o NeA.ã@slddlmZddlmZddlmZddlmZgd¢ZGdd „d eƒZ Gd d „d eƒZ Gd d „d eƒZ dS)é)Ú OrderedDicté)Ú Parameteré)ÚLayer)Ú param_guard)Ú SequentialÚ ParameterListÚ LayerListcsHeZdZdZ‡fdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z ‡Z S)ra®Sequential container. Sub layers will be added to this container in the order of argument in the constructor. The argument passed to the constructor can be iterable Layers or iterable name Layer pairs. Parameters: layers(Layer|list|tuple): Layer or list/tuple of iterable name Layer pair. Examples: .. code-block:: python import paddle import numpy as np data = np.random.uniform(-1, 1, [30, 10]).astype('float32') data = paddle.to_tensor(data) # create Sequential with iterable Layers model1 = paddle.nn.Sequential( paddle.nn.Linear(10, 1), paddle.nn.Linear(1, 2) ) model1[0] # access the first layer res1 = model1(data) # sequential execution # create Sequential with name Layer pairs model2 = paddle.nn.Sequential( ('l1', paddle.nn.Linear(10, 2)), ('l2', paddle.nn.Linear(2, 3)) ) model2['l1'] # access l1 layer model2.add_sublayer('l3', paddle.nn.Linear(3, 3)) # add sublayer res2 = model2(data) # sequential execution csptt|ƒ ¡t|ƒdkr%t|dttfƒr%|D] \}}| ||¡qdSt|ƒD] \}}| t |ƒ|¡q)dS)Nr) ÚsuperrÚ__init__ÚlenÚ isinstanceÚlistÚtupleÚ add_sublayerÚ enumerateÚstr)ÚselfÚlayersÚnameÚlayerÚidx©Ú __class__©úND:\Projects\ConvertPro\env\Lib\site-packages\paddle/fluid/dygraph/container.pyr =s ÿÿzSequential.__init__cCsªt|tƒr|jt|j ¡ƒ|ŽSt|tƒr|j|S|t|jƒkr)td  |¡ƒ‚|dkr=|t|jƒ kr=|t|jƒ7}n|t|jƒ krLtd  |¡ƒ‚t|j ¡ƒ|S)Nzindex {} is out of ranger) rÚslicerrÚ _sub_layersÚvaluesrr Ú IndexErrorÚformat©rrrrrÚ __getitem__Fs   zSequential.__getitem__cCó"t|tƒsJ‚t|t|ƒ|ƒdS©N)rrÚsetattrr)rrrrrrÚ __setitem__TózSequential.__setitem__cCs"t|ƒ}||jvs J‚|j|=dSr%)rrr"rrrÚ __delitem__Xs zSequential.__delitem__cCó t|jƒSr%©r r©rrrrÚ__len__]ó zSequential.__len__cCs|j ¡D]}||ƒ}q|Sr%)rr)rÚinputrrrrÚforward`s zSequential.forward) Ú__name__Ú __module__Ú __qualname__Ú__doc__r r#r'r)r-r0Ú __classcell__rrrrrs ! rcsJeZdZdZd‡fdd„ Zdd„Zdd„Zd d „Zd d „Zd d„Z ‡Z S)r aParameterList 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 import numpy as np class MyLayer(paddle.nn.Layer): def __init__(self, num_stacked_param): super(MyLayer, self).__init__() # create ParameterList with iterable Parameters self.params = paddle.nn.ParameterList( [paddle.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') x = paddle.to_tensor(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 = paddle.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(paddle.create_parameter(shape=[3, 4], dtype='float32')) # append param print(len(model.params)) # 5 res = model(x) print(res.shape) # [5, 4] NcsNtt|ƒ ¡|dur#t|ƒD]\}}t|tƒsJ‚| t|ƒ|¡qdSdSr%)r r r rrrÚ add_parameterr)rÚ parametersrÚparamrrrr ›sýzParameterList.__init__cCs<t|jƒ|jt|ƒWdƒS1swYdSr%)rÚ _parametersr©rrrrrr#¢ó  $ÿzParameterList.__getitem__cCr$r%)rrr&r)rrr8rrrr'¦r(zParameterList.__setitem__cCr*r%)r r9r,rrrr-ªr.zParameterList.__len__cCs<t|jƒt|j ¡ƒWdƒS1swYdSr%)rr9Úiterrr,rrrÚ__iter__­r;zParameterList.__iter__cCst|jƒ}| t|ƒ|¡|S)z†Appends a given parameter at the end of the list. Parameters: parameter (Parameter): parameter to append )r r9r6r)rZ parameterrrrrÚappend±s zParameterList.appendr%) r1r2r3r4r r#r'r-r=r>r5rrrrr fs4r csjeZdZdZd‡fdd„ Zdd„Zdd„Zd d „Zd d „Zd d„Z dd„Z dd„Z dd„Z dd„Z ‡ZS)r a` LayerList holds sublayers, and sublayers it contains are properly registered. Holded sublayers can be indexed like a regular python list. Parameters: sublayers (iterable of Layer, optional): sublayers to hold Examples: .. code-block:: python import paddle import numpy as np class MyLayer(paddle.nn.Layer): def __init__(self): super(MyLayer, self).__init__() self.linears = paddle.nn.LayerList( [paddle.nn.Linear(10, 10) for i in range(10)]) def forward(self, x): # LayerList can act as an iterable, or be indexed using ints for i, l in enumerate(self.linears): x = self.linears[i // 2](x) + l(x) return x Ncs@tt|ƒ ¡|durt|ƒD]\}}| t|ƒ|¡qdSdSr%)r r r rrr)rÚ sublayersrrrrrr ×s þzLayerList.__init__cCs^t|tƒr-t|ƒ |krt|ƒks#ntd |t|ƒ t|ƒ¡ƒ‚|dkr-|t|ƒ7}|S)Nz@index {} is out of range, should be an integer in range [{}, {})r)rÚintr r r!r:rrrÚ _get_abs_idxÝs  þ zLayerList._get_abs_idxcCs:t|tƒr| t|j ¡ƒ|¡S| |¡}|jt|ƒSr%)rrrrrrrArr:rrrr#çs  zLayerList.__getitem__cCs| |¡}t|t|ƒ|ƒSr%)rAr&r)rrÚsublayerrrrr'îs zLayerList.__setitem__cCs€t|tƒrtt|jƒƒ|D] }t|t|ƒƒqn | |¡}t|t|ƒƒdd„tt|jƒƒDƒ}tt t ||j  ¡ƒƒƒ|_dS)NcSsg|]}t|ƒ‘qSr)r)Ú.0ÚirrrÚ ùsz)LayerList.__delitem__..) rrÚranger rÚdelattrrrArrÚzipr)rrÚkZ str_indicesrrrr)òs ÿ  ÿzLayerList.__delitem__cCr*r%r+r,rrrr-ýr.zLayerList.__len__cCst|j ¡ƒSr%)r<rrr,rrrr=szLayerList.__iter__cCs| tt|ƒƒ|¡|S)aº Appends a sublayer to the end of the list. Parameters: sublayer (Layer): sublayer to append Examples: .. code-block:: python import paddle linears = paddle.nn.LayerList([paddle.nn.Linear(10, 10) for i in range(10)]) another = paddle.nn.Linear(10, 10) linears.append(another) print(len(linears)) # 11 )rrr )rrBrrrr>szLayerList.appendcCs˜t|tƒrt|jƒ |krt|jƒks$nJd t|ƒ t|ƒ¡ƒ‚| |¡}tt|jƒ|dƒD]}|jt|dƒ|jt|ƒ<q2||jt|ƒ<dS)a Insert a sublayer before a given index in the list. Parameters: index (int): index to insert. sublayer (Layer): sublayer to insert Examples: .. code-block:: python import paddle linears = paddle.nn.LayerList([paddle.nn.Linear(10, 10) for i in range(10)]) another = paddle.nn.Linear(10, 10) linears.insert(3, another) print(linears[3] is another) # True another = paddle.nn.Linear(10, 10) linears.insert(-1, another) print(linears[-2] is another) # True z,index should be an integer in range [{}, {})éÿÿÿÿrN)rr@r rr!rArFr)rÚindexrBrDrrrÚinserts &ÿ zLayerList.insertcCs6t|ƒ}t|ƒD]\}}t||ƒ}| ||¡q|S)aD Appends sublayers to the end of the list. Parameters: sublayers (iterable of Layer): iterable of sublayers to append Examples: .. code-block:: python import paddle linears = paddle.nn.LayerList([paddle.nn.Linear(10, 10) for i in range(10)]) another_list = paddle.nn.LayerList([paddle.nn.Linear(10, 10) for i in range(5)]) linears.extend(another_list) print(len(linears)) # 15 print(another_list[0] is linears[10]) # True )r rrr)rr?ÚoffsetrDrBrrrrÚextend5s  zLayerList.extendr%)r1r2r3r4r rAr#r'r)r-r=r>rLrNr5rrrrr ¼s  r N) Ú collectionsrZ frameworkrrrÚbaserÚ__all__rr r rrrrÚs    KV