Fix lable label (#60951)

co63oc · web-flow · commit bdebc863153d · 2024-01-19T16:20:25.000+08:00
diff --git a/test/amp/test_amp_api.py b/test/amp/test_amp_api.py
@@ -176,7 +176,7 @@ def test_amp_grad_scaler(self):
     "run test when gpu's compute capability is at least 7.0.",
 )
 class TestFp16Guard(AmpTestBase):
-    def test_fp16_gurad(self):
+    def test_fp16_guard(self):
         paddle.enable_static()
 
         def run_example_code():
@@ -221,7 +221,7 @@ def run_example_code():
                     use_dynamic_loss_scaling=True,
                     use_pure_fp16=True,
                 )
-                # If you don't use the default_startup_program(), you sholud pass
+                # If you don't use the default_startup_program(), you should pass
                 # your defined `startup_program` into `minimize`.
                 optimizer.minimize(loss)
 
diff --git a/test/amp/test_amp_master_grad_static.py b/test/amp/test_amp_master_grad_static.py
@@ -46,7 +46,7 @@ def _check_optimizer(self, program, expected_num_mp):
         self.assertEqual(
             actual_num_mp,
             expected_num_mp,
-            f"The number of optimizers with multi_precison = True is expected to be {expected_num_mp}, but received {actual_num_mp}.",
+            f"The number of optimizers with multi_precision = True is expected to be {expected_num_mp}, but received {actual_num_mp}.",
         )
 
     def amp_fp16_o2(self, use_master_grad):
@@ -107,7 +107,7 @@ def _generate_feed_x(self, dtype="float16"):
             x_f16 = x.astype(np.float16)
             x_f32 = x_f16.astype(np.float32)
         else:
-            raise AssertionError(f"unkown dtype:{dtype}")
+            raise AssertionError(f"unknown dtype:{dtype}")
         return x_f32, x_f16
 
     def test_compare_o1_and_o2_master_grad(self):
diff --git a/test/amp/test_compare_accuracy_api.py b/test/amp/test_compare_accuracy_api.py
@@ -44,7 +44,7 @@ def test(self):
         self.calc(fp32_path, "float32")
         self.calc(fp16_path, "float16")
 
-        out_excel = "compary_accuracy_out_excel.csv"
+        out_excel = "compare_accuracy_out_excel.csv"
         paddle.amp.debugging.compare_accuracy(
             fp32_path,
             fp16_path,
@@ -57,7 +57,7 @@ def test2(self):
         fp32_path = "workerlog_fp32_log_dir"
         fp16_path = "workerlog_fp16_null_log_dir"
         self.calc(fp32_path, "float32")
-        out_excel = "compary_accuracy_out_excel_2.csv"
+        out_excel = "compare_accuracy_out_excel_2.csv"
         paddle.amp.debugging.compare_accuracy(
             fp32_path,
             fp16_path,
diff --git a/test/amp/test_model_cast_to_bf16.py b/test/amp/test_model_cast_to_bf16.py
@@ -212,7 +212,7 @@ def _check_optimizer(self, program, expected_num_mp):
         self.assertEqual(
             actual_num_mp,
             expected_num_mp,
-            f"The number of optimizers with multi_precison = True is expected to be {expected_num_mp}, but received {actual_num_mp}.",
+            f"The number of optimizers with multi_precision = True is expected to be {expected_num_mp}, but received {actual_num_mp}.",
         )
 
     def test_amp_bf16_o1(self):
diff --git a/test/asp/test_asp_customized_pruning.py b/test/asp/test_asp_customized_pruning.py
@@ -74,7 +74,7 @@ def test_add_supported_layer_via_name(self):
         )
 
 
-class TestASPDynamicCustomerizedPruneFunc(unittest.TestCase):
+class TestASPDynamicCustomizedPruneFunc(unittest.TestCase):
     def setUp(self):
         paddle.disable_static()
 
@@ -184,7 +184,7 @@ def test_training_pruning(self):
         self.assertEqual(supported_layer_count, self.supported_layer_count_ref)
 
 
-class TestASPStaticCustomerizedPruneFunc(unittest.TestCase):
+class TestASPStaticCustomizedPruneFunc(unittest.TestCase):
     def setUp(self):
         paddle.enable_static()
 
diff --git a/test/auto_parallel/custom_op/semi_auto_parallel_for_custom_op.py b/test/auto_parallel/custom_op/semi_auto_parallel_for_custom_op.py
@@ -29,7 +29,7 @@
 assert core.contains_spmd_rule("custom_relu")
 
 
-class TestCusomOpSemiAutoParallel(SemiAutoParallelTestBase):
+class TestCustomOpSemiAutoParallel(SemiAutoParallelTestBase):
     def __init__(self):
         super().__init__()
         self._backend = os.getenv("backend")
@@ -86,4 +86,4 @@ def run_test_case(self):
 
 
 if __name__ == '__main__':
-    TestCusomOpSemiAutoParallel().run_test_case()
+    TestCustomOpSemiAutoParallel().run_test_case()
diff --git a/test/auto_parallel/custom_op/test_semi_auto_parallel_custom_op.py b/test/auto_parallel/custom_op/test_semi_auto_parallel_custom_op.py
@@ -21,7 +21,7 @@
 from paddle.utils.cpp_extension.extension_utils import run_cmd
 
 
-class TestCusomOp(test_base.CommunicationTestDistBase):
+class TestCustomOp(test_base.CommunicationTestDistBase):
     def setUp(self):
         super().setUp(num_of_devices=2, timeout=200, nnode=1)
         self._default_envs = {"dtype": "float32", "seed": "2023"}
diff --git a/test/auto_parallel/hybrid_strategy/semi_auto_parallel_llama_model.py b/test/auto_parallel/hybrid_strategy/semi_auto_parallel_llama_model.py
@@ -1052,11 +1052,11 @@ def scaled_dot_product_attention(
     else:
         #  [ bz, seqlen, nhead, head_dim] -> [bs, nhead, seq_len, head_dim]
         query_states = paddle.transpose(query_states, [0, 2, 1, 3])
-        # merge with the next tranpose
+        # merge with the next transpose
         key_states = paddle.transpose(key_states, [0, 2, 1, 3])
         value_states = paddle.transpose(value_states, [0, 2, 1, 3])
 
-        # matmul and devide by sqrt(head_dim)
+        # matmul and divide by sqrt(head_dim)
         attn_weights = paddle.matmul(
             query_states / math.sqrt(head_dim),
             key_states.transpose([0, 1, 3, 2]),
diff --git a/test/auto_parallel/hybrid_strategy/semi_auto_parallel_simple_net_dp_mp_pp.py b/test/auto_parallel/hybrid_strategy/semi_auto_parallel_simple_net_dp_mp_pp.py
@@ -51,7 +51,7 @@ def __init__(self):
 
     def dp_mp_pp_shard_fn(self, layer_name, layer, process_mesh):
         if layer_name == 'linear_0':
-            # shard_layer doens't support cross-mesh now.
+            # shard_layer doesn't support cross-mesh now.
             # input process_mesh of pp_shard_fn is useless,
             # it's defined just for unified format.
             layer.weight = dist.shard_tensor(
diff --git a/test/auto_parallel/hybrid_strategy/test_cross_mesh_reshard.py b/test/auto_parallel/hybrid_strategy/test_cross_mesh_reshard.py
@@ -52,7 +52,7 @@ def setUp(self):
         }
         self._changeable_envs = {"backend": ["gpu"]}
 
-    def test_simple_net_bybrid_strategy(self):
+    def test_simple_net_hybrid_strategy(self):
         envs_list = test_base.gen_product_envs_list(
             self._default_envs, self._changeable_envs
         )
diff --git a/test/auto_parallel/spmd_rules/test_cross_entropy_with_softmax_rule.py b/test/auto_parallel/spmd_rules/test_cross_entropy_with_softmax_rule.py
@@ -36,11 +36,11 @@ def setUp(self):
         self.x_dist_tensor_spec = DistTensorSpec(x_shape, x_tensor_dist_attr)
         label_tensor_dist_attr = TensorDistAttr()
         label_tensor_dist_attr.process_mesh = process_mesh
-        self.lable_dist_tensor_spec = DistTensorSpec(
+        self.label_dist_tensor_spec = DistTensorSpec(
             label_shape, label_tensor_dist_attr
         )
 
-        self.loss_spec = DistTensorSpec(self.lable_dist_tensor_spec)
+        self.loss_spec = DistTensorSpec(self.label_dist_tensor_spec)
         self.softmax_out_spec = DistTensorSpec(self.x_dist_tensor_spec)
 
         self.attrs = OrderedDict(
@@ -56,11 +56,11 @@ def setUp(self):
     def test_cross_entropy_with_softmax_infer_forward(self):
         # GPT DP case
         self.x_dist_tensor_spec.set_dims_mapping([1, -1, -1])
-        self.lable_dist_tensor_spec.set_dims_mapping([-1, 0, -1])
+        self.label_dist_tensor_spec.set_dims_mapping([-1, 0, -1])
 
         result_dist_attrs = self.rule1.infer_forward(
             self.x_dist_tensor_spec,
-            self.lable_dist_tensor_spec,
+            self.label_dist_tensor_spec,
             self.attrs['soft_label'],
             self.attrs['use_softmax'],
             self.attrs['numeric_stable_mode'],
@@ -86,11 +86,11 @@ def test_cross_entropy_with_softmax_infer_forward(self):
 
         # GPT MP case, shard normalized axis
         self.x_dist_tensor_spec.set_dims_mapping([-1, -1, 0])
-        self.lable_dist_tensor_spec.set_dims_mapping([-1, -1, -1])
+        self.label_dist_tensor_spec.set_dims_mapping([-1, -1, -1])
 
         result_dist_attrs = self.rule1.infer_forward(
             self.x_dist_tensor_spec,
-            self.lable_dist_tensor_spec,
+            self.label_dist_tensor_spec,
             self.attrs['soft_label'],
             self.attrs['use_softmax'],
             self.attrs['numeric_stable_mode'],
@@ -112,11 +112,11 @@ def test_cross_entropy_with_softmax_infer_forward(self):
 
         # GPT MP-DP case
         self.x_dist_tensor_spec.set_dims_mapping([-1, -1, 0])
-        self.lable_dist_tensor_spec.set_dims_mapping([1, -1, -1])
+        self.label_dist_tensor_spec.set_dims_mapping([1, -1, -1])
 
         result_dist_attrs = self.rule1.infer_forward(
             self.x_dist_tensor_spec,
-            self.lable_dist_tensor_spec,
+            self.label_dist_tensor_spec,
             self.attrs['soft_label'],
             self.attrs['use_softmax'],
             self.attrs['numeric_stable_mode'],
@@ -135,11 +135,11 @@ def test_cross_entropy_with_softmax_infer_forward(self):
         # Soft Label Error
         self.attrs['soft_label'] = True
         self.x_dist_tensor_spec.set_dims_mapping([-1, -1, 0])
-        self.lable_dist_tensor_spec.set_dims_mapping([1, -1, -1])
+        self.label_dist_tensor_spec.set_dims_mapping([1, -1, -1])
         with self.assertRaises(ValueError):
             result_dist_attrs = self.rule1.infer_forward(
                 self.x_dist_tensor_spec,
-                self.lable_dist_tensor_spec,
+                self.label_dist_tensor_spec,
                 self.attrs['soft_label'],
                 self.attrs['use_softmax'],
                 self.attrs['numeric_stable_mode'],
@@ -151,10 +151,10 @@ def test_cross_entropy_with_softmax_infer_forward(self):
         # Normalized axis
         self.attrs['axis'] = 1
         self.x_dist_tensor_spec.set_dims_mapping([1, -1, 0])
-        self.lable_dist_tensor_spec.set_dims_mapping([-1, -1, -1])
+        self.label_dist_tensor_spec.set_dims_mapping([-1, -1, -1])
         result_dist_attrs = self.rule1.infer_forward(
             self.x_dist_tensor_spec,
-            self.lable_dist_tensor_spec,
+            self.label_dist_tensor_spec,
             self.attrs['soft_label'],
             self.attrs['use_softmax'],
             self.attrs['numeric_stable_mode'],
@@ -174,11 +174,11 @@ def test_cross_entropy_with_softmax_infer_forward(self):
         # Soft Normalized axis Error
         self.attrs['axis'] = 1
         self.x_dist_tensor_spec.set_dims_mapping([-1, 0, -1])
-        self.lable_dist_tensor_spec.set_dims_mapping([1, -1, -1])
+        self.label_dist_tensor_spec.set_dims_mapping([1, -1, -1])
         with self.assertRaises(ValueError):
             result_dist_attrs = self.rule1.infer_forward(
                 self.x_dist_tensor_spec,
-                self.lable_dist_tensor_spec,
+                self.label_dist_tensor_spec,
                 self.attrs['soft_label'],
                 self.attrs['use_softmax'],
                 self.attrs['numeric_stable_mode'],
@@ -191,10 +191,10 @@ def test_cross_entropy_with_softmax_infer_forward(self):
         self.attrs['axis'] = 1
         self.attrs['use_softmax'] = False
         self.x_dist_tensor_spec.set_dims_mapping([1, -1, 0])
-        self.lable_dist_tensor_spec.set_dims_mapping([-1, -1, -1])
+        self.label_dist_tensor_spec.set_dims_mapping([-1, -1, -1])
         result_dist_attrs = self.rule1.infer_forward(
             self.x_dist_tensor_spec,
-            self.lable_dist_tensor_spec,
+            self.label_dist_tensor_spec,
             self.attrs['soft_label'],
             self.attrs['use_softmax'],
             self.attrs['numeric_stable_mode'],
@@ -228,7 +228,7 @@ def test_cross_entropy_with_softmax_infer_backward(self):
 
         result_dist_attrs = self.rule1.infer_backward(
             self.x_dist_tensor_spec,
-            self.lable_dist_tensor_spec,
+            self.label_dist_tensor_spec,
             self.softmax_out_spec,
             self.loss_spec,
             self.attrs['soft_label'],
@@ -266,7 +266,7 @@ def test_cross_entropy_with_softmax_infer_backward(self):
 
         result_dist_attrs = self.rule1.infer_backward(
             self.x_dist_tensor_spec,
-            self.lable_dist_tensor_spec,
+            self.label_dist_tensor_spec,
             self.softmax_out_spec,
             self.loss_spec,
             self.attrs['soft_label'],
@@ -300,7 +300,7 @@ def test_cross_entropy_with_softmax_infer_backward(self):
 
         result_dist_attrs = self.rule1.infer_backward(
             self.x_dist_tensor_spec,
-            self.lable_dist_tensor_spec,
+            self.label_dist_tensor_spec,
             self.softmax_out_spec,
             self.loss_spec,
             self.attrs['soft_label'],
@@ -333,7 +333,7 @@ def test_cross_entropy_with_softmax_infer_backward(self):
         self.loss_spec.set_dims_mapping([1, -1, -1])
         result_dist_attrs = self.rule1.infer_backward(
             self.x_dist_tensor_spec,
-            self.lable_dist_tensor_spec,
+            self.label_dist_tensor_spec,
             self.softmax_out_spec,
             self.loss_spec,
             self.attrs['soft_label'],
@@ -366,7 +366,7 @@ def test_cross_entropy_with_softmax_infer_backward(self):
         self.loss_spec.set_dims_mapping([1, -1, -1])
         result_dist_attrs = self.rule1.infer_backward(
             self.x_dist_tensor_spec,
-            self.lable_dist_tensor_spec,
+            self.label_dist_tensor_spec,
             self.softmax_out_spec,
             self.loss_spec,
             self.attrs['soft_label'],
@@ -399,7 +399,7 @@ def test_cross_entropy_with_softmax_infer_backward(self):
         self.loss_spec.set_dims_mapping([1, -1, 0])
         result_dist_attrs = self.rule1.infer_backward(
             self.x_dist_tensor_spec,
-            self.lable_dist_tensor_spec,
+            self.label_dist_tensor_spec,
             self.softmax_out_spec,
             self.loss_spec,
             self.attrs['soft_label'],
diff --git a/test/auto_parallel/spmd_rules/test_embedding_rule.py b/test/auto_parallel/spmd_rules/test_embedding_rule.py
@@ -206,7 +206,7 @@ def test_embedding_infer_backward(self):
         self.assertEqual(infered_output_dist_attrs[0].dims_mapping, [1, 0, -1])
 
         # table row-wise parallel
-        # skiped
+        # skipped
 
 
 if __name__ == "__main__":

Original file line number	Diff line number	Diff line change
`@@ -212,7 +212,7 @@ def _check_optimizer(self, program, expected_num_mp):`
`212`	`212`	`self.assertEqual(`
`213`	`213`	`actual_num_mp,`
`214`	`214`	`expected_num_mp,`
`215`		`- f"The number of optimizers with multi_precison = True is expected to be {expected_num_mp}, but received {actual_num_mp}.",`
	`215`	`+ f"The number of optimizers with multi_precision = True is expected to be {expected_num_mp}, but received {actual_num_mp}.",`
`216`	`216`	`)`
`217`	`217`
`218`	`218`	`def test_amp_bf16_o1(self):`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ def setUp(self):`
`52`	`52`	`}`
`53`	`53`	`self._changeable_envs = {"backend": ["gpu"]}`
`54`	`54`
`55`		`- def test_simple_net_bybrid_strategy(self):`
	`55`	`+ def test_simple_net_hybrid_strategy(self):`
`56`	`56`	`envs_list = test_base.gen_product_envs_list(`
`57`	`57`	`self._default_envs, self._changeable_envs`
`58`	`58`	`)`