Socialenetwerkanalyse in Python

Asymmetrische netwerken

Wat als de relatie tussen knopen 'kind van' is? Dan is de relatie niet langer symmetrisch. Als A het kind is van B, dan is B niet het kind van A. Zo'n netwerk, waarbij de relatie asymmetrisch is (A is gerelateerd aan B, maar dat betekent niet per se dat B is geassocieerd met A), noemen we een asymmetrisch netwerk. We kunnen het asymmetrische netwerk in NetworkX bouwen met de methode DiGraph, wat staat voor Directional Graph. Laten we een asymmetrische graaf maken.

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')Mogelijk gemaakt door

Nu visualiseren we hem. We kunnen, net als eerder, de functie draw_networkx() gebruiken. Het kan echter gebeuren dat knopen niet mooi uit elkaar komen te staan en niet duidelijk zichtbaar zijn in de tekening. Om dit te verhelpen kunnen we de layout forceren met een functie die de knopen zo positioneert dat we ze goed kunnen onderscheiden. Dat doen we met de functie spring_layout(), gevolgd door draw_networkx().

nx.spring_layout(G_asymmetric)
nx.draw_networkx(G_asymmetric)Mogelijk gemaakt door

Hieronder zie je het netwerk met en zonder het gebruik van het layout-commando. De versie met het layout-commando is duidelijker.

Gewogen netwerken

Tot nu toe hadden we netwerken zonder gewichten, maar het is ook mogelijk om netwerken met gewichten te maken. Als we in ons eerste netwerk het aantal films dat samen is gedaan als gewicht nemen, krijgen we een gewogen netwerk. Laten we er opnieuw één maken van de acteurs, maar nu voegen we een gewicht toe aan het netwerk: elke verbinding heeft een gewicht dat het aantal films aangeeft dat ze samen hebben gedaan.

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)Mogelijk gemaakt door

De bovenstaande figuur toont het gewogen netwerk van acteurs in een circular-layout. De lijndikte geeft het gewicht tussen twee knopen aan.

Multigraaf

We kunnen verschillende attributen aan de verbindingen meegeven. Zo kunnen we een relatie van buur tussen twee knopen 'A' en 'B' definiëren met het attribuut relation. Als binnen een netwerk twee knopen met twee verschillende verbindingen (relaties) verbonden zijn, hebben we een multigraaf. We kunnen een multigraaf maken met de klasse 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')Mogelijk gemaakt door

Deze code bouwt een graaf met twee verbindingen tussen A en B. We kunnen de verbindingen controleren met G.edges(); de output zou laten zien:

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

Netwerkconnectiviteit

Nu het netwerk is gemaakt, kunnen we meer te weten komen over een specifieke knoop in het netwerk? Jazeker, laten we er een paar verkennen.

Graad (Degree)

De graad van een knoop is het aantal verbindingen dat een knoop heeft. NetworkX heeft de functie degree waarmee we de graad van een knoop in het netwerk kunnen bepalen.

nx.degree(G_symmetric, 'Dev Anand`)
Mogelijk gemaakt door

Dit levert de waarde 3 op, omdat Dev Anand slechts met drie acteurs in het netwerk heeft samengewerkt.

Clusteringcoëfficiënt

Er is waargenomen dat mensen die verbindingen delen in een sociaal netwerk de neiging hebben om samen verbanden te vormen. Met andere woorden: er is een neiging in een sociaal netwerk om clusters te vormen. We kunnen de clusters rond een knoop bepalen: de lokale clusteringcoëfficiënt, het aandeel paren van vrienden (verbindingen) van de knoop die onderling met elkaar verbonden zijn. Om de lokale clusteringcoëfficiënt te bepalen, gebruiken we de functie nx.clustering(Graph, Node).

In het symmetrische actornetwerk heeft Dev Anand een lokale clusteringcoëfficiënt van 1 en Abhishek Bachchan een lokale clusteringcoëfficiënt van 0,67.

De gemiddelde clusteringcoëfficiënt (de som van alle lokale clusteringcoëfficiënten gedeeld door het aantal knopen) voor het symmetrische actornetwerk is 0,867. We kunnen die verkrijgen met:

nx.average_clustering(G_symmetric)
Mogelijk gemaakt door

Afstand

We kunnen in NetworkX ook het kortste pad tussen twee knopen en de lengte ervan bepalen met respectievelijk nx.shortest_path(Graph, Node1, Node2) en nx.shortest_path_length(Graph, Node1, Node2).

Als we uitvoeren

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

Krijgen we

['Dev Anand', 'Amitabh Bachchan', 'Akshay Kumar']
Mogelijk gemaakt door

We kunnen de afstand van een knoop tot elke andere knoop in het netwerk vinden met een breadth-first search-algoritme, beginnend bij die knoop. NetworkX biedt hiervoor de functie bfs_tree. Als je dus T = nx.bfs_tree(G_symmetric, 'Dev Anand') probeert en vervolgens deze boom tekent, krijg je een netwerkstructuur die laat zien hoe je andere knopen in het netwerk kunt bereiken vanuit Dev Anand

Excentriciteit

De excentriciteit van een knoop A is gedefinieerd als de grootste afstand tussen A en alle andere knopen. Die is te vinden met de functie nx.eccentricity(). In het symmetrische actornetwerk heeft Dev Anand een excentriciteit van 2 en Abhishek Bachchan een excentriciteit van 1 (hij is met iedereen verbonden).

Invloedrijke knopen in het netwerk

Hierboven leerden we enkele netwerkafstandsmaten kennen; die zijn nuttig om te weten hoe informatie zich door het netwerk zal verspreiden. In deze sectie leren we hoe we de belangrijkste knopen (individuen) in het netwerk vinden. Deze parameters heten centraliteitsmaten.

Herinner je je dat populaire meisje van de middelbare school, of de beste honkbalspeler van de school? Dat waren de mensen die jouw middelbareschooltijd hemels of hels konden maken. Wat gaf hen die macht? Centraliteitsmaten helpen ons populariteit, meest geliefden en grootste influencers binnen het netwerk te identificeren.

Degree centrality

De meest populaire of meest geliefde mensen zijn meestal degenen met de meeste vrienden. Degree centrality is een maat voor het aantal verbindingen dat een bepaalde knoop in het netwerk heeft. Het is gebaseerd op het idee dat belangrijke knopen veel verbindingen hebben. NetworkX heeft de functie degree_centrality() om de degree centrality van alle knopen in een netwerk te berekenen.

Eigenvectorcentraliteit

Het gaat niet alleen om hoeveel personen iemand kent, maar ook om het type mensen met wie iemand verbonden is, dat het belang van een knoop kan bepalen. Op de wegen in Delhi is de eerste zin die de verkeerspolitie hoort wanneer ze iemand aanhouden voor een verkeersovertreding: "Weet je met wie ik verbonden ben?"

Eigenvectorcentraliteit is precies een maat hiervoor. Een knoop is belangrijk als hij verbonden is met andere belangrijke knopen. We kunnen de functie eigenvector_centrality() van NetworkX gebruiken om de eigenvectorcentraliteit van alle knopen in een netwerk te berekenen.

Het Pagerank-algoritme van Google is een variant op het eigenvectorcentraliteitsalgoritme.

Betweenness centrality

Betweenness centrality is de centraliteit van controle. Het geeft aan hoe vaak een punt voorkomt op de geodetische lijnen (kortste paden) die paren van punten verbinden. Het kwantificeert hoe vaak een bepaalde knoop voorkomt op het gekozen kortste pad tussen twee andere knopen. Knopen met een hoge betweenness centrality spelen een significante rol in de communicatie- en informatiestroom binnen het netwerk. Ze kunnen strategische controle en invloed op anderen uitoefenen. Iemand op zo'n strategische positie kan de hele groep beïnvloeden door informatie achter te houden of te kleuren tijdens de overdracht.

NetworkX heeft de functie betweenness_centrality() om dit voor het netwerk te meten. Je kunt aangeven of je de betweenness-waarden wilt normaliseren, of gewichten moeten worden meegenomen in de centraliteitsberekening, en of de eindpunten moeten worden meegenomen in het tellen van de kortste paden.

Alles combineren

Laten we aan de slag gaan met Facebook-data. Voor onze analyse hier gebruiken we de dataset met gecombineerde ego-netwerken van Facebook; die bevat het geaggregeerde netwerk van de vriendenlijsten van tien individuen. Je kunt het benodigde bestand facebook_combined.txt downloaden van de site van de Stanford University.

Je kunt je eigen Facebook/Twitter-data ophalen met de Facebook/Twitter-API's. Kijk uit naar de komende tutorial waarin we leren hoe je de Facebook- en Twitter-API's gebruikt om data op te halen en de hier opgedane kennis toe te passen om die te analyseren.

We lezen het bestand in en bouwen de graaf:

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

Het netwerk bestaat uit 4.039 knopen, verbonden via 88.234 verbindingen! Jep, het is een groot netwerk. Je krijgt deze informatie met de functie info().

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


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

Hieronder zie je het netwerk:

We kunnen het netwerk ook visualiseren zodat de kleur van de knoop varieert met de graad en de grootte van de knoop met de betweenness centrality. De code hiervoor is:

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')
Mogelijk gemaakt door

En de resulterende graaf is:

Je kunt ook de labels zien van de knopen met de hoogste betweenness centrality met:

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

De onderstaande tabel toont de vijf knooppuntlabels met de hoogste centraliteitsmaten.

We zien dat sommige knopen overeenkomen tussen degree centrality, een maat voor graad, en betweenness centrality, die de informatiestroom controleert. Het is logisch dat knopen die sterker verbonden zijn ook op kortste paden tussen andere knopen liggen. Knoop 1912 is een belangrijke knoop, omdat die volgens alle drie de beschouwde centraliteitsmaten cruciaal is.

Referenties

• De actorgegevens zijn afkomstig van de site van IMDB
• De beste plek om meer te weten te komen over NetworkX en de functies is de documentatie

Wil je meer leren over socialenetwerkanalyse in Python? Volg dan de cursus Analyzing Social Media Data in Python van DataCamp.