How to deal with high-dimensional features of nodes?

[finquick]

I just started using PYG, how to deal with the high dimensional feature of nodes？
For example, if the node feature dimension is 7*96 and the input data shape is 【Batch, num_nodes, signal_channel, time_slice】, how do I feed the data into the GAT model? 【Num_nodes, signal_channel*time_slice】?
In DGL I can feed the feature as the shape【Batch, num_nodes, signal_channel, time_slice】, how can I do this in PYG?
thanks！

[rusty1s]

This depends on what you are trying to achieve. If you want to share parameters across the "time" dimension, you should move them outside the feature dimension into the node/batch dimension, i.e., [batch_size * num_nodes * time_slice, signal_channels].

We also have support for static graphs with batch-wise node features, i.e., [batch_size, num_nodes, num_features], but this is not applicable for any GNN operator (e.g., GATConv does not support this yet).

Do you have a pointer on how DGL handles arbitrary feature shapes? I don't find any reference to this in the doc.

[finquick]

Different from the meaning of CNN's channel, channel in graph neural network means the length of the feature, right? Channel_in refers to the transformation dimension of a feature.
That is, the dimensions that need feature extraction are put in the channel position of the last dimension, and the remaining dimensions are merged, right?
How does the message passing between nodes indicated by the adjacency matrix take place when the node dimensions are merged?
Thank you very much!
I checked the DGL code again, I think I misunderstood. I carried out a similar process as follows in my experiment before, and finally, the shape was consistent with my expectation, so I thought it was normal to support multi-dimensional feature operation.

my_edge_index = torch.tensor([[0, 1, 1, 2, 3, 4, 5, 6],
                [1, 0, 2, 1, 0, 0, 0, 0]], dtype=torch.long)
my_x = torch.randn((64,4,9,128), dtype=torch.float)
mydata = Data(x=x, edge_index = my_edge_index)

from torch_geometric.nn import GCNConv
mygat = GCNConv(128, 256, 3)
x = mygat(my_x, my_edge_index)
x.shape #torch.Size([64, 4, 9, 256])

The final output and input of the model are only transformed in the channel dimension, this makes me think that high-dimensional feature calculation of GNN nodes is supported.

[rusty1s]

Different from the meaning of CNN's channel, channel in graph neural network means the length of the feature, right?

Yes, but it's actual the same concept as utilized in CNNs, i.e., it refers to the size of the feature dimension. Similar to a CNN, the weights are shared across all other dimensions.

In your example, you may want to specify the actual node_dim as well (the dimension to aggregate information in). By default, it is set to node_dim=-2.

[finquick]

Thanks for your help!
In my research area, every node has 9 channels, and each channel has a time sequence which has a length of 128, in another word, there are 9*128 features of every node, when I want the nodes to transmit info with each other, I need to transform the dim of the channel, is the demo right? Thanks!

batch_size = 32
node_num = 6
channel_size = 9
seq_len = 128
hidden_size = 256

from torch_geometric.nn import GCNConv

edge_index = torch.tensor([[1,2,3,4,5],
                            [0,0,0,0,0]])
har_tensor = torch.randn(32, 6, 9, 128)
data = Data(x=har_tensor, edge_index=edge_index)

model = GCNConv(channel_size*seq_len, channel_size*hidden_size)

x = model(data.x.reshape(batch_size, node_num, -1), data.edge_index)

x = x.reshape(batch_size, node_num, channel_size, -1)
print(x.shape)#32*6*9*256

[rusty1s]

Yes, this works, although this procedure will share information across different timestamps (not sure if this is intended). Otherwise, you need to permute your matrix to shape [batch_size, time_seq, num_nodes, num_feat] via data.x.permute(0, 3, 1, 2) prior to inputting into GCNConv.

[finquick]

Otherwise, you need to permute your matrix to shape [batch_size, time_seq, num_nodes, num_feat] via data.x.permute(0, 3, 1, 2) prior to inputting into GCNConv.

Excellent, I just want to do this work!

batch_size = 32
node_num = 6
channel_size = 9
time_steps = 4
seq_len = 128
step_seq_len = 32
hidden_size = 256

import torch
from torch_geometric.data import Data
from torch_geometric.nn import GCNConv

edge_index = torch.tensor([[1,2,3,4,5],
                            [0,0,0,0,0]])
#                                          split to 4 timesteps                          merge node features                        
har_tensor = torch.randn(32, 6, 9, 128).reshape(32, 6, 9, 4, 32).permute(0, 3, 1, 2, 4).reshape(32, 4, 6, 9*32)


data = Data(x=har_tensor, edge_index=edge_index)

model = GCNConv(channel_size*step_seq_len, channel_size*hidden_size)

x = model(data.x.reshape(batch_size, time_steps, node_num, -1), data.edge_index)

x = x.reshape(batch_size, time_steps, node_num, channel_size, -1)

print(x.shape)#32*4*6*9*256

In this way, the graph formed by each timestep is messaging and aggregation. The time steps are independent graph structures, and parameters are shared between timesteps, right?
If I wanted to introduce the sliding window with overlap, I would have to build the graph while the data is being built, and now the data is being built without any overlap between the two timesteps.
Thanks!