PyPI - pyg-nightly - Versions diffs - 2.7.0.dev20250605__tar.gz → 2.7.0.dev20250607__tar.gz - Mend

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyg-nightly
-Version: 2.7.0.dev20250605
+Version: 2.7.0.dev20250607
 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.dev20250605"
+version="2.7.0.dev20250607"
 authors=[
     {name="Matthias Fey", email="matthias@pyg.org"},
 ]
@@ -161,7 +161,6 @@ select = [
     "D",  # pydocstyle
 ]
 ignore = [
-    "B006",  # TODO Don't ignore "Do not use mutable data structures for argument defaults"
     "B007",  # TODO Don't ignore "Loop control variable `{name}` not used within loop body"
     "B008",  # TODO Don't ignore "Do not perform function call `{name}` in argument defaults; instead, perform the call within the function, or read the default from a module-level singleton variable"
     "B020",  # TODO Don't ignore "Loop control variable `{name}` overrides iterable it iterates"

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

@@ -18,8 +18,9 @@ def get_stats():
     return params_count(model)
-def match_computation(stats_baseline, key=['gnn', 'dim_inner'], mode='sqrt'):
+def match_computation(stats_baseline, key=None, mode='sqrt'):
     """Match computation budget by modifying :obj:`cfg.gnn.dim_inner`."""
+    key = key or ['gnn', 'dim_inner']
     stats = get_stats()
     if stats != stats_baseline:
         # Phase 1: fast approximation

@@ -81,7 +81,7 @@ class EGConv(MessagePassing):
         self,
         in_channels: int,
         out_channels: int,
-        aggregators: List[str] = ['symnorm'],
+        aggregators: Optional[List[str]] = None,
         num_heads: int = 8,
         num_bases: int = 4,
         cached: bool = False,
@@ -96,23 +96,23 @@ class EGConv(MessagePassing):
                              f"divisible by the number of heads "
                              f"(got {num_heads})")
-        for a in aggregators:
-            if a not in ['sum', 'mean', 'symnorm', 'min', 'max', 'var', 'std']:
-                raise ValueError(f"Unsupported aggregator: '{a}'")
         self.in_channels = in_channels
         self.out_channels = out_channels
         self.num_heads = num_heads
         self.num_bases = num_bases
         self.cached = cached
         self.add_self_loops = add_self_loops
-        self.aggregators = aggregators
+        self.aggregators = aggregators or ['symnorm']
+        for a in self.aggregators:
+            if a not in ['sum', 'mean', 'symnorm', 'min', 'max', 'var', 'std']:
+                raise ValueError(f"Unsupported aggregator: '{a}'")
         self.bases_lin = Linear(in_channels,
                                 (out_channels // num_heads) * num_bases,
                                 bias=False, weight_initializer='glorot')
         self.comb_lin = Linear(in_channels,
-                               num_heads * num_bases * len(aggregators))
+                               num_heads * num_bases * len(self.aggregators))
         if bias:
             self.bias = Parameter(torch.empty(out_channels))

@@ -197,7 +197,7 @@ class GLEM(torch.nn.Module):
             optimizer.zero_grad()
             all_out.append(out)
             total_correct += int(out.argmax(dim=-1).eq(labels).sum())
-            total_loss += float(loss)
+            total_loss += float(loss.detach())
             if verbose:
                 pbar.update(batch['n_id'].size(0))
@@ -251,7 +251,7 @@ class GLEM(torch.nn.Module):
             loss.backward()
             optimizer.step()
             optimizer.zero_grad()
-            total_loss += float(loss)
+            total_loss += float(loss.detach())
             total_correct += int(out.argmax(dim=-1).eq(labels).sum())
             if verbose:
                 pbar.update(batch.batch_size)

@@ -716,11 +716,18 @@ class GPSENodeEncoder(torch.nn.Module):
 @torch.no_grad()
-def gpse_process(model: Module, data: Data, rand_type: str,
-                 use_vn: bool = True, bernoulli_thresh: float = 0.5,
-                 neighbor_loader: bool = False,
-                 num_neighbors: List[int] = [30, 20, 10], fillval: int = 5,
-                 layers_mp: int = None, **kwargs) -> torch.Tensor:
+def gpse_process(
+    model: Module,
+    data: Data,
+    rand_type: str,
+    use_vn: bool = True,
+    bernoulli_thresh: float = 0.5,
+    neighbor_loader: bool = False,
+    num_neighbors: Optional[List[int]] = None,
+    fillval: int = 5,
+    layers_mp: int = None,
+    **kwargs,
+) -> torch.Tensor:
     r"""Processes the data using the :class:`GPSE` model to generate and append
     GPSE encodings. Identical to :obj:`gpse_process_batch`, but operates on a
     single :class:`~torch_geometric.data.Dataset` object.
@@ -784,6 +791,8 @@ def gpse_process(model: Module, data: Data, rand_type: str,
         if layers_mp is None:
             raise ValueError('Please provide the number of message-passing '
                              'layers as "layers_mp".')
+        num_neighbors = num_neighbors or [30, 20, 10]
         diff = layers_mp - len(num_neighbors)
         if fillval > 0 and diff > 0:
             num_neighbors += [fillval] * diff
@@ -806,12 +815,18 @@ def gpse_process(model: Module, data: Data, rand_type: str,
 @torch.no_grad()
-def gpse_process_batch(model: GPSE, batch, rand_type: str, use_vn: bool = True,
-                       bernoulli_thresh: float = 0.5,
-                       neighbor_loader: bool = False,
-                       num_neighbors: List[int] = [30, 20, 10],
-                       fillval: int = 5, layers_mp: int = None,
-                       **kwargs) -> Tuple[torch.Tensor, torch.Tensor]:
+def gpse_process_batch(
+    model: GPSE,
+    batch,
+    rand_type: str,
+    use_vn: bool = True,
+    bernoulli_thresh: float = 0.5,
+    neighbor_loader: bool = False,
+    num_neighbors: Optional[List[int]] = None,
+    fillval: int = 5,
+    layers_mp: int = None,
+    **kwargs,
+) -> Tuple[torch.Tensor, torch.Tensor]:
     r"""Process a batch of data using the :class:`GPSE` model to generate and
     append :class:`GPSE` encodings. Identical to `gpse_process`, but operates
     on a batch of :class:`~torch_geometric.data.Data` objects.
@@ -881,6 +896,8 @@ def gpse_process_batch(model: GPSE, batch, rand_type: str, use_vn: bool = True,
         if layers_mp is None:
             raise ValueError('Please provide the number of message-passing '
                              'layers as "layers_mp".')
+        num_neighbors = num_neighbors or [30, 20, 10]
         diff = layers_mp - len(num_neighbors)
         if fillval > 0 and diff > 0:
             num_neighbors += [fillval] * diff

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Tuple
+from typing import Any, Dict, Optional, Tuple
 import numpy as np
 import torch
@@ -78,18 +78,17 @@ class GDC(BaseTransform):
         self_loop_weight: float = 1.,
         normalization_in: str = 'sym',
         normalization_out: str = 'col',
-        diffusion_kwargs: Dict[str, Any] = dict(method='ppr', alpha=0.15),
-        sparsification_kwargs: Dict[str, Any] = dict(
-            method='threshold',
-            avg_degree=64,
-        ),
+        diffusion_kwargs: Optional[Dict[str, Any]] = None,
+        sparsification_kwargs: Optional[Dict[str, Any]] = None,
         exact: bool = True,
     ) -> None:
         self.self_loop_weight = self_loop_weight
         self.normalization_in = normalization_in
         self.normalization_out = normalization_out
-        self.diffusion_kwargs = diffusion_kwargs
-        self.sparsification_kwargs = sparsification_kwargs
+        self.diffusion_kwargs = diffusion_kwargs or dict(
+            method='ppr', alpha=0.15)
+        self.sparsification_kwargs = sparsification_kwargs or dict(
+            method='threshold', avg_degree=64)
         self.exact = exact
         if self_loop_weight:

@@ -1,4 +1,4 @@
-from typing import List, Union
+from typing import List, Optional, Union
 from torch_geometric.data import Data, HeteroData
 from torch_geometric.data.datapipes import functional_transform
@@ -14,8 +14,8 @@ class NormalizeFeatures(BaseTransform):
         attrs (List[str]): The names of attributes to normalize.
             (default: :obj:`["x"]`)
     """
-    def __init__(self, attrs: List[str] = ["x"]):
-        self.attrs = attrs
+    def __init__(self, attrs: Optional[List[str]] = None) -> None:
+        self.attrs = attrs or ["x"]
     def forward(
         self,

pyg-nightly 2.7.0.dev20250605__tar.gz → 2.7.0.dev20250607__tar.gz

pyg-nightly 2.7.0.dev20250605tar.gz → 2.7.0.dev20250607tar.gz