Question on edge regression

[edvin-svk]

I'm new to pyg and would like to do edge regression on a graph, more specifically flows between nodes. I.e. I have an undirected graph with one target value per edge (the sign of which indicates the direction of the flow). I'm not sure how to write this in code - is there a way to achieve this without having to specify a target value for both directions in the graph? What confuses me is the undirected nature of the underlying data graph, which seems to require that I specify target values for both directions.

I haven't been able to find a simple example of edge regression, I'd be happy to be directed to some code.

[rusty1s]

I think you have two options:

• Use an undirected edge classifier and train on ground-truth for both directions:

out = self.MLP(x[edge_index[0]] * x[edge_index[1]])

• Only train on one specific direction, e.g:

mask = edge_index[0] >= edge_index[1]
out = self.MLP(torch.cat([x[edge_index[0, mask]], x[edge_index[1, mask]]], dim=-1))
y = y[mask]

[edvin-svk]

I think the formatting got a bit messed up there, could you fix that?
hm can you elaborate a bit on the first option -- do you mean to use a classifier to separate the directions? I also don't understand the code there, there are some square brackets missing. What do you mean "train on ground-truth for both directions"?

[rusty1s]

Fixed the formatting, let me know if this resolves your concerns.

[edvin-svk]

Sorry no I'm a bit too new to this to understand your example.

Perhaps showing my current code will help give you an idea of my current level of knowledge.
I think I'm not doing things correctly in the forward method where I'm trying to get an estimate for each edge's flow.

class GNN(torch.nn.Module):
    name = "gnn"

    def __init__(self, hidden_channels: int = None) -> None:
        super().__init__()
        torch.manual_seed(1234)

        TOPOLOGY = get_static_graph()
        nr_of_nodes = TOPOLOGY.number_of_nodes()
        hidden_channels = hidden_channels or nr_of_nodes

        # We want to go from #n input features to #m output features (number of edges)
        self.conv1 = GCNConv(-1, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, TOPOLOGY.number_of_edges())

    def forward(self, x, edge_index):
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = self.conv2(x, edge_index)
        x = F.relu(x)
        # TODO: does this make sense to just sum? I want to get nr-of-edges numbers in the end
        return torch.sum(x, axis=0)

model = GNN(20)
criterion = torch.nn.MSELoss()

for snapshot in samples:
    # snapshot.x contains node features. edge_index is always the same (static graph)
    out = model(snapshot.x, snapshot.edge_index)
    loss = criterion(out, snapshot.flows)
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()

[rusty1s]

It could be something like

class GNN(torch.nn.Module):
    name = "gnn"

    def __init__(self, hidden_channels: int = None) -> None:
        super().__init__()
        torch.manual_seed(1234)

        TOPOLOGY = get_static_graph()
        nr_of_nodes = TOPOLOGY.number_of_nodes()
        hidden_channels = hidden_channels or nr_of_nodes

        self.conv1 = GCNConv(-1, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, hidden_channels)
        self.lin = Linear(2 * hidden_channels, 1)

    def forward(self, x, edge_index):
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = self.conv2(x, edge_index)
        x = F.relu(x)
        edge_x = torch.cat([x[edge_index[0]], x[edge_index[1]]], dim=-1)
        return self.lin(edge_x)

model = GNN(20)
criterion = torch.nn.MSELoss()

for snapshot in samples:
    # snapshot.x contains node features. edge_index is always the same (static graph)
    out = model(snapshot.x, snapshot.edge_index)
    loss = criterion(out, snapshot.flows)
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()

[edvin-svk]

Ah, thanks! So, do I understand correctly that

• The two GCNConv layers will process the input node feature data with convolutions in two message passing steps, to arrive at some sort of node representations (vectors) holding information from two "steps" away in the graph.
• The last linear step compute edge values by computing a linear combination of the node representations of each node-node pair associated to the respective edge

?

[rusty1s]

Yes, that is correct.