Fix some typos (estabulished, desciriptor, etc.) (#61738)

co63oc · web-flow · commit 69f48d9ea60d · 2024-02-19T15:54:22.000+08:00
diff --git a/paddle/phi/kernels/autotune/auto_tune_base.h b/paddle/phi/kernels/autotune/auto_tune_base.h
@@ -105,7 +105,7 @@ class AutoTuneBase {
     size_t best_idx = 0;
     float min_time = std::numeric_limits<float>::max();
 
-    // Time cost test estabulished in default stream.
+    // Time cost test established in default stream.
     for (size_t i = 0; i < kernels_.size(); ++i) {
       auto time = RunAndMeasureKernel<Context>(ctx, i, args...);
       if (time < min_time) {
@@ -244,7 +244,7 @@ class GatherGemmScatterAutoTuner
     size_t best_idx = NO_KERNEL_WORKS;
     float min_time = std::numeric_limits<float>::max();
 
-    // Time cost test estabulished in default stream.
+    // Time cost test established in default stream.
     for (int i = 0; i < this->kernels_.size(); ++i) {
       float time = 0;
       // Some kernels may require more shared memory than available, skip these
diff --git a/paddle/phi/kernels/funcs/blas/blaslt_impl.cu.h b/paddle/phi/kernels/funcs/blas/blaslt_impl.cu.h
@@ -426,7 +426,7 @@ struct MatmulGradDescriptor : MatmulDescriptor {
     this->SetFusedEpilogueOpDescriptor(
         planner, trans_x, trans_y, TransX ? M : K);
 
-    // Create operation desciriptor; see cublasLtMatmulDescAttributes_t for
+    // Create operation descriptor; see cublasLtMatmulDescAttributes_t for
     // details about defaults; just need to set the transforms for A and B
     this->CreateMatrixLayout(&x_desc, mat_type, N, M, true);
     if (grad_for_dx) {
@@ -927,9 +927,9 @@ struct DescriptorSetter {
       sub_key = planner->GenSubKey();
     }
 
-    auto& mamtul_cache = phi::autotune::AutoTuneCache::Instance().GetMatmul();
-    if (mamtul_cache.FindSubKey(sub_key)) {
-      desc = *(reinterpret_cast<DescT*>(mamtul_cache.GetSubKey(sub_key)));
+    auto& matmul_cache = phi::autotune::AutoTuneCache::Instance().GetMatmul();
+    if (matmul_cache.FindSubKey(sub_key)) {
+      desc = *(reinterpret_cast<DescT*>(matmul_cache.GetSubKey(sub_key)));
       desc.template SetFusedEpiloguePtr<DYT>(planner);
       VLOG(7) << desc.GetDescResultString("[Heap CublasltDescriptor] ");
     } else {
diff --git a/python/paddle/base/compiler.py b/python/paddle/base/compiler.py
@@ -631,7 +631,7 @@ def __init__(self):
 
     def register_patch(self):
         """
-        Register patchs function to support dynamic to static on IPU. This operation would break the dy2static functionality on CPU.
+        Register patch function to support dynamic to static on IPU. This operation would break the dy2static functionality on CPU.
         Use `release_patch` to release the patch.
 
         Examples:
diff --git a/python/paddle/base/core.py b/python/paddle/base/core.py
@@ -320,7 +320,7 @@ def to_list(s):
 
     # isort: off
 
-    # custom devivce
+    # custom device
     from .libpaddle import (  # noqa: F401
         CustomDeviceEvent,
         CustomDeviceStream,
@@ -483,7 +483,7 @@ def _test_use_sync(value):
     __sync_stat_with_flag(value)
 
 
-# ops in forward_blacklisk will not be replaced by composite ops.
+# ops in forward_blacklist will not be replaced by composite ops.
 prim_config = {"forward_blacklist": set(), "composite_ops_record": set()}
 
 
diff --git a/python/paddle/base/data_feeder.py b/python/paddle/base/data_feeder.py
@@ -185,7 +185,7 @@ def check_type(input, input_name, expected_type, op_name, extra_message=''):
         return
 
     # NOTE: `in_to_static_mode` is used to determined whether this op is called under
-    # @to_static in transformation from dygrah to static layer. We add Tensor in
+    # @to_static in transformation from dygraph to static layer. We add Tensor in
     # expected_type to skip checking because Tensor may be created and used in unusual way.
     from .dygraph.base import in_to_static_mode
 
@@ -259,11 +259,11 @@ def __init__(self, place, lod_level, shape, dtype):
         self.place = place
         self.lod_level = lod_level
         self.shape = shape
-        negtive_count = 0
+        negative_count = 0
         for s in self.shape:
             if s < 0:
-                negtive_count += 1
-            if negtive_count > 1:
+                negative_count += 1
+            if negative_count > 1:
                 self.shape = None
                 break
         self.dtype = convert_dtype(dtype)
diff --git a/python/paddle/base/framework.py b/python/paddle/base/framework.py
@@ -632,10 +632,10 @@ def _set_pipeline_stage(stage):
 
 # NOTE(zhiqiu): This decorator is used for the APIs of Variable which is only
 # used to make Variable and Tensor has same interfaces, like numpy. Since Tensor is not exposed in our
-# official docments, logically, we want to keep Tensor and logically consistent. While, actually,
+# official documents, logically, we want to keep Tensor and logically consistent. While, actually,
 # in our implementation, there some APIs not supported, like numpy, because Variable contains the desc.
 # So, those APIs are listed under class Variable to generate docs only.
-# TODO(zhiqiu): We should make Tensor consistent with Variable in future, for example, by inheritting
+# TODO(zhiqiu): We should make Tensor consistent with Variable in future, for example, by inheriting
 # same base class.
 def _fake_interface_only_(func):
     def __impl__(*args, **kwargs):
@@ -810,7 +810,7 @@ def disable_signal_handler():
 
     Paddle installs signal handlers at C++ level to log debug information upon failing.
     However, conflicts can happen if another python module is making use of such signal.
-    Such being the case, one may disblae paddle signal handler via this interface.
+    Such being the case, one may disable paddle signal handler via this interface.
 
     Known frameworks that require disabling signal handler includes:
     1. TVM
@@ -1373,7 +1373,7 @@ def wrap_as_scalar(number):
 
 def wrap_as_scalars(array):
     """This function is used to convert flat list, or numpy array(not
-    necesarily flat) to list of core.Scalar, which correspond to
+    necessarily flat) to list of core.Scalar, which correspond to
     std::vector<paddle::experimental::Scalar> in operator runtime.
 
     Args:
@@ -1718,7 +1718,7 @@ def backward(self, retain_graph=False):
         Args:
             retain_graph(bool, optional): If False, the graph used to compute grads will be freed. If you would
                 like to add more ops to the built graph after calling this method( :code:`backward` ), set the parameter
-                :code:`retain_graph` to True, then the grads will be retained. Thus, seting it to False is much more memory-efficient.
+                :code:`retain_graph` to True, then the grads will be retained. Thus, setting it to False is much more memory-efficient.
                 Defaults to False.
 
         Returns:
@@ -2129,7 +2129,7 @@ def name(self):
         """
         Indicating name of current Variable
 
-        **Notes: If it has two or more Varaible share the same name in the same** :ref:`api_guide_Block_en` **, it means these Variable will share content in no-** Dygraph **mode. This is how we achieve Parameter sharing**
+        **Notes: If it has two or more Variable share the same name in the same** :ref:`api_guide_Block_en` **, it means these Variable will share content in no-** Dygraph **mode. This is how we achieve Parameter sharing**
 
         Examples:
             .. code-block:: python
@@ -2241,7 +2241,7 @@ def lod_level(self):
                 LoD Level of current Var is: 0
         """
         if self.type == core.VarDesc.VarType.SELECTED_ROWS:
-            raise Exception("SelectedRows DO NOT supprt lod")
+            raise Exception("SelectedRows DO NOT support lod")
         if self.type == core.VarDesc.VarType.STRINGS:
             return None
         return self.desc.lod_level()
@@ -2627,7 +2627,7 @@ def get_value(self, scope=None):
                 ...         var.set_value(t_load)
         """
         # The 'framework' is a low-level module, and 'executor'
-        # can not be imported at the begainning of this file.
+        # can not be imported at the beginning of this file.
         # Therefore, the above two modules are dynamically imported.
         from .executor import global_scope
 
@@ -2694,7 +2694,7 @@ def set_value(self, value, scope=None):
         '''
 
         # The 'framework' is a low-level module, and 'executor'
-        # can not be imported at the begainning of this file.
+        # can not be imported at the beginning of this file.
         # Therefore, the above two modules are dynamically imported.
         from .executor import global_scope
 
@@ -3869,7 +3869,7 @@ def check_if_to_static_diff_with_dygraph(op_type, inplace_map, outputs):
                     and inplace_map.get("Input", None) == "Out"
                 ):
                     raise ValueError(
-                        'Sorry about what\'s happend. In to_static mode, {}\'s output variable {} is a viewed Tensor in dygraph. This will result in inconsistent calculation behavior between dynamic and static graphs. If you are sure it is safe, you can call with paddle.base.framework._stride_in_no_check_dy2st_diff() in your safe code block.'.format(
+                        'Sorry about what\'s happened. In to_static mode, {}\'s output variable {} is a viewed Tensor in dygraph. This will result in inconsistent calculation behavior between dynamic and static graphs. If you are sure it is safe, you can call with paddle.base.framework._stride_in_no_check_dy2st_diff() in your safe code block.'.format(
                             op_type, k
                         )
                     )
@@ -5810,7 +5810,7 @@ def __init__(self):
         # the distributed lookup table names
         self._distributed_lookup_table = None
 
-        # use Deep gradient comrepssion or not
+        # use Deep gradient compression or not
         self._enable_dgc = False
         self._use_lamb = False
 
@@ -6272,7 +6272,7 @@ def clone(self, for_test=False):
         """
         .. note:::
             1. :code:`Program.clone()` method DOES NOT clone :ref:`api_paddle_io_DataLoader` .
-            2. Recommend you to use :code:`clone` before using :code:`Opimizer.minimize` .
+            2. Recommend you to use :code:`clone` before using :code:`Optimizer.minimize` .
             3. This API has no effect in Dygraph Mode.
 
         Create a new Program with forward content of original one when ``for_test=True``.
@@ -6286,8 +6286,8 @@ def clone(self, for_test=False):
         * Set for_test to False when you want to clone the program for training.
         * Set for_test to True when you want to clone the program for testing.
           We will prune the backward and optimize part of the program when you
-          use :code:`clone` after :code:`Opimizer.minimize`, but we still
-          recommend you to use :code:`clone` before using :code:`Opimizer.minimize`.
+          use :code:`clone` after :code:`Optimizer.minimize`, but we still
+          recommend you to use :code:`clone` before using :code:`Optimizer.minimize`.
 
         Examples:
             .. code-block:: python
diff --git a/python/paddle/decomposition/rules.py b/python/paddle/decomposition/rules.py
@@ -18,7 +18,7 @@
 
 
 # TODO(kevincheng2): python implementation of prim feature,
-# now it has been sinked to c++, waiting for further deletion.
+# now it has been sunk to c++, waiting for further deletion.
 @register_decomp('pd_op.unsqueeze')
 def unsqueeze(x, axis):
     """define composite rule of op unsqueeze"""
diff --git a/python/paddle/device/__init__.py b/python/paddle/device/__init__.py
@@ -156,7 +156,7 @@ def XPUPlace(dev_id):
 def get_cudnn_version():
     """
 
-    This function return the version of cudnn. the retuen value is int which represents the
+    This function return the version of cudnn. the return value is int which represents the
     cudnn version. For example, if it return 7600, it represents the version of cudnn is 7.6.
 
     Returns:
@@ -348,16 +348,16 @@ def get_all_device_type():
             >>> import paddle
             >>> paddle.device.get_all_device_type()
 
-            >>> # Case 1: paddlepaddle-cpu package installed, and no custom device registerd.
+            >>> # Case 1: paddlepaddle-cpu package installed, and no custom device registered.
             >>> # Output: ['cpu']
 
-            >>> # Case 2: paddlepaddle-gpu package installed, and no custom device registerd.
+            >>> # Case 2: paddlepaddle-gpu package installed, and no custom device registered.
             >>> # Output: ['cpu', 'gpu']
 
-            >>> # Case 3: paddlepaddle-cpu package installed, and custom deivce 'CustomCPU' is registerd.
+            >>> # Case 3: paddlepaddle-cpu package installed, and custom device 'CustomCPU' is registered.
             >>> # Output: ['cpu', 'CustomCPU']
 
-            >>> # Case 4: paddlepaddle-gpu package installed, and custom deivce 'CustomCPU' and 'CustomGPU' is registerd.
+            >>> # Case 4: paddlepaddle-gpu package installed, and custom device 'CustomCPU' and 'CustomGPU' is registered.
             >>> # Output: ['cpu', 'gpu', 'CustomCPU', 'CustomGPU']
 
     """
@@ -378,10 +378,10 @@ def get_all_custom_device_type():
             >>> import paddle
             >>> paddle.device.get_all_custom_device_type()
 
-            >>> # Case 1: paddlepaddle-gpu package installed, and no custom device registerd.
+            >>> # Case 1: paddlepaddle-gpu package installed, and no custom device registered.
             >>> # Output: None
 
-            >>> # Case 2: paddlepaddle-gpu package installed, and custom deivce 'CustomCPU' and 'CustomGPU' is registerd.
+            >>> # Case 2: paddlepaddle-gpu package installed, and custom device 'CustomCPU' and 'CustomGPU' is registered.
             >>> # Output: ['CustomCPU', 'CustomGPU']
 
     """
@@ -402,16 +402,16 @@ def get_available_device():
             >>> import paddle
             >>> paddle.device.get_available_device()
 
-            >>> # Case 1: paddlepaddle-cpu package installed, and no custom device registerd.
+            >>> # Case 1: paddlepaddle-cpu package installed, and no custom device registered.
             >>> # Output: ['cpu']
 
-            >>> # Case 2: paddlepaddle-gpu package installed, and no custom device registerd.
+            >>> # Case 2: paddlepaddle-gpu package installed, and no custom device registered.
             >>> # Output: ['cpu', 'gpu:0', 'gpu:1']
 
-            >>> # Case 3: paddlepaddle-cpu package installed, and custom deivce 'CustomCPU' is registerd.
+            >>> # Case 3: paddlepaddle-cpu package installed, and custom device 'CustomCPU' is registered.
             >>> # Output: ['cpu', 'CustomCPU']
 
-            >>> # Case 4: paddlepaddle-gpu package installed, and custom deivce 'CustomCPU' and 'CustomGPU' is registerd.
+            >>> # Case 4: paddlepaddle-gpu package installed, and custom device 'CustomCPU' and 'CustomGPU' is registered.
             >>> # Output: ['cpu', 'gpu:0', 'gpu:1', 'CustomCPU', 'CustomGPU:0', 'CustomGPU:1']
 
     """
@@ -432,10 +432,10 @@ def get_available_custom_device():
             >>> import paddle
             >>> paddle.device.get_available_custom_device()
 
-            >>> # Case 1: paddlepaddle-gpu package installed, and no custom device registerd.
+            >>> # Case 1: paddlepaddle-gpu package installed, and no custom device registered.
             >>> # Output: None
 
-            >>> # Case 2: paddlepaddle-gpu package installed, and custom deivce 'CustomCPU' and 'CustomGPU' is registerd.
+            >>> # Case 2: paddlepaddle-gpu package installed, and custom device 'CustomCPU' and 'CustomGPU' is registered.
             >>> # Output: ['CustomCPU', 'CustomGPU:0', 'CustomGPU:1']
 
     """
@@ -448,8 +448,8 @@ class Event:
     A device event wrapper around StreamBase.
 
     Args:
-        device(str|paddle.CUDAPlace(n)|paddle.CustomPlace(n)): Which device the stream runn on. If device is None, the device is the current device. Default: None.
-            It can be ``gpu``, ``gpu:x``, ``custom_device``, ``custom_device:x``, where ``custom_device`` is the name of CustomDevicec,
+        device(str|paddle.CUDAPlace(n)|paddle.CustomPlace(n)): Which device the stream run on. If device is None, the device is the current device. Default: None.
+            It can be ``gpu``, ``gpu:x``, ``custom_device``, ``custom_device:x``, where ``custom_device`` is the name of CustomDevice,
             where ``x`` is the index of the GPUs, XPUs. And it can be paddle.CUDAPlace(n) or paddle.CustomPlace(n).
         enable_timing (bool, optional): indicates if the event should measure time, default is False
         blocking (bool, optional): if True, ``wait`` will be blocking, default is False
@@ -620,8 +620,8 @@ class Stream:
     A device stream wrapper around StreamBase.
 
     Args:
-        device(str|paddle.CUDAPlace(n)|paddle.CustomPlace(n)): Which device the stream runn on. If device is None, the device is the current device. Default: None.
-            It can be ``gpu``, ``gpu:x``, ``custom_device``, ``custom_device:x``, where ``custom_device`` is the name of CustomDevicec,
+        device(str|paddle.CUDAPlace(n)|paddle.CustomPlace(n)): Which device the stream run on. If device is None, the device is the current device. Default: None.
+            It can be ``gpu``, ``gpu:x``, ``custom_device``, ``custom_device:x``, where ``custom_device`` is the name of CustomDevice,
             where ``x`` is the index of the GPUs, XPUs. And it can be paddle.CUDAPlace(n) or paddle.CustomPlace(n).
         priority(int, optional): priority of the CUDA stream. Can be either
             1 (high priority) or 2 (low priority). By default, streams have
@@ -839,8 +839,8 @@ def current_stream(device=None):
 
     Args:
         device(str|paddle.CUDAPlace(n)|paddle.CustomPlace(n)): The device which want to get stream from.  If device is None, the device is the current device. Default: None.
-            It can be ``gpu``, ``gpu:x``, ``custom_device``, ``custom_device:x``, where ``custom_device`` is the name of CustomDevicec,
-            where ``x`` is the index of the GPUs, CustomDevicecs. And it can be paddle.CUDAPlace(n) or paddle.CustomPlace(n).
+            It can be ``gpu``, ``gpu:x``, ``custom_device``, ``custom_device:x``, where ``custom_device`` is the name of CustomDevice,
+            where ``x`` is the index of the GPUs, CustomDevices. And it can be paddle.CUDAPlace(n) or paddle.CustomPlace(n).
 
     Returns:
         Stream: The stream to the device.
@@ -995,7 +995,7 @@ def synchronize(device=None):
 
     Args:
         device(str|paddle.CUDAPlace(n)|paddle.XPUPlace(n)|paddle.CustomPlace(n)): The device which want to wait for.  If device is None, the device is the current device. Default: None.
-            It can be ``gpu``, ``gpu:x``, ``xpu``, ``xpu:x``, ``custom_device``, ``custom_device:x``, where ``custom_device`` is the name of CustomDevicec,
+            It can be ``gpu``, ``gpu:x``, ``xpu``, ``xpu:x``, ``custom_device``, ``custom_device:x``, where ``custom_device`` is the name of CustomDevice,
             where ``x`` is the index of the GPUs, XPUs. And it can be paddle.CUDAPlace(n) or paddle.XPUPlace(n) or paddle.CustomPlace(n).
 
     Examples:
diff --git a/python/paddle/distributed/auto_parallel/static/cost/op_runtime_cost.py b/python/paddle/distributed/auto_parallel/static/cost/op_runtime_cost.py
@@ -285,7 +285,7 @@ def measure_program_real_op_cost(
     )
     if run_iters == 1:
         warnings.warn(
-            'run_iters was set to 1, profiling results might be inaccurate due to outilers.'
+            'run_iters was set to 1, profiling results might be inaccurate due to outliers.'
         )
 
     logger = get_logger(log_level=logging.INFO)
diff --git a/python/paddle/distributed/auto_parallel/static/operators/dist_eltwise.py b/python/paddle/distributed/auto_parallel/static/operators/dist_eltwise.py
@@ -49,13 +49,13 @@ def update_dims_mapping(dist_op):
         op_desc = dist_op.serial_op.desc
         assert (
             len(op_desc.input_arg_names()) >= 1
-        ), "elementwsie op [{}] has [{}] inputs".format(
+        ), "elementwise op [{}] has [{}] inputs".format(
             op_desc.type, len(op_desc.input_arg_names())
         )
         input_arg_names = op_desc.input_arg_names()
         assert (
             len(op_desc.output_arg_names()) == 1
-        ), "elementwsie op [{}] has [{}] outputs".format(
+        ), "elementwise op [{}] has [{}] outputs".format(
             str(dist_op.serial_op), len(op_desc.output_arg_names())
         )
         output_arg_name = op_desc.output_arg_names()[0]

Original file line number	Diff line number	Diff line change
`@@ -285,7 +285,7 @@ def measure_program_real_op_cost(`
`285`	`285`	`)`
`286`	`286`	`if run_iters == 1:`
`287`	`287`	`warnings.warn(`
`288`		`- 'run_iters was set to 1, profiling results might be inaccurate due to outilers.'`
	`288`	`+ 'run_iters was set to 1, profiling results might be inaccurate due to outliers.'`
`289`	`289`	`)`
`290`	`290`
`291`	`291`	`logger = get_logger(log_level=logging.INFO)`