Fix _is_list_or_turple_ _is_list_or_tuple_ (#60857)

co63oc · web-flow · commit e6e8b607025a · 2024-01-17T16:12:13.000+08:00
diff --git a/python/paddle/hapi/dynamic_flops.py b/python/paddle/hapi/dynamic_flops.py
@@ -75,7 +75,7 @@ def flops(net, input_size, custom_ops=None, print_detail=False):
             ...         return x
             ...
             >>> lenet = LeNet()
-            >>> # m is the instance of nn.Layer, x is the intput of layer, y is the output of layer.
+            >>> # m is the instance of nn.Layer, x is the input of layer, y is the output of layer.
             >>> def count_leaky_relu(m, x, y):
             ...     x = x[0]
             ...     nelements = x.numel()
diff --git a/python/paddle/jit/dy2static/export_subgraph.py b/python/paddle/jit/dy2static/export_subgraph.py
@@ -99,10 +99,10 @@ def verify_saving_dir(self, dir_path):
         if not os.path.exists(dir_path):
             os.makedirs(dir_path)
 
-    def insert_feed_op(self, intputs, rename_prefix):
+    def insert_feed_op(self, inputs, rename_prefix):
         global_block = self.program.block(0)
-        intputs.sort()
-        for i, old_name in enumerate(intputs):
+        inputs.sort()
+        for i, old_name in enumerate(inputs):
             new_name = rename_prefix + str(i)
             global_block._rename_var(old_name, new_name)
             out = global_block.var(new_name)
diff --git a/python/paddle/nn/functional/common.py b/python/paddle/nn/functional/common.py
@@ -72,7 +72,7 @@ def unfold(x, kernel_sizes, strides=1, paddings=0, dilations=1, name=None):
         kernel_sizes(int|list|tuple):   The size of convolution kernel, should be [k_h, k_w]
                                   or an integer k treated as [k, k].
         strides(int|list|tuple, optional):        The strides, should be [stride_h, stride_w]
-                                  or an integer stride treated as [sride, stride].
+                                  or an integer stride treated as [stride, stride].
                                   For default, strides will be [1, 1].
         paddings(int|list|tuple, optional):       The paddings of each dimension, should be
                                   [padding_top, padding_left, padding_bottom, padding_right]
@@ -91,7 +91,7 @@ def unfold(x, kernel_sizes, strides=1, paddings=0, dilations=1, name=None):
 
     Returns:
         Tensor, The tensor corresponding to the sliding local blocks.
-        The output shape is [N, Cout, Lout] as decriabled above.
+        The output shape is [N, Cout, Lout] as described above.
         Cout is the  total number of values within each block,
         and Lout is the total number of such blocks.
         The data type of output is the same as the input :math:`x`
@@ -193,7 +193,7 @@ def interpolate(
     or 4-D (num_batches, channels, in_h, in_w), or a 5-D Tensor of the shape
     (num_batches, channels, in_d, in_h, in_w) or (num_batches, in_d, in_h, in_w, channels),
     Where in_w is width of the input tensor, in_h is the height of the input tensor,
-    in_d is the depth of the intput tensor.
+    in_d is the depth of the input tensor.
     and the resizing only applies on the three dimensions(depth, height and width).
 
     Supporting resample methods:
@@ -340,7 +340,7 @@ def interpolate(
                                corner pixels.This only has an effect when 'linear', 'bilinear', 'bicubic' or 'trilinear'.
                                Default: False
         align_mode(int)  :  An optional for linear/bilinear/trilinear interpolation. Refer to the formula in the example above,
-                            it can be \'0\' for src_idx = scale_factor*(dst_indx+0.5)-0.5 , can be \'1\' for
+                            it can be \'0\' for src_idx = scale_factor*(dst_index+0.5)-0.5 , can be \'1\' for
                             src_idx = scale_factor*dst_index.
         data_format (str, optional): Specify the data format of the input, and the data format of the output
             will be consistent with that of the input. An optional string from:`NCW`, `NWC`,  `"NCHW"`, `"NHWC"`, `"NCDHW"`,
@@ -466,7 +466,7 @@ def interpolate(
             + " received but only `NCDHW` or `NDHWC` supported for 5-D input."
         )
 
-    def _is_list_or_turple_(data):
+    def _is_list_or_tuple_(data):
         return isinstance(data, (list, tuple))
 
     if data_format == 'NCHW' or data_format == 'NCDHW' or data_format == 'NCW':
@@ -509,7 +509,7 @@ def _is_list_or_turple_(data):
                 for i, dim in enumerate(out_shape):
                     if isinstance(dim, Variable):
                         out_shape[i] = dim.item()
-            if not (_is_list_or_turple_(out_shape)):
+            if not (_is_list_or_tuple_(out_shape)):
                 raise TypeError("size should be a list or tuple or Variable.")
             # Validate the shape
             contain_var = False
@@ -730,7 +730,7 @@ def upsample(
     or 4-D (num_batches, channels, in_h, in_w), or a 5-D Tensor of the shape
     (num_batches, channels, in_d, in_h, in_w) or (num_batches, in_d, in_h, in_w, channels),
     Where in_w is width of the input tensor, in_h is the height of the input tensor,
-    in_d is the depth of the intput tensor.
+    in_d is the depth of the input tensor.
     and the resizing only applies on the three dimensions(depth, height and width).
 
     Supporting resample methods:
@@ -877,7 +877,7 @@ def upsample(
                                corner pixels.
                                Default: False
         align_mode(int, optional)  :  An optional for linear/bilinear/trilinear interpolation. Refer to the formula in the example above,
-                            it can be \'0\' for src_idx = scale_factor*(dst_indx+0.5)-0.5 , can be \'1\' for
+                            it can be \'0\' for src_idx = scale_factor*(dst_index+0.5)-0.5 , can be \'1\' for
                             src_idx = scale_factor*dst_index.
         data_format (str, optional): Specify the data format of the input, and the data format of the output
             will be consistent with that of the input. An optional string from:`NCW`, `NWC`, `"NCHW"`, `"NHWC"`, `"NCDHW"`,
@@ -1713,7 +1713,7 @@ def pad(x, pad, mode='constant', value=0.0, data_format="NCHW", name=None):
         3,
         4,
         5,
-    ], f"input tesor dimension must be in [3, 4, 5] but got {x_dim}"
+    ], f"input tensor dimension must be in [3, 4, 5] but got {x_dim}"
 
     supported_format_map = {
         3: ["NCL", "NLC"],
@@ -2304,11 +2304,11 @@ def fold(
         x(Tensor):                3-D Tensor, input tensor of format [N, C, L],
                                   data type can be float32, float64, complex64 or complex128
         output_sizes(int|list|tuple):       The size of output size, should be [output_size_h, output_size_w]
-                                  or an interger o treated as [o, o].
+                                  or an integer o treated as [o, o].
         kernel_sizes(int|list|tuple):   The size of convolution kernel, should be [k_h, k_w]
                                   or an integer k treated as [k, k].
         strides(int|list|tuple, optional):        The strides, should be [stride_h, stride_w]
-                                  or an integer stride treated as [sride, stride].
+                                  or an integer stride treated as [stride, stride].
                                   For default, strides will be [1, 1].
         paddings(int|list|tuple, optional):       The paddings of each dimension, should be
                                   [padding_top, padding_left, padding_bottom, padding_right]
@@ -2327,7 +2327,7 @@ def fold(
 
     Returns:
         The tensor formed by combining a group of sliding local blocks
-        The output shape is [N, Cout, H, W] as decriabled above.
+        The output shape is [N, Cout, H, W] as described above.
 
     Examples:
 
@@ -2353,34 +2353,34 @@ def fold(
 
     assert len(x.shape) == 3, "input should be the format of [N, C, L]"
 
-    def _is_list_or_turple_(data):
+    def _is_list_or_tuple_(data):
         return isinstance(data, (list, tuple))
 
     if isinstance(output_sizes, int):
         output_sizes = [output_sizes, output_sizes]
     else:
-        assert _is_list_or_turple_(output_sizes) and (
+        assert _is_list_or_tuple_(output_sizes) and (
             len(output_sizes) == 2
         ), "output_sizes should either be an integer or a list/tuple of two integers"
 
     if isinstance(kernel_sizes, int):
         kernel_sizes = [kernel_sizes, kernel_sizes]
     else:
-        assert _is_list_or_turple_(kernel_sizes) and (
+        assert _is_list_or_tuple_(kernel_sizes) and (
             len(kernel_sizes) == 2
         ), "kernel_sizes should either be an integer or a list/tuple of two integers"
 
     if isinstance(strides, int):
         strides = [strides, strides]
     else:
-        assert _is_list_or_turple_(strides) and (
+        assert _is_list_or_tuple_(strides) and (
             len(strides) == 2
         ), "strides should either be an integer or a list/tuple of two integers"
 
     if isinstance(dilations, int):
         dilations = [dilations, dilations]
     else:
-        assert _is_list_or_turple_(dilations) and (
+        assert _is_list_or_tuple_(dilations) and (
             len(dilations) == 2
         ), "dilations should either be an integer or a list/tuple of two integers"
 
diff --git a/python/paddle/nn/layer/common.py b/python/paddle/nn/layer/common.py
@@ -202,7 +202,7 @@ class Upsample(Layer):
     or 4-D (num_batches, channels, in_h, in_w), or a 5-D Tensor of the shape
     (num_batches, channels, in_d, in_h, in_w) or (num_batches, in_d, in_h, in_w, channels),
     Where in_w is width of the input tensor, in_h is the height of the input tensor,
-    in_d is the depth of the intput tensor.
+    in_d is the depth of the input tensor.
     and the resizing only applies on the three dimensions(depth, height and width).
 
     Supporting resample methods:
diff --git a/python/paddle/static/nn/common.py b/python/paddle/static/nn/common.py
@@ -708,7 +708,7 @@ def group_norm(
         ['float16', 'uint16', 'float32', 'float64'],
         'group_norm',
     )
-    # create intput and parameters
+    # create input and parameters
     inputs = {'X': input}
     input_shape = input.shape
     if len(input_shape) < 2:
@@ -3455,7 +3455,7 @@ def spectral_norm(weight, dim=0, power_iters=1, eps=1e-12, name=None):
     check_type(eps, 'eps', float, 'spectral_norm')
     dtype = weight.dtype
 
-    # create intput and parameters
+    # create input and parameters
     input_shape = weight.shape
     assert weight.numel() > 0, "Any dimension of input cannot be equal to 0."
 
@@ -3596,7 +3596,7 @@ def layer_norm(
     )
     dtype = helper.input_dtype()
 
-    # create intput and parameters
+    # create input and parameters
     inputs = {'X': input}
     input_shape = input.shape
     param_shape = [reduce(lambda x, y: x * y, input_shape[begin_norm_axis:], 1)]
