यादृच्छिक पावर-लॉ वितरित वजन वाले नेटवर्क

Question

मैं पावर-लॉ वितरण से वजन को बड़ी संख्या में नोड्स के साथ यादृच्छिक रूप से कैसे असाइन कर सकता हूं।

मैंने लिखा

import networkx as nx 
import numpy as np 
from networkx.utils import powerlaw_sequence 

z=nx.utils.create_degree_sequence(200,nx.utils.powerlaw_sequence,exponent=1.9) 
nx.is_valid_degree_sequence(z) 
G=nx.configuration_model(z) 
Gcc=nx.connected_component_subgraphs(G)[0] 

edgelist=[nx.utils.powerlaw_sequence(nx.number_of_edges(Gcc),exponent=2.0)] 

मैं जानता हूँ कि मैं tuples (node1, node2, वजन) का उपयोग करने का एक शब्दकोश से किनारों को वजन आवंटित:

nx.from_edgelist(edgelist,create_using=None) 

लेकिन सिर्फ एक हो रही में रुचि रखते जब मैं कर रहा हूँ भारित नेटवर्क जहां वजन शक्ति-कानून वितरित होते हैं, क्या कोई और छोटा रास्ता है?

Answer 1

आप वजन सीधे G [यू] का उपयोग आवंटित कर सकते हैं [V] [ 'वजन'], उदाहरण के लिए

In [1]: import networkx as nx 

In [2]: import random 

In [3]: G = nx.path_graph(10) 

In [4]: for u,v in G.edges(): 
    ...:  G[u][v]['weight'] = random.paretovariate(2) 
    ...:  
    ...:  

In [5]: print G.edges(data=True) 
[(0, 1, {'weight': 1.6988521989583232}), (1, 2, {'weight': 1.0749963615177736}), (2, 3, {'weight': 1.1503859779558812}), (3, 4, {'weight': 1.675436575683888}), (4, 5, {'weight': 1.1948608572552846}), (5, 6, {'weight': 1.080152340891444}), (6, 7, {'weight': 1.0296667672332183}), (7, 8, {'weight': 2.0014384064255446}), (8, 9, {'weight': 2.2691612212058447})] 

मैं पायथन के random.paretovariate() का इस्तेमाल किया वजन चयन करने के लिए, लेकिन आप कर सकते हैं , ज़ाहिर है, जो भी आप चाहते हैं उसे डाल दें।

Answer 2

मैंने कोशिश की और निम्नलिखित प्राप्त किया .. मुझे उम्मीद है कि इससे मदद मिलती है। इसके अलावा, मैं बेहतर तरीकों की तलाश में हूं क्योंकि यह बीमा नहीं करता है कि मुझे एक कनेक्टेड नेटवर्क मिलता है। इसके अलावा, मुझे अभी भी इसकी संपत्तियों की जांच करनी है।

'''written by Aya Al-Zarka''' 

import networkx as nx 
import matplotlib.pyplot as plt 
from networkx.utils import powerlaw_sequence 
import random as r 
import numpy as np 

G=nx.Graph() 
v=[] 
for i in range(100): 
v.append(i) 

G.add_nodes_from(v) 

weight=[] 
for j in range(300): 
    l=powerlaw_sequence(300,exponent=2.0) 
    weight.append(r.choice(l)) 
#print(weight) 
e=[] 
for k in range(300): 
    f=[r.choice(v),r.choice(v),r.choice(weight)] 
    e.append(f) 

G.add_weighted_edges_from(e,weight='weight') 

print(nx.is_connected(G)) #not always! 


m=np.divide(weight,100.0) 
pos=nx.random_layout(G,dim=2) 
nx.draw_networkx_nodes(G,pos,nodelist=None,node_size=300,node_color='y', 
        node_shape='*', alpha=1.0, cmap=None, vmin=None, 
        vmax=None, ax=None, linewidths=None,) 
nx.draw_networkx_edges(G,pos,edgelist=None,width=m, 
edge_color='b',style='solid',alpha=None,edge_cmap=None, edge_vmin=None, 
edge_vmax=None, ax=None, arrows=False) 
plt.ylim(0,1) 
plt.xlim(0,1) 
plt.axis('off') 
plt.show()