pyg-nightly 2.7.0.dev20250504__tar.gz → 2.7.0.dev20250506__tar.gz

{pyg_nightly-2.7.0.dev20250504 → pyg_nightly-2.7.0.dev20250506}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyg-nightly
-Version: 2.7.0.dev20250504
+Version: 2.7.0.dev20250506
 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.dev20250504 → pyg_nightly-2.7.0.dev20250506}/pyproject.toml

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

{pyg_nightly-2.7.0.dev20250504 → pyg_nightly-2.7.0.dev20250506}/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.dev20250504'
+__version__ = '2.7.0.dev20250506'
 
 __all__ = [
     'Index',
@@ -57,6 +57,13 @@ __all__ = [
     '__version__',
 ]
 
+if not torch_geometric.typing.WITH_PT113:
+    import warnings as std_warnings
+
+    std_warnings.warn("PyG 2.7 removed support for PyTorch < 1.13. Consider "
+                      "Consider upgrading to PyTorch >= 1.13 or downgrading "
+                      "to PyG <= 2.6. ")
+
 # Serialization ###############################################################
 
 if torch_geometric.typing.WITH_PT24:

{pyg_nightly-2.7.0.dev20250504 → pyg_nightly-2.7.0.dev20250506}/torch_geometric/data/collate.py

@@ -191,10 +191,8 @@ def _collate(
             if torch_geometric.typing.WITH_PT20:
                 storage = elem.untyped_storage()._new_shared(
                     numel * elem.element_size(), device=elem.device)
-            elif torch_geometric.typing.WITH_PT112:
-                storage = elem.storage()._new_shared(numel, device=elem.device)
             else:
-                storage = elem.storage()._new_shared(numel)
+                storage = elem.storage()._new_shared(numel, device=elem.device)
             shape = list(elem.size())
             if cat_dim is None or elem.dim() == 0:
                 shape = [len(values)] + shape

{pyg_nightly-2.7.0.dev20250504 → pyg_nightly-2.7.0.dev20250506}/torch_geometric/edge_index.py

@@ -298,8 +298,7 @@ class EdgeIndex(Tensor):
                 indptr = None
             data = torch.stack([row, col], dim=0)
 
-        if (torch_geometric.typing.WITH_PT112
-                and data.layout == torch.sparse_csc):
+        if data.layout == torch.sparse_csc:
             row = data.row_indices()
             indptr = data.ccol_indices()
 
@@ -882,10 +881,6 @@ class EdgeIndex(Tensor):
                 If not specified, non-zero elements will be assigned a value of
                 :obj:`1.0`. (default: :obj:`None`)
         """
-        if not torch_geometric.typing.WITH_PT112:
-            raise NotImplementedError(
-                "'to_sparse_csc' not supported for PyTorch < 1.12")
-
         (colptr, row), perm = self.get_csc()
         if value is not None and perm is not None:
             value = value[perm]
@@ -922,7 +917,7 @@ class EdgeIndex(Tensor):
             return self.to_sparse_coo(value)
         if layout == torch.sparse_csr:
             return self.to_sparse_csr(value)
-        if torch_geometric.typing.WITH_PT112 and layout == torch.sparse_csc:
+        if layout == torch.sparse_csc:
             return self.to_sparse_csc(value)
 
         raise ValueError(f"Unexpected tensor layout (got '{layout}')")

{pyg_nightly-2.7.0.dev20250504 → pyg_nightly-2.7.0.dev20250506}/torch_geometric/nn/dense/linear.py

@@ -1,4 +1,3 @@
-import copy
 import math
 import sys
 import time
@@ -114,25 +113,6 @@ class Linear(torch.nn.Module):
 
         self.reset_parameters()
 
-    def __deepcopy__(self, memo):
-        # PyTorch<1.13 cannot handle deep copies of uninitialized parameters :(
-        # TODO Drop this code once PyTorch 1.12 is no longer supported.
-        out = Linear(
-            self.in_channels,
-            self.out_channels,
-            self.bias is not None,
-            self.weight_initializer,
-            self.bias_initializer,
-        ).to(self.weight.device)
-
-        if self.in_channels > 0:
-            out.weight = copy.deepcopy(self.weight, memo)
-
-        if self.bias is not None:
-            out.bias = copy.deepcopy(self.bias, memo)
-
-        return out
-
     def reset_parameters(self):
         r"""Resets all learnable parameters of the module."""
         reset_weight_(self.weight, self.in_channels, self.weight_initializer)

{pyg_nightly-2.7.0.dev20250504 → pyg_nightly-2.7.0.dev20250506}/torch_geometric/nn/pool/connect/base.py

@@ -4,7 +4,6 @@ from typing import Optional
 import torch
 from torch import Tensor
 
-import torch_geometric.typing
 from torch_geometric.nn.pool.select import SelectOutput
 
 
@@ -49,8 +48,7 @@ class ConnectOutput:
         self.batch = batch
 
 
-if torch_geometric.typing.WITH_PT113:
-    ConnectOutput = torch.jit.script(ConnectOutput)
+ConnectOutput = torch.jit.script(ConnectOutput)
 
 
 class Connect(torch.nn.Module):

{pyg_nightly-2.7.0.dev20250504 → pyg_nightly-2.7.0.dev20250506}/torch_geometric/nn/pool/select/base.py

@@ -4,8 +4,6 @@ from typing import Optional
 import torch
 from torch import Tensor
 
-import torch_geometric.typing
-
 
 @dataclass(init=False)
 class SelectOutput:
@@ -64,8 +62,7 @@ class SelectOutput:
         self.weight = weight
 
 
-if torch_geometric.typing.WITH_PT113:
-    SelectOutput = torch.jit.script(SelectOutput)
+SelectOutput = torch.jit.script(SelectOutput)
 
 
 class Select(torch.nn.Module):

{pyg_nightly-2.7.0.dev20250504 → pyg_nightly-2.7.0.dev20250506}/torch_geometric/typing.py

@@ -21,8 +21,6 @@ WITH_PT23 = WITH_PT20 and int(torch.__version__.split('.')[1]) >= 3
 WITH_PT24 = WITH_PT20 and int(torch.__version__.split('.')[1]) >= 4
 WITH_PT25 = WITH_PT20 and int(torch.__version__.split('.')[1]) >= 5
 WITH_PT26 = WITH_PT20 and int(torch.__version__.split('.')[1]) >= 6
-WITH_PT111 = WITH_PT20 or int(torch.__version__.split('.')[1]) >= 11
-WITH_PT112 = WITH_PT20 or int(torch.__version__.split('.')[1]) >= 12
 WITH_PT113 = WITH_PT20 or int(torch.__version__.split('.')[1]) >= 13
 
 WITH_WINDOWS = os.name == 'nt'

{pyg_nightly-2.7.0.dev20250504 → pyg_nightly-2.7.0.dev20250506}/torch_geometric/utils/_lexsort.py

@@ -1,11 +1,7 @@
 from typing import List
 
-import numpy as np
-import torch
 from torch import Tensor
 
-import torch_geometric.typing
-
 
 def lexsort(
     keys: List[Tensor],
@@ -28,11 +24,6 @@ def lexsort(
     """
     assert len(keys) >= 1
 
-    if not torch_geometric.typing.WITH_PT113:
-        keys = [k.neg() for k in keys] if descending else keys
-        out = np.lexsort([k.detach().cpu().numpy() for k in keys], axis=dim)
-        return torch.from_numpy(out).to(keys[0].device)
-
     out = keys[0].argsort(dim=dim, descending=descending, stable=True)
     for k in keys[1:]:
         index = k.gather(dim, out)

pyg_nightly-2.7.0.dev20250506/torch_geometric/utils/_scatter.py

@@ -0,0 +1,290 @@
+from typing import List, Optional, Tuple, Union
+
+import torch
+from torch import Tensor
+
+import torch_geometric.typing
+from torch_geometric import is_compiling, is_in_onnx_export, warnings
+from torch_geometric.typing import torch_scatter
+from torch_geometric.utils.functions import cumsum
+
+warnings.filterwarnings('ignore', '.*is in beta and the API may change.*')
+
+
+def scatter(
+    src: Tensor,
+    index: Tensor,
+    dim: int = 0,
+    dim_size: Optional[int] = None,
+    reduce: str = 'sum',
+) -> Tensor:
+    r"""Reduces all values from the :obj:`src` tensor at the indices specified
+    in the :obj:`index` tensor along a given dimension ``dim``. See the
+    `documentation <https://pytorch-scatter.readthedocs.io/en/latest/functions/scatter.html>`__  # noqa: E501
+    of the ``torch_scatter`` package for more information.
+
+    Args:
+        src (torch.Tensor): The source tensor.
+        index (torch.Tensor): The index tensor.
+        dim (int, optional): The dimension along which to index.
+            (default: ``0``)
+        dim_size (int, optional): The size of the output tensor at dimension
+            ``dim``. If set to :obj:`None`, will create a minimal-sized output
+            tensor according to ``index.max() + 1``. (default: :obj:`None`)
+        reduce (str, optional): The reduce operation (``"sum"``, ``"mean"``,
+            ``"mul"``, ``"min"``, ``"max"`` or ``"any"``). (default: ``"sum"``)
+    """
+    if isinstance(index, Tensor) and index.dim() != 1:
+        raise ValueError(f"The `index` argument must be one-dimensional "
+                         f"(got {index.dim()} dimensions)")
+
+    dim = src.dim() + dim if dim < 0 else dim
+
+    if isinstance(src, Tensor) and (dim < 0 or dim >= src.dim()):
+        raise ValueError(f"The `dim` argument must lay between 0 and "
+                         f"{src.dim() - 1} (got {dim})")
+
+    if dim_size is None:
+        dim_size = int(index.max()) + 1 if index.numel() > 0 else 0
+
+    # For now, we maintain various different code paths, based on whether
+    # the input requires gradients and whether it lays on the CPU/GPU.
+    # For example, `torch_scatter` is usually faster than
+    # `torch.scatter_reduce` on GPU, while `torch.scatter_reduce` is faster
+    # on CPU.
+    # `torch.scatter_reduce` has a faster forward implementation for
+    # "min"/"max" reductions since it does not compute additional arg
+    # indices, but is therefore way slower in its backward implementation.
+    # More insights can be found in `test/utils/test_scatter.py`.
+
+    size = src.size()[:dim] + (dim_size, ) + src.size()[dim + 1:]
+
+    # For "any" reduction, we use regular `scatter_`:
+    if reduce == 'any':
+        index = broadcast(index, src, dim)
+        return src.new_zeros(size).scatter_(dim, index, src)
+
+    # For "sum" and "mean" reduction, we make use of `scatter_add_`:
+    if reduce == 'sum' or reduce == 'add':
+        index = broadcast(index, src, dim)
+        return src.new_zeros(size).scatter_add_(dim, index, src)
+
+    if reduce == 'mean':
+        count = src.new_zeros(dim_size)
+        count.scatter_add_(0, index, src.new_ones(src.size(dim)))
+        count = count.clamp(min=1)
+
+        index = broadcast(index, src, dim)
+        out = src.new_zeros(size).scatter_add_(dim, index, src)
+
+        return out / broadcast(count, out, dim)
+
+    # For "min" and "max" reduction, we prefer `scatter_reduce_` on CPU or
+    # in case the input does not require gradients:
+    if reduce in ['min', 'max', 'amin', 'amax']:
+        if (not torch_geometric.typing.WITH_TORCH_SCATTER or is_compiling()
+                or is_in_onnx_export() or not src.is_cuda
+                or not src.requires_grad):
+
+            if (src.is_cuda and src.requires_grad and not is_compiling()
+                    and not is_in_onnx_export()):
+                warnings.warn(f"The usage of `scatter(reduce='{reduce}')` "
+                              f"can be accelerated via the 'torch-scatter'"
+                              f" package, but it was not found")
+
+            index = broadcast(index, src, dim)
+            if not is_in_onnx_export():
+                return src.new_zeros(size).scatter_reduce_(
+                    dim, index, src, reduce=f'a{reduce[-3:]}',
+                    include_self=False)
+
+            fill = torch.full(  # type: ignore
+                size=(1, ),
+                fill_value=src.min() if 'max' in reduce else src.max(),
+                dtype=src.dtype,
+                device=src.device,
+            ).expand_as(src)
+            out = src.new_zeros(size).scatter_reduce_(dim, index, fill,
+                                                      reduce=f'a{reduce[-3:]}',
+                                                      include_self=True)
+            return out.scatter_reduce_(dim, index, src,
+                                       reduce=f'a{reduce[-3:]}',
+                                       include_self=True)
+
+        return torch_scatter.scatter(src, index, dim, dim_size=dim_size,
+                                     reduce=reduce[-3:])
+
+    # For "mul" reduction, we prefer `scatter_reduce_` on CPU:
+    if reduce == 'mul':
+        if (not torch_geometric.typing.WITH_TORCH_SCATTER or is_compiling()
+                or not src.is_cuda):
+
+            if src.is_cuda and not is_compiling():
+                warnings.warn(f"The usage of `scatter(reduce='{reduce}')` "
+                              f"can be accelerated via the 'torch-scatter'"
+                              f" package, but it was not found")
+
+            index = broadcast(index, src, dim)
+            # We initialize with `one` here to match `scatter_mul` output:
+            return src.new_ones(size).scatter_reduce_(dim, index, src,
+                                                      reduce='prod',
+                                                      include_self=True)
+
+        return torch_scatter.scatter(src, index, dim, dim_size=dim_size,
+                                     reduce='mul')
+
+    raise ValueError(f"Encountered invalid `reduce` argument '{reduce}'")
+
+
+def broadcast(src: Tensor, ref: Tensor, dim: int) -> Tensor:
+    dim = ref.dim() + dim if dim < 0 else dim
+    size = ((1, ) * dim) + (-1, ) + ((1, ) * (ref.dim() - dim - 1))
+    return src.view(size).expand_as(ref)
+
+
+def scatter_argmax(
+    src: Tensor,
+    index: Tensor,
+    dim: int = 0,
+    dim_size: Optional[int] = None,
+) -> Tensor:
+
+    if (torch_geometric.typing.WITH_TORCH_SCATTER and not is_compiling()
+            and not is_in_onnx_export()):
+        out = torch_scatter.scatter_max(src, index, dim=dim, dim_size=dim_size)
+        return out[1]
+
+    # Only implemented under certain conditions for now :(
+    assert src.dim() == 1 and index.dim() == 1
+    assert dim == 0 or dim == -1
+    assert src.numel() == index.numel()
+
+    if dim_size is None:
+        dim_size = int(index.max()) + 1 if index.numel() > 0 else 0
+
+    if not is_in_onnx_export():
+        res = src.new_empty(dim_size)
+        res.scatter_reduce_(0, index, src.detach(), reduce='amax',
+                            include_self=False)
+    else:
+        # `include_self=False` is currently not supported by ONNX:
+        res = src.new_full(
+            size=(dim_size, ),
+            fill_value=src.min(),  # type: ignore
+        )
+        res.scatter_reduce_(0, index, src.detach(), reduce="amax",
+                            include_self=True)
+
+    out = index.new_full((dim_size, ), fill_value=dim_size - 1)
+    nonzero = (src == res[index]).nonzero().view(-1)
+    out[index[nonzero]] = nonzero
+
+    return out
+
+
+def group_argsort(
+    src: Tensor,
+    index: Tensor,
+    dim: int = 0,
+    num_groups: Optional[int] = None,
+    descending: bool = False,
+    return_consecutive: bool = False,
+    stable: bool = False,
+) -> Tensor:
+    r"""Returns the indices that sort the tensor :obj:`src` along a given
+    dimension in ascending order by value.
+    In contrast to :meth:`torch.argsort`, sorting is performed in groups
+    according to the values in :obj:`index`.
+
+    Args:
+        src (torch.Tensor): The source tensor.
+        index (torch.Tensor): The index tensor.
+        dim (int, optional): The dimension along which to index.
+            (default: :obj:`0`)
+        num_groups (int, optional): The number of groups.
+            (default: :obj:`None`)
+        descending (bool, optional): Controls the sorting order (ascending or
+            descending). (default: :obj:`False`)
+        return_consecutive (bool, optional): If set to :obj:`True`, will not
+            offset the output to start from :obj:`0` for each group.
+            (default: :obj:`False`)
+        stable (bool, optional): Controls the relative order of equivalent
+            elements. (default: :obj:`False`)
+
+    Example:
+        >>> src = torch.tensor([0, 1, 5, 4, 3, 2, 6, 7, 8])
+        >>> index = torch.tensor([0, 0, 1, 1, 1, 1, 2, 2, 2])
+        >>> group_argsort(src, index)
+        tensor([0, 1, 3, 2, 1, 0, 0, 1, 2])
+    """
+    # Only implemented under certain conditions for now :(
+    assert src.dim() == 1 and index.dim() == 1
+    assert dim == 0 or dim == -1
+    assert src.numel() == index.numel()
+
+    if src.numel() == 0:
+        return torch.zeros_like(src)
+
+    # Normalize `src` to range [0, 1]:
+    src = src - src.min()
+    src = src / src.max()
+
+    # Compute `grouped_argsort`:
+    src = src - 2 * index if descending else src + 2 * index
+    perm = src.argsort(descending=descending, stable=stable)
+    out = torch.empty_like(index)
+    out[perm] = torch.arange(index.numel(), device=index.device)
+
+    if return_consecutive:
+        return out
+
+    # Compute cumulative sum of number of entries with the same index:
+    count = scatter(torch.ones_like(index), index, dim=dim,
+                    dim_size=num_groups, reduce='sum')
+    ptr = cumsum(count)
+
+    return out - ptr[index]
+
+
+def group_cat(
+    tensors: Union[List[Tensor], Tuple[Tensor, ...]],
+    indices: Union[List[Tensor], Tuple[Tensor, ...]],
+    dim: int = 0,
+    return_index: bool = False,
+) -> Union[Tensor, Tuple[Tensor, Tensor]]:
+    r"""Concatenates the given sequence of tensors :obj:`tensors` in the given
+    dimension :obj:`dim`.
+    Different from :meth:`torch.cat`, values along the concatenating dimension
+    are grouped according to the indices defined in the :obj:`index` tensors.
+    All tensors must have the same shape (except in the concatenating
+    dimension).
+
+    Args:
+        tensors ([Tensor]): Sequence of tensors.
+        indices ([Tensor]): Sequence of index tensors.
+        dim (int, optional): The dimension along which the tensors are
+            concatenated. (default: :obj:`0`)
+        return_index (bool, optional): If set to :obj:`True`, will return the
+            new index tensor. (default: :obj:`False`)
+
+    Example:
+        >>> x1 = torch.tensor([[0.2716, 0.4233],
+        ...                    [0.3166, 0.0142],
+        ...                    [0.2371, 0.3839],
+        ...                    [0.4100, 0.0012]])
+        >>> x2 = torch.tensor([[0.3752, 0.5782],
+        ...                    [0.7757, 0.5999]])
+        >>> index1 = torch.tensor([0, 0, 1, 2])
+        >>> index2 = torch.tensor([0, 2])
+        >>> scatter_concat([x1,x2], [index1, index2], dim=0)
+        tensor([[0.2716, 0.4233],
+                [0.3166, 0.0142],
+                [0.3752, 0.5782],
+                [0.2371, 0.3839],
+                [0.4100, 0.0012],
+                [0.7757, 0.5999]])
+    """
+    assert len(tensors) == len(indices)
+    index, perm = torch.cat(indices).sort(stable=True)
+    out = torch.cat(tensors, dim=dim).index_select(dim, perm)
+    return (out, index) if return_index else out

{pyg_nightly-2.7.0.dev20250504 → pyg_nightly-2.7.0.dev20250506}/torch_geometric/utils/_sort_edge_index.py

@@ -107,8 +107,6 @@ def sort_edge_index(  # noqa: F811
     num_nodes = maybe_num_nodes(edge_index, num_nodes)
 
     if num_nodes * num_nodes > torch_geometric.typing.MAX_INT64:
-        if not torch_geometric.typing.WITH_PT113:
-            raise ValueError("'sort_edge_index' will result in an overflow")
         perm = lexsort(keys=[
             edge_index[int(sort_by_row)],
             edge_index[1 - int(sort_by_row)],

{pyg_nightly-2.7.0.dev20250504 → pyg_nightly-2.7.0.dev20250506}/torch_geometric/utils/_spmm.py

@@ -115,8 +115,7 @@ def spmm(
         if src.layout == torch.sparse_csr:
             ptr = src.crow_indices()
             deg = ptr[1:] - ptr[:-1]
-        elif (torch_geometric.typing.WITH_PT112
-              and src.layout == torch.sparse_csc):
+        elif src.layout == torch.sparse_csc:
             assert src.layout == torch.sparse_csc
             ones = torch.ones_like(src.values())
             index = src.row_indices()

{pyg_nightly-2.7.0.dev20250504 → pyg_nightly-2.7.0.dev20250506}/torch_geometric/utils/sparse.py

@@ -1,4 +1,3 @@
-import typing
 import warnings
 from typing import Any, List, Optional, Tuple, Union
 
@@ -124,8 +123,7 @@ def is_torch_sparse_tensor(src: Any) -> bool:
             return True
         if src.layout == torch.sparse_csr:
             return True
-        if (torch_geometric.typing.WITH_PT112
-                and src.layout == torch.sparse_csc):
+        if src.layout == torch.sparse_csc:
             return True
     return False
 
@@ -320,12 +318,6 @@ def to_torch_csc_tensor(
                size=(4, 4), nnz=6, layout=torch.sparse_csc)
 
     """
-    if not torch_geometric.typing.WITH_PT112:
-        if typing.TYPE_CHECKING:
-            raise NotImplementedError
-        return torch_geometric.typing.MockTorchCSCTensor(
-            edge_index, edge_attr, size)
-
     if size is None:
         size = int(edge_index.max()) + 1
 
@@ -392,7 +384,7 @@ def to_torch_sparse_tensor(
         return to_torch_coo_tensor(edge_index, edge_attr, size, is_coalesced)
     if layout == torch.sparse_csr:
         return to_torch_csr_tensor(edge_index, edge_attr, size, is_coalesced)
-    if torch_geometric.typing.WITH_PT112 and layout == torch.sparse_csc:
+    if layout == torch.sparse_csc:
         return to_torch_csc_tensor(edge_index, edge_attr, size, is_coalesced)
 
     raise ValueError(f"Unexpected sparse tensor layout (got '{layout}')")
@@ -431,7 +423,7 @@ def to_edge_index(adj: Union[Tensor, SparseTensor]) -> Tuple[Tensor, Tensor]:
         col = adj.col_indices().detach()
         return torch.stack([row, col], dim=0).long(), adj.values()
 
-    if torch_geometric.typing.WITH_PT112 and adj.layout == torch.sparse_csc:
+    if adj.layout == torch.sparse_csc:
         col = ptr2index(adj.ccol_indices().detach())
         row = adj.row_indices().detach()
         return torch.stack([row, col], dim=0).long(), adj.values()
@@ -480,7 +472,7 @@ def set_sparse_value(adj: Tensor, value: Tensor) -> Tensor:
             device=value.device,
         )
 
-    if torch_geometric.typing.WITH_PT112 and adj.layout == torch.sparse_csc:
+    if adj.layout == torch.sparse_csc:
         return torch.sparse_csc_tensor(
             ccol_indices=adj.ccol_indices(),
             row_indices=adj.row_indices(),