Add ParameterList (#21056)

* add ParameterList container

* add unittest
test=develop

* fix container, rebase remove build_once
test=develop

* add parameters None check
test=develop

* update Sequential unittest
test=develop

* use Linear in Sequential sample code
test=develop

* fix Sequential arg type doc
test=develop

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

python/paddle/fluid/tests/unittests/test_imperative_container_parameterlist.py

+# 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()

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])