pyg-nightly 2.7.0.dev20250206__py3-none-any.whl → 2.7.0.dev20250208__py3-none-any.whl

{pyg_nightly-2.7.0.dev20250206.dist-info → pyg_nightly-2.7.0.dev20250208.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyg-nightly
-Version: 2.7.0.dev20250206
+Version: 2.7.0.dev20250208
 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.dev20250206.dist-info → pyg_nightly-2.7.0.dev20250208.dist-info}/RECORD

@@ -1,4 +1,4 @@
-torch_geometric/__init__.py,sha256=YRPiIO7ws7RIgUmJ-pamZ1ePmFmWSCBpTtTWmYrzv7k,1904
+torch_geometric/__init__.py,sha256=xs18p-86SDSyeHiH_4BXNgCg3hZ9F3aP-Swz2mVgRz0,1904
 torch_geometric/_compile.py,sha256=f-WQeH4VLi5Hn9lrgztFUCSrN_FImjhQa6BxFzcYC38,1338
 torch_geometric/_onnx.py,sha256=V9ffrIKSqhDw6xUZ12lkuSfNs48cQp2EeJ6Z19GfnVw,349
 torch_geometric/backend.py,sha256=lVaf7aLoVaB3M-UcByUJ1G4T4FOK6LXAg0CF4W3E8jo,1575
@@ -7,7 +7,7 @@ torch_geometric/config_store.py,sha256=zdMzlgBpUmBkPovpYQh5fMNwTZLDq2OneqX47QEx7
 torch_geometric/debug.py,sha256=cLyH9OaL2v7POyW-80b19w-ctA7a_5EZsS4aUF1wc2U,1295
 torch_geometric/deprecation.py,sha256=dWRymDIUkUVI2MeEmBG5WF4R6jObZeseSBV9G6FNfjc,858
 torch_geometric/device.py,sha256=tU5-_lBNVbVHl_kUmWPwiG5mQ1pyapwMF4JkmtNN3MM,1224
-torch_geometric/edge_index.py,sha256=r4_24Rhm3YCK0BF-kzLvL7PlY_1tWcXrBDIr7JPDjkw,70048
+torch_geometric/edge_index.py,sha256=BsLh5tOZRjjSYDkjqOFAdBuvMaDg7EWaaLELYsUL0Z8,70048
 torch_geometric/experimental.py,sha256=JbtNNEXjFGI8hZ9raM6-qrZURP6Z5nlDK8QicZUIbz0,4756
 torch_geometric/home.py,sha256=EV54B4Dmiv61GDbkCwtCfWGWJ4eFGwZ8s3KOgGjwYgY,790
 torch_geometric/index.py,sha256=9ChzWFCwj2slNcVBOgfV-wQn-KscJe_y7502w-Vf76w,24045
@@ -288,8 +288,8 @@ torch_geometric/loader/shadow.py,sha256=_hCspYf9SlJYX0lqEjxFec9e9t1iMScNThOoWR1w
 torch_geometric/loader/temporal_dataloader.py,sha256=AQ2QFeiXKbPp6I8sUeE8H7br-1_yndivXt7Z6_w62zI,2248
 torch_geometric/loader/utils.py,sha256=f27mczQ7fEP2HpTsJGJxKS0slPu0j8zTba3jP8ViNck,14901
 torch_geometric/loader/zip_loader.py,sha256=3lt10fD15Rxm1WhWzypswGzCEwUz4h8OLCD1nE15yNg,3843
-torch_geometric/metrics/__init__.py,sha256=Ck-rqQOGoKYRNSI95zlsTtQKVN4ZJGDaYYTMeSOjvvU,435
-torch_geometric/metrics/link_pred.py,sha256=dEsKVrjJ3OYnDbeDxowMNTCQMjKdgj-Xsh0L2VY5hLo,18563
+torch_geometric/metrics/__init__.py,sha256=9gPEg0_oMfq7LAr5rsrebasnvYN9nDXwq2ML56lWcMo,529
+torch_geometric/metrics/link_pred.py,sha256=H-s9U9n2CKpj9pRQWG9KdTZ0jueds1iy7hr893BmGoE,23121
 torch_geometric/nn/__init__.py,sha256=RrWRzEoqtR3lsO2lAzYXboLPb3uYEX2z3tLxiBIVWjc,847
 torch_geometric/nn/data_parallel.py,sha256=lDAxRi83UNuzAQSj3eu9K2sQheOIU6wqR5elS6oDs90,4764
 torch_geometric/nn/encoding.py,sha256=QNjwWczYExZ1wRGBmpuqYbn6tB7NC4BU-DEgzjhcZqw,3115
@@ -630,6 +630,6 @@ torch_geometric/utils/undirected.py,sha256=H_nfpI0_WluOG6VfjPyldvcjL4w5USAKWu2x5
 torch_geometric/visualization/__init__.py,sha256=PyR_4K5SafsJrBr6qWrkjKr6GBL1b7FtZybyXCDEVwY,154
 torch_geometric/visualization/graph.py,sha256=ZuLPL92yGRi7lxlqsUPwL_EVVXF7P2kMcveTtW79vpA,4784
 torch_geometric/visualization/influence.py,sha256=CWMvuNA_Nf1sfbJmQgn58yS4OFpeKXeZPe7kEuvkUBw,477
-pyg_nightly-2.7.0.dev20250206.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-pyg_nightly-2.7.0.dev20250206.dist-info/METADATA,sha256=KnKyWFmumAGBhzhyA643F5d0-IMruzDX0VRCAosZ3qY,62977
-pyg_nightly-2.7.0.dev20250206.dist-info/RECORD,,
+pyg_nightly-2.7.0.dev20250208.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+pyg_nightly-2.7.0.dev20250208.dist-info/METADATA,sha256=Jmer8BBk_bwb3Zs2JdZLAoVFNv_uQRoH_N9JxVAJQ_U,62977
+pyg_nightly-2.7.0.dev20250208.dist-info/RECORD,,

torch_geometric/__init__.py

@@ -30,7 +30,7 @@ from .lazy_loader import LazyLoader
 contrib = LazyLoader('contrib', globals(), 'torch_geometric.contrib')
 graphgym = LazyLoader('graphgym', globals(), 'torch_geometric.graphgym')
 
-__version__ = '2.7.0.dev20250206'
+__version__ = '2.7.0.dev20250208'
 
 __all__ = [
     'Index',

torch_geometric/edge_index.py

@@ -183,7 +183,7 @@ class EdgeIndex(Tensor):
 
         edge_index = EdgeIndex(
             [[0, 1, 1, 2],
-             [1, 0, 2, 1]]
+             [1, 0, 2, 1]],
             sparse_size=(3, 3),
             sort_order='row',
             is_undirected=True,
@@ -210,7 +210,7 @@ class EdgeIndex(Tensor):
         assert not edge_index.is_undirected
 
         # Sparse-Dense Matrix Multiplication:
-        out = edge_index.flip(0) @ torch.randn(3, 16)
+        out = edge_index.flip(0) @ torch.randn(3, 16)
         assert out.size() == (3, 16)
     """
     # See "https://pytorch.org/docs/stable/notes/extending.html"

torch_geometric/metrics/__init__.py

@@ -9,6 +9,8 @@ from .link_pred import (
     LinkPredMAP,
     LinkPredNDCG,
     LinkPredMRR,
+    LinkPredCoverage,
+    LinkPredDiversity,
 )
 
 link_pred_metrics = [
@@ -20,6 +22,8 @@ link_pred_metrics = [
     'LinkPredMAP',
     'LinkPredNDCG',
     'LinkPredMRR',
+    'LinkPredCoverage',
+    'LinkPredDiversity',
 ]
 
 __all__ = link_pred_metrics

torch_geometric/metrics/link_pred.py

@@ -138,7 +138,7 @@ class LinkPredMetricData:
         return pos
 
 
-class LinkPredMetric(BaseMetric):
+class _LinkPredMetric(BaseMetric):
     r"""An abstract class for computing link prediction retrieval metrics.
 
     Args:
@@ -147,7 +147,6 @@ class LinkPredMetric(BaseMetric):
     is_differentiable: bool = False
     full_state_update: bool = False
     higher_is_better: Optional[bool] = None
-    weighted: bool
 
     def __init__(self, k: int) -> None:
         super().__init__()
@@ -158,16 +157,6 @@ class LinkPredMetric(BaseMetric):
 
         self.k = k
 
-        self.accum: Tensor
-        self.total: Tensor
-
-        if WITH_TORCHMETRICS:
-            self.add_state('accum', torch.tensor(0.), dist_reduce_fx='sum')
-            self.add_state('total', torch.tensor(0), dist_reduce_fx='sum')
-        else:
-            self.register_buffer('accum', torch.tensor(0.))
-            self.register_buffer('total', torch.tensor(0))
-
     def update(
         self,
         pred_index_mat: Tensor,
@@ -194,6 +183,53 @@ class LinkPredMetric(BaseMetric):
                 a vector of positive values. Required for weighted metrics,
                 ignored otherwise. (default: :obj:`None`)
         """
+        raise NotImplementedError
+
+    def compute(self) -> Tensor:
+        r"""Computes the final metric value."""
+        raise NotImplementedError
+
+    def reset(self) -> None:
+        r"""Resets metric state variables to their default value."""
+        if WITH_TORCHMETRICS:
+            super().reset()
+        else:
+            self._reset()
+
+    def _reset(self) -> None:
+        raise NotImplementedError
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}(k={self.k})'
+
+
+class LinkPredMetric(_LinkPredMetric):
+    r"""An abstract class for computing link prediction retrieval metrics.
+
+    Args:
+        k (int): The number of top-:math:`k` predictions to evaluate against.
+    """
+    weighted: bool
+
+    def __init__(self, k: int) -> None:
+        super().__init__(k)
+
+        self.accum: Tensor
+        self.total: Tensor
+
+        if WITH_TORCHMETRICS:
+            self.add_state('accum', torch.tensor(0.), dist_reduce_fx='sum')
+            self.add_state('total', torch.tensor(0), dist_reduce_fx='sum')
+        else:
+            self.register_buffer('accum', torch.tensor(0.))
+            self.register_buffer('total', torch.tensor(0))
+
+    def update(
+        self,
+        pred_index_mat: Tensor,
+        edge_label_index: Union[Tensor, Tuple[Tensor, Tensor]],
+        edge_label_weight: Optional[Tensor] = None,
+    ) -> None:
         if self.weighted and edge_label_weight is None:
             raise ValueError(f"'edge_label_weight' is a required argument for "
                              f"weighted '{self.__class__.__name__}' metrics")
@@ -214,19 +250,10 @@ class LinkPredMetric(BaseMetric):
         self.total += (data.label_count > 0).sum()
 
     def compute(self) -> Tensor:
-        r"""Computes the final metric value."""
         if self.total == 0:
             return torch.zeros_like(self.accum)
         return self.accum / self.total
 
-    def reset(self) -> None:
-        r"""Resets metric state variables to their default value."""
-        if WITH_TORCHMETRICS:
-            super().reset()
-        else:
-            self.accum.zero_()
-            self.total.zero_()
-
     def _compute(self, data: LinkPredMetricData) -> Tensor:
         r"""Computes the specific metric.
         To be implemented separately for each metric class.
@@ -237,6 +264,10 @@ class LinkPredMetric(BaseMetric):
         """
         raise NotImplementedError
 
+    def _reset(self) -> None:
+        self.accum.zero_()
+        self.total.zero_()
+
     def __repr__(self) -> str:
         weighted_repr = ', weighted=True' if self.weighted else ''
         return f'{self.__class__.__name__}(k={self.k}{weighted_repr})'
@@ -284,7 +315,7 @@ class LinkPredMetricCollection(torch.nn.ModuleDict):
 
         if isinstance(metrics, (list, tuple)):
             metrics = {
-                (f'{"Weighted" if metric.weighted else ""}'
+                (f'{"Weighted" if getattr(metric, "weighted", False) else ""}'
                  f'{metric.__class__.__name__}@{metric.k}'):
                 metric
                 for metric in metrics
@@ -293,6 +324,7 @@ class LinkPredMetricCollection(torch.nn.ModuleDict):
         assert isinstance(metrics, dict)
 
         for name, metric in metrics.items():
+            assert isinstance(metric, _LinkPredMetric)
             self[name] = metric
 
     @property
@@ -307,7 +339,8 @@ class LinkPredMetricCollection(torch.nn.ModuleDict):
         r"""Returns :obj:`True` in case the collection holds at least one
         weighted link prediction metric.
         """
-        return any([metric.weighted for metric in self.values()])
+        return any(
+            [getattr(metric, 'weighted', False) for metric in self.values()])
 
     def update(  # type: ignore
         self,
@@ -348,7 +381,7 @@ class LinkPredMetricCollection(torch.nn.ModuleDict):
         )
 
         for metric in self.values():
-            if metric.weighted:
+            if isinstance(metric, LinkPredMetric) and metric.weighted:
                 metric._update(data)
                 if WITH_TORCHMETRICS:
                     metric._update_count += 1
@@ -362,11 +395,19 @@ class LinkPredMetricCollection(torch.nn.ModuleDict):
             del data._edge_label_weight_pos
 
         for metric in self.values():
-            if not metric.weighted:
+            if isinstance(metric, LinkPredMetric) and not metric.weighted:
                 metric._update(data)
                 if WITH_TORCHMETRICS:
                     metric._update_count += 1
 
+        for metric in self.values():
+            if not isinstance(metric, LinkPredMetric):
+                metric.update(
+                    pred_index_mat=pred_index_mat,
+                    edge_label_index=edge_label_index,
+                    edge_label_weight=edge_label_weight,
+                )
+
     def compute(self) -> Dict[str, Tensor]:
         r"""Computes the final metric values."""
         return {name: metric.compute() for name, metric in self.items()}
@@ -521,3 +562,108 @@ class LinkPredMRR(LinkPredMetric):
         device = pred_rel_mat.device
         arange = torch.arange(1, pred_rel_mat.size(1) + 1, device=device)
         return (pred_rel_mat / arange).max(dim=-1)[0]
+
+
+class LinkPredCoverage(_LinkPredMetric):
+    r"""A link prediction metric to compute the Coverage @ :math:`k` of
+    predictions.
+
+    Args:
+        k (int): The number of top-:math:`k` predictions to evaluate against.
+        num_dst_nodes (int): The total number of destination nodes.
+    """
+    higher_is_better: bool = True
+
+    def __init__(self, k: int, num_dst_nodes: int) -> None:
+        super().__init__(k)
+        self.num_dst_nodes = num_dst_nodes
+
+        self.mask: Tensor
+        mask = torch.zeros(num_dst_nodes, dtype=torch.bool)
+        if WITH_TORCHMETRICS:
+            self.add_state('mask', mask, dist_reduce_fx='max')
+        else:
+            self.register_buffer('mask', mask)
+
+    def update(
+        self,
+        pred_index_mat: Tensor,
+        edge_label_index: Union[Tensor, Tuple[Tensor, Tensor]],
+        edge_label_weight: Optional[Tensor] = None,
+    ) -> None:
+        self.mask[pred_index_mat[:, :self.k].flatten()] = True
+
+    def compute(self) -> Tensor:
+        return self.mask.to(torch.get_default_dtype()).mean()
+
+    def _reset(self) -> None:
+        self.mask.zero_()
+
+    def __repr__(self) -> str:
+        return (f'{self.__class__.__name__}(k={self.k}, '
+                f'num_dst_nodes={self.num_dst_nodes})')
+
+
+class LinkPredDiversity(_LinkPredMetric):
+    r"""A link prediction metric to compute the Diversity @ :math:`k` of
+    predictions according to item categories.
+
+    Diversity is computed as
+
+    .. math::
+        div_{u@k} = 1 - \left( \frac{1}{k \cdot (k-1)} \right) \sum_{i \neq j}
+        sim(i, j)
+
+    where
+
+    .. math::
+        sim(i,j) = \begin{cases}
+            1 & \quad \text{if } i,j \text{ share category,}\\
+            0 & \quad \text{otherwise.}
+        \end{cases}
+
+    which measures the pair-wise inequality of recommendations according to
+    item categories.
+
+    Args:
+        k (int): The number of top-:math:`k` predictions to evaluate against.
+        category (torch.Tensor): A vector that assigns each destination node to
+            a specific category.
+    """
+    higher_is_better: bool = True
+
+    def __init__(self, k: int, category: Tensor) -> None:
+        super().__init__(k)
+
+        if WITH_TORCHMETRICS:
+            self.add_state('accum', torch.tensor(0.), dist_reduce_fx='sum')
+            self.add_state('total', torch.tensor(0), dist_reduce_fx='sum')
+        else:
+            self.register_buffer('accum', torch.tensor(0.))
+            self.register_buffer('total', torch.tensor(0))
+
+        self.category: Tensor
+        self.register_buffer('category', category)
+
+    def update(
+        self,
+        pred_index_mat: Tensor,
+        edge_label_index: Union[Tensor, Tuple[Tensor, Tensor]],
+        edge_label_weight: Optional[Tensor] = None,
+    ) -> None:
+        category = self.category[pred_index_mat[:, :self.k]]
+
+        sim = (category.unsqueeze(-2) == category.unsqueeze(-1)).sum(dim=-1)
+        div = 1 - 1 / (self.k * (self.k - 1)) * (sim - 1).sum(dim=-1)
+
+        self.accum += div.sum()
+        self.total += pred_index_mat.size(0)
+
+    def compute(self) -> Tensor:
+        if self.total == 0:
+            return torch.zeros_like(self.accum)
+        return self.accum / self.total
+
+    def _reset(self) -> None:
+        self.accum.zero_()
+        self.total.zero_()