Heterogeneous graph from networkx

[HamidL]

Hi,

I'm having issues working with heterogeneous data represented in networkx graphs.

I have data represented in a networkx graph containing two types of nodes ("source" and "update") and two types of edges ("topology", which connects two "source" node types; and "involved", which connects an "update" to a "source").

I have created extra attributes in the nodes to make sure that all of them have the same attributes, as required (from_networkx).

Even though the conversion works, when executing to_heterogeneous, I get an error:

...in Data.to_heterogeneous(self, node_type, edge_type, node_type_names, edge_type_names)
    525     node_type_names = store.__dict__.get('_node_type_names', None)
    526 if node_type_names is None:
--> 527     node_type_names = [str(i) for i in node_type.unique().tolist()]
    529 if edge_type is None:
    530     edge_type = self._store.get('edge_type', None)

AttributeError: 'list' object has no attribute 'unique

The node_type attribute contains the following:

['source', 'source', 'update']

To reproduce the issue:

import networkx as nx
import torch
from torch_geometric.utils.convert import from_networkx

graph = nx.Graph()
graph.add_node(1,
               node_type="source",
               dummy=torch.tensor([1.]),
               count=torch.tensor([1.]),
               addr=torch.tensor([[0., 0., 0., 0., 1., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 1., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.]]),
               mask=torch.tensor([[0., 1., 1., 0., 0., 0.], [0., 1., 1., 0., 0., 0.]]),
               as_path=torch.zeros((1, 32)),
               type=torch.tensor([1.]))
graph.add_node(2,
               node_type="source",
               dummy=torch.tensor([1.]),
               count=torch.tensor([1.]),
               addr=torch.tensor([[0., 0., 0., 0., 1., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.]]),
               mask=torch.tensor([[0., 1., 1., 0., 0., 0.]]),
               as_path=torch.zeros((1, 32)),
               type=torch.tensor([1.]))
graph.add_node(123131243,
               node_type="update",
               dummy=torch.tensor([1.]),
               count=torch.tensor([1.]),
               type=torch.tensor([1.]),
               addr=torch.tensor([0., 0., 0., 0., 1., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.]),
               mask=torch.tensor([0., 1., 1., 0., 0., 0.]),
               as_path=torch.tensor([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,  0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1.]]))

graph.add_edge(1, 2, edge_type="topology")
graph.add_edge(123131243, 1, edge_type="involved")

data = from_networkx(graph)
data.to_heterogeneous()

My main question is: what would be the best way of transforming a networkx heterogeneous graph to HeteroData??

Thank you for your time.

[rusty1s]

to_heterogeneous requires that node_type and edge_type denote index-based vectors, not lists of strings:

import networkx as nx
import numpy as np
import torch

from torch_geometric.utils.convert import from_networkx

graph = nx.DiGraph()
graph.add_node(...)
graph.add_node(...)
graph.add_node(...)

graph.add_edge(1, 2, edge_type="topology")
graph.add_edge(123131243, 1, edge_type="involved")

data = from_networkx(graph)

data.node_type = np.unique(np.array(data.node_type), return_inverse=True)[1]
data.node_type = torch.from_numpy(data.node_type)

data.edge_type = np.unique(np.array(data.edge_type), return_inverse=True)[1]
data.edge_type = torch.from_numpy(data.edge_type)

hetero_data = data.to_heterogeneous(
    node_type_names=['source', 'update'],
    edge_type_names=[('source', 'topology', 'source'),
                     ('update', 'involved', 'source')])

print(hetero_data)

[HamidL]

Hi!

Thank you for your answer!! It works as intended, but I still have one more doubt. The resulting HeteroData object is the following:

HeteroData(
  addr=[3],
  mask=[3],
  as_path=[3],
  source={
    dummy=[2],
    count=[2],
    type=[2]
  },
  update={
    dummy=[1],
    count=[1],
    type=[1]
  },
  (source, topology, source)={ edge_index=[2, 2] },
  (update, involved, source)={ edge_index=[2, 2] }
)

The addr, mask and as_path attributes are not included in the source and update nodes due to their shapes. What would be the proper way of dealing with attributes with different shapes? Is there any other way other than padding the attributes before converting the graph to HeteroData?? I fear that this may not be very efficient, even though I'm not sure that there's any other way to do it (for example, the as_path attribute may be a tensor of shape (n, 32) with n being about 50 in some cases).

I've seen that a list of tensors is used if no stack can be performed due to dimensions. Padding before calling to_heterogeneous solves it.

Again, thank you for your time.