net_op_test.cc 3.3 KB
Newer Older
D
dzhwinter 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13
//  Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserve.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
14 15
#include "paddle/operators/net_op.h"

16
#include <gtest/gtest.h>
17

D
dongzhihong 已提交
18
namespace paddle {
19
namespace operators {
D
dongzhihong 已提交
20 21
using Scope = framework::Scope;
using DeviceContext = platform::DeviceContext;
22 23 24

static int run_cnt = 0;

D
dongzhihong 已提交
25
class TestOp : public framework::OperatorBase {
26
 public:
27
  using framework::OperatorBase::OperatorBase;
28
  DEFINE_OP_CLONE_METHOD(TestOp);
29
  void Run(const Scope& scope, const platform::Place& place) const override {
30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
    ++run_cnt;
  }
};

template <typename T>
void AssertSameVectorWithoutOrder(const std::vector<T>& expected,
                                  const std::vector<T>& actual) {
  ASSERT_EQ(expected.size(), actual.size());
  std::unordered_set<T> expected_set;
  for (auto& tmp : expected) {
    expected_set.insert(tmp);
  }
  for (auto& act : actual) {
    ASSERT_NE(expected_set.end(), expected_set.find(act));
  }
}

TEST(OpKernel, all) {
Y
Yu Yang 已提交
48
  auto net = std::make_shared<NetOp>();
D
dongzhihong 已提交
49 50
  ASSERT_NE(net, nullptr);

51
  net->AppendOp(std::unique_ptr<TestOp>(
52
      new TestOp("test", {{"X", {"x"}}, {"W", {"w1"}}, {"b", {"b1"}}},
Y
Yiqun Liu 已提交
53
                 {{"Out", {"y"}}}, framework::AttributeMap{})));
54
  net->AppendOp(std::unique_ptr<TestOp>(
55
      new TestOp("test", {{"X", {"y"}}, {"W", {"w2"}}, {"b", {"b2"}}},
Y
Yiqun Liu 已提交
56
                 {{"Out", {"z"}}}, framework::AttributeMap{})));
D
dongzhihong 已提交
57 58

  net->CompleteAddOp();
Y
Yu Yang 已提交
59
  AssertSameVectorWithoutOrder({"x", "w1", "b1", "w2", "b2"},
60 61
                               net->Inputs(NetOp::kAll));
  AssertSameVectorWithoutOrder({"y", "z"}, net->Outputs(NetOp::kAll));
D
dongzhihong 已提交
62

63
  auto final_outs = net->OutputVars(false);
D
dongzhihong 已提交
64

65 66
  ASSERT_EQ(final_outs.size(), 1UL);
  ASSERT_EQ(final_outs[0], "z");
D
dongzhihong 已提交
67 68
}

69
TEST(NetOp, insert_op) {
Y
Yu Yang 已提交
70
  NetOp net;
71
  auto op1 = std::unique_ptr<framework::NOP>(
F
fengjiayi 已提交
72
      new framework::NOP("empty", {{"X", {"x"}}, {"W", {"w1"}}, {"b", {"b1"}}},
Y
Yiqun Liu 已提交
73
                         {{"Out", {"y"}}}, framework::AttributeMap{}));
74
  net.AppendOp(*op1);
75
  net.InsertOp(0, *op1);
Y
Yu Yang 已提交
76
  ASSERT_EQ(2UL, net.ops_.size());
77
  net.InsertOp(2, std::move(op1));
Y
Yu Yang 已提交
78 79
  ASSERT_EQ(3UL, net.ops_.size());
}
80

81 82
TEST(NetOp, Clone) {
  NetOp net;
Y
Yiqun Liu 已提交
83 84 85 86 87 88
  net.AppendOp(std::unique_ptr<framework::NOP>(new framework::NOP{
      "empty", framework::VariableNameMap{}, framework::VariableNameMap{},
      framework::AttributeMap{}}));
  net.AppendOp(std::unique_ptr<framework::NOP>(new framework::NOP{
      "empty2", framework::VariableNameMap{}, framework::VariableNameMap{},
      framework::AttributeMap{}}));
89
  net.CompleteAddOp(true);
90
  auto new_net_op = net.Clone();
91 92
  ASSERT_NE(new_net_op, nullptr);
  ASSERT_TRUE(new_net_op->IsNetOp());
93
  auto* new_net = static_cast<NetOp*>(new_net_op.get());
94
  ASSERT_EQ(2UL, new_net->ops_.size());
95 96 97 98
  ASSERT_EQ(new_net->ops_[0]->Type(), "empty");
  ASSERT_EQ(new_net->ops_[1]->Type(), "empty2");
}

99
}  // namespace operators
D
dongzhihong 已提交
100
}  // namespace paddle
反馈
建议
客服 返回
顶部