pyg-nightly 2.7.0.dev20250902__tar.gz → 2.7.0.dev20250904__tar.gz

{pyg_nightly-2.7.0.dev20250902 → pyg_nightly-2.7.0.dev20250904}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyg-nightly
-Version: 2.7.0.dev20250902
+Version: 2.7.0.dev20250904
 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>

{pyg_nightly-2.7.0.dev20250902 → pyg_nightly-2.7.0.dev20250904}/pyproject.toml

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

{pyg_nightly-2.7.0.dev20250902 → pyg_nightly-2.7.0.dev20250904}/torch_geometric/__init__.py

@@ -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.dev20250902'
+__version__ = '2.7.0.dev20250904'
 
 __all__ = [
     'Index',

{pyg_nightly-2.7.0.dev20250902 → pyg_nightly-2.7.0.dev20250904}/torch_geometric/data/data.py

@@ -1,5 +1,6 @@
 import copy
 import warnings
+from collections import defaultdict
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from itertools import chain
@@ -904,6 +905,60 @@ class Data(BaseData, FeatureStore, GraphStore):
 
         return data
 
+    def connected_components(self) -> List[Self]:
+        r"""Extracts connected components of the graph using a union-find
+        algorithm. The components are returned as a list of
+        :class:`~torch_geometric.data.Data` objects, where each object
+        represents a connected component of the graph.
+
+        .. code-block::
+
+            data = Data()
+            data.x = torch.tensor([[1.0], [2.0], [3.0], [4.0]])
+            data.y = torch.tensor([[1.1], [2.1], [3.1], [4.1]])
+            data.edge_index = torch.tensor(
+                [[0, 1, 2, 3], [1, 0, 3, 2]], dtype=torch.long
+            )
+
+            components = data.connected_components()
+            print(len(components))
+            >>> 2
+
+            print(components[0].x)
+            >>> Data(x=[2, 1], y=[2, 1], edge_index=[2, 2])
+
+        Returns:
+            List[Data]: A list of disconnected components.
+        """
+        # Union-Find algorithm to find connected components
+        self._parents: Dict[int, int] = {}
+        self._ranks: Dict[int, int] = {}
+        for edge in self.edge_index.t().tolist():
+            self._union(edge[0], edge[1])
+
+        # Rerun _find_parent to ensure all nodes are covered correctly
+        for node in range(self.num_nodes):
+            self._find_parent(node)
+
+        # Group parents
+        grouped_parents = defaultdict(list)
+        for node, parent in self._parents.items():
+            grouped_parents[parent].append(node)
+        del self._ranks
+        del self._parents
+
+        # Create components based on the found parents (roots)
+        components: List[Self] = []
+        for nodes in grouped_parents.values():
+            # Convert the list of node IDs to a tensor
+            subset = torch.tensor(nodes, dtype=torch.long)
+
+            # Use the existing subgraph function
+            component_data = self.subgraph(subset)
+            components.append(component_data)
+
+        return components
+
     ###########################################################################
 
     @classmethod
@@ -1150,6 +1205,49 @@ class Data(BaseData, FeatureStore, GraphStore):
 
         return list(edge_attrs.values())
 
+    # Connected Components Helper Functions ###################################
+
+    def _find_parent(self, node: int) -> int:
+        r"""Finds and returns the representative parent of the given node in a
+        disjoint-set (union-find) data structure. Implements path compression
+        to optimize future queries.
+
+        Args:
+            node (int): The node for which to find the representative parent.
+
+        Returns:
+            int: The representative parent of the node.
+        """
+        if node not in self._parents:
+            self._parents[node] = node
+            self._ranks[node] = 0
+        if self._parents[node] != node:
+            self._parents[node] = self._find_parent(self._parents[node])
+        return self._parents[node]
+
+    def _union(self, node1: int, node2: int):
+        r"""Merges the sets containing node1 and node2 in the disjoint-set
+        data structure.
+
+        Finds the root parents of node1 and node2 using the _find_parent
+        method. If they belong to different sets, updates the parent of
+        root2 to be root1, effectively merging the two sets.
+
+        Args:
+            node1 (int): The index of the first node to union.
+            node2 (int): The index of the second node to union.
+        """
+        root1 = self._find_parent(node1)
+        root2 = self._find_parent(node2)
+        if root1 != root2:
+            if self._ranks[root1] < self._ranks[root2]:
+                self._parents[root1] = root2
+            elif self._ranks[root1] > self._ranks[root2]:
+                self._parents[root2] = root1
+            else:
+                self._parents[root2] = root1
+                self._ranks[root1] += 1
+
 
 ###############################################################################
 

{pyg_nightly-2.7.0.dev20250902 → pyg_nightly-2.7.0.dev20250904}/torch_geometric/data/feature_store.py

@@ -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:

{pyg_nightly-2.7.0.dev20250902 → pyg_nightly-2.7.0.dev20250904}/torch_geometric/data/graph_store.py

@@ -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

{pyg_nightly-2.7.0.dev20250902 → pyg_nightly-2.7.0.dev20250904}/torch_geometric/data/hetero_data.py

@@ -487,6 +487,77 @@ class HeteroData(BaseData, FeatureStore, GraphStore):
 
         return status
 
+    def connected_components(self) -> List[Self]:
+        r"""Extracts connected components of the heterogeneous graph using
+        a union-find algorithm. The components are returned as a list of
+        :class:`~torch_geometric.data.HeteroData` objects.
+
+        .. code-block::
+
+            data = HeteroData()
+            data["red"].x = torch.tensor([[1.0], [2.0], [3.0], [4.0]])
+            data["blue"].x = torch.tensor([[5.0], [6.0]])
+            data["red", "to", "red"].edge_index = torch.tensor(
+                [[0, 1, 2, 3], [1, 0, 3, 2]], dtype=torch.long
+            )
+
+            components = data.connected_components()
+            print(len(components))
+            >>> 4
+
+            print(components[0])
+            >>> HeteroData(
+                red={x: tensor([[1.], [2.]])},
+                blue={x: tensor([[]])},
+                red, to, red={edge_index: tensor([[0, 1], [1, 0]])}
+            )
+
+        Returns:
+            List[HeteroData]: A list of connected components.
+        """
+        # Initialize union-find structures
+        self._parents: Dict[Tuple[str, int], Tuple[str, int]] = {}
+        self._ranks: Dict[Tuple[str, int], int] = {}
+
+        # Union-Find algorithm to find connected components
+        for edge_type in self.edge_types:
+            src, _, dst = edge_type
+            edge_index = self[edge_type].edge_index
+            for src_node, dst_node in edge_index.t().tolist():
+                self._union((src, src_node), (dst, dst_node))
+
+        # Rerun _find_parent to ensure all nodes are covered correctly
+        for node_type in self.node_types:
+            for node_index in range(self[node_type].num_nodes):
+                self._find_parent((node_type, node_index))
+
+        # Group nodes by their representative parent
+        components_map = defaultdict(list)
+        for node, parent in self._parents.items():
+            components_map[parent].append(node)
+        del self._parents
+        del self._ranks
+
+        components: List[Self] = []
+        for nodes in components_map.values():
+            # Prefill subset_dict with all node types to ensure all are present
+            subset_dict = {node_type: [] for node_type in self.node_types}
+
+            # Convert the list of (node_type, node_id) tuples to a subset_dict
+            for node_type, node_id in nodes:
+                subset_dict[node_type].append(node_id)
+
+            # Convert lists to tensors
+            for node_type, node_ids in subset_dict.items():
+                subset_dict[node_type] = torch.tensor(node_ids,
+                                                      dtype=torch.long)
+
+            # Use the existing subgraph function to do all the heavy lifting
+            component_data = self.subgraph(subset_dict)
+            components.append(component_data)
+
+        return components
+
     def debug(self):
         pass  # TODO
 
@@ -1148,6 +1219,51 @@ class HeteroData(BaseData, FeatureStore, GraphStore):
 
         return list(edge_attrs.values())
 
+    # Connected Components Helper Functions ###################################
+
+    def _find_parent(self, node: Tuple[str, int]) -> Tuple[str, int]:
+        r"""Finds and returns the representative parent of the given node in a
+        disjoint-set (union-find) data structure. Implements path compression
+        to optimize future queries.
+
+        Args:
+            node (tuple[str, int]): The node for which to find the parent.
+            First element is the node type, second is the node index.
+
+        Returns:
+            tuple[str, int]: The representative parent of the node.
+        """
+        if node not in self._parents:
+            self._parents[node] = node
+            self._ranks[node] = 0
+        if self._parents[node] != node:
+            self._parents[node] = self._find_parent(self._parents[node])
+        return self._parents[node]
+
+    def _union(self, node1: Tuple[str, int], node2: Tuple[str, int]):
+        r"""Merges the node1 and node2 in the disjoint-set data structure.
+
+        Finds the root parents of node1 and node2 using the _find_parent
+        method. If they belong to different sets, updates the parent of
+        root2 to be root1, effectively merging the two sets.
+
+        Args:
+            node1 (Tuple[str, int]): The first node to union. First element is
+                the node type, second is the node index.
+            node2 (Tuple[str, int]): The second node to union. First element is
+                the node type, second is the node index.
+        """
+        root1 = self._find_parent(node1)
+        root2 = self._find_parent(node2)
+        if root1 != root2:
+            if self._ranks[root1] < self._ranks[root2]:
+                self._parents[root1] = root2
+            elif self._ranks[root1] > self._ranks[root2]:
+                self._parents[root2] = root1
+            else:
+                self._parents[root2] = root1
+                self._ranks[root1] += 1
+
 
 # Helper functions ############################################################
 

{pyg_nightly-2.7.0.dev20250902 → pyg_nightly-2.7.0.dev20250904}/torch_geometric/datasets/airfrans.py

@@ -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>`_.

{pyg_nightly-2.7.0.dev20250902 → pyg_nightly-2.7.0.dev20250904}/torch_geometric/distributed/partition.py

@@ -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)

{pyg_nightly-2.7.0.dev20250902 → pyg_nightly-2.7.0.dev20250904}/torch_geometric/loader/cluster.py

@@ -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`.

{pyg_nightly-2.7.0.dev20250902 → pyg_nightly-2.7.0.dev20250904}/torch_geometric/nn/conv/meshcnn_conv.py

@@ -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 \

{pyg_nightly-2.7.0.dev20250902 → pyg_nightly-2.7.0.dev20250904}/torch_geometric/nn/models/polynormer.py

@@ -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`)

{pyg_nightly-2.7.0.dev20250902 → pyg_nightly-2.7.0.dev20250904}/torch_geometric/nn/models/rev_gnn.py

@@ -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

{pyg_nightly-2.7.0.dev20250902 → pyg_nightly-2.7.0.dev20250904}/torch_geometric/utils/influence.py

@@ -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