Question about ''TypeError: Required parameter xxx is empty.''

[jiaruHithub]

In GATConv, attention value alpha_ij will computed by softmax to normalized. I try to normalize it by alpha_ij/√(degree_i)√(degree_j). I imitate GCN's practice, and the code is as follows:

class GATConv(MessagePassing):
    _alpha: OptTensor

    def __init__(self, in_channels: Union[int, Tuple[int, int]],
                 out_channels: int, heads: int = 1, concat: bool = True,
                 negative_slope: float = 0.2, dropout: float = 0.0,
                 add_self_loops: bool = None, bias: bool = True, **kwargs):
        kwargs.setdefault('aggr', 'add')
        super(GATConv, self).__init__(node_dim=0, **kwargs)

        self.in_channels = in_channels
        self.out_channels = out_channels
        self.heads = heads
        self.concat = concat
        self.negative_slope = negative_slope
        self.dropout = dropout
        self.add_self_loops = add_self_loops

        if isinstance(in_channels, int):
            self.lin_l = Linear(in_channels, heads * out_channels, bias=False)
            self.lin_r = self.lin_l
        else:
            self.lin_l = Linear(in_channels[0], heads * out_channels, False)
            self.lin_r = Linear(in_channels[1], heads * out_channels, False)

        self.att_l = Parameter(torch.Tensor(1, heads, out_channels))
        self.att_r = Parameter(torch.Tensor(1, heads, out_channels))

        if bias and concat:
            self.bias = Parameter(torch.Tensor(heads * out_channels))
        elif bias and not concat:
            self.bias = Parameter(torch.Tensor(out_channels))
        else:
            self.register_parameter('bias', None)

        self._alpha = None

        self.reset_parameters()

    def reset_parameters(self):
        nn.init.xavier_normal_(self.lin_l.weight, gain=1.414)
        nn.init.xavier_normal_(self.lin_r.weight, gain=1.414)
        nn.init.xavier_normal_(self.att_l, gain=1.414)
        nn.init.xavier_normal_(self.att_r, gain=1.414)
        #nn.init.xavier_normal_(self.bias, gain=1.414)


    def forward(self, x: Union[Tensor, OptPairTensor], edge_index: Adj,
                size: Size = None, return_attention_weights=None):
        r"""
        Args:
            return_attention_weights (bool, optional): If set to :obj:`True`,
                will additionally return the tuple
                :obj:`(edge_index, attention_weights)`, holding the computed
                attention weights for each edge. (default: :obj:`None`)
        """
        H, C = self.heads, self.out_channels

        x_l: OptTensor = None
        x_r: OptTensor = None
        alpha_l: OptTensor = None
        alpha_r: OptTensor = None
        if isinstance(x, Tensor):
            assert x.dim() == 2, 'Static graphs not supported in `GATConv`.'
            x_l = x_r = self.lin_l(x).view(-1, H, C)
            alpha_l = (x_l * self.att_l).sum(dim=-1)
            alpha_r = (x_r * self.att_r).sum(dim=-1)
        else:
            x_l, x_r = x[0], x[1]
            assert x[0].dim() == 2, 'Static graphs not supported in `GATConv`.'
            x_l = self.lin_l(x_l).view(-1, H, C)
            alpha_l = (x_l * self.att_l).sum(dim=-1)
            if x_r is not None:
                x_r = self.lin_r(x_r).view(-1, H, C)
                alpha_r = (x_r * self.att_r).sum(dim=-1)

        assert x_l is not None
        assert alpha_l is not None
        row, col = edge_index
        deg = degree(col, x.size(0), dtype=x.dtype)
        deg_inv_sqrt = deg.pow(-0.5)
        norm = deg_inv_sqrt[row] * deg_inv_sqrt[col]

        # propagate_type: (x: OptPairTensor, alpha: OptPairTensor)
        out = self.propagate(edge_index, x=(x_l, x_r),alpha=(alpha_l, alpha_r), size=size)
        return out


    def message(self, x_j: Tensor, alpha_j: Tensor, alpha_i: OptTensor,
                index: Tensor, ptr: OptTensor, norm: OptTensor, 
                size_i: Optional[int]) -> Tensor:
        alpha = alpha_j if alpha_i is None else alpha_j + alpha_i
        alpha = torch.tanh(alpha)
        self._alpha = alpha
        alpha = F.dropout(alpha, p=self.dropout, training=self.training)
        return norm.view(-1, 1) * x_j * alpha.unsqueeze(-1)

    def __repr__(self):
        return '{}({}, {}, heads={})'.format(self.__class__.__name__,
                                             self.in_channels,
                                             self.out_channels, self.heads)

But the error has reported:

Traceback (most recent call last):
  File "gat.py", line 56, in <module>
    args.early_stopping, permute_masks)
  File "/home/pytorch_geometric-master/pytorch_geometric-master/benchmark/citation1/train_eval.py", line 66, in run
    train(model, optimizer, data)
  File "/home/pytorch_geometric-master/pytorch_geometric-master/benchmark/citation1/train_eval.py", line 104, in train
    out = model(data)
  File "/opt/conda/lib/python3.7/site-packages/torch/nn/modules/module.py", line 722, in _call_impl
    result = self.forward(*input, **kwargs)
  File "gat.py", line 47, in forward
    x = F.elu(self.conv1(x, edge_index))
  File "/opt/conda/lib/python3.7/site-packages/torch/nn/modules/module.py", line 722, in _call_impl
    result = self.forward(*input, **kwargs)
  File "/home/pytorch_geometric-master/pytorch_geometric-master/benchmark/citation1/GATConv.py", line 156, in forward
    out = self.propagate(edge_index, x=(x_l, x_r),alpha=(alpha_l, alpha_r), size=size)
  File "/opt/conda/lib/python3.7/site-packages/torch_geometric/nn/conv/message_passing.py", line 236, in propagate
    msg_kwargs = self.inspector.distribute('message', coll_dict)
  File "/opt/conda/lib/python3.7/site-packages/torch_geometric/nn/conv/utils/inspector.py", line 58, in distribute
    raise TypeError(f'Required parameter {key} is empty.')
TypeError: Required parameter norm is empty.

I hope you can give me help, thank you!

[wsad1]

Pass norm to the self.propogate function.

self.propogate(edge_index, x=(x_l, x_r),alpha=(alpha_l, alpha_r), size=size, norm=norm)

Also checkout FAConv, which probably does exactly what you want.

[jiaruHithub]

Thanks a lot!