How to estimate a nodes feature vector based on neighbours data

[tristen-tooming]

A novice in need of help:

I have a very simple directed graph 1 -> 2 -> 3 -> 4 with one feature per node lets say it could be speed.
More on graph.x = [[120], [90], [110], [105], [100]] and graph.edge_index = [[0, 1, 2, 3], [1, 2, 3, 4]].

A graph is generated by setting the n = 1st node speed for example to 100 and n + 1 speed is calculated by transforming the n nodes speed with a randomly generated polynomial function with added random bias. This way there exists a function between nodes that could be learned. I generate these kinds of graphs 1000 by drawing starting speed randomly from [90, 130] and keeping the functions the same between the nodes for all the draws. MSE loss is calculated from unbiased values.

Network definition with GraphSAGE-layer:

class Net(torch.nn.Module):
    def __init__(self, in_channels, hidden_channels, num_layers):
        super(Net, self).__init__()

        self.num_layers = num_layers
        self.convs = nn.ModuleList()
        for i in range(num_layers):
            in_channels = in_channels if i == 0 else hidden_channels
            if i == range(num_layers)[-1]:
                self.convs.append(SAGEConv(in_channels, 1)) # Outputs 1d weight
            else:
                self.convs.append(SAGEConv(in_channels, hidden_channels))

    def forward(self, data):
        x, edge_index = data.x, data.edge_index

        for i in range(self.num_layers):
            x = self.convs[i](x, edge_index)
            if i != self.num_layers - 1:
                x = x.relu()
        return x

With two layers and 16 hidden_channels the Network converges. However, I am a bit stuck from now on how to use the learned data. Especially, I want to estimate the node's speed by transforming the previous node's speed with the learned parameters (chaining the message). More on transforming the previous node's signal to the desired one by carrying the message through the graph.

Node -> function -> Node
1 -> f_1(speed) -> 2
100 -> f_1(100) -> 120

Calling model(graph.x) calculates a new feature only for the same node by the learned weights and so on cannot be chained.

I think I need to call the propagate step to achieve the wanted result and chain them (looping)? This way we get the information from the neighbors and the message is carried through the graph?

To achieve this I need probably write a new method for the Net class. Could I just call message, message_and_aggregate or propagate from the SAGEConv class?

[rusty1s]

I thin your GNN implementation looks fine to me. If you want to change specific input features (say data.x[0] = 100), you will need to re-evaluate the model on the complete graph (as there is a inter-dependency of outputs between nodes), e.g.:

data.x[0] = 100
output = model(data)
output[1]  # New estimation for node 1 that takes the modification of node 0 into account