Python में Social Network Analysis

Asymmetric Networks

यदि नोड्स के बीच का संबंध 'child of' हो, तो संबंध अब symmetric नहीं रहता। यदि A, B का child है, तो B, A का child नहीं होगा। ऐसा नेटवर्क जहाँ संबंध asymmetric हो (A का संबंध B से है, तो यह आवश्यक नहीं कि B का संबंध A से हो) Asymmetric network कहलाता है। हम NetworkX में DiGraph मेथड—जो Directional Graph का संक्षिप्त रूप है—का उपयोग करके asymmetric नेटवर्क बना सकते हैं। आइए एक asymmetric ग्राफ बनाते हैं।

G_asymmetric = nx.DiGraph()
G_asymmetric.add_edge('A','B')
G_asymmetric.add_edge('A','D')
G_asymmetric.add_edge('C','A')
G_asymmetric.add_edge('D','E')

अब इसे विज़ुअलाइज़ करते हैं। हम पहले की तरह draw_networkx() फ़ंक्शन का उपयोग कर सकते हैं। हालांकि, संभव है कि नोड्स अलग-अलग न दिखें और नेटवर्क में स्पष्ट नज़र न आएँ। इसे सुधारने के लिए, हम layout को force करने वाला फ़ंक्शन इस्तेमाल कर सकते हैं, जो नोड्स को ऐसी स्थिति में रखता है कि वे स्पष्ट दिखें। यह हम spring_layout() फ़ंक्शन के बाद draw_networkx() फ़ंक्शन का उपयोग करके कर सकते हैं।

nx.spring_layout(G_asymmetric)
nx.draw_networkx(G_asymmetric)

नीचे आप layout कमांड के साथ और बिना बनाए नेटवर्क देख सकते हैं। layout कमांड से बना नेटवर्क अधिक स्पष्ट है।

Weighted Networks

अब तक हमारे नेटवर्क बिना weight के थे, लेकिन संभव है कि नेटवर्क weights के साथ हों; उदाहरण के लिए, यदि हम अपने शुरुआती नेटवर्क में साथ की गई फिल्मों की संख्या को weight मानें, तो हमें एक Weighted Network मिलेगा। आइए फिर से अभिनेताओं का नेटवर्क बनाते हैं, लेकिन इस बार हम नेटवर्क में weight जोड़ते हैं—हर edge का एक weight होगा जो दर्शाएगा कि उन्होंने साथ में कितनी फिल्में की हैं।

G_weighted = nx.Graph()
G_weighted.add_edge('Amitabh Bachchan','Abhishek Bachchan', weight=25)
G_weighted.add_edge('Amitabh Bachchan','Aaamir Khan', weight=8)
G_weighted.add_edge('Amitabh Bachchan','Akshay Kumar', weight=11)
G_weighted.add_edge('Amitabh Bachchan','Dev Anand', weight=1)
G_weighted.add_edge('Abhishek Bachchan','Aaamir Khan', weight=4)
G_weighted.add_edge('Abhishek Bachchan','Akshay Kumar',weight=7)
G_weighted.add_edge('Abhishek Bachchan','Dev Anand', weight=1)
G_weighted.add_edge('Dev Anand','Aaamir Khan',weight=1)

ऊपर का चित्र circular layout में अभिनेताओं का weighted नेटवर्क दिखाता है। edge की चौड़ाई दो नोड्स के बीच के weight को दर्शाती है।

Multigraph

हम edges को अलग-अलग attributes दे सकते हैं। उदाहरण के लिए, हम दो नोड्स 'A' और 'B' के बीच relation attribute का उपयोग कर neighbor संबंध परिभाषित कर सकते हैं। यदि किसी नेटवर्क के भीतर दो नोड्स दो अलग-अलग edges (संबंधों) से जुड़े हैं, तो हमारे पास एक multigraph होता है। हम MultiGraph क्लास का उपयोग करके multigraph बना सकते हैं।

G = nx.MultiGraph()
G.add_edge('A','B',relation ='neighbor')
G.add_edge('A','B',relation='friend)
G.add_edge('B','C', relation='neighbor')
G.add_edge('D','C',relation='friend')

यह कोड A और B के बीच दो edges वाला ग्राफ बनाएगा। हम G.edges() का उपयोग करके कनेक्शनों की जाँच कर सकते हैं; आउटपुट कुछ इस प्रकार होगा:

MultiEdgeDataView([('A', 'B', {'relation': 'neighbor'}), ('A', 'B', {'relation': 'friend'}), ('B', 'C', {'relation': 'neighbor'}), ('B', 'D', {'relation': 'neighbor'}), ('C', 'D', {'relation': 'friend'})])

Network Connectivity

अब जब नेटवर्क बन गया है, क्या हम नेटवर्क में किसी विशेष नोड के बारे में अधिक जान सकते हैं? जी हाँ, आइए कुछ मापदंडों की पड़ताल करते हैं।

Degree

किसी नोड का degree उस नोड के पास मौजूद कनेक्शनों की संख्या को परिभाषित करता है। NetworkX में degree फ़ंक्शन है, जिसकी मदद से हम नेटवर्क में किसी नोड का degree निकाल सकते हैं।

nx.degree(G_symmetric, 'Dev Anand`)

यह 3 का मान लौटाएगा, क्योंकि Dev Anand के नेटवर्क में केवल तीन अभिनेताओं से संबंध हैं।

Clustering Coefficient

यह देखा गया है कि सोशल नेटवर्क में कनेक्शन साझा करने वाले लोग अक्सर आपस में समूह बनाते हैं। दूसरे शब्दों में, सोशल नेटवर्क में क्लस्टर्स बनने की प्रवृत्ति होती है। हम किसी नोड के क्लस्टर्स—अर्थात Local Clustering Coefficient—का निर्धारण कर सकते हैं, जो नोड के दोस्तों (कनेक्शनों) की उन युग्मों का अनुपात है जो आपस में जुड़े हैं। स्थानीय क्लस्टरिंग गुणांक निकालने के लिए हम nx.clustering(Graph, Node) फ़ंक्शन का उपयोग करते हैं।

सिमेट्रिक Actor-नेटवर्क में, आप पाएँगे कि Dev Anand का स्थानीय क्लस्टरिंग गुणांक 1 है और Abhishek Bachchan का 0.67।

सिमेट्रिक Actor-नेटवर्क के लिए औसत क्लस्टरिंग गुणांक (सभी स्थानीय क्लस्टरिंग गुणांकों का योग, नोड्स की संख्या से भाग) 0.867 है। इसे हम इस प्रकार प्राप्त कर सकते हैं:

nx.average_clustering(G_symmetric)

Distance

हम NetworkX में nx.shortest_path(Graph, Node1, Node2) और nx.shortest_path_length(Graph, Node1, Node2) फ़ंक्शनों का उपयोग करके दो नोड्स के बीच का सबसे छोटा पथ और उसकी लंबाई भी निकाल सकते हैं।

यदि हम चलाएँ

nx.shortest_path(G_symmetric, 'Dev Anand', 'Akshay Kumar')

तो यह लौटाता है

['Dev Anand', 'Amitabh Bachchan', 'Akshay Kumar']

हम breadth-first search एल्गोरिद्म का उपयोग करके, किसी नोड से शुरू करते हुए, नेटवर्क में हर अन्य नोड तक की दूरी भी खोज सकते हैं। NetworkX इसके लिए bfs_tree फ़ंक्शन देता है। तो यदि आप T = nx.bfs_tree(G_symmetric, 'Dev Anand') आज़माएँ और अब इस पेड़ को ड्रॉ करें, तो हमें एक नेटवर्क संरचना मिलेगी जो बताएगी कि Dev Anand से शुरू करके नेटवर्क के अन्य नोड्स तक कैसे पहुँचा जा सकता है।

Eccentricity

किसी नोड A की eccentricity, A और सभी अन्य नोड्स के बीच की अधिकतम दूरी के रूप में परिभाषित होती है। इसे nx.eccentricity() फ़ंक्शन से पाया जा सकता है। सिमेट्रिक Actor-नेटवर्क में, Dev Anand की eccentricity 2 है, और Abhishek Bachchan की 1 (यह सभी से जुड़ा है)।

Network Influencers

ऊपर हमने कुछ नेटवर्क distance मेट्रिक्स सीखे, जो यह जानने में सहायक हैं कि जानकारी नेटवर्क में कैसे फैलेगी। इस सेक्शन में, हम नेटवर्क में सबसे महत्वपूर्ण नोड्स (व्यक्तियों) को ढूँढना सीखेंगे। इन पैरामीटर्स को centrality measures कहा जाता है।

क्या आपको अपने स्कूल की वह लोकप्रिय लड़की या स्कूल का टॉप बेसबॉल खिलाड़ी याद है? ये वे लोग थे जिनके पास आपके स्कूल के अनुभव को अच्छा या बुरा बनाने की शक्ति थी। उन्हें यह शक्ति किसने दी? Centrality Measures हमें नेटवर्क में लोकप्रियता, सबसे अधिक पसंद किए जाने वाले, और सबसे बड़े Influencers की पहचान करने में मदद कर सकते हैं।

Degree Centrality

सबसे लोकप्रिय या अधिक पसंद किए जाने वाले लोग अक्सर वे होते हैं जिनके अधिक दोस्त होते हैं। Degree centrality नेटवर्क में किसी विशेष नोड के पास मौजूद कनेक्शनों की संख्या का माप है। यह इस विचार पर आधारित है कि महत्वपूर्ण नोड्स के बहुत से कनेक्शन होते हैं। NetworkX में degree_centrality() फ़ंक्शन है, जिससे हम नेटवर्क के सभी नोड्स की degree centrality की गणना कर सकते हैं।

Eigenvector Centrality

महत्व केवल इस बात से तय नहीं होता कि कोई व्यक्ति कितने लोगों से जुड़ा है, बल्कि इससे भी कि वे किन लोगों से जुड़े हैं। दिल्ली की सड़कों पर जब ट्रैफिक पुलिस किसी को नियम तोड़ते हुए पकड़ती है, तो पहला वाक्य अक्सर यही सुनने को मिलता है—"आप जानते हैं मैं किससे सम्बंधित हूँ?"

Eigenvector centrality ठीक इसी बात का माप है। यह तय करती है कि कोई नोड तब महत्वपूर्ण है जब वह अन्य महत्वपूर्ण नोड्स से जुड़ा हो। हम NetworkX के eigenvector_centrality() फ़ंक्शन का उपयोग करके नेटवर्क के सभी नोड्स की eigenvector centrality निकाल सकते हैं।

Google का Pagerank एल्गोरिद्म Eigenvector centrality एल्गोरिद्म का एक प्रकारांतर है।

Betweenness Centrality

Betweenness Centrality नियंत्रण की केन्द्रीयता है। यह उस आवृत्ति का प्रतिनिधित्व करती है जिसके साथ कोई बिंदु उन geodesic (सबसे छोटे पथ) पर आता है जो बिंदुओं की जोड़ी को जोड़ते हैं। यह मापती है कि दो अन्य नोड्स के बीच चुने गए सबसे छोटे पथों में कोई विशेष नोड कितनी बार आता है। उच्च betweenness centrality वाले नोड्स नेटवर्क के भीतर संचार/सूचना प्रवाह में महत्वपूर्ण भूमिका निभाते हैं। ऐसे नोड्स दूसरों पर रणनीतिक नियंत्रण और प्रभाव रख सकते हैं। ऐसी रणनीतिक स्थिति में मौजूद व्यक्ति, सूचना को रोककर या उसे रंग देकर, पूरे समूह को प्रभावित कर सकता है।

NetworkX में betweenness_centrality() फ़ंक्शन है, जिससे हम नेटवर्क के लिए इसे माप सकते हैं। इसमें विकल्प होते हैं—क्या हम betweenness मानों को normalize करना चाहते हैं या नहीं, centrality गणना में weights शामिल करने हैं या नहीं, और सबसे छोटे पथ की गणना में endpoints को शामिल करना है या नहीं।

सब कुछ साथ में

आइए Facebook डेटा से शुरू करें; यहाँ के विश्लेषण के लिए हम Facebook combined ego networks dataset का उपयोग करेंगे। इसमें दस व्यक्तियों की Facebook friends सूची का समेकित नेटवर्क है। आप आवश्यक facebook_combined.txt फ़ाइल Stanford University साइट से डाउनलोड कर सकते हैं।

आप Facebook/Twitter APIs का उपयोग करके अपना खुद का Facebook/Twitter डेटा प्राप्त कर सकते हैं। अगले ट्यूटोरियल में हम सीखेंगे कि Facebook और Twitter APIs से डेटा कैसे लें और यहाँ सीखी जानकारी का उपयोग करके उसका विश्लेषण कैसे करें।

हम फ़ाइल को पढ़ते हैं और Graph का निर्माण करते हैं:

G_fb = nx.read_edgelist("facebook_combined.txt", create_using = nx.Graph(), nodetype=int)

नेटवर्क में 4,039 नोड्स हैं, जो 88,234 edges से जुड़े हैं! जी हाँ, यह एक बड़ा नेटवर्क है। आप info() फ़ंक्शन का उपयोग करके यह जानकारी प्राप्त कर सकते हैं।

[In]: print(nx.info(G_fb))


[Out]: Name:
       Type: Graph
       Number of nodes: 4039
       Number of edges: 88234
       Average degree:  43.6910

नीचे आप नेटवर्क देख सकते हैं:

हम नेटवर्क को इस तरह भी विज़ुअलाइज़ कर सकते हैं कि नोड का रंग Degree के साथ और नोड का आकार Betweenness Centrality के साथ बदलता रहे। इसे करने का कोड यह है:

pos = nx.spring_layout(G_fb)
betCent = nx.betweenness_centrality(G_fb, normalized=True, endpoints=True)
node_color = [20000.0 * G_fb.degree(v) for v in G_fb]
node_size =  [v * 10000 for v in betCent.values()]
plt.figure(figsize=(20,20))
nx.draw_networkx(G_fb, pos=pos, with_labels=False,
                 node_color=node_color,
                 node_size=node_size )
plt.axis('off')

और प्राप्त ग्राफ यह है:

आप सबसे अधिक betweenness centrality वाले नोड्स के लेबल इस तरह भी जान सकते हैं:

sorted(betCent, key=betCent.get, reverse=True)[:5]

नीचे दी गई तालिका में सबसे अधिक centrality measures वाले पाँच नोड लेबल सूचीबद्ध हैं।

हम देखते हैं कि Degree Centrality—जो degree का माप है—और Betweenness Centrality—जो सूचना प्रवाह को नियंत्रित करती है—के बीच कुछ नोड्स सामान्य हैं। यह स्वाभाविक है कि जो नोड्स अधिक जुड़े हुए हैं, वे अन्य नोड्स के बीच के सबसे छोटे पथों पर भी अधिक बार आते हैं। नोड 1912 एक महत्वपूर्ण नोड है क्योंकि यह हमारे द्वारा विचार किए गए सभी तीन centrality measures के अनुसार अहम है।

संदर्भ

• Actor डेटा IMDB साइट से लिया गया है
• NetworkX और उसके फ़ंक्शनों के बारे में अधिक जानने के लिए इसका documentation सबसे अच्छा स्थान है

यदि आप Python में Social Network Analysis के बारे में और सीखना चाहते हैं, तो DataCamp का Analyzing Social Media Data in Python कोर्स लें।