PyPI - pyg-nightly - Versions diffs - 2.7.0.dev20250901__tar.gz → 2.7.0.dev20250903__tar.gz - Mend

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyg-nightly
-Version: 2.7.0.dev20250901
+Version: 2.7.0.dev20250903
 Summary: Graph Neural Network Library for PyTorch
 Keywords: deep-learning,pytorch,geometric-deep-learning,graph-neural-networks,graph-convolutional-networks
 Author-email: Matthias Fey <matthias@pyg.org>

@@ -4,7 +4,7 @@ build-backend="flit_core.buildapi"
 [project]
 name="pyg-nightly"
-version="2.7.0.dev20250901"
+version="2.7.0.dev20250903"
 authors=[
     {name="Matthias Fey", email="matthias@pyg.org"},
 ]

@@ -31,7 +31,7 @@ from .lazy_loader import LazyLoader
 contrib = LazyLoader('contrib', globals(), 'torch_geometric.contrib')
 graphgym = LazyLoader('graphgym', globals(), 'torch_geometric.graphgym')
-__version__ = '2.7.0.dev20250901'
+__version__ = '2.7.0.dev20250903'
 __all__ = [
     'Index',

@@ -11,7 +11,7 @@ This particular feature store abstraction makes a few key assumptions:
 * A feature can be uniquely identified from any associated attributes specified
   in `TensorAttr`.
-It is the job of a feature store implementor class to handle these assumptions
+It is the job of a feature store implementer class to handle these assumptions
 properly. For example, a simple in-memory feature store implementation may
 concatenate all metadata values with a feature index and use this as a unique
 index in a KV store. More complicated implementations may choose to partition
@@ -352,7 +352,7 @@ class FeatureStore(ABC):
         .. note::
             The default implementation simply iterates over all calls to
-            :meth:`get_tensor`. Implementor classes that can provide
+            :meth:`get_tensor`. Implementer classes that can provide
             additional, more performant functionality are recommended to
             to override this method.
@@ -412,7 +412,7 @@ class FeatureStore(ABC):
         value. Returns whether the update was successful.
         .. note::
-            Implementor classes can choose to define more efficient update
+            Implementer classes can choose to define more efficient update
             methods; the default performs a removal and insertion.
         Args:

@@ -10,7 +10,7 @@ This particular graph store abstraction makes a few key assumptions:
   support dynamic modification of edge indices once they have been inserted
   into the graph store.
-It is the job of a graph store implementor class to handle these assumptions
+It is the job of a graph store implementer class to handle these assumptions
 properly. For example, a simple in-memory graph store implementation may
 concatenate all metadata values with an edge index and use this as a unique
 index in a KV store. More complicated implementations may choose to partition

@@ -30,8 +30,8 @@ class AirfRANS(InMemoryDataset):
     divided by the specific mass (one component in meter squared per second
     squared), the turbulent kinematic viscosity (one component in meter squared
     per second).
-    Finaly, a boolean is attached to each point to inform if this point lies on
-    the airfoil or not.
+    Finally, a boolean is attached to each point to inform if this point lies
+    on the airfoil or not.
     A library for manipulating simulations of the dataset is available `here
     <https://airfrans.readthedocs.io/en/latest/index.html>`_.

@@ -79,7 +79,7 @@ class ModelNet(InMemoryDataset):
     urls = {
         '10':
-        'http://vision.princeton.edu/projects/2014/3DShapeNets/ModelNet10.zip',
+        'http://3dvision.princeton.edu/projects/2014/3DShapeNets/ModelNet10.zip',  # noqa
         '40': 'http://modelnet.cs.princeton.edu/ModelNet40.zip'
     }

@@ -361,7 +361,7 @@ class Partitioner:
             '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 columnn/destination.
+            'is_sorted': True,  # Based on column/destination.
         }
         with open(osp.join(self.root, 'META.json'), 'w') as f:
             json.dump(meta, f)

@@ -235,9 +235,9 @@ class ClusterData(torch.utils.data.Dataset):
 class ClusterLoader(torch.utils.data.DataLoader):
     r"""The data loader scheme from the `"Cluster-GCN: An Efficient Algorithm
     for Training Deep and Large Graph Convolutional Networks"
-    <https://arxiv.org/abs/1905.07953>`_ paper which merges partioned subgraphs
-    and their between-cluster links from a large-scale graph data object to
-    form a mini-batch.
+    <https://arxiv.org/abs/1905.07953>`_ paper which merges partitioned
+    subgraphs and their between-cluster links from a large-scale graph data
+    object to form a mini-batch.
     .. note::
@@ -252,7 +252,7 @@ class ClusterLoader(torch.utils.data.DataLoader):
     Args:
         cluster_data (torch_geometric.loader.ClusterData): The already
-            partioned data object.
+            partitioned data object.
         **kwargs (optional): Additional arguments of
             :class:`torch.utils.data.DataLoader`, such as :obj:`batch_size`,
             :obj:`shuffle`, :obj:`drop_last` or :obj:`num_workers`.

@@ -64,7 +64,7 @@ class MeshCNNConv(MessagePassing):
         :math:`\mathcal{N}(1) = (a(1), b(1), c(1), d(1)) = (2, 3, 4, 5)`
-    Because of this ordering constrait, :obj:`MeshCNNConv` **requires
+    Because of this ordering constraint, :obj:`MeshCNNConv` **requires
     that the columns of** :math:`A`
     **be ordered in the following way**:
@@ -149,7 +149,7 @@ class MeshCNNConv(MessagePassing):
     Args:
-        in_channels (int): Corresonds to :math:`\text{Dim-Out}(k)`
+        in_channels (int): Corresponds to :math:`\text{Dim-Out}(k)`
             in the above overview. This
             represents the output dimension of the prior layer. For the given
             input mesh :math:`\mathcal{m} = (V, F)`, the prior layer is
@@ -184,7 +184,7 @@ class MeshCNNConv(MessagePassing):
             a vector of dimensions :attr:`out_channels`.
     Discussion:
-        The key difference that seperates :obj:`MeshCNNConv` from a traditional
+        The key difference that separates :obj:`MeshCNNConv` from a traditional
         message passing graph neural network is that :obj:`MeshCNNConv`
         requires the set of neighbors for a node
         :math:`\mathcal{N}(u) = (v_1, v_2, ...)`
@@ -198,7 +198,7 @@ class MeshCNNConv(MessagePassing):
         :math:`\mathbb{S}_4`. Put more plainly, in tradition message passing
         GNNs, the network is *unable* to distinguish one neighboring node
         from another.
-        In constrast, in :obj:`MeshCNNConv`, each of the 4 neighbors has a
+        In contrast, in :obj:`MeshCNNConv`, each of the 4 neighbors has a
         "role", either the "a", "b", "c", or "d" neighbor. We encode this fact
         by requiring that :math:`\mathcal{N}` return the 4-tuple,
         where the first component is the "a" neighbor, and so on.
@@ -444,7 +444,7 @@ class MeshCNNConv(MessagePassing):
         """
         assert isinstance(kernels, ModuleList), \
             f"Parameter 'kernels' must be a \
-            torch.nn.module.ModuleList with 5 memebers, but we got \
+            torch.nn.module.ModuleList with 5 members, but we got \
             {type(kernels)}."
         assert len(kernels) == 5, "Parameter 'kernels' must be a \

@@ -37,7 +37,7 @@ class Polynormer(torch.nn.Module):
             (default: :obj:`True`)
         pre_ln (bool): Pre layer normalization.
             (default: :obj:`False`)
-        post_bn (bool): Post batch normlization.
+        post_bn (bool): Post batch normalization.
             (default: :obj:`True`)
         local_attn (bool): Whether use local attention.
             (default: :obj:`False`)

@@ -196,8 +196,8 @@ class InvertibleModule(torch.nn.Module):
 class GroupAddRev(InvertibleModule):
     r"""The Grouped Reversible GNN module from the `"Graph Neural Networks with
     1000 Layers" <https://arxiv.org/abs/2106.07476>`_ paper.
-    This module enables training of arbitary deep GNNs with a memory complexity
-    independent of the number of layers.
+    This module enables training of arbitrary deep GNNs with a memory
+    complexity independent of the number of layers.
     It does so by partitioning input node features :math:`\mathbf{X}` into
     :math:`C` groups across the feature dimension. Then, a grouped reversible

@@ -159,8 +159,8 @@ def jacobian_l1_agg_per_hop(
                             vectorize=vectorize)
     hop_subsets = k_hop_subsets_exact(node_idx, max_hops, edge_index,
                                       num_nodes, influence.device)
-    sigle_node_influence_per_hop = [influence[s].sum() for s in hop_subsets]
-    return torch.tensor(sigle_node_influence_per_hop, device=influence.device)
+    single_node_influence_per_hop = [influence[s].sum() for s in hop_subsets]
+    return torch.tensor(single_node_influence_per_hop, device=influence.device)
 def avg_total_influence(
@@ -169,7 +169,7 @@ def avg_total_influence(
 ) -> Tensor:
     """Compute the *influence‑weighted receptive field* ``R``."""
     avg_total_influences = torch.mean(influence_all_nodes, dim=0)
-    if normalize:  # nomalize by hop_0 (jacobian of the center node feature)
+    if normalize:  # normalize by hop_0 (jacobian of the center node feature)
         avg_total_influences = avg_total_influences / avg_total_influences[0]
     return avg_total_influences

pyg-nightly 2.7.0.dev20250901__tar.gz → 2.7.0.dev20250903__tar.gz

pyg-nightly 2.7.0.dev20250901tar.gz → 2.7.0.dev20250903tar.gz