networkx | Network Analysis in Python

This benchmark shows the performance of many graphs libraries (from different languages). It confirms NetworkX is very slow. The graph-tool Python package seems a significantly faster alternative to NetworkX. Please note that the performance of a given package is dependent of what you want to achieve because the performance of a graph algorithm is very dependent of the chosen internal representation.

The from_pandas_edgelist function requires both the source and target.

It looks like, in calculate_community_modularity, you use greedy_modularity_communities to create a dict, modularity_dict, which maps a node in your graph to a community. If I understand correctly, you can take each subgraph community in modularity_dict and pass it into shannon_entropy to calculate the entropy for that community.

this is pseudo code, so there may be some errors. This should convey the principle, though.

after running calculate_community_modularity, you have a dict like this, where the key is each node, and the value is that which the community belongs to

You can first aggregate the pandas tables to have a weight column, and then load it to networkx with that edge column:

The reason why the edge weights are plotted is that the weights are not updated after removing a node. Hence, pos and labels in your script should be recalculated after removing the node:

Simply call nx.draw(G, pos, with_labels=True) again before plotting new graph. Your code should look like:

The networkx solution you were referring to created an undirected graph, where the nodes were names and the edges were observed pairings. The clusters are then the connected components of the graph, which you can read off using a graph traversal algorithm (e.g. DFS, BFS).

So, you have two options:

1. Construct your own graph implementation, without using networkx, doing the above. Nothing I've just described are things that you can only do with networkx.

2. Use the disjoint sets data structure to generate the groupings. As the name suggests, we maintain a collection of disjoint sets (where a set represents a cluster of people). Whenever we see a pair, we union the clusters that the two people in the pairing originally belonged to. An implementation of union-find, as well as its application to the problem you've described, is given below:

Assuming the graph is not directed (ie. G.is_directed() == False), the number of triangles can be efficiently found by finding nodes that are both neighbors of neighbors and direct neighbors of a same node. Pre-computing and pre-filtering the neighbors of nodes so that each triangle is counted only once helps to improve a lot the execution time. Here is the code:

The easiest way is to add all information to the networkx graph and directly create it in the way you need it. I guess you want to use some Graph Neural Networks. Then you want to have something like below.

1. Instead of text as labels, you probably want to have a categorial representation, e.g. 1 stands for Ford.
2. If you want to match the "usual convention". Then you name your input features x and your labels/ground truth y.
3. The splitting of the data into train and test is done via mask. So the graph still contains all information, but only part of it is used for training. Check the PyTorch Geometric introduction for an example, which uses the Cora dataset.