diff --git a/python/paddle/fluid/dygraph/layers.py b/python/paddle/fluid/dygraph/layers.py index 88e24e7e1ea99f..3ae6d384be7e3e 100644 --- a/python/paddle/fluid/dygraph/layers.py +++ b/python/paddle/fluid/dygraph/layers.py @@ -62,10 +62,6 @@ def remove(self): class Layer(core.Layer): """ - :alias_main: paddle.nn.Layer - :alias: paddle.nn.Layer - :old_api: paddle.fluid.dygraph.layers.Layer - Dynamic graph Layer based on OOD, includes the parameters of the layer, the structure of the forward graph and so on. Parameters: @@ -74,16 +70,16 @@ class Layer(core.Layer): 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 or core.VarDesc.VarType, optional): data type of this parameter. + 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: ``core.VarDesc.VarType.FP32`` + Default: "float32" Returns: None """ - def __init__(self, name_scope=None, dtype=core.VarDesc.VarType.FP32): + def __init__(self, name_scope=None, dtype="float32"): self.training = True if name_scope is None: name_scope = _convert_camel_to_snake(self.__class__.__name__) @@ -110,6 +106,30 @@ def train(self): 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) + """ # global setting framework._dygraph_tracer().train_mode() @@ -125,6 +145,29 @@ def eval(self): 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) + """ # global setting framework._dygraph_tracer().eval_mode() @@ -149,15 +192,13 @@ def apply(self, fn): import paddle import paddle.nn as nn - - paddle.disable_static() - + 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.fill_constant(layer.weight.shape, layer.weight.dtype, value=0.9) + 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()) @@ -177,6 +218,23 @@ def full_name(self): 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 + """ return self._full_name @@ -197,34 +255,33 @@ def register_forward_post_hook(self, hook): Examples: .. code-block:: python - import paddle.fluid as fluid - import numpy as np + 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 - # 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 - # change the output - return output * 2 + linear = paddle.nn.Linear(13, 5) - with fluid.dygraph.guard(): - linear = fluid.Linear(13, 5, dtype="float32") + # register the hook + forward_post_hook_handle = linear.register_forward_post_hook(forward_post_hook) - # 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 = fluid.dygraph.to_variable(value1) - - out0 = linear(in1) - - # remove the hook - forward_post_hook_handle.remove() + value1 = np.arange(26).reshape(2, 13).astype("float32") + in1 = paddle.to_tensor(value1) - out1 = linear(in1) + out0 = 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() + # 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() """ hook_remove_helper = HookRemoveHelper(self._forward_post_hooks) self._forward_post_hooks[hook_remove_helper._hook_id] = hook @@ -249,36 +306,35 @@ def register_forward_pre_hook(self, hook): Examples: .. code-block:: python - import paddle.fluid as fluid - import numpy as np + import paddle + import numpy as np - # the forward_post_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 + # the forward_post_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 + # change the input + input_return = (input[0] * 2) + return input_return - with fluid.dygraph.guard(): - linear = fluid.Linear(13, 5, dtype="float32") + linear = paddle.nn.Linear(13, 5) - # register the hook - forward_pre_hook_handle = linear.register_forward_pre_hook(forward_pre_hook) + # 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 = fluid.dygraph.to_variable(value0) - out0 = linear(in0) + 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() + # remove the hook + forward_pre_hook_handle.remove() - value1 = value0 * 2 - in1 = fluid.dygraph.to_variable(value1) - out1 = linear(in1) + 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() + # hook change the linear's input to input * 2, so out0 is equal to out1. + assert (out0.numpy() == out1.numpy()).any() """ hook_remove_helper = HookRemoveHelper(self._forward_pre_hooks) self._forward_pre_hooks[hook_remove_helper._hook_id] = hook @@ -294,17 +350,37 @@ def create_parameter(self, Parameters: shape(list): Shape of the parameter. - attr(ParamAttr, optional): Parameter attribute of weight. Please refer to :ref:`api_fluid_ParamAttr`. Default: None. - dtype(str or core.VarDesc.VarType or str, optional): Data type of this 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 :ref:`api_fluid_initializer_XavierInitializer` and :ref:`api_fluid_initializer_ConstantInitializer` + 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: - :ref:`api_guide_Variable_en` : created parameter. + :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 + """ temp_attr = copy.deepcopy(attr) if isinstance(temp_attr, six.string_types) and temp_attr == "": @@ -313,24 +389,40 @@ def create_parameter(self, default_initializer) # TODO: Add more parameter list when we need them - def create_variable(self, - name=None, - persistable=None, - dtype=None, - type=core.VarDesc.VarType.LOD_TENSOR): + def create_variable(self, name=None, persistable=None, dtype=None): """Create Variable for this layer. Parameters: name(str, optional): name of the variable. Please refer to :ref:`api_guide_Name` . Default: None persistable(bool, optional): if set this variable persistable. Default: False - dtype(str or core.VarDesc.VarType, optional): data type of this parameter. + 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 ``core.VarDesc.VarType.FP32``. Default: None - type(core.VarDesc.VarType, optional): type of the variable. No need to set this parameter. Default: ``core.VarDesc.VarType.LOD_TENSOR`` + If set None, it will be "float32". Default: None Returns: - :ref:`api_guide_Variable_en` : created Variable. + Tensor, created Variable. + + 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 + """ if name is not None: var_name = ".".join([self._full_name, name]) @@ -339,7 +431,10 @@ def create_variable(self, [self._full_name, "_generated_var"])) return self._helper.main_program.current_block().create_var( - name=var_name, persistable=persistable, dtype=dtype, type=type) + name=var_name, + persistable=persistable, + dtype=dtype, + type=core.VarDesc.VarType.LOD_TENSOR) def parameters(self, include_sublayers=True): """Returns a list of all Parameters from current layer and its sub-layers. @@ -348,7 +443,16 @@ def parameters(self, include_sublayers=True): include_sublayers(bool, optional): Whether include the parameters of sublayers. If True, also include the parameters from sublayers. Default: True Returns: - list of :ref:`api_guide_Variable_en` : a list of Parameters. + 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 + """ ret = [ param @@ -366,16 +470,15 @@ def children(self): Examples: .. code-block:: python - import paddle.fluid as fluid + import paddle - with fluid.dygraph.guard(): - fc1 = fluid.Linear(10, 3) - fc2 = fluid.Linear(3, 10, bias_attr=False) - model = fluid.dygraph.Sequential(fc1, fc2) - - layer_list = list(model.children()) + 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) + print(layer_list) # [, ] """ for _, layer in self.named_children(): @@ -391,14 +494,15 @@ def named_children(self): Examples: .. code-block:: python - import paddle.fluid as fluid + import paddle - with fluid.dygraph.guard(): - fc1 = fluid.Linear(10, 3) - fc2 = fluid.Linear(3, 10, bias_attr=False) - model = fluid.dygraph.Sequential(fc1, fc2) - for prefix, layer in model.named_children(): - print(prefix, layer) + 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', ) """ memo = set() @@ -415,6 +519,26 @@ def sublayers(self, include_sublayers=True): 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()) # [, ] + """ ret = [ layer @@ -438,14 +562,13 @@ def named_parameters(self, prefix='', include_sublayers=True): Examples: .. code-block:: python - import paddle.fluid as fluid + import paddle - with fluid.dygraph.guard(): - fc1 = fluid.Linear(10, 3) - fc2 = fluid.Linear(3, 10, bias_attr=False) - model = fluid.dygraph.Sequential(fc1, fc2) - for name, param in model.named_parameters(): - print(name, param) + 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) """ params_set = set() @@ -483,14 +606,13 @@ def named_sublayers(self, Examples: .. code-block:: python - import paddle.fluid as fluid + import paddle - with fluid.dygraph.guard(): - fc1 = fluid.Linear(10, 3) - fc2 = fluid.Linear(3, 10, bias_attr=False) - model = fluid.dygraph.Sequential(fc1, fc2) - for prefix, layer in model.named_sublayers(): - print(prefix, layer) + 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) """ if layers_set is None: @@ -510,11 +632,11 @@ def named_sublayers(self, layers_set=layers_set): yield p, l - def register_buffer(self, name, variable, persistable=True): + def register_buffer(self, name, tensor, persistable=True): """ - Registers a variable as buffer into the layer. + Registers a tensor as buffer into the layer. - `buffer` is a non-parameteric variable and will not be updated by optimizer, + `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 @@ -525,7 +647,7 @@ def register_buffer(self, name, variable, persistable=True): Parameters: name (string): name of the buffer. The buffer can be accessed from this layer using the given name - variable (Variable): the variable to be registered as buffer. + tensor (Tensor): the tensor to be registered as buffer. persistable (bool): whether the buffer is part of this layer's state_dict. @@ -536,16 +658,15 @@ def register_buffer(self, name, variable, persistable=True): .. code-block:: python import numpy as np - import paddle.fluid as fluid + import paddle - with fluid.dygraph.guard(): - linear = fluid.Linear(10, 3) - value = np.array([0]).astype("float32") - buffer = fluid.dygraph.to_variable(value) - linear.register_buffer("buf_name", buffer, persistable=True) - - # get the buffer by attribute. - print(linear.buf_name) + 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) """ @@ -565,12 +686,12 @@ def register_buffer(self, name, variable, persistable=True): raise KeyError("The name of buffer can not be empty.") elif hasattr(self, name) and name not in self._buffers: raise KeyError("attribute '{}' already exists.".format(name)) - elif variable is not None and not type(variable) == core.VarBase: + elif tensor is not None and not type(tensor) == core.VarBase: raise TypeError( "The registered buffer should be a core.VarBase, but received {}.". - format(type(variable).__name__)) + format(type(tensor).__name__)) else: - self._buffers[name] = variable + self._buffers[name] = tensor if persistable: self._non_persistable_buffer_names_set.discard(name) else: @@ -584,7 +705,21 @@ def buffers(self, include_sublayers=True): include_sublayers(bool, optional): Whether include the buffers of sublayers. If True, also include the buffers from sublayers. Default: True Returns: - list of :ref:`api_guide_Variable_en` : a list of buffers. + 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]) + """ ret = [ buffer @@ -595,7 +730,7 @@ def buffers(self, include_sublayers=True): def named_buffers(self, prefix='', include_sublayers=True): """ - Returns an iterator over all buffers in the Layer, yielding tuple of name and Variable. + 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: ''. @@ -603,31 +738,30 @@ def named_buffers(self, prefix='', include_sublayers=True): If True, also include the named buffers from sublayers. Default: True. Yields: - (string, Variable): Tuple of name and Variable + (string, Tensor): Tuple of name and tensor Examples: .. code-block:: python import numpy as np - import paddle.fluid as fluid + import paddle - with fluid.dygraph.guard(): - fc1 = fluid.Linear(10, 3) - buffer1 = fluid.dygraph.to_variable(np.array([0]).astype("float32")) - # register a variable as buffer by specific `persistable` - fc1.register_buffer("buf_name_1", buffer1, persistable=True) + 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 = fluid.Linear(3, 10) - buffer2 = fluid.dygraph.to_variable(np.array([1]).astype("float32")) - # register a buffer by assigning an attribute with Variable. - # The `persistable` can only be False by this way. - fc2.buf_name_2 = buffer2 + 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 = fluid.dygraph.Sequential(fc1, fc2) + model = paddle.nn.Sequential(fc1, fc2) - # get all named buffers - for name, buffer in model.named_buffers(): - print(name, buffer) + # get all named buffers + for name, buffer in model.named_buffers(): + print(name, buffer) """ buffers_set = set() @@ -654,19 +788,18 @@ def clear_gradients(self): Examples: .. code-block:: python - import paddle.fluid as fluid + import paddle import numpy as np - with fluid.dygraph.guard(): - value = np.arange(26).reshape(2, 13).astype("float32") - a = fluid.dygraph.to_variable(value) - linear = fluid.Linear(13, 5, dtype="float32") - adam = fluid.optimizer.Adam(learning_rate=0.01, - parameter_list=linear.parameters()) - out = linear(a) - out.backward() - adam.minimize(out) - linear.clear_gradients() + 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() """ for p in self.parameters(): @@ -726,6 +859,32 @@ def add_sublayer(self, name, 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) """ assert isinstance(sublayer, core.Layer) @@ -742,6 +901,25 @@ def add_parameter(self, name, parameter): 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 + """ if '_parameters' not in self.__dict__: raise RuntimeError( @@ -871,24 +1049,23 @@ def __dir__(self): Return a list. Get all parameters, buffers(non-parameter variables), sublayers, method and attr of Layer. Examples: - import paddle.fluid as fluid - import numpy as np - - fluid.dygraph.enable_dygraph() + .. code-block:: python + import paddle + import numpy as np - class Mylayer(fluid.dygraph.Layer): - def __init__(self): - super(Mylayer, self).__init__() - self.linear1 = fluid.dygraph.Linear(10, 10) - self.linear2 = fluid.dygraph.Linear(5, 5) - self.conv2d = fluid.dygraph.Conv2D(3, 2, 3) - self.embedding = fluid.dygraph.Embedding(size=[128, 16]) - self.h_0 = fluid.dygraph.to_variable(np.zeros([10, 10]).astype('float32')) + 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'] + 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'] """ method = dir(self.__class__) @@ -918,12 +1095,12 @@ def state_dict(self, Examples: .. code-block:: python - import paddle.fluid as fluid - with fluid.dygraph.guard(): - emb = fluid.dygraph.Embedding([10, 10]) + import paddle - state_dict = emb.state_dict() - fluid.save_dygraph( state_dict, "paddle_dy") + emb = paddle.nn.Embedding(10, 10) + + state_dict = emb.state_dict() + paddle.save( state_dict, "paddle_dy.pdparams") ''' @@ -967,16 +1144,12 @@ def set_state_dict(self, .. code-block:: python import paddle - - paddle.disable_static() - + 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) '''