o Ne@sddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddlm Z ddl Z ddl Z ddl mZddlmZddlmZddlmZddlmZdd lmZdd lmZmZmZdd lmZmZmZm Z dd lm!Z!dd l"m#Z#ddl$m%Z%m&Z&ddl'm(Z(m)Z)m*Z*ddl'm+Z+m,Z,ddl'm-Z.ddl/m0Z0ddl1m2Z2ddl3m4m5Z5dgZ6e7dZ8e7dZ9ddZ:ddZ;Gddde<Z=Gddde<Z>dS)N)deepcopy)in_profiler_mode)parallel_helper) unique_name)core)LayerObjectHelper)record_program_ops_pre_hook!set_op_customized_attrs_post_hookLayerOpsRecoder)program_desc_tracing_guard param_guardin_declarative_mode_convert_into_variable) framework) ParamAttr)Executor global_scope)_non_static_modeconvert_np_dtype_to_dtype_in_dygraph_mode)Program program_guard)_current_expected_place)VarDesc)no_gradLayerz(.)([A-Z][a-z]+)z([a-z])([A-Z])cCstd|}td|S)Nz\1_\2) _first_cap_resub _all_cap_relower)names1r$KD:\Projects\ConvertPro\env\Lib\site-packages\paddle/fluid/dygraph/layers.py_convert_camel_to_snake5s r&cCsd|d}t|dkr |Sg}t|D]\}}|dkr&|t|d|q|ddd|S)N rr )splitlen enumerateappendstrjoin)stringindentr#s2idxliner$r$r% _addindent:s  r4c@s$eZdZdZdZddZddZdS)HookRemoveHelperz5 A HookRemoveHelper that can be used to remove hook. rcCs&t||_tj|_tjd7_dS)Nr)weakrefref _hooks_refr5 next_hook_id_hook_idselfhooksr$r$r%__init__Js zHookRemoveHelper.__init__cCs.|}|dur|j|vr||j=dSdSdSN)r8r:r;r$r$r%removeOs zHookRemoveHelper.removeN)__name__ __module__ __qualname____doc__r9r>r@r$r$r$r%r5Es  r5c@seZdZdZdiddZddZdd Zd d Zd d ZddZ ddZ    djddZ e dddddkddZ dkddZdlddZd d!Zd"d#Zdmd$d%Zdnd'd(Zdod)d*Zdld+d,Zdld-d.Zdnd/d0Zd1d2Zd3d4Zd5d6Zd7d8Zd9d:Zd;d<Zd=d>Zd?d@ZdAdBZ dCdDZ!dEdFZ"dGdHZ#dIdJZ$dKdLZ%dMdNZ&dOdPZ'dQdRZ(dSdTZ)   &dpdUdVZ*   &  dqdWdXZ+   & drdYdZZ,   & drd[d\Z-e.j/dld]d^Z0dkd_d`Z1dldadbZ2dcddZ3     dsdedfZ4dgdhZ5e0Z6e0Z7dS)tra Dynamic graph Layer based on OOD, includes the parameters of the layer, the structure of the forward graph and so on. Parameters: name_scope (str, optional): prefix name used by the layer to name parameters. If prefix is "my_layer", parameter name in MyLayer can be "my_layer_0.w_n", where "w" is the parameter base name and "n" is an unique suffix auto-generated. If None, prefix name will be snake cased class name. Default: None. dtype(str, optional): data type of this parameter. If set str, it can be "bool", "float16", "float32", "float64", "int8", "int16", "int32", "int64", "uint8" or "uint16". Default: "float32" Returns: None Examples: .. code-block:: python import paddle class MyLayer(paddle.nn.Layer): def __init__(self): super(MyLayer, self).__init__() self._linear = paddle.nn.Linear(1, 1) self._dropout = paddle.nn.Dropout(p=0.5) def forward(self, input): temp = self._linear(input) temp = self._dropout(temp) return temp x = paddle.randn([10, 1], 'float32') mylayer = MyLayer() mylayer.eval() # set mylayer._dropout to eval mode out = mylayer(x) mylayer.train() # set mylayer._dropout to train mode out = mylayer(x) Nfloat32cCsd|_|dur t|jj}t||_t|j|_d|_ ||_ t |_ t|_t|_t|_t|_t|_tggd|_i|_t|_t|_d|_t|_t|_dS)NTF)opsr=)trainingr& __class__rArgenerate _full_namer _helper_built_dtyperrZ_init_in_dynamic_mode collections OrderedDict _parameters_buffersset!_non_persistable_buffer_names_set _sub_layers_loaddict_holderr _op_recorder_customized_attrs_forward_pre_hooks_forward_post_hooksZ_casted_by_pure_fp16_state_dict_hooksZ_original_funcs)r<Z name_scopedtyper$r$r%r>|s(           zLayer.__init__cC0tr td|_|D]}d|_qdS)a Sets this Layer and all its sublayers to training mode. This only effects certain modules like `Dropout` and `BatchNorm`. Returns: None Example:: .. code-block:: python import paddle class MyLayer(paddle.nn.Layer): def __init__(self): super(MyLayer, self).__init__() self._linear = paddle.nn.Linear(1, 1) self._dropout = paddle.nn.Dropout(p=0.5) def forward(self, input): temp = self._linear(input) temp = self._dropout(temp) return temp x = paddle.randn([10, 1], 'float32') mylayer = MyLayer() mylayer.eval() # set mylayer._dropout to eval mode out = mylayer(x) mylayer.train() # set mylayer._dropout to train mode out = mylayer(x) TN)rr_dygraph_tracerZ train_moderG sublayersr<layerr$r$r%trains #  z Layer.traincCr\)a Sets this Layer and all its sublayers to evaluation mode. This only effects certain modules like `Dropout` and `BatchNorm`. Returns: None Example:: .. code-block:: python import paddle class MyLayer(paddle.nn.Layer): def __init__(self): super(MyLayer, self).__init__() self._linear = paddle.nn.Linear(1, 1) self._dropout = paddle.nn.Dropout(p=0.5) def forward(self, input): temp = self._linear(input) temp = self._dropout(temp) return temp x = paddle.randn([10, 1], 'float32') mylayer = MyLayer() mylayer.eval() # set mylayer._dropout to eval mode out = mylayer(x) print(out) FN)rrr]Z eval_moderGr^r_r$r$r%evals "  z Layer.evalcCs$|D]}||q|||S)a Applies ``fn`` recursively to every sublayer (as returned by ``.sublayers()``) as well as self. Typical use includes initializing the parameters of a model. Parameters: fn (function): a function to be applied to each sublayer Returns: Layer: self Example:: .. code-block:: python import paddle import paddle.nn as nn net = nn.Sequential(nn.Linear(2, 2), nn.Linear(2, 2)) def init_weights(layer): if type(layer) == nn.Linear: print('before init weight:', layer.weight.numpy()) new_weight = paddle.full(shape=layer.weight.shape, dtype=layer.weight.dtype, fill_value=0.9) layer.weight.set_value(new_weight) print('after init weight:', layer.weight.numpy()) net.apply(init_weights) print(net.state_dict()) )childrenapply)r<fnr`r$r$r%rds  z Layer.applycC|jS)aFull name for this layer, composed by name_scope + "/" + MyLayer.__class__.__name__ Returns: str: full name of this layer. Example:: .. code-block:: python import paddle class LinearNet(paddle.nn.Layer): def __init__(self): super(LinearNet, self).__init__(name_scope = "demo_linear_net") self._linear = paddle.nn.Linear(1, 1) def forward(self, x): return self._linear(x) linear_net = LinearNet() print(linear_net.full_name()) # demo_linear_net_0 )rJr<r$r$r% full_nameszLayer.full_namecCt|j}||j|j<|S)aRegister a forward post-hook for Layer. The hook will be called after `forward` function has been computed. It should have the following form, `input` and `output` of the `hook` is `input` and `output` of the `Layer` respectively. User can use forward post-hook to change the output of the Layer or perform information statistics tasks on the Layer. hook(Layer, input, output) -> None or modified output Parameters: hook(function): a function registered as a forward post-hook Returns: HookRemoveHelper: a HookRemoveHelper object that can be used to remove the added hook by calling `hook_remove_helper.remove()` . Examples: .. code-block:: python import paddle import numpy as np # the forward_post_hook change the output of the layer: output = output * 2 def forward_post_hook(layer, input, output): # user can use layer, input and output for information statistis tasks # change the output return output * 2 linear = paddle.nn.Linear(13, 5) # register the hook forward_post_hook_handle = linear.register_forward_post_hook(forward_post_hook) value1 = np.arange(26).reshape(2, 13).astype("float32") in1 = paddle.to_tensor(value1) out0 = linear(in1) # remove the hook forward_post_hook_handle.remove() out1 = linear(in1) # hook change the linear's output to output * 2, so out0 is equal to out1 * 2. assert (out0.numpy() == (out1.numpy()) * 2).any() )r5rYr:r<hookZhook_remove_helperr$r$r%register_forward_post_hook+s - z Layer.register_forward_post_hookcCri)aRegister a forward pre-hook for Layer. The hook will be called before `forward` function has been computed. It should have the following form, `input` of the `hook` is `input` of the `Layer`, hook can either return a tuple or a single modified value in the hook. We will wrap the value into a tuple if a single value is returned(unless that value is already a tuple). User can use forward pre-hook to change the input of the Layer or perform information statistics tasks on the Layer. hook(Layer, input) -> None or modified input Parameters: hook(function): a function registered as a forward pre-hook Returns: HookRemoveHelper: a HookRemoveHelper object that can be used to remove the added hook by calling `hook_remove_helper.remove()` . Examples: .. code-block:: python import paddle import numpy as np # the forward_pre_hook change the input of the layer: input = input * 2 def forward_pre_hook(layer, input): # user can use layer and input for information statistis tasks # change the input input_return = (input[0] * 2) return input_return linear = paddle.nn.Linear(13, 5) # register the hook forward_pre_hook_handle = linear.register_forward_pre_hook(forward_pre_hook) value0 = np.arange(26).reshape(2, 13).astype("float32") in0 = paddle.to_tensor(value0) out0 = linear(in0) # remove the hook forward_pre_hook_handle.remove() value1 = value0 * 2 in1 = paddle.to_tensor(value1) out1 = linear(in1) # hook change the linear's input to input * 2, so out0 is equal to out1. assert (out0.numpy() == out1.numpy()).any() )r5rXr:rjr$r$r%register_forward_pre_hook\s 1 zLayer.register_forward_pre_hookFcCs6t|}t|tjr|dkrd}|j|||||S)aYCreate parameters for this layer. Parameters: shape(list): Shape of the parameter. attr(ParamAttr, optional): Parameter attribute of weight. Please refer to :ref:`api_paddle_ParamAttr`. Default: None. dtype(str, optional): Data type of this parameter. If set str, it can be "bool", "float16", "float32", "float64", "int8", "int16", "int32", "int64", "uint8" or "uint16". Default: "float32". is_bias(bool, optional): if this is a bias parameter. Default: False. default_initializer(Initializer, optional): the default initializer for this parameter. If set None, default initializer will be set to paddle.nn.initializer.Xavier and paddle.nn.initializer.Constant for non-bias and bias parameter, respectively. Default: None. Returns: :Tensor, created parameter. Examples: .. code-block:: python import paddle class MyLayer(paddle.nn.Layer): def __init__(self): super(MyLayer, self).__init__() self._linear = paddle.nn.Linear(1, 1) w_tmp = self.create_parameter([1,1]) self.add_parameter("w_tmp", w_tmp) def forward(self, input): return self._linear(input) mylayer = MyLayer() for name, param in mylayer.named_parameters(): print(name, param) # will print w_tmp,_linear.weight,_linear.bias N)copyr isinstancesix string_typesrKcreate_parameter)r<shapeattrr[Zis_biasZdefault_initializerZ temp_attrr$r$r%rss *zLayer.create_parameterz2.0.0zpaddle.nn.Layer.create_tensorz(New api in create_tensor, easier to use.)ZsinceZ update_toreasoncCP|dur d|j|g}n td|jdg}|jjj|||tj j j dS)a Create Tensor for this layer. Parameters: name(str, optional): name of the tensor. Please refer to :ref:`api_guide_Name` . Default: None persistable(bool, optional): if set this tensor persistable. Default: False dtype(str, optional): data type of this parameter. If set str, it can be "bool", "float16", "float32", "float64","int8", "int16", "int32", "int64", "uint8" or "uint16". If set None, it will be "float32". Default: None Returns: Tensor, created Tensor. Examples: .. code-block:: python import paddle class MyLinear(paddle.nn.Layer): def __init__(self, in_features, out_features): super(MyLinear, self).__init__() self.linear = paddle.nn.Linear( 10, 10) self.back_var = self.create_variable(name = "linear_tmp_0", dtype=self._dtype) def forward(self, input): out = self.linear(input) paddle.assign( out, self.back_var) return out N._generated_varr" persistabler[type r.rJrrIrKZ main_programZ current_blockZ create_varrrVarTypeZ LOD_TENSORr<r"r{r[var_namer$r$r%create_variables' zLayer.create_variablecCrw)a Create Tensor for this layer. Parameters: name(str, optional): name of the tensor. Please refer to :ref:`api_guide_Name` . Default: None persistable(bool, optional): if set this tensor persistable. Default: False dtype(str, optional): data type of this parameter. If set str, it can be "bool", "float16", "float32", "float64", "int8", "int16", "int32", "int64", "uint8" or "uint16". If set None, it will be "float32". Default: None Returns: Tensor, created Tensor. Examples: .. code-block:: python import paddle class MyLinear(paddle.nn.Layer): def __init__(self, in_features, out_features): super(MyLinear, self).__init__() self.linear = paddle.nn.Linear( 10, 10) self.back_var = self.create_tensor(name = "linear_tmp_0", dtype=self._dtype) def forward(self, input): out = self.linear(input) paddle.assign( out, self.back_var) return out Nrxryrzr}rr$r$r% create_tensors% zLayer.create_tensorTcCdd|j|dD}|S)aaReturns a list of all Parameters from current layer and its sub-layers. Returns: list of Tensor : a list of Parameters. Examples: .. code-block:: python import paddle linear = paddle.nn.Linear(1,1) print(linear.parameters()) # print linear_0.w_0 and linear_0.b_0 cSg|]\}}|qSr$r$).0_paramr$r$r% 5z$Layer.parameters..include_sublayers)named_parametersr<rretr$r$r% parameters&s zLayer.parametersccs|D]\}}|VqdS)aJReturns an iterator over immediate children layers. Yields: Layer: a child layer Examples: .. code-block:: python import paddle linear1 = paddle.nn.Linear(10, 3) linear2 = paddle.nn.Linear(3, 10, bias_attr=False) model = paddle.nn.Sequential(linear1, linear2) layer_list = list(model.children()) print(layer_list) # [, ] N)named_children)r<rr`r$r$r%rc;szLayer.childrenccsDt}|jD]\}}|dur||vr||||fVq dS)aReturns an iterator over immediate children layers, yielding both the name of the layer as well as the layer itself. Yields: (string, Layer): Tuple containing a name and child layer Examples: .. code-block:: python import paddle linear1 = paddle.nn.Linear(10, 3) linear2 = paddle.nn.Linear(3, 10, bias_attr=False) model = paddle.nn.Sequential(linear1, linear2) for prefix, layer in model.named_children(): print(prefix, layer) # ('0', ) # ('1', ) N)rRrTitemsadd)r<memor"r`r$r$r%rRs  zLayer.named_childrencCr)aReturns a list of sub layers. Parameters: include_self(bool, optional): Whether return self as sublayers. Default: False Returns: list of Layer : a list of sub layers. Examples: .. code-block:: python import paddle class MyLayer(paddle.nn.Layer): def __init__(self): super(MyLayer, self).__init__() self._linear = paddle.nn.Linear(1, 1) self._dropout = paddle.nn.Dropout(p=0.5) def forward(self, input): temp = self._linear(input) temp = self._dropout(temp) return temp mylayer = MyLayer() print(mylayer.sublayers()) # [, ] cSrr$r$)rrr`r$r$r%rsz#Layer.sublayers..) include_self)named_sublayers)r<rrr$r$r%r^ms zLayer.sublayersrnc ct}|r |j|ddnt|g|g}|D]-\}}|j}|D]!\}} | dus-| |vr.q!|| ||r8dnd|} | | fVq!qdS)a? Returns an iterator over all parameters in the Layer, yielding tuple of name and parameter. Parameters: prefix(str, optional): Prefix to prepend to all parameter names. Default: ''. include_sublayers(bool, optional): Whether include the parameters of sublayers. If True, also include the named parameters from sublayers. Default: True. Yields: (string, Parameter): Tuple of name and Parameter Examples: .. code-block:: python import paddle fc1 = paddle.nn.Linear(10, 3) fc2 = paddle.nn.Linear(3, 10, bias_attr=False) model = paddle.nn.Sequential(fc1, fc2) for name, param in model.named_parameters(): print(name, param) TprefixrNrxrn)rRrziprPrr) r<rrZ params_setr layer_prefixsublayerparamskeyrr"r$r$r%rs(     zLayer.named_parametersc cs|durt}|r||vr||||fV|jD]%\}}|dur&q||r+dnd|}|j|d|dD] \}}||fVq8qdS)au Returns an iterator over all sublayers in the Layer, yielding tuple of name and sublayer. The duplicate sublayer will only be yielded once. Parameters: prefix(str, optional): Prefix to prepend to all parameter names. Default: ''. include_self(bool, optional): Whether include the Layer itself. Default: False. layers_set(set, optional): The set to record duplicate sublayers. Default: None. Yields: (string, Layer): Tuple of name and Layer Examples: .. code-block:: python import paddle fc1 = paddle.nn.Linear(10, 3) fc2 = paddle.nn.Linear(3, 10, bias_attr=False) model = paddle.nn.Sequential(fc1, fc2) for prefix, layer in model.named_sublayers(): print(prefix, layer) NrxrnT)rr layers_set)rRrrTrr) r<rrrrr`rplr$r$r%rs"    zLayer.named_sublayerscCsd|jvr tdt|tjstdt|jd|vr!t d|dkr)t dt ||r:||j vr:t d||d urWt|t j ksWt|t jjksWtd t|j||j |<|rf|j|d S|j|d S) aO Registers a tensor as buffer into the layer. `buffer` is a non-trainable tensor and will not be updated by optimizer, but is necessary for evaluation and inference. For example, the mean and variance in BatchNorm layers. The registered buffer is persistable by default, and will be saved into `state_dict` alongside parameters. If set persistable=False, it registers a non-persistable buffer, so that it will not be a part of `state_dict` . Buffers can be accessed as attributes using given names. Parameters: name (string): name of the buffer. The buffer can be accessed from this layer using the given name tensor (Tensor): the tensor to be registered as buffer. persistable (bool): whether the buffer is part of this layer's state_dict. Returns: None Examples: .. code-block:: python import numpy as np import paddle linear = paddle.nn.Linear(10, 3) value = np.array([0]).astype("float32") buffer = paddle.to_tensor(value) linear.register_buffer("buf_name", buffer, persistable=True) # get the buffer by attribute. print(linear.buf_name) rQ8super(YourLayer, self).__init__() should be called firstz7The name of buffer should be a string, but received {}.rxzThe name of buffer can not contain `.`, because when you access the newly added buffer in the form of `self.**.**`, it will cause AttributeError.rnz$The name of buffer can not be empty.zattribute '{}' already exists.NzAThe registered buffer should be a Paddle.Tensor, but received {}.)__dict__ ValueErrorrprqrr TypeErrorformatr|rAKeyErrorhasattrrQrVarBaseeagerTensorrSdiscardr)r<r"Ztensorr{r$r$r%register_buffers6 &    zLayer.register_buffercCr)a Returns a list of all buffers from current layer and its sub-layers. Parameters: include_sublayers(bool, optional): Whether include the buffers of sublayers. If True, also include the buffers from sublayers. Default: True Returns: list of Tensor : a list of buffers. Examples: .. code-block:: python import numpy as np import paddle linear = paddle.nn.Linear(10, 3) value = np.array([0]).astype("float32") buffer = paddle.to_tensor(value) linear.register_buffer("buf_name", buffer, persistable=True) print(linear.buffers()) # == print([linear.buf_name]) cSrr$r$)rrbufferr$r$r%r6rz!Layer.buffers..r) named_buffersrr$r$r%bufferss z Layer.buffersc cr)aJ Returns an iterator over all buffers in the Layer, yielding tuple of name and Tensor. Parameters: prefix(str, optional): Prefix to prepend to all buffer names. Default: ''. include_sublayers(bool, optional): Whether include the buffers of sublayers. If True, also include the named buffers from sublayers. Default: True. Yields: (string, Tensor): Tuple of name and tensor Examples: .. code-block:: python import numpy as np import paddle fc1 = paddle.nn.Linear(10, 3) buffer1 = paddle.to_tensor(np.array([0]).astype("float32")) # register a tensor as buffer by specific `persistable` fc1.register_buffer("buf_name_1", buffer1, persistable=True) fc2 = paddle.nn.Linear(3, 10) buffer2 = paddle.to_tensor(np.array([1]).astype("float32")) # register a buffer by assigning an attribute with Tensor. # The `persistable` can only be False by this way. fc2.buf_name_2 = buffer2 model = paddle.nn.Sequential(fc1, fc2) # get all named buffers for name, buffer in model.named_buffers(): print(name, buffer) TrNrxrn)rRrrrQrr) r<rrZ buffers_setrrrrrrr"r$r$r%r<s($     zLayer.named_bufferscCs |D] }|jr |qdS)a Clear the gradients of all parameters for this layer. Returns: None Examples: .. code-block:: python import paddle import numpy as np value = np.arange(26).reshape(2, 13).astype("float32") a = paddle.to_tensor(value) linear = paddle.nn.Linear(13, 5) adam = paddle.optimizer.Adam(learning_rate=0.01, parameters=linear.parameters()) out = linear(a) out.backward() adam.step() linear.clear_gradients() N)rZ trainableZclear_gradient)r<rr$r$r%clear_gradientsms zLayer.clear_gradientscOsdSr?r$)r<argskwargsr$r$r% _build_onceszLayer._build_oncecOs"|jD]}|||}|durt|ts|f}|}q|jsMtd |j|i|tr;t r;t |j Wdn1sEwYd|_t rst|jjtjj|j|i|}Wdn1smwYn|j|i|}|jD]}||||}|dur|}q|S)NFT)rXvaluesrptuplerLr rrZ_is_data_parallel_modepaddleZis_compiled_with_xpuZ_broadcast_parametersrPrprofilerZ RecordEventrHrAZTracerEventTypeForwardforwardrY)r<inputsrZforward_pre_hook hook_resultZoutputsZforward_post_hookr$r$r%_dygraph_call_funcsB      zLayer._dygraph_call_funccOsTts"|js"|js"|js"tr"ts"|j|i||j|i|S|j|i|Sr?) rrXrYrLrrrrrr<rrr$r$r%__call__s zLayer.__call__cOst)z Defines the computation performed at every call. Should be overridden by all subclasses. Parameters: *inputs(tuple): unpacked tuple arguments **kwargs(dict): unpacked dict arguments )NotImplementedErrorrr$r$r%rs z Layer.forwardcGstd)Nz"Layer shouldn't implement backward)r)r<rr$r$r%backwardszLayer.backwardcCs$t|ts |dks J||j|<|S)a1Adds a sub Layer instance. Added sublayer can be accessed by self.name Parameters: name(str): name of this sublayer. sublayer(Layer): an instance of Layer. Returns: Layer: the sublayer passed in. Examples: .. code-block:: python import paddle class MySequential(paddle.nn.Layer): def __init__(self, *layers): super(MySequential, self).__init__() if len(layers) > 0 and isinstance(layers[0], tuple): for name, layer in layers: self.add_sublayer(name, layer) else: for idx, layer in enumerate(layers): self.add_sublayer(str(idx), layer) def forward(self, input): for layer in self._sub_layers.values(): input = layer(input) return input fc1 = paddle.nn.Linear(10, 3) fc2 = paddle.nn.Linear(3, 10, bias_attr=False) model = MySequential(fc1, fc2) for prefix, layer in model.named_sublayers(): print(prefix, layer) N)rprrT)r<r"rr$r$r% add_sublayers% zLayer.add_sublayercCsd|jvr tdt|tjstdt|jd|vr!t d|dkr)t dt ||r:||j vr:t d||d urNt|t j sNtd t|j|d urWd |j |<t|jd kru|j|jvslJd |j||j|j||j |<|S) aAdds a Parameter instance. Added parameter can be accessed by self.name Parameters: name(str): name of this sublayer. parameter(Parameter): an instance of Parameter. Returns: Parameter: the parameter passed in. Examples: .. code-block:: python import paddle class MyLayer(paddle.nn.Layer): def __init__(self): super(MyLayer, self).__init__() self._linear = paddle.nn.Linear(1, 1) w_tmp = self.create_parameter([1,1]) self.add_parameter("w_tmp", w_tmp) def forward(self, input): return self._linear(input) mylayer = MyLayer() for name, param in mylayer.named_parameters(): print(name, param) # will print w_tmp,_linear.weight,_linear.bias rPz;super(YourLayer, self).__init__() should be called firstly.z:The name of parameter should be a string, but received {}.rxzThe name of parameter can not contain `.`, because when you access the newly added parameter in the form of `self.**.**`, it will cause AttributeError.rnz'The name of parameter can not be empty.z"The parameter '{}' already exists.NzAThe parameter to be added should be a Parameter, but received {}.r8Parameter not found, Can't not find [ {} ] in state_dict)r RuntimeErrorrprqrrrrr|rArrrPr Parameterr*rUr" set_value)r<r"Z parameterr$r$r% add_parametersB       zLayer.add_parametercsfdd}t|tstdt|jj||dds4t }t j j dks/J|gj _ |ddsa t}t jdkrNjj|jdd t j j dksXJj j |d Sd S) aY Add customized attribute while append_op. In case of quantization, we want to save some attributes into op_desc while exporting inference model by @to_static. Arguments: attrs(dict): customized attributes that will be added into op_descs. NOTE: The interface is only exposed to developers. cs@|rjnj}|r tnt}d}|rtt|}|||k}|S)NF)rXrYr r nextreversed) is_pre_hookZ layers_hooksZcandidate_hookZalready_registedlast_keyrgr$r%is_already_registered;s   z2Layer._set_op_attrs..is_already_registeredz+attrs should be type(dict), but received {}T)rrFr)lastN)rpdictrrr|rArWupdatermr r*rVr=rlr rY move_to_endr:r,)r<attrsrZpre_hook_helperZpost_hook_helperr$rgr% _set_op_attrs0s2      zLayer._set_op_attrscCrfr?)rrgr$r$r% __getstate__aszLayer.__getstate__cCs|j|dSr?)rr)r<stater$r$r% __setstate__dszLayer.__setstate__cCsd|jvr|jd}||jvrtrt|j|S|j|Sd|jvr2|jd}||jvr2|j|Sd|jvrM|jd}||vrMtrIt||S||St||S)NrPrTrQ)rrPrrrTobject__getattribute__)r<r"rPrTrQr$r$r% __getattr__gs"            zLayer.__getattr__csfdd}ttt|dtrt|||jdd}t|tj rZ|dur-t dt |j dkrK|j |j vsBJd|j ||j |j ||j|j|j||<dS|durw|vrw|durqtdt|jd|<dS|jdd}t|tr|durt d||j|j|j||<dS|dur|vr|durtd t|jd|<dS|jd d}t|tjtjjfr|durt d||j|j|j|jvr|j|j std |_ ||<dS|durY|vrYt|tjkrCdd lm }t!r|durt"d |dus1tt|tjkr9|||<dS||t|dS|durStdt|jd|<dSt||dS)Ncs|D] }|vr |=qdSr?r$)Zdictsdr"r$r%_remove_if_exist|s z+Layer.__setattr__.._remove_if_existrPrrrzNassignment to parameter '{}' should be of type Parameter or None, but got '{}'rTzIassignment to sublayer '{}' should be of type Layer or None, but got '{}'rQZ _buffers_)assignziIn Dy2stat, self.{0} is a buffer and self.{0} is not allowed to be set to Variable when self.{0} is None.zOassignment to buffers '{}' should be of type core.VarBase or None, but got '{}')#rpgetattrr|propertyr __setattr__rgetrrrr*rUr"rrrQrTrrArrPrrrrrSrrrIVariablerrrr)r<r"valuerrZlayersrQrr$rr%rzs              zLayer.__setattr__cCs^||jvr |j|=dS||jvr|j|=dS||jvr'|j|=|j|dSt||dSr?)rPrTrQrSrr __delattr__)r<r"r$r$r%rs     zLayer.__delattr__cCsZt|j}t|j}t|j}t|j}t|j}|||||}|S)a Return a list. Get all parameters, buffers(non-parameter tensors), sublayers, method and attr of Layer. Examples: .. code-block:: python import paddle import numpy as np class Mylayer(paddle.nn.Layer): def __init__(self): super(Mylayer, self).__init__() self.linear1 = paddle.nn.Linear(10, 10) self.linear2 = paddle.nn.Linear(5, 5) self.conv2d = paddle.nn.Conv2D(3, 2, 3) self.embedding = paddle.nn.Embedding(128, 16) self.h_0 = paddle.to_tensor(np.zeros([10, 10]).astype('float32')) mylayer = Mylayer() print(dir(mylayer)) # only parts are shown, because of list have too much content # ['__call__', '__class__', ... , 'conv2d', 'embedding', 'h_0', 'linear1', 'linear2', ... , 'sublayers', 'train'] )dirrHlistrkeysrPrTrQ)r<methodrrr^rrr$r$r%__dir__s z Layer.__dir__cCsdS)zs Extra representation of this layer, you can have custom implementation of your own layer. rnr$rgr$r$r% extra_reprszLayer.extra_reprcCsg}|}|d}g}|jD]\}}t|}t|d}|d|d|q|jjd}|rQt |dkrE|dd |d7}n t |dkrQ||d7}|r^|dd |d7}|d7}|S) Nr'r(z): rz r)) rr)rTrreprr4r,rHrAr*r.)r< extra_linesrZsublayer_linesr"r`Z sublayer_strZ final_strr$r$r%__repr__ s$      zLayer.__repr__cCrir?)r5rZr:rjr$r$r%register_state_dict_hook"s  zLayer.register_state_dict_hookc Cs|durt}|jD]\}}|dur||||<q |jD]\}}|dur4||jvr4||||<q!|rY|jD]\}}|durX|} | | | |||d| }q<|S)z The difference from state_dict() is that state_dict_hook will not be called, but the original types of parameters and buffers will be maintained. Nrx) rNrOrPrrQrSrTror_obtain_parameters_buffers) r< destinationrstructured_name_prefixr"datar layer_name layer_itemdestination_tempr$r$r%r's.   z Layer._obtain_parameters_buffersc Cs|durt}|jD]\}}|dur||||<q |jD] \}}|s7|dur6||jvr6||||<q!|durA||||<q!|rh|jD]\} } | durg|} | | | ||| d||| }qI|r||j D] } | |} | dur{| }qo|S)a Get all parameters and persistable buffers of current layer and its sub-layers. And set them into a dict Parameters: destination(dict, optional) : If provide, all the parameters and persistable buffers will be set to this dict . Default: None include_sublayers(bool, optional) : If true, also include the parameters and persistable buffers from sublayers. Default: True include_non_persistable_buffer(bool, optional): If true, include non persistable buffers of current layer and its sub-layers, it is used in pure fp16 and jit.save. Default: False use_hook(bool, optional) : If true, the operations contained in _state_dict_hooks will be appended to the destination. Default: True Nrx) rNrOrPrrQrSrTror_state_dict_implrZr)r<rrrinclude_non_persistable_bufferuse_hookr"rrrrrZstate_dict_hookrr$r$r%rCsD    zLayer._state_dict_implcC|j|||d|dS)a Get all parameters and buffers of current layer and its sub-layers. And set them into a dict Parameters: destination(dict, optional) : If provide, all the parameters and persistable buffers will be set to this dict . Default: None include_sublayers(bool, optional) : If true, also include the parameters and persistable buffers from sublayers. Default: True use_hook(bool, optional) : If true, the operations contained in _state_dict_hooks will be appended to the destination. Default: True Retruns: dict: a dict contains all the parameters and persistable buffers. Examples: .. code-block:: python import paddle emb = paddle.nn.Embedding(10, 10) state_dict = emb.to_static_state_dict() paddle.save( state_dict, "paddle_dy.pdparams") Trrrrrrr<rrrrr$r$r%to_static_state_dictrzLayer.to_static_state_dictcCr)a Get all parameters and persistable buffers of current layer and its sub-layers. And set them into a dict Parameters: destination(dict, optional) : If provide, all the parameters and persistable buffers will be set to this dict . Default: None include_sublayers(bool, optional) : If true, also include the parameters and persistable buffers from sublayers. Default: True use_hook(bool, optional) : If true, the operations contained in _state_dict_hooks will be appended to the destination. Default: True Retruns: dict: a dict contains all the parameters and persistable buffers. Examples: .. code-block:: python import paddle emb = paddle.nn.Embedding(10, 10) state_dict = emb.state_dict() paddle.save( state_dict, "paddle_dy.pdparams") Frrrr$r$r% state_dictrzLayer.state_dictc sfdd}g}|jddD]5\}}|r|n|j}z |||}||WqtyE} ztd|t| WYd} ~ qd} ~ wwt rW|D] \}} | | qKdSdd} t t j } td d |Dt| |D] \}} | || qpdS) a[ Set parameters and persistable buffers from state_dict. All the parameters and buffers will be reset by the tensor in the state_dict Parameters: state_dict(dict) : Dict contains all the parameters and persistable buffers. use_structured_name(bool, optional) : If true, use structured name as key, otherwise, use parameter or buffer name as key. Default: True Returns: None Examples: .. code-block:: python import paddle emb = paddle.nn.Embedding(10, 10) state_dict = emb.state_dict() paddle.save(state_dict, "paddle_dy.pdparams") para_state_dict = paddle.load("paddle_dy.pdparams") emb.set_state_dict(para_state_dict) cs|d}|durtd|t|tst|tr4t|t|kr0td|t|t|||fSt|j r>| n|j }t|t|j krXtd|t|t|j ||fS)Nz%{} is not found in the provided dict.z;{} receieves the length of {}, but the expected shape is {}z5{} receives a shape {}, but the expected shape is {}.) rrrrprrr*inspectismethodrt)rrrZ state_shaperr$r% _check_matchs0  z*Layer.set_state_dict.._check_matchF)rzSkip loading for {}. NcSst|j}|}|rt}n2|rt }n)| r6t }| |t |}nt }| |t|}|||dSr?)rZfind_varr" get_tensorZ_placeZ is_cpu_placerCPUPlaceZis_cuda_pinned_placeCUDAPinnedPlaceZ is_xpu_placeZPlaceZ set_placeXPUPlaceZ xpu_device_id CUDAPlaceZ gpu_device_idrR)varZndarraytrplacer$r$r%_set_vars  z&Layer.set_state_dict.._set_varcSsg|]\}}|qSr$r$)rrrr$r$r%rsz(Layer.set_state_dict..)rrr"r,rwarningswarnrr-rrr _get_device_default_executorrZ_create_loaded_parameterr) r<rZuse_structured_namerZmatched_param_staterrZkey_nameZ match_reserrrr executorr$rr%set_state_dicts0  $     zLayer.set_state_dictcCs|j|||dddS)a Cast the parameters and buffers of Layer by the give device, dtype and blocking. Parameters: device(str|paddle.CPUPlace()|paddle.CUDAPlace()|paddle.CUDAPinnedPlace()|paddle.XPUPlace()|None, optional): The device of the Layer which want to be stored. If None, the device is the same with the original Tensor. If device is string, it can be ``cpu``, ``gpu:x`` and ``xpu:x``, where ``x`` is the index of the GPUs or XPUs. Default: None. dtype(str|numpy.dtype|paddle.dtype|None, optional): The type of the data. If None, the dtype is the same with the original Tensor. Default: None. blocking(bool|None, optional): If False and the source is in pinned memory, the copy will be asynchronous with respect to the host. Otherwise, the argument has no effect. If None, the blocking is set True. Default: None. Returns: self Examples: .. code-block:: python # required: skip import paddle linear=paddle.nn.Linear(2, 2) linear.weight #Parameter containing: #Tensor(shape=[2, 2], dtype=float32, place=CUDAPlace(0), stop_gradient=False, # [[-0.32770029, 0.38653070], # [ 0.46030545, 0.08158520]]) linear.to(dtype='float64') linear.weight #Tenor(shape=[2, 2], dtype=float64, place=CUDAPlace(0), stop_gradient=False, # [[-0.32770029, 0.38653070], # [ 0.46030545, 0.08158520]]) linear.to(device='cpu') linear.weight #Tensor(shape=[2, 2], dtype=float64, place=CPUPlace, stop_gradient=False, # [[-0.32770029, 0.38653070], # [ 0.46030545, 0.08158520]]) linear.to(device=paddle.CUDAPinnedPlace(), blocking=False) linear.weight #Tensor(shape=[2, 2], dtype=float64, place=CUDAPinnedPlace, stop_gradient=False, # [[-0.04989364, -0.56889004], # [ 0.33960250, 0.96878713]]) TF)devicer[blockingr floating_only)_to_impl)r<rr[rr$r$r%to s 0zLayer.toc Cs|r|D] }||||||q|jD]C\}}|durZt|||||} Wdn1s4wY|jdurZt|||||} Wdn1sUwYq|jD]\}} | durr|| ||||j|<q`||_dSr?) rc_applyrPrrZgradZ _grad_ivarrQrM) r<funcrr[rrr`rrZ param_appliedZ grad_appliedbufr$r$r%rCs(    z Layer._applyc CsD|dur|j}|dur|j}t|tjurt|}|jrOt|}t |j |dddd}t }||krL| t|}|n|}n|}|durz||jkrztjjj|jd|j|d} Wdn1stwYn|} |dur| j|s| ||} n| } |} | } | | |S)Nrg333333?)r )r[)r r[r|rr~rZ is_gpu_placerZ size_of_dtypenpprodrtgpu_memory_availableZ_copy_torrrr_clearZfluidrZ_dygraph_place_guardcastZ_equalsZ_share_data_with) r<r rr[rZ size_dtypeZwaiting_alloc_memoryrZt_usedZt_castedZnew_tZ dst_tensorZ src_tensorr$r$r% _transformXsF      zLayer._transformcs|dur|dur|durS|dur5t|trtj|}nt|tjtjtjtj fr,n t dt |j |dur.transformignore)category)rpr-rrZ_convert_to_placerrrrrrr|rAboolr catch_warningsfilterwarnings UserWarningrrM)r<rr[rrrr$r$r#r%rs:   zLayer._to_implcCs&t}|D] }||q|S)z Return starup program containing initialization operations of all parameters. NOTE(dev): This is a very low level API and only for inner developer. )rrZ_create_init_opZ global_block)r<Zstartup_programrr$r$r%_startup_programs zLayer._startup_program)NrE)NNFN)NNN)T)F)rnT)rnFN)NTrn)NTrnFT)NTrnT)NNNTF)8rArBrCrDr>rarbrdrhrlrmrs deprecatedrrrrcrr^rrrrrrrrrrrrrrrrrrrrrrrrrrrrZdeprecate_stat_dictrrrr"rr+Zset_dict load_dictr$r$r$r%rUs &*)%17 0  1 1  # % ' B 1$ *@1^ "  0 # "  V 63 = )?rN contextlibsysnumpyrrqreror6r rrrZpaddle.profilerrZpaddle.profiler.utilsrrnrrZ paddle.fluidrZlayer_object_helperr Z layer_hooksr r r baser rrrrZ param_attrrZpaddle.fluid.executorrrZpaddle.fluid.frameworkrrrrrrrZpaddle.fluid.corerZpaddle.fluid.dygraphrZpaddle.utils.deprecatedutilsr,__all__compilerr r&r4rr5rr$r$r$r%sH