Fix typo under test directory (pytorch#112346)

kiszk · pytorchmergebot · commit 908924204841 · 2023-11-03T07:53:33.000Z
This PR fixes typo in comments and messages under `test` directory. This PR also fixes related typo in messages under `torch` directory. Pull Request resolved: pytorch#112346 Approved by: https://github.com/kit1980, https://github.com/ezyang
diff --git a/test/distributed/_shard/sharded_optim/test_sharded_optim.py b/test/distributed/_shard/sharded_optim/test_sharded_optim.py
@@ -104,7 +104,7 @@ def test_sharded_optim(self):
         local_model = MyShardedModel().cuda()
         sharded_model = MyShardedModel(spec=rowwise_spec).cuda()
 
-        # copy the parameteres from local model
+        # copy the parameters from local model
         sharded_model.sharded_param.local_shards()[0].tensor = \
             local_model.sharded_param.detach().clone().requires_grad_()
 
diff --git a/test/distributed/_shard/sharded_tensor/test_sharded_tensor.py b/test/distributed/_shard/sharded_tensor/test_sharded_tensor.py
@@ -1594,7 +1594,7 @@ def test_sharded_tensor_to_cpu(self):
         # test ability to move st to CPU
         spec_before_move = st.sharding_spec()
         new_st = st.cpu(process_group=gloo_pg)
-        # return a copy of orginal st
+        # return a copy of original st
         self.assertFalse(st is new_st)
         # check the spec is still ChunkShardingSpec
         spec_after_move = new_st.sharding_spec()
@@ -1626,7 +1626,7 @@ def test_sharded_tensor_to_cpu(self):
 
         st = sharded_tensor.zeros(mixed_spec, h, w, process_group=gloo_pg)
         new_st = st.cpu()
-        # return a copy of orginal st
+        # return a copy of original st
         self.assertFalse(st is new_st)
         # check the spec is still ChunkShardingSpec
         spec_after_move = new_st.sharding_spec()
diff --git a/test/distributed/_spmd/test_tracing.py b/test/distributed/_spmd/test_tracing.py
@@ -669,7 +669,7 @@ def train_step(mod, opt, inp):
         train_step(mod, opt, inp)
         for node in train_step._compiled_obj.gm.graph.nodes:
             if node.target == torch.ops.aten.expand.default:
-                # backward grad expandion op should match local batch size
+                # backward grad expansion op should match local batch size
                 # instead of global batch size.
                 self.assertEqual(node.args[1], [2, 10])
 
diff --git a/test/distributed/_tensor/test_dtensor_ops.py b/test/distributed/_tensor/test_dtensor_ops.py
@@ -495,7 +495,7 @@ def wrapped(fn):
     xfail("zeros"),
     # ops inside this might even fail without dtensor
     # tests, as we rescale op db common test size factor (i.e. L, M, S)
-    # which triggered the orignal function run failures with input
+    # which triggered the original function run failures with input
     # generation becomes wrong, we skip them for now but should enable later.
     # TODO: need to clean this list and remove all cases
     skip("argwhere"),
@@ -643,7 +643,7 @@ def to_replicate(e: object) -> object:
                         # errors
                         dtensor_rs = func(*dtensor_args, **dtensor_kwargs)
 
-                        # we need to skip tests containing tensors of zero elmeents for now.
+                        # we need to skip tests containing tensors of zero elements for now.
                         # see issue: https://github.com/pytorch/tau/issues/470
                         # TODO remove this once issue above fixed.
                         flat_args = pytree.tree_leaves(dtensor_rs)
diff --git a/test/distributed/checkpoint/e2e/test_fine_tuning.py b/test/distributed/checkpoint/e2e/test_fine_tuning.py
@@ -93,7 +93,7 @@ def pretrain(self, pretrain_dir: str) -> None:
         model = FSDP(model, device_mesh=device_mesh)
         optim = torch.optim.Adam(model.parameters(), lr=1e-3)
 
-        # Trainining
+        # Training
         for i in range(3):
             batch = torch.rand(32, DIM, device="cuda")
             loss = model(batch).sum()
@@ -158,7 +158,7 @@ def finetune(self, pretrain_dir: str, finetune_dir: str) -> None:
                 # If this is the restart of the fine tuning, then checkpoint should exit.
                 self.assertEqual(i, 0)
 
-            # Trainining
+            # Training
             for j in range(3):
                 batch = torch.rand(32, DIM, device="cuda")
                 loss = model(batch).sum()
diff --git a/test/distributed/checkpoint/test_dtensor_resharding.py b/test/distributed/checkpoint/test_dtensor_resharding.py
@@ -87,7 +87,7 @@ def test_1d_to_1d_reshard_placement_change(self) -> None:
             )
             self.assertEqual(global_tensor, state_dict_to_load["dtensor"].to_local())
 
-            # redistribute the tensor back to its original placment for comparison.
+            # redistribute the tensor back to its original placement for comparison.
             state_dict_to_load["dtensor"] = state_dict_to_load["dtensor"].redistribute(
                 device_mesh,
                 placements=original_placement,
diff --git a/test/distributed/elastic/agent/server/test/local_elastic_agent_test.py b/test/distributed/elastic/agent/server/test/local_elastic_agent_test.py
@@ -336,7 +336,7 @@ def run_agent(
     ) -> Optional[RunResult]:
         """
         Runs a single agent. This method can be called either on a separate process
-        or the main test process. When calling this method on a sparate process make
+        or the main test process. When calling this method on a separate process make
         sure to pass the ``agent_results`` multiprocessing Queue so that the agent's
         run results can be returned. If ``agent_results`` is omitted, then the
         run result is returned from the method.
diff --git a/test/distributed/elastic/timer/local_timer_example.py b/test/distributed/elastic/timer/local_timer_example.py
@@ -40,7 +40,7 @@ def _stuck_function(rank, mp_queue):
         time.sleep(5)
 
 
-# timer is not supported on macos or windowns
+# timer is not supported on macos or windows
 if not (IS_WINDOWS or IS_MACOS):
     class LocalTimerExample(TestCase):
         """
diff --git a/test/distributed/fsdp/test_fsdp_core.py b/test/distributed/fsdp/test_fsdp_core.py
@@ -327,7 +327,7 @@ def test_pre_backward_hook_registration_after_state_dict(self):
     def _test_pre_backward_hook_registration(self, model):
         optim = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
         optim.zero_grad()
-        # Inputs always cuda, as computation happes on CUDA device only
+        # Inputs always cuda, as computation happens on CUDA device only
         input = model.module.get_input(torch.device("cuda"))
         output = model(*input)
         # this is pre-bwd hook
diff --git a/test/distributed/fsdp/test_fsdp_fine_tune.py b/test/distributed/fsdp/test_fsdp_fine_tune.py
@@ -181,7 +181,7 @@ def forward(self, x):
     def test_hooks_multi_traversal(self):
         """
         Tests that the hooks do reshard / unshard correctly in the case of same
-        parameters being used mutliple times during forward pass.
+        parameters being used multiple times during forward pass.
         """
         self.run_subtests(
             {
diff --git a/test/distributed/fsdp/test_fsdp_memory.py b/test/distributed/fsdp/test_fsdp_memory.py
@@ -191,8 +191,8 @@ def test_fsdp_memory(self, ckpt):
                 # sharded model size + sharded grad size + 1M temp memory
                 expected[f"iter {iteration}: after bwd"] = 2 * sharded_model_size_mb + 1
             else:
-                # after optimizer step in the first iteraiton, memory usage increased by
-                # sharded_model_size_mb becasue of increased optimizer states memory usage
+                # after optimizer step in the first iteration, memory usage increased by
+                # sharded_model_size_mb because of increased optimizer states memory usage
                 expected[f"iter {iteration}: start"] = 2 * sharded_model_size_mb + 1
                 if ckpt == "ckpt":
                     expected[f"iter {iteration}: after fwd"] = (
diff --git a/test/distributed/fsdp/test_fsdp_meta.py b/test/distributed/fsdp/test_fsdp_meta.py
@@ -108,7 +108,7 @@ def forward(self, x):
 def _init_with_reset_params(module: nn.Module):
     """
     to_empty + reset_parameters() init function example for modules
-    initailized with device="meta"
+    initialized with device="meta"
     """
     has_meta_states = any(
         t.is_meta
diff --git a/test/distributed/fsdp/test_fsdp_misc.py b/test/distributed/fsdp/test_fsdp_misc.py
@@ -507,7 +507,7 @@ def test_fsdp_cpu_init_stays_on_cpu(self):
         # Move me to MT test once warning logging and backward collective issue
         # is resolved.
         """Tests that passing a CPU module to FSDP preserves that the wrapped
-        module is on CPU after FSDP initialization, albeit after loging a
+        module is on CPU after FSDP initialization, albeit after logging a
         warning, and that FSDP moves CPU input to GPU before the forward."""
         torch.cuda.set_device(self.rank)
         regex = "passed-in `module` is on CPU"
diff --git a/test/distributed/fsdp/test_fsdp_state_dict.py b/test/distributed/fsdp/test_fsdp_state_dict.py
@@ -719,7 +719,7 @@ def test_save_and_load_after_forward_state_dict(
             optim.step()
 
         trained_params = get_full_params(model)
-        # Ensure some training occured
+        # Ensure some training occurred
         self.assertNotEqual(initial_params, trained_params)
         # Save a copy of the state_dict
         fsd_mgr = self._get_state_dict_mgr(
diff --git a/test/distributed/pipeline/sync/test_bugs.py b/test/distributed/pipeline/sync/test_bugs.py
@@ -49,7 +49,7 @@ def forward(self, input):
 
 def test_exception_no_hang(setup_rpc):
     # In v0.0.2, once a failed partition receives a normal message
-    # (non-closing) for the next micro-batch, a hang occured. The reason was
+    # (non-closing) for the next micro-batch, a hang occurred. The reason was
     # that a failed partition didn't call in_queue.task_done() on a normal
     # message. So the former partition was blocked at out_queue.join() for the
     # next of next micro-batch.
diff --git a/test/distributed/tensor/parallel/test_tp_random_state.py b/test/distributed/tensor/parallel/test_tp_random_state.py
@@ -115,11 +115,11 @@ def tp_weights_assert(tensor1, tensor2):
                 # compare local shards across TP groups
                 def dp_weights_assert(tensor1, tensor2):
                     if enable_distribute_flag:
-                        # local weights shall be initialized the same acorss TP groups
+                        # local weights shall be initialized the same across TP groups
                         self.assertEqual(tensor1, tensor2)
                     else:
                         # without the parallel RNG, weight initialization violates the TP setup:
-                        # local weights are initialized differently acorss TP groups due to different
+                        # local weights are initialized differently across TP groups due to different
                         # random seeds set in data loading.
                         self.assertNotEqual(tensor1, tensor2)
 
diff --git a/test/distributed/test_c10d_common.py b/test/distributed/test_c10d_common.py
@@ -137,7 +137,7 @@ def test_store_based_barrier(self):
         port = common.find_free_port()
 
         def thread_work(timeout, init_type, world_size, rank, error_list):
-            # we need to create a seperate store just for the store barrier test
+            # we need to create a separate store just for the store barrier test
             if init_type == "file":
                 barrier_store = dist.FileStore(f.name)
             elif init_type == "tcp":
@@ -572,7 +572,7 @@ def test_ddp_checkpointing_unused_params(self, use_reentrant):
     @parametrize("use_reentrant", [True, False])
     def test_ddp_checkpointing_twice(self, use_reentrant):
         """
-        Checkpoitning twice fails for non-static graph with reentrant checkpoint
+        Checkpointing twice fails for non-static graph with reentrant checkpoint
         implementation, succeeds with non-reentrant checkpoint implementation.
         """
         process_group = self._get_process_group()
@@ -684,7 +684,7 @@ def test_ddp_checkpointing_weight_sharing(self, use_reentrant):
     def test_ddp_checkpointing_twice_weight_sharing(self):
         """
         Checkpointing should work with static graph in the case of checkpointing
-        same layer twice and having weights shared acrosss layers.
+        same layer twice and having weights shared across layers.
         """
         process_group = self._get_process_group()
         torch.cuda.set_device(self.rank)
diff --git a/test/distributed/test_c10d_nccl.py b/test/distributed/test_c10d_nccl.py
@@ -2584,7 +2584,7 @@ def hook(work_info: torch._C._distributed_c10d.WorkInfo):
         pg._register_on_completion_hook(hook)
         tensor = torch.ones([2, 3]).cuda(self.rank)
         tensor_list = [torch.empty_like(tensor) for _ in range(self.world_size)]
-        # intentionall using async ops.
+        # intentionally using async ops.
         pg.allreduce(tensor)
         pg.allgather(tensor_list, tensor)
         pg.allreduce(tensor)
@@ -2936,7 +2936,7 @@ def _test_broadcast_coalesced(self, process_group, device, root_rank):
         target += torch.arange(60, dtype=half, device=device).chunk(5)
         target += torch.arange(60, dtype=torch.float32, device=device).chunk(5)
 
-        # The tensors to pass to broadcast are idential to the target
+        # The tensors to pass to broadcast are identical to the target
         # only on the process that is the root of the broadcast.
         if self.rank == root_rank:
             tensors = [tensor.clone() for tensor in target]
diff --git a/test/distributed/test_device_mesh.py b/test/distributed/test_device_mesh.py
@@ -196,7 +196,7 @@ def test_init_device_mesh(self):
     def test_raises_duplicate_mesh_dim_names(self):
         with self.assertRaisesRegex(
             RuntimeError,
-            "Each mesh_dim_name must be uqique.",
+            "Each mesh_dim_name must be unique.",
         ):
             mesh = init_device_mesh(
                 self.device_type,
diff --git a/test/distributed/test_dynamo_distributed.py b/test/distributed/test_dynamo_distributed.py
@@ -558,7 +558,7 @@ def opt_fn(inputs):
         self.assertTrue(same(correct_outputs, opt_outputs))
         self.assertEqual(check_splits_compiler.compiler_called, 3)
 
-        # ensure compatibilty with dynamo explain
+        # ensure compatibility with dynamo explain
 
         explain_out = torch._dynamo.explain(ddp_m)(inputs)
         break_reasons = explain_out.break_reasons
@@ -586,7 +586,7 @@ def opt_fn(inputs):
     def test_no_split(self):
         """
         Ensures the DDPOptimizer returns a correct, compiled module without
-        introducing graph splits. (Based on model parmeters fitting in the bucket)
+        introducing graph splits. (Based on model parameters fitting in the bucket)
         """
         # DDP will always do a 'first bucket' with a really small size;  so only a tiny model will escape this
         m, inputs, correct_outputs = self.get_model(hidden_feat=5)
diff --git a/test/dynamo/test_aot_autograd.py b/test/dynamo/test_aot_autograd.py
@@ -277,9 +277,9 @@ def capturing_fn(gm, inputs):
     # This test is a spiritual equivalent to test_invalid_requires_grad_fake in test_autodispatch.py
     # The point of this test is to invoke aot_autograd in a way that would normally trigger an assertion
     # (This is what test_invalid_requires_grad_fake) does. However, the point of this test is to prove
-    # that we do not hit this asseriton, as dynamo recompiles correctly and protects this condition.
+    # that we do not hit this assertion, as dynamo recompiles correctly and protects this condition.
     #
-    # Subnote: The reason for us having test_invalid_requires_grad_fake utilizing fake tenosrs
+    # Subnote: The reason for us having test_invalid_requires_grad_fake utilizing fake tensors
     # is because dynamo sends fake tensors down to aot_autograd.
     @patch("torch._functorch.config.debug_assert", True)
     def test_requires_grad_fake_via_dynamo_recompiles(self):
diff --git a/test/dynamo/test_exc.py b/test/dynamo/test_exc.py
@@ -280,7 +280,7 @@ def fn(x, shape):
             """\
 translation validation failed when evaluating: Eq(s1 + s2 + s3, s0)
 
-Failure ocurred while running node:
+Failure occurred while running node:
     %split : [num_users=1] = call_method[target=split](args = (%l_x_, (%l_shape_0_, %l_shape_1_, %l_shape_2_)), kwargs = {})
 
 Model:
diff --git a/test/dynamo/test_misc.py b/test/dynamo/test_misc.py
@@ -8150,8 +8150,8 @@ def test_shape_env_equal_runtime_assert(self):
         other.create_unbacked_symint()
 
         # Create a runtime assert: r % 3 == 0 (only in the main ShapeEnv)
-        #   - +1 defferred_runtime_asserts entry
-        #   - Change: num_defferred_runtime_asserts
+        #   - +1 deferred_runtime_asserts entry
+        #   - Change: num_deferred_runtime_asserts
         expect_true(r % 3 == 0)
 
         self.assertExpectedRaisesInline(
diff --git a/test/dynamo/test_modules.py b/test/dynamo/test_modules.py
@@ -1527,7 +1527,7 @@ def forward(self, x):
         mod = MockModule()
         opt_mod = torch._dynamo.optimize("eager")(mod)
 
-        # Check parameteres and buffers
+        # Check parameters and buffers
         for p1, p2 in zip(mod.parameters(), opt_mod.parameters()):
             self.assertTrue(id(p1) == id(p2))
         for b1, b2 in zip(mod.buffers(), opt_mod.buffers()):
@@ -1768,7 +1768,7 @@ def guard_fail_fn(failure):
 
         """
         Summary:
-          - removing a hook doesn't fail a guard, becuase we weren't compiling the hook
+          - removing a hook doesn't fail a guard, because we weren't compiling the hook
             (at least into the same graph) as forward in the first place! We do correctly
             omit calling the removed hook, but since this hook is a post forward hook,
             the 'RETURN' from forward is breaking the graph.
diff --git a/test/dynamo/test_python_autograd.py b/test/dynamo/test_python_autograd.py
@@ -95,7 +95,7 @@ def gather_grad(entries: List[str]):
         # perform chain rule propagation specific to each compute
         dL_dinputs = entry.propagate(dL_doutputs)
 
-        # Accululate the gradient produced for each input.
+        # Accumulate the gradient produced for each input.
         # Each use of a variable produces some gradient dL_dinput for that
         # use. The multivariate chain rule tells us it is safe to sum
         # all the contributions together.
diff --git a/test/dynamo/test_recompile_ux.py b/test/dynamo/test_recompile_ux.py
@@ -72,7 +72,7 @@ def loop_torture(input, iters):
         # self.assertEqual(counters["frames"]["ok"], 1 + self.cache_limit)
 
         # compile_counter only sees frames that were fed to the backend compiler,
-        # which is a subset of counters["frames"]["ok"] -- probably becuase
+        # which is a subset of counters["frames"]["ok"] -- probably because
         # counters["frames"]["ok"] includes frames not containing torch ops?
         self.assertEqual(compile_counter.frame_count, self.cache_limit)
 
@@ -104,7 +104,7 @@ def model(input):
     def test_nvfuser_guards(self):
         # we may want to model dynamo's guards sufficiently after nvfuser's ProfilingExecutor guards
         # such that we ensure dynamo is in charge of all the recompilations at the top level,
-        # and we could thus simplfy the underlying torchscript executor
+        # and we could thus simplify the underlying torchscript executor
         def func(a, b, c):
             return a + b * c
 
diff --git a/test/dynamo/test_replay_record.py b/test/dynamo/test_replay_record.py
@@ -176,7 +176,7 @@ def test_fn(x):
 
         self.check_replay(test_fn, torch.ones(1, 1), exp_exc_name="RuntimeError")
 
-    # Verfiy that we replay when we have tensor arguments to the frame being replayed
+    # Verify that we replay when we have tensor arguments to the frame being replayed
     @requires_dill
     def test_fn_call_args(self):
         def test_fn(x, y):
diff --git a/test/dynamo/test_repros.py b/test/dynamo/test_repros.py
@@ -513,7 +513,7 @@ def forward(self, x_spt, y_spt, x_qry, y_qry):
         corrects = [0 for _ in range(self.update_step_test + 1)]
 
         # in order to not ruin the state of running_mean/variance and bn_weight/bias
-        # we finetunning on the copied model instead of self.net
+        # we finetuning on the copied model instead of self.net
         net = deepcopy(self.net)
 
         # 1. run the i-th task and compute loss for k=0
diff --git a/test/dynamo/test_subclasses.py b/test/dynamo/test_subclasses.py
@@ -197,7 +197,7 @@ def fn(x):
             x.sigmoid()
 
         msg = (
-            "Accessing overidden method/attribute sigmoid on a tensor"
+            "Accessing overridden method/attribute sigmoid on a tensor"
             " subclass with a __torch_function__ override is not supported"
         )
         with torch._dynamo.config.patch(
@@ -221,7 +221,7 @@ def fn(x):
             return x.ndim
 
         msg = (
-            "Accessing overidden method/attribute ndim on a tensor"
+            "Accessing overridden method/attribute ndim on a tensor"
             " subclass with a __torch_function__ override is not supported"
         )
         with torch._dynamo.config.patch(
@@ -254,7 +254,7 @@ def fn(x):
             return x.ndim
 
         msg = (
-            "Accessing overidden method/attribute ndim on a tensor"
+            "Accessing overridden method/attribute ndim on a tensor"
             " subclass with a __torch_function__ override is not supported"
         )
         with torch._dynamo.config.patch(
@@ -613,7 +613,7 @@ def backend(gm, args):
             context = torch._guards.TracingContext.get()
             val_to_guards = list(context.fake_mode.shape_env.var_to_guards.values())
 
-            # Grab info on sources and guards from the shapenv
+            # Grab info on sources and guards from the shapeenv
             nonlocal lower_bound_str
             nonlocal upper_bound_str
             nonlocal curr_var_to_val
diff --git a/test/dynamo/test_unspec.py b/test/dynamo/test_unspec.py
@@ -110,7 +110,7 @@ def fn(x):
 
     # Really annoying intersection of specialization and RandomValueSource
     # If we get a RandomValueSource with a single element tensor, we should return a ConstantVariable like other
-    # unspects... but if we do, we break the bytecode assumptions and guards will not work as we will be reffering
+    # unspects... but if we do, we break the bytecode assumptions and guards will not work as we will be referring
     # to a name from a source that is not there. If we call .item() and take the wrapped_value out, where we do
     # wrapped_value = wrapped_value.item() where we send unspec down to wrap_fx_proxy, this test passes and then
     # some models fail on missing codegen.tx.output.random_values_var. If we let the tensor value go into wrap as
diff --git a/test/export/test_serialize.py b/test/export/test_serialize.py
diff --git a/test/functorch/attn_ft.py b/test/functorch/attn_ft.py
diff --git a/test/functorch/test_aotdispatch.py b/test/functorch/test_aotdispatch.py
diff --git a/test/functorch/test_control_flow.py b/test/functorch/test_control_flow.py
diff --git a/test/functorch/test_eager_transforms.py b/test/functorch/test_eager_transforms.py
diff --git a/test/functorch/test_ops.py b/test/functorch/test_ops.py
diff --git a/test/functorch/test_vmap.py b/test/functorch/test_vmap.py
diff --git a/test/fx/test_gradual_type.py b/test/fx/test_gradual_type.py
diff --git a/test/fx/test_subgraph_rewriter.py b/test/fx/test_subgraph_rewriter.py
diff --git a/test/fx/test_z3_gradual_types.py b/test/fx/test_z3_gradual_types.py
diff --git a/torch/_dynamo/variables/torch_function.py b/torch/_dynamo/variables/torch_function.py
diff --git a/torch/distributed/_device_mesh.py b/torch/distributed/_device_mesh.py
diff --git a/torch/fx/experimental/validator.py b/torch/fx/experimental/validator.py

Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ def test_1d_to_1d_reshard_placement_change(self) -> None:`
`87`	`87`	`)`
`88`	`88`	`self.assertEqual(global_tensor, state_dict_to_load["dtensor"].to_local())`
`89`	`89`
`90`		`- # redistribute the tensor back to its original placment for comparison.`
	`90`	`+ # redistribute the tensor back to its original placement for comparison.`
`91`	`91`	`state_dict_to_load["dtensor"] = state_dict_to_load["dtensor"].redistribute(`
`92`	`92`	`device_mesh,`
`93`	`93`	`placements=original_placement,`
Original file line number	Diff line number	Diff line change
`@@ -181,7 +181,7 @@ def forward(self, x):`
`181`	`181`	`def test_hooks_multi_traversal(self):`
`182`	`182`	`"""`
`183`	`183`	`Tests that the hooks do reshard / unshard correctly in the case of same`
`184`		`- parameters being used mutliple times during forward pass.`
	`184`	`+ parameters being used multiple times during forward pass.`
`185`	`185`	`"""`
`186`	`186`	`self.run_subtests(`
`187`	`187`	`{`