Fix typos in multiple files (#10274)

Co-authored-by: Rishi Puri <riship@nvidia.com>

Author: co63oc

benchmark/multi_gpu/training/README.md

@@ -44,7 +44,7 @@ pip install torch==2.1.0.post2 intel-extension-for-pytorch==2.1.30+xpu --extra-i
 
 ### Running benchmark
 
-This [guide](https://intel.github.io/intel-extension-for-pytorch/xpu/latest/tutorials/features/DDP.html) is helpful for you to lauch DDP training on intel GPU.
+This [guide](https://intel.github.io/intel-extension-for-pytorch/xpu/latest/tutorials/features/DDP.html) is helpful for you to launch DDP training on intel GPU.
 
 To Run benchmark, e.g. assuming you have `n` XPUs:
 

benchmark/multi_gpu/training/common.py

@@ -122,7 +122,7 @@ def run(rank: int, world_size: int, args: argparse.ArgumentParser,
         num_neighbors = [num_neighbors] * args.num_layers
 
     if len(num_neighbors) != args.num_layers:
-        err_msg = (f'num_neighbors={num_neighbors} lenght != num of'
+        err_msg = (f'num_neighbors={num_neighbors} length != num of'
                    'layers={args.num_layers}')
 
     kwargs = {

benchmark/training/training_benchmark.py

@@ -170,7 +170,7 @@ def run(args: argparse.ArgumentParser):
 
                     assert len(
                         num_neighbors) == layers, \
-                        f'''num_neighbors={num_neighbors} lenght
+                        f'''num_neighbors={num_neighbors} length
                         != num of layers={layers}'''
 
                     kwargs = {

docs/source/advanced/hgam.rst

@@ -115,7 +115,7 @@ Here, we show examples of how to use the HGAM functionality in combination with
       >>> [128, 508, 1598]  # Number of sampled paper nodes per hop/layer.
 
       print(batch['author', 'writes', 'paper'].num_sampled_edges)
-      >>>> [629, 2621]  # Number of sampled autor<>paper edges per hop/layer.
+      >>>> [629, 2621]  # Number of sampled author<>paper edges per hop/layer.
 
 The attributes :obj:`num_sampled_nodes` and :obj:`num_sampled_edges` can be used by the :meth:`~torch_geometric.utils.trim_to_layer` function inside the GNN:
 

docs/source/advanced/sparse_tensor.rst

@@ -44,9 +44,9 @@ Under the hood, the :class:`~torch_geometric.nn.conv.message_passing.MessagePass
     # Aggregate messages based on target node indices
     out = scatter(msg, edge_index[1], dim=0, dim_size=x.size(0), reduce='sum')
 
-While the gather-scatter formulation generalizes to a lot of useful GNN implementations, it has the disadvantage of explicitely materalizing :obj:`x_j` and :obj:`x_i`, resulting in a high memory footprint on large and dense graphs.
+While the gather-scatter formulation generalizes to a lot of useful GNN implementations, it has the disadvantage of explicitly materalizing :obj:`x_j` and :obj:`x_i`, resulting in a high memory footprint on large and dense graphs.
 
-Luckily, not all GNNs need to be implemented by explicitely materalizing :obj:`x_j` and/or :obj:`x_i`.
+Luckily, not all GNNs need to be implemented by explicitly materalizing :obj:`x_j` and/or :obj:`x_i`.
 In some cases, GNNs can also be implemented as a simple-sparse matrix multiplication.
 As a general rule of thumb, this holds true for GNNs that do not make use of the central node features :obj:`x_i` or multi-dimensional edge features when computing messages.
 For example, the :class:`~torch_geometric.nn.conv.GINConv` layer

docs/source/modules/nn.rst

@@ -76,7 +76,7 @@ For this, an :obj:`index` vector defines the mapping from input elements to thei
 
 Notably, all aggregations share the same set of forward arguments, as described in detail in the :class:`torch_geometric.nn.aggr.Aggregation` base class.
 
-Each of the provided aggregations can be used within :class:`~torch_geometric.nn.conv.MessagePassing` as well as for hierachical/global pooling to obtain graph-level representations:
+Each of the provided aggregations can be used within :class:`~torch_geometric.nn.conv.MessagePassing` as well as for hierarchical/global pooling to obtain graph-level representations:
 
 .. code-block:: python
 
@@ -101,7 +101,7 @@ Each of the provided aggregations can be used within :class:`~torch_geometric.nn
            self.global_pool = aggr.SortAggregation(k=4)
            self.classifier = torch.nn.Linear(...)
 
-        def foward(self, x, edge_index, batch):
+        def forward(self, x, edge_index, batch):
             x = self.conv(x, edge_index).relu()
             x = self.global_pool(x, batch)
             x = self.classifier(x)
@@ -129,7 +129,7 @@ Secondly, **multiple aggregations** can be combined and stacked via the :class:`
            super().__init__(aggr=aggr.MultiAggregation(
                ['mean', 'std', aggr.SoftmaxAggregation(learn=True)]))
 
-Importantly, :class:`~torch_geometric.nn.aggr.MultiAggregation` provides various options to combine the outputs of its underlying aggegations (*e.g.*, using concatenation, summation, attention, ...) via its :obj:`mode` argument.
+Importantly, :class:`~torch_geometric.nn.aggr.MultiAggregation` provides various options to combine the outputs of its underlying aggregations (*e.g.*, using concatenation, summation, attention, ...) via its :obj:`mode` argument.
 The default :obj:`mode` performs concatenation (:obj:`"cat"`).
 For combining via attention, we need to additionally specify the :obj:`in_channels` :obj:`out_channels`, and :obj:`num_heads`:
 

docs/source/tutorial/distributed_pyg.rst

@@ -9,7 +9,7 @@ Distributed Training in PyG
     Developers and researchers can now take full advantage of distributed training on large-scale datasets which cannot be fully loaded in memory of one machine at the same time.
     This implementation doesn't require any additional packages to be installed on top of the default :pyg:`PyG` stack.
 
-In real life applications, graphs often consists of billions of nodes that cannott fit into a single system memory.
+In real life applications, graphs often consists of billions of nodes that cannot fit into a single system memory.
 This is when distributed training of Graph Neural Networks comes in handy.
 By allocating a number of partitions of the large graph into a cluster of CPUs, one can deploy synchronized model training on the whole dataset at once by making use of :pytorch:`PyTorch's` `Distributed Data Parallel (DDP) <https://pytorch.org/docs/stable/notes/ddp.html>`_ capabilities.
 This architecture seamlessly distributes training of Graph Neural Networks across multiple nodes via `Remote Procedure Calls (RPCs) <https://pytorch.org/docs/stable/rpc.html>`_ for efficient sampling and retrieval of non-local features with traditional DDP for model training.
@@ -174,7 +174,7 @@ The :class:`~torch_geometric.distributed.DistNeighborSampler` class provides ful
 
 A batch of seed nodes follows three main steps before it is made available for the model's :meth:`forward` pass by the data loader:
 
-#. **Distributed node sampling:** While the underlying priciples of neighbor sampling holds for the distributed case as well, the implementation slightly diverges from single-machine sampling.
+#. **Distributed node sampling:** While the underlying principles of neighbor sampling holds for the distributed case as well, the implementation slightly diverges from single-machine sampling.
    In distributed training, seed nodes can belong to different partitions, leading to simultaneous sampling on multiple machines for a single batch.
    Consequently, synchronization of sampling results across machines is necessary to obtain seed nodes for the subsequent layer, requiring modifications to the basic algorithm.
    For nodes within a local partition, the sampling occurs on the local machine.

docs/source/tutorial/graph_transformer.rst

@@ -146,7 +146,7 @@ Combine local and global outputs
             out = self.norm3(out)
 
 Next, we introduce GraphGPS architecture. The difference between `GraphGPS <https://arxiv.org/abs/2205.12454>`_ and `GraphTrans <https://arxiv.org/abs/2201.08821>`_ is the organization of MPNN and transformer.
-In GraphTrans, a few layers of MPNNs are comprised before the Transformer, which may be limited by problems of over-smoothing, over-squashing and low expressivity agianst the WL test.
+In GraphTrans, a few layers of MPNNs are comprised before the Transformer, which may be limited by problems of over-smoothing, over-squashing and low expressivity against the WL test.
 These layers could irreparably fail to keep some information in the early stage. The design of GraphGPS is a stacking of MPNN + transformer hybrid, which resolves
 the local expressivity bottlenecks by allowing information to spread across the graph via full-connectivity.
 

docs/source/tutorial/heterogeneous.rst

@@ -108,7 +108,7 @@ Utility Functions
 
 The :class:`torch_geometric.data.HeteroData` class provides a number of useful utility functions to modify and analyze the given graph.
 
-For example, single node or edge stores can be indiviually indexed:
+For example, single node or edge stores can be individually indexed:
 
 .. code-block:: python
 

examples/distributed/graphlearn_for_pytorch/dist_train_sage_supervised.py

@@ -208,7 +208,7 @@ def run_training_proc(
         '--num_training_procs',
         type=int,
         default=2,
-        help='The number of traning processes per node',
+        help='The number of training processes per node',
     )
     parser.add_argument(
         '--epochs',

examples/llm/g_retriever_utils/README.md

@@ -6,6 +6,6 @@
 | [`rag_graph_store.py`](./rag_graph_store.py)                     | A Proof of Concept Implementation of a RAG enabled GraphStore that can serve as a starting point for implementing a custom RAG Remote Backend                             |
 | [`rag_backend_utils.py`](./rag_backend_utils.py)                 | Utility functions used for loading a series of Knowledge Graph Triplets into the Remote Backend defined by a FeatureStore and GraphStore                                  |
 | [`rag_generate.py`](./rag_generate.py)                           | Script for generating a unique set of subgraphs from the WebQSP dataset using a custom defined retrieval algorithm (defaults to the FeatureStore and GraphStore provided) |
-| [`benchmark_model_archs_rag.py`](./benchmark_model_archs_rag.py) | Script for running a GNN/LLM benchmark on GRetriever while grid searching relevent architecture parameters and datasets.                                                  |
+| [`benchmark_model_archs_rag.py`](./benchmark_model_archs_rag.py) | Script for running a GNN/LLM benchmark on GRetriever while grid searching relevant architecture parameters and datasets.                                                  |
 
 NOTE: Evaluating performance on GRetriever with smaller sample sizes may result in subpar performance. It is not unusual for the fine-tuned model/LLM to perform worse than an untrained LLM on very small sample sizes.

examples/llm/g_retriever_utils/benchmark_model_archs_rag.py

@@ -47,7 +47,7 @@
 if not args.dataset_path:
     ds = WebQSPDataset('benchmark_archs', verbose=True, force_reload=True)
 else:
-    # We just assume that the size of the dataset accomodates the
+    # We just assume that the size of the dataset accommodates the
     # train/val/test split, because checking may be expensive.
     dataset = torch.load(args.dataset_path)
 

examples/llm/g_retriever_utils/rag_backend_utils.py

@@ -32,7 +32,7 @@
 
 RemoteGraphBackend = Tuple[FeatureStore, GraphStore]
 
-# TODO: Make everything compatible with Hetero graphs aswell
+# TODO: Make everything compatible with Hetero graphs as well
 
 
 # Adapted from LocalGraphStore
@@ -161,7 +161,7 @@ class to use. Defaults to LocalFeatureStore.
         pre_transform (Callable[[TripletLike], TripletLike] | None, optional):
             optional preprocessing function for triplets. Defaults to None.
         path (str, optional): path to save resulting stores. Defaults to ''.
-        n_parts (int, optional): Number of partitons to store in.
+        n_parts (int, optional): Number of partitions to store in.
             Defaults to 1.
         node_method_kwargs (Optional[Dict[str, Any]], optional): args to pass
             into node encoding method. Defaults to None.

examples/llm/glem.py

@@ -8,7 +8,7 @@
 from peft.
 
 ``note::
-    use addtional trick, please add your external prediction by assigning
+    use additional trick, please add your external prediction by assigning
     `ext_pred_path` and combine it into pretraining phase and node features
 """
 
@@ -96,7 +96,7 @@ def main(args):
     split_idx['valid']
     test_idx = split_idx['test']
 
-    # randome sample pseudo labels nodes, generate their index
+    # random sample pseudo labels nodes, generate their index
     num_pseudo_labels = int(gold_idx.numel() * pl_ratio)
     idx_to_select = torch.randperm(test_idx.numel())[:num_pseudo_labels]
     pseudo_labels_idx = test_idx[idx_to_select]

examples/randlanet_classification.py

@@ -38,7 +38,7 @@ def __init__(self, *args, **kwargs):
         kwargs['act'] = kwargs.get('act', 'LeakyReLU')
         kwargs['act_kwargs'] = kwargs.get('act_kwargs', lrelu02_kwargs)
         # BatchNorm with 1 - 0.99 = 0.01 momentum
-        # and 1e-6 eps by defaut (tensorflow momentum != pytorch momentum)
+        # and 1e-6 eps by default (tensorflow momentum != pytorch momentum)
         kwargs['norm_kwargs'] = kwargs.get('norm_kwargs', bn099_kwargs)
         super().__init__(*args, **kwargs)
 
@@ -72,7 +72,7 @@ def message(self, x_j: Tensor, pos_i: Tensor, pos_j: Tensor,
             (Tensor): locSE weighted by feature attention scores.
 
         """
-        # Encode local neighboorhod structural information
+        # Encode local neighborhood structural information
         pos_diff = pos_j - pos_i
         distance = torch.sqrt((pos_diff * pos_diff).sum(1, keepdim=True))
         relative_infos = torch.cat([pos_i, pos_j, pos_diff, distance],

examples/tgn.py

@@ -8,7 +8,7 @@
 # the batch, the TGN paper code has access to previous interactions in the
 # batch.
 # While both approaches are correct, together with the authors of the paper we
-# decided to present this version here as it is more realsitic and a better
+# decided to present this version here as it is more realistic and a better
 # test bed for future methods.
 
 import os.path as osp

test/nn/models/test_graph_mixer.py

@@ -20,7 +20,7 @@ def test_node_encoder():
     out = encoder(x, edge_index, edge_time, seed_time)
     # Node 0 aggregates information from node 2 (excluding node 1).
     # Node 1 aggregates information from node 0.
-    # Node 2 aggregates information from node 0 and node 1 (exluding node 3).
+    # Node 2 aggregates information from node 0 and node 1 (excluding node 3).
     # Node 3 aggregates no information.
     expected = torch.tensor([
         [0 + 2],

torch_geometric/data/feature_store.py

@@ -409,7 +409,7 @@ def remove_tensor(self, *args, **kwargs) -> bool:
     def update_tensor(self, tensor: FeatureTensorType, *args,
                       **kwargs) -> bool:
         r"""Updates a :obj:`tensor` in the :class:`FeatureStore` with a new
-        value. Returns whether the update was succesful.
+        value. Returns whether the update was successful.
 
         .. note::
             Implementor classes can choose to define more efficient update

torch_geometric/data/hetero_data.py

@@ -566,7 +566,7 @@ def collect(
             This is equivalent to writing :obj:`data.x_dict`.
 
         Args:
-            key (str): The attribute to collect from all node and ege types.
+            key (str): The attribute to collect from all node and edge types.
             allow_empty (bool, optional): If set to :obj:`True`, will not raise
                 an error in case the attribute does not exit in any node or
                 edge type. (default: :obj:`False`)

torch_geometric/data/hypergraph_data.py

@@ -39,7 +39,7 @@ class HyperGraphData(Data):
         edge_index (LongTensor, optional): Hyperedge tensor
             with shape :obj:`[2, num_edges*num_nodes_per_edge]`.
             Where `edge_index[1]` denotes the hyperedge index and
-            `edge_index[0]` denotes the node indicies that are connected
+            `edge_index[0]` denotes the node indices that are connected
             by the hyperedge. (default: :obj:`None`)
             (default: :obj:`None`)
         edge_attr (torch.Tensor, optional): Edge feature matrix with shape

torch_geometric/datasets/airfrans.py

@@ -25,7 +25,7 @@ class AirfRANS(InMemoryDataset):
     features: the inlet velocity (two components in meter per second), the
     distance to the airfoil (one component in meter), and the normals (two
     components in meter, set to :obj:`0` if the point is not on the airfoil).
-    Each point is given a target of 4 components for the underyling regression
+    Each point is given a target of 4 components for the underlying regression
     task: the velocity (two components in meter per second), the pressure
     divided by the specific mass (one component in meter squared per second
     squared), the turbulent kinematic viscosity (one component in meter squared

torch_geometric/datasets/tag_dataset.py

@@ -277,7 +277,7 @@ def tokenize_graph(self, batch_size: int = 256) -> Dict[str, Tensor]:
             for k, tensor in all_encoded_token.items():
                 torch.save(tensor, os.path.join(path, f'{k}.pt'))
                 print('Token saved:', os.path.join(path, f'{k}.pt'))
-        os.environ["TOKENIZERS_PARALLELISM"] = 'true'  # supressing warning
+        os.environ["TOKENIZERS_PARALLELISM"] = 'true'  # suppressing warning
         return all_encoded_token
 
     def __repr__(self) -> str:

torch_geometric/distributed/partition.py

@@ -304,7 +304,7 @@ def generate_partition(self):
                 elif self.is_node_level_time:
                     node_time = data.time
 
-                # Sort by column to avoid keeping track of permuations in
+                # Sort by column to avoid keeping track of permutations in
                 # `NeighborSampler` when converting to CSC format:
                 global_row, global_col, perm = sort_csc(
                     global_row, global_col, node_time, edge_time)
@@ -361,7 +361,7 @@ def generate_partition(self):
             'edge_types': self.edge_types,
             'node_offset': list(node_offset.values()) if node_offset else None,
             'is_hetero': self.is_hetero,
-            'is_sorted': True,  # Based on colum/destination.
+            'is_sorted': True,  # Based on columnn/destination.
         }
         with open(osp.join(self.root, 'META.json'), 'w') as f:
             json.dump(meta, f)

torch_geometric/explain/algorithm/captum.py

@@ -190,7 +190,7 @@ def to_captum_input(
 
     Args:
         x (torch.Tensor or Dict[NodeType, torch.Tensor]): The node features.
-            For heterogeneous graphs this is a dictionary holding node featues
+            For heterogeneous graphs this is a dictionary holding node features
             for each node type.
         edge_index(torch.Tensor or Dict[EdgeType, torch.Tensor]): The edge
             indices. For heterogeneous graphs this is a dictionary holding the

torch_geometric/explain/metric/faithfulness.py

@@ -13,7 +13,7 @@ def unfaithfulness(
     top_k: Optional[int] = None,
 ) -> float:
     r"""Evaluates how faithful an :class:`~torch_geometric.explain.Explanation`
-    is to an underyling GNN predictor, as described in the
+    is to an underlying GNN predictor, as described in the
     `"Evaluating Explainability for Graph Neural Networks"
     <https://arxiv.org/abs/2208.09339>`_ paper.
 

torch_geometric/graphgym/models/layer.py

@@ -52,7 +52,7 @@ def new_layer_config(
     has_bias: bool,
     cfg,
 ) -> LayerConfig:
-    r"""Createa a layer configuration for a GNN layer.
+    r"""Create a layer configuration for a GNN layer.
 
     Args:
         dim_in (int): The input feature dimension.

torch_geometric/graphgym/utils/comp_budget.py

@@ -67,12 +67,12 @@ def dict_to_stats(cfg_dict):
 
 def match_baseline_cfg(cfg_dict, cfg_dict_baseline, verbose=True):
     """Match the computational budget of a given baseline model. The current
-    configuration dictionary will be modifed and returned.
+    configuration dictionary will be modified and returned.
 
     Args:
         cfg_dict (dict): Current experiment's configuration
         cfg_dict_baseline (dict): Baseline configuration
-        verbose (str, optional): If printing matched paramter conunts
+        verbose (str, optional): If printing matched parameter conunts
     """
     from yacs.config import CfgNode as CN
     stats_baseline = dict_to_stats(cfg_dict_baseline)

torch_geometric/index.py

@@ -104,7 +104,7 @@ class Index(Tensor):
     conversion in case its representation is sorted.
     Caches are filled based on demand (*e.g.*, when calling
     :meth:`Index.get_indptr`), or when explicitly requested via
-    :meth:`Index.fill_cache_`, and are maintaned and adjusted over its
+    :meth:`Index.fill_cache_`, and are maintained and adjusted over its
     lifespan.
 
     This representation ensures optimal computation in GNN message passing