test_RecurrentGradientMachine.cpp 4.9 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.
Z
zhangjinchao01 已提交
2 3 4 5 6 7 8 9 10 11 12 13 14 15

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. */

#include <gtest/gtest.h>
16
#include <paddle/gserver/gradientmachines/GradientMachine.h>
Z
zhangjinchao01 已提交
17 18
#include <paddle/trainer/Trainer.h>
#include <paddle/trainer/TrainerInternal.h>
19 20 21
#include <paddle/utils/PythonUtil.h>
#include <paddle/utils/Util.h>
#include <paddle/utils/Version.h>
Z
zhangjinchao01 已提交
22

23
DECLARE_int32(seed);
24

Z
zhangjinchao01 已提交
25
using namespace paddle;  // NOLINT
26
using namespace std;     // NOLINT
Z
zhangjinchao01 已提交
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
class TrainerForTest : public paddle::Trainer {
public:
  void startTrain() {
    GradientMachine& gm = *this->trainerInternal_.getGradientMachine();
    gm.start(this->getConfig(), dataProvider_);
  }

  void finishTrain() {
    GradientMachine& gm = *this->trainerInternal_.getGradientMachine();
    gm.finish();
  }

  /**
   * Get total dimension of all parameters.
   *
   * @return the total dimension of all parameters
   */
  size_t getTotalParameterSize() const {
    auto p = const_cast<TrainerForTest*>(this);
46 47
    auto& params = p->getGradientMachine()->getParameters();
    return std::accumulate(
48 49 50
        params.begin(), params.end(), 0UL, [](size_t a, const ParameterPtr& p) {
          return a + p->getSize();
        });
Z
zhangjinchao01 已提交
51 52 53
  }
};

54 55 56
void CalCost(const string& conf,
             const string& dir,
             real* cost,
Z
zhangjinchao01 已提交
57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
             int num_passes) {
  auto config = std::make_shared<TrainerConfigHelper>(conf);
  TrainerForTest trainer;
  trainer.init(config);
  mkDir(dir.c_str());
  config->setSaveDir(dir);
  auto dataProvider = trainer.getDataProvider();
  int32_t batchSize = config->getOptConfig().batch_size();
  real learningRate = config->getOptConfig().learning_rate();
  real momentum = 0;
  real decayRate = 0;
  int64_t dim = trainer.getTotalParameterSize();
  CpuVector vecW(dim);
  CpuVector vecGradient(dim);
  CpuVector vecMomentum(dim);

  // vecW needs to be assigned, otherwise the variable is an uncertain value.
74 75 76

  *ThreadLocalRand::getSeed() = FLAGS_seed;
  vecW.randnorm(0, 0.1);
77
  vecMomentum.randnorm(0, 0.1);
Z
zhangjinchao01 已提交
78 79 80 81 82 83 84 85 86 87

  trainer.startTrain();
  for (int i = 0; i < num_passes; ++i) {
    real totalCost = 0;
    dataProvider->reset();
    while (true) {
      DataBatch dataBatch;
      int num = dataProvider->getNextBatch(batchSize, &dataBatch);
      if (num == 0) break;
      totalCost += trainer.calcGradient(dataBatch, vecW, vecGradient);
88 89
      sgdUpdate(
          learningRate, momentum, decayRate, &vecW, &vecGradient, &vecMomentum);
Z
zhangjinchao01 已提交
90 91 92 93 94 95 96
    }
    cost[i] = totalCost;
  }
  trainer.finishTrain();
  rmDir(dir.c_str());
}

97 98 99 100 101
void test(const string& conf1, const string& conf2, double eps, bool useGpu) {
  if (!paddle::version::isWithGpu() && useGpu) {
    return;
  }
  FLAGS_use_gpu = useGpu;
Z
zhangjinchao01 已提交
102 103 104 105 106 107 108 109 110 111 112
  int num_passes = 5;
  real* cost1 = new real[num_passes];
  const string dir1 = "gserver/tests/t1";
  CalCost(conf1, dir1, cost1, num_passes);

  real* cost2 = new real[num_passes];
  const string dir2 = "gserver/tests/t2";
  CalCost(conf2, dir2, cost2, num_passes);

  for (int i = 0; i < num_passes; i++) {
    LOG(INFO) << "num_passes: " << i << ", cost1=" << cost1[i]
113 114 115
              << ", cost2=" << cost2[i]
              << ", diff=" << std::abs(cost1[i] - cost2[i]);
    ASSERT_NEAR(cost1[i], cost2[i], eps);
Z
zhangjinchao01 已提交
116 117 118 119 120
  }
  delete[] cost1;
  delete[] cost2;
}

121
TEST(RecurrentGradientMachine, HasSubSequence) {
122 123 124
  for (bool useGpu : {false, true}) {
    test("gserver/tests/sequence_layer_group.conf",
         "gserver/tests/sequence_nest_layer_group.conf",
125 126
         1e-5,
         useGpu);
127
  }
128 129
}

Y
Yu Yang 已提交
130
TEST(RecurrentGradientMachine, DISABLED_rnn) {
131 132 133
  for (bool useGpu : {false, true}) {
    test("gserver/tests/sequence_rnn.conf",
         "gserver/tests/sequence_nest_rnn.conf",
134 135
         1e-6,
         useGpu);
136
  }
137 138
}

Y
Yu Yang 已提交
139
TEST(RecurrentGradientMachine, DISABLED_rnn_multi_input) {
140 141 142
  for (bool useGpu : {false, true}) {
    test("gserver/tests/sequence_rnn_multi_input.conf",
         "gserver/tests/sequence_nest_rnn_multi_input.conf",
143 144
         1e-6,
         useGpu);
145 146
  }
}
147

Y
Yu Yang 已提交
148
TEST(RecurrentGradientMachine, DISABLED_rnn_multi_unequalength_input) {
149
  for (bool useGpu : {false, true}) {
150 151
    test("gserver/tests/sequence_rnn_multi_unequalength_inputs.py",
         "gserver/tests/sequence_nest_rnn_multi_unequalength_inputs.py",
152 153 154
         1e-6,
         useGpu);
  }
155 156
}

Z
zhangjinchao01 已提交
157
int main(int argc, char** argv) {
Y
Yu Yang 已提交
158 159
  testing::InitGoogleTest(&argc, argv);

Z
zhangjinchao01 已提交
160 161 162 163 164 165 166 167 168 169 170
  if (paddle::version::isWithPyDataProvider()) {
    if (!paddle::version::isWithGpu()) {
      FLAGS_use_gpu = false;
    }
    initMain(argc, argv);
    initPython(argc, argv);
    return RUN_ALL_TESTS();
  } else {
    return 0;
  }
}