Interface between networkx and igraph

Question

I\'ve been working with networkx for quite some time now and it\'s been serving my purposes quite well with minimal tweaks until recently when I started looking into communi

Answer 1

Here two ways to convert a NetworkX graph to an igraph:

import networkx as nx, igraph as ig

# create sample NetworkX graph
g = nx.planted_partition_graph(5, 5, 0.9, 0.1, seed=3)

# convert via edge list
g1 = ig.Graph(len(g), list(zip(*list(zip(*nx.to_edgelist(g)))[:2])))
  # nx.to_edgelist(g) returns [(0, 1, {}), (0, 2, {}), ...], which is turned
  #  into [(0, 1), (0, 2), ...] for igraph

# convert via adjacency matrix
g2 = ig.Graph.Adjacency((nx.to_numpy_matrix(g) > 0).tolist())

assert g1.get_adjacency() == g2.get_adjacency()

Using the edge list was somewhat faster for the following 2500-node graph on my machine: (Note that the code below is Python 2 only; I updated the code above to be Python 2/3 compatible.)

In [5]: g = nx.planted_partition_graph(50, 50, 0.9, 0.1, seed=3)

In [6]: %timeit ig.Graph(len(g), zip(*zip(*nx.to_edgelist(g))[:2]))
1 loops, best of 3: 264 ms per loop

In [7]: %timeit ig.Graph.Adjacency((nx.to_numpy_matrix(g) > 0).tolist())
1 loops, best of 3: 496 ms per loop

Using the edge list was also somewhat faster for g = nx.complete_graph(2500).

Answer 2

In an upcoming release of python-igraph or if you install from source this will be as easy as

import igraph
g = igraph.Graph.from_networkx(G)

The source code for how this is done can be found here.

Answer 3

Next to GML, and Pajek, here is how I transported my graph using GraphML. Edgelist works as well, but has the main disadvantage that it discards node identifiers.

I exported my undirected graph using R - iGraph (see similar function in python igraph)

write_graph(igraphNetwork, exportFilePath, format = "graphml") with exportFilePath being e.g. "folder/yournetwork.graphml"

And import via python - networkX and relabel by node attribute name:

import networkx as nx
G = nx.read_graphml(exportFilePath)
G = nx.relabel_nodes(G, nx.get_node_attributes(G, 'name'))

This way I kept the node identifiers.

Answer 4

Networkx and python-igraph both support a wide range of read/write algorithms (networkx, python-igraph).

At least two formats (GML and pajek) appear to be common between the two, although I haven't tried this.

Answer 5

As I try to store names of nodes/edges on both igraph or nx, this is my one-liner version which also transfers nodes names while transferring from igraph object, g, to nx:

G = nx.from_edgelist([(names[x[0]], names[x[1]])
                      for names in [g.vs['name']] # simply a let
                      for x in g.get_edgelist()], nx.DiGraph())

And the reverse way if G, a nx object, is given but an igraph object is needed:

g = igraph.Graph.TupleList(G.edges(), directed=True)

Of course these are not complete transfer as other node attributes and also edge attribute transfers are missing but I hope would be useful when you don't have them.

---

More verbose version that you have more control while transferring, from igraph to nx:

G = nx.DiGraph()
names = g.vs['name']
G.add_nodes_from(names)
G.add_edges_from([(names[x[0]], (names[x[1]])) for x in g.get_edgelist()])

From nx to igraph:

g = igraph.Graph(directed=True)
g.add_vertices(G.nodes())
g.add_edges(G.edges())

(also posted here)