How to deal with two-dimensional node feature when using GAT

[william2ai]

Hi, I‘m using GAT to do an EEG regression task. My node is (47,18,18), 47 is the node number and 18*18 represents the node feature. I'm a beginner to GNN and all I know for now is GNN can handle one-dimensional node feature for sure.
My 18 * 18 matrix is a positive definite symmetric matrix, so I want to map it to a hyperbolic space through exp(). Some people also suggest that I can first remove the triangle or convert it into one-dimensional through MLP, as it would be better if I could directly process the two-dimensional node feature data. By the way, I'm using a hyperbolic GAT.
Looking forward for your kind help.

The code is as follows:

class HGATConv(MessagePassing):
def init(self,
manifold,
in_channels,
out_channels,
heads=1,
concat=True,
negative_slope=0.2,
dropout=0,
bias=True,
act=None,
atten=True,
dist=True):
super(HGATConv, self).init('add')

    self.manifold = manifold
    self.c = 1.0
    self.concat = concat
    if bias:
        self.bias = Parameter(torch.Tensor(out_channels))
    else:
        self.register_parameter('bias', None)

    if concat:
        self.out_channels = out_channels // heads
    else:
        self.out_channels = out_channels

    self.in_channels = in_channels
    self.heads = heads
    self.negative_slope = negative_slope
    self.dropout = dropout
    self.act = act
    self.dist = dist
    self.atten = atten

    self.hy_linear = HypLinear(manifold, in_channels, heads * self.out_channels, 1, dropout, bias)
    self.att = Parameter(torch.Tensor(1, heads, 2 * self.out_channels))

    self.reset_parameters()

def reset_parameters(self):
    glorot(self.att)
    zeros(self.bias)
    self.hy_linear.reset_parameters()

def forward(self, input):
    x, adj = input
    x = self.hy_linear.forward(x)

    edge_index = adj._indices()
    edge_index, _ = remove_self_loops(edge_index)
    edge_index = add_self_loops(edge_index, num_nodes=x.size(0))

    log_x = pmath.logmap0(x, c=1.0)  # Get log(x) as input to GCN
    log_x = log_x.view(-1, self.heads, self.out_channels)
    out = self.propagate(edge_index, x=log_x, num_nodes=x.size(0), original_x=x)
    out = self.manifold.proj_tan0(out, c=self.c)

    out = self.act(out)
    out = self.manifold.proj_tan0(out, c=self.c)

    return self.manifold.proj(self.manifold.expmap0(out, c=self.c), c=self.c)

def message(self, edge_index_i, x_i, x_j, num_nodes, original_x_i, original_x_j):
    # Compute attention coefficients.
    if self.atten:
        alpha = (torch.cat([x_i, x_j], dim=-1) * self.att).sum(dim=-1)
        if self.dist:  # Compute distance
            dist = pmath.dist(original_x_i, original_x_j)
            dist = softmax(dist, edge_index_i, num_nodes).reshape(-1, 1)
            alpha = alpha * dist
        alpha = F.leaky_relu(alpha, self.negative_slope)
        alpha = softmax(alpha, edge_index_i, num_nodes)

        # Sample attention coefficients stochastically.
        if self.training and self.dropout > 0:
            alpha = F.dropout(alpha, p=self.dropout, training=True)

        return x_j * alpha.view(-1, self.heads, 1)
    else:
        return x_j

def update(self, aggr_out):
    if self.concat:
        aggr_out = aggr_out.view(-1, self.heads * self.out_channels)
    else:
        aggr_out = aggr_out.mean(dim=1)

    if self.bias is not None:
        aggr_out = aggr_out + self.bias
    return aggr_out

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

[rusty1s]

Sorry, can you clarify the issue for me? Is your node feature matrix three-dimensional? Can't you simply reshape that to a two-dimensional feature matrix?

[william2ai]

Thanks for your quick response, my graph have 47 nodes, and each node has a two dimensional feature(18,18). Is the reshape you mentioned directly changing 18*18 into a one-dimensional (N,) form?

My node feature is a positive definite symmetric matrix, and directly using exponential function on this matrix would map it to a hyperbolic space while making it gaussian distribution, which I think maybe better when training.

[william2ai]

Looking forward for your help @rusty1s thanks

[rusty1s]

Is the reshape you mentioned directly changing 18*18 into a one-dimensional (N,) form?

I was thinking you need to reshape to [num_nodes, 18*18]. Currently, GNN layers in PyG expect two-dimensional node feature tensors.