def forward(self, x: Tensor, batch: OptTensor = None) -> Tensor:
""""""
if batch is None:
x = x - x.mean()
out = x / (x.std(unbiased=False) + self.eps)
else:
batch_size = int(batch.max()) + 1
norm = degree(batch, batch_size, dtype=x.dtype).clamp_(min=1)
norm = norm.mul_(x.size(-1)).view(-1, 1)
mean = scatter(x, batch, dim=0, dim_size=batch_size,
reduce='add').sum(dim=-1, keepdim=True) / norm
x = x - mean[batch]
var = scatter(x * x,
batch,
dim=0,
dim_size=batch_size,
reduce='add').sum(dim=-1, keepdim=True)
var = var / norm
out = x / (var.sqrt()[batch] + self.eps)
if self.weight is not None and self.bias is not None:
out = out * self.weight + self.bias
return out
def __norm__(self, edge_index, num_nodes: Optional[int],
edge_weight: OptTensor, normalization: Optional[str],
lambda_max: OptTensor = None, dtype: Optional[int] = None,
batch: OptTensor = None):
edge_index, edge_weight = remove_self_loops(edge_index, edge_weight)
edge_index, edge_weight = get_laplacian(edge_index, edge_weight,
normalization, dtype,
num_nodes)
if lambda_max is None:
lambda_max = 2.0 * edge_weight.max()
elif not isinstance(lambda_max, torch.Tensor):
lambda_max = torch.tensor(lambda_max, dtype=dtype,
device=edge_index.device)
assert lambda_max is not None
if batch is not None and lambda_max.numel() > 1:
lambda_max = lambda_max[batch[edge_index[0]]]
edge_weight = (2.0 * edge_weight) / lambda_max
edge_weight.masked_fill_(edge_weight == float('inf'), 0)
edge_index, edge_weight = add_self_loops(edge_index, edge_weight,
fill_value=-1.,
num_nodes=num_nodes)
assert edge_weight is not None
return edge_index, edge_weight
def forward(self, x: Tensor, batch: OptTensor = None) -> Tensor:
""""""
if batch is None:
out = F.instance_norm(
x.t().unsqueeze(0), self.running_mean, self.running_var,
self.weight, self.bias, self.training
or not self.track_running_stats, self.momentum, self.eps)
return out.squeeze(0).t()
batch_size = int(batch.max()) + 1
mean = var = unbiased_var = x # Dummies.
if self.training or not self.track_running_stats:
norm = degree(batch, batch_size, dtype=x.dtype).clamp_(min=1)
norm = norm.view(-1, 1)
unbiased_norm = (norm - 1).clamp_(min=1)
mean = scatter(x, batch, dim=0, dim_size=batch_size,
reduce='add') / norm
x = x - mean[batch]
var = scatter(x * x,
batch,
dim=0,
dim_size=batch_size,
reduce='add')
unbiased_var = var / unbiased_norm
var = var / norm
momentum = self.momentum
if self.running_mean is not None:
self.running_mean = (
1 - momentum) * self.running_mean + momentum * mean.mean(0)
if self.running_var is not None:
self.running_var = (
1 - momentum
) * self.running_var + momentum * unbiased_var.mean(0)
else:
if self.running_mean is not None:
mean = self.running_mean.view(1, -1).expand(batch_size, -1)
if self.running_var is not None:
var = self.running_var.view(1, -1).expand(batch_size, -1)
x = x - mean[batch]
out = x / (var + self.eps).sqrt()[batch]
if self.weight is not None and self.bias is not None:
out = out * self.weight.view(1, -1) + self.bias.view(1, -1)
return out
def forward(self, x: Tensor, batch: OptTensor = None) -> Tensor:
""""""
if self.mode == 'graph':
if batch is None:
x = x - x.mean()
out = x / (x.std(unbiased=False) + self.eps)
else:
batch_size = int(batch.max()) + 1
norm = degree(batch, batch_size, dtype=x.dtype).clamp_(min=1)
norm = norm.mul_(x.size(-1)).view(-1, 1)
mean = scatter(
x, batch, dim=0, dim_size=batch_size, reduce='add').sum(
dim=-1, keepdim=True) / norm
x = x - mean.index_select(0, batch)
var = scatter(x * x,
batch,
dim=0,
dim_size=batch_size,
reduce='add').sum(dim=-1, keepdim=True)
var = var / norm
out = x / (var + self.eps).sqrt().index_select(0, batch)
if self.weight is not None and self.bias is not None:
out = out * self.weight + self.bias
return out
if self.mode == 'node':
return F.layer_norm(x, (self.in_channels, ), self.weight,
self.bias, self.eps)
raise ValueError(f"Unknow normalization mode: {self.mode}")
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
