Ana içeriğe geç

Python ile Sosyal Ağ Analizi

Ağlar bugün günlük yaşamımızın bir parçası. Python ve Networks kullanarak bir sosyal ağı nasıl görselleştirip anlayacağımızı öğrenelim.
· 12 dk. oku

Yapay Zeka ile Keşfedin

Eğer Ağ Analizi hakkında bilgi edinmek istiyorsanız, DataCamp’in Python ile Ağ Analizi (Bölüm 1) kursunu alın.

Ağlar her yerde: yol ağları, sosyal medyada arkadaşlar ve takipçiler ağı, ofis mesai arkadaşları ağı. Günlük hayatımızda faydalı bilgilerin yayılmasından ulusal seçimlerin etkilenmesine kadar önemli bir rol oynuyorlar. Bu ağları analiz edip onlara dayanarak bilinçli kararlar alabilmek, her veri analisti için önemli bir yetenektir.

Bu eğitimin odağı, karmaşık ağların yapısını, dinamiklerini ve işlevlerini incelemek için bir Python kütüphanesi olan NetworkX ve Python kullanarak sosyal ağ analizini (SNA) öğretmektir. Bu eğitim, okuyucunun Python’un temel sözdizimine aşina olduğunu varsayar; SNA hakkında ön bilgi beklenmez.

Giriş

Önce Sosyal Ağlar ile ne kastettiğimizi netleştirelim. Aşağıda düğümler olarak Bollywood oyuncularının yer aldığı bir ağ görüyorsunuz. En az bir filmde birlikte çalıştılarsa aralarında düz çizgilerle bağlantı kurulmuştur.

bollywood oyuncuları

Buradan, hem Amitabh Bachchan’ın hem de Abhishek Bachchan’ın ağdaki tüm oyuncularla birlikte rol aldığını, Akshay Kumar’ın ise yalnızca iki Bachchan ile çalıştığını görebiliyoruz. İlginç değil mi!

Bu da bir sosyal ağdır. Bireyler arasındaki bağlantıları ve bu bağlantıların aralarındaki ilişkiyi yansıttığı her ağ bir sosyal ağdır. Bu ağları analiz etmek, ağdaki kişiler hakkında gerçek etkileyicilerin kimler olduğu, en çok bağlantısı olanların kimler olduğu gibi konularda önemli içgörüler sağlayabilir.

Her ağ şunlardan oluşur:

  • Düğümler: Ağını kurduğumuz bireyler. Yukarıdaki örnekteki oyuncular.
  • Kenarlar: Düğümler arasındaki bağlantı. Ağın düğümleri arasındaki ilişkiyi temsil eder. Bizim örneğimizde ilişki, oyuncuların birlikte çalışmış olmasıydı.

NetworkX kullanarak ağ oluşturma

Birçok ağ türü vardır. Bu farklı ağları geliştirmek ve analiz etmek için NetworkX kullanacağız. Başlamak için networkX’i kurmanız gerekir: Şunlardan birini kullanabilirsiniz:

pip install networkx

veya Anaconda kullanıyorsanız

conda install -c anaconda networkx

Bu, networkx’in en son sürümünü kuracaktır. Bu eğitimdeki kodlar Python=3.5, NetworkX = 2.0 sürümünde yazılmıştır.

Simetrik Ağlar

Yukarıda oluşturduğumuz ilk oyuncu ağı, “bir filmde birlikte çalışmak” ilişkisinin simetrik bir ilişki olmasından dolayı simetrik bir ağdır. Eğer A, B ile ilişkiliyse, B de A ile ilişkilidir. Hadi NetworkX’te yukarıda gördüğümüz ağı oluşturalım.

Yeni bir ağ oluşturmak için Graph() yöntemini ve iki düğüm arasında bir kenar eklemek için add_edge() yöntemini kullanacağız.

import networkx as nx
G_symmetric = nx.Graph()
G_symmetric.add_edge('Amitabh Bachchan','Abhishek Bachchan')
G_symmetric.add_edge('Amitabh Bachchan','Aamir Khan')
G_symmetric.add_edge('Amitabh Bachchan','Akshay Kumar')
G_symmetric.add_edge('Amitabh Bachchan','Dev Anand')
G_symmetric.add_edge('Abhishek Bachchan','Aamir Khan')
G_symmetric.add_edge('Abhishek Bachchan','Akshay Kumar')
G_symmetric.add_edge('Abhishek Bachchan','Dev Anand')
G_symmetric.add_edge('Dev Anand','Aamir Khan')

Şimdi nx.draw_networkx(G_symmetric) kullanarak az önce oluşturduğumuz ağı görselleştirelim.

görselleştirilmiş ağ

Asimetrik Ağlar

Eğer düğümler arasındaki ilişki ‘çocuğu’ ise, bu ilişki artık simetrik değildir. A, B’nin çocuğuyse, B, A’nın çocuğu değildir. İlişkinin asimetrik olduğu (A, B ile ilişkiliyse bu mutlaka B’nin A ile ilişkili olduğu anlamına gelmez) böyle bir ağa Asimetrik ağ denir. NetworkX’te asimetrik bir ağı, Yönlü Grafikin kısaltması olan DiGraph yöntemiyle kurabiliriz. Hadi bir asimetrik grafik oluşturalım.

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')

Şimdi görselleştirelim. Önceki gibi draw_networkx() fonksiyonunu kullanabiliriz. Ancak çizilen ağda düğümlerin ayrışmaması ve net görünmemesi mümkündür. Bunu gidermek için, düğümleri net şekilde görebileceğimiz bir konumlandırma yapan bir yerleşim zorlaması kullanabiliriz. Bunu spring_layout() fonksiyonunu, ardından draw_networkx() fonksiyonunu kullanarak gerçekleştirebiliriz.

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

Aşağıda yerleşim komutu kullanılarak ve kullanılmadan çizilmiş ağı görebilirsiniz. Yerleşim komutuyla oluşturulan daha anlaşılırdır.

görselleştirilmiş ağ 2

Ağırlıklı Ağlar

Şimdiye kadar ağlarımız ağırlıksızdı, ancak ağların ağırlıklarla kurulması da mümkündür. Örneğin, ilk ağımızda birlikte oynanan film sayısını bir ağırlık olarak alırsak, bir Ağırlıklı Ağ elde ederiz. Hadi yine oyunculardan bir ağ oluşturalım ama bu kez ağa ağırlık ekleyelim; her kenar birlikte oynanan film sayısını belirten bir ağırlığa sahip olsun.

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)
ağırlıklı ağ

Yukarıdaki şekil, dairesel yerleşimdeki oyuncuların ağırlıklı ağını göstermektedir. Kenar kalınlığı iki düğüm arasındaki ağırlığı belirtir.

Multigraph

Kenarlarına farklı öznitelikler verebiliriz. Örneğin, relation özniteliğini kullanarak ‘A’ ve ‘B’ düğümleri arasında komşuluk ilişkisi tanımlayabiliriz. Bir ağ içinde iki düğüm farklı iki kenar (ilişki) ile bağlıysa, elimizde bir multigraph vardır. MultiGraph sınıfını kullanarak bir multigraph oluşturabiliriz.

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')

Bu kod, A ve B arasında iki kenarı olan bir grafik oluşturur. Bağlantıları G.edges() ile kontrol edebiliriz; çıktı şöyle olacaktır:

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

Ağ Bağlanırlığı

Artık ağı oluşturduk; ağdaki belirli bir düğüm hakkında daha fazla şey öğrenebilir miyiz? Elbette, bazılarını inceleyelim.

Derece

Bir düğümün derecesi, o düğümün sahip olduğu bağlantı sayısını tanımlar. NetworkX’teki degree fonksiyonunu, ağdaki bir düğümün derecesini belirlemek için kullanabiliriz.

nx.degree(G_symmetric, 'Dev Anand`)

Bu, Dev Anand’ın ağda yalnızca üç oyuncuyla çalışmış olması nedeniyle 3 değerini döndürecektir.

Kümeleşme Katsayısı

Bir sosyal ağda bağlantı paylaşan kişilerin birliktelikler oluşturma eğiliminde olduğu gözlemlenir. Başka bir deyişle, sosyal ağlarda kümeler oluşturma eğilimi vardır. Bir düğümün arkadaş çiftlerinin (yani bağlantılarının) birbirleriyle bağlantılı olanlarının oranı olan Yerel Kümeleşme Katsayısını belirleyebiliriz. Yerel kümeleşme katsayısını belirlemek için nx.clustering(Graph, Node) fonksiyonunu kullanırız.

Simetrik Oyuncu ağında, Dev Anand’ın yerel kümeleşme katsayısının 1, Abhishek Bachchan’ın ise 0,67 olduğunu göreceksiniz.

Simetrik Oyuncu ağının ortalama kümeleşme katsayısı (tüm yerel kümeleşme katsayılarının toplamının düğüm sayısına bölümü) 0,867’dir. Bunu şu şekilde elde edebiliriz:

nx.average_clustering(G_symmetric)

Mesafe

Ayrıca iki düğüm arasındaki en kısa yolu ve bu yolun uzunluğunu NetworkX’te sırasıyla nx.shortest_path(Graph, Node1, Node2) ve nx.shortest_path_length(Graph, Node1, Node2) fonksiyonlarını kullanarak belirleyebiliriz.

Şunu çalıştırdığımızda

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

Şunu döndürür

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

Bir düğümün ağdaki diğer tüm düğümlere olan uzaklığını, o düğümden başlayarak genişlik-öncelikli arama algoritmasıyla bulabiliriz. networkX bunu yapmak için bfs_tree fonksiyonunu sağlar. Dolayısıyla T = nx.bfs_tree(G_symmetric, 'Dev Anand') dener ve şimdi bu ağacını çizerseniz, Dev Anand’dan başlayarak ağdaki diğer düğümlere nasıl ulaşabileceğimizi gösteren bir ağ yapısı elde ederiz.

düğümler

Eksantriklik

A düğümünün eksantrikliği, A ile diğer tüm düğümler arasındaki en büyük mesafe olarak tanımlanır. nx.eccentricity() fonksiyonuyla bulunabilir. Simetrik Oyuncu ağında, Dev Anand’ın eksantrikliği 2, Abhishek Bachchan’ın eksantrikliği ise 1’dir (Hepsiyle bağlantılıdır).

Ağdaki Etkileyiciler

Yukarıda bazı ağ mesafe ölçülerini öğrendik; bunlar, bilginin ağ içinde nasıl yayılacağını anlamada faydalıdır. Bu bölümde, ağdaki en önemli düğümleri (bireyleri) bulmayı öğreneceğiz. Bu parametrelere merkezilik ölçüleri denir.

Lisede o popüler kızı ya da okulun en iyi beyzbol oyuncusunu hatırlayın. Bunlar lise deneyiminizi cennet ya da cehenneme çevirebilecek güce sahip kişilerdi. Onlara bu gücü ne verdi? Merkezilik Ölçüleri, ağ içinde popülerliği, en çok beğenilenleri ve en büyük etkileyicileri belirlememize yardımcı olabilir.

Derece Merkeziliği

En popüler ya da daha çok beğenilen kişiler genellikle daha fazla arkadaşa sahip olanlardır. Derece merkeziliği, belirli bir düğümün ağdaki bağlantı sayısının bir ölçüsüdür. Önemli düğümlerin çok sayıda bağlantıya sahip olduğu gerçeğine dayanır. NetworkX, bir ağdaki tüm düğümlerin derece merkeziliğini hesaplamak için degree_centrality() fonksiyonuna sahiptir.

Özvektör Merkeziliği

Bir kişinin kaç kişiyle bağlantılı olduğu kadar, kimlerle bağlantılı olduğu da bir düğümün önemini belirleyebilir. Delhi yollarında trafik polisi, kural ihlali yapan birini yakaladığında ilk duyduğu cümle şudur: “Benim kimle bağlantılı olduğumu biliyor musunuz?”.

Özvektör merkeziliği tam olarak bunu ölçer. Bir düğüm, diğer önemli düğümlerle bağlantılıysa önemli sayılır. Bir ağdaki tüm düğümlerin özvektör merkeziliğini hesaplamak için NetworkX’in eigenvector_centrality() fonksiyonunu kullanabiliriz.

Google’ın PageRank algoritması, Özvektör merkeziliği algoritmasının bir türevidir.

Aradalık Merkeziliği

Aradalık Merkeziliği, denetim merkeziliğidir. Bir noktanın, birbirine bağlı nokta çiftlerini birleştiren jeodeziklerde (en kısa yollarda) ne sıklıkla yer aldığını temsil eder. Belirli bir düğümün, iki başka düğüm arasındaki seçilen en kısa yolda kaç kez yer aldığını niceliksel olarak ifade eder. Aradalık merkeziliği yüksek düğümler, ağ içindeki iletişim/bilgi akışında önemli rol oynar. Bu düğümler, diğerleri üzerinde stratejik bir denetim ve etkiye sahip olabilir. Böyle stratejik bir konumdaki birey, iletimdeki bilgiyi saklayarak ya da çarpıtarak tüm grubu etkileyebilir.

Networkx, ağ için bunu ölçmek üzere betweenness_centrality() fonksiyonuna sahiptir. Değerlerin normalize edilip edilmeyeceğini, merkezilik hesaplamasında ağırlıkların dahil edilip edilmeyeceğini ve en kısa yol sayımlarında uç noktaların dahil edilip edilmeyeceğini seçmek için seçenekler sunar.

Hepsini bir araya getirmek

Facebook verileriyle başlayalım; burada analizimiz için Facebook birleştirilmiş ego ağları veri setini kullanacağız; bu veri seti, on kişinin Facebook arkadaş listelerinin birleştirilmiş ağını içerir. Gerekli facebook_combined.txt dosyasını Stanford University sitesinden indirebilirsiniz.

Kendi Facebook/Twitter verilerinizi Facebook/Twitter API’lerini kullanarak alabilirsiniz. Bir sonraki eğitimde, verileri almak için Facebook ve Twitter API’lerini nasıl kullanacağımızı ve burada edindiğimiz bilgileri analiz etmek için nasıl uygulayacağımızı öğreneceğiz.

Dosyayı okuyup Graf’ı oluşturuyoruz:

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

Ağ 4.039 düğümden ve 88.234 kenarla birbirine bağlanmış yapılardan oluşur! Evet, büyük bir ağ. Bu bilgiyi info() fonksiyonunu kullanarak alabilirsiniz.

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


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

Aşağıda ağı görebilirsiniz:

ağ

Ağı, düğüm renginin Derece ile ve düğüm boyutunun Aradalık Merkeziliği ile değiştiği şekilde de görselleştirebiliriz. Bunu yapmanın kodu şöyledir:

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')

Ve ortaya çıkan grafik şöyledir:

ortaya çıkan grafik

Ayrıca en yüksek aradalık merkeziliğine sahip düğümlerin etiketlerini şununla öğrenebilirsiniz:

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

Aşağıdaki tablo, en yüksek merkezilik ölçülerine sahip beş düğüm etiketini listeler.

Derece MerkeziliğiÖzvektör MerkeziliğiAradalık Merkeziliği
1071912107
168422661684
191222063437
343722331912
024641085

Derece Merkeziliği (bağlantı sayısının bir ölçüsü) ile bilgi akışını kontrol eden Aradalık Merkeziliği arasında ortak bazı düğümlerin bulunduğunu görüyoruz. Daha çok bağlantısı olan düğümlerin, diğer düğümler arasındaki en kısa yollar üzerinde yer alması doğaldır. 1912 düğümü, ele aldığımız üç merkezilik ölçütüne göre de kritik olduğundan önemli bir düğümdür.

Kaynakça

  • Oyuncu verileri IMDB sitesinden alınmıştır
  • NetworkX ve fonksiyonları hakkında daha fazla bilgi edinmek için en iyi yer dokümantasyonudur

Python’da Sosyal Ağ Analizi hakkında daha fazla bilgi edinmek istiyorsanız, DataCamp’in Python’da Sosyal Medya Verilerini Analiz Etme kursunu alın.

Konular

İlgili