Algorithmische Methoden zur Netzwerkanalyse

Algorithmische Methoden zur
Netzwerkanalyse
Prof. Dr. Henning Meyerhenke
Skript zur Vorlesung
Version v0.5.3
20. Juli 2017
Vorwort
Dieses Skript basiert im Wesentlichen auf der Vorlesung Algorithmische Methoden zur
Netzwerkanalyse, die ich mehrfach am Karlsruher Institut für Technologie (KIT) als
V2Ü1 gehalten habe, zuletzt im Sommersemester 2017. Perspektivisch werden Vorlesung
und Skript in Richtung V4Ü2 ausgeweitet werden, weshalb teilweise schon mehr Material
angedeutet wird, als bisher innerhalb eines einzelnen Semesters gelesen wurde.
Danken möchte ich im Rahmen der Entstehung des Skriptes zunächst Demian Hespe,
dessen Vorlesungsmitschrift in manchen Teilen als Grundlage gedient hat. Außerdem
danke ich meinen wissenschaftlichen Mitarbeitern, die mit ihren Forschungsergebnissen
bzw. ihrem Einsatz in der Lehre diese Vorlesung und die zugehörigen Übungen in Teilen
mitgestaltet haben: Elisabetta Bergamini, Moritz von Looz und Christian Staudt. Weiterer Dank gilt natürlich auch allen, die zum Entstehen unserer Open-Source-Software
NetworKit beigetragen haben. Ohne eure vielen Beiträge wäre NetworKit heute nicht das,
was es ist!
Im Laufe der Zeit wird das Skript weiter wachsen. Trotzdem erhebt das Skript auch
zum Semesterende keinen Anspruch auf Vollständigkeit, jedenfalls nicht in den Versionsnummern mit führender Null. Es ergänzt lediglich in einigen Teilen die Folien zur
Vorlesung – mal mehr, mal weniger. Momentan fehlen noch viele Erklärungen (sowie
Abbildungen und Beispiele), die gerade das Skript als Erweiterung zu den Folien liefern
soll. Beide zusammen, Folien und Skript, sind jedoch nicht als Ersatz zum Besuch der
Vorlesung gedacht, sondern als Hilfestellung bei der notwendigen Vor- und Nachbereitung.
Sollten Sie auf Fehler stoßen, bitte ich um einen entsprechenden Hinweis.
Karlsruhe, im Sommer 2017
2
Henning Meyerhenke
Versionen
v0.1.0 (März 2017): Wenige Fragmente zur Ergänzung
v0.2.0 (26. April 2017): Neue Struktur, erste Details in Kapitel 2
v0.3.0 (17. Mai 2017): Korrekturen, erweitert um Kapitel 2.1.7 und Teile von Kapitel 3
v0.4.0 (7. Juni 2017): Erste Teile von Kapitel 4
v0.4.1 (13. Juni 2017): Korrekturen, ER-Graphen, neue Kapitel im Anhang vorgesehen
v0.4.2 (22. Juni 2017): Weitere Teile von Kapitel 4
v0.4.3 (29. Juni 2017): Korrekturen und Ergänzungen zu vorhandenen Teilen in Kapitel 5
v0.5.0 (5. Juli 2017): Korrekturen, Ergänzungen in Kapitel 5
v0.5.1 (11. Juli 2017): Korrekturen, Ergänzungen in Kapiteln 5 und 6
v0.5.2 (17. Juli 2017): Korrekturen, Ergänzungen in Kapitel 6
v0.5.3 (20. Juli 2017): Korrekturen, Ergänzungen in Kapitel 6
Achtung: weitere Überarbeitungen der existierenden Teile werden folgen (müssen)
3
Inhaltsverzeichnis
1. Einleitung
1.1. Motivation . . . . . . . . . . . . . .
1.2. Notation und Wiederholung . . . . .
1.2.1. Netzwerke und Graphen . . .
1.2.2. Repräsentation von Graphen
1.2.3. Grundlegende Eigenschaften .
1.3. NetworKit . . . . . . . . . . . . . . .
1.3.1. Grundlegende Funktionen . .
1.4. Weiterführende Literatur . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2. Zentralitätsmaße
2.1. Knotenzentralitätsmaße . . . . . . . . . . . . . . . . . .
2.1.1. Grad-Zentralität . . . . . . . . . . . . . . . . . .
2.1.2. Kernzahl und k-Kern-Zerlegung . . . . . . . . . .
2.1.2.1. Motivation und Definition . . . . . . . .
2.1.2.2. Theoretische Resultate* . . . . . . . . .
2.1.2.3. Sequentieller Linearzeit-Algorithmus . .
2.1.2.4. Paralleler Algorithmus . . . . . . . . . .
2.1.3. Clusterkoeffizienten und Transitivität . . . . . .
2.1.3.1. Motivation und Definition . . . . . . . .
2.1.3.2. Exakte Berechnung . . . . . . . . . . .
2.1.3.3. Approximation . . . . . . . . . . . . . .
2.1.4. Eigenvektor-Zentralität . . . . . . . . . . . . . .
2.1.4.1. Besonderheiten bei gerichteten Graphen
2.1.4.2. Berechnung . . . . . . . . . . . . . . . .
2.1.5. PageRank . . . . . . . . . . . . . . . . . . . . . .
2.1.5.1. Kontext . . . . . . . . . . . . . . . . . .
2.1.5.2. Etwas Mathematik hinter PageRank . .
2.1.6. Betweenness Centrality . . . . . . . . . . . . . .
2.1.6.1. Effiziente Berechnung der BC-Werte . .
2.1.6.2. Approximation der BC-Werte . . . . .
2.1.7. Nähe- und harmonische Zentralität . . . . . . . .
2.2. Top-k-Ranglisten* . . . . . . . . . . . . . . . . . . . . .
2.3. Kantenzentralitätsmaße* . . . . . . . . . . . . . . . . . .
2.4. Weiterführende Literatur . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
9
9
9
9
9
10
10
11
11
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
13
13
13
15
15
16
17
18
18
18
20
21
23
24
25
27
27
27
30
31
34
34
36
37
37
5
Inhaltsverzeichnis
3. Kürzeste Wege und globaler Zusammenhang
3.1. Paarweise Abstände und kürzeste Wege . . . . . . . .
3.1.1. Floyd-Warshall-Algorithmus . . . . . . . . . . .
3.1.2. Matrix-Multiplikation . . . . . . . . . . . . . .
3.2. Zweistufige Berechnung kürzester Wege . . . . . . . .
3.2.1. Naiver Ansatz . . . . . . . . . . . . . . . . . .
3.2.2. Markieren mit Beschränkung der Suche . . . .
3.3. Das Phänomen der kleinen Welt und der Durchmesser
3.4. Zusammenhangskomponenten . . . . . . . . . . . . . .
3.5. Weiterführende Literatur . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
39
39
39
40
41
42
43
46
50
52
4. Generierung von Graphen
4.1. Exakte Generierung von Gradfolgen . . . . . . . . . . . . . . .
4.2. Erdős-Rényi-Modell . . . . . . . . . . . . . . . . . . . . . . . .
4.2.1. Grundlegende Eigenschaften von G(n, p)-Graphen . . .
4.2.2. Phasenübergang bzgl. der Zusammenhangskomponenten
4.2.3. Effiziente Generierung von Erdős-Rényi-Graphen . . . .
4.3. Barabási-Albert-Modell . . . . . . . . . . . . . . . . . . . . . .
4.4. Chung-Lu-Modell . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5. Rekursives Matrix-Modell (R-MAT) . . . . . . . . . . . . . . .
4.6. Zufallsgraphen mit hyperbolischer Geometrie (RHG) . . . . . .
4.7. LFR und ReCon . . . . . . . . . . . . . . . . . . . . . . . . . .
4.8. Weiterführende Literatur . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
53
53
56
57
58
61
61
61
61
61
62
62
5. Clusteranalyse
5.1. Zielfunktion Modularität . . . . . . . . . . . . . .
5.2. Spektrale Optimierung von Modularität . . . . .
5.3. Die Louvain-Methode . . . . . . . . . . . . . . .
5.4. Verbesserung von Clusterungen mit Gütegarantie
5.4.1. Algorithmus . . . . . . . . . . . . . . . . .
5.4.2. Analyse des Algorithmus . . . . . . . . .
5.4.3. Zusammenfassung . . . . . . . . . . . . .
5.5. Weiterführende Literatur . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
63
64
68
68
68
69
71
73
73
6. Ausbreitung von Krankheiten in Netzwerken
6.1. Verzweigungsprozess . . . . . . . . . . . . . . . . . . . . . . .
6.2. SI*-Modelle . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.3. Cyberabwehr als Optimierungsproblem . . . . . . . . . . . . .
6.3.1. Einführung . . . . . . . . . . . . . . . . . . . . . . . .
6.3.2. Optimierungsmodell . . . . . . . . . . . . . . . . . . .
6.3.3. Heuristische Lösung durch ein Mehrebenen-Verfahren
6.3.4. Fazit . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
75
75
76
76
76
78
79
82
Literaturverzeichnis
6
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
82
Inhaltsverzeichnis
A. Grundlagen der linearen Algebra
A.1. Matrizen, Vektoren und ihre Operationen
A.2. Eigenwerte und -vektoren . . . . . . . . .
A.3. NetworKit-Quellcodes . . . . . . . . . . . .
A.4. Lösungen zu den Übungsaufgaben . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
87
87
87
88
88
7
1. Einleitung
1.1. Motivation
1.2. Notation und Wiederholung
1.2.1. Netzwerke und Graphen
Definition 1.1 (Weglänge bzw. -gewicht). Sei ein gerichteter und gewichteter Graph
G = (V, E, ω) mit der Gewichtsfunktion ω : E 7→ R gegeben. Das Gewicht
P eines Weges
p = hv0 , v1 , . . . , vk i ist die Summe der Gewichte seiner Kanten: w(p) := ki=1 ω(vi−1 , vi ).
Im ungewichteten Fall muss man nur alle Kantengewichte als 1 ansehen und man
erhält, dass die Länge des Weges die Zahl seiner Kanten ist.
Definition 1.2 (Kürzester Weg). Sei G = (V, E, ω) wie in Definition 1.1. Ein kürzester
Weg von u nach v ist ein Weg minimalen Gewichts unter allen Wegen von u nach v. Sein
Gewicht ist die Distanz von u nach v. Existiert kein Weg von u nach v, so definiert man
die Distanz als unendlich.
Auf Basis von Wegen lässt sich der Zusammenhang in Graphen definieren:
Definition 1.3 (Zusammenhang). Ein gerichteter Graph G = (V, E) heißt stark zusammenhängend, falls er für jedes Paar (u, v) ∈ V × V sowohl einen (u, v)-Pfad als auch
einen (v, u)-Pfad enthält.
G heißt schwach zusammenhängend, wenn der symmetrische Graph (d. h. der Graph,
der entsteht, wenn jede Kante von G doppelt gerichtet wird) zu G stark zusammenhängend ist.
Im ungerichteten Fall spricht man nur von zusammenhängend, da dort starker und
schwacher Zusammenhang zusammenfallen.
Definition 1.4 (Zusammenhangskomponente). Ein maximaler [stark, schwach] zusammenhängender Teilgraph eines Graphen G heißt [starke, schwache] Zusammenhangskomponente.
1.2.2. Repräsentation von Graphen
Die gängigste graphische Darstellung eines Graphen ist sein Knoten-Kanten-Diagramm.
Zur Repräsentation im Rechner bieten sich platzeffiziente Datenstrukturen an, da wir
mitunter mit sehr großen Graphen arbeiten. Zudem ist es manchmal vorteilhaft, den
Graphen algebraisch über seine Adjazenzmatrix (oder eine andere Matrix) zu definieren:
9
1. Einleitung
Definition 1.5 (Adjazenzmatrix). Die Adjazenzmatrix eines schlichten Graphen G =
(V, E, ω) mit n Knoten ist eine n × n-Matrix mit folgenden Einträgen:
(
ω(u, v) , falls (u, v) ∈ E
Auv =
0
, sonst
Der Eintrag an der Position (u, v) ist also das Gewicht der Kante von u nach v (bzw.
Gewicht 1 bei ungewichteten Graphen). Beachten Sie, dass das Lehrbuch von Newman [New10a] entgegen der vorherrschenden Konvention in der Algorithmik die Richtung der Kanten genau andersherum definiert! Das kann man natürlich auch machen,
man muss sich als Leser nur über die Bedeutung im Klaren sein.
In der Praxis ist die Adjazenzmatrix wie oben beschrieben wegen ihres hohen Speicherverbrauchs ungebräuchlich. Allerdings gibt es Matrix-Datenstrukturen, die Nullen nicht
speichern und ähnlich zu Adjazenzarrays (Speicherverbrauch O(n+m) sind. Die MatrixSchreibweise erlaubt uns zusätzliche Analyse-Möglichkeiten, indem wir Ergebnisse der
numerischen linearen Algebra verwenden. Der Mathematik ist es dabei (weitgehend)
egal, ob die Matrix als dünne oder dichte Matrix im Rechner gespeichert wird.
1.2.3. Grundlegende Eigenschaften
In diesem Kapitel geben wir einige grundlegende Eigenschaften von Graphen wider, die
Sie vermutlich bereits aus Grundlagenveranstaltungen kennen.
Lemma 1.6 (handshake lemma). In (gerichteten wie ungerichteten) Multigraphen mit
m Kanten gilt:
X
deg(v) = 2m
v∈V
Beweis. Selbstübung.
Das handshake lemma ist häufig nützlich bei der Laufzeitanalyse. Iteriert ein Algorithmus über alle Knoten und dabei über die Nachbarn des aktuellen Knotens, dann wissen
wir, dass am Ende alle Kanten genau zweimal angeschaut wurden und der Aufwand
daher O(n + m) ist.
Die oben beschriebene Adjazenzmatrix kann u. a. dazu verwendet werden, auf (methodisch) einfache Art und Weise die Anzahl der Wege einer bestimmten Länge zu zählen:
Lemma 1.7. Sei A die Adjazenzmatrix des Graphen G = (V, E). Dann gilt: Ati,j ist die
Anzahl der Pfade der Länge t von i nach j in G.
Beweis. Selbstübung.
1.3. NetworKit
NetworKit [SSM16] ist ein Software-Werkzeug zur Analyse großer Netzwerke. Seine Entwicklung geschieht quelloffen auf github, dabei spielt meine Arbeitsgruppe als Initiator
10
1.4. Weiterführende Literatur
des Projekts eine tragende Rolle. NetworKit verbindet das Beste aus zwei Welten: Das
Frontend für und in Python erlaubt interaktive explorative Analyse. Die performancerelevanten Teile sind allerdings in C++ geschrieben und häufig auch mit OpenMP für
Shared-Memory-Systeme parallelisiert. Dazwischen vermittelt Cython, ein Compiler von
Python nach C/C++. Auf diese Weise erhalten wir den Komfort einer interpretierten
Sprache mit der Geschwindigkeit von nativ kompiliertem Code. Zugleich können wir
über das Python-Frontend ganz leicht weitere Python-Module einbinden, beispielsweise
zur Visualisierung oder statistischen Analyse von Daten.
Im Rahmen der Vorlesung werden wir NetworKit immer wieder einsetzen, insbesondere
für die praktischen Übungen. Viele der vorgestellten Algorithmen sind auch in NetworKit
implementiert. Nutzen Sie das! Es hilft oft dem Verständnis von Pseudocode, wenn man
die echte Implementierung hinzuzieht.
Der Haupteinstiegspunkt in NetworKit ist die Projektwebseite network-analysis.info.
Dort finden Sie Links zu den wesentlichen weiteren Aspekten: wie Sie starten (githubLink, Installation, einfache Beispiele), Dokumentation und Features.
1.3.1. Grundlegende Funktionen
1.4. Weiterführende Literatur
Wesentliche Definitionen zu Maßen der Netzwerkanalyse sind im Lehrbuch von Newman [New10a] zu finden.
11
2. Zentralitätsmaße
2.1. Knotenzentralitätsmaße
Eine sehr grundlegende Fragestellung der Netzwerkanalyse ist, welche Knoten eines Netzwerks allein aufgrund ihrer Vernetzung wichtig sind. Üblicherweise betrachtet man die
Knoten in einer Rangliste, absteigend nach Wichtigkeit sortiert. Dieses Vorgehen formalisiert man durch den Begriff Zentralität:
Definition 2.1. Ein Knotenzentralitätsmaß für ein Netzwerk G = (V, E) ist eine Funktion c : V → R, die jedem Knoten v ∈ V einen reellen Wert (allgemeiner kann man hier
auch von einem Attributwert auf einer geeigneten Skala sprechen, die eine Rangordnung
ermöglicht) zuweist.
Der zugewiesene Wert hängt von der Position des Knotens v in G ab, die sich aus einer
Teilmenge der Kanten E 0 ⊆ E ergibt. Die Betrachtung über Positionen ließe sich weiter
formalisieren (siehe Brandes [Bra16]) – wir werden das hier aus Gründen der Einfachheit
aber nicht tun.
Es gibt mehr als hundert Zentralitätsmaße; wir können daher natürlich auch nicht alle
betrachten. Daher konzentrieren wir uns auf die gängigsten und wie man diese effizient
berechnet. Es hängt von der konkreten Anwendung ab, welches Zentralitätsmaß man
verwenden sollte. Auch hierzu gibt es wichtige wissenschaftliche Arbeiten, auf die wir
aber nur verweisen.
Der Zentralitätswert eines Knotens ist zunächst eine Aussage über den einzelnen Knoten. Die daraus resultierende Rangfolge ermöglicht eventuell bereits eine gewisse Aussage
über den Graphen. Aussagekräftiger ist aber in der Regel die Verteilung der Zentralitätswerte, also welche Werte (oder Intervalle von Werten) wie häufig (absolut oder
relativ) innerhalb einer Grundgesamtheit angenommen werden.
2.1.1. Grad-Zentralität
Das vermutlich einfachste Zentralitätsmaß ist die Grad-Zentralität:
Definition 2.2. Die Grad-Zentralität weist jedem Knoten v ∈ V die Zahl seiner inzidenten Nachbarn zu:
DC : V → N, v 7→ deg(v).
DC spiegelt in einem sozialen Netzwerk wider, wie viele Personen man kennt. Das
kann unter Umständen ein vernünftiges Maß sein. Hat jemand nur sehr wenige Kontakte, ist es eher unwahrscheinlich, dass er oder sie besonders zentral im Netzwerk ist.
Andererseits können wenige sehr wichtige Kontakte unter Umständen wertvoller sein
13
2. Zentralitätsmaße
Abbildung 2.1.: Knotengradverteilung des Graphen PGPgiantcompo.
als viele unwichtige. Es ist also wünschenswert, zur Bewertung eines Knotens auch die
Wichtigkeit seiner Nachbarn zu berücksichtigen. Somit ist die Grad-Zentralität ist nur
sehr beschränkt aussagekräftig. Wir werden uns daher in den kommenden Abschnitten
mit besseren Maßen befassen.
Die Gradverteilung der Knoten ist wiederum eine sehr interessante Eigenschaft eines
Netzwerks.
Definition 2.3. Die Gradverteilung eines Graphen G = (V, E) ist eine Funktion
dd : {0, . . . , n − 1} → {0, . . . , n},
d 7→ |{v ∈ V : deg(v) = d}|
Die Gradverteilung misst demnach die absolute (alternativ: relative) Häufigkeit jedes
möglichen Gradwertes. Wir stellen nun in unserem Kontext den Knotengrad und seine
absolute Häufigkeit als x-y-Diagramm gegenüber:
Beachten Sie dabei, dass beide Achsen logarithmisch skaliert sind. Durch die logarithmische Skalierung ergibt sich in unserem dargestellten Beispiel zumindest streckenweise
eine Gerade. Diese fällt erst gegen Ende ab.
Die Gradverteilung kann bereits erste wichtige Erkenntnisse über ein Netzwerk liefern. Während Gitternetze und andere auf regelmäßigen Formen basierende eingebettete Graphen meist eine sehr gleichförmige Gradverteilung haben, gilt dies für komplexe
Netzwerke nicht. Letztere haben eine endlastige Verteilung (heavy-tail distribution), die
häufig einem Potenzgesetz (power law ) folgt.
Eng verwandt zur Gradverteilung ist die Gradfolge eines Graphen:
Definition 2.4 (Gradfolge). Gegeben sei ein gerichteter oder ungerichteter Multigraph
G = (V, E) mit Knotenmenge V = {v1 , . . . , vn }.
Die Folge
D(G) = (deg− (v1 ), deg+ (v1 ), . . . , deg− (vn ), deg+ (vn ))
14
2.1. Knotenzentralitätsmaße
des gerichteten bzw.
D(G) = (deg(v1 ), . . . , deg(vn ))
des ungerichteten Multigraphen G heißt dessen Gradfolge.
2.1.2. Kernzahl und k-Kern-Zerlegung
2.1.2.1. Motivation und Definition
Wir haben oben festgestellt, dass die Gradzentralität nur wenig Aussagekraft hat, weil
sie die Wichtigkeit der Nachbarn nicht berücksichtigt. In dieser Hinsicht ist die Kernzahl,
die aus der k-Kern-Zerlegung resultiert, ein besseres Maß. Gleichzeitig liefert die k-KernZerlegung, die wir erst mal defnieren müssen, einen Einblick in die globale Struktur des
Graphen.
Definition 2.5. Eine geschachtelte Zerlegung eines schlichten ungerichteten Graphen
G = (V, E) ist eine endliche Folge (V0 , . . . , Vk ) von Teilmengen der Knoten mit folgenden
Eigenschaften:
• V0 = V
• Vi+1 ⊂ Vi für 0 ≤ i < k
• Vk 6= ∅
Die folgende Definition des k-Kerns ist konstruktiv; sie gibt bereits einen Algorithmus
an, wie man die gewünschte Zerlegung prinzipiell berechnen kann.
Definition 2.6. Der i-Kern von G ist der eindeutige Teilgraph, den man erhält, indem
man nacheinander alle Knoten mit Grad kleiner als i entfernt.
Alternativ lässt sich der i-Kern so definieren:
Definition 2.7. Der i-Kern ist die Menge aller Knoten mit mindestens i Nachbarn, die
auch zum i-Kern gehören.
Definition 2.8. Der Kern, Core(G), von G ist der nichtleere k-Kern mit maximalem k.
Nun können wir endlich die Kernzahl eines Knotens definieren.
Definition 2.9. Ein Knoten v hat die Kernzahl (coreness) i, wenn v zum i-Kern gehört,
aber nicht zum (i + 1)-Kern.
Ein Beispiel einer k-Kern-Zerlegung ist in Abbildung 2.2 dargestellt. Die Kernzahl ist
dabei in den Knoten als Zahl vermerkt.
Definition 2.10. Die i-Schale von G besteht aus allen Knoten mit Kernzahl i.
Definition 2.11. Das Zentralitätsmaß CoreC ordnet jedem Knoten seine Kernzahl zu.
15
2. Zentralitätsmaße
Abbildung 2.2.: Beispiel einer k-Kern-Zerlegung [BGG+ 08]
2.1.2.2. Theoretische Resultate*
Lemma 2.12. Sei G = (V, E) ein Graph, (V0 , . . . , Vk ) seine Kern-Zerlegung und Gi :=
(Vi , Ei ) := G[Vi ] sein i-Kern. Seien weiterhin ni := |Vi \Vi+1 | die Zahl der Knoten in
der i-Schale und mi := |Ei \Ei+1 | die Zahl der Kanten, deren Endknoten mit minimaler
Kernzahl zur i-Schale gehören. Per Definition gelte: Vk+1 := ∅, Ek+1 := ∅. Dann lässt
sich die Größe der i-Schale beschränken durch:
(
i
d i·n
2 e
ni
2 + ni (i − ni + 1)
0
≤ ni
, if ni > i
, if ni ≤ i
≤ mi
≤ |V |
(
i · ni
≤
i · ni −
(2.1)
i(i+1)
2
, if i < k
, if i = k
(2.2)
Beweis. Ungleichung (2.1) ist trivial. Wir beweisen nun von (2.2) die erste Zeile. Seien
dazu V 0 := Vi \Vi+1 und deg(i) (v) := degGi (v) der Knotengrad von v in Gi .
(i)
1. Nach Konstruktion der Zerlegung
v ∈ V 0 gelten. WeiP
Pmuss deg (v)P≥ i für alle
(i)
terhin muss 2|Ei \Ei+1 | ≥ v∈V 0 u∈N (i) (v) 1 = v∈V 0 deg (v) gelten. Denn nur
die Kanten mit beiden Endknoten in Vi werden nicht nur auf der linken Seite der Ungleichung,
sondern
P
P auch rechtsi davon doppelt gezählt. Daraus folgt:
mi ≥ 12 v∈V 0 deg(i) (v) ≥ 12 v∈V 0 i = i·n
2 .
2. Falls alle Kanten extern sind (also zwischen verschiedenen Schalen verlaufen), dann
sind dies i · ni Stück. Mehr als i externe Kanten kann ein Knoten der i-Schale nicht
haben, da er sonst einer höheren Schale angehören würde.
16
2.1. Knotenzentralitätsmaße
2.1.2.3. Sequentieller Linearzeit-Algorithmus
Der generische Algorithmus 2.1 zur Berechnung der k-Kern-Zerlegung folgt der konstruktiven Definition 2.6. Nacheinander werden die Knoten einer Schale (startend bei
der 0-Schale) entfernt, bis keiner mehr aus dieser Schale übrig bleibt. Dann wird zur
nächsten Schale übergegangen. Die wesentliche Einsicht dabei ist, dass die Knoten zur
i-Schale gehören, deren Residualgrad resdegree kleiner als i ist.
Algorithm 2.1 Generischer Code für die Berechnung der k-Kern-Zerlegung
1: function CoreDecomposition(G = (V, E))
2: Ausgabe: Kernzahl k des Kerns von G und Feld core mit Kernzahl jedes Knotens
3:
Speichere die Knotengrade für alle Knoten in resdegree
4:
i←0
5:
while V 6= ∅ do
6:
i←i+1
7:
for each v ∈ V mit resdegree[v] < i do
8:
core[v] ← i − 1
9:
for each u ∈ N (v) do
10:
resdegree[u] ← resdegree[u] − 1
11:
end for
12:
Entferne v aus G
13:
end for
14:
end while
15:
return (i − 1, core)
16: end function
Pseudocode ist wie bekannt bewusst abstrakt gehalten. Das kann dafür sorgen, dass die
Zeitkomplexität eines Algorithmus auf den ersten Blick höher als nötig erscheint. Auch
hier sollte die Implementierung des Algorithmus mit der üblichen Sorgfalt erfolgen, damit man einen effizienten Algorithmus erhält. In der Tat lässt sich die k-Kern-Zerlegung
nämlich in linearer Zeit (bezogen auf die Zahl der Kanten) umsetzen. Die wesentliche
Einsicht, die dazu benötigt wird, ist eine effiziente Suche der Knoten, deren Residualgrad kleiner als i ist. Dazu nutzt man eine adressierbare Prioritätswarteschlange für
ganzzahlige Werte. Dann lässt sich Zeile 7 des Algorithmus in amortisierter konstanter
Zeit durchführen, wie das folgende Lemma beweist.
Lemma 2.13. Sei G = (V, E) mit |E| =: m zusammenhängend, ungewichtet und
schlicht. Dann kann der Algorithmus CoreDecomposition(G) in der Laufzeit O(m)
implementiert werden.
Beweis. Das Berechnen und Speichern der Knotengrade in Zeile 3 ist offensichtlich in
O(m) Zeit möglich.
Damit die Schleife in Linearzeit läuft, brauchen wir eine geeignete Datenstruktur. Es
handelt sich dabei um eine adressierbare Prioritätswarteschlange mit Behältern (bucket
priority queue). Sie besteht zunächst aus einem Feld A der Länge n, wobei A[i] ein
17
2. Zentralitätsmaße
Zeiger auf die doppelt verkettete Liste Li ist, die alle Knoten v mit resdegree[v] = i
speichert (0 ≤ i < n). Außerdem gibt es eine Variable dmin , die das minimale i mit nichtleerer Liste Li speichert, und ein Feld vptr, dessen Einträge vptr[v] auf den Eintrag von
Knoten v in der passenden Liste Li verweist. Vor dem Eintritt in die while-Schleife kann
diese Datenstruktur in O(n) Zeit konstruiert werden. Weil G zusammenhängend ist, gilt
m ≥ n − 1. Somit ist max{n, m} = O(m).
Der Pseudocode wird so erweitert, dass direkt nach Zeile 9 ein Knoten u in die Liste
Lresdegree[u] verschoben wird. Dies geht in konstanter Zeit. Ggf. muss zwar dmin auch
verändert werden, aber dies geht nach Ergebnissen von Fiduccia und Mattheyses in
amortisiert konstanter Zeit. Das Hauptargument hier ist, dass ein Ansteigen des Zeigers
durch die Summe aller Knotengrade beschränkt werden kann, welcher O(m) ist. In Zeile 6
können die Knoten mit Grad < i jeweils in konstanter Zeit gefunden werden, indem man
auf Ldmin zugreift. Somit kostet ein Schleifendurchlauf für den Knoten v eine Laufzeit
von O(resdegree[v]) = O(deg(v)). Da jeder Knoten nur einmal betrachtet wird, ergibt
sich insgesamt:
X
O(deg(v)) = O(m).
v∈V
2.1.2.4. Paralleler Algorithmus
Die Verwendung einer Prioritätsliste ist im parallelen Fall nicht so einfach. Gleichzeitige
Zugriffe von verschiedenen Threads müssen koordiniert werden, damit keine race conditions entstehen. Diese Koordination ist nicht kostenlos zu haben. Zwar existieren gute
Forschungsarbeiten zu parallelen Prioritätslisten, aber häufig ist ein hemdsärmeligeres
Vorgehen tatsächlich einfacher zu realisieren. So ersetzen auch die Autoren von ParK,
einem parallelen Algorithmus zur k-Kern-Zerlegung, das sequentielle Vorgehen im Wesentlichen durch einen parallelen Array-Scan. Auf diese Weise vollbringt der parallele
Algorithmus zwar mehr Arbeit, bei einer größeren Anzahl von Threads sinkt die Laufzeit
in der Regel dennoch deutlich. Algorithmus 2.2 skizziert ParK, dessen Untermethoden
in Algorithmus 2.3 und 2.4 dargestellt sind.
2.1.3. Clusterkoeffizienten und Transitivität
2.1.3.1. Motivation und Definition
Stellen wir uns vor, uns gibt jemand einen Netzwerkdatensatz und behauptet, es sei ein
soziales Netzwerk. Wie können wir diese Behauptung mit unseren bisherigen Mitteln
überprüfen? Zunächst können wir uns die Gradverteilung anschauen. Ist diese nicht
zumindest einigermaßen endlastig, sollten wir skeptisch werden. Ein weiteres einfaches
Maß beruht auf der Überlegung, dass zwei gemeinsame Freunde derselben Person häufig
auch miteinander befreundet sind – jedenfalls mit höherer Wahrscheinlichkeit als mit
einer zufälligen Person im Netzwerk. Formalisieren wir diesen Gedanken zunächst.
18
2.1. Knotenzentralitätsmaße
Algorithm 2.2 Paralleler Algorithmus zur Berechnung der k-Kern-Zerlegung
1: procedure ParK(G = (V, E))
2:
Initialisiere resdeg
3:
curr ← ∅
4:
next ← ∅
5:
todo ← n
6:
level ← 1
7:
while todo > 0 do
8:
scan(resdeg, level, curr)
9:
while |curr| > 0 do
10:
todo ← todo - |curr|
11:
processSublevel(resdeg, level, curr, next)
12:
curr ← next
13:
next ← ∅
14:
end while
15:
level++
16:
end while
17: end procedure
• Der lokale Cluster-Koeffizient eines Knotens v ist definiert als:
Definition 2.14.
C(v) :=
Zahl der Dreiecke mit v
Zahl der Tripel (Pfade der Länge 2) mit v als zentralem Knoten
• Der durchschnittliche lokale Clusterkoeffizient eines Graphen G ist definiert als:
1 X
Clocal (G) := 0
C(v)
|V |
0
v∈V
Beispiel 2.15.
(1,
(1,
(1,
(2,
(2,
(2,
(2,
(2,
(2,
(3,
(3,
(3,
(3,
(3,
(3,
(3,
2,
2,
2,
3,
3,
3,
4,
4,
5,
2,
2,
2,
4,
4,
5,
6,
3)
4)
5)
4)
5)
6)
3)
6)
3)
1)
4)
5)
2)
6)
2)
4)
(4,
(4,
(4,
(4,
(4,
(4,
(4,
(5,
(5,
(5,
(5,
(5,
(5,
(6,
(6,
(6,
(6,
(6,
2,
2,
2,
3,
3,
3,
6,
2,
2,
2,
3,
3,
3,
3,
3,
3,
4,
4,
1)
3)
5)
2)
5)
6)
3)
1)
3)
4)
2)
4)
6)
2)
4)
5)
2)
3)
19
2. Zentralitätsmaße
Algorithm 2.3 Untermethode ProcessSublevel von ParK
1: procedure ProcessSublevel(G = (V, E), resdeg, level, curr, next)
2:
idx ← 0
3:
for each v ∈ curr do in parallel
4:
core[v] ← level
5:
for each u ∈ N (v) do
6:
if resdeg[u] > level then
7:
a ← atomicDec(resdeg[u], 1)
8:
if a = level then
9:
b ← atomicInc(idx, 1)
10:
next[b] ← u
11:
end if
12:
end if
13:
end for
14:
end for
15: end procedure
Algorithm 2.4 Untermethode Scan von ParK
1: procedure Scan(G = (V, E), resdeg, level, curr)
2:
3:
4:
5:
6:
7:
8:
9:
10:
idx ← 0
for i ← 0 to n-1 do in parallel
if resdeg[i] = level then
a ← atomicInc(idx, 1)
curr[a] ← i
end if
end for
end procedure
2.1.3.2. Exakte Berechnung
Die exakte Berechnung der Clusterkoeffizienten ist ziemlich aufwändig und daher für
große Graphen ungeeignet. Ein naiver Ansatz iteriert über alle Knoten v ∈ V und
Paare von Nachbarn von v. Dabei wird geprüft, ob die beiden Nachbarn im aktuellen
Paar auch miteinander durch eine Kante verbunden sind. Dieser Ansatz hat eine WorstCase-Komplexität von O(n · ∆(G)2 ). Auch eine parallele Iteration ändert nichts daran,
dass dies für große Graphen mit einigermaßen häufig auftretenden hohen Knotengraden
ungeeignet ist. Denn hier ergibt sich in der Praxis häufig (nahezu) kubische Laufzeit.
Der asymptotisch schnellste bekannte exakte Ansatz beruht auf schneller MatrixMultiplikation.
20
2.1. Knotenzentralitätsmaße
2.1.3.3. Approximation
Wir gehen aufgrund der hohen asymptotischen Laufzeit eines exakten Ansatzes hier
(auch) den Weg der Approximation und betrachten Algorithmus 2.5 von Schank und
Wagner [SW05]. Dieser ist ein Sampling-Algorithmus mit Stichprobengröße k, wobei k
ein Parameter ist. In jeder Runde wird zunächst ein zufälliger Knoten r aus der Menge
V 0 := V \{v ∈ V : deg(v) ≤ 1} gezogen. Die Knoten mit Grad kleiner oder gleich
eins lässt man aus, weil diese nicht Teil eines Tripels sein können. Zu r bestimmt man
zwei zufällige (unterschiedliche) Nachbarn. Danach prüft man, ob die beiden Nachbarn
selbst durch eine Kante verbunden sind. Falls ja, wird der Zähler l erhöht. Die Variable
l speichert somit die Zahl der gefundenen Dreiecke. Somit drückt der Rückgabewert kl
das Verhältnis von gefundenen Dreiecken zu untersuchten Tripeln aus.
Algorithm 2.5
1: function ApproximateLocalCK(G = (V, E), k)
2:
l←0
3:
for i ← 1 to k do
4:
r ← UniformRandomNumber(1, |V 0 |)
5:
u ← UniformRandomNeighbor(Ar )
6:
repeat
7:
w ← UniformRandomNeighbor(Ar )
8:
until u 6= w
9:
if {u, w} ∈ E then
10:
l ←l+1
11:
end if
12:
end for
13:
return l/k
14: end function
approx
(G) ∈
Theorem 2.16. Für einen ungerichteten Graphen G = (V, E) kann ein Wert Clocal
ν−1
[Clocal (G) − , Clocal (G) + ] mit Wahrscheinlichkeit mindestens ν in der erwarteten
ν
Zeit O( log
) berechnet werden.
2
Beweis. Bzgl. der Laufzeit können wir zunächst annehmen, dass die zufällige Auswahl
eines Knotens bzw. Nachbarns in konstanter Zeit möglich ist. Die Zeitkomplexität der
Prüfung, ob eine Kante im Graphen vorhanden ist, hängt von der Graphdatenstruktur
ab. In sortierten Adjazenzlisten benötigt sie O(log n); nutzt man effizientes Hashing,
geht die Prüfung in erwartet konstanter Zeit. Falls man dann k := dln(2ν)/(22 ) setzt,
ν
).
ergibt sich die erwartete asymptotische Laufzeit von O( log
2
Um die Korrektheit unserer Wahl von k zu beweisen, benutzen wir Hoeffdings Schranke: Sei Xi eine unabhängige reelle Zufallsvariable, die für alle i durch 0 ≤ Xi ≤ M
beschränkt ist. Falls k die Größe der Stichprobe sowie > 0 eine Fehlerschranke ange-
21
2. Zentralitätsmaße
ben, gilt:
k
#
!
" k
1 X
X
−2k2
1
Pr Xi − E
Xi ≥ ≤ 2 exp
k
k
M2
i=1
(2.3)
i=1
Wir müssen nun beweisen, dass der Erwartungswert E(l/k) gleich Clocal (G) ist und
dass die gewünschten Schranken für unsere Wahl von k gelten.
Sei dazu Π(G) die Menge aller Tripel in G und Π(v) [∆(v)] die Menge der Tripel
[Dreiecke] mit v als
( Zentrum. Außerdem sei Υ ∈ Π(G) ein beliebiges Tripel von G.
1 , falls Υ Dreieck
Dann ist X(Υ) =
eine Indikatorabbildung von Π(G) nach {0, 1}.
0 , sonst
Weiterhin gilt:
Clocal (G) =
1 X |∆(v)|
|V 0 |
|Π(v)|
0
v∈V
=
1 X X X(Υ)
|V 0 |
|Π(v)|
0
v∈V Υ∈Π(v)
Die Wahrscheinlichkeit, dass ein bestimmtes Tripel Υ mit Zentrum v ∈ V 0 gezogen
1
wird, ist |V 0 ||Π(v)|
. Also gilt wegen der Linearität des Erwartungswertes:
E[l/k]
=
(2)
=
k
1X
1
E[l] =
E[X(Υi )]
k
k
i=1
X X
1
X(Υ) · 0
|V
||Π(v)|
0
v∈V Υ∈Π(v)
=
1 X |∆(v)|
|V 0 |
|Π(v)|
0
v∈V
=
Clocal (G).
Gleichung (2) gilt dabei oben, weil wir zunächst statt über die Tripel der k Runden
über jedes einzelne Tripel summieren. Wir kennen Υi aus Runde i ja nicht und sehen
alle Tripel als gleich wahrscheinlich an. Dann schreiben wir noch den Erwartungswert in
seine Definition aus Ereigniswert mal Wahrscheinlichkeit des Ereignisses um.
Da die Zufallsvariable X(Υi ) eine Abbildung von Π(G) nach {0, 1} ist, gilt M = 1 in
Hoeffdings Schranke. Daher gilt mit unseren Werten für Ungleichung (2.3):
k
" k
#
!
1 X
−2dln(2ν)/(22 )e2
1X
Pr ≤ 2 exp
Xi − E
Xi ≥ k
k
1
i=1
i=1
≤ 2 exp(− ln(2ν))
1
=
ν
Daraus folgt die Behauptung für unsere Wahl von k.
22
2.1. Knotenzentralitätsmaße
2.1.4. Eigenvektor-Zentralität
Die k-Kern-Zerlegung bzw. die Kernzahl hatten wir im Kontext von Zentralität bereits
damit motiviert, dass sie robuster ist als die Grad-Zentralität. Es macht nun mal in
vielen Fällen einen Unterschied, wie wichtig die eigenen Nachbarn sind, um die eigene Wichtigkeit zu beurteilen. Dieser Ansatz liegt auch der Eigenvektor-Zentralität zu
Grunde. Dabei soll der Zentralitäts-Wert eines Nachbarn proportional in den eigenen
Zentralitäts-Wert EC(v) für v ∈ V eingehen:
!
EC(v) =
X
ω(vu) · EC(j)
u∈N (v)
In algebraischer Schreibweise ergibt sich analog (mit x als Zentralitätsvektor):
X
xv =
Avu xu
(2.4)
u
Daraus ergeben sich unmittelbar zwei Fragen: (i) Existiert so ein Vektor x überhaupt?
(ii) Wie berechnen wir den Vektor x, falls er existiert? Dazu stellen wir Gleichung (2.4)
in Matrix-Vektor-Schreibweise dar, die bereits ein iteratives Vorgehen beschreibt:
x(t+1) = Ax(t)
(2.5)
Diese Darstellung sollte uns an unsere Vorkenntnisse aus der linearen Algebra erinnern (siehe auch Kapitel A). Dann können wir den Zusammenhang zu Eigenwerten
und Eigenvektoren herstellen. Aus Definition A.3 folgt, dass der stationäre Zustand von
Gleichung (2.5), sofern er existiert, ein Eigenvektor ist:
Ax = λx
(2.6)
für einen Eigenwert λ. Man bezeichnet das iterative Vorgehen von Gleichung (2.5) als Potenzmethode (engl. power iteration). Seine Konvergenz hängt von den Eigenwerten λi von
A ab, wie wir sehen werden. Seien die Eigenwerte dazu absteigend nach betragsmäßiger
Größe sortiert. Außerdem gilt wegen Theorem A.4 unmittelbar:
Folgerung 2.17. Die Adjazenzmatrix A eines ungewichteten ungerichteten Graphen
besitzt n unterschiedliche Eigenvektoren z (1) , . . . , z (n) ∈ Rn , die in Rn eine Basis bilden.
Ferner gilt z (i) ⊥ z (j) für alle 1 ≤ i 6= j ≤ n. Die Eigenwerte von A liegen zwischen
−dmax und dmax , wobei dmax den maximalen Knotengrad in G darstellt.
Zudem lässt sich etwas über den führenden Eigenwert sowie die Einträge des dazu
korrespondierenden Eigenvektors einer Adjazenzmatrix aussagen:
Lemma 2.18. Der betragsmäßig größte Eigenwert einer Matrix mit nicht-negativen
Einträgen ist nicht-negativ.
Beweis. Siehe Newman [New10a, S. 346f.]. Die Aussage ist im Übrigen Teil des berühmten
Perron-Frobenius-Theorems.
23
2. Zentralitätsmaße
Lemma 2.19. Die Einträge des führenden Eigenvektors einer nicht-negativen Matrix
haben alle dasselbe Vorzeichen (s. [New10a, S. 346f.]).
Weil die Eigenvektoren z (i) von A eine Basis bilden, lassen sich Vektoren des Rn
auch in dieser BasisP
repräsentieren. Dementsprechend sei die Eigenvektor-Zerlegung von
(0)
x gegeben durch ni=1 ci z (i) für geeignete reelle Konstanten ci und die normalisierten
Eigenvektoren z (i) . Dann gilt:
X
X
x(t) = At
ci z (i) =
ci λti z (i)
(2.7)
i
= λt1
X
i
ci
λi
λ1
t
i
z (i) .
(2.8)
Weil |λi | < λ1 für alle 2 ≤ i ≤ n, fallen alle Terme außer dem ersten exponentiell gegen 0 ab. Für t → ∞ konvergiert die Summe demnach gegen den ersten Term:
x(t) → c1 λt1 z (1) . Der Vektor z (1) ist der zu λ1 korrespondierende Eigenvektor, so dass der
stationäre Zustand zu z (1) proportional ist. Da die Proportionalität für die Rangfolge
irrelevant ist, können wir festhalten:
Definition 2.20. Die Eigenvektor-Zentralität ordnet jedem Knoten v ∈ V den v-ten
Eintrag im Eigenvektor zum größten Eigenwert von A zu.
Das Ziel der Proportionalität zu den Zentralitätswerten der Nachbarn haben wir nun
erreicht:
Lemma 2.21. EC(v) ist proportional zu den Nachbarn von v für alle v ∈ V :
X
Avu xu
xv = λ−1
1
u
Beweis. Selbstübung.
Die Eigenvektor-Zentralität eines Knotens kann demnach groß sein, weil (i) ein Knoten
vielen Nachbarn hat, (ii) die Nachbarn eine hohe Eigenvektor-Zentralität haben oder (iii)
beides gilt.
Es ist zwar keine zwingende Bedingung, aber die meisten Zentralitätsmaße bilden auf
nicht-negative Werte ab. Insofern ist es interessant festzuhalten, dass dies auch für die
Eigenvektor-Zentralität gilt:
Folgerung 2.22. Aus Lemma 2.19: Der Zentralitätsvektor x mit Ax = λ1 x lässt sich
so normalisieren, dass xv ≥ 0 ∀v ∈ V gilt.
2.1.4.1. Besonderheiten bei gerichteten Graphen
Die Eigenvektor-Zentralität ist prinzipiell auf ungerichtete und gerichtete Graphen anwendbar. Allerdings ist zu beachten, dass man bei gerichteten Graphen eine unsymmetrische Adjazenzmatrix erhält. Eine unsymmetrische Matrix hat einen linken und einen
rechten Eigenvektor. Welchen würde man also nehmen?
24
2.1. Knotenzentralitätsmaße
Abbildung 2.3.: Gerichteter Graph, dessen Knoten allesamt Eigenvektor-Zentralität 0
haben.
Betrachten wir dazu als Anwendungsbeispiel analog zu Newman [New10a] den WebGraphen, der aus Webseiten (= Knoten) und Links (= Kanten) besteht. Eine Webseite ist
sicherlich wichtiger, wenn viele andere Seiten auf sie verlinken als umgekehrt. Also sollte
die Eigenvektor-Zentralität proportional zu den Zentralitäten der eingehenden Nachbarn
sein:
X
xi = κ−1
Aji xj
1
j
Dies ergibt in der Matrix-Vektor-Darstellung xA = κ1 x, wobei x der führende linke
Eigenvektor ist. Beachten Sie hier wieder die Abweichung zu Newman, die durch die
umgekehrte Richtung der Kanten in der Adjazenzmatrix herrührt.
Weiterhin ist zu beachten, dass die Eigenvektor-Zentralität nur in zusammenhängenden
(ungerichtet) bzw. stark zusammenhängenden (gerichtet) Graphen sinnvoll anwendbar
ist. Um dies einzusehen, betrachten wir den gerichteten Graphen in Abbildung 2.3. Knoten mit Eingangsgrad 0 haben offensichtlich auch Eigenvektor-Zentralität 0 (Selbstübung:
warum?). Dieser Wert gilt demnach für den Knoten A. Die wichtige Beobachtung ist nun,
dass diese Eigenschaft kaskadiert. Knoten B und alle anderen Knoten des Graphen haben
somit auch Eigenvektor-Zentralität 0.
2.1.4.2. Berechnung
Bei der Potenzmethode ist die Wahl der Startlösung nicht schwierig, darf aber auch nicht
beliebig sein. Insbesondere gilt wegen Lemma 2.19 zu beachten:
Folgerung 2.23. Wähle einen Startvektor x(0) , in dem alle Einträge ein positives Vorzeichen haben.
Um die Konvergenz im Algorithmus festzustellen, kann man bspw. zwei verschiedene
Startvektoren wählen und diese nach einer Normalisierung in jeder Iteration (oder alle
paar Iterationen) miteinander vergleichen. Die Normalisierung ist auch ohne die Verwendung von zwei Vektoren notwendig, da sonst die Werte im Rechner schnell überlaufen
würden.
25
2. Zentralitätsmaße
Nach der Konvergenz lässt sich auch der Eigenwert leicht berechnen. Dazu muss man
nur einen Eintrag des Eigenvektors vor und nach einer weiteren Iteration durcheinander teilen (wegen numerischer Ungenauigkeiten sollte man aber über mehrere Einträge
mitteln).
Auch wenn die Eigenvektor-Zentralität nicht zu den beliebtesten (aber durchaus zu
den etablierten) Maßen gehört, lohnt sich ein Blick auf die Zeitkomplexität der Potenzmethode. Dieser Algorithmus ist nämlich auch in anderen Situationen einsetzbar, so auch
im nächsten Abschnitt.
Zunächst können wir festhalten, dass jede Iteration mit einer geeigneten Datenstruktur (etwa: Adjazenzarray) in O(m) zu realisieren ist, da die wesentliche Operation ein
Matrix-Vektor-Produkt ist. Für dünne Graphen, die in unserem Kontext meist vorliegen,
ergibt sich somit O(n). Bleibt zu zeigen, wie viele Iterationen wir brauchen.
Wie wir bereits in Gleichung (2.8) gesehen haben, hängt die Konvergenz von den
Eigenwerten λi von A ab. Der Ausdruck wird maßgeblich vom Quotienten aus dem
betragsmäßig zweitgrößten Eigenwert λ2 und dem betragsmäßig größten Eigenwert λ1
bestimmt. Diesen gilt es zu analysieren.
Wegen Lemma 2.18 und unseren Vorüberlegungen gilt nach t Iterationen:
x
(t)
=
λt1
n
X
ci
i=1
⇒
c2
x(t)
= z (1) +
t
c1 λ1
c1
|
λi t (i)
z
λ1
t
λ2
z (2) + . . .
λ1
{z
}
Hauptfehlerterm
Der mittlere Fehler (RMSD) im Eigenvektor ist dann (bei Vernachlässigung niederer
Terme und unter Berücksichtigung von kz (2) k = 1):
s
2
x(t)
c2 λ2 t
(1)
c1 λt − z = c1 λ1
1
Falls dieser Fehler höchstens sein soll, muss gelten:
t≥
ln(1/) + ln(c2 /c1 )
ln(λ1 /λ2 )
Als Selbstübung kann die Leserin die Umformung selbst nachvollziehen.
Beachten Sie, dass weder noch die Konstanten c1 und c2 von der Größe des Netzwerks
abhängen! Also ergeben sich Variationen in der Laufzeit allein durch die Eigenwerte λ1
und λ2 . Wir wissen: λn ≥ −|λ1 |. Daraus können wir schließen, dass der mittlere Abstand
höchstens 2λ1 /(n−1) ist. Eine ausreichend genaue Abschätzung für λ2 ist daher, dass λ2
proportional zu λ1 − aλ1 /n ist, wobei a eine Konstante der betrachteten Größenordnung
ist. Also:
λ1
a (1) a
' − ln 1 −
= + O(n−2 ).
ln
λ2
n
n
26
2.1. Knotenzentralitätsmaße
Umformung (1) folgt dabei aus limn→∞ (1 − na )n = e−a . Zusammen ergibt das t = O(n)
Schritte, bis die Potenzmethode zur führenden Ordnung konvergiert. Dies ist allerdings
eine pessimistische Abschätzung. In der Praxis wird Konvergenz in der Regel deutlich
schneller erreicht. Meist zeigt sich ein nahezu lineares Laufzeitverhalten (in m) bei der
Analyse komplexer Netzwerke, wenn die Genauigkeit nicht zu niedrig gewählt wird.
2.1.5. PageRank
2.1.5.1. Kontext
Ende der 1990er Jahre waren Suchmaschinen teilweise noch katalogbasiert. Es gab nur
wenige, die tatsächlich suchbasiert arbeiteten, d. h. auf eine beliebige Anfrage hin eine
Liste möglichst relevanter Webseiten präsentierten. Die Ergebnisse waren zu jener Zeit
auch nicht besonders zufriedenstellend. Diese Situation wurde durch eine Firma maßgeblich verändert, die von zwei Informatik-Doktoranden der Stanford University gegründet
wurde: Google.
Die beiden Gründer, Sergey Brin und Larry Page, hatten zuvor den PageRank-Algorithmus entwickelt und veröffentlicht [BP12]. Dieser bildete die Grundlage für das Ranking von Suchergebnissen. Dem PageRank-Algorithmus liegt das Modell des Zufallssurfers zu Grunde. Dabei gehen wir davon aus, dass das WWW durch einen Graphen
modelliert wird – jeder Knoten ist eine Webseite und Links auf einer Webseite werden
durch eine ausgehende gerichtete Kante modelliert. Ein Zufallssurfer bewegt sich nun
zufällig in diesem Graphen. Ist er auf einer Seite (= Knoten), klickt er entweder auf
einen Link oder gibt eine neue URL in die Adresszeile des Browsers ein. Im Graphen
bedeutet das Verfolgen eines Links, dass ein benachbarter Knoten besucht wird. Dabei
wird ein Link (= Nachbar) zufällig gleichverteilt unter allen Links ausgewählt. Im Gegensatz zur Linkverfolgung bedeutet das Eintippen einer neuen URL, dass man auf einen
beliebigen Knoten im Graphen “teleportiert” wird.
Ein Beispiel-Graph mit seinen PageRank-Werten sehen wir in Abbildung 2.4. Der
Knoten B ist dort wichtig, weil viele andere Knoten auf ihn zeigen. Knoten C profitiert
von der Popularität von B, da B nur auf C zeigt. Wir sehen außerdem, dass ein Problem
der Eigenvektor-Zentralität nicht mehr auftritt. Knoten mit Eingangsgrad 0 haben hier
positiven PageRank. Mathematisch wird dies durch die Teleportation erreicht.
2.1.5.2. Etwas Mathematik hinter PageRank
Wir werden feststellen, dass der PageRank-Vektor x der stationäre Zustand eines stochastischen Prozesses ist und letztlich auch ein Eigenvektor. Allerdings ist x kein Eigenvektor zu A, sondern zur sogenannten Google-Matrix – wodurch die angesprochenen
Probleme der Eigenvektor-Zentralität umgangen werden.
Um die Google-Matrix von unserer üblichen Notation eines Graphen zu unterscheiden, stellen wir sie als G dar. Wir benötigen außerdem folgende Objekte: (i) einen
Dämpfungsfaktor α, der die Teleport-Wahrscheinlichkeit angibt, (ii) eine Transitionsmatrix P , die die Linkverfolgung modelliert und (iii) einen stochastischen Teleport-Vektor
27
2. Zentralitätsmaße
Abbildung 2.4.: Ein gerichteter Graph, bei dem die Knotengröße den PageRank des Knoten visualisiert. Quelle: https://en.wikipedia.org/wiki/PageRank.
y. Üblicherweise setzt man y := 1/n. Somit wird jede Webseite mit gleicher Wahrscheinlichkeit in die Adresszeile eingetippt (auch wenn das realitätsfern ist).
Beobachtung 2.24. Die möglichen Zustandsübergänge eines Zufallssurfers lassen sich
durch die Google-Matrix
G := αP + (1 − α)1y T
beschreiben. Dabei ist die Transitionsmatrix P der Linkverfolgung durch Pij := Aij / deg(i)
beschrieben – oder in Matrixschreibweise: P = D−1 A.
Der Ausdruck Pij gibt somit die Wahrscheinlichkeit an, dass man den Link von Seite i
zu Seite j verfolgt (man beachte wieder, dass wir hier gegenüber Newman die umgedrehte
Richtung der Kanten in A verwenden). Die konkreten numerischen Ergebnisse hängen
zwar von der Wahl von α und y ab; sinnvolle Werte beeinflussen das Ranking aber kaum.
Beobachtung 2.25. Der stochastische Prozess des Zufallssurfers startet mit einer Wahrscheinlichkeitsverteilung x(0) (einem stochastischer Vektor). Die weiteren Übergänge werden durch die Iteration
(x(t+1) )T := (x(t) )T G
(2.9)
beschrieben.
Zur Selbstübung sei der Leserin empfohlen, die Iteration für einen konkreten Eintrag
(t+1)
v nachzuvollziehen. Dann sieht man, dass sich xv
aus den Wahrscheinlichkeitsmas(t)
sen xu der Nachbarn u von v, gewichtet um die Übergangswahrscheinlichkeiten Guv ,
zusammensetzt.
Man kann sich leicht davon überzeugen, dass die Matrizen P und G spaltenstochastisch sind; wir tun dies hier nur für G:
28
2.1. Knotenzentralitätsmaße
Lemma 2.26. G ist zeilenstochastisch.
Beweis. Für einen einzelnen beliebigen Eintrag von G gilt:
Guv = αPuv + (1 − α)(1y T )uv
= α(D−1 A)uv + (1 − α)yv
Auv
+ (1 − α)yv
=α·
Duu
Somit folgt für eine beliebige Zeile 1 ≤ u ≤ n:
X
v
X
Auv
+ (1 − α)yv
Duu
v
X
α X
=
Auv + (1 − α)
yv
Duu v
v
Guv =
α·
= α + (1 − α) = 1
Wir können wir nun folgern:
Lemma 2.27. Der größte Eigenwert von G ist 1 und er ist einfach. Zu diesem Eigenwert
korrespondiert der rechte Eigenvektor 1.
Beweis. Dass 1 rechter Eigenvektor zum Eigenwert 1 ist, folgt aus Lemma 2.26. Aus
diesem Lemma und Proposition A.5 folgt, dass 1 der größte (rechte) Eigenwert ist. Da
G quadratisch ist, sind die linken und rechten Eigenwerte aber gleich, so dass es keinen
größeren geben kann. Da G > 0 (elementweise größer als 0), folgt außerdem aus dem Satz
von Perron-Frobenius (Theorem A.6), dass 1 einfacher Eigenwert ist und alle anderen
betragsmäßig kleiner sind.
Iteration (2.9) ist wiederum eine Linksmultiplikation. Nach unseren Vorüberlegungen
muss diese gegen den linken Eigenvektor zum Eigenwert 1 konvergieren. Dieser Eigenvektor ist der sogenannte PageRank-Vektor, den wir suchen.
Definition 2.28. Die PageRank-Zentralität des Knotens v ergibt sich aus dem v-ten
Eintrag des PageRank-Vektors x. Dieser Vektor wird in der Markov-Ketten-Forschung
traditionell als π bezeichnet und ist der dominante linke Eigenvektor von G: π T = π T G.
Will man nun den PageRank-Vektor zur Bestimmung der Zentralität berechnen, kann
man somit wie bei der Eigenvektor-Zentralität die Potenzmethode verwenden. Dies war
auch tatsächlich das Vorgehen bei Google bei seiner Gründung. Zwar ist die Potenzmethode kein universell guter Eigenlöser, aber sie funktioniert sehr gut auf Web-Graphen
und ist außerdem sehr leicht zu parallelisieren – eine wichtige Eigenschaften bei Graphen
mit Milliarden von Knoten und Kanten. Der Algorithmus sieht dann folgendermaßen aus:
1. Starte mit initialem Vektor x(0)
29
2. Zentralitätsmaße
2. Berechne (x(t+1) )T = (x(t) )T G
3. Normalisiere x
4. Wenn nicht konvergiert: gehe zu 2.)
Die Konvergenzgeschwindigkeit der Potenzmethode für die Berechnung des PageRank
hängt ähnlich wie bei der Eigenvektor-Zentralität vom zweitgrößten Eigenwert ab (bzw.
vom Quotienten aus zweitgrößtem und größtem, aber hier ist der größte gleich 1). Da
der zweitgrößte Eigenwert von G bei Web-Graphen meist weit genug weg von der 1
liegt, kann man den PageRank auch für große Graphen in akzeptabler Zeit berechnen –
geeignete Hardware vorausgesetzt.
Der PageRank hat sich aufgrund des überlegenen Rankings von Google schnell durchgesetzt. Heute ist er allerdings nur ein Kriterium unter vielen bei der Bildung der Rangfolge von Suchergebnissen.
2.1.6. Betweenness Centrality
Eins der am meisten beachteten Zentralitätsmaße ist die betweenness centrality. Ihr deutscher Name Intermediationszentralität ist wenig gebräuchlich – wir werden daher auch
im Deutschen meist den englischen Begriff verwenden. In der Folge gehen wir der einfacheren Darstellung wegen von zusammenhängenden Graphen aus, falls nichts Anderes
vermerkt ist.
Die Betweenness Centrality (BC) sieht einen Knoten als wichtig an, wenn ein hoher
Anteil kürzester Wege über ihn verlaufen. Formal definieren wir:
Definition 2.29 (Betweenness Centrality). Sei σst = σts die Zahl der kürzesten Wege
zwischen s und t. Zudem sei σst (v) = σts (v) die Zahl der kürzesten Wege zwischen s und
t, auf denen der Knoten v (als Zwischenknoten) liegt.
Dann ist die (nicht normalisierte) Betweenness Centrality eines Knotens v ∈ V in
einem ungerichteten Graphen definiert als:
BC(v) :=
X
s6=v6=t∈V
σst (v)
σst
(2.10)
Man summiert also über alle geordneten Knotenpaare (s, t), wobei s und t ungleich
sind. Außerdem dürfen weder s noch t gleich v sein. Für ein solches Paar addiert man
dann den Anteil der kürzesten Wege zwischen s und t, die auch über v laufen.
Hinter dieser Definition steckt die Annahme, dass sich bspw. Informationen über
kürzeste Wege im Netzwerk ausbreiten. Eine Person mit hoher BC in einem sozialen
Netzwerk ist wichtig, weil sie den Informationsfluss kontrollieren kann.
Um uns der effizienten Berechnung der BC zu nähern, interpretieren wir Teile der
Summe neu:
Definition 2.30 (Paar-Abhängigkeit). Die Paar-Abhängigkeit eines Knotens v ist gegeben durch:
δst (v) = σst (v)/σst
30
2.1. Knotenzentralitätsmaße
Folglich ist
BC(v) =
X
s6=v6=t∈V
=
X
σst (v)
σst
(2.11)
δst (v)
(2.12)
s6=v6=t∈V
die Summe über die Paar-Abhängigkeiten von v.
Ein naiver Algorithmus würde nun die Zahl der kürzesten Wege zwischen allen Knotenpaaren sowie für jeden Knoten die Summe der Paar-Abhängigkeiten berechnen. Zur
Einordnung erinnern wir uns an unsere Algorithmik-Grundvorlesung und die Laufzeiten
von Dijkstras Algorithmus bzw. von Breitensuche zur Lösung eines einzelnen singlesource shortest path (SSSP) Problems:
Lemma 2.31. Sei ein Startknoten s ∈ V gegeben. Die Zahl und Länge aller kürzesten
Pfade zu allen anderen Knoten lässt sich in O(m + n log n) Zeit für gewichtete Graphen
berechnen (in O(m + n) für ungewichtete).
Es gibt allerdings quadratisch viele Paar-Abhängigkeiten. Somit hätte das naive Vorgehen mindestens kubischen Aufwand in n.
2.1.6.1. Effiziente Berechnung der BC-Werte
Eine wesentliche Einsicht zur Beschleunigung des naiven Algorithmus ist, dass beim obigen Vorgehen Zwischenergebnisse mehrfach berechnet werden. Einmal berechnete Zwischenergebnisse sollte man mehrfach verwenden. Der nachfolgende Algorithmus stammt
von Ulrik Brandes [Bra01] und ist der schnellste bekannte Algorithmus, der die Betweenness-Werte exakt berechnet. Zunächst benötigen wir dazu das Vorgänger-Konzept; dazu müssen wir uns noch überlegen, unter welchen Umständen ein Knoten Teil eines
kürzesten Weges ist (ohne Beweis, da Teil von Grundvorlesungen).
Lemma 2.32. Ein Knoten v liegt genau dann auf dem kürzesten Pfad zwischen s und
t, wenn dist(s, v) + dist(v, t) = dist(s, t) gilt.
Definition 2.33 (Vorgänger). Die Menge der Vorgänger von v auf einem kürzesten Pfad
von s schreiben wir als Ps (v) = {u ∈ V : {u, v} ∈ E, distG (s, v) = distG (s, u) + ω(u, v)}.
Die Zahl der kürzesten Wege von s nach v kann man berechnen, indem man die Zahl
der kürzesten Wege von s zu den Vorgängern von v summiert (der Beweis sei der Leserin
zur Übung empfohlen):
P
Lemma 2.34. Für s 6= v ∈ V gilt: σsv = u∈Ps (v) σsu .
Unser Ziel ist nun, nicht alle Paar-Abhängigkeiten summieren zu müssen. Wir betrachten anstelle von Paaren daher (gedanklich) Abhängigkeiten eines einzelnen Knotens:
P
Definition 2.35 (Abhängigkeit eines Knotens s). δs• (v) = t∈V δst (v).
31
2. Zentralitätsmaße
Abbildung 2.5.: Akkumulation der Abhängigkeiten im Beweis von Theorem 2.37. Quelle:
Brandes [Bra01].
Die entscheidende Einsicht ist, dass diese Summen eine rekursive Beziehung haben:
Lemma 2.36. Falls es exakt einen kürzesten Weg von s ∈ V zu jedem t ∈ V gibt, dann
gilt für die Abhängigkeit von s von jedem anderen v ∈ V :
X
δs• (v) =
(1 + δs• (w)).
w:v∈Ps (w)
Für einen Knoten v lässt sich seine Abhängigkeit demnach aus den Abhängigkeiten
seiner Nachfolger berechnen – also der Knoten w, für die v Vorgänger auf einem kürzesten
Weg ist. Der Beweis dieses Lemmas bietet sich als Übungsaufgabe an. Der allgemeinere
Fall wird als nächstes bewiesen. Hat man dessen Beweis verstanden, fällt der Beweis des
Spezialfalls leicht.
Theorem 2.37. Für die Abhängigkeit δs• (v) eines Startknotens s ∈ V zu einem anderen
Knoten v ∈ V gilt:
X
σsv
δs• (v) =
· (1 + δs• (w)).
σsw
w:v∈Ps (w)
Beweis. Die Eigenschaft δst (v) > 0 gilt nur für solche t ∈ V \{s}, für die v auf mindestens
einem kürzesten Pfad von s nach t liegt. Auf jedem dieser Pfade gibt es genau eine Kante
{v, w} mit v ∈ Ps (w). Siehe dazu auch Abbildung 2.5.
Wir erweitern nun das Konzept der Paar-Abhängigkeit durch den Einbezug einer
Kante e ∈ E anhand der Definition
δst (v, e) :=
σst (v, e)
.
σst
Dabei ist σst (v, e) die Zahl der kürzesten Pfade von s nach t, die sowohl v als auch e
enthalten. Dann gilt:
X
X X
δs• (v) =
δst (v) =
δst (v, {v, w})
(2.13)
t∈V
32
t∈V w:v∈Ps (w)
2.1. Knotenzentralitätsmaße
=
X
X
δst (v, {v, w}).
(2.14)
w:v∈Ps (w) t∈V
Sei nun w ein beliebiger Knoten mit v ∈ Ps (w). Von den σsw kürzesten Pfaden von
s nach w verlaufen σsv Stück von s nach v und dann über {v, w}. Folglich beinhalten
σsv
σsw · σst (w) kürzeste Pfade von s nach t 6= w den Knoten v und die Kante {v, w}. Also
ist die Paar-Abhängigkeit von s und t bgzl. v und {v, w}:
(
σsv
falls t = w
δst (v, {v, w}) = σσsw
(2.15)
σst (w)
sv
sonst
σsw · σst
(2.16)
Wir setzen dies in Formel (2.14) ein und beachten dabei, dass w 6= s genau einmal
Endpunkt (also = t) des kürzesten Weges von s ist:
X X
δst (v, {v, w})
(2.17)

w:v∈Ps (w) t∈V

X
σ
σ
σ
(w)
sv
st
 sv +

=
·
σsw
σsw
σst
w:v∈Ps (w)
t∈V \{w}


X σst (w)
X
σsv 
.
· 1+
=
σsw
σst
X
=
(2.19)
t∈V \{w}
w:v∈Ps (w)
(Def. 2.35)
(2.18)
X
w:v∈Ps (w)
σsv
· (1 + δs• (w)).
σsw
(2.20)
Wie nutzen wir diese rekursive Beziehung nun algorithmisch aus? Die Grundidee ist,
n SSSP-Probleme zu lösen und dabei temporäre BC-Werte zu akkumulieren.
Bei der Berechnung der kürzesten Wege von einem Startknoten s ∈ V in G entsteht
implizit ein DAG. Wenn wir ihn auf die Kanten der ersten Entdeckung eines Knotens
reduzieren, entsteht wiederum ein Baum T .
Satz 2.38. Sei der oben beschriebene Baum T der kürzesten Pfade von einem Startknoten s ∈ V in G gegeben. Dann lassen sich die Abhängigkeiten von s zu allen anderen
Knoten in Zeit O(m) und Platz O(n + m) berechnen.
Beweis. Während einer Postorder-Traversierung lassen sich die Abhängigkeiten gemäß
Theorem 2.37 akkumulieren. An jedem Knoten ist dafür nur konstante Zeit notwendig.
Pro Knoten muss dazu ein Abhängigkeit und die Liste der Vorgänger gespeichert
werden. Da es pro Kante höchstens ein Element in allen diesen Listen gibt, folgt die
Behauptung.
Der Algorithmus von Brandes lässt sich nun informell so beschreiben:
33
2. Zentralitätsmaße
• Eingabe: G = (V, E), Ausgabe: BC-Werte für alle v ∈ V
• Berechne n Kürzeste-Pfade-Bäume, einen pro s ∈ V , und währenddessen auch die
Mengen Ps (v)!
• Berechne für jedes jeweilige s ∈ V und alle anderen v ∈ V die Abhängigkeiten
δs• (v) mit Hilfe des Baumes, der Vorgängermengen und des Theorems 2.37:
– Starte an den Blättern des Baumes, arbeite dich per Postorder-Traversierung
schrittweise zur Wurzel voran
– Sei der aktuell betrachtete Knoten w. Akkumuliere den Abhängigkeitswert
σ[v]
des Startknotens s zu v ∈ Ps (w): δ[v] ← δ[v] + σ[w]
· (1 + δ[w]). Akkumuliere
dann den BC-Wert von w: BC(w) ← BC(w) + δ[w]. (Die Notation weicht hier
bewusst leicht ab, um näher am Code zu sein und die Unterschiede von ProgrammVariablen und unserer mathematischen Notation zu verdeutlichen.)
Theorem 2.39. Der Algorithmus von Brandes berechnet für Graphen mit nicht-negativen
Kantengewichten die exakten BC-Werte in der Zeit O(nm + n2 log n) und benötigt dabei
O(n + m) Speicher.
Für ungewichtete Graphen reduziert sich die Laufzeit auf O(n(n + m)). Im Falle m =
Ω(n) ergibt sich O(nm).
Beweis. Es sind n SSSPs zu lösen. Laufzeit und Speicherverbrauch ergeben sich damit
im Wesentlichen aus Lemma 2.31 und Proposition 2.38.
Für dicht besetzte Graphen ergibt sich somit weiterhin kubische Laufzeit. In der Praxis
haben wir es aber meist mit dünn besetzten Graphen zu tun. In dem Fall verbessern wir
uns asymptotisch um den Faktor logn n bzw. n gegenüber dem naiven Algorithmus.
Trotzdem ist die mindestens quadratische Laufzeit ein Problem hinsichtlich der Skalierbarkeit auf große Graphen. Für Millionen von Knoten und Kanten ist daher eigentlich
nur eine approximative Lösung praktikabel. Geeignete Algorithmen dafür besprechen wir
im nächsten Abschnitt.
2.1.6.2. Approximation der BC-Werte
Für diesen Abschnitt verweisen wir auf die Folien, die Elisabetta Bergamini in der Vorlesung bzw. Übung präsentiert hat. Es ist geplant, künftige Skript-Versionen zu diesem
Thema weiter auszubauen.
2.1.7. Nähe- und harmonische Zentralität
Informationen fließen in Netzwerken sicherlich meist auf kurzen Wegen zwischen zwei
Knoten s und t, zumindest wenn der Prozess der Informationsverbreitung effizient ist.
Nicht notwendigerweise sind es auch tatsächlich immer die kürzesten Wege, aber wir
werden auch in diesem Abschnitt diese Annahme treffen. Dabei betrachten wir nun
nicht deren Zahl bzw. Anteile, sondern deren Länge.
34
2.1. Knotenzentralitätsmaße
Abbildung 2.6.: Wärmebild der Nähezentralität (rot = hoch, dunkelblau = niedrig),
Quelle: Wikipedia.
Der mittlere kürzeste Abstand eines Knotens v ∈ V ist definiert als
1X
lv :=
dist(v, u).
n
u∈V
Knoten, die sehr zentral in einem Netzwerk positioniert sind, summieren dabei tendenziell kleine Abstände. In einem sozialen Netzwerk können solche zentralen Personen
Informationen viel schneller streuen. Im Unterschied dazu haben Knoten am Rand eines Netzwerks hohe Abstände zu vielen anderen Knoten, siehe auch Abbildung 2.6. Es
dauert daher viel länger, bis eine Information von nicht zentralen Knoten bei allen anderen angelangt ist (unter der Annahme, dass diese sich nur auf einem kürzesten Weg
ausbreitet).
Ein Nachteil des mittleren kürzesten Abstands ist, dass zentrale Knoten niedrige Werte
haben. Um dies auszugleichen, bilden wir den Kehrwert. Damit Knoten unterschiedlicher
Netzwerke einigermaßen vergleichbar werden, normalisieren wir zusätzlich noch durch die
Anzahl der Knoten, über die der Durchschnitt gebildet wird:
Definition 2.40 (Nähezentralität). Die (normalisierte) Nähezentralität eines Knotens
v ∈ V ist definiert als:
1X
CloseC(v) :=
dist(v, u)
(2.21)
n
u∈V
Einige Autoren summieren in Formel (2.21) nur über die Knoten ungleich v. Dann
erfolgt die Normalisierung mit n − 1 statt mit n – was aber auch die einzige Änderung
ist, da der Abstand von v zu sich selbst 0 ist. NetworKit führt die Normalisierung mit
n − 1 durch; analytische Ergebnisse sind laut Newman [New10b] eleganter, wenn man
mit n normalisiert.
35
2. Zentralitätsmaße
Ein weiteres Problem der Nähezentralität ist ihre Erweiterung auf unzusammenhängende
bzw. nicht stark zusammenhängende Graphen. Man könnte natürlich nur über Knotenpaare einer Zusammenhangskomponente summieren. Dies hätte allerdings u. a. den
Nachteil, dass das Einfügen einer Brückenkante zwischen zwei Komponenten gravierende
Änderungen in den Zentralitätswerten nach sich ziehen würde.
Besser erscheint da die harmonische Zentralität, die über die Kehrwerte der Distanzen summiert. Folgt man der Konvention, dass nicht verbundene Knoten den Abstand
unendlich haben und der Kehrwert von unendlich 0 ist, ergibt sich:
Definition 2.41 (Harmonische Zentralität). Die harmonische Zentralität eines Knotens
v ∈ V ist definiert als:
HC(v) :=
1 X
1
.
n−1
dist(v, u)
(2.22)
u∈V
Beachten Sie, dass wir hier nur über n − 1 Terme summieren, denn der Term für u = v
muss unbedingt ausgeschlossen werden. Der Grund dafür ist eine leichte Übungsaufgabe
und erschließt sich direkt aus der Definition.
Nähe- und harmonische Zentralität lassen sich auch heranziehen, um ein komplettes
Netzwerk zu beurteilen. Für ein Netzwerk mit nur einer Zusammenhangskomponente
lässt sich dazu die mittlere Nähezentralität heranziehen:
l :=
1X
1 X
dist(v,
u)
=
lv .
n2 vu
n v
Bei mehreren Zusammenhangskomponenten ergibt sich wieder das weiter oben angesprochene Problem mit unendlich langen Abständen. Man kann dann beispielsweise
nur über Knotenpaare aus derselben Komponente summieren. Alternativ – und nach
den obigen Überlegungen vermutlich oft vorteilhaft – verwenden wir wieder die Summe
harmonischer Abstände:
n
l0 := P
.
(2.23)
v HC(v)
Im Kapitel 3 widmen wir uns der effizienten Berechnung von Distanzen und kürzesten
Wegen, wie wir sie zur Berechnung der obigen Zentralitätsmaße benötigen.
2.2. Top-k-Ranglisten*
Es kann unter Umständen sehr viel schneller sein, die k Knoten mit der höchsten Zentralität zu berechnen, als die komplette Rangfolge zu bestimmen (natürlich nur, wenn
k deutlich kleiner als n ist). Auf dieses Thema gehen wir in der Vorlesung aus Zeitgründen bestenfalls am Rande ein. Die interessierte Leserin sei für weitere Details auf
eine aktuelle Arbeit zur Nähezentralität [BBC+ 16] verwiesen.
36
2.3. Kantenzentralitätsmaße*
2.3. Kantenzentralitätsmaße*
Eine Reihe von Knotenzentralitätsmaßen lassen sich sehr einfach als Kantenzentralität
umformulieren. Zudem gibt es eine ganze Reihe von Maßen, die nur für Kanten definiert
wurden. Aus Zeitgründen werden wir darauf in der Vorlesung aber leider nicht genauer
eingehen können.
2.4. Weiterführende Literatur
Eine breite Übersicht zu Zentralitätsmaßen und ihren Eigenschaften liefert das Lehrbuch
von Newman [New10a]. Etwas älter ist die Darstellung im von Brandes und Erlebach
herausgegebenen Buch [BE05]. Sehr zu empfehlen ist der Artikel von Boldi und Vigna [BV14], der unter anderem eine Übersicht über viele bekannte Maße bietet und
diese hinsichtlich einer Axiomatik beurteilt.
Bezüglich der Rangfolgen für Webseiten genoss auch der hubs and Authorities genannte Algorithmus von Kleinberg [Kle99] Popularität. Allerdings hat der Erfolg von Google
dazu geführt, dass PageRank in diesem Kontext stark dominiert.
37
3. Kürzeste Wege und globaler
Zusammenhang
3.1. Paarweise Abstände und kürzeste Wege
Zunächst betrachten wir zwei Algorithmen, die für jedes Knotenpaar den Abstand bzw.
den kürzesten Weg berechnet. Ihre Laufzeit ist allerdings für größere Probleme in der
Praxis ungeeignet. Wir werden daher einen weiteren Algorithmus kennenlernen, der nach
einem Vorverarbeitungsschritt einzelne Anfragen sehr schnell abarbeiten kann.
3.1.1. Floyd-Warshall-Algorithmus
Der Floyd-Warshall-Algorithmus zur Berechnung paarweiser Distanzen (bzw. paarweiser
kürzester Wege) basiert auf der Idee, das Problem schrittweise zu vergrößern. In Iteration
k werden alle Wege berücksichtigt, die über Knoten aus der Menge {1, . . . , k} verlaufen
(direkte Kanten des Graphen eingeschlossen). Nach Ende der äußersten Schleife hat k
den Wert n überschritten, so dass alle möglichen Wege berücksichtigt worden sind.
Algorithm 3.1 Algorithmus von Floyd-Warshall zur Berechnung paarweiser Distanzen
1: function Floyd-Warshall-APD(G = (V, E))
2: Ausgabe: Distanzmatrix D (n)
3:
D(0) ← W
4:
for k ← 1 to n do
5:
for i ← 1 to n do
6:
for j ← 1 to n do
(k)
(k−1) (k−1)
(k−1)
7:
dij ← min(dij , dik
+ dkj )
8:
end for
9:
end for
10:
end for
11:
return D(n)
12: end function
Theorem 3.1. Sei G = (V, E) ein Graph ohne negative Zyklen. Dann berechnet der
Algorithmus von Floyd-Warshall die Entfernung zwischen jedem Knotenpaar in O(|V |3 )
Schritten.
Der Beweis von Theorem 3.1 wird dem Leser als Übung empfohlen.
39
3. Kürzeste Wege und globaler Zusammenhang
Bemerkung 3.2. Das als Algorithmus 3.1 angegebene Verfahren löst nur das Problem
All-Pairs-Distances (APD), d. h. es werden die paarweisen Distanzen und nicht auch die
zugehörigen kürzesten Wege berechnet. Eine entsprechende Erweiterung des Algorithmus
für APSP wird der Leserin ebenfalls als Übungsaufgabe empfohlen.
3.1.2. Matrix-Multiplikation
Kommen wir nun zu einem asymptotisch etwas schnelleren Algorithmus. Dazu betrachten wir ungerichtete ungewichtete Graphen G = (V, E), gegeben durch die Adjazenzmatrix A. Es seien D, W ∈ (R ∪ {∞})n×n quadratische Matrizen. Verwenden wir die
Verknüpfungen (min, +) bei der Matrixmultiplikation, so gilt bekanntlich:
(DW )ij = min {Dik + Wkj }
1≤k≤n
Diese Tatsache setzen wir nun ein, um mit Hilfe eines modifizierten Algorithmus zur
Matrixmultiplikation die Distanzen aller paarweise kürzesten Wege zu berechnen. Wir
wollen demnach D(n−1) berechnen. Das ist offensichtlich durch n − 1 Matrixmultiplikationen möglich. In Iteration k wird dabei D(k−1) mit W multipliziert. Allerdings ist
dieser Ansatz zu langsam. Die wichtige Idee ist daher nun, D(n−1) durch fortgesetztes
Quadrieren bzgl. der Matrixmultiplikation zu berechnen:
D(1) = W, D(2) = W 2 = W ∗ W, D(4) = W 4 = W 2 ∗ W 2 , ...
D(2dlog n−1e) = D2dlog n−1e = Ddlog n−1e−1 ∗ Ddlog n−1e−1
Algorithmus 3.3 namens mmAPD zeigt nun, wie man durch fortgesetzte Aufrufe an eine
Subroutine zur modifizierten Matrixmultiplikation die Distanzen der paarweise kürzesten
Wege berechnen kann. Er nutzt dabei eine Matrixmultiplikation als Untermethode, siehe
dazu Algorithmus 3.2 für eine mögliche (aber nicht schnelle) Implementierung.
Algorithm 3.2 Matrixprodukt gemäß Schulmethode, allerdings für Halbring (min, +).
1: function MatMult(A, B)
2: Ausgabe: Matrixprodukt AB
3:
for i ← 1 to n do
4:
Cij ← ∞
5:
for k ← 1 to n do
6:
Cij ← min{Cij , Aik + Bkj }
7:
end for
8:
end for
9:
returnC
10: end function
Momentan liegt die beste bekannte Laufzeit eines Algorithmus für Matrixmultiplikation bei O(n2.373 ) [Gal14]. Eine bessere untere Schranke als Ω(n2 ) ist nicht bekannt,
so dass hier eine noch nicht geschlossene Lücke zwischen unterer und oberer Laufzeitschranke klafft. Die Laufzeit des Algorithmus mmAPD ist demnach O(mm(n) · log n),
40
3.2. Zweistufige Berechnung kürzester Wege
Algorithm 3.3 Distanzberechnung durch fortgesetzte Matrixmultiplikation
1: function mmAPD(W )
2: Ausgabe: Distanzmatrix
3:
D(1) ← W
4:
m←1
5:
while m < n − 1 do
6:
D(2m) ← MatMult(D(m) , D(m) )
7:
m ← 2m
8:
end while
9:
return D(m)
10: end function
wobei mm(n) die Zeit ist, um zwei n × n Matrizen miteinander zu multiplizieren. Es gibt
allerdings den Nachteil, dass die kürzesten Wege nicht gespeichert werden, auch nicht
implizit. Dazu wären alle Matrizen D1 , . . . , Dm notwendig. Außerdem würde die Laufzeit
auf O(mm(n) · n) ansteigen, was zur Zeit langsamer als Algorithmus 3.1 wäre.
Zu beachten ist in diesem Kontext auch, dass die schnellen Algorithmen zur Matrixmultiplikation nur auf Ringen operieren können. Zwar lässt sich die Multiplikation boolescher Matrizen (zu denen Adjazenzmatrizen ungewichteter Graphen gehören) durch
ganzzahlige Matrixmultiplikation realisieren. Dabei können allerdings ganzzahlige Matrizen entstehen, deren Einträge superlinear in n sind. In diesem Fall gelten die üblichen
Annahmen für die Laufzeitschranken nicht mehr [MR95]. Daher lassen sich schnelle Algorithmen zur Matrixmultiplikation nicht auf allgemeine Graphen anwenden, was natürlich
ein erheblicher Nachteil ist.
3.2. Zweistufige Berechnung kürzester Wege
Ein grundlegendes Szenario für Graphenberechnungen sind Distanzanfragen zwischen
zwei Knoten s und t. Solche Anfragen sind in vielen verschiedenen Anwendungsbereichen anzutreffen, beispielsweise in sozialen Netzwerken und bei Webseiten (Ähnlichkeiten
finden, soziale Suche) [AIY13]. Zudem haben wir bereits in Kapitel 2 gesehen, dass Distanzen und deren Berechnungen ein wichtige Thema der Netzwerkanalyse sind.
Betrachten wir ungewichtete Graphen. Hat man wenige Distanzanfragen, dann wird
man diese mit Breitensuchen zwischen den jeweiligen Knotenpaaren lösen. Falls die Anfragen (fast) alle Knotenpaare betreffen, erscheint die Lösung des APSP- bzw. APDProblems sinnvoll. Aber was macht man, wenn sowohl die Zahl als auch die Knotenpaare der Anfragen im Vorfeld unbekannt sind? Insbesondere bei sehr großen Graphen mit
Millionen von Knoten und Kanten?
Akiba et al. [AIY13] präsentieren einen Ansatz, der ein komplexes Netzwerk (ungewichtet, ungerichtet, zusammenhängend) der oben genannten Größenordnung innerhalb
weniger Minuten vorverarbeiten kann und dabei einen erträglichen Speicherverbrauch
aufweist. Anfragen können dann im Mikrosekundenbereich exakt beantwortet werden.
Diese schnelle Antwortzeit ist bei Anwendungen wichtig, die in Echtzeit mit dem Be-
41
3. Kürzeste Wege und globaler Zusammenhang
nutzer interagieren. In solchen Szenarien wären einzelne Breitensuchen oder DijkstraAufrufe schlicht zu langsam (da im Sekundenbereich für große Graphen). Die Darstellung
von Akiba et al.– an der wir uns orientieren – ist für ungewichtete und ungerichtete Graphen. Eine Erweiterung für gewichtete und gerichtete Graphen ist möglich; wir verzichten aus Gründen der einfacheren Darstellung hier aber darauf. Es sei der Vollständigkeit
halber erwähnt, dass es für Straßennetzwerke eine Reihe von alternativen zweistufigen
Verfahren gibt, die das Routing sehr effizient unterstützen [BDG+ 16] und für solche
Eingaben noch besser sind.
Die wesentliche Idee besteht darin, für jeden Knoten u ∈ V eine Distanzmarke (distance label ) L(u) zu erstellen. Die Distanzmarke L(u) ist dabei eine Menge von Paaren
(w, dist(u, w)) für alle sogenannten Drehkreuze (hubs) w von u (Menge C(u)). Diese
Drehkreuzmengen sollen nun so viele Knoten enthalten, dass für jedes Knotenpaar (s, t),
die Distanzanfrage auf folgende Weise gelöst werden kann:
Query(s, t, L) = min{dist(v, s) + dist(v, t) | (v, dist(v, s)) ∈ L(s), (v, dist(v, t)) ∈ L(t)}.
v∈V
Sollte es ein Paar (s, t) geben, für das L(s) und L(t) keinen gemeinsamen Knoten
haben, dann definieren wir die Antwort der Anfrage als unendlich. Andernfalls bezeichnen wir L als (Distanz-gewahre) 2-Sprung-Überdeckung, englisch (distance-aware) 2-hop
cover. Ähnlich zur Sprechweise im Datenbank-Bereich nennen wir die durch den Vorverarbeitungsschritt berechnete Überdeckung auch Index. In jeder Marke speichern wir
dabei die Knoten aufsteigend, so dass eine Anfrage ähnlich wie ein Algorithmus zum
Verschmelzen sortierter Listen in O(|L(s)| + |L(t)|) Zeit angewendet werden kann. Unser
Ziel bei der Vorverarbeitung muss demnach sein, einen möglichst kleinen (im Sinne der
Markengrößen) zu finden – und dies möglichst schnell.
3.2.1. Naiver Ansatz
Wenn in jeder Marke L(u) alle Knoten w ∈ V \ {u} gespeichert werden, ist dies offensichtlich eine 2-Sprung-Überdeckung. Dies lässt sich natürlich erreichen, indem wir
von jedem Knoten u ∈ V eine Breitensuche durchführen. Klar ist aber auch, dass dieser
Ansatz sowohl hinsichtlich seiner Laufzeit als auch seines Speicherverbrauchs ineffizient
ist. Um die eigentliche Methode einfacher erläutern zu können, starten wir trotzdem
zunächst mit diesem naiven Ansatz.
Die Grundidee ist also, von jedem Knoten v1 , . . . vn eine Breitensuche zu starten und
dabei die Marken zu füllen. Gestartet wird mit L0 (u) ← ∅ ∀u ∈ V . In Runde k, während
BF S(vk ), wird für einen Knoten u, der von vk erreicht wird, die Marke so aktualisiert:
Lk (u) ← Lk−1 (u) ∪ {(vk , dG (vk , u))}.
Wird u nicht von vk erreicht, behält man die alte Marke bei: Lk (u) ← Lk−1 (u). Nach
n Runden muss sich nach Konstruktion ergeben:
Query(s, t, Ln ) =
min
{distvs + distvt | (v, dist(v, s)) ∈ L(s), (v, dist(v, t)) ∈ L(t)}
v∈Ln (s)∩Ln (t)
(3.1)
42
3.2. Zweistufige Berechnung kürzester Wege
Abbildung 3.1.: Ungerichteter Beispiel-Graph, der die Breitensuche vom Knoten 1 aus
illustriert. Gerichtete Kanten geben lediglich den BFS-Ablauf wider.
Quelle: Akiba et al. [AIY13, S. 353]
= dist(s, t).
(3.2)
Beispiel 3.3. Betrachten wir den Graphen aus Abbildung 3.1. Einige der (partiellen)
Distanzmarken sehen folgendermaßen aus:
• Ln (1) = {(2, 2), (3, 2), (4, 1), . . . }
• Ln (6) = {(1, 1), (2, 3), (3, 3), . . . }
• Ln (11) = {(1, 2), (2, 2), (3, 1), . . . }
Aus Ln (6) ∩ Ln (11) = {(1, 3), (2, 5), (3, 4), . . . } (man beachte die Überladung von ∩ durch
Einbezug der Summe) ergibt sich dann beispielsweise:
Query(6, 11, Ln ) = dist(6, 11) = 1 + 2 = 3
über das Drehkreuz 1.
3.2.2. Markieren mit Beschränkung der Suche
Nun geht es darum, den obigen naiven Ansatz zu beschleunigen. Der einzige wesentliche
Unterschied wird sein, dass wir anstatt normaler Breitensuche beschränkte Breitensuchen
durchführen werden (Methode PrunedBFS. Wir starten wieder mit einem leeren Index
L00 und erzeugen L0k aus L0k−1 während des k-ten PrunedBFS-Aufrufes, welcher von vk
startet.
Die wesentliche Änderung in PrunedBFS(vk ), siehe Algorithmus 3.4, ist folgende
Abfrage während des Besuchs eines Knotens u: Falls Query(vk , u, L0k−1 ) kleiner oder
43
3. Kürzeste Wege und globaler Zusammenhang
Algorithm 3.4 BFS mit Suchbeschränkung zur Bestimmung der Distanzmarken
1: function PrunedBFS(G = (V, E), vk , L0k−1 )
2: Ausgabe: Distanzmarkierung L0k
3:
Q ← {vk }
4:
P [vk ] ← 0
5:
P [v] ← ∞ ∀v ∈ V \ {vk }
6:
L0k [v] ← L0k−1 [v] ∀v ∈ V
7:
while Q is not empty do
8:
u ← dequeue(Q)
9:
if Query(vk , u, L0k−1 ) > P [u] then
10:
L0k [u] ← L0k−1 [u] ∪ {(vk , P [vk ])}
11:
for all w ∈ NG (u) mit P [w] = ∞ do
12:
P [w] ← P [u] + 1
13:
enqueue(Q, w)
14:
end for
15:
end if
16:
end while
17:
return L0k
18: end function
Algorithm 3.5 Vorverarbeitung zur Konstruktion des Index L0
1: function Preprocess(G = (V, E))
2:
Ausgabe: Distanz-gewahre 2-Sprung-Überdeckung von G
3:
L00 [v] ← ∅ ∀v ∈ G
4:
for k = 1, 2, . . . , n do
5:
L0k ← PrunedBFS(G, vk , L0k−1 )
6:
end for
7:
return L0n
8: end function
gleich der Schätzdistanz P [u] ist, dann kennen wir bereits einen Weg zwischen vk und
u, der nicht länger ist. Somit wird vk nicht in die Marke von u eingetragen und u nicht
in die BFS-Warteschlange eingefügt.
Beispiel 3.4. Wenn man Algorithmus 3.5 auf den Graphen aus Beispiel 3.3 anwendet,
erhält man Abbildung 3.2:
Bleibt zu zeigen, dass Algorithmus 3.5 korrekt arbeitet und eine 2-Sprung-Überdeckung
zurückgibt:
Theorem 3.5. Für jedes 0 ≤ k ≤ n und jedes Paar von Knoten s und t gilt:
Query(s, t, L0k ) = Query(s, t, Lk ).
Beweis. Für den Induktionsanfang mit k = 0 gilt L00 = L0 und somit die Behauptung.
Wir setzen nun voraus, dass die Behauptung für alle 0, 1, . . . , k − 1 gilt und wollen vom
44
3.2. Zweistufige Berechnung kürzester Wege
Abbildung 3.2.: Ablauf der verschiedenen PrunedBFS-Aufrufe. Gelb: aktueller Wurzelknoten, blau: erreichter und dabei markierte Knoten, rot: erreichte
und dabei beschränkte Knoten, grau: bereits verwendete Wurzelknoten,
weiß: nicht erreichte Knoten. Quelle: Akiba et al. [AIY13, S. 353]
.
Fall k − 1 auf den Fall k schließen. Dabei verwenden wir auch die Notation δuv :=
dist(u, v).
Seien dazu s und t ein Paar von Knoten, die sich oBdA erreichen. Sei j die kleinste Zahl
derart, dass (vj , δvj ,s ) ∈ Lk (s), (vj , δvj ,t ) ∈ Lk (t) und δvj ,s + δvj ,t = Query(s, t, Lk ). Wir
beweisen, dass (vj , δvj ,s ) und (vj , δvj ,t ) auch in L0k (s) bzw. L0k (t) enthalten sind. Daraus
folgt direkt Query(s, t, L0k ) = Query(s, t, Lk ). Aus Symmetriegründen beweisen wir nur
(vj , δvj ,s ) ∈ L0k (s).
Für jedes i < j beweisen wir per Widerspruch, dass vi ∈
/ PG (vj , s). Nehmen wir das
Gegenteil an. Dann gilt:
Query(s, t, Lk ) = distG (s, vj ) + distG (vj , t)
(3.3)
= distG (s, vi ) + distG (vi , vj ) + distG (vj , t)
(3.4)
≥ distG (s, vi ) + distG (vi , t).
(3.5)
Weil dann (vi , distG (s, vi )) ∈ Lk (s) und (vi , distG (t, vi )) ∈ Lk (t) nach Annahme und
Konstruktion gelten muss, haben wir den Widerspruch zur Minimalität von j. Daraus
folgt vi ∈
/ PG (vj , s) für alle i < j.
Nun nutzen wir die obige Erkenntnis und beweisen, dass (vj , distG (vj , s)) ∈ L0k (s).
Genau genommen beweisen wir das allgemeinere Ergebnis (vj , distG (vj , u)) ∈ L0k (u) für
alle u ∈ PG (vj , s). Dabei gilt s ∈ PG (vj , s) offensichtlich. Nehmen wir oBdA an, dass
nun PrunedBFS(vj ) durchgeführt wird, um L0j zu erstellen. Sei u ∈ PG (vj , s). Da
PG (vj , u) ⊆ PG (vj , s) und vi ∈
/ PG (vj , s) für alle i < j, gilt vi ∈
/ PG (vj , u) für alle i < j.
Anders ausgedrückt: Kein Knoten vi mit i < j ist Teil eines kürzesten Weges zwischen vj
und u. Daraus folgt für Zeile 9 von Algorithmus 3.4: Query(vj , u, L0j−1 ) > distG (vj , u).
Folglich besuchen wir alle Knoten u ∈ PG (vj , s) (weil die Suche nicht beschränkt wird),
so dass gilt: (vj , distG (vj , u)) ∈ L0j (u) ⊆ L0k (u).
Indem man im Theorem k = n wählt, lässt sich folgern, dass die exakten Distanzen
berechnet werden:
45
3. Kürzeste Wege und globaler Zusammenhang
Folgerung 3.6. Für jedes Paar von Knoten s und t gilt:
Query(s, t, L0n ) = distG (s, t).
L0 liefert somit nicht nur korrekte Ergebnisse auf Anfragen. Es lässt sich außerdem
zeigen, dass wir mit L0 “keinen Speicher verschwenden”:
Theorem 3.7. L0n ist minimal im folgenden Sinn: Für jeden Knoten v und jedes Paar
(u, δuv ) ∈ L0n gibt es ein Paar von Knoten (s, t) derart, dass Query(s, t, L0n ) eine falsche
Antwort liefert, falls wir (u, δuv ) aus L0n entfernen.
Beweis. Präsenzübung.
Einige Implementierungsaspekte seien noch kurz erwähnt, da sie für die Performance
des Ansatzes durchaus wesentlich sind. Für Details verweisen wir allerdings aus Zeitgründen auf Akiba et al. [AIY13].
Zunächst ist die Reihenfolge der Abarbeitung der Knoten sehr wichtig. Neben einer zufälligen Reihenfolge experimentieren Akiba et al.auch mit einer approximierten
Closeness-Rangfolge sowie einer absteigenden Sortierung nach Knotengrad. Die beiden
letzten Strategien sind ungefähr gleich gut, die Sortierung nach Knotengrad aber schneller zu berechnen.
3.3. Das Phänomen der kleinen Welt und der Durchmesser
Vielleicht haben Sie schon mal von der Redewendung “six degrees of separation” oder
vom Phänomen der kleinen Welt gehört. Beide beziehen sich darauf, dass kürzeste Wege
in sozialen Netzwerken erstaunlich wenige Kanten haben. Graphentheoretisch spricht
man von einem kleinen Durchmesser:
Definition 3.8. Für einen Graphen G = (V, E) definieren wir:
eccG (v) = max {distG (v, w) : w ∈ V }
(Exzentrizität von v)
(3.6)
rad(G) = min {eccG (v) : v ∈ V }
(Radius von G)
(3.7)
diam(G) = max {eccG (v) : v ∈ V }
(Durchmesser von G)
(3.8)
Der Durchmesser ist also der längste kürzeste Weg im Graphen. In komplexen Netzwerken ist dieser kurz, weil es meist einige hochgradige Drehkreuze gibt, über die man “weit
springen” kann. Um diese lose Intuition zu schärfen, betrachten wir unser soziales Netzwerk SnappedIn und sein Freundschaftsnetzwerk. Betten wir dann das Freundschaftsnetzwerk gedanklich auf die Kugeloberfläche der Erde ein. Die meisten Verbindungen
zwischen Freunden werden lokal und daher von kurzer Länge sein. Aber manche Verbindungen können auch sehr lang sein und selbst Kontinente überbrücken. Letzteres gilt insbesondere für Drehkreuze, die meist sehr weit ausstrahlen. Dieses Gedankenexperiment
sollte verdeutlichen, warum gemäß “six degrees of separation” der Bekanntschaftsgraph
der Menschen auf der Erde nur einen Durchmesser von sechs haben soll (Anmerkung: Das
46
3.3. Das Phänomen der kleinen Welt und der Durchmesser
soziologische Experiment hatte einen Entwurfsfehler, der wohl zu einem zu kleinen Wert
geführt hat. Andererseits wissen wir von sozialen Online-Netzwerken, dass bei ihnen der
Durchmesser sogar noch kleiner ist. Die Online-Welt lässt uns näher zusammenrücken,
zumindest graphentheoretisch).
Wie berechnet man nun aber den Durchmesser? Ein naiver Ansatz, der zunächst alle
paarweisen Abstände berechnet und darüber das Maximum bildet, ist offensichtlich zu
langsam und wäre für SnappedIn mit hohen Nutzerzahlen nutzlos. Dies gälte auch für
ungewichtete Graphen und einem n-maligen Aufruf einer Breitensuche – ähnlich wie bei
Betweenness Centrality.
Man kann sich zu Nutzen machen, dass der Durchmesser komplexer Netzwerke klein
ist. Es gibt Heuristiken, die den exakten Durchmesser berechnen und dabei auf realen
Instanzen typischerweise sehr schnell sind. Die nicht-exakte Komponente dieser Heuristiken besteht darin, dass die Laufzeit im schlechtesten Fall O(nm) Rechenschritte beträgt
– und somit nicht besser ist als ein naiver Ansatz. Ein solches in der Praxis sehr erfolgreiches Verfahren von Crescenzi et al. [CGH+ 13a] für ungerichtete Graphen schauen wir
uns nun genauer an.
Sei nachfolgend G = (V, E) ein ungerichteter Graph und u ∈ V beliebig, aber fest.
Beobachtung 3.9. Sei Tu der BFS-Baum von G mit Wurzel u. Dann ist die Höhe von
Tu gleich ecc(u).
Des weiteren können wir feststellen:
Lemma 3.10. Für einen ungerichteten Graphen G = (V, E) und einen Knoten u ∈ V
gilt: eccG (u) ≤ diam(G) ≤ 2 eccG (u).
Der Beweis der beiden Schranken ist einfach und zur Übung empfohlen. Die Güte
dieser Schranken in Lemma 3.10 hängt natürlich stark vom gewählten Knoten u ab. Aus
den obigen Ergebnissen lässt sich bereits eine einfache algorithmische Methode ableiten.
Wenn man von einem geeigneten Knoten u aus einen BFS-Baum aufbaut, lässt sich die
Exzentrizität von u und somit eine obere Schranke für den Durchmesser leicht berechnen.
Wiederholungen für andere Wurzelknoten können die Schranken potentiell verbessern.
Letztlich ist dieses einfache Vorgehen noch nicht ausreichend für eine niedrige Laufzeit.
Es wird insbesondere darauf ankommen, (i) die Wurzelknoten geeignet zu wählen und
(ii) weitere Ergebnisse zu BFS-Bäumen und den Exzentrizitäten der enthaltenen Knoten herzuleiten und durch Annähern von unteren und oberen Schranken auszunutzen.
Starten wir mit einigen Definitionen und Beobachtungen.
Definition 3.11.
• Sei Ni (u) die Menge der Knoten auf Ebene i von Tu . (Anders ausgedrückt ist Ni (u)
die i-Sprung-Nachbarschaft von u.)
• Sei F (u) := Necc(u) (u). (Die Knoten von F (u) bilden die unterste Ebene von Tu .)
• Sei Bi (u) := maxz∈Ni (u) ecc(z) die maximale Exzentrizität der Knoten in Ni (u).
47
3. Kürzeste Wege und globaler Zusammenhang
Beispiel 3.12. Siehe zunächst Tafel...
Unser algorithmisches Ziel wird es sein, in Tu möglichst große Werte für ecc(x) für
Knoten x ∈ V zu finden. Damit wird dann eine untere Schranke für den Durchmesser
schrittweise verbessert.
Beobachtung 3.13. Für jedes x, y ∈ V mit x ∈ Ni (u) oder y ∈ Ni (u) gilt:
dist(x, y) ≤ Bi (u).
Dies folgt direkt aus dist(x, y) ≤ min{ecc(x), ecc(y)} ≤ Bi (u).
Lemma 3.14. Für alle 1 ≤ i, j ≤ ecc(u) und für alle x ∈ Ni (u), y ∈ Nj (u) gilt:
dist(x, y) ≤ i + j ≤ 2 max{i, j}.
Beweis. Dies folgt aus der Definition der Ni . Um von x nach y zu kommen, muss man
schlimmstenfalls i Schritte in Tu bis zur Wurzel laufen und von dort j Schritte bis y.
Interessant an Lemma 3.14 ist, dass wir daraus eine Abbruchbedingung für unseren
späteren Algorithmus in Form des nachfolgenden Theorems herleiten können. Etwas
weniger formal ausgedrückt, nehmen wir uns dabei eine Ebene i des Baumes Tu her,
die nicht die unterste ist. Dann gilt für jeden Knoten x, der oberhalb von Ebene i liegt
und für den ecc(x) > 2(i − 1) gilt, dass sein längster kürzester Weg zu einem Knoten yx
führt, der tiefer als x im Baum liegt und zwar in Ebene i oder tiefer:
Theorem 3.15. Seien 1 ≤ i < ecc(u) und 1 ≤ k < i beliebig. Für jedes x ∈ Ni−k (u)
mit ecc(x) > 2(i − 1) existiert ein yx ∈ Nj (u) mit j ≥ i derart, dass dist(x, yx ) = ecc(x).
Beweis. Seien i, k und x ∈ Ni−k (u) wie im Theorem. Aufgrund der Definition von ecc(·)
muss es einen Knoten yx mit dist(x, yx ) = ecc(x) > 2(i − 1) geben. Falls yx ∈ Nj (u)
mit j < i gälte, dann würde daraus und aus Lemma 3.14 folgen: dist(x, yx ) ≤ 2 max{i −
k, j} ≤ 2 max{i − k, i − 1} = 2(i − 1). Aus diesem Widerspruch folgt yx ∈ Nj (u) mit
j ≥ i.
Satz 3.16. Sei y ∈ Ni.. ecc(u) (u) := Ni (u) ∪ Ni+1 (u) ∪ · · · ∪ Necc(u) ein Knoten mit
maximaler Exzentrizität in dieser Menge und sei diese Exzentrizität ecc(y) > 2(i − 1).
Dann gilt für alle x ∈ N1..i−1 (u) := N1 (u) ∪ N2 (u) ∪ · · · ∪ Ni−1 (u):
ecc(x) ≤ ecc(y).
Beweis. Sei x ∈ N1..i−1 beliebig und yx ∈ Ni.. ecc(u) ein Knoten mit ecc(x) = dist(x, y)
– ein solcher Knoten existiert immer nach Theorem 3.15. Gemäß der Definition von
Exzentrizität muss dann ecc(yx ) ≥ ecc(x) = dist(x, yx ) gelten. Nach Konstruktion gilt
nun ecc(y) = Bi.. ecc(u) (u) und somit ecc(y) ≥ ecc(y 0 ) ∀y 0 ∈ Ni.. ecc(u) (u). Schließlich folgt
daraus:
ecc(y) ≥ ecc(x) ∀x ∈ N1..i−1 (u).
48
3.3. Das Phänomen der kleinen Welt und der Durchmesser
Dieses Ergebnis zeigt uns, dass wir einen BFS-Baum Tu bottom up traversieren sollten,
angefangen bei den Knoten von F (u). Auf jeder Ebene von Tu berechnen wir die Exzentrizitäten der Knoten dieser Ebene. Falls die maximale Exzentrizität c∗ größer als 2(i−1)
ist, dann können wir uns die Abarbeitung der höheren Ebenen sparen, weil die Exzentrizitäten der darin enthaltenen Knoten nicht größer sein können als c∗ . Algorithmisch
können wir somit für u grundsätzlich ableiten:
1. Initialisiere i ← ecc(u) und M ← Bi (u)
2. Falls M > 2(i − 1), dann gib M zurück. Andernfalls setze i ← i − 1, M ←
max{M, Bi (u)} und wiederhole diesen Schritt.
Beobachtung 3.17. Für den Durchmesser D von G und M := Bi (u) gilt:
• M ≤ D, da M eine Exzentrizität angibt;
• falls M ≤ 2(i − 1), dann D ≤ 2(i − 1).
Indem wir unsere obigen Resultate kombinieren, erhalten wir schließlich Algorithmus 3.6. Die grau gefärbten Teile sind dabei nicht notwendig, erleichtern aber bei Bedarf die Analyse. Die Schleife von Algorithmus 3.6 über i beschreibt die Bottom-upAbarbeitung, wobei i die aktuelle Ebene des Baumes indiziert. Wichtig ist noch der
Hinweis, dass Bi (u) durch BFS von jedem Knoten aus Ni (u) berechnet werden muss,
wenn keine zusätzlichen Informationen genutzt werden. Der Rest funktioniert gemäß der
obigen Überlegungen.
Satz 3.18. Algorithmus 3.6 führt höchstens D/2 Iterationen durch.
Beweis. Übungsaufgabe. Hinweis: Zeigen Sie zunächst, dass ub − lb in jeder Iteration um
mindestens 2 gesenkt wird. Dazu bietet sich eine Schleifeninvariante an.
Folgerung 3.19. Algorithmus 3.6 ruft BFS höchstens |ND/2.. ecc(u) (u)| mal auf.
Wie bereits angedeutet, ist die Wahl des Startknotens u wichtig. Für die Details dazu
und zu experimentellen Ergebnissen verweisen wir auf die Originalarbeit [CGH+ 13b].
Grob gesagt will man erreichen, dass ein möglichst flacher und oben dichter BFS-Baum
entsteht. Mit etwas Glück erreicht man dies bereits, indem man den Knoten mit höchstem
Knotengrad als u wählt. Etwas ausgeklügeltere Strategien basieren auf folgendem Ergebnis:
Satz 3.20. Sie T ein Spannbaum von G. Dann gilt:
diam(G) ≤ diam(T ).
(3.9)
Wenn v so gewählt wird, dass distT (u, v) = eccT (u) für einen Knoten u, dann gilt:
diam(T ) = eccT (v).
(3.10)
Übung 3.21. Beweisen Sie Satz 3.20!
49
3. Kürzeste Wege und globaler Zusammenhang
Algorithm 3.6 iFUB-Algorithmus
1: function iFUB(Graph G = (V, E), u ∈ V , untere Schranke l für Durchmesser D,
Fehlerschranke k ∈ N0 )
2: Ausgabe: Wert M mit D − M ≤ k
3:
Berechne Tu
4:
i ← ecc(u)
. ecc(u) ist Tiefe von Tu
5:
lb ← max{ecc(u), l)
. lower bound lb
6:
ub ← 2 ecc(u)
. upper bound ub
7:
while ub − lb > k do
8:
Berechne Bi (u)
. BFS von Knoten aus Ni (u)
9:
if max{lb, Bi (u)} > 2(i − 1) then
10:
return max{lb, Bi (u)}
11:
else
12:
lb ← max{lb, Bi (u)}
13:
ub ← 2(i − 1)
14:
i←i−1
. Ebene raufgehen in Tu
15:
end if
16:
end while
17:
return lb
18: end function
Mit bereits zwei BFS-Bäumen lässt sich wegen Satz 3.20 eine obere Schranke für D
finden. Gleichzeitig kann eccG (v) als untere Schranke lb für Algorithmus 3.6 dienen.
Diese Grundidee lässt sich weiter verfeinern, siehe Crescenzi et al. [CGH+ 13b] oder auch
Magnien et al. [MLH08]. Umfangreiche Experimente von Crescenzi et al. [CGH+ 13b]
zeigen, dass der exakte Durchmesser von Realwelt-Graphen oft mit einigen Dutzend oder
wenigen Hundert BFS-Aufrufen in iFub bestimmt werden kann. Andererseits lassen sich
natürlich auch Graphen konstruieren, für die der Algorithmus eine Laufzeit von O(nm)
hat, da eine in n lineare Anzahl von Breitensuchen erforderlich ist.
Übung 3.22. Berechnen Sie den Durchmesser von Graphen aus verschiedenen Klassen (Gitternetze aus Simulationen, Straßennetzwerke, Zitationsnetzwerke, Co-AutorenNetzwerke, Internet-Router-Graphen und Web-Graphen) mit NetworKit! Laden Sie diese Graphen aus dem Fundus der 10th DIMACS Implementation Challenge [BMS+ 14],
zu finden unter http: // www. cc. gatech. edu/ dimacs10/ downloads. shtml . Arbeiten Sie jeweils mit der größten Zusammenhangskomponente.
Diskutieren Sie Ihre Ergebnisse! Für welche Graphen zeigt sich das Phänomen der
kleinen Welt?
3.4. Zusammenhangskomponenten
Unser soziales Online-Netzwerk SnappedIn stellt im Profil jedes Benutzers dar, wie viele
Personen grundsätzlich erreicht werden können, d. h. wie viele andere Benutzer durch
50
3.4. Zusammenhangskomponenten
endlich viele Schritte im Freundschaftsgraphen besucht werden können. Graphentheoretisch sind dazu die Zusammenhangskomponenten (ZHK) und deren Größen zu bestimmen. Wir verweisen für die entsprechenden Definitionen von (starkem, schwachen)
Zusammenhang auf Kaptitel 1. Hier betrachten wir nur einige Beispiel-Graphen zur
Auffrischung (siehe Abbildung 3.3).
Abbildung 3.3.: Beispielgraphen mit verschiedenen Zusammenhangseigenschaften.
Starke Zusammenhangskomponenten (sZHK) in gerichteten Graphen sind demnach
maximale Teilgraphen, in denen jeder Knoten jeden anderen erreicht und von allen
anderen erreicht wird. Warum kann es wichtig sein, diese für SnappedIn oder einen
Web-Graphen zu berechnen? Nun, ein Nutzer von SnappedIn hat sicherlich ein Interesse
daran, möglichst viele andere Nutzer erreichen zu können bzw. von ihnen erreicht zu
werden. Falls er sich in einer kleinen sZHK befindet, möchte er sich womöglich schnell
“vergrößern”. Käme es da nicht gelegen, wenn SnappedIn ihm Personen als potentielle
neue Freunde vorschlägt, die aus einer großen sZHK stammen?
Weiterhin gibt es viele Graphenalgorithmen, die davon ausgehen, mit einem (stark)
zusammenhängenden Graphen zu arbeiten. Wir haben bspw. in Kapitel 2.1.4 bereits
festgestellt, dass man die Eigenvektor-Zentralität nur auf stark zusammenhängende Graphen anwenden sollte. Ein gängiger Weg um dieses Problem herum ist, dass man solche
Algorithmen auf jede (s)ZHK getrennt anwendet.
Komplexe Netzwerke zeichnen sich auch dadurch aus, dass sie zwar nicht unbedingt
zusammenhängend sind, aber meist eine besonders große ZHK haben, die sogenannte
giant component (GC). Bei Benchmark-Graphen kommt es daher nicht selten vor, dass
nur die größte ZHK des Original-Datensatzes verwendet wird. Da diese ZHK oft deutlich
mehr als 90% der Knoten beinhaltet, bleiben die mit der GC erzielten Ergebnisse auch
für die Original-Daten typischerweise gültig (das hängt aber natürlich vom Algorithmus
und den Daten ab).
Wie berechnen wir nun aber (s)ZHK schnell – um z. B. festzustellen, ob ein Knoten
51
3. Kürzeste Wege und globaler Zusammenhang
zur GC gehört oder nicht (in gewisser Hinsicht hat das auch etwas mit Zentralität zu
tun, ist aber ein sehr schlecht unterscheidendes Zentralitätsmaß).
Übung 3.23. (Präsenzübung) Angenommen, die Zeit, die man für die Multiplikation
zweier Boolescher n × n-Matrizen (also Matrizen, deren Einträge entweder 0 oder 1
sind) benötigt, ist BM (n). Sei weiterhin die transitive Hülle eines gerichteten Graphen
G = (V, E) definiert als
G∗ = (V, E ∗ ) mit E ∗ = {{i, j} : es gibt einen Weg von i nach j in G}.
Zeigen Sie, dass die transitive Hülle einer Booleschen n×n-Matrix in der Zeit O(BM (n))
berechnet werden kann. Tipp: Denken Sie an Zusammenhangskomponenten!
3.5. Weiterführende Literatur
52
4. Generierung von Graphen
Die Erzeugung von Graphen anhand generativer Modelle spielt eine zentrale Rolle bei
der Untersuchung komplexer Netzwerke. Dies hat eine Vielzahl von Gründen:
• Realwelt-Daten können vertrauliche Informationen beinhalten, so dass es aus Datenschutz-Erwägungen vorteilhaft ist, mit ähnlichen synthetischen Daten zu arbeiten.
• Bei der Algorithmen-Entwicklung benötigt man für kurze Tests mit ersten Prototypen kleine Testfälle. Auf der anderen Seite sollten Benchmark-Instanzen verschiedene Größen abdecken; insbesondere für Skalierbarkeits-Studien sind sogar
sehr, sehr große Instanzen erforderlich. Der Vorteil von geeigneten Graphgeneratoren ist, dass sie Graphen mit (statistisch) ähnlicher Verbindungsstruktur, aber
unterschiedlicher Größe erzeugen können.
• Weiterhin können Generatoren bei der Weitergabe von Benchmark-Daten nützlich
sein: Statt Giga- oder Terabytes von generierten Daten über schmalbandige Verbindungen senden zu müssen, reichen auch wenige Kilo- oder Megabytes an Code
für den Generator und die geeigneten Parameter für die gewünschten Instanzen.
• Schließlich sind generative Modelle auch aus theoretischer Sicht interessant, weil sie
unser Verständnis dafür schärfen, wie sich reale Netzwerke über die Zeit entwickeln.
Wir werden uns in diesem Kapitel mit einer Reihe verschiedener Modelle befassen.
Algorithmen für die effiziente Erzeugung der zugehörigen Graphen steht dabei im Vordergrund. Aber wir werden auch verschiedene Eigenschaften der Modelle unter die Lupe
nehmen und mit den Eigenschaften realer komplexer Netzwerke vergleichen.
4.1. Exakte Generierung von Gradfolgen
Stellen Sie sich vor, Sie müssten einen Graphen aus Datenschutz-Gründen verfremden.
Andererseits soll der verfremdete Graph wichtige Eigenschaften des Originals (weitgehend) erhalten. Wir haben im Verlauf der Vorlesung bereits mehrfach gesehen, dass die
Gradverteilung eines Graphen eine wichtige Eigenschaft ist. Wie generieren wir daher
(zunächst) Graphen, die eine vorgegebene Gradfolge, zum Beispiel eine mit Power-law Verteilung, erfüllen? Hier helfen uns Ergebnisse von Havel und Hakimi:
Theorem 4.1 (Havel 1955; Hakimi 1962). Eine Folge d1 ≥ · · · ≥ dn ist genau dann
Gradfolge eines schlichten ungerichteten Graphen, wenn auch die Folge d2 −1, . . . , dd1 +1 −
1, dd1 +2 , . . . , dn Gradfolge eines solchen Graphen ist.
Beweis. (Präsenz)Übung.
53
4. Generierung von Graphen
Algorithm 4.1 Algorithmus von Havel und Hakimi
1: function HavelHakimi(D = (d1 , . . . , dn ))
2:
Eingabe: Realisierbare Gradfolge D
3:
Ausgabe: Graph mit Gradfolge D
4:
V ← {v1 , . . . , vn }
5:
E←∅
6:
Li = (di , i) ∀i ∈ [n]
7:
while G = (V, E) erfüllt D nicht do
8:
Stell sicher, dass L absteigend gemäß der ersten Komponente sortiert ist
9:
Verbinde L1 .second in E mit den nächsten L1 .f irst Knoten in L
10:
Li .f irst ← Li .f irst − 1 ∀i ∈ {2, . . . , L1 .f irst + 1}
11:
Entferne L1 aus L
12:
end while
13:
return G = (V, E)
14: end function
Theorem 4.1 führt uns bereits in die Richtung eines Algorithmus. Dieser Weg wird
vom folgenden Lemma weiter konkretisiert:
Lemma 4.2. Zu einer Folge D = (d1 , . . . , dn ) mit d1 ≥ · · · ≥ dn sei GD die Menge aller
schlichten ungerichteten Graphen mit Knoten {v1 , . . . , vn }, in denen vi den Grad di hat.
Falls GD nicht leer ist, dann enthält GD einen Graphen mit N (v1 ) = {v2 , . . . , vd1 +1 }.
Es gibt somit einen Graphen, der eine für uns günstige Nummerierung der Knoten
hat. Daraus lässt sich nun Algorithmus 4.1 entwickeln. Beachten Sie, dass der angegebene
Pseudocode recht abstrakt gehalten ist. Insbesondere ist es in Zeile 8 nicht nötig, explizit
zu sortieren. In der Tat lässt sich der Algorithmus mit einer geeigneten Datenstruktur
sehr effizient ausführen:
Theorem 4.3. Der Algorithmus von Havel und Hakimi ist korrekt und lässt sich so
implementieren, dass er Laufzeit O(m) hat.
Beweis. Übung.
Spätestens jetzt sollten wir uns dazu aber auch überlegen, welche Gradfolgen überhaupt
realisierbar sind, d. h. ob man daraus tatsächlich einen gültigen Graphen konstruieren
kann:
Theorem 4.4 (Satz von Erdös und Gallai). Eine Partition d1 ≥ · · · ≥ dn > 0 einer
natürlichen Zahl ist genau dann die Gradfolge eines schlichten ungerichteten Graphen,
wenn
n
X
di ≡ 0 mod 2
(4.1)
i=1
und für alle j ∈ [n] gilt:
j
X
i=1
54
di ≤ j(j − 1) +
n
X
i=j+1
min{di , j}.
(4.2)
4.1. Exakte Generierung von Gradfolgen
Beweis. “⇒”: Sei G = (V, E) ein Graph mit der Gradfolge D. Dann können wir eine be:= V \ U betrachten.
liebige Teilmenge U ⊆ V mit |U | =: j und ihr Komplement U P
Mit einem Blick auf U sieht man ein, dass es nun mindestens v∈U (d(v) − (j − 1))
Kanten zwischen U und U geben muss. Denn jeder Knoten aus U kann mit
höchstens j − 1 anderen Knoten aus U verbunden
sein. Weiterhin zeigt uns ein
P
Blick auf die Knoten aus U , dass es höchstens v∈U min{d(v), j} Kanten zwischen
U und U geben kann. Im Spezialfall U = {v1 , . . . , vj } liefert dieses Argument die
notwendigerweise geltende Abschätzung.
“⇐”: Der Rest des Beweises ist konstruktiv, d. h. wir geben ein Verfahren an, mit dem
wir aus einer geeigneten Partition einen Graphen erstellen. Dazu definieren wir:
Definition 4.5 (Teilrealisierung). Eine Teilrealisierung einer nichtaufsteigenden
Folge (d1 , . . . , dn ) sei ein Graph mit Knotenmenge {v1 , . . . , vn } derart, dass deg(vi ) ≤
di für alle 1 ≤ i ≤ n.
Wenn nun eine Folge (d1 , . . . , dn ) mit gerader Summe gegeben ist, die Ungleichung (4.2) erfüllt, dann konstruieren wir eine Realisierung durch sukzessive Teilrealisierungen. Initial habe dabei die Teilrealisierung n Knoten und keine Kanten.
In einer Teilrealisierung ist der kritische Index r der größte Index, so dass deg(vi ) =
di für alle 1 ≤ i < r. Initial gilt r = 1, falls die Liste nicht überall 0 ist und wir
ohnehin fertig wären. Solange r ≤ n gilt, erhalten wir durch unser Vorgehen eine
neue Teilrealisierung mit kleinerem Defizit dr − deg(vr ) am Knoten vr , ohne den
Grad eines Knotens vi mit i < r zu ändern. Der Prozess stoppt erst, wenn die
Teilrealisierung eine Realisierung von D ist.
Sei S = {vr+1 , . . . , vn }. Wir halten die Bedingung aufrecht, dass S eine unabhängige
Menge ist, was anfangs offensichtlich erfüllt ist. Wir schreiben vi ↔ vj , falls
{vi , vj } ∈ E(G), sonst vi = vj .
Fall 0: vr = vi für einen Knoten vi mit deg(vi ) < di : Füge Kante {vi , vr } hinzu.
Fall 1: vr = vi für ein i mit i < r: Da deg(vi ) = di ≥ dr > deg(vr ), gibt es ein
u ∈ N (vi ) \ N (vr ). (a) Falls dr − deg(vr ) ≥ 2, dann ersetze {u, vi } mit {u, vr }
und {vi , vr }. (b) Falls
P dr − deg(v
P r ) = 1, dann gibt es einen Index k > r mit
deg(vk ) < dk , weil ni=r di − deg(vi ) gerade ist. (b1) Falls vr = vk , wendet
man Fall 0 an. (b2) Andernfalls ersetzt man {vr , vk } und {u, vi } durch {u, vr }
und {vi , vr }.
Fall 2: v1 , . . . , vr−1 ∈ N (vr ) und deg(vk ) 6= min{r, dk } für ein k > r: In einer Teilrealisierung gilt deg(vk ) ≤ dk . Da S unabhängig ist, gilt deg(vk ) ≤ r (|S| = r)
und somit deg(vk ) < min{r, dk }. (a) Falls vk = vr gilt, führen wir Fall 0
aus. (b) Falls jedoch vk ↔ vr , dann gilt: Weil auch deg(vk ) < r, gibt es ein
i < r mit vk = vi (vk hat maximalen Grad r − 1, wobei eine Kante zu vr
geht und kann deshalb nicht mit allen Knoten v1 , . . . , vr−1 verbunden sein).
Weil deg(vi ) > deg(vr ), existiert ein u ∈ N (vi ) \ N (vr ). Ersetze {u, vi } durch
{u, vr } und {vi , vk }.
55
4. Generierung von Graphen
Fall 3: v1 , . . . , vr−1 ∈ N (vr ) und vi = vj für ein i und j mit i < j < r: Übung 4.6!
Falls keiner der Fälle 0 bis 3 gilt, sind v1 , . . . vr paarweise
Pr adjazent und deg(vk ) =
min{r,
d
}
für
alle
k
>
r.
Da
S
unabhängig
ist,
gilt
k
Pn
Pr i=1 deg(vi ) = r(r − 1) +
min{r,
d
}.
Wegen
Ungleichung
(4.2)
ist
k
k=r+1
i=1 di beschränkt durch die
rechte Seite. Also haben wir das Defizit am Knoten vr beseitigt und setzen mit
dem nächsten kritischen Index fort.
Übung 4.6. Beweisen Sie Fall 3 von Theorem 4.4!
4.2. Erdős-Rényi-Modell
Bei unserer Betrachtung von Zufallsgraphen starten wir mit einem sehr gut untersuchten,
da vergleichsweise altem Modell. Genau genommen handelt es sich um zwei Modelle, die
häufig (wenn auch nicht ganz korrekt) als Erdős-Rényi -Modelle bezeichnet werden. Beide
Modelle generieren schlichte, ungerichtete, statische Graphen.
• Ein Graph des Modells G(n, m) hat n Knoten und m zufällig, unabhängig und
gleichverteilt gezogene Kanten zwischen Knotenpaaren. Eine andere Sichtweise ist,
dass man einen Graphen zufällig und gleichverteilt aus der Menge aller Graphen
mit n Knoten und m Kanten zieht.
• Ein Graph des Modells G(n, p) besteht aus n Knoten. p gibt für jede mögliche Kante zwischen einem Knotenpaar die Wahrscheinlichkeit an, ob diese Kante existiert
oder nicht. G(n, p) ist häufig leichter zu analysieren als G(n, m).
Abbildung 4.1.: Erdős-Rényi-Graphen des Modells G(20, p) mit unterschiedlichen
Wahrscheinlichkeiten p. Quelle: http://epress.anu.edu.au/cs/
chap5Newth-final-5.jpg.
56
4.2. Erdős-Rényi-Modell
4.2.1. Grundlegende Eigenschaften von G(n, p)-Graphen
Betrachten wir zunächst einige grundlegende Eigenschaften des G(n, p)-Modells. Man
kann sich dazu den Prozess der Erzeugung eines solchen Graphen als n2 -faches BernoulliExperiment mit Erfolgswahrscheinlichkeit p vorstellen. Dabei wandert man das obere
Dreieck der Adjazenzmatrix des Graphen entlang und führt bei jedem Eintrag ein solches Bernoulli-Experiment durch. Im Erfolgsfall wird eine 1 eingetragen für die erzeugte
Kante, sonst eine 0. In Übung 4.8 werden wir ausarbeiten, wie die Generierung effizienter
(O(m) statt O(n2 )) durchgeführt werden kann.
• Die Zahl der erwarteten Kanten ist E[m] =
n
2
· p.
• Der erwartete Durchschnittsgrad des Graphen ist 2m/n = (n − 1)p.
n
• Jeder Graph G mit m Kanten tritt mit Wahrscheinlichkeit P(G) = pm (1 − p)( 2 )−m
auf. Um dies einzusehen, muss man sich nur den oben erwähnten Erzeugungsprozess vor Augen führen: m mal trat Erfolg auf, in den übrigen Versuchen Misserfolg.
Grundsätzlich können wir feststellen (ohne dies im Detail auszuführen), dass viele
Eigenschaften des Modells um den Mittelwert konzentriert sind. Dies gilt auch für die
Gradverteilung, die wir nun genauer betrachten. Die Wahrscheinlichkeit, zu bestimmten
k anderen Knoten verbunden zu sein und zu den anderen n − 1 − k nicht, ergibt sich zu
pk (1 − p)n−1−k . Die k anderen Knoten, zu denen eine Verbindung besteht, können auf
n−1
Arten gewählt werden. Also ist die Wahrscheinlichkeit dass ein Knoten zu genau
k
k anderen adjazent ist:
n−1 k
pk =
p (1 − p)n−1−k ,
(4.3)
k
was eine Binomialverteilung darstellt. Diese unterscheidet sich sehr deutlich von den
endlastigen Verteilungen, die wir im Kapitel 2 als typische Gradverteilung vieler realer
Netzwerktypen kennengelernt haben.
Zudem hatten wir bereits festgestellt, dass reale Netzwerke häufig einen konstanten
Durchschnittsgrad c aufweisen – zumindest wächst er typischerweise nicht mit n. Das
bedeutetet wiederum, dass p = c/(n − 1) bei großem n sehr klein wird für konstantes
k
n−1−k
c. Unter der Annahme p → 0 bei n → ∞ wird die Gradverteilung n−1
k p (1 − p)
poissonsch:
ln((1 − p)n−1−k ) = (n − 1 − k) ln(1 −
≈ −(n − 1 − k)
c
)
n−1
c
≈ −c
n−1
Demnach gilt (1 − p)n−1−k = e−c für n → ∞ sowie (ebenfalls für n → ∞)
n−1
(n − 1)!
(n − 1)k
=
≈
.
k
(n − 1 − k)!k!
k!
57
4. Generierung von Graphen
Daraus können wir schließlich folgern:
(n − 1)k k −c (n − 1)k
pk ≈
p e =
k!
k!
c
n−1
k
e−c = e−c ·
ck
.
k!
Zwar gilt dieses Ergebnis nur unter unseren getätigten Annahmen. Aber wir hatten ja
bereits argumentiert, dass diese durchaus realistisch sind – in dem Sinn, dass sie für viele
reale Netzwerktypen gelten.
In Kapitel 2 hatten wir auch festgestellt, dass zumindest soziale Netzwerke einen
hohen globalen Cluster-Koeffizienten C aufweisen. Auch dies gilt nicht für Erdős-RényiGraphen, denn C gibt die Wahrscheinlichkeit an, dass zwei Nachbarn eines Knotens auch
benachbart sind. Zwischen jedem Knotenpaar existiert aber unabhängig vom konkreten
Paar eine Kante mit Wahrscheinlichkeit p = c/(n − 1). Daraus folgt
E[C] = c/(n − 1),
was für große n und konstantes c gegen 0 geht. Insofern muss man konstatieren, dass
selbst so grundlegende Eigenschaften wie Gradverteilung und Clusterkoeffizient stark
von vielen realen Eingaben abweichen. Nichtsdestotrotz sind Erdős-Rényi-Graphen ein
interessantes Forschungsobjekt; viele grundlegende Ergebnisse zu Netzwerkeigenschaften
wurden zuerst für Erdős-Rényi-Graphen gezeigt.
4.2.2. Phasenübergang bzgl. der Zusammenhangskomponenten
In Kapitel 3.4 hatten wir festgestellt, dass komplexe Netzwerke oft eine einzige sehr große
Zusammenhangskomponente besitzen. Da ist die Frage nur natürlich, wie sich diese Eigenschaft bei Erdős-Rényi-Graphen darstellt, wenn man p variiert. Klar ist, dass wir
bei p = 0 n isolierte Knoten, also Zusammenhangskomponenten der Größe 1 erhalten.
Bei p = 1 wiederum erhalten wir einen vollständigen Graphen und somit eine Zusammenhangskomponente der Größe n. Hier zeigt sich ein ganz wesentlicher qualitativer
Unterschied: in beiden Fällen ergeben sich die Extreme, einerseits konstant, andererseits
linear von n abhängig.
Komplexe Systeme zeichnen sich oft durch nichtlineares Verhalten aus. Dies äußert sich
beispielsweise darin, dass kleine Parameteränderungen sehr große Effekte haben. Dieses
Phänomen bezeichnet man auch als Phasenübergang, d. h. das System geht ruckartig von
einer Phase (= Zustand) in eine andere über. Wir werden dieses Phänomen für ErdősRényi-Graphen und die Größe ihrer Zusammenhangskomponente betrachten, da dies ein
sehr zentrales Resultat in diesem Bereich darstellt:
Theorem 4.7 (Erdős-Rényi). Die Funktion t(n) = ln n/n ist eine Grenzfunktion für
den Zusammenhang in einem Zufallsgraphen der Art G(n, t(n)).
In anderen Worten bedeutet das Theorem, dass kleinere Wahrscheinlichkeiten als t(n)
fast immer zu unzusammenhängenden Graphen führen, wohingegen größere Wahrscheinlichkeiten fast immer eine große Zusammenhangskomponente ergeben.
58
4.2. Erdős-Rényi-Modell
Vor dem für dieses Skript vergleichsweise langen Beweis, der auf Jacksons Darstellung [Jac08, Kapitel 4.2] (adaptiert von Bollobás) beruht, geben wir eine grobe Übersicht.
Zunächst beruht der Beweis auf der Tatsache, dass die Grenzfunktion t(n) nicht nur für
den Zusammenhang gilt, sondern auch für die Existenz isolierter Knoten. Um dies einzusehen, stellen wir fest, dass die Wahrscheinlichkeit, dass ein bestimmter Knoten isoliert
ist, (1−p)n−1 ist. Für große n ist dies ungefähr (1−p)n . Liegt p nahe am Grenzwert ln n/n,
so konvergiert p/n ≈ ln n/n2 gegen 0. Daraus ergibt sich für die Wahrscheinlichkeit, dass
ein bestimmter Knoten isoliert ist, (1 − p)n = e−np beträgt, denn limn→∞ (1 − na )n = e−a .
Am Grenzwert ergibt sich
e−n
ln n
n
= 1/n
(4.4)
für diese Wahrscheinlichkeit.
Im ersten Beweisteil wählen wir p dann kleiner als den Grenzwert. Dort zeigen wir, dass
die Wahrscheinlichkeit für einen isolierten Knoten gegen 1 strebt. Im zweiten Beweisteil
wählen wir p größer. Dort zeigen wir dann, dass es mit hoher Wahrscheinlichkeit keine
Zusammenhangskomponenten mit weniger als n/2 Knoten gibt.
Beweis. (von Theorem 4.7 Wir zeigen zunächst: Falls p/(ln n/n) → 0, dann geht die
Wahrscheinlichkeit für die Existenz isolierter Knoten gegen 1. Nach unserer Vorüberlegung
wissen wir bereits: P(gegebener Knoten ist isoliert) → e−pn . Um die Abhängigkeit von
p von n auszudrücken, schreiben wir nachfolgend
p := p(n) =
ln n − f (n)
,
n
wobei in diesem Beweisteil f (n) → ∞ und f (n) < ln n gelten. Dann wird aus e−pn
(durch die Wahl von p)
ef (n)
,
n
woraus folgt, dass die erwartete Anzahl isolierter Knoten ef (n) gegen ∞ strebt.
Dass die Zahl isolierter Knoten divergiert, beweist allerdings noch nicht, dass P(es gibt
einen isolierten Knoten) gegen 1 strebt. Um dies zu zeigen, sei X die Zahl der isolierten
Knoten und eine Zufallsvariable mit Mittelwert µ und Streuung σ. Unsere Behauptung
gilt, wenn für die Varianz von X, E[X 2 ] − E[X]2 , gilt:
E[X 2 ] − E[X]2 ≤ 2µ = 2E[X].
(4.5)
Insbesondere gilt dann wegen der Chebyshev-Ungleichung (Definition A.7): P(X <
√
µ − r 2µ) < 1/r2 . Dies folgt aus der Tatsache, dass σ die Wurzel der Varianz ist. Vor
allem folgt daraus aber wiederum wegen µ → ∞, dass die Wahrscheinlichkeit für ein
divergierendes X gegen 1 strebt.
Um die obere Schranke (4.5) zu zeigen, machen wir uns zunächst klar, dass E(X(X−1))
die erwartete Zahl geordneter Paare von isolierten Knoten ist. Diese ist nach Vorüberlegung
n(n − 1)(1 − p)2n−3 , weil jedes Knotenpaar von allen anderen Knoten isoliert ist, falls
59
4. Generierung von Graphen
keine der 2(n − 2) möglichen Kanten zu den übrigen Knoten vorhanden ist sowie auch
nicht die Kante zwischen den beiden betrachteten Knoten. Somit gilt:
E[X 2 ] − E[X]2 = E[X 2 − X] + E[X] − E[X]2
= n(n − 1)(1 − p)
2n−3
(4.6)
2
+ E[X] − E[X]
= n(n − 1)(1 − p)2n−3 + E[X] − n2 (1 − p)2n−2
2
≤ E[X] + pn (1 − p)
2n−3
(4.7)
(4.8)
(4.9)
(4.4)
= E[X](1 + p(1 − p))
(4.10)
≤ 2E[X].
(4.11)
Um zu zeigen, dass t(n) = ln n/n die Grenzfunktion für die Existenz isolierter Knoten
ist, müssen wir noch beweisen, dass die Wahrscheinlichkeit isolierter Knoten gegen 0
geht, wenn p(n)/t(n) → ∞. Es reicht dabei, dies für p(n) = ln n + f (n) mit f (n) → ∞
(aber f (n)/n → 0) zu zeigen. Ähnlich wie zuvor schließen wir, dass die erwartete Anzahl
isolierter Knoten gegen e−f (n) und somit nun gegen 0 geht. Die Wahrscheinlichkeit, dass
X mindestens 1 ist, muss dann auch gegen 0 gehen für E[X] → 0.
Um den Beweis abzuschließen, müssen wir noch zeigen, dass auch die Wahrscheinlichkeit für Zusammenhangskomponenten der Größen 2 bis n/2 gegen 0 geht für p(n)/t(n) →
(n)
,
∞. Sei dazu X k die Zahl der Komponenten mit Größe k. Sei weiterhin p(n) = ln n+f
n
Pn/2 k
wobei f (n) → ∞ und f (n)/n → 0. Es genügt zu zeigen, dass E[ k=2 X ] → 0:
E[
n/2
X
k=2
n/2 X
n
(1 − p)k(n−k) (Sei nun n := dn3/4 e.)
X ]≤
k
k
(4.12)
k=2
n/2 n X
X
n
n
k(n−k)
=
(1 − p)k(n−k)
(1 − p)
+
k
k
(4.13)
≤
(4.14)
k=2
k=n+1
n X
k=2
≤
n
X
e
n/2 X
en k −knp/2
en k −knp k2 p
e
e +
e
k
k
k=n+1
k(1−f (n)) −k 2k2 ln n/n
k
e
k=2
n/2 X
en k −knp/2
+
e
k
(4.15)
k=n+1
3/4 /5
≤ 3e−f (n) + n−n
→0
(4.16)
In der nachfolgenden Tabelle 4.1 ist noch einmal in der Übersicht dargestellt, welchen
Einfluss die Wahl der Kantenwahrscheinlichkeit p auf die Zahl der Zusammenhangskomponenten hat.
60
4.3. Barabási-Albert-Modell
Tabelle 4.1.: Einfluss von p bzw. np auf die erwartete Zahl und Größe der Zusammenhangskomponenten eines Graphen des G(n, p)-Modells
np < 1
np = 1
np → c > 1
np > (1 + ε) ln n
fast nie ZHK, die größer als O(log n) ist
fast immer eine ZHK, die größer als O(log n) ist
fast immer eine eindeutige riesige ZHK, keine andere
ZHK enthält mehr als O(log n) Knoten mhW
fast immer zusammenhängend (ε > 0)
4.2.3. Effiziente Generierung von Erdős-Rényi-Graphen
Übung 4.8. (Präsenzübung) Entwickeln Sie einen Algorithmus mit Laufzeit O(m) zur
Generierung von Graphen des G(n, p)-Modells!
Den zugehörigen NetworKit-Quellcode finden Sie im cpp-Verzeichnis generators; die
Klasse heißt ErdosRenyiGenerator.
4.3. Barabási-Albert-Modell
Übung 4.9. Entwerfen Sie einen effizienten sequentiellen Algorithmus zur Generierung von Barabási-Albert-Graphen mit n Knoten und Knotengrad c eines “neuen” Knotens! Beschreiben Sie die Idee, setzen diese in Pseudocode um und argumentieren Sie
dann, dass die Laufzeit O(cn) = O(m) eingehalten wird! Schauen Sie erst danach in den
NetworKit-Quellcode.
Tipp: Überlegen Sie sich zunächst, wie Sie auf einfache Weise einen Knoten derart
zufällig ziehen können, dass die Wahrscheinlichkeit vom Knotengrad abhängt.
Den zugehörigen NetworKit-Quellcode finden Sie im cpp-Verzeichnis generators; die
Klasse heißt BarabasiAlbertGenerator.
4.4. Chung-Lu-Modell
Den zugehörigen NetworKit-Quellcode finden Sie im cpp-Verzeichnis generators; die
Klasse heißt ChungLuGenerator.
4.5. Rekursives Matrix-Modell (R-MAT)
Den zugehörigen NetworKit-Quellcode finden Sie im cpp-Verzeichnis generators; die
Klasse heißt RmatGenerator.
4.6. Zufallsgraphen mit hyperbolischer Geometrie (RHG)
Den zugehörigen NetworKit-Quellcode finden Sie im cpp-Verzeichnis generators; die
Klasse heißt HyperbolicGenerator.
61
4. Generierung von Graphen
Übung 4.10. Generieren Sie Graphen gleicher Größe (sei n = 4096) gemäß der Modelle
R-MAT, Barabási-Albert, Erdős-Rényiund RHG (hyperbolische Graphen)! Diskutieren
Sie die resultierenden Graphen:
• Wenden Sie das Profiling-Tool von NetworKit an, um statistische Übersichten zu
den Graphen zu erhalten.
• Um zufällige Verzerrungen auszugleichen, sollten Sie die Generierung mehrmals
wiederholen. Vergleichen Sie dann die Profile der verschiedenen Modelle!
• Was fällt besonders auf ? Wo werden asymptotische Aussagen bestätigt, wo nicht?
4.7. LFR und ReCon
Mit Hilfe eines LFR-Generators kann man Graphen erzeugen, die eine festgelegte Community-Struktur haben. Dies wird insbesondere im Kontext des nachfolgenden Kapitels 5
wichtig, um die dort vorgestellten Clustering-Algorithmen zu testen. LFR steht für die
drei Autoren Lancichinetti, Fortunato und Radicchi [LFR08].
Durch einige Erweiterungen von LFR lässt sich ein Generator erzeugen, der ein bestehendes Netzwerk Go hernimmt und ein größeres neues Gn erzeugt, das statistisch
gesehen wesentliche Eigenschaften von Go erhält – abgesehen natürlich von Eigenschaften, die direkt von der Größe abhängen. Insbesondere handelt es sich um Verteilungen
von Maßen, die wir im Rahmen der Vorlesung bereits kennengelernt haben. Auf diese
Weise lassen sich aussagekräftige Benchmark-Graphen von fast beliebiger Größe erstellen
– wichtig für Skalierungstests. Eine detailliertere Beschreibung dieses noch recht neuen
Generators namens ReCon muss aus Zeitgründen leider entfallen; wir verweisen auf die
Originalarbeit von Staudt et al. [SHS+ 16].
Den zugehörigen NetworKit-Quellcode finden Sie im cpp-Verzeichnis generators; die
Klasse heißt für beide Einsatzzwecke (d. h. auch für ReCon) LFRGenerator.
4.8. Weiterführende Literatur
62
5. Clusteranalyse
Irregulär strukturierte Daten, die sich als Graph bzw. Netzwerk darstellen lassen, finden
sich in immer mehr Anwendungen. Die Datenmengen, die sich dabei ergeben, sind in
den letzten Jahren rasant angestiegen. Es stellt sich somit aus algorithmischer Sicht die
Frage, wie man mit diesen sehr großen Datenmengen umgehen kann.
Ein Ansatz kann dabei sein, einen teuren Algorithmus nicht auf den ganzen Graphen
anzuwenden, sondern nur auf relevante Teile. Was dabei ,,relevant” ist, hängt natürlich
vom konkreten Problem bzw. der konkreten Anwendung ab. Aber zumindest kann es
sinnvoll sein, in einem Durchgang Teilgraphen zu betrachten, in denen sich die Knoten
in gewisser Weise ähnlich sind. Diese Ähnlichkeit kann etwa darin bestehen, dass diese
Knoten einen hohen Grad an Zusammenhang aufweisen (was wir gleich noch formalisieren müssen).
Zugleich kann es für einen Analysten auch aus ganz anderen Gründen interessant sein
zu erfahren, wie ein Netzwerk in natürliche Gruppen zerfällt. Im sozialen Kontext lässt
sich daraus mglw. ableiten, welche Effekte bei der Bildung von Gruppen eine wichtige
Rolle spielen. Aus der sozialen Netzwerkanalyse hat sich daher der Begriff community detection für das Graphclustering entwickelt. Teilweise unterscheidet die Literatur
die beiden Begriffe – je nach wissenschaftlichem Feld. Wir verwenden die Begriffe hier
synonym.
Was die beste oder wenigstens eine gute Clusterung ist, kann sich deutlich von Problem zu Problem unterscheiden. Als Algorithmiker wollen wir aber natürlich Methoden entwickeln, die vielseitig und ohne großes Zutun eines Benutzers verwendbar sind.
Grundsätzlich versucht man bei der Clusteranalyse zu erreichen, dass die Objekte desselben Clusters sich ähnlich sind und Objekte verschiedener Cluster sich unähnlich sind.
Ein vielfach genutztes Prinzip für das Clustern von Graphen ist daher das Paradigma,
dass Cluster intern dicht sein und nach außen nur wenige Verbindungen haben sollen
(engl. intra-dense vs inter-sparse paradigm). Somit sollen Clustergrenzen möglichst wenige Kanten schneiden. Anders ausgedrückt sollen zwischen Knoten desselben Clusters
viele Wege kurzer Länge verlaufen, zwischen Knoten verschiedener Cluster aber nur
wenige solcher Wege.
Um auf algorithmischem Wege zu einer guten Clusterung zu kommen, formalisiert
man die obige abstrakte Vorstellung mit einer Zielfunktion. Dabei ist es auch wichtig zu
beachten, dass die Cluster nicht völlig unterschiedliche Größe haben. Denn wenn man
nur die Schnittgröße (also die Zahl der Kanten zwischen verschiedenen Clustern) ohne
jegliches Balancekriterium berücksichtigen würde, wäre das Abschneiden der Knoten mit
geringstem Grad immer optimal. Manche Zielfunktionen nehmen daher ein Balancekriterium explizit auf (wie etwa der normalisierte Schnitt), andere implizit.
63
5. Clusteranalyse
5.1. Zielfunktion Modularität
Wir betrachten hier nur disjunkte Cluster, suchen also eine Partition der Knotenmenge
V gemäß der obigen Überlegungen. Um diese Überlegungen zu formalisieren, führen
wir die Zielfunktion Modularität (engl. modularity) ein. Sie ist im Bereich der sozialen
Netzwerkanalyse sehr populär und hat auch in vielen weiteren Anwendungen breiten
Einsatz gefunden:
Definition 5.1. Sei G = (V, E) ein Graph, dieser habe eine Clusterung C, also eine
Partition der Knotenmenge V . Die Modularität q von C auf G ist definiert als:
P
2
X |E(C)| v∈C deg(v)
q(G, C) :=
.
(5.1)
−
m
2m
C∈C
Bei der obigen Definition bezeichnet E(C) die Menge der Intra-Cluster-Kanten des
Clusters C. Modularität lässt sich alternativ auch so schreiben (der Nachweis der Äquivalenz beider Ausdrücke sei als Übungsaufgabe empfohlen):
1 X
deg(i) deg(j)
q(G, C) :=
Aij −
δ(c(i), c(j)).
(5.2)
2m
2m
ij
Der Cluster eines Knotens i wird dabei mit c(i) bezeichnet. Außerdem stellt δ(·, ·) das
sogenannte Kronecker-Delta dar, welches genau dann 1 ist, wenn beide Parameter gleich
sind und sonst 0. Modularität muss maximiert werden. Die Leserin kann sich leicht
überzeugen, dass der Wert 1 eine obere Schranke darstellt. Werte um 0 weisen auf eine fehlende Clusterstruktur hin. Das theoretische Minimum liegt nach Bisseling und
Fagginger Auer [AB12] bei - 12 . Es ergibt sich nun folgendes Clustering-Problem:
Problem 5.2. Graph Clustering gemäß Modularität)
• Eingabe: Graph G = (V, E)
• Ausgabe: Clusterung C (eine Partition von V ), die q(G, C) maximiert
Modularität gehört zu den Zielfunktionen, die implizit balancieren. Die Idee hinter
Modularität ist, den Anteil der Intra-Cluster-Kanten (diesen Ausdruck nennt man englisch auch coverage) mit dem erwarteten Anteil dieser Größe in einem Zufallsgraphen
mit gleicher Gradfolge zu vergleichen. Eine Clusterung, die aus nur einem Cluster besteht, hat dann Modularität 0, was ausdrückt, dass keine nennenswerte Clusterstruktur
vorliegt. Dabei hat der Zufallsgraph des Nullmodells dieselbe Gradverteilung wie der
ursprüngliche Graph.
Satz 5.3. Modularität vergleicht die tatsächliche coverage und ihren Erwartungswert für
jeden Cluster.
Beweis. Dass der Teil links des Minuszeichens der coverage entspricht, ist in Formel (5.1)
offensichtlich. Der Erwartungswert für den rechten Teil lässt sich wiederum leichter aus
64
5.1. Zielfunktion Modularität
Formel (5.2) herleiten: Betrachten wir dazu eine beliebige Kante mit dem Ziel, zunächst
die Zahl der erwarteten Intra-Cluster-Kanten herzuleiten.
Starte diese Kante am Knoten i. Wenn wir für diese Kante einen zufälligen anderen
Endpunkt suchen, dann wird in unserem Nullmodell des Zufallsgraphen mit Wahrscheinlichkeit deg(j)
2m der Knoten j gewählt, weil die m Kanten von G insgesamt 2m Endpunkte
haben. Wenn wir dieses Prozedere der Neuverdrahtung für alle Kanten des Knoten i
durchführen, multipliziert man den Ausdruck noch mit deg(i). Wir erhalten also für alle
P
P
Halbkanten: i deg(i) j deg(j)
2m .
Den Erwartungswert für den Anteil der Intra-Cluster-Kanten erhalten wir, indem
wir für jedes geordnete Knotenpaar den Beitrag wie oben angegeben verwenden sowie
eine Indikator-Variable, ob sie innerhalb eines Clusters verläuft. Letzteres erledigt der
Ausdruck δ(c(i), c(j)). Um jede Kante wiederum nur einmal zu zählen, brauchen wir
noch die Normalisierung 12 vor der Summe. Um coverage, also den Anteil der IntraCluster-Kanten, zu erhalten, teilen wir schließlich noch durch m.
Fast alle (interessanten) Zielfunktionen sind als Entscheidungsprobleme N P-vollständig,
dies gilt für Modularität sogar im strengen Sinn:
Problem 5.4. (Modularity)
• Gegeben: Graph G und eine Zahl K
• Frage: Gibt es eine Clusterung C von G, für die q(C) ≥ K gilt?
Theorem 5.5. Das Problem Modularity ist streng N P-vollständig.
Der Beweis erfolgt nach Brandes et al. [BDG+ 08] durch Reduktion von 3-Partition auf
Modularity.
Problem 5.6. (3-Partition)
• Gegeben: 3k positive ganze Zahlen a1 , . . . , a3k derart, dass
ai ≤ b/2 für eine ganze Zahl b und alle i = 1, . . . , 3k
P3k
i=1 ai
= kb und b/4 ≤
• Frage: Gibt es eine Partition dieser Zahlen in k Mengen derart, dass die Zahlen
in jeder Menge in der Summe b ergeben?
Für den Beweis benötigen wir einige Lemmas, die wir aus Zeitgründen nicht beweisen
werden.
Die Transformation für die geplante Reduktion im Beweis geschieht folgendermaßen:
Sei eine Instanz A für 3-Partition gegeben. Daraus konstruieren
wir einen Graphen
P
a
.
Für jedes Element
G(A) mit k Cliquen H1 , . . . , Hk der jeweiligen Größe a = 3k
i
i=1
ai ∈ A fügen wir einen sogenannten Element-Knoten ein. Diesen verbinden wir mit
ai Knoten in jeder der k Cliquen derart, dass jeder Cliquen-Knoten zu genau einem
Element-Knoten verbunden ist. Damit hat jeder Cliquen-Knoten Grad a. Der ElementKnoten zum Element ai hat wiederum Grad kai . Die Zahl der Kanten in G(A) ist dann
m = k/2 · a(a + 1), denn: (i) wir haben k Cliquen mit jeweils a Knoten mit Grad a,
P
2
somit ka2 Kanten; (ii) bei den Elementknoten ergeben sich i kai = ak Kanten, was
noch durch zwei geteilt werden muss, um die Kanten nicht doppelt zu zählen.
65
5. Clusteranalyse
Lemma 5.7. In einer Clusterung von G(A) mit maximaler Modularität wird keine der
Cliquen H1 , . . . , Hk geteilt.
Lemma 5.8. In einer Clusterung von G(A) mit maximaler Modularität enthält jeder
Cluster höchstens eine der Cliquen H1 , . . . , Hk .
Lemma 5.9. In einer Clusterung von G(A) mit maximaler Modularität besteht kein
Cluster ausschließlich aus Element-Knoten.
Aus den Lemmas folgt, dass für Graphen der Form G(A) die Clusterung mit maximaler
Modularität aus genau k Clustern besteht, die jeweils genau eine Clique beinhalten. Jeder
Element-Knoten gehört zudem zu genau einem Clique-Cluster.
Beweis. (von Theorem 5.5) Für eine gegebene Clusterung C von G(A) lässt sich in
polynomieller Zeit prüfen, ob q(C) ≥ K(A) gilt. Also ist Modularity ∈ N P.
Wir beweisen nun die Reduktion 3-Partition ≤ Modularity. Dazu transformieren
wir wie oben beschrieben eine Instanz A = {a1 , . . . , a3k von 3-Partition in eine Instanz (G(A), K(A)) von Modularity. Zur Bestimmung von K(A) betrachten wir eine
Clusterung in G(A) mit genau k Cliquen-Clustern. Jede solche Clusterung hat genau
(k − 1)a Inter-Cluster-Kanten, denn von jedem Element-Knoten gehen kai Kanten aus,
wovon (k − 1)ai zwischen verschiedenen Clustern verlaufen. Es ergibt sich:
X |E(C)|
m − (k − 1)a
2(k − 1)a
2k − 2
=
=1−
=1−
.
m
m
ka(a + 1)
k(a + 1)
(5.3)
C∈C
Da dieser Ausdruck nur von k und a abhängt, muss die Clusterung C = (C1 , . . . , Ck )
mit maximaler Modularität den rechten Teil der Modularitätsformel minimieren, also deg(C1 )2 , deg(C2 )2 , . . . , deg(Ck )2 . Dies erfordert eine Aufteilung der Element-Knoten
zwischen den Clustern, die so gleichmäßig wie möglich bezüglich der Summe der Knotengrade pro Cluster ist. Im Optimalfall können wir an einen jeden Cluster Element-Knoten
zuweisen, die Elementen entsprechen, die sich zu b = a/k aufsummieren. In diesem
Fall ist die Aufsummierung der Knotengrade der Element-Knoten in jeder Clique gleich
k · a/k = a. Dies ergibt deg(Ci ) = a2 + a für jeden Cliquen-Cluster Ci , i = 1, . . . , k.
Schließlich ergibt sich:
deg(C1 )2 + · · · + deg(Ck )2 ≥ k(a2 + a)2 = ka2 (a + 1)2 .
(5.4)
Gleichheit gilt nur für den Fall, dass eine Zuweisung von b an jeden Cluster möglich ist.
Beachten Sie zudem, dass G(A), der in der Reduktion aus A konstruierte Graph,
polynomielle Größe in der unären Kodierungsgröße von A hat. Da 3-Partition streng
N P-vollständig ist, reicht eine solche Transformation für unsere Zwecke aus.
Es bleibt noch zu zeigen, dass sich aus der Lösung des einen Problems eine Lösung
für das jeweils andere Problem ergibt.
“⇐” Falls es eine Clusterung C gibt mit
q(C) ≥ K(A) = 1 −
66
2k − 2
ka2 (a + 1)2
(k − 1)(a − 1)
− 2 2
=
,
2
k(a + 1) k a (a + 1)
k(a + 1)
5.1. Zielfunktion Modularität
dann wissen wir, dass diese Clusterung die Element-Knoten perfekt auf die k CliquenCluster aufteilen muss. Weil jedes Element in genau einem Cluster enthalten ist, erzeugt
dies eine Lösung für die 3-Partition-Instanz. Mit dieser Wahl von K(A) ist also die
Instanz (G(A), K(A)) von Modularity nur dann erfüllbar, falls auch die Instanz A
von 3-Partition erfüllbar ist. Oder umgekehrt: Ist A nicht erfüllbar, dann auch nicht
(G(A), K(A)).
“⇒” Für die andere Beweisrichtung nehmen wir an, dass die Instanz A von 3-Partition
erfüllbar ist. Dann gibt es eine Partition in k Mengen derart, dass die Summe über jede
Menge k1 ·a = b ist. Wenn wir den zugehörigen Graphen clustern, indem wir die ElementKnoten jeder Menge mit einer anderen Clique vereinigen, erhalten wir eine Clusterung
mit Modularität K(A). Also ist dann auch die Instanz (G(A), K(A)) von Modularity
erfüllbar.
Die Definition von Modularität sowie das Ergebnis aus Theorem 5.5 lassen sich im
Übrigen leicht auf gewichtete Graphen übertragen.
Modularität hat einige bekannte Nachteile, z. B. das sogenannte Auflösungsproblem.
Das bedeutet, dass ein und derselbe Cluster in zwei Graphen mit stark unterschiedlicher
Größe mal als eigenständiger Cluster erkannt wird und mal nicht (weil er in dem Fall
in einen größeren Cluster integriert wird). Dieses Auflösungsproblem kann man teilweise
durch ein Gewichtsschema beseitigen, aber einige Probleme bleiben weiterhin bestehen.
Letztlich haben aber auch andere populäre Zielfunktionen Nachteile – die Wahl der
Zielfunktion wird sich daher meist nach dem Anwendungsfall richten müssen.
Übung 5.10. Zeigen Sie, dass für die Modularitätsfunktion gilt:
P
2 !
deg(v)
|E(C)|
v∈C
−
m
2m
C∈C
1 X
deg(i) deg(j)
· δ(C(i), C(j)),
=
Aij −
2m
2m
X
ij
wobei δ(a, b) das Kronecker-Delta ist mit δ(a, b) = 1, falls a = b und 0 sonst. C(i)
bezeichnet den Cluster des Knotens i.
Übung 5.11. Zeigen Sie für eine 2-Clusterung C und ihren Modularitätswert:
Q(C) =
1 T
x Bx,
4m
wobei x ein Indikatorvektor mit xi ∈ {−1, 1} ist und B die Modularitätsmatrix mit
Bij = Aij −
deg(i) deg(j)
.
2m
67
5. Clusteranalyse
5.2. Spektrale Optimierung von Modularität
5.3. Die Louvain-Methode
Die Louvain-Methode geht auf vier Wissenschaftler zurück, die zum Zeitpunkt der Entwicklung der Methode alle in der belgischen Stadt Louvain forschten – daher der Name.
Die Methode geht lokal und gierig (greedy) vor und verwendet einen Mehrebenen-Ansatz.
Die unten stehende Beschreibung ist den Folien entnommen und wird bald überarbeitet.
• Initialisierung: Jeder Knoten ist sein eigener Cluster.
• Danach: Zwei Phasen, die sich wiederholen:
• Phase 1, lokale Verbesserung
– Für jeden Knoten v lokal entscheiden, ob eine Wechsel in die Community des
Nachbarn eine Verbesserung der ZF (Modalität) ergibt.
– Wechsel von v in Community des Nachbarn mit stärkster positiver Verbesserung.
– Wiederholung, bis keine Verbesserung möglich.
– Abarbeitungsreihenfolge der Knoten beliebig, z.B. zufällig.
• Phase 2, Schrumpfen des Graphen:
– Kontraktion jeder gefundenen Community zu einem einzelnen Knoten.
– Aktualisierung der Knoten- und Kantengewichten: Schleifen erhalten Gewicht
aller alten Intra-Cluster-Kanten, die übrigen Kanten erhalten das Gewicht der
alten Kanten zwischen den zugehörigen Communitys.
5.4. Verbesserung von Clusterungen mit Gütegarantie
Wir haben bereits gesehen, dass es schwierig ist, optimale Clusterungen zu berechnen.
Modularität ist dabei nur eine Zielfunktion unter vielen, wenn auch eine populäre. Dennoch wollen wir noch zwei weitere Zielfunktionen betrachten, die sich in ihrem Aufbau
ähneln. Allen genannten Zielfunktionen ist gemeinsam, dass sie sehr große oder sehr
kleine Cluster typischerweise vermeiden.
Definition 5.12 (Quotientenwertung). Sei G = (V, E) und S ⊆ V . Sei |∂S| das Gesamtgewicht der Kanten, die zwischen S und S̄ verlaufen. Die Quotientenwertung (engl.:
quotient score) ist
|∂(S)|
Q(S) =
.
min{π(S), π(S̄)}
Dabei sei π eine Funktion, die jedem Knoten einen positiven Wert zuweist.
Beispiel 5.13 (Beispiele für π-Funktionen). Oft verwendete Beispiele solcher Quotientenwertungen sind der Quotientenschnitt und die Leitfähigkeit:
68
5.4. Verbesserung von Clusterungen mit Gütegarantie
• π(v) = 1 ∀v ∈ V (quotient cut) oder
• π(v) = deg(v) ∀v ∈ V (conductance).
Man kann das Clustering-Problem so definieren, dass wir bei einem gegebenen Graphen die Quotientenwertung für einen Schnitt (S, S̄) optimieren wollen. Dieses Problem
ist für die in Beispiel 5.13 genannten Ausprägungen N P-schwer (und als Entscheidungsproblem N P-vollständig). Hier gehen wir aber einen anderen Weg und versuchen, eine
gegebene Clusterung eines Graphen weiter zu verbessern.
Problem 5.14 (Finde verbesserte Lösung).
• Eingabe: G = (V, E), A ⊆ V mit π(A) ≤ π(Ā)
• Ausgabe: S ⊆ V mit Q(S) < Q(A), sofern diese existiert.
5.4.1. Algorithmus
Bevor wir zu der Idee des Algorithmus kommen, erinnern wir uns an das grundlegende
Max-flow-min-cut-Theorem (für die Notation verweisen wir an Lehrbücher zu Netzwerkflüssen oder zu kombinatorischer Optimierung):
Theorem 5.15. Die folgenden drei Aussagen sind äquivalent:
1. f ist ein maximaler Fluss in G.
2. Das Residualnetzwerk Gf enthält keinen augmentierenden Pfad.
3. Für mindestens einen Schnitt (S, T ) ist der Wert des Flusses gleich der Kapazität
des Schnittes: |f | = c(S, T ).
Für unsere Zwecke reicht es zu wissen, dass man aus dem maximalen Fluss den minimalen Schnitt rekonstruieren kann. Natürlich sind wir nicht direkt an minimalen Schnitten interessiert, weil diese überhaupt keine Balance garantieren. Aber wir werden sehen,
dass sich die Lösung eines abgewandelten Flussproblems sehr wohl für unsere Zwecken
nutzen lässt.
Die Idee des Algorithmus besteht darin, den Graphen auf geeignete Weise in ein Flussnetzwerk zu transformieren. Bei dieser Transformation werden die aktuelle Lösung und
deren Qualität berücksichtigt. Aus der Lösung des zugehörigen Flussproblems wird dann
der minimale Schnitt und daraus eine Partition von V (G) berechnet. Wie wir sehen werden, kann man sogar Gütegarantien für die so entstandene Clusterung abgeben.
Die Transformation des Eingabegraphen sowie des zugehörigen Clusterings in ein
Flussnetzwerk geschieht folgendermaßen:
Definition 5.16 (Transformation der Eingabe in Flussnetzwerk).
• Eingabe: G = (V, E), A ⊆ V, α ∈ [0, ∞)
• Ausgabe: GA (α) mit
69
5. Clusteranalyse
• V (GA (α)) = V ∪ {s, t},
• E(GA (α)) = E ∪ (s, v)|v ∈ A ∪ {(v, t)|v ∈ Ā},
• w(s, v) = απ(v),
• w(v, t) = απ(v)f (A) mit f (A) = π(A)/π(Ā) ≤ 1,
• w(u, v) = wG (u, v).
Beispiel 5.17.
Beobachtung 5.18. Einfaches Nachrechnen ergibt für das gemäß Definition 5.16 entstandene Flussnetzwerk:
• Die Gesamtkapazität der Quellkanten ist gleich der Gesamtkapazität der Senkkanten.
• Für die Kosten von (S, S̄) gilt: costA,α (S) = |∂(s)| + απ(A ∩ S̄) + απ(S ∩ Ā)f (A).
Die ursprüngliche Quotientenwertung bezieht sich nur auf das Endergebnis, also auf
die Clusterung S, aber nicht auf die Eingabeclusterung A. Damit A im Algorithmus auf
sinnvolle Weise den Optimierungsprozess steuern kann, wandeln wir die Zielfunktion ab:
Definition 5.19.
Sei A ⊆ V derart, dass π(A) ≤ π(Ā) und sei S 6= A. Wir definieren:
DA (S) = π(S ∩ A) − π(S ∩ Ā)f (A)
mit f (A) := π(A)/π(Ā) ≤ 1 und
(
|∂(S)|/DA (S)
Q̃A (S) =
+∞
, falls DA (S) > 0,
, falls DA (S) ≤ 0.
Beobachtung 5.20.
• Es gilt immer: DA (S) ≤ π(S).
• Falls S 6= A und nicht S ⊂ A, gilt sogar: DA (S) < π(S).
Der vollständige Algorithmus ist (etwas abstrahiert) als Algorithmus 5.1 dargestellt.
Wir hatten bereits angedeutet, dass uns der Algorithmus eine Gütegarantie erlaubt.
Theorem 5.21. Sei A eine Menge mit π(A) ≤ π(Ā) und sei S = Improve(A). Dann
gilt:
1. Für jede Menge C ⊆ A gilt: Q(S) ≤ Q(C).
70
5.4. Verbesserung von Clusterungen mit Gütegarantie
Algorithm 5.1 Verbesserung der Quotientenwertung
function Improve(G,A)
S0 = A; i = 0
α0 = Q̃A (A) = Q(A) < ∞
repeat
Berechne minimalen s-t-Schnitt (Si+1 , Si+1 ) in Graph GA (αi )
αi+1 = Q̃a (Si+1 )
i=i+1
until αi ≥ αi−1
return Si
end function
2. Falls C eine Menge ist, für die
π(A ∩ C)
π(A)
π(A)
≥
+
π(C)
π(V )
π(V )
für ein > 0 gilt, dann erfüllt die Ausgabe S
1
Q̃A (S) ≤ Q(C).
3. Der Algorithmus Improve läuft in polynomieller Zeit.
Theorem 5.21 stellt fest, dass jede Iteration ein Ergebnis liefert, das mindestens so
gut ist wie das Ergebnis der besten Teilmenge der bisherigen Lösung. Der Beweis des
Theorems erfolgt schrittweise im nächsten Abschnitt. Lemma 5.22 als Teil dieses Beweises sagt demnach aus, dass die Lösung S das Optimum 1 -approximiert, falls die Lösung
der Eingabe A genügend Übereinstimmung mit dem Optimum hat. Die Bedingung zur
Übereinstimmung bei π(v) = 1 ∀v ∈ V ist, dass der Anteil von C, der auch in A liegt,
etwas größer sein muss als der erwartete Anteil von C in einer Zufallsmenge der Größe
von A.
5.4.2. Analyse des Algorithmus
Lemma 5.22.
1. Der Algorithmus Improve(G, A) berechnet eine Menge S, die Q̃A (S)
minimiert.
2. Bei ganzzahligen positiven Kantengewichten führt der Algorithmus höchstens π(V )2
Iterationen durch.
3. Bei ungewichteten Kanten führt der Algorithmus höchstens |E| Iterationen durch.
Beweis. (1) Bei gegebenem A sei
α∗ = min Q̃A (X).
X⊆V
71
5. Clusteranalyse
Wir werden zeigen, dass die Menge S=Improve(A) die Gleichheit Q̃A (S) = α∗ erfüllt.
Dazu zeigen wir zunächst, dass wir eine Menge X mit Q̃A (X) < α durch das Lösen eines
s-t-Flussproblems in GA (α) finden können, falls eine solche Menge existiert. Fixiere dazu
α ∈ (0, ∞) und sei Sα die feste Menge, die die Kosten costA,α (Sα ) minimiert. Wir werden
zeigen, dass Q̃(Sα ) < α gilt, falls es eine Menge X ⊂ V mit Q̃(X) < α gibt.
Dazu stellen wir fest, dass Q̃(X) < α gdw. ∂(X) − αDA (X) < 0 nach Definition.
Daher folgt aus der Existenz einer Menge X ⊆ V mit Q̃(X) < α auch
costA,α (Sα ) ≤ costA,α (X)
= απ(A) + (∂(X) − αDA (X))
< απ(A).
Die Kosten von Sα lassen sich durch Umformung auch schreiben als costA,α (Sα ) =
απ(A)+(∂(S)−αDA (S)). Dann haben wir απ(A)+(∂(Sα )−αDA (Sα )) = costA,α (Sα ) <
απ(A). Aus der Ungleichung folgt ∂(Sα ) − αDA (Sα ) < 0 und daher auch Q̃(Sα ) < α.
Da wir demnach in jeder Iteration eine Verbesserung in Q̃ herbeiführen und erst
stoppen, wenn es keine Verbesserung mehr gibt, wird das Minimum gefunden.
Für jeden Schritt, in dem die Schleife nicht abbricht, sind sowohl αi als auch αi+1
endlich. Daher sind sowohl DA (Si+1 ) als auch DA (Si ) größer als 0 gemäß Definition der
α-Werte. Daher können wir schreiben:
costA,α−1 (Si ) = αi−1 π(A) + (∂(Si ) − αi−1 DA (Si ))
= αi−1 π(A) + DA (Si )(Q̃A (Si ) − αi−1 )
= αi−1 π(A) + DA (Si )(αi − αi−1 ).
Analog dazu gilt costA,α−1 (Si+1 ) = αi−1 π(A) + DA (Si+1 )(αi+1 − αi−1 ). Weil Si die
Kosten minimiert, gilt costA,α−1 (Si ) ≤ costA,α−1 (Si+1 ). Daraus folgt DA (Si ) · (αi −
αi−1 ) ≤ DA (Si+1 ) · (αi+1 − αi−1 ). Wegen αi+1 < αi < αi−1 < ∞ gilt auch wie gewünscht
DA (Si+1 ) < DA (Si ) (an dieser Stelle gilt tatsächlich in Abweichung zur Originalarbeit
echt kleiner, wie man leicht nachprüfen kann).
(2) Sind die Knotengewichte π(v) positive ganze Zahlen, dann können die Größen
π(S ∩ A) und π(S ∩ A) jeweils höchstens π(V ) mögliche Werte annehmen. Daher kann
DA (S) höchstens quadratisch so viele Werte annehmen. Weil DA (S) in jeder Iteration
verringert wird, ergibt sich die maximale Laufzeit.
(3) Weil sowohl Q̃A (Si ) als auch DA (Si ) in jeder Iteration verringert werden, muss
dies auch für ∂(Si ) gelten. Bei ungewichteten Kanten kann ∂(Si ) höchstens |E| unterschiedliche Werte annehmen.
Lemma 5.23. Falls für eine Menge C
π(A ∩ C)
π(A)
π(A)
≥
+
π(C)
π(V )
π(V )
für ein > 0 gilt, dann gilt Q̃A (C) ≤ 1 Q(C).
72
5.5. Weiterführende Literatur
Beweis. Aufgrund der Definition von Q und Q̃ reicht es, DA (C) ≥ π(C) zu zeigen. Es
gelte die Voraussetzung des Lemmas. Dann:
DA (C)
π(C ∩ A)
π(C ∩ A)
=
− f (A)
π(C)
π(C)
π(C)
π(A)
π(A)
π(A)
π(A)
≥(
+
) − f (A)(1 −
−
)
π(V )
π(V )
π(V )
π(V )
π(A)
π(A) π(A) π(A) π(A)
π(A)
+ f (A)
)+(
−
+
)
= (
π(V )
π(V )
π(V ) π(A) π(A) π(V )
π(A)
π(V ) π(A)
=·1+
(1 −
+
)
π(V )
π(A) π(A)
= .
Dabei wurden ausgenutzt:
1. Definition DA (C)
2. Voraussetzung
3. Definition f (A)
4. Mengenregeln
5.4.3. Zusammenfassung
Die Verbindung zwischen minimalen Schnitten und maximalen Flüssen lässt sich auf
vielfältige Weise nutzen. Beim betrachteten Algorithmus geht die Qualität der aktuellen Lösung bzgl. der Zielfunktion in die Formulierung des Flussproblems ein. Daraufhin findet jede Iteration das Optimum einer abgewandelten Zielfunktion auf Basis der
Flusslösung.
5.5. Weiterführende Literatur
Die (für uns alternative) Definition der Modularität sowie die Herleitung der spektralen
Methode findet sich bei Newman [New10a]. Die graphentheoretische Definition von Modularität geht auf die Darstellung von Brandes et al. [BDG+ 08] zurück; dort findet sich
auch der Beweis der N P-Vollständigkeit.
Die Louvain-Methode stammt von Blondel et al. [BGLM08]. Ihre parallele Version
wurde erstmals (in skalierbarer Form) in der Konferenzversion von Staudt und Meyerhenke [SM16] vorgestellt. Mittlerweile gibt es eine ganze Reihe von parallelen Varianten
für verschiedene parallele Architekturen. Der Improve-Algorithmus geht wiederum auf
Andersen und Lang [AL08] zurück.
73
6. Ausbreitung von Krankheiten in
Netzwerken
Die erste Reaktion beim Lesen des Titels dieses Kapitels mag Verwunderung sein. Verwunderung darüber, wieso Informatiker die Ausbreitung von Krankheiten betrachten.
Auf den zweiten Blick ist dies aber sehr nachvollziehbar, wenn man den Begriff “Krankheit” weit genug fasst und “elektronischen Befall” einbezieht. Nicht umsonst werden
auch in der IT-Welt medizinische Begriffe wie “Virus” der Medizin entliehen.
Netzwerkanalyse-Methoden können aber tatsächlich auch medizinischen Nutzen haben. Dies gilt insbesondere dann, wenn Infektionskrankheiten, die den Menschen befallen, modelliert, simuliert und eingeschätzt werden. Denken wir dazu an Ausbrüche
von SARS, AIDS, Ebola oder Schweinegrippe. Politisch kann es sehr interessant sein
zu wissen, wie entsprechende Ausbrüche (Schweregrad, geographische Konzentration)
vermutlich verlaufen werden.
Nun fragen Sie sich vielleicht selbst am Ende dieser Vorlesungsreihe noch, was AIDS oder andere Krankheiten mit Netzwerken zu tun haben. Letztlich geht man bei der
Modellierung solcher Krankheiten per Netzwerkanalyse sehr ähnlich vor. Möglicherweise
betroffene Personen werden als Knoten dargestellt. Eine Kante existiert zwischen zwei
Knoten, wenn diese miteinander “in Kontakt” getreten sind – und zwar so, dass die
Krankheit prinzipiell übertragen werden kann. Bei einige Krankheiten genügt dafür
räumliche Nähe, bei anderen ist bspw. Geschlechtsverkehr notwendig. Ein solcher Kontakt ist aber typischerweise nicht hinreichend für die Weitergabe einer Infektion; diese
geschieht nur mit einer gewissen Wahrscheinlichkeit. Ist eine solche Wahrscheinlichkeit
abhängig vom konkreten Knotenpaar, ist sie üblicherweise ein Kantenlabel. Für manche
Krankheiten ergeben sich wiederum global gültige Werte.
6.1. Verzweigungsprozess
Zunächst betrachten wir ein sehr, sehr einfaches Modell, basierend auf der Darstellung
von Easley und Kleinberg [EK10, Kapitel 21]. Bereits hier lassen sich aber einige wichtige
Einsichten ableiten. Das Modell bezeichnen wir als Verzweigungsprozess und es funktioniert so:
• (Erste Welle) Nehmen wir an, eine infizierte Person P erscheint in einer bisher
gesunden Population. Beim Erscheinen wird die Krankheit mit Wahrscheinlichkeit
p auf jede Person übertragen, die P trifft. Die Wahrscheinlichkeit p ist dabei völlig
unabhängig, also auch von der Nachbarschaft. Nehmen wir an, P trifft k Personen,
75
6. Ausbreitung von Krankheiten in Netzwerken
während er ansteckend ist. Abhängig vom Ausgang der jeweiligen Zufallsexperimente werden dann einige der k Personen mglw. infiziert, andere nicht.
• (Zweite Welle) In der zweiten Welle trifft jede Person, die P in der ersten Welle
getroffen hat, auf jeweils k (unterschiedliche) Personen. Somit werden in der zweiten Welle k · k = k 2 Personen kontaktiert. Jede in der ersten Welle infizierte Person
kann die Krankheit wieder mit Wahrscheinlichkeit p unabhängig zu jedem ihrer k
Nachbarn weitergeben.
• (Nachfolgende Wellen) Weitere Infektionswellen werden analog gebildet. Jede in
der vorigen Welle kontaktierte Person kontaktiert selbst wieder k Personen und
gibt die Krankheit unabhängig mit Wahrscheinlichkeit p weiter.
Unter der Annahme, dass die jeweiligen Kontakte disjunkt sind, lässt sich ein solcher
Verzweigungsprozess als Baum darstellen, siehe Abbildung ??. Offensichtlich stirbt der
Prozess aus, wenn in einer Welle niemand neu infiziert wird. Der Prozess hat also nur
zwei Möglichkeiten: entweder er stirbt aus oder setzt sich unendlich fort. Welche der
beiden Alternativen eintritt, hängt von der Reprodukationszahl R0 ab. Diese gibt die
erwartete Zahl neuer Fälle an, die durch eine einzelne Person hervorgerufen werden. In
unserem Modell gilt:
R0 = k · p.
Hier ergibt sich wieder ein Phasenübergang, dieses Mal bezüglich R0 :
Theorem 6.1. Falls R0 < 1, dann stirbt die Krankheit mit Wahrscheinlichkeit 1 nach
endlich vielen Schritten aus.
Falls R0 > 1, dann bleibt die Krankheit mit Wahrscheinlichkeit größer als 0 erhalten
und infiziert in jeder Welle mindestens eine Person.
Auch wenn dieses Modell sehr einfach ist, erkennt man bereits zwei wesentliche “Stellschrauben”, mit denen man eine Epidemie eindämmen kann. Zum einen sollte man infizierte Personen isolieren und zum anderen die Übertragungswahrscheinlichkeit senken
(bspw. durch Impfungen oder besondere Vorsichtsmaßnahmen). Zwar braucht es für diese
Erkenntnis erst mal kein mathematisches Modell. Wenn es aber darum geht, aus gesundheitspolitischer Sicht eine Kosten-Nutzen-Abwägung zu machen, können mathematische
Modelle natürlich sehr hilfreich sein. Wir werden daher nachfolgend netzwerkspezifische
Modelle betrachten, mit denen man zu realistischeren Modellen kommen kann.
6.2. SI*-Modelle
6.3. Cyberabwehr als Optimierungsproblem
6.3.1. Einführung
Computernetzwerke können vielfältige Ausprägungen haben. Wir gehen in unserer allgemeinen Modellierung als gewichteter Graph daher von einem sehr allgemeinen Szenario
76
6.3. Cyberabwehr als Optimierungsproblem
aus. Knoten repräsentieren dabei grundlegende Elemente des Gesamtsystems (bspw.
einen einzelnen Rechenknoten, Sensor oder auch Switch). Kanten beschreiben Interaktionskanäle zwischen den Elementen, die technisch auf unterschiedliche Arten realisiert
sein können. Die Stärke der Interaktion wird durch das Kantengewicht ausgedrückt.
Die Elemente des Netzwerks können in zwei Zuständen sein, anfällig (S) oder infiziert
(I). Ein anfälliges Element kann durch einen Cyberangriff infiziert werden, während
ein infizierter Knoten bspw. durch ein Anti-Viren-Programm oder eine Neuinstallation
geheilt werden kann. Dennoch ist die Heilung meist nur von sehr kurzer Dauer, weil dadurch nicht alle offenen Lücken geschlossen werden. Der neue Zustand nach Eliminierung
des Schädlings ist daher wieder S (und nicht R), so dass wir hier von einem SIS-Modell
ausgehen.
Die Kernfrage zur Vermeidung oder Abwehr eines Angriffs ist, wie wir die Funktionalität des Netzwerks möglichst gut aufrecht erhalten können, aber gleichzeitig das Netzwerk schützen bzw. säubern. Diese Problemstellung werden wir als Optimierungsproblem modellieren und (wegen der Problemkomplexität nicht exakt) mit einer MultilevelHeuristik lösen. Darstellung und Ergebnisse gehen auf Leyffer und Safro [LS13] zurück.
Die Arbeit zeigt exemplarisch, wie man sehr schwierige Optimierungsprobleme in Netzwerken durch eine geschickte Kombination verschiedener algorithmischer Techniken lösen
kann – zwar nicht optimal, aber dafür auf recht großen Instanzen und mit einer in der
Praxis häufig sehr guten Lösungsqualität.
Beginnen wir mit etwas Notation:
Definition 6.2.
• S: Zahl der anfälligen Knoten
• I: Zahl der infizierten Knoten
• β: Übertragungsrate
• γ: Heilungsrate
• φi,t : Wahrscheinlichkeit, dass Knoten i im Zeitpunkt t infiziert ist
Aus unseren Überlegungen im vorigen Abschnitt können wir folgern:
Beobachtung 6.3. Für die zeitliche Entwicklung der Zahl der infizierten bzw. der
anfälligen Elemente gilt:
dI
= λS − γI
dt
dS
= γI − λS.
dt
Dabei ist λ = βhkiI/(S + I) die durchschnittliche Infektionsrate im Netzwerk und hki
der durchschnittliche Knotengrad.
Eine feste Infektionsrate zu verwenden (wie wir das bisher gemacht haben), ist in der
Realität oft nicht angebracht. Die Übertragung einer Krankheit von Mensch zu Mensch
wird auch dadurch beeinflusst, wie eng oder von welcher Art der Kontakt zwischen diesen
77
6. Ausbreitung von Krankheiten in Netzwerken
beiden gewesen ist. Auch bei Computernetzwerken mag sie variieren, weil verschiedene
Elemente bspw. unterschiedlich gut geschützt sind. Wir verwenden daher nachfolgend
eine Infektionsmatrix
P n×n = (pij ),
wobei pij die Wahrscheinlichkeit angibt, dass i von j infiziert wird. Beachten Sie, dass
die Krankheit in der Matrix demnach von j nach i “fließt”!
Sei nun hi,t die Wahrscheinlichkeit, dass ein anfangs gesunder Knoten i zum Zeitpunkt t nicht infiziert ist. Dann gilt offensichtlich unter Annahme stochastischer Unabhängigkeit:
hi,t = Πj∈N (i) (1 − pij φj,t−1 ).
6.3.2. Optimierungsmodell
Es ist sicher eine sinnvolle Annahme, dass infizierte Elemente abgeschaltet werden, damit sie ohne weitere Schadwirkung im Netzwerk vom Schädling geheilt werden können.
Entfernt man allerdings einen Knoten aus dem Netzwerk, werden auch alle zugehörigen
Kanten und somit mögliche Kommunikationskanäle und -wege entfernt. Wir wollen daher das Gesamtgewicht der operierenden Kanten maximieren, dabei gleichzeitig aber den
Infektionsgrad an jedem Knoten gering halten.
Formal ergibt sich folgendes Optimierungsmodell (unter der Annahme, dass die Infektion in einer Nachbarschaft unabhängig zwischen Nachbarn erfolgt):
Problem 6.4. Sei G = (V, E, w) ein gewichteter Graph, wobei w(u, v) die Stärke der
Verbindung (u, v) angibt. Die binäre Variable xi gebe an, ob Knoten i an- (1) oder ausgeschaltet (0) ist. Die reelle Variable bi ∈ [0, 1] gebe den Grenzwert für den Infektionsgrad
eines Knotens i an. Dann ergibt sich für unser Optimierungsproblem:
max
x
X
wij xi xj
(6.1)
ij∈E
udNB xi − Πj∈N (i) (1 − pij φj,t−1 xj ) ≤ bi ∀i ∈ V
xi ∈ {0, 1} ∀i ∈ V.
(6.2)
(6.3)
Veranschaulichen wir die Nebenbedingung 6.2 an einem kleinen Zahlenbeispiel: Sei dazu bi = 0.4 für einen Knoten i. Der Sinn dieser Nebenbedingung ist, den Infektionsgrad
angeschalteter Knoten zu beschränken. Ist xi = 0, ist die Nebenbedingung auf triviale
Weise erfüllt, da der linke Ausdruck negativ wird. Falls xi = 1 ist, dann wollen wir verhindern, dass der Infektionsgrad über 40% steigt. Dazu müssen wir die Nachbarschaft
betrachten. Der Ausdruck (1−pij φj,t−1 xj ) gibt dabei an, mit welcher Wahrscheinlichkeit
keine Krankheit vom Nachbarn j in diesem Zeitschritt übertragen wird. Das Produkt
dieser Einzelwahrscheinlichkeiten ergibt dann wegen der Unabhängigkeit die Gesamtwahrscheinlichkeit. Zieht man sie von xi = 1 ab, ergibt sich der Infektionsgrad.
78
6.3. Cyberabwehr als Optimierungsproblem
6.3.3. Heuristische Lösung durch ein Mehrebenen-Verfahren
Optimierungsproblem 6.4 ist ein nicht-konvexes und nichtlineares ganzzahliges Optimierungsproblem. Das Berechnen einer optimalen Lösung ist somit N P-schwer, das zugehörige Entscheidungsproblem N P-vollständig. Eine exakte Lösung des Problems ist
daher nur für recht kleine Instanzen mit einigen Hundert Knoten möglich. Da ein Computernetzwerk in großen Unternehmen aber aus Tausenden von einzelnen Elementen
bestehen kann, sind wir an Lösungsmöglichkeiten für größere Probleme interessiert. In
diesem Fall verwenden wir ein Mehrebenen-Verfahren (engl.: multilevel approach), mit
dem auch Netzwerke mit Hunderttausenden von Knoten in akzeptabler Zeit mit hoher
Qualität gelöst werden können.
Zur Beschreibung einer Mehrebenen-Methode müssen wir angeben, wie die drei Phasen
(Vergröberung, initiale Lösung auf der gröbsten Ebene und lokale Verbesserung nach
Interpolation) konkret implementiert werden sollen. Der vorliegende Ansatz orientiert
sich sehr nah an Mehrgitter-Verfahren, wie sie in der angewandten Mathematik zur
Lösung von linearen Gleichungssystemen und anderen numerischen Problemen eingesetzt
werden.
Vergröberung. Die Vergröberung erfolgt rekursiv, bis ein gröbster Graph erstellt wurde, der “klein genug” ist. “Klein genug” bedeutet dabei häufig, dass ein teures Lösungsverfahren für einen Graphen dieser Größe eine akzeptable Geschwindigkeit hat. Da dies
anwendungsabhängig ist, müssen wir hier etwas vage bleiben. Wegen des rekursiven Vorgehens genügt es, in der Folge zwei Ebenen zu betrachten.
Um den groben Graphen G0 zu erstellen, werden zunächst die Knoten von G ausgewählt, die in G0 übernommen werden sollen. Diese Menge nennen wir C (von engl.:
coarse). Die Knoten, die nicht übernommen werden, gehören zur Menge F (feine Kno·
ten). Es gilt: V = C ∪ F . Häufig werden die Knoten von C als (große) unabhängige
Menge gewählt. Diesem Vorgehen liegt die Idee zugrunde, dass C zwar möglichst klein
sein sollte, um die Laufzeit des Verfahrens niedrig zu halten; gleichzeitig muss aber jeder
Knoten aus V entweder in C sein oder einen Nachbarn aus C haben.
Algorithm 6.1 Wahl der groben Knotenmenge C
1: function ChooseCoarseNodes(G = (V, E))
2: Ausgabe: Menge C der groben Knoten
3:
F ←V
4:
C←∅
5:
for i ←
with nodes with high φi )
P1 to n doP(starting
−1
6:
if j∈C %−1
/
%
≥
θ then
j∈V ij
ij
7:
C ← C ∪ {i}
8:
F ← F \ {i}
9:
end if
10:
end for
11:
return C
12: end function
79
6. Ausbreitung von Krankheiten in Netzwerken
Algorithmus 6.1 stellt das Verfahren im Pseudocode dar. Die Traversierung von V geschieht dabei so, dass Knoten mit hohen Infektionswerten φi zuerst betrachtet werden.
Eine exakte Sortierung ist dabei nach Aussage der Originalarbeit allerdings nicht notwendig. Der Standardwert für θ in der AMG-Literatur ist 0,5; hier sind aber auch andere
Werte denkbar. Kleinere Werte führen zu größeren Mengen C und somit zu (tendentiell)
mehr Hierarchie-Ebenen. Dies kostet natürlich mehr Speicher und Rechenzeit, kann sich
aber unter Umständen durch ein besseres Konvergenz-Verhalten auszahlen. Bleibt noch
zu erklären, was % ist.
Bei der Vergröberung ist es wichtig zu wissen, wie “nah” sich zwei Knoten auf der
feinen Ebene sind. Dabei ist hier nicht unbedingt die graphentheoretische Distanz gemeint. Im vorliegenden Kontext bezieht sich %ij auf die algebraische Distanz zwischen i
und j. Dies ist ein von Random Walks abgeleitetes Maß. Sein Kehrwert gibt dann keine Distanz, sondern eine Ähnlichkeit an. Dieses Maß bezieht nicht nur die Länge eines
kürzesten Weges ein, sondern versucht zu berücksichtigen, ob es viele oder wenige Wege
kurzer Länge zwischen i und j gibt.
Hat man die Knoten von C ausgewählt, werden die Interpolationsgewichte festgelegt.
Diese geben an, wie die Werte eines F -Knoten durch die Interpolation seiner C-Nachbarn
näherungsweise rekonstruiert werden. Das Ziel muss dabei sein, dass jeder F -Knoten auf
sinnvolle Art und weise interpoliert wird. Dies lässt sich beispielsweise durch folgendes
Schema für die Restriktionsmatrix R ∈ R|Vf |×|C| (für die Interpolationsmatrix gilt P =
RT ) erreichen:
 −1 P
−1
C

%ij / k∈N C (i) %ik für i ∈ F, j ∈ N (i)
T
Rij
= 1
(6.4)
für i ∈ C, j = i


0
sonst
Dabei sollten zu kleine Werte auf 0 gesetzt werden, wobei häufig ein heuristisch bestimmter Schwellwert eingesetzt wird.
Die Laplacematrix Lc des groben Graphen lässt sich dann anhand der Formel
Lc = RLf RT
(6.5)
berechnen. Somit ergibt sich ein grobes Kantengewicht WIJ zwischen den groben Knoten
I und J durch:
X
T
WIJ =
RIk wk` R`J
.
k6=`
Initiale Lösung auf der gröbsten Ebene. Wenn das Problem klein genug ist, kann es
auf der gröbsten Ebene durch aufwändige Verfahren gelöst werden, mitunter sogar exakt.
Dies wird für das vorliegende Problem mit dem exakten Löser MINOTAUR gemacht;
dazu wird das grobe Problem gegenüber Optimierungsproblem 6.4 allerdings noch leicht
umformuliert:
X
X
max
WIJ XI XJ +
AI XI
(6.6)
X
IJ∈Ec
I∈Vc
udNB XI − ΠJ∈N (I) (1 − PIJ ΦJ,t−1 XJ ) ≤ BI ∀I ∈ Vc
80
(6.7)
6.3. Cyberabwehr als Optimierungsproblem
XI ∈ {0, 1} ∀I ∈ Vc .
(6.8)
Der erste Unterschied besteht darin, dass nun über grobe Variablenmengen (zu erkennen
an denPIndizes mit großen Buchstaben) iteriert wird. Außerdem kommt nun der lineare
Term I∈Vc AI XI , der die feinen Kanten innerhalb eines groben Knotens (wenn man so
will eine gewichtete Schleife) modelliert.
Lokale Verbesserung nach Interpolation. Die normale Vorgehensweise von MultigridVerfahren bei der Interpolation ist die Multiplikation des Lösungsvektors mit der Matrix
P = RT . Bei der Lösung dieses Optimierungsproblems wird von dieser Vorgehensweise
leicht abgewichen. Zwar erhält jeder Knoten i ∈ C genauso wie bei der Multiplikation
mit P seinen groben Wert, d. h. xi = XI . Bei den F -Knoten wird hier aber abgewichen und eine Extra-Routine zur Maximierung des Beitrags zur Zielfunktion aufgerufen.
Aus Zeitgründen gehen wir auf diese allerdings nicht näher ein. Die so erhaltene initiale
Lösung auf dieser Ebene wird dann durch eine Gauß-Seidel-ähnliche Relaxation verbessert. Aber auch in diesem Relaxations-Schritt wird von der in der Numerik üblichen
Vorgehensweise abgewichen. Denn für unser Optimierungsproblem werden kleine Teilprobleme unabhängig voneinander gelöst. Dabei werden die Randbedingungen für die
Knoten, die nicht zum aktuell betrachteten Teilproblem S gehören, fixiert. Dies hat zwar
den Nachteil, dass hier ein (kleiner) Fehler gemacht wird, weil die Teilprobleme in der
Regel natürlich voneinander abhängen. Aber auf diese Weise ergibt sich auch der Vorteil
eines hohen Grades an Parallelität
max
x
X
i,j∈S
wij xi xj +
X
i∈S,j ∈S
/
wij xi x̃j +
X
ai xi
i∈S
udNB xi − ki · Πj∈N (i)∩S (1 − pij φj,t−1 xj ) ≤ bi ∀i ∈ V
xi ∈ {0, 1} ∀i ∈ V,
(6.9)
(6.10)
(6.11)
wobei x̃j eine feste Lösung für j ∈
/ S ist und ki := Πj∈N (i)∩S (1 − pij φj,t−1 x˜j ).
Setzt man nun die Komponenten für die drei Phasen Vergröberung, initiale Lösung
und Interpolation mit lokaler Verbesserung zusammen, so erhält man ein vollständiges
Mehrgitter- bzw. Mehrebenen-Verfahren. Wie man über die einzelnen Ebenen iteriert,
ist problemspezifisch. Die Mehrgitter-Literatur führt dabei insbesondere V-, W- und
F(MV)-Zyklen auf [?].
Experimentelle Ergebnisse. In ihrer experimentellen Studie betrachten Leyffer und
Safro zunächst je 200 kleine Graphen für je drei verschiedene generative Modelle, ErdősRényi, Barabási-Albertund R-MAT. Die Ergebnisse sind in einem Performance-Plot in
Abbildung 6.1 relativ zur exakten Lösung dargestellt. In einem Performance-Plot sortiert man üblicherweise die Instanzen aufsteigend bezüglich ihrer Qualität. Je steiler
eine Kurve dann ansteigt, desto besser im Allgemeinen. Hier zeigt sich, dass etwa die
Hälfte der Netzwerke optimal gelöst werden. Graphen vom Typus R-MAT und BarabásiAlbertwerden mit recht ähnlicher Qualität gelöst, wohingegen Erdős-Rényietwas abfällt.
81
Ratio between MA and optimal solution
6. Ausbreitung von Krankheiten in Netzwerken
FAST RESPONSE TO INFECTION SPREAD
9 of 17
1
0.98
0.96
0.94
0.92
0
50
100
150
Networks ordered by ratios
200
Fig. 3. Comparison
with optimal
solutions for
small networks.
pointkleine
represents
a ratio between
the objectives of MA
Abbildung
6.1.: Vergleich
mit200
optimaler
LösungEach
für 200
Netzwerke
(ER schwarz,
and optimal solutions, respectively,
for
one
network.
Solutions
of
MA
are
feasible.
Circles,
squares,
and
triangles
correspond t
R-MAT rot, BA grün). Quelle: Leyffer und Safro [LS13].
Erdös-Rényi, R-MAT, and Barabasi-Albert models, respectively.
Trotzdem lässt sich festhalten, dass die Qualität hier insgesamt überzeugt, da maximal
um 9% von der optimalen Lösung abgewichen wird. Ob sich diese sehr gute Qualität
auf größere Instanzen überträgt, ist allerdings in der zu Grunde liegenden Arbeit nicht
untersucht worden.
Für weitere Ergebnisse, beispielsweise zu einem hochskalierten Netzwerk zu HIVÜbertragungen, wird auf die Originalarbeit verwiesen.
6.3.4. Fazit
Die betrachtete Problemstellung und die gewählte Lösungsmethode hat uns tiefer in
sogenannte Mehrebenen/-skalen/-gitterverfahren eingeführt. Durch eine geeignete Wahl
der einzelnen Komponenten ist ein Verfahren entstanden, das auch für große Graphen
sehr gute Lösungen liefert. Exakte Löser wären dafür viel zu langsam und die Metaheuristik Iterative Lokale Suche kann qualitativ nicht mithalten.
Ob ein solches Verfahren im Ernstfall von einem Administrator zur Netzwerküberwachung eingesetzt würde, sei dahingestellt. Dennoch haben wir gelernt, wie ein Problem der Netzwerksicherheit als (schwieriges) Optimierungsproblem modelliert und mit
vergleichsweise hoher Geschwindigkeit gelöst werden kann.
Fig. 4. Infection spread network (|V | = 25,090, |E| = 28,284) constructed by sparse random connections among 100 generate
networks that are similar to real HIV spread data.
contains a network with 250 vertices, where each vertex corresponds to an individual. We generated 100
similar networks by using a multiscale network generator [32] and connected them by several random
edges in order to create one big network (see Fig. 4). We simulated an immediate outbreak of th
infection in 82
which initially 5% of vertices were associated with high level of infection (φi ∈ [0.8, 1]) and
each edge had the same rate of infection transmission. Then five iterations of the infection spread wer
performed; at each iteration, all vertices released their infection to the neighbours, and the updated φ wa
⎞
⎛
#
pij
$
∀i ∈ V φinew = min ⎝1, φiold +
φjold ⎠ .
p
k∈Γi ik
j∈Γ
i
Literaturverzeichnis
[AB12]
Auer, Bas F. ; Bisseling, Rob H.: Graph coarsening and clustering on
the GPU. In: Bader, David A. (Hrsg.) ; Meyerhenke, Henning (Hrsg.) ;
Sanders, Peter (Hrsg.) ; Wagner, Dorothea (Hrsg.): Graph Partitioning
and Graph Clustering, 10th DIMACS Implementation Challenge Workshop,
Georgia Institute of Technology, Atlanta, GA, USA, February 13-14, 2012.
Proceedings Bd. 588, American Mathematical Society, 2012 (Contemporary
Mathematics), 223
[AIY13]
Akiba, Takuya ; Iwata, Yoichi ; Yoshida, Yuichi: Fast exact shortest-path
distance queries on large networks by pruned landmark labeling. In: Proceedings of the ACM SIGMOD International Conference on Management
of Data, SIGMOD 2013, New York, NY, USA, June 22-27, 2013, ACM,
2013. – ISBN 978–1–4503–2037–5, 349–360
[AL08]
Andersen, Reid ; Lang, Kevin J.: An Algorithm for Improving Graph
Partitions. In: Proceedings of the Nineteenth Annual ACM-SIAM Symposium on Discrete Algorithms. Philadelphia, PA, USA : Society for Industrial
and Applied Mathematics, 2008 (SODA ’08), 651–660
[BBC+ 16]
Bergamini, Elisabetta ; Borassi, Michele ; Crescenzi, Pierluigi ; Marino, Andrea ; Meyerhenke, Henning: Computing Top-k Closeness Centrality Faster in Unweighted Graphs. In: Goodrich, Michael T. (Hrsg.)
; Mitzenmacher, Michael (Hrsg.): Proceedings of the Eighteenth Workshop on Algorithm Engineering and Experiments, ALENEX 2016, Arlington, Virginia, USA, January 10, 2016, SIAM, 2016, 68–80
[BDG+ 08]
Brandes, Ulrik ; Delling, Daniel ; Gaertler, Marco ; Gorke, Robert ;
Hoefer, Martin ; Nikoloski, Zoran ; Wagner, Dorothea: On modularity
clustering. In: Knowledge and Data Engineering, IEEE Transactions on 20
(2008), Nr. 2, S. 172–188
[BDG+ 16]
Bast, Hannah ; Delling, Daniel ; Goldberg, Andrew V. ; MüllerHannemann, Matthias ; Pajor, Thomas ; Sanders, Peter ; Wagner,
Dorothea ; Werneck, Renato F.: Route Planning in Transportation Networks. Version: 2016. https://doi.org/10.1007/978-3-319-49487-6_2.
In: Kliemann, Lasse (Hrsg.) ; Sanders, Peter (Hrsg.): Algorithm Engineering - Selected Results and Surveys Bd. 9220. 2016, 19–80
[BE05]
Brandes, Ulrik (Hrsg.) ; Erlebach, Thomas (Hrsg.): Network Analysis:
Methodological Foundations [outcome of a Dagstuhl seminar, 13-16 April
83
Literaturverzeichnis
2004]. Bd. 3418. Springer, 2005 (Lecture Notes in Computer Science). –
ISBN 3–540–24979–6
[BGG+ 08]
Baur, Michael ; Gaertler, Marco ; Görke, Robert ; Krug, Marcus ;
Wagner, Dorothea: Augmenting k -core generation with preferential attachment. In: NHM 3 (2008), Nr. 2, 277–294. http://dx.doi.org/10.
3934/nhm.2008.3.277. – DOI 10.3934/nhm.2008.3.277
[BGLM08] Blondel, V.D. ; Guillaume, J.L. ; Lambiotte, R. ; Mech, E.L.J.S.:
Fast unfolding of communities in large networks. In: J. Stat. Mech (2008),
S. P10008
[BMS+ 14]
Bader, David A. ; Meyerhenke, Henning ; Sanders, Peter ; Schulz,
Christian ; Kappes, Andrea ; Wagner, Dorothea: Benchmarking for Graph
Clustering and Partitioning. In: Encyclopedia of Social Network Analysis
and Mining. 2014, S. 73–82
[BP12]
Brin, Sergey ; Page, Lawrence: Reprint of: The anatomy of a large-scale
hypertextual web search engine. In: Computer Networks 56 (2012), Nr. 18,
3825–3833. http://dx.doi.org/10.1016/j.comnet.2012.10.007
[Bra01]
Brandes, U.: A faster algorithm for betweenness centrality. In: J. Mathematical Sociology 25 (2001), Nr. 2, S. 163–177
[Bra16]
Brandes, Ulrik:
(2016), S. 1–19
[BV14]
Boldi, Paolo ; Vigna, Sebastiano: Axioms for Centrality. In: Internet
Mathematics 10 (2014), Nr. 3-4, 222–262. http://dx.doi.org/10.1080/
15427951.2013.865686. – DOI 10.1080/15427951.2013.865686
Network positions.
In: Methodological Innovations 9
[CGH+ 13a] Crescenzi, Pilu ; Grossi, Roberto ; Habib, Michel ; Lanzi, Leonardo
; Marino, Andrea: On computing the diameter of real-world undirected
graphs. In: Theor. Comput. Sci. 514 (2013), 84–95. http://dx.doi.org/
10.1016/j.tcs.2012.09.018. – DOI 10.1016/j.tcs.2012.09.018
[CGH+ 13b] Crescenzi, Pilu ; Grossi, Roberto ; Habib, Michel ; Lanzi, Leonardo
; Marino, Andrea: On computing the diameter of real-world undirected
graphs. In: Theoretical Computer Science 514 (2013), S. 84–95
[EK10]
Easley, David A. ; Kleinberg, Jon M.:
Networks, Crowds, and
Markets - Reasoning About a Highly Connected World.
Cambridge
University Press, 2010 http://www.cambridge.org/gb/knowledge/isbn/
item2705443/?site_locale=en_GB. – ISBN 978–0–521–19533–1
[Gal14]
Gall, François Le: Powers of tensors and fast matrix multiplication. In:
Nabeshima, Katsusuke (Hrsg.) ; Nagasaka, Kosaku (Hrsg.) ; Winkler,
84
Literaturverzeichnis
Franz (Hrsg.) ; Szántó, Ágnes (Hrsg.): International Symposium on Symbolic and Algebraic Computation, ISSAC ’14, Kobe, Japan, July 23-25, 2014,
ACM, 2014, 296–303
[Jac08]
Jackson, Matthew O.: Social and Economic Networks. Princeton, NJ, USA
: Princeton University Press, 2008. – ISBN 0691134405, 9780691134406
[Kle99]
Kleinberg, Jon M.: Authoritative Sources in a Hyperlinked Environment. In: J. ACM 46 (1999), Nr. 5, 604–632. http://dx.doi.org/10.
1145/324133.324140. – DOI 10.1145/324133.324140
[LFR08]
Lancichinetti, Andrea ; Fortunato, Santo ; Radicchi, Filippo: Benchmark graphs for testing community detection algorithms. In: Phys. Rev.
E 78 (2008), Oct, 046110. http://dx.doi.org/10.1103/PhysRevE.78.
046110. – DOI 10.1103/PhysRevE.78.046110
[LS13]
Leyffer, Sven ; Safro, Ilya: Fast response to infection spread and cyber attacks on large-scale networks. In: J. Complex Networks 1 (2013),
Nr. 2, 183–199. http://dx.doi.org/10.1093/comnet/cnt009. – DOI
10.1093/comnet/cnt009
[Mei05]
Meister, Andreas: Numerik linearer Gleichungssysteme. 2. Aufl. Vieweg, 2005. – ISBN 9–528–13135–7. – Mit Matlab-Implementierungen von
Christof Vömel
[MLH08]
Magnien, Clémence ; Latapy, Matthieu ; Habib, Michel: Fast computation of empirically tight bounds for the diameter of massive graphs. In: ACM
Journal of Experimental Algorithmics 13 (2008). http://dx.doi.org/10.
1145/1412228.1455266. – DOI 10.1145/1412228.1455266
[MR95]
Motwani, Rajeev ; Raghavan, Prabhakar: Randomized Algorithms. Cambridge University Press, 1995. – ISBN 0–521–47465–5
[New10a]
Newman, Mark: Networks: An Introduction. 2010 http://books.google.
de/books/about/Networks.html?id=q7HVtpYVfC0C&pgis=1. –
ISBN
0199206651
[New10b]
Newman, Mark: Networks: an introduction. Oxford University Press, 2010
[SHS+ 16]
Staudt, Christian L. ; Hamann, Michael ; Safro, Ilya ; Gutfraind, Alexander ; Meyerhenke, Henning: Generating Scaled Replicas of Real-World
Complex Networks. In: International Workshop on Complex Networks and
their Applications Springer International Publishing, 2016, S. 17–28
[SM16]
Staudt, Christian L. ; Meyerhenke, Henning: Engineering Parallel Algorithms for Community Detection in Massive Networks. In: IEEE Trans.
Parallel Distrib. Syst. 27 (2016), Nr. 1, 171–184. http://dx.doi.org/10.
1109/TPDS.2015.2390633. – DOI 10.1109/TPDS.2015.2390633
85
Literaturverzeichnis
[SSM16]
Staudt, Christian L. ; Sazonovs, Aleksejs ; Meyerhenke, Henning: NetworKit: A Tool Suite for Large-scale Complex Network Analysis. In: Network Science 4 (2016), Dec, Nr. 4, S. 508–530
[SW05]
Schank, Thomas ; Wagner, Dorothea: Approximating Clustering Coefficient and Transitivity. In: Journal of Graph Algorithms and Applications 9
(2005), Nr. 2, S. 265–275
86
A. Grundlagen der linearen Algebra
A.1. Matrizen, Vektoren und ihre Operationen
Definition A.1. Ein Vektor v ∈ Rn heißt stochastisch, wenn gilt:
vi ≥ 0 ∀ 1 ≤ i ≤ n
n
X
vi = 1
i=1
Eine Matrixnorm kann mittels einer vorliegenden Vektornorm definiert werden, siehe
bspw. Meister [Mei05, S. 19]. Wir benötigen hier nur zwei Normen:
Definition A.2 (Matrixnormen). Die Spaltensummennorm und die Zeilensummennorm
für eine Matrix A ∈ Rn×n sind definiert als:
kAk1 = max
k=1,...,n
kAk∞ = max
n
X
i=1,...,n
|Aik |
i=1
n
X
|Aik |
(Spaltensummennorm)
(A.1)
(Zeilensummennorm)
(A.2)
k=1
A.2. Eigenwerte und -vektoren
Definition A.3 (Eigenwert, Eigenvektor). Sei A eine symmetrische n × n-Matrix mit
reellen Einträgen. Die Zahl λ heißt Eigenwert von A, wenn es einen Vektor z 6= 0 gibt,
so dass
Az = λz.
Der Vektor z heißt Eigenvektor zum Eigenwert λ.
Theorem A.4 (Eigenvektorbasis). Eine reelle symmetrische n × n-Matrix hat n unterschiedliche Eigenvektoren z (1) , . . . , z (n) ∈ Rn , die in Rn eine Basis bilden.
Ferner gilt: z (i) ⊥ z (j) für alle 1 ≤ i 6= j ≤ n.
Satz A.5. Der betragsmäßig größte Eigenwert ist nicht größer als eine induzierte Matrixnorm.
Theorem A.6 (Perron-Frobenius). Sei A eine positive Matrix. Dann ist der größte
Eigenwert λ1 von A positiv und einfach. Alle anderen Eigenwerte sind also betragsmäßig
kleiner als λ1 . Außerdem existiert zu λ1 ein ebenfalls positiver Eigenvektor x.
87
A. Grundlagen der linearen Algebra
Definition A.7 (Chebyshev-Ungleichung). Sei X eine Zufallsvariable mit Mittelwert µ
und Streuung σ. Dann gilt für jedes r > 0:
Pr(|X − µ| > rσ) < 1/r2 .
A.3. NetworKit-Quellcodes
A.4. Lösungen zu den Übungsaufgaben
Die Lösungen für die Übungsaufgaben werden kooperierenden Lehrenden auf Anfrage
zur Verfügung gestellt. Unter Kooperation verstehe ich dabei beispielsweise, dass eigene
Aufgaben mit Lösungen zur Verfügung gestellt werden.
Im öffentlich zugänglichen Dokument sind die Lösungen nicht verfügbar.
88