Edge classification example

[Ishitori]

Hi team,

I have an edge classification task at hand, where each node and an edge has features, and I need to binary classify each edge. I don't really need to find a missing links as all edges are given, but I need to binary classify each of the edges on a separate, test graph.

Is there an example that:

1. Uses edge features to calculate node embeddings?
2. Doing edge classification task given features of 2 nodes + features of the edge
3. Does it on a large scale graph (tens of millions nodes)
4. Does it on GPU (or even multi-GPU) to speed up the process

If there are no single example that does it all, then maybe there are separate examples you could share so I could combine it all together into a single unit?

Thank you.

[rusty1s]

1. There exists operators that can incorporate both node and edge features (take a look at: https://pytorch-geometric.readthedocs.io/en/latest/notes/cheatsheet.html), e.g., TransformerConv.
2. This is usually done by just converting node embeddings to edge-level representations:

   x = gnn(x, edge_index, edge_attr)
   x_src, x_dst = x[edge_index[0]], x[edge_index[1]]
   edge_feat = torch.cat([x_src, edge_attr, x_dst], dim=-1)
   out = classifier(edge_feat)

3. We provide support for this via LinkNeighborLoader (needs installation from master)
4. Yes :)

I sadly do not have an exact example of this use-case to share, but it should be pretty similar to https://github.com/pyg-team/pytorch_geometric/blob/master/examples/link_pred.py (without the negative sampling part).

[hahahaha90]

Hi, could you introduce how to push graphs into GPU first then load in mini batch?

[rusty1s]

See here. Importantly, edge_index needs to sit on the CPU for now.

[sipie800]

See here. Importantly, edge_index needs to sit on the CPU for now.

1. There exists operators that can incorporate both node and edge features (take a look at: https://pytorch-geometric.readthedocs.io/en/latest/notes/cheatsheet.html), e.g., TransformerConv.
2. This is usually done by just converting node embeddings to edge-level representations:

   x = gnn(x, edge_index, edge_attr)
   x_src, x_dst = x[edge_index[0]], x[edge_index[1]]
   edge_feat = torch.cat([x_src, edge_attr, x_dst], dim=-1)
   out = classifier(edge_feat)

3. We provide support for this via LinkNeighborLoader (needs installation from master)
4. Yes :)

I sadly do not have an exact example of this use-case to share, but it should be pretty similar to https://github.com/pyg-team/pytorch_geometric/blob/master/examples/link_pred.py (without the negative sampling part).

Hi, I'm new to graph learning. In this example (https://github.com/pyg-team/pytorch_geometric/blob/master/examples/link_pred.py), line 43, why the edge output is directly the element-wise dot of the logits of two nodes ? In my experience, should it be processed by a linear projection or something ? Could you explain the idea ?

[KantiCodes]

Hi @Ishitori, seems like your use case perfectly its what we are doing. I wanted to check up on you and see how it went with your project? Did you use TransformerConv? If it's not confidential could you provide some details of your solution?

Regards

[ghost]

I am also interested in that:

https://discuss.dgl.ai/t/implementing-multidimensional-edge-features-in-node-embedding/4487
https://www.reddit.com/r/MLQuestions/comments/1e50qqv/struggling_with_gnn_for_node_classification_in/

Any updates?