Visualizing Heterogeneous Graphs with NetworkX

[igrangel]

Hi there,
I'm reproducing this example for heterogeneous graphs.
I would like to draw the graph with NetworkX using the following:
print(type(data)) networkx_graph = to_networkx(data) nx.draw(networkx_graph)

In this case, of course the type of data is <class 'torch_geometric.data.hetero_data.HeteroData'>

And I got the following error:

for key, value in data(*(node_attrs + edge_attrs)): TypeError: 'HeteroData' object is not callable

Is this possible for Heterogeneous Graphs? Should I follow a different strategy if I need to visualize the Graph I'm processing?
Looking forward to your comments.

[rusty1s]

We currently do not support conversion of HeteroData to networkx and vice versa (since networkx follows a different path to represent heterogeneous graphs). The best way to do this currently is to convert your HeteroData object into a Data object via data.to_homogeneous() and use to_networkx on this data object.

[igrangel]

@rusty1s thanks a lot, I followed your suggestion and it worked. However, please bear in mind that the majority of applications, at least in the Manufacturing Domain will take into account Heterogeneous Graphs, rather than homogeneous ones.

[vats2004]

I am also trying the same on a very small graph: the goal is to label the nodes and appropriately color them in NetworkX. I tried this:

My Graph data set and metadata looks like this:

Graph Dataset:
HeteroData(
  org={ x=[4, 2] },
  player={
    x=[5, 2],
    y=[5],
  },
  event={ x=[5, 1] },
  (player, played_in, event)={ edge_index=[2, 12] },
  (player, belongs_to, org)={ edge_index=[2, 5] }
)

Data Metadata:
(['org', 'player', 'event'], [('player', 'played_in', 'event'), ('player', 'belongs_to', 'org')])

    def convert_to_networkx(self, graph_data):
        data = graph_data.to_homogeneous()
        print(f'Data.Node_Attrs: {data.node_attrs}')

        nxg = to_networkx(data,
                          node_attrs=data.node_attrs,
                          to_undirected=False)
        print(nxg.nodes(data=True))
        return nxg

Data.Node_Attrs: <bound method BaseData.node_attrs of Data(edge_index=[2, 17], x=[14, 2], node_type=[14], edge_type=[17])>
Traceback (most recent call last):
  File "/Users/vats2/code/GNN/src/main.py", line 78, in <module>
    main()
  File "/Users/vats2/code/GNN/src/main.py", line 58, in main
    g = bld_data_obj.convert_to_networkx(graph_data)
  File "/Users/vats2/code/GNN/src/utiltiies.py", line 369, in convert_to_networkx
    nxg = to_networkx(data,
  File "/Users/vats2/.pyenv/versions/3.10.13/lib/python3.10/site-packages/torch_geometric/utils/convert.py", line 165, in to_networkx
    for key in node_attrs or []:
TypeError: 'method' object is not iterable

Would appreciate any suggestions to carry the node-types/values to networkx so that I can appropriately map and color.

[rusty1s]

You need to pass the attribute names to node_attrs in to_networkx, e.g.:

to_networkx(data, node_attrs=['x'])

[vats2004]

Thanks. The thing is I have 3 types of nodes (org, player and event) and would like to somehow know what each node is after conversion to networkx. My attempts:

data = pyg.to_homogeneous()
print(f'data: {data}')
nxg = to_networkx(data, node_attrs=['x'], to_undirected=True)
print(nxg.nodes(data=True))
print(nxg.edges(data=True))
print(f"G node attr: {nx.get_node_attributes(nxg, 'x')}")

data: Data(edge_index=[2, 17], x=[14, 2], node_type=[14], edge_type=[17])
initial nodelist: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

[(0, {'x': [1, 2]}), (1, {'x': [0, 1]}), (2, {'x': [2, 3]}), (3, {'x': [3, 0]}), (4, {'x': [1, 2]}), (5, {'x': [4, 1]}), (6, {'x': [3, 1]}), (7, {'x': [0, 0]}), (8, {'x': [2, 1]}), (9, {'x': [1, 0]}), (10, {'x': [4, 0]}), (11, {'x': [0, 0]}), (12, {'x': [2, 0]}), (13, {'x': [3, 0]})]

[(0, 5, {}), (1, 6, {}), (2, 7, {}), (3, 4, {}), (3, 8, {}), (4, 12, {}), (4, 11, {}), (4, 9, {}), (5, 9, {}), (5, 10, {}), (6, 12, {}), (6, 11, {}), (7, 9, {}), (7, 11, {}), (7, 12, {}), (8, 12, {}), (8, 13, {})]

G node attr: {0: [1, 2], 1: [0, 1], 2: [2, 3], 3: [3, 0], 4: [1, 2], 5: [4, 1], 6: [3, 1], 7: [0, 0], 8: [2, 1], 9: [1, 0], 10: [4, 0], 11: [0, 0], 12: [2, 0], 13: [3, 0]}

Now, my graph has 14 nodes. But, I do not know which is which (org, player or event). Something like this eg would be great, but, this example has a named-attribute to refer to:
https://stackoverflow.com/questions/62184321/set-node-color-based-on-attribute.

Any suggestions?

[rusty1s]

You can store this attribute in data and then add it to node_attrs. For example

to_networkx(data, node_attrs=['x', 'node_type'])