diff --git a/python/paddle/fluid/dygraph/container.py b/python/paddle/fluid/dygraph/container.py index 20731a66afdf9a9591e4ccd445b7e5f7c57dd032..07667f548ca59635b8290028aa68c3fd929b1fc8 100644 --- a/python/paddle/fluid/dygraph/container.py +++ b/python/paddle/fluid/dygraph/container.py @@ -12,9 +12,13 @@ # See the License for the specific language governing permissions and # limitations under the License. +from ..framework import Parameter from .layers import Layer -__all__ = ['Sequential'] +__all__ = [ + 'Sequential', + 'ParameterList', +] class Sequential(Layer): @@ -23,8 +27,7 @@ class Sequential(Layer): The argument passed to the constructor can be iterable Layers or iterable name Layer pairs. Parameters: - name_scope(str): The name of this class. - layers(iterable): Iterable Layers or iterable name Layer pairs. + *layers(tuple): Layers or iterable name Layer pairs. Examples: .. code-block:: python @@ -36,27 +39,25 @@ class Sequential(Layer): with fluid.dygraph.guard(): data = fluid.dygraph.to_variable(data) # create Sequential with iterable Layers - model1 = fluid.dygraph.Sequential('model1', - fluid.FC('fc1', 2), - fluid.FC('fc2', 3) + model1 = fluid.dygraph.Sequential( + fluid.Linear(10, 1), fluid.Linear(1, 2) ) - model1[0] # access fc1 layer + model1[0] # access the first layer res1 = model1(data) # sequential execution # create Sequential with name Layer pairs - model2 = fluid.dygraph.Sequential('model2', - ('l1', fluid.FC('l1', 2)), - ('l2', fluid.FC('l2', 3)) + model2 = fluid.dygraph.Sequential( + ('l1', fluid.Linear(10, 2)), + ('l2', fluid.Linear(2, 3)) ) model2['l1'] # access l1 layer - model2.add_sublayer('l3', fluid.FC('l3', 3)) # add sublayer - print([l.full_name() for l in model2.sublayers()]) # ['l1/FC_0', 'l2/FC_0', 'l3/FC_0'] + model2.add_sublayer('l3', fluid.Linear(3, 3)) # add sublayer res2 = model2(data) # sequential execution """ - def __init__(self, name_scope, *layers): - super(Sequential, self).__init__(name_scope) + def __init__(self, *layers): + super(Sequential, self).__init__() if len(layers) > 0 and isinstance(layers[0], tuple): for name, layer in layers: self.add_sublayer(name, layer) @@ -83,3 +84,88 @@ class Sequential(Layer): for layer in self._sub_layers.values(): input = layer(input) return input + + +class ParameterList(Layer): + """ParameterList Container. + + This container acts like a Python list, but parameters it contains will be properly added. + + Parameters: + parameters (iterable, optional): Iterable Parameters to be added + + Examples: + .. code-block:: python + + import paddle.fluid as fluid + import numpy as np + + class MyLayer(fluid.Layer): + def __init__(self, num_stacked_param): + super(MyLayer, self).__init__() + # create ParameterList with iterable Parameters + self.params = fluid.dygraph.ParameterList( + [fluid.layers.create_parameter( + shape=[2, 2], dtype='float32')] * num_stacked_param) + + def forward(self, x): + for i, p in enumerate(self.params): + tmp = self._helper.create_variable_for_type_inference('float32') + self._helper.append_op( + type="mul", + inputs={"X": x, + "Y": p}, + outputs={"Out": tmp}, + attrs={"x_num_col_dims": 1, + "y_num_col_dims": 1}) + x = tmp + return x + + data_np = np.random.uniform(-1, 1, [5, 2]).astype('float32') + with fluid.dygraph.guard(): + x = fluid.dygraph.to_variable(data_np) + num_stacked_param = 4 + model = MyLayer(num_stacked_param) + print(len(model.params)) # 4 + res = model(x) + print(res.shape) # [5, 2] + + replaced_param = fluid.layers.create_parameter(shape=[2, 3], dtype='float32') + model.params[num_stacked_param - 1] = replaced_param # replace last param + res = model(x) + print(res.shape) # [5, 3] + model.params.append(fluid.layers.create_parameter(shape=[3, 4], dtype='float32')) # append param + print(len(model.params)) # 5 + res = model(x) + print(res.shape) # [5, 4] + """ + + def __init__(self, parameters=None): + super(ParameterList, self).__init__() + if parameters is not None: + for idx, param in enumerate(parameters): + assert isinstance(param, Parameter) + self.add_parameter(str(idx), param) + + def __getitem__(self, idx): + return self._parameters[str(idx)] + + def __setitem__(self, idx, param): + assert isinstance(param, Parameter) + setattr(self, str(idx), param) + + def __len__(self): + return len(self._parameters) + + def __iter__(self): + return iter(self._parameters.values()) + + def append(self, parameter): + """Appends a given parameter at the end of the list. + + Parameters: + parameter (Parameter): parameter to append + """ + idx = len(self._parameters) + self.add_parameter(str(idx), parameter) + return self diff --git a/python/paddle/fluid/tests/unittests/test_imperative_container_parameterlist.py b/python/paddle/fluid/tests/unittests/test_imperative_container_parameterlist.py new file mode 100644 index 0000000000000000000000000000000000000000..14dcc288b710282efce2a475fdca0ec459e5f562 --- /dev/null +++ b/python/paddle/fluid/tests/unittests/test_imperative_container_parameterlist.py @@ -0,0 +1,72 @@ +# Copyright (c) 2019 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 print_function + +import unittest +import paddle.fluid as fluid +import numpy as np + + +class MyLayer(fluid.Layer): + def __init__(self, num_stacked_param): + super(MyLayer, self).__init__() + # create ParameterList with iterable Parameters + self.params = fluid.dygraph.ParameterList( + [fluid.layers.create_parameter( + shape=[2, 2], dtype='float32')] * num_stacked_param) + + def forward(self, x): + for i, p in enumerate(self.params): + tmp = self._helper.create_variable_for_type_inference('float32') + self._helper.append_op( + type="mul", + inputs={"X": x, + "Y": p}, + outputs={"Out": tmp}, + attrs={"x_num_col_dims": 1, + "y_num_col_dims": 1}) + x = tmp + return x + + +class TestImperativeContainerParameterList(unittest.TestCase): + def test_paramter_list(self): + data_np = np.random.uniform(-1, 1, [5, 2]).astype('float32') + with fluid.dygraph.guard(): + x = fluid.dygraph.to_variable(data_np) + num_stacked_param = 4 + model = MyLayer(num_stacked_param) + self.assertEqual(len(model.params), num_stacked_param) + res = model(x) + self.assertListEqual(res.shape, [5, 2]) + loss = fluid.layers.reduce_mean(res) + loss.backward() + + model.params[num_stacked_param - 1] = fluid.layers.create_parameter( + shape=[2, 3], dtype='float32') + res = model(x) + self.assertListEqual(res.shape, [5, 3]) + model.params.append( + fluid.layers.create_parameter( + shape=[3, 4], dtype='float32')) + self.assertEqual(len(model.params), num_stacked_param + 1) + res = model(x) + self.assertListEqual(res.shape, [5, 4]) + loss = fluid.layers.reduce_mean(res) + loss.backward() + + +if __name__ == '__main__': + unittest.main() diff --git a/python/paddle/fluid/tests/unittests/test_imperative_container_sequential.py b/python/paddle/fluid/tests/unittests/test_imperative_container_sequential.py index 017116b216640b13755e9bb40b4e1972a149d730..846c84c8a58b5c4c437270be525af2f0fa5608c2 100644 --- a/python/paddle/fluid/tests/unittests/test_imperative_container_sequential.py +++ b/python/paddle/fluid/tests/unittests/test_imperative_container_sequential.py @@ -24,33 +24,30 @@ class TestImperativeContainerSequential(unittest.TestCase): data = np.random.uniform(-1, 1, [5, 10]).astype('float32') with fluid.dygraph.guard(): data = fluid.dygraph.to_variable(data) - model1 = fluid.dygraph.Sequential('model1', - fluid.FC('fc1', 1), - fluid.FC('fc2', 2)) + model1 = fluid.dygraph.Sequential( + fluid.Linear(10, 1), fluid.Linear(1, 2)) res1 = model1(data) self.assertListEqual(res1.shape, [5, 2]) - self.assertTrue('fc1' in model1[0]._full_name) - model1[1] = fluid.FC('fc2_new', 3) + model1[1] = fluid.Linear(1, 3) res1 = model1(data) self.assertListEqual(res1.shape, [5, 3]) - self.assertTrue('fc2_new' in name - for name in [p.name for p in model1.parameters()]) loss1 = fluid.layers.reduce_mean(res1) loss1.backward() - model2 = fluid.dygraph.Sequential( - 'model2', ('l1', fluid.FC('l1', 1)), ('l2', fluid.FC('l2', 3))) + l1 = fluid.Linear(10, 1) + l2 = fluid.Linear(1, 3) + model2 = fluid.dygraph.Sequential(('l1', l1), ('l2', l2)) self.assertEqual(len(model2), 2) res2 = model2(data) - self.assertTrue('l1' in model2.l1.full_name()) + self.assertTrue(l1 is model2.l1) self.assertListEqual(res2.shape, res1.shape) self.assertEqual(len(model1.parameters()), len(model2.parameters())) del model2['l2'] self.assertEqual(len(model2), 1) res2 = model2(data) self.assertListEqual(res2.shape, [5, 1]) - model2.add_sublayer('l3', fluid.FC('l3', 3)) - model2.add_sublayer('l4', fluid.FC('l4', 4)) + model2.add_sublayer('l3', fluid.Linear(1, 3)) + model2.add_sublayer('l4', fluid.Linear(3, 4)) self.assertEqual(len(model2), 3) res2 = model2(data) self.assertListEqual(res2.shape, [5, 4])