def forward(self, x: Tensor, edge_index: Adj) -> Tensor:
""""""
edge_weight: OptTensor = None
if isinstance(edge_index, Tensor):
num_nodes = x.size(self.node_dim)
if self.add_self_loops:
edge_index, _ = remove_self_loops(edge_index)
edge_index, _ = add_self_loops(edge_index, num_nodes=num_nodes)
row, col = edge_index[0], edge_index[1]
deg_inv = 1. / degree(col, num_nodes=num_nodes).clamp_(1.)
edge_weight = deg_inv[col]
edge_weight[row == col] += self.diag_lambda * deg_inv
elif isinstance(edge_index, SparseTensor):
if self.add_self_loops:
edge_index = set_diag(edge_index)
col, row, _ = edge_index.coo() # Transposed.
deg_inv = 1. / sparsesum(edge_index, dim=1).clamp_(1.)
edge_weight = deg_inv[col]
edge_weight[row == col] += self.diag_lambda * deg_inv
edge_index = edge_index.set_value(edge_weight, layout='coo')
# propagate_type: (x: Tensor, edge_weight: OptTensor)
out = self.propagate(edge_index,
x=x,
edge_weight=edge_weight,
size=None)
out = self.lin_out(out) + self.lin_root(x)
return out
def adj_type_to_edge_tensor_type(layout: EdgeLayout,
edge_index: Adj) -> EdgeTensorType:
r"""Converts a PyG Adj tensor to an EdgeTensorType equivalent."""
if isinstance(edge_index, Tensor):
return (edge_index[0], edge_index[1]) # (row, col)
if layout == EdgeLayout.COO:
return edge_index.coo()[:-1] # (row, col)
elif layout == EdgeLayout.CSR:
return edge_index.csr()[:-1] # (rowptr, col)
else:
return edge_index.csr()[-2::-1] # (row, colptr)
def homophily(edge_index: Adj, y: Tensor, method: str = 'edge'):
r"""The homophily of a graph characterizes how likely nodes with the same
label are near each other in a graph.
There are many measures of homophily that fits this definition.
In particular:
- In the `"Beyond Homophily in Graph Neural Networks: Current Limitations
and Effective Designs" <https://arxiv.org/abs/2006.11468>`_ paper, the
homophily is the fraction of edges in a graph which connects nodes
that have the same class label:
.. math::
\text{homophily} = \frac{| \{ (v,w) : (v,w) \in \mathcal{E} \wedge
y_v = y_w \} | } {|\mathcal{E}|}
That measure is called the *edge homophily ratio*.
- In the `"Geom-GCN: Geometric Graph Convolutional Networks"
<https://arxiv.org/abs/2002.05287>`_ paper, edge homophily is normalized
across neighborhoods:
.. math::
\text{homophily} = \frac{1}{|\mathcal{V}|} \sum_{v \in \mathcal{V}}
\frac{ | \{ (w,v) : w \in \mathcal{N}(v) \wedge y_v = y_w \} | }
{ |\mathcal{N}(v)| }
That measure is called the *node homophily ratio*.
Args:
edge_index (Tensor or SparseTensor): The graph connectivity.
y (Tensor): The labels.
method (str, optional): The method used to calculate the homophily,
either :obj:`"edge"` (first formula) or :obj:`"node"`
(second formula). (default: :obj:`"edge"`)
"""
assert method in ['edge', 'node']
y = y.squeeze(-1) if y.dim() > 1 else y
if isinstance(edge_index, SparseTensor):
col, row, _ = edge_index.coo()
else:
row, col = edge_index
if method == 'edge':
return int((y[row] == y[col]).sum()) / row.size(0)
else:
out = torch.zeros_like(row, dtype=float)
out[y[row] == y[col]] = 1.
out = scatter_mean(out, col, 0, dim_size=y.size(0))
return float(out.mean())
def forward(self, x: Tensor, edge_index: Adj) -> Tensor:
""""""
row, col, edge_attr = edge_index.coo()
edge_index = torch.stack([row, col], dim=0)
# calculate edge weights [edge_attr -> edge_weight]
encodings = F.one_hot(torch.flatten(edge_attr).long(), num_classes=self.num_edge_types).double()
alpha_m = (encodings * self.att_m).sum(dim=-1).reshape(-1, 1)
alpha_l = (x * self.att_l).sum(dim=-1).reshape(-1, 1)
alpha_r = (x * self.att_r).sum(dim=-1).reshape(-1, 1)
# propagate_type: (x: Tensor, x_norm: Tensor)
return self.propagate(edge_index,
x=x,
alpha=(alpha_l, alpha_r),
alpha_m=alpha_m,
size=None)
def forward(self, edge_index: Adj,
edge_label_index: OptTensor = None) -> Tensor:
r"""Computes rankings for pairs of nodes.
Args:
edge_index (Tensor or SparseTensor): Edge tensor specifying the
connectivity of the graph.
edge_label_index (Tensor, optional): Edge tensor specifying the
node pairs for which to compute rankings or probabilities.
If :obj:`edge_label_index` is set to :obj:`None`, all edges in
:obj:`edge_index` will be used instead. (default: :obj:`None`)
"""
if edge_label_index is None:
if isinstance(edge_index, SparseTensor):
edge_label_index = torch.stack(edge_index.coo()[:2], dim=0)
else:
edge_label_index = edge_index
out = self.get_embedding(edge_index)
out_src = out[edge_label_index[0]]
out_dst = out[edge_label_index[1]]
return (out_src * out_dst).sum(dim=-1)
def homophily(edge_index: Adj,
y: Tensor,
batch: OptTensor = None,
method: str = 'edge') -> Union[float, Tensor]:
r"""The homophily of a graph characterizes how likely nodes with the same
label are near each other in a graph.
There are many measures of homophily that fits this definition.
In particular:
- In the `"Beyond Homophily in Graph Neural Networks: Current Limitations
and Effective Designs" <https://arxiv.org/abs/2006.11468>`_ paper, the
homophily is the fraction of edges in a graph which connects nodes
that have the same class label:
.. math::
\frac{| \{ (v,w) : (v,w) \in \mathcal{E} \wedge y_v = y_w \} | }
{|\mathcal{E}|}
That measure is called the *edge homophily ratio*.
- In the `"Geom-GCN: Geometric Graph Convolutional Networks"
<https://arxiv.org/abs/2002.05287>`_ paper, edge homophily is normalized
across neighborhoods:
.. math::
\frac{1}{|\mathcal{V}|} \sum_{v \in \mathcal{V}} \frac{ | \{ (w,v) : w
\in \mathcal{N}(v) \wedge y_v = y_w \} | } { |\mathcal{N}(v)| }
That measure is called the *node homophily ratio*.
- In the `"Large-Scale Learning on Non-Homophilous Graphs: New Benchmarks
and Strong Simple Methods" <https://arxiv.org/abs/2110.14446>`_ paper,
edge homophily is modified to be insensitive to the number of classes
and size of each class:
.. math::
\frac{1}{C-1} \sum_{k=1}^{C} \max \left(0, h_k - \frac{|\mathcal{C}_k|}
{|\mathcal{V}|} \right),
where :math:`C` denotes the number of classes, :math:`|\mathcal{C}_k|`
denotes the number of nodes of class :math:`k`, and :math:`h_k` denotes
the edge homophily ratio of nodes of class :math:`k`.
Thus, that measure is called the *class insensitive edge homophily
ratio*.
Args:
edge_index (Tensor or SparseTensor): The graph connectivity.
y (Tensor): The labels.
batch (LongTensor, optional): Batch vector\
:math:`\mathbf{b} \in {\{ 0, \ldots,B-1\}}^N`, which assigns
each node to a specific example. (default: :obj:`None`)
method (str, optional): The method used to calculate the homophily,
either :obj:`"edge"` (first formula), :obj:`"node"` (second
formula) or :obj:`"edge_insensitive"` (third formula).
(default: :obj:`"edge"`)
"""
assert method in {'edge', 'node', 'edge_insensitive'}
y = y.squeeze(-1) if y.dim() > 1 else y
if isinstance(edge_index, SparseTensor):
row, col, _ = edge_index.coo()
else:
row, col = edge_index
if method == 'edge':
out = torch.zeros(row.size(0), device=row.device)
out[y[row] == y[col]] = 1.
if batch is None:
return float(out.mean())
else:
dim_size = int(batch.max()) + 1
return scatter_mean(out, batch[col], dim=0, dim_size=dim_size)
elif method == 'node':
out = torch.zeros(row.size(0), device=row.device)
out[y[row] == y[col]] = 1.
out = scatter_mean(out, col, 0, dim_size=y.size(0))
if batch is None:
return float(out.mean())
else:
return scatter_mean(out, batch, dim=0)
elif method == 'edge_insensitive':
assert y.dim() == 1
num_classes = int(y.max()) + 1
assert num_classes >= 2
batch = torch.zeros_like(y) if batch is None else batch
num_nodes = degree(batch, dtype=torch.int64)
num_graphs = num_nodes.numel()
batch = num_classes * batch + y
h = homophily(edge_index, y, batch, method='edge')
h = h.view(num_graphs, num_classes)
counts = batch.bincount(minlength=num_classes * num_graphs)
counts = counts.view(num_graphs, num_classes)
proportions = counts / num_nodes.view(-1, 1)
out = (h - proportions).clamp_(min=0).sum(dim=-1)
out /= num_classes - 1
return out if out.numel() > 1 else float(out)
else:
raise NotImplementedError
