From ec613d90001cb5bd571879d262c00216b96b2ff9 Mon Sep 17 00:00:00 2001 From: zhhsplendid Date: Tue, 22 Sep 2020 07:45:19 +0000 Subject: [PATCH] Split PR, test=develop --- .../simnet_dygraph_model_v2.py | 504 ------------------ .../dygraph_to_static/test_ptb_lm_v2.py | 314 ----------- .../dygraph_to_static/test_simnet_v2.py | 168 ------ 3 files changed, 986 deletions(-) delete mode 100644 python/paddle/fluid/tests/unittests/dygraph_to_static/simnet_dygraph_model_v2.py delete mode 100644 python/paddle/fluid/tests/unittests/dygraph_to_static/test_ptb_lm_v2.py delete mode 100644 python/paddle/fluid/tests/unittests/dygraph_to_static/test_simnet_v2.py diff --git a/python/paddle/fluid/tests/unittests/dygraph_to_static/simnet_dygraph_model_v2.py b/python/paddle/fluid/tests/unittests/dygraph_to_static/simnet_dygraph_model_v2.py deleted file mode 100644 index 3fa01d02ae2..00000000000 --- a/python/paddle/fluid/tests/unittests/dygraph_to_static/simnet_dygraph_model_v2.py +++ /dev/null @@ -1,504 +0,0 @@ -# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. -# -# 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. - -from functools import reduce -import paddle - - -class EmbeddingLayer(object): - """ - Embedding Layer class - """ - - def __init__(self, dict_size, emb_dim, name="emb", padding_idx=None): - """ - initialize - """ - self.dict_size = dict_size - self.emb_dim = emb_dim - self.name = name - self.padding_idx = padding_idx - - def ops(self): - """ - operation - """ - # TODO(huihuangzheng): The original code set the is_sparse=True, but it - # causes crush in dy2stat. Set it to True after fixing it. - emb = paddle.fluid.dygraph.Embedding( - size=[self.dict_size, self.emb_dim], - is_sparse=True, - padding_idx=self.padding_idx, - param_attr=paddle.ParamAttr( - name=self.name, initializer=paddle.nn.initializer.Xavier())) - - return emb - - -class FCLayer(object): - """ - Fully Connect Layer class - """ - - def __init__(self, fc_dim, act, name="fc"): - """ - initialize - """ - self.fc_dim = fc_dim - self.act = act - self.name = name - - def ops(self): - """ - operation - """ - fc = FC(size=self.fc_dim, - param_attr=paddle.ParamAttr(name="%s.w" % self.name), - bias_attr=paddle.ParamAttr(name="%s.b" % self.name), - act=self.act) - return fc - - -class ConcatLayer(object): - """ - Connection Layer class - """ - - def __init__(self, axis): - """ - initialize - """ - self.axis = axis - - def ops(self, inputs): - """ - operation - """ - concat = paddle.concat(x=inputs, axis=self.axis) - return concat - - -class ReduceMeanLayer(object): - """ - Reduce Mean Layer class - """ - - def __init__(self): - """ - initialize - """ - pass - - def ops(self, input): - """ - operation - """ - mean = paddle.reduce_mean(input) - return mean - - -class CosSimLayer(object): - """ - Cos Similarly Calculate Layer - """ - - def __init__(self): - """ - initialize - """ - pass - - def ops(self, x, y): - """ - operation - """ - sim = paddle.metric.cos_sim(x, y) - return sim - - -class ElementwiseMaxLayer(object): - """ - Elementwise Max Layer class - """ - - def __init__(self): - """ - initialize - """ - pass - - def ops(self, x, y): - """ - operation - """ - max = paddle.maximum(x=x, y=y) - return max - - -class ElementwiseAddLayer(object): - """ - Elementwise Add Layer class - """ - - def __init__(self): - """ - initialize - """ - pass - - def ops(self, x, y): - """ - operation - """ - add = paddle.add(x=x, y=y) - return add - - -class ElementwiseSubLayer(object): - """ - Elementwise Add Layer class - """ - - def __init__(self): - """ - initialize - """ - pass - - def ops(self, x, y): - """ - operation - """ - sub = paddle.fluid.layers.elementwise_sub(x, y) - return sub - - -class ConstantLayer(object): - """ - Generate A Constant Layer class - """ - - def __init__(self): - """ - initialize - """ - pass - - def ops(self, input, shape, dtype, value): - """ - operation - """ - shape = list(shape) - input_shape = paddle.shape(input) - shape[0] = input_shape[0] - constant = paddle.fill_constant(shape, dtype, value) - return constant - - -class SoftsignLayer(object): - """ - Softsign Layer class - """ - - def __init__(self): - """ - initialize - """ - pass - - def ops(self, input): - """ - operation - """ - softsign = paddle.nn.functional.softsign(input) - return softsign - - -class FC(paddle.nn.Layer): - """ - This interface is used to construct a callable object of the ``FC`` class. - For more details, refer to code examples. - It creates a fully connected layer in the network. It can take - one or multiple ``Tensor`` as its inputs. It creates a Variable called weights for each input tensor, - which represents a fully connected weight matrix from each input unit to - each output unit. The fully connected layer multiplies each input tensor - with its corresponding weight to produce an output Tensor with shape [N, `size`], - where N is batch size. If multiple input tensors are given, the results of - multiple output tensors with shape [N, `size`] will be summed up. If ``bias_attr`` - is not None, a bias variable will be created and added to the output. - Finally, if ``act`` is not None, it will be applied to the output as well. - When the input is single ``Tensor`` : - .. math:: - Out = Act({XW + b}) - When the input are multiple ``Tensor`` : - .. math:: - Out = Act({\sum_{i=0}^{N-1}X_iW_i + b}) - In the above equation: - * :math:`N`: Number of the input. N equals to len(input) if input is list of ``Tensor`` . - * :math:`X_i`: The i-th input ``Tensor`` . - * :math:`W_i`: The i-th weights matrix corresponding i-th input tensor. - * :math:`b`: The bias parameter created by this layer (if needed). - * :math:`Act`: The activation function. - * :math:`Out`: The output ``Tensor`` . - See below for an example. - .. code-block:: text - Given: - data_1.data = [[[0.1, 0.2]]] - data_1.shape = (1, 1, 2) # 1 is batch_size - data_2.data = [[[0.1, 0.2, 0.3]]] - data_2.shape = (1, 1, 3) # 1 is batch_size - fc = FC("fc", 2, num_flatten_dims=2) - out = fc(input=[data_1, data_2]) - Then: - out.data = [[[0.182996 -0.474117]]] - out.shape = (1, 1, 2) - Parameters: - - size(int): The number of output units in this layer. - num_flatten_dims (int, optional): The fc layer can accept an input tensor with more than - two dimensions. If this happens, the multi-dimension tensor will first be flattened - into a 2-dimensional matrix. The parameter `num_flatten_dims` determines how the input - tensor is flattened: the first `num_flatten_dims` (inclusive, index starts from 1) - dimensions will be flatten to form the first dimension of the final matrix (height of - the matrix), and the rest `rank(X) - num_flatten_dims` dimensions are flattened to - form the second dimension of the final matrix (width of the matrix). For example, suppose - `X` is a 5-dimensional tensor with a shape [2, 3, 4, 5, 6], and `num_flatten_dims` = 3. - Then, the flattened matrix will have a shape [2 x 3 x 4, 5 x 6] = [24, 30]. Default: 1 - param_attr (ParamAttr or list of ParamAttr, optional): The parameter attribute for learnable - weights(Parameter) of this layer. Default: None. - bias_attr (ParamAttr or list of ParamAttr, optional): The attribute for the bias - of this layer. If it is set to False, no bias will be added to the output units. - If it is set to None, the bias is initialized zero. Default: None. - act (str, optional): Activation to be applied to the output of this layer. Default: None. - is_test(bool, optional): A flag indicating whether execution is in test phase. Default: False. - dtype(str, optional): Dtype used for weight, it can be "float32" or "float64". Default: "float32". - Attribute: - **weight** (list of Parameter): the learnable weights of this layer. - **bias** (Parameter or None): the learnable bias of this layer. - Returns: - None - - Examples: - .. code-block:: python - from paddle.fluid.dygraph.base import to_variable - import paddle.fluid as fluid - from paddle.fluid.dygraph import FC - import numpy as np - data = np.random.uniform(-1, 1, [30, 10, 32]).astype('float32') - with fluid.dygraph.guard(): - fc = FC("fc", 64, num_flatten_dims=2) - data = to_variable(data) - conv = fc(data) - """ - - def __init__(self, - size, - num_flatten_dims=1, - param_attr=None, - bias_attr=None, - act=None, - is_test=False, - dtype="float32"): - super(FC, self).__init__(dtype) - - self._size = size - self._num_flatten_dims = num_flatten_dims - self._dtype = dtype - self._param_attr = param_attr - self._bias_attr = bias_attr - self._act = act - self.__w = list() - - def _build_once(self, input): - i = 0 - for inp, param in self._helper.iter_inputs_and_params(input, - self._param_attr): - input_shape = inp.shape - - param_shape = [ - reduce(lambda a, b: a * b, input_shape[self._num_flatten_dims:], - 1) - ] + [self._size] - self.__w.append( - self.add_parameter( - '_w%d' % i, - self.create_parameter( - attr=param, - shape=param_shape, - dtype=self._dtype, - is_bias=False))) - i += 1 - - size = list([self._size]) - self._b = self.create_parameter( - attr=self._bias_attr, shape=size, dtype=self._dtype, is_bias=True) - - # TODO(songyouwei): We should remove _w property - @property - def _w(self, i=0): - return self.__w[i] - - @_w.setter - def _w(self, value, i=0): - assert isinstance(self.__w[i], Variable) - self.__w[i].set_value(value) - - @property - def weight(self): - if len(self.__w) > 1: - return self.__w - else: - return self.__w[0] - - @weight.setter - def weight(self, value): - if len(self.__w) == 1: - self.__w[0] = value - - @property - def bias(self): - return self._b - - @bias.setter - def bias(self, value): - self._b = value - - def forward(self, input): - mul_results = list() - i = 0 - for inp, param in self._helper.iter_inputs_and_params(input, - self._param_attr): - tmp = self._helper.create_variable_for_type_inference(self._dtype) - self._helper.append_op( - type="mul", - inputs={"X": inp, - "Y": self.__w[i]}, - outputs={"Out": tmp}, - attrs={ - "x_num_col_dims": self._num_flatten_dims, - "y_num_col_dims": 1 - }) - i += 1 - mul_results.append(tmp) - - if len(mul_results) == 1: - pre_bias = mul_results[0] - else: - pre_bias = self._helper.create_variable_for_type_inference( - self._dtype) - self._helper.append_op( - type="sum", - inputs={"X": mul_results}, - outputs={"Out": pre_bias}, - attrs={"use_mkldnn": False}) - - if self._b is not None: - pre_activation = self._helper.create_variable_for_type_inference( - dtype=self._dtype) - self._helper.append_op( - type='elementwise_add', - inputs={'X': [pre_bias], - 'Y': [self._b]}, - outputs={'Out': [pre_activation]}, - attrs={'axis': self._num_flatten_dims}) - else: - pre_activation = pre_bias - # Currently, we don't support inplace in dygraph mode - return self._helper.append_activation(pre_activation, act=self._act) - - -class HingeLoss(object): - """ - Hing Loss Calculate class - """ - - def __init__(self, conf_dict): - """ - initialize - """ - self.margin = conf_dict["loss"]["margin"] - - def compute(self, pos, neg): - """ - compute loss - """ - elementwise_max = ElementwiseMaxLayer() - elementwise_add = ElementwiseAddLayer() - elementwise_sub = ElementwiseSubLayer() - constant = ConstantLayer() - reduce_mean = ReduceMeanLayer() - loss = reduce_mean.ops( - elementwise_max.ops( - constant.ops(neg, neg.shape, "float32", 0.0), - elementwise_add.ops( - elementwise_sub.ops(neg, pos), - constant.ops(neg, neg.shape, "float32", self.margin)))) - return loss - - -class BOW(paddle.nn.Layer): - """ - BOW - """ - - def __init__(self, conf_dict): - """ - initialize - """ - super(BOW, self).__init__() - self.dict_size = conf_dict["dict_size"] - self.task_mode = conf_dict["task_mode"] - self.emb_dim = conf_dict["net"]["emb_dim"] - self.bow_dim = conf_dict["net"]["bow_dim"] - self.seq_len = conf_dict["seq_len"] - self.emb_layer = EmbeddingLayer(self.dict_size, self.emb_dim, - "emb").ops() - self.bow_layer = paddle.nn.Linear( - in_features=self.bow_dim, out_features=self.bow_dim) - self.bow_layer_po = FCLayer(self.bow_dim, None, "fc").ops() - self.softmax_layer = FCLayer(2, "softmax", "cos_sim").ops() - - @paddle.fluid.dygraph.declarative - def forward(self, left, right): - """ - Forward network - """ - - # embedding layer - left_emb = self.emb_layer(left) - right_emb = self.emb_layer(right) - left_emb = paddle.fluid.layers.reshape( - left_emb, shape=[-1, self.seq_len, self.bow_dim]) - right_emb = paddle.fluid.layers.reshape( - right_emb, shape=[-1, self.seq_len, self.bow_dim]) - - bow_left = paddle.reduce_sum(left_emb, dim=1) - bow_right = paddle.reduce_sum(right_emb, dim=1) - softsign_layer = SoftsignLayer() - left_soft = softsign_layer.ops(bow_left) - right_soft = softsign_layer.ops(bow_right) - - # matching layer - if self.task_mode == "pairwise": - left_bow = self.bow_layer(left_soft) - right_bow = self.bow_layer(right_soft) - cos_sim_layer = CosSimLayer() - pred = cos_sim_layer.ops(left_bow, right_bow) - return left_bow, pred - else: - concat_layer = ConcatLayer(1) - concat = concat_layer.ops([left_soft, right_soft]) - concat_fc = self.bow_layer_po(concat) - pred = self.softmax_layer(concat_fc) - return left_soft, pred diff --git a/python/paddle/fluid/tests/unittests/dygraph_to_static/test_ptb_lm_v2.py b/python/paddle/fluid/tests/unittests/dygraph_to_static/test_ptb_lm_v2.py deleted file mode 100644 index c08106b9be3..00000000000 --- a/python/paddle/fluid/tests/unittests/dygraph_to_static/test_ptb_lm_v2.py +++ /dev/null @@ -1,314 +0,0 @@ -# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. -# -# 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. - -from __future__ import absolute_import, division, print_function - -import logging -import time -import unittest - -import numpy as np -import paddle - -PRINT_STEP = 20 -SEED = 2020 - -program_translator = paddle.fluid.dygraph.dygraph_to_static.ProgramTranslator() - - -class SimpleLSTMRNN(paddle.fluid.Layer): - def __init__(self, - hidden_size, - num_steps, - num_layers=2, - init_scale=0.1, - dropout=None): - super(SimpleLSTMRNN, self).__init__() - self._hidden_size = hidden_size - self._num_layers = num_layers - self._init_scale = init_scale - self._dropout = dropout - self._num_steps = num_steps - self.cell_array = [] - self.hidden_array = [] - - self.weight_1_arr = [] - self.weight_2_arr = [] - self.bias_arr = [] - self.mask_array = [] - - for i in range(self._num_layers): - weight_1 = self.create_parameter( - attr=paddle.ParamAttr(initializer=paddle.nn.initializer.Uniform( - low=-self._init_scale, high=self._init_scale)), - shape=[self._hidden_size * 2, self._hidden_size * 4], - dtype="float32", - default_initializer=paddle.nn.initializer.Uniform( - low=-self._init_scale, high=self._init_scale)) - self.weight_1_arr.append(self.add_parameter('w_%d' % i, weight_1)) - bias_1 = self.create_parameter( - attr=paddle.ParamAttr(initializer=paddle.nn.initializer.Uniform( - low=-self._init_scale, high=self._init_scale)), - shape=[self._hidden_size * 4], - dtype="float32", - default_initializer=paddle.nn.initializer.Constant(0.0)) - self.bias_arr.append(self.add_parameter('b_%d' % i, bias_1)) - - def forward(self, input_embedding, init_hidden=None, init_cell=None): - cell_array = [] - hidden_array = [] - - for i in range(self._num_layers): - hidden_array.append(init_hidden[i]) - cell_array.append(init_cell[i]) - - res = [] - for index in range(self._num_steps): - step_input = input_embedding[:, index, :] - for k in range(self._num_layers): - pre_hidden = hidden_array[k] - pre_cell = cell_array[k] - weight_1 = self.weight_1_arr[k] - bias = self.bias_arr[k] - - nn = paddle.concat(x=[step_input, pre_hidden], axis=1) - gate_input = paddle.matmul(x=nn, y=weight_1) - - gate_input = paddle.add(x=gate_input, y=bias) - i, j, f, o = paddle.split( - x=gate_input, num_or_sections=4, axis=-1) - c = pre_cell * paddle.nn.functional.sigmoid( - f) + paddle.nn.functional.sigmoid(i) * paddle.tanh(j) - m = paddle.tanh(c) * paddle.nn.functional.sigmoid(o) - hidden_array[k] = m - cell_array[k] = c - step_input = m - - if self._dropout is not None and self._dropout > 0.0: - step_input = paddle.fluid.layers.dropout( - step_input, - dropout_prob=self._dropout, - dropout_implementation='upscale_in_train') - res.append(step_input) - real_res = paddle.concat(x=res, axis=1) - real_res = paddle.fluid.layers.reshape( - real_res, [-1, self._num_steps, self._hidden_size]) - last_hidden = paddle.concat(x=hidden_array, axis=1) - last_hidden = paddle.fluid.layers.reshape( - last_hidden, shape=[-1, self._num_layers, self._hidden_size]) - last_hidden = paddle.transpose(x=last_hidden, perm=[1, 0, 2]) - last_cell = paddle.concat(x=cell_array, axis=1) - last_cell = paddle.fluid.layers.reshape( - last_cell, shape=[-1, self._num_layers, self._hidden_size]) - last_cell = paddle.transpose(x=last_cell, perm=[1, 0, 2]) - return real_res, last_hidden, last_cell - - -class PtbModel(paddle.fluid.Layer): - def __init__(self, - hidden_size, - vocab_size, - num_layers=2, - num_steps=20, - init_scale=0.1, - dropout=None): - super(PtbModel, self).__init__() - self.hidden_size = hidden_size - self.vocab_size = vocab_size - self.init_scale = init_scale - self.num_layers = num_layers - self.num_steps = num_steps - self.dropout = dropout - self.simple_lstm_rnn = SimpleLSTMRNN( - hidden_size, - num_steps, - num_layers=num_layers, - init_scale=init_scale, - dropout=dropout) - self.embedding = paddle.fluid.dygraph.nn.Embedding( - size=[vocab_size, hidden_size], - dtype='float32', - is_sparse=False, - param_attr=paddle.ParamAttr( - name='embedding_para', - initializer=paddle.nn.initializer.Uniform( - low=-init_scale, high=init_scale))) - self.softmax_weight = self.create_parameter( - attr=paddle.ParamAttr(), - shape=[self.hidden_size, self.vocab_size], - dtype="float32", - default_initializer=paddle.nn.initializer.Uniform( - low=-self.init_scale, high=self.init_scale)) - self.softmax_bias = self.create_parameter( - attr=paddle.ParamAttr(), - shape=[self.vocab_size], - dtype="float32", - default_initializer=paddle.nn.initializer.Uniform( - low=-self.init_scale, high=self.init_scale)) - - def build_once(self, input, label, init_hidden, init_cell): - pass - - @paddle.fluid.dygraph.jit.declarative - def forward(self, input, label, init_hidden, init_cell): - - init_h = paddle.fluid.layers.reshape( - init_hidden, shape=[self.num_layers, -1, self.hidden_size]) - - init_c = paddle.fluid.layers.reshape( - init_cell, shape=[self.num_layers, -1, self.hidden_size]) - - x_emb = self.embedding(input) - - x_emb = paddle.fluid.layers.reshape( - x_emb, shape=[-1, self.num_steps, self.hidden_size]) - if self.dropout is not None and self.dropout > 0.0: - x_emb = paddle.fluid.layers.dropout( - x_emb, - dropout_prob=self.dropout, - dropout_implementation='upscale_in_train') - rnn_out, last_hidden, last_cell = self.simple_lstm_rnn(x_emb, init_h, - init_c) - - projection = paddle.matmul(x=rnn_out, y=self.softmax_weight) - projection = paddle.add(x=projection, y=self.softmax_bias) - - loss = paddle.nn.functional.softmax_with_cross_entropy( - logits=projection, label=label, soft_label=False) - loss = paddle.fluid.layers.reshape(loss, shape=[-1, self.num_steps]) - loss = paddle.reduce_mean(loss, dim=[0]) - loss = paddle.reduce_sum(loss) - - return loss, last_hidden, last_cell - - def debug_emb(self): - - np.save("emb_grad", self.x_emb.gradient()) - - -def train(place): - - num_layers = 1 - batch_size = 4 - hidden_size = 10 - num_steps = 3 - init_scale = 0.1 - max_epoch = 1 - dropout = 0.0 - vocab_size = 1000 - batch_num = 200 - - paddle.disable_static(place) - paddle.manual_seed(SEED) - paddle.framework.random._manual_program_seed(SEED) - ptb_model = PtbModel( - hidden_size=hidden_size, - vocab_size=vocab_size, - num_layers=num_layers, - num_steps=num_steps, - init_scale=init_scale, - dropout=dropout) - - sgd = paddle.optimizer.SGD(learning_rate=1e-3, - parameters=ptb_model.parameters()) - - for epoch_id in range(max_epoch): - - total_loss = 0.0 - iters = 0.0 - total_sample = 0 - - init_hidden_data = np.zeros( - (num_layers, batch_size, hidden_size), dtype='float32') - init_cell_data = np.zeros( - (num_layers, batch_size, hidden_size), dtype='float32') - - init_hidden = paddle.to_tensor( - data=init_hidden_data, dtype=None, place=None, stop_gradient=True) - init_cell = paddle.to_tensor( - data=init_cell_data, dtype=None, place=None, stop_gradient=True) - for step_id in range(batch_num): - x_data = np.arange(12).reshape(4, 3).astype('int64') - y_data = np.arange(1, 13).reshape(4, 3).astype('int64') - y_data = y_data.reshape((-1, 1)) - - x_data = x_data.reshape((-1, num_steps, 1)) - y_data = y_data.reshape((-1, num_steps, 1)) - - x = paddle.to_tensor( - data=x_data, dtype=None, place=None, stop_gradient=True) - y = paddle.to_tensor( - data=y_data, dtype=None, place=None, stop_gradient=True) - - dy_loss, last_hidden, last_cell = ptb_model(x, y, init_hidden, - init_cell) - out_loss = dy_loss.numpy() - - dy_loss.backward() - sgd.minimize(dy_loss) - ptb_model.clear_gradients() - - total_loss += out_loss - iters += num_steps - total_sample += 1 - if step_id % PRINT_STEP == 0: - if step_id == 0: - logging.info("epoch %d | step %d, loss %0.3f" % - (epoch_id, step_id, total_loss / total_sample)) - avg_batch_time = time.time() - else: - speed = PRINT_STEP / (time.time() - avg_batch_time) - logging.info( - "epoch %d | step %d, loss %0.3f, speed %.3f steps/s" % - (epoch_id, step_id, total_loss / total_sample, speed)) - avg_batch_time = time.time() - - ret = out_loss, last_hidden.numpy(), last_cell.numpy() - paddle.enable_static() - return ret - - -def train_dygraph(place): - program_translator.enable(False) - return train(place) - - -def train_static(place): - program_translator.enable(True) - return train(place) - - -class TestPtb(unittest.TestCase): - def setUp(self): - self.place = paddle.CUDAPlace(0) if paddle.fluid.is_compiled_with_cuda() \ - else paddle.CPUPlace() - - def test_check_result(self): - loss_1, hidden_1, cell_1 = train_static(self.place) - loss_2, hidden_2, cell_2 = train_dygraph(self.place) - - self.assertTrue( - np.allclose(loss_1, loss_2), - msg="static loss: {} \ndygraph loss: {}".format(loss_1, loss_2)) - self.assertTrue( - np.allclose(hidden_1, hidden_2), - msg="static hidden: {} \ndygraph acc1: {}".format(hidden_1, - hidden_2)) - self.assertTrue( - np.allclose(cell_1, cell_2), - msg="static cell: {} \ndygraph cell: {}".format(cell_1, cell_2)) - - -if __name__ == '__main__': - unittest.main() diff --git a/python/paddle/fluid/tests/unittests/dygraph_to_static/test_simnet_v2.py b/python/paddle/fluid/tests/unittests/dygraph_to_static/test_simnet_v2.py deleted file mode 100644 index 8ba4d1a2fb3..00000000000 --- a/python/paddle/fluid/tests/unittests/dygraph_to_static/test_simnet_v2.py +++ /dev/null @@ -1,168 +0,0 @@ -# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. -# -# 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. - -import argparse -import numpy as np -import paddle -import random -import unittest - -from simnet_dygraph_model_v2 import BOW, HingeLoss - -SEED = 102 -random.seed(SEED) - - -def create_conf_dict(): - conf_dict = {} - conf_dict["task_mode"] = "pairwise" - conf_dict["net"] = {"emb_dim": 128, "bow_dim": 128, "hidden_dim": 128} - conf_dict["loss"] = {"margin": 0.1} - return conf_dict - - -def parse_args(): - parser = argparse.ArgumentParser() - parser.add_argument( - "--batch_size", - type=int, - default=32, - help="Total examples' number in batch for training.") - parser.add_argument( - "--seq_len", type=int, default=32, help="The length of each sentence.") - parser.add_argument( - "--epoch", type=int, default=1, help="The number of training epoch.") - parser.add_argument( - "--fake_sample_size", - type=int, - default=128, - help="The number of samples of fake data.") - args = parser.parse_args([]) - return args - - -args = parse_args() - - -def fake_vocabulary(): - vocab = {} - vocab[""] = 0 - for i in range(26): - c = chr(ord('a') + i) - vocab[c] = i + 1 - return vocab - - -vocab = fake_vocabulary() - - -class FakeReaderProcessor(object): - def __init__(self, args, vocab): - self.vocab = vocab - self.seq_len = args.seq_len - self.sample_size = args.fake_sample_size - self.data_samples = [] - for i in range(self.sample_size): - query = [random.randint(0, 26) for i in range(self.seq_len)] - pos_title = query[:] - neg_title = [26 - q for q in query] - self.data_samples.append( - np.array([query, pos_title, neg_title]).astype(np.int64)) - - def get_reader(self, mode, epoch=0): - def reader_with_pairwise(): - if mode == "train": - for i in range(self.sample_size): - yield self.data_samples[i] - - return reader_with_pairwise - - -simnet_process = FakeReaderProcessor(args, vocab) - - -def train(conf_dict, to_static): - """ - train process - """ - program_translator = paddle.jit.ProgramTranslator() - program_translator.enable(to_static) - - # Get device - if paddle.fluid.is_compiled_with_cuda(): - place = paddle.CUDAPlace(0) - else: - place = paddle.CPUPlace() - - paddle.disable_static(place) - paddle.manual_seed(SEED) - paddle.framework.random._manual_program_seed(SEED) - - conf_dict['dict_size'] = len(vocab) - conf_dict['seq_len'] = args.seq_len - - net = BOW(conf_dict) - loss = HingeLoss(conf_dict) - optimizer = paddle.optimizer.Adam( - learning_rate=0.001, - beta1=0.9, - beta2=0.999, - epsilon=1e-08, - parameters=net.parameters()) - - metric = paddle.fluid.metrics.Auc(name="auc") - - global_step = 0 - losses = [] - - train_loader = paddle.io.DataLoader.from_generator( - capacity=16, return_list=True, iterable=True, use_double_buffer=True) - get_train_examples = simnet_process.get_reader("train", epoch=args.epoch) - train_loader.set_sample_list_generator( - paddle.batch( - get_train_examples, batch_size=args.batch_size), place) - - for left, pos_right, neg_right in train_loader(): - left = paddle.fluid.layers.reshape(left, shape=[-1, 1]) - pos_right = paddle.fluid.layers.reshape(pos_right, shape=[-1, 1]) - neg_right = paddle.fluid.layers.reshape(neg_right, shape=[-1, 1]) - net.train() - global_step += 1 - left_feat, pos_score = net(left, pos_right) - pred = pos_score - _, neg_score = net(left, neg_right) - avg_cost = loss.compute(pos_score, neg_score) - losses.append(np.mean(avg_cost.numpy())) - avg_cost.backward() - optimizer.minimize(avg_cost) - net.clear_gradients() - paddle.enable_static() - return losses - - -class TestSimnet(unittest.TestCase): - def test_dygraph_static_same_loss(self): - if paddle.fluid.is_compiled_with_cuda(): - paddle.fluid.set_flags({"FLAGS_cudnn_deterministic": True}) - conf_dict = create_conf_dict() - dygraph_loss = train(conf_dict, to_static=False) - static_loss = train(conf_dict, to_static=True) - - self.assertEqual(len(dygraph_loss), len(static_loss)) - for i in range(len(dygraph_loss)): - self.assertAlmostEqual(dygraph_loss[i], static_loss[i]) - - -if __name__ == '__main__': - unittest.main() -- GitLab