Fix words (#60093)

co63oc · web-flow · commit a19227d9ee0e · 2023-12-18T15:39:14.000+08:00
diff --git a/python/cinn/compiler/compute_code_generator.py b/python/cinn/compiler/compute_code_generator.py
@@ -92,7 +92,7 @@ def visit_compound_statement(self, stmts):
     def visit_arguments(self, node):
         """
         Parse CINN Low Level IR Argument.
-        If it is not jit mode, it will get information from arg.annoatation.
+        If it is not jit mode, it will get information from arg.annotation.
 
         Args:
             node(ast.arguments): The ast argument Node
diff --git a/python/cinn/compiler/expr_executor.py b/python/cinn/compiler/expr_executor.py
@@ -65,7 +65,7 @@ def visit(self, node):
             # some nodes don't need to parse, such as ast.Load
             return node
         if isinstance(node, (ast.Lambda, ast.Starred)):
-            raise Exception("Current not suporrted: Lambda, Starred")
+            raise Exception("Current not supported: Lambda, Starred")
 
         cls_fields = {}
         for field in node.__class__._fields:
diff --git a/python/cinn/compiler/schedule_code_generator.py b/python/cinn/compiler/schedule_code_generator.py
@@ -107,7 +107,7 @@ def visit_With(self, node):
                 local_var_table = exec_assign(
                     target=item.optional_vars, source=sch_block
                 )
-                # 3. Set the block's loop to its attritbute
+                # 3. Set the block's loop to its attribute
                 sch_block.set_scheduler(self.scheduler)
                 self.block_stack.append(sch_block)
                 for k, v in local_var_table.items():
diff --git a/python/paddle/static/io.py b/python/paddle/static/io.py
@@ -103,7 +103,7 @@ def _get_valid_program(program=None):
         program = program._program
         if program is None:
             raise TypeError(
-                "The type of input program is invalid, expected tyep is Program, but received None"
+                "The type of input program is invalid, expected type is Program, but received None"
             )
         warnings.warn(
             "The input is a CompiledProgram, this is not recommended."
diff --git a/python/paddle/tensor/linalg.py b/python/paddle/tensor/linalg.py
@@ -1259,7 +1259,7 @@ def cov(x, rowvar=True, ddof=True, fweights=None, aweights=None, name=None):
             )
         if fweights.min() < 0:
             raise ValueError(
-                "The value of Input(fweights) cannot be negtive, but received "
+                "The value of Input(fweights) cannot be negative, but received "
                 f"min of Input(fweights) is {fweights.min()}."
             )
         if not paddle.all(fweights == paddle.round(fweights.astype('float64'))):
@@ -1284,7 +1284,7 @@ def cov(x, rowvar=True, ddof=True, fweights=None, aweights=None, name=None):
             )
         if aweights.min() < 0:
             raise ValueError(
-                "The value of Input(aweights) cannot be negtive, but received "
+                "The value of Input(aweights) cannot be negative, but received "
                 f"min of Input(aweights) is {aweights.min()}."
             )
         if w is not None:
@@ -2010,11 +2010,11 @@ def svd(x, full_matrices=False, name=None):
 
     Args:
         x (Tensor): The input tensor. Its shape should be `[..., N, M]`,
-            where `...` is zero or more batch dimensions. N and M can be arbitraty
-            positive number. Note that if x is sigular matrices, the grad is numerical
+            where `...` is zero or more batch dimensions. N and M can be arbitrary
+            positive number. Note that if x is singular matrices, the grad is numerical
             instable. The data type of x should be float32 or float64.
-        full_matrices (bool, optional): A flag to control the behavor of svd.
-            If full_matrices = True, svd op will compute full U and V matrics,
+        full_matrices (bool, optional): A flag to control the behavior of svd.
+            If full_matrices = True, svd op will compute full U and V matrices,
             which means shape of U is `[..., N, N]`, shape of V is `[..., M, M]`. K = min(M, N).
             If full_matrices = False, svd op will use a economic method to store U and V.
             which means shape of U is `[..., N, K]`, shape of V is `[..., M, K]`. K = min(M, N).
@@ -2027,7 +2027,7 @@ def svd(x, full_matrices=False, name=None):
         - S (Tensor), is the singular value decomposition result S.
         - VH (Tensor), VH is the conjugate transpose of V, which is the singular value decomposition result V.
 
-        Tuple of 3 tensors(U, S, VH): VH is the conjugate transpose of V. S is the singlar value vectors of matrics with shape `[..., K]`
+        Tuple of 3 tensors(U, S, VH): VH is the conjugate transpose of V. S is the singular value vectors of matrices with shape `[..., K]`
 
     Examples:
         .. code-block:: python
@@ -2088,7 +2088,7 @@ def pca_lowrank(x, q=None, center=True, niter=2, name=None):
 
     Args:
         x (Tensor): The input tensor. Its shape should be `[..., N, M]`,
-            where `...` is zero or more batch dimensions. N and M can be arbitraty
+            where `...` is zero or more batch dimensions. N and M can be arbitrary
             positive number. The data type of x should be float32 or float64.
         q (int, optional): a slightly overestimated rank of :math:`X`.
             Default value is :math:`q=min(6,N,M)`.
@@ -2886,7 +2886,7 @@ def pinv(x, rcond=1e-15, hermitian=False, name=None):
     Args:
         x (Tensor): The input tensor. Its shape should be (*, m, n)
             where * is zero or more batch dimensions. m and n can be
-            arbitraty positive number. The data type of x should be
+            arbitrary positive number. The data type of x should be
             float32 or float64 or complex64 or complex128. When data
             type is complex64 or cpmplex128, hermitian should be set
             True.
diff --git a/python/paddle/tensor/manipulation.py b/python/paddle/tensor/manipulation.py
@@ -149,10 +149,10 @@ def tensor_array_to_tensor(input, axis=1, use_stack=False, name=None):
                     'tensor_array_to_tensor',
                 )
                 if not input_x.is_dense_tensor_array_type():
-                    raise TypeError("input should be tensor array vairable")
+                    raise TypeError("input should be tensor array variable")
         else:
             if not input.is_dense_tensor_array_type():
-                raise TypeError("input should be tensor array vairable")
+                raise TypeError("input should be tensor array variable")
         return paddle._pir_ops.array_to_tensor(input, axis, use_stack)
     else:
         check_type(input, 'input', (list, Variable), 'tensor_array_to_tensor')
@@ -1668,7 +1668,7 @@ def flatten(x, start_axis=0, stop_axis=-1, name=None):
             Out.shape = (3 * 100 * 100 * 4)
 
     Args:
-        x (Tensor): A tensor of number of dimentions >= axis. A tensor with data type float16, float32,
+        x (Tensor): A tensor of number of dimensions >= axis. A tensor with data type float16, float32,
                       float64, int8, int32, int64, uint8.
         start_axis (int): the start axis to flatten
         stop_axis (int): the stop axis to flatten
@@ -2580,7 +2580,7 @@ def tensor_split(x, num_or_indices, axis=0, name=None):
         num_or_indices (int|list|tuple): If ``num_or_indices`` is an int ``n``, ``x`` is split into ``n`` sections along ``axis``.
             If ``x`` is divisible by ``n``, each section will be ``x.shape[axis] / n``. If ``x`` is not divisible by ``n``, the first
             ``int(x.shape[axis] % n)`` sections will have size ``int(x.shape[axis] / n) + 1``, and the rest will be ``int(x.shape[axis] / n).
-            If ``num_or_indices`` is a list or tuple of integter indices, ``x`` is split along ``axis`` at each of the indices. For instance,
+            If ``num_or_indices`` is a list or tuple of integer indices, ``x`` is split along ``axis`` at each of the indices. For instance,
             ``num_or_indices=[2, 4]`` with ``axis=0`` would split ``x`` into ``x[:2]``, ``x[2:4]`` and ``x[4:]`` along axis 0.
         axis (int|Tensor, optional): The axis along which to split, it can be a integer or a ``0-D Tensor``
             with shape [] and data type  ``int32`` or ``int64``.
@@ -2696,7 +2696,7 @@ def hsplit(x, num_or_indices, name=None):
     Args:
         x (Tensor): A Tensor whose dimension must be greater than 0. The data type is bool, bfloat16, float16, float32, float64, uint8, int32 or int64.
         num_or_indices (int|list|tuple): If ``num_or_indices`` is an int ``n``, ``x`` is split into ``n`` sections.
-            If ``num_or_indices`` is a list or tuple of integter indices, ``x`` is split at each of the indices.
+            If ``num_or_indices`` is a list or tuple of integer indices, ``x`` is split at each of the indices.
         name (str, optional): The default value is None.  Normally there is no need for user to set this property.
             For more information, please refer to :ref:`api_guide_Name` .
     Returns:
@@ -2749,7 +2749,7 @@ def dsplit(x, num_or_indices, name=None):
     Args:
         x (Tensor): A Tensor whose dimension must be greater than 2. The data type is bool, bfloat16, float16, float32, float64, uint8, int32 or int64.
         num_or_indices (int|list|tuple): If ``num_or_indices`` is an int ``n``, ``x`` is split into ``n`` sections.
-            If ``num_or_indices`` is a list or tuple of integter indices, ``x`` is split at each of the indices.
+            If ``num_or_indices`` is a list or tuple of integer indices, ``x`` is split at each of the indices.
         name (str, optional): The default value is None.  Normally there is no need for user to set this property.
             For more information, please refer to :ref:`api_guide_Name` .
     Returns:
@@ -2791,7 +2791,7 @@ def vsplit(x, num_or_indices, name=None):
     Args:
         x (Tensor): A Tensor whose dimension must be greater than 1. The data type is bool, bfloat16, float16, float32, float64, uint8, int32 or int64.
         num_or_indices (int|list|tuple): If ``num_or_indices`` is an int ``n``, ``x`` is split into ``n`` sections.
-            If ``num_or_indices`` is a list or tuple of integter indices, ``x`` is split at each of the indices.
+            If ``num_or_indices`` is a list or tuple of integer indices, ``x`` is split at each of the indices.
         name (str, optional): The default value is None.  Normally there is no need for user to set this property.
             For more information, please refer to :ref:`api_guide_Name` .
     Returns:
@@ -5412,8 +5412,8 @@ def as_complex(x, name=None):
     The data type of the input tensor is 'float32' or 'float64', and the data
     type of the returned tensor is 'complex64' or 'complex128', respectively.
 
-    The shape of the input tensor is ``(* ,2)``, (``*`` means arbitary shape), i.e.
-    the size of the last axis shoule be 2, which represent the real and imag part
+    The shape of the input tensor is ``(* ,2)``, (``*`` means arbitrary shape), i.e.
+    the size of the last axis should be 2, which represent the real and imag part
     of a complex number. The shape of the returned tensor is ``(*,)``.
 
     Args:
@@ -5458,7 +5458,7 @@ def as_real(x, name=None):
     The data type of the input tensor is 'complex64' or 'complex128', and the data
     type of the returned tensor is 'float32' or 'float64', respectively.
 
-    When the shape of the input tensor is ``(*, )``, (``*`` means arbitary shape),
+    When the shape of the input tensor is ``(*, )``, (``*`` means arbitrary shape),
     the shape of the output tensor is ``(*, 2)``, i.e. the shape of the output is
     the shape of the input appended by an extra ``2``.
 
@@ -5618,9 +5618,9 @@ def moveaxis(x, source, destination, name=None):
     ), "'source' must have the same number with 'destination'"
 
     if len(src) != len(set(src)):
-        raise ValueError("Each elemment of 'source' must be unique!")
+        raise ValueError("Each element of 'source' must be unique!")
     if len(dst) != len(set(dst)):
-        raise ValueError("Each elemment of 'destination' must be unique!")
+        raise ValueError("Each element of 'destination' must be unique!")
 
     ndim = len(x.shape)
 
@@ -5632,7 +5632,7 @@ def moveaxis(x, source, destination, name=None):
     for i, axis in enumerate(zip(src, dst)):
         assert isinstance(
             axis[0], int
-        ), "Each elemment of 'source' must be integer."
+        ), "Each element of 'source' must be integer."
         if axis[0] < 0:
             assert (
                 axis[0] >= -ndim
@@ -5645,7 +5645,7 @@ def moveaxis(x, source, destination, name=None):
 
         assert isinstance(
             axis[1], int
-        ), "Each elemment of 'source' must be integer."
+        ), "Each element of 'source' must be integer."
         if axis[1] < 0:
             assert (
                 axis[1] >= -ndim
@@ -5710,7 +5710,7 @@ def masked_fill(x, mask, value, name=None):
             refer to :ref:`api_guide_Name`.
 
     Returns:
-        Tensor, same dimention and dtype with x.
+        Tensor, same dimension and dtype with x.
     Examples:
         .. code-block:: python
 
@@ -6088,7 +6088,7 @@ def index_add(x, index, axis, value, name=None):
         name(str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None.
 
     Returns:
-        Tensor, same dimention and dtype with x.
+        Tensor, same dimension and dtype with x.
 
     Examples:
         .. code-block:: python
@@ -6187,7 +6187,7 @@ def index_put_(x, indices, value, accumulate=False, name=None):
         name(str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None.
 
     Returns:
-        Tensor, same dimention and dtype with x.
+        Tensor, same dimension and dtype with x.
 
     Examples:
         .. code-block:: python
@@ -6569,7 +6569,7 @@ def index_fill(x, index, axis, value, name=None):
 @inplace_apis_in_dygraph_only
 def index_fill_(x, index, axis, value, name=None):
     """
-    Fill the elements of the input tensor with value by the spcific axis and index.
+    Fill the elements of the input tensor with value by the specific axis and index.
 
     Args:
         x (Tensor) : The Destination Tensor. Supported data types are int32, int64, float16, float32, float64.
@@ -6580,7 +6580,7 @@ def index_fill_(x, index, axis, value, name=None):
         name(str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None.
 
     Returns:
-        Tensor, same dimention and dtype with x.
+        Tensor, same dimension and dtype with x.
 
     Examples:
         .. code-block:: python
@@ -6630,7 +6630,7 @@ def diagonal_scatter(x, y, offset=0, axis1=0, axis2=1, name=None):
         name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.
 
     Returns:
-        Tensor, Tensor with diagonal embedeed with ``y``.
+        Tensor, Tensor with diagonal embedded with ``y``.
 
     Examples:
         .. code-block:: python
diff --git a/python/paddle/tensor/math.py b/python/paddle/tensor/math.py
@@ -778,7 +778,7 @@ def logaddexp(x, y, name=None):
 
 def subtract(x, y, name=None):
     """
-    Substract two tensors element-wise. The equation is:
+    Subtract two tensors element-wise. The equation is:
 
     .. math::
         out = x - y
@@ -1629,7 +1629,7 @@ def nan_to_num(x, nan=0.0, posinf=None, neginf=None, name=None):
              -99.                                    ])
     """
     # NOTE(tiancaishaonvjituizi): it seems that paddle handles the dtype of python float number
-    # incorrectly, so we have to explicitly contruct tensors here
+    # incorrectly, so we have to explicitly construct tensors here
     posinf_value = paddle.full_like(x, float("+inf"))
     neginf_value = paddle.full_like(x, float("-inf"))
     nan = paddle.full_like(x, nan)
@@ -2251,7 +2251,7 @@ def addmm(input, x, y, beta=1.0, alpha=1.0, name=None):
     y_shape = y.shape
     if not len(x_shape) == len(y_shape) == 2:
         raise ValueError(
-            "The dimention of x, y should be 2 but receive x's shape: {}, y's shape: {}".format(
+            "The dimension of x, y should be 2 but receive x's shape: {}, y's shape: {}".format(
                 x_shape, y_shape
             )
         )
@@ -2291,7 +2291,7 @@ def addmm(input, x, y, beta=1.0, alpha=1.0, name=None):
             )
     else:
         raise ValueError(
-            "The dimention of input should be 2 or 1 but receive input's shape: {}".format(
+            "The dimension of input should be 2 or 1 but receive input's shape: {}".format(
                 input_shape
             )
         )
@@ -2331,7 +2331,7 @@ def addmm_(input, x, y, beta=1.0, alpha=1.0, name=None):
     y_shape = y.shape
     if not len(x_shape) == len(y_shape) == 2:
         raise ValueError(
-            "The dimention of x, y should be 2 but receive x's shape: {}, y's shape: {}".format(
+            "The dimension of x, y should be 2 but receive x's shape: {}, y's shape: {}".format(
                 x_shape, y_shape
             )
         )
@@ -2371,7 +2371,7 @@ def addmm_(input, x, y, beta=1.0, alpha=1.0, name=None):
             )
     else:
         raise ValueError(
-            "The dimention of input should be 2 or 1 but receive input's shape: {}".format(
+            "The dimension of input should be 2 or 1 but receive input's shape: {}".format(
                 input_shape
             )
         )
diff --git a/python/paddle/tensor/random.py b/python/paddle/tensor/random.py
@@ -648,7 +648,7 @@ def normal(mean=0.0, std=1.0, shape=None, name=None):
         std (float|Tensor, optional): The  standard deviation of the output Tensor's normal distribution.
             If ``std`` is float, all elements of the output Tensor shared the same standard deviation.
             If ``std`` is a Tensor(data type supports float32, float64), it has per-element standard deviations.
-            Defaule is 1.0
+            Default is 1.0
         shape (tuple|list|Tensor): Shape of the Tensor to be created. The data type is ``int32`` or ``int64`` .
             If ``shape`` is a list or tuple, each element of it should be integer or 0-D Tensor with shape [].
             If ``shape`` is an Tensor, it should be an 1-D Tensor which represents a list. If ``mean`` or ``std``
diff --git a/python/paddle/tensor/search.py b/python/paddle/tensor/search.py
@@ -145,7 +145,7 @@ def argmax(x, axis=None, keepdim=False, dtype="int64", name=None):
         axis (int, optional): Axis to compute indices along. The effective range
             is [-R, R), where R is x.ndim. when axis < 0, it works the same way
             as axis + R. Default is None, the input `x` will be into the flatten tensor, and selecting the min value index.
-        keepdim (bool, optional): Whether to keep the given axis in output. If it is True, the dimensions will be same as input x and with size one in the axis. Otherwise the output dimentions is one fewer than x since the axis is squeezed. Default is False.
+        keepdim (bool, optional): Whether to keep the given axis in output. If it is True, the dimensions will be same as input x and with size one in the axis. Otherwise the output dimensions is one fewer than x since the axis is squeezed. Default is False.
         dtype (str|np.dtype, optional): Data type of the output tensor which can
                     be int32, int64. The default value is ``int64`` , and it will
                     return the int64 indices.
diff --git a/python/paddle/tensor/to_string.py b/python/paddle/tensor/to_string.py
@@ -135,7 +135,7 @@ def _format_item(np_var, max_width=0, signed=False):
         item_str = f'{np_var}'
 
     if max_width > len(item_str):
-        if signed:  # handle sign character for tenosr with negative item
+        if signed:  # handle sign character for tensor with negative item
             if np_var < 0:
                 return item_str.ljust(max_width)
             else:

Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ def visit_With(self, node):`
`107`	`107`	`local_var_table = exec_assign(`
`108`	`108`	`target=item.optional_vars, source=sch_block`
`109`	`109`	`)`
`110`		`- # 3. Set the block's loop to its attritbute`
	`110`	`+ # 3. Set the block's loop to its attribute`
`111`	`111`	`sch_block.set_scheduler(self.scheduler)`
`112`	`112`	`self.block_stack.append(sch_block)`
`113`	`113`	`for k, v in local_var_table.items():`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ def _get_valid_program(program=None):`
`103`	`103`	`program = program._program`
`104`	`104`	`if program is None:`
`105`	`105`	`raise TypeError(`
`106`		`- "The type of input program is invalid, expected tyep is Program, but received None"`
	`106`	`+ "The type of input program is invalid, expected type is Program, but received None"`
`107`	`107`	`)`
`108`	`108`	`warnings.warn(`
`109`	`109`	`"The input is a CompiledProgram, this is not recommended."`
Original file line number	Diff line number	Diff line change
`@@ -778,7 +778,7 @@ def logaddexp(x, y, name=None):`
`778`	`778`
`779`	`779`	`def subtract(x, y, name=None):`
`780`	`780`	`"""`
`781`		`- Substract two tensors element-wise. The equation is:`
	`781`	`+ Subtract two tensors element-wise. The equation is:`
`782`	`782`
`783`	`783`	`.. math::`
`784`	`784`	`out = x - y`
`@@ -1629,7 +1629,7 @@ def nan_to_num(x, nan=0.0, posinf=None, neginf=None, name=None):`
`1629`	`1629`	`-99. ])`
`1630`	`1630`	`"""`
`1631`	`1631`	`# NOTE(tiancaishaonvjituizi): it seems that paddle handles the dtype of python float number`
`1632`		`- # incorrectly, so we have to explicitly contruct tensors here`
	`1632`	`+ # incorrectly, so we have to explicitly construct tensors here`
`1633`	`1633`	`posinf_value = paddle.full_like(x, float("+inf"))`
`1634`	`1634`	`neginf_value = paddle.full_like(x, float("-inf"))`
`1635`	`1635`	`nan = paddle.full_like(x, nan)`
`@@ -2251,7 +2251,7 @@ def addmm(input, x, y, beta=1.0, alpha=1.0, name=None):`
`2251`	`2251`	`y_shape = y.shape`
`2252`	`2252`	`if not len(x_shape) == len(y_shape) == 2:`
`2253`	`2253`	`raise ValueError(`
`2254`		`- "The dimention of x, y should be 2 but receive x's shape: {}, y's shape: {}".format(`
	`2254`	`+ "The dimension of x, y should be 2 but receive x's shape: {}, y's shape: {}".format(`
`2255`	`2255`	`x_shape, y_shape`
`2256`	`2256`	`)`
`2257`	`2257`	`)`
`@@ -2291,7 +2291,7 @@ def addmm(input, x, y, beta=1.0, alpha=1.0, name=None):`
`2291`	`2291`	`)`
`2292`	`2292`	`else:`
`2293`	`2293`	`raise ValueError(`
`2294`		`- "The dimention of input should be 2 or 1 but receive input's shape: {}".format(`
	`2294`	`+ "The dimension of input should be 2 or 1 but receive input's shape: {}".format(`
`2295`	`2295`	`input_shape`
`2296`	`2296`	`)`
`2297`	`2297`	`)`
`@@ -2331,7 +2331,7 @@ def addmm_(input, x, y, beta=1.0, alpha=1.0, name=None):`
`2331`	`2331`	`y_shape = y.shape`
`2332`	`2332`	`if not len(x_shape) == len(y_shape) == 2:`
`2333`	`2333`	`raise ValueError(`
`2334`		`- "The dimention of x, y should be 2 but receive x's shape: {}, y's shape: {}".format(`
	`2334`	`+ "The dimension of x, y should be 2 but receive x's shape: {}, y's shape: {}".format(`
`2335`	`2335`	`x_shape, y_shape`
`2336`	`2336`	`)`
`2337`	`2337`	`)`
`@@ -2371,7 +2371,7 @@ def addmm_(input, x, y, beta=1.0, alpha=1.0, name=None):`
`2371`	`2371`	`)`
`2372`	`2372`	`else:`
`2373`	`2373`	`raise ValueError(`
`2374`		`- "The dimention of input should be 2 or 1 but receive input's shape: {}".format(`
	`2374`	`+ "The dimension of input should be 2 or 1 but receive input's shape: {}".format(`
`2375`	`2375`	`input_shape`
`2376`	`2376`	`)`
`2377`	`2377`	`)`