PaddlePaddle
diff --git a/‎python/paddle/nn/layer/pooling.py
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎python/paddle/nn/layer/pooling.py
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎python/paddle/nn/layer/rnn.py
Copy file name to clipboard
+25-25Lines changed: 25 additions & 25 deletions b/‎python/paddle/nn/layer/rnn.py
Copy file name to clipboard
+25-25Lines changed: 25 additions & 25 deletions
diff --git a/‎python/paddle/nn/layer/vision.py
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions b/‎python/paddle/nn/layer/vision.py
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions
diff --git a/‎python/paddle/nn/quant/lsq.py
Copy file name to clipboard
+6-6Lines changed: 6 additions & 6 deletions b/‎python/paddle/nn/quant/lsq.py
Copy file name to clipboard
+6-6Lines changed: 6 additions & 6 deletions
diff --git a/‎python/paddle/nn/quant/quant_layers.py
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions b/‎python/paddle/nn/quant/quant_layers.py
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions
diff --git a/‎python/paddle/nn/utils/weight_norm_hook.py
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎python/paddle/nn/utils/weight_norm_hook.py
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎python/paddle/optimizer/adagrad.py
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions b/‎python/paddle/optimizer/adagrad.py
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions
@@ -1481,7 +1481,7 @@ class FractionalMaxPool2D(Layer):
 
             >>> x = paddle.rand([2, 3, 32, 32])
 
-            >>> # disjont: without `kernel_size`
+            >>> # disjoint: without `kernel_size`
             >>> fractional_max_pool = paddle.nn.FractionalMaxPool2D(output_size=3)
             >>> pool_out = fractional_max_pool(x=x)
             >>> print(pool_out.shape)
@@ -1597,7 +1597,7 @@ class FractionalMaxPool3D(Layer):
 
             >>> x = paddle.rand([2, 3, 8, 32, 32])
 
-            >>> # disjont: without `kernel_size`
+            >>> # disjoint: without `kernel_size`
             >>> fractional_max_pool = paddle.nn.FractionalMaxPool3D(output_size=3)
             >>> pool_out = fractional_max_pool(x=x)
             >>> print(pool_out.shape)
 
@@ -79,12 +79,12 @@ def rnn(
     Returns:
         outputs (Tensor|list|tuple): the output sequence. Tensor or nested
             structure of Tensors.
-            If `time_major` is True, the shape of each tensor in outpus is
+            If `time_major` is True, the shape of each tensor in outputs is
             `[time_steps, batch_size, hidden_size]`, else
             `[batch_size, time_steps, hidden_size]`.
         final_states (Tensor|list|tuple): final states. A (possibly nested structure of)
             tensor[s], representing the final state for RNN. It has the same
-            structure of intial state. Each tensor in final states has the same
+            structure of initial state. Each tensor in final states has the same
             shape and dtype as the corresponding tensor in initial states.
 
     Examples:
@@ -542,10 +542,10 @@ def concat_states(states, bidirectional=False, state_components=1):
         return paddle.stack(paddle.utils.flatten(states))
     else:
         states = paddle.utils.flatten(states)
-        componnets = []
+        components = []
         for i in range(state_components):
-            componnets.append(states[i::state_components])
-        return tuple([paddle.stack(item) for item in componnets])
+            components.append(states[i::state_components])
+        return tuple([paddle.stack(item) for item in components])
 
 
 class RNNCellBase(Layer):
@@ -666,31 +666,31 @@ def state_shape(self):
         r"""
         Abstract method (property).
         Used to initialize states.
-        A (possiblely nested structure of) shape[s], where a shape is a
+        A (possibly nested structure of) shape[s], where a shape is a
         list/tuple of integers (-1 for batch size would be automatically
         inserted into a shape if shape is not started with it).
         Not necessary to be implemented if states are not initialized by
         `get_initial_states` or the `shape` argument is provided when using
         `get_initial_states`.
         """
         raise NotImplementedError(
-            "Please add implementaion for `state_shape` in the used cell."
+            "Please add implementation for `state_shape` in the used cell."
         )
 
     @property
     def state_dtype(self):
         r"""
         Abstract method (property).
         Used to initialize states.
-        A (possiblely nested structure of) data types[s]. The structure must be
+        A (possibly nested structure of) data types[s]. The structure must be
         same as that of `shape`, except when all tensors' in states has the same
-        data type, a signle data type can be used.
+        data type, a single data type can be used.
         Not necessary to be implemented if states are not initialized
         by `get_initial_states` or the `dtype` argument is provided when using
         `get_initial_states`.
         """
         raise NotImplementedError(
-            "Please add implementaion for `state_dtype` in the used cell."
+            "Please add implementation for `state_dtype` in the used cell."
         )
 
 
@@ -895,7 +895,7 @@ class LSTMCell(RNNCellBase):
 
         y_{t} & = h_{t}
 
-    where :math:`\sigma` is the sigmoid fucntion, and * is the elemetwise
+    where :math:`\sigma` is the sigmoid function, and * is the elementwise
     multiplication operator.
 
     Please refer to `An Empirical Exploration of Recurrent Network Architectures
@@ -919,7 +919,7 @@ class LSTMCell(RNNCellBase):
         - **weight_ih** (Parameter): shape (4 * hidden_size, input_size), input to hidden weight, which corresponds to the concatenation of :math:`W_{ii}, W_{if}, W_{ig}, W_{io}` in the formula.
         - **weight_hh** (Parameter): shape (4 * hidden_size, hidden_size), hidden to hidden weight, which corresponds to the concatenation of :math:`W_{hi}, W_{hf}, W_{hg}, W_{ho}` in the formula.
         - **bias_ih** (Parameter): shape (4 * hidden_size, ), input to hidden bias, which corresponds to the concatenation of :math:`b_{ii}, b_{if}, b_{ig}, b_{io}` in the formula.
-        - **bias_hh** (Parameter): shape (4 * hidden_size, ), hidden to hidden bias, swhich corresponds to the concatenation of :math:`b_{hi}, b_{hf}, b_{hg}, b_{ho}` in the formula.
+        - **bias_hh** (Parameter): shape (4 * hidden_size, ), hidden to hidden bias, which corresponds to the concatenation of :math:`b_{hi}, b_{hf}, b_{hg}, b_{ho}` in the formula.
 
     Inputs:
         - **inputs** (Tensor): shape `[batch_size, input_size]`, the input, corresponding to :math:`x_t` in the formula.
@@ -1090,7 +1090,7 @@ class GRUCell(RNNCellBase):
 
         y_{t} & = h_{t}
 
-    where :math:`\sigma` is the sigmoid fucntion, and * is the elemetwise
+    where :math:`\sigma` is the sigmoid function, and * is the elementwise
     multiplication operator.
 
     Please refer to `An Empirical Exploration of Recurrent Network Architectures
@@ -1114,7 +1114,7 @@ class GRUCell(RNNCellBase):
         - **weight_ih** (Parameter): shape (3 * hidden_size, input_size), input to hidden weight, which corresponds to the concatenation of :math:`W_{ir}, W_{iz}, W_{ic}` in the formula.
         - **weight_hh** (Parameter): shape (3 * hidden_size, hidden_size), hidden to hidden weight, which corresponds to the concatenation of :math:`W_{hr}, W_{hz}, W_{hc}` in the formula.
         - **bias_ih** (Parameter): shape (3 * hidden_size, ), input to hidden bias, which corresponds to the concatenation of :math:`b_{ir}, b_{iz}, b_{ic}` in the formula.
-        - **bias_hh** (Parameter): shape (3 * hidden_size, ), hidden to hidden bias, swhich corresponds to the concatenation of :math:`b_{hr}, b_{hz}, b_{hc}` in the formula.
+        - **bias_hh** (Parameter): shape (3 * hidden_size, ), hidden to hidden bias, which corresponds to the concatenation of :math:`b_{hr}, b_{hz}, b_{hc}` in the formula.
 
     Inputs:
         - **inputs** (Tensor): A tensor with shape `[batch_size, input_size]`, corresponding to :math:`x_t` in the formula.
@@ -1287,7 +1287,7 @@ class RNN(Layer):
 
     Outputs:
         - **outputs** (Tensor|list|tuple): the output sequences. If `time_major` is True, the shape is `[time_steps, batch_size, hidden_size]`, else `[batch_size, time_steps, hidden_size]`.
-        - **final_states** (Tensor|list|tuple): final states of the cell. Tensor or a possibly nested structure of tensors which has the same structure with intial state. Each tensor in final states has the same shape and dtype as the corresponding tensor in initial states.
+        - **final_states** (Tensor|list|tuple): final states of the cell. Tensor or a possibly nested structure of tensors which has the same structure with initial state. Each tensor in final states has the same shape and dtype as the corresponding tensor in initial states.
 
     Notes:
         This class is a low-level API for wrapping rnn cell into a RNN network.
@@ -1341,9 +1341,9 @@ def forward(
 
 class BiRNN(Layer):
     r"""
-    Wrapper for bidirectional RNN, which builds a bidiretional RNN given the
+    Wrapper for bidirectional RNN, which builds a bidirectional RNN given the
     forward rnn cell and backward rnn cell. A BiRNN applies forward RNN and
-    backward RNN with coresponding cells separately and concats the outputs
+    backward RNN with corresponding cells separately and concats the outputs
     along the last axis.
 
     Parameters:
@@ -1536,7 +1536,7 @@ def flatten_parameters(self):
                 )
                 layer_idx = i // 4
                 self._all_weights[offset + layer_idx * 2 + i % 2] = param
-            # Wrap using a list to avoid registed into params and saving, maybe
+            # Wrap using a list to avoid registered into params and saving, maybe
             # need a better way to handle this later. Use `create_parameter` to
             # add both to main_program and startup_program for static-graph.
             # Use Constant initializer to avoid make effect on random generator.
@@ -1748,7 +1748,7 @@ class SimpleRNN(RNNBase):
             means the time steps. If time_major is True, the shape of Tensor is
             [time_steps,batch_size,input_size], otherwise [batch_size, time_steps,input_size].
             Defaults to False. `time_steps` means the length of input sequence.
-        dropout (float, optional): The droput probability. Dropout is applied
+        dropout (float, optional): The dropout probability. Dropout is applied
             to the input of each layer except for the first layer. The range of
             dropout from 0 to 1. Defaults to 0.
         activation (str, optional): The activation in each SimpleRNN cell. It can be
@@ -1865,7 +1865,7 @@ class LSTM(RNNBase):
 
         y_{t} & = h_{t}
 
-    where :math:`\sigma` is the sigmoid fucntion, and * is the elemetwise
+    where :math:`\sigma` is the sigmoid function, and * is the elementwise
     multiplication operator.
 
     Using key word arguments to construct is recommended.
@@ -1881,7 +1881,7 @@ class LSTM(RNNBase):
             means the time steps. If time_major is True, the shape of Tensor is
             [time_steps,batch_size,input_size], otherwise [batch_size, time_steps,input_size].
             Defaults to False. `time_steps` means the length of input sequence.
-        dropout (float, optional): The droput probability. Dropout is applied
+        dropout (float, optional): The dropout probability. Dropout is applied
             to the input of each layer except for the first layer. The range of
             dropout from 0 to 1. Defaults to 0.
         weight_ih_attr (ParamAttr, optional): The parameter attribute for
@@ -1910,7 +1910,7 @@ class LSTM(RNNBase):
         - **weight_ih_l[k]**: the learnable input-hidden weights of the k-th layer. If `k = 0`, the shape is `[hidden_size, input_size]`. Otherwise, the shape is `[hidden_size, num_directions * hidden_size]`.
         - **weight_hh_l[k]**: the learnable hidden-hidden weights of the k-th layer, with shape `[hidden_size, hidden_size]`.
         - **bias_ih_l[k]**: the learnable input-hidden bias of the k-th layer, with shape `[hidden_size]`.
-        - **bias_hh_l[k]**: the learnable hidden-hidden bias of the k-th layer, swith shape `[hidden_size]`.
+        - **bias_hh_l[k]**: the learnable hidden-hidden bias of the k-th layer, with shape `[hidden_size]`.
 
     Examples:
 
@@ -1966,7 +1966,7 @@ def __init__(
 
 class GRU(RNNBase):
     r"""
-    Multilayer GRU. It takes input sequencse and initial states as inputs, and
+    Multilayer GRU. It takes input sequence and initial states as inputs, and
     returns the output sequences and the final states.
 
     Each layer inside the GRU maps the input sequences and initial states
@@ -1987,7 +1987,7 @@ class GRU(RNNBase):
 
         y_{t} & = h_{t}
 
-    where :math:`\sigma` is the sigmoid fucntion, and * is the elemetwise
+    where :math:`\sigma` is the sigmoid function, and * is the elementwise
     multiplication operator.
 
     Using key word arguments to construct is recommended.
@@ -2003,7 +2003,7 @@ class GRU(RNNBase):
             means the time steps. If time_major is True, the shape of Tensor is
             [time_steps,batch_size,input_size], otherwise [batch_size, time_steps,input_size].
             Defaults to False. `time_steps` means the length of input sequence.
-        dropout (float, optional): The droput probability. Dropout is applied
+        dropout (float, optional): The dropout probability. Dropout is applied
             to the input of each layer except for the first layer. The range of
             dropout from 0 to 1. Defaults to 0.
         weight_ih_attr (ParamAttr, optional): The parameter attribute for
 
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# TODO: define specitial functions used in computer vision task
+# TODO: define special functions used in computer vision task
 
 from .. import functional
 from .layers import Layer
@@ -66,7 +66,7 @@ def __init__(self, upscale_factor, data_format="NCHW", name=None):
         if data_format not in ["NCHW", "NHWC"]:
             raise ValueError(
                 "Data format should be 'NCHW' or 'NHWC'."
-                f"But recevie data format: {data_format}"
+                f"But receive data format: {data_format}"
             )
 
         self._upscale_factor = upscale_factor
@@ -132,7 +132,7 @@ def __init__(self, downscale_factor, data_format="NCHW", name=None):
         if data_format not in ["NCHW", "NHWC"]:
             raise ValueError(
                 "Data format should be 'NCHW' or 'NHWC'."
-                f"But recevie data format: {data_format}"
+                f"But receive data format: {data_format}"
             )
 
         self._downscale_factor = downscale_factor
@@ -211,7 +211,7 @@ def __init__(self, groups, data_format="NCHW", name=None):
         if data_format not in ["NCHW", "NHWC"]:
             raise ValueError(
                 "Data format should be 'NCHW' or 'NHWC'."
-                f"But recevie data format: {data_format}"
+                f"But receive data format: {data_format}"
             )
 
         self._groups = groups
 
@@ -139,7 +139,7 @@ class FakeQuantActLSQPlus(Layer):
     def __init__(
         self,
         quant_bits,
-        all_postive=False,
+        all_positive=False,
         symmetric=False,
         batch_init=20,
         dtype='float32',
@@ -150,15 +150,15 @@ def __init__(
         '''
         Args:
             quant_bits(int): quantization bit number for weights.
-            all_postive(bool): whether unsigned or signed quantization, where True for unsigned quantization and False for signed quantization.
+            all_positive(bool): whether unsigned or signed quantization, where True for unsigned quantization and False for signed quantization.
             symmetric(bool): whether symmetric or asymmetric quantization.
             batch_init(int): number of batches that collect Gaussian approximation for the weight distribution in each layer.
             dtype(str): data type.
             name(str): the name of the weight.
             reduce_type(str): the reduce type which is needed when parallel training.
         '''
         self.bits = quant_bits
-        self.all_positive = all_postive
+        self.all_positive = all_positive
         self.symmetric = symmetric
         self.batch_init = batch_init
         self.name = name
@@ -246,7 +246,7 @@ class FakeQuantWeightLSQPlus(Layer):
     def __init__(
         self,
         quant_bits,
-        all_postive=False,
+        all_positive=False,
         per_channel=False,
         batch_init=20,
         channel_num=None,
@@ -259,7 +259,7 @@ def __init__(
         '''
         Args:
             quant_bits(int): quantization bit number for weights.
-            all_postive(bool): whether unsigned or signed quantization, where True for unsigned quantization and False for signed quantization.
+            all_positive(bool): whether unsigned or signed quantization, where True for unsigned quantization and False for signed quantization.
             per_channel(bool): whether layer-wise or channel-wise quantization, where True for layer-wise quantization and False for channel-wise quantization.
             batch_init(int): number of batches that collect Gaussian approximation for the weight distribution in each layer.
             channel_num(int): the channel number of the weight which is needed when per_channel is True.
@@ -270,7 +270,7 @@ def __init__(
         '''
 
         self.bits = quant_bits
-        self.all_positive = all_postive
+        self.all_positive = all_positive
         self.per_channel = per_channel
         self.quant_linear = quant_linear
         self.batch_init = batch_init
 
@@ -1147,13 +1147,13 @@ def _get_fake_quant_type(quant_type, **kwargs):
             "when you use channel_wise_abs_max strategy."
         )
     elif quant_type == 'lsq_weight':
-        call_args["all_postive"] = kwargs.get("all_postive", False)
+        call_args["all_positive"] = kwargs.get("all_positive", False)
         call_args["per_channel"] = False
         call_args["channel_num"] = 1
         call_args["quant_linear"] = kwargs.get("quant_linear", False)
     elif quant_type == 'channel_wise_lsq_weight':
         quant_type = 'lsq_weight'
-        call_args["all_postive"] = kwargs.get("all_postive", False)
+        call_args["all_positive"] = kwargs.get("all_positive", False)
         call_args["per_channel"] = True
         call_args["channel_num"] = kwargs.get("channel_num", None)
         call_args["quant_linear"] = kwargs.get("quant_linear", False)
@@ -1162,7 +1162,7 @@ def _get_fake_quant_type(quant_type, **kwargs):
             "when you use channel_wise_abs_max strategy."
         )
     elif quant_type == 'lsq_act':
-        call_args["all_postive"] = kwargs.get("all_postive", False)
+        call_args["all_positive"] = kwargs.get("all_positive", False)
         call_args["symmetric"] = kwargs.get("symmetric", True)
     fake_quant_map = {
         'abs_max': FakeQuantAbsMax,
 
@@ -119,7 +119,7 @@ def apply(layer, name, dim):
         if dim is None:
             dim = -1
 
-        # support dim is negative numeber, (dim = -1) == (dim = None)
+        # support dim is negative number, (dim = -1) == (dim = None)
         weight_dim = len(layer._parameters[name].shape)
         assert (
             dim < weight_dim and dim >= -1 * weight_dim
 
@@ -47,7 +47,7 @@ class Adagrad(Optimizer):
         parameters (list|tuple, optional): List/Tuple of ``Tensor`` to update to minimize ``loss``.
             This parameter is required in dygraph mode. And you can specify different options for
             different parameter groups such as the learning rate, weight decay, etc,
-            then the parameters are list of dict. Note that the learning_rate in paramter groups
+            then the parameters are list of dict. Note that the learning_rate in parameter groups
             represents the scale of base learning_rate.
             The default value is None in static graph mode, at this time all parameters will be updated.
         weight_decay (float|WeightDecayRegularizer, optional): The strategy of regularization.
@@ -57,8 +57,8 @@ class Adagrad(Optimizer):
             the regularization setting here in optimizer will be ignored for this parameter.
             Otherwise, the regularization setting here in optimizer will take effect.
             Default None, meaning there is no regularization.
-        grad_clip (GradientClipBase, optional): Gradient cliping strategy, it's an instance of
-            some derived class of ``GradientClipBase`` . There are three cliping strategies,
+        grad_clip (GradientClipBase, optional): Gradient clipping strategy, it's an instance of
+            some derived class of ``GradientClipBase`` . There are three clipping strategies,
             ClipGradByGlobalNorm, ClipGradByNorm and ClipGradByValue. Default None,
             meaning there is no gradient clipping.
         name (str, optional): Normally there is no need for user to set this property.