NetworkX最小生成树对于相同的数据有不同的集群排列？

Question

I have a large dataset which compares products with a relatedness measure which looks like this:

product1      product2  relatedness
0101          0102      0.047619
0101          0103      0.023810
0101          0104      0.095238
0101          0105      0.214286
0101          0106      0.047619
...           ...       ...

I used the following code to feed the data into the NetworkX graphing tool and produce an MST diagram:

import networkx as nx
import matplotlib.pyplot as plt

products = (data['product1'])
products = list(dict.fromkeys(products))
products = sorted(products)

G = nx.Graph()
G.add_nodes_from(products)
print(G.number_of_nodes())
print(G.nodes())

row = 0
for c in data['product1']:
    p = data['product2'][row]
    w = data['relatedness'][row]
    if w > 0:
        G.add_edge(c,p, weight=w, with_labels=True)
    row = row + 1

nx.draw(nx.minimum_spanning_tree(G), with_labels=True)
plt.show()

The resulting diagram looks like this: https://i.imgur.com/pBbcPGc.jpg

However, when I re-run the code, with the same data and no modifications, the arrangement of the clusters appears to change, so it then looks different, example here: https://i.imgur.com/4phvFGz.jpg , second example here: https://i.imgur.com/f2YepVx.jpg . The clusters, edges, and weights do not appear to be changing, but the arrangement of them on the graph space is changing each time.

What causes the arrangement of the nodes to change each time without any changes to the code or data? How can I re-write this code to produce a network diagram with approximately the same arrangement of nodes and edges for the same data each time?

Answer 1

The nx.draw method uses by default the spring_layout (link to the doc) . This layout implements the Fruchterman-Reingold force-directed algorithm which starts with random initial positions. This is this layout effect that you witness in your repetitive trials.

If you want to "fix" the positions, then you should explicitely call the spring_layout function and specify the initial positions in the pos argument.

Answer 2

Assign G = nx.minimum_spanning_tree(G) for purpose of clarity. Then

nx.draw(G, with_labels=True)

is equivalent to

pos = nx.spring_layout(G)
nx.draw(G, pos=pos, with_labels=True)

Since you don't like pos to be calculated randomly every time you run your script, the only way to keep your pos stable is to store it once and retrieve from file after each rerun. You can put this script to calculate pos in an improved manner before nx.draw(G, pos=pos, with_labels=True) :

import os, json

def store(pos):
    #form of dictionary to be stored dictionary retrieved
    return {k: v.tolist() for k, v in pos.items()}
def retrieve(pos):
    #form of dictionary to be retrieved
    return {float(k): v for k, v in pos.items()}

if 'nodes.txt' in os.listdir():
    json_file = open('pos.txt').read()
    pos = retrieve(json.loads(json_file)) #retrieving dictionary from file
    print('retrieve', pos)
else:
    with open('pos.txt', 'w') as outfile:
        pos = nx.spring_layout(new_G) #calculates pos
        print('store', pos)
        json.dump(store(pos), outfile, indent=4) #records pos dictionary into file

This is an ugly solution because it depends unconditionally of data types used in pos dictionary. It worked for me, but you might to define your custom ones used in store and retrieve