Graph Convolutional Networks (GCN)
Message-Passing-Framework, GCNConv, Aggregation von Knoten-Features, Einrichtung von PyTorch Geometric.
Graph Convolutional Networks (GCN) ist eine kostenlose Learn AI with Python-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn AI with Python-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn AI with Python-Kurs umfasst insgesamt 4 Lektionen.
Von CNNs zu GCNs
CNNs nutzen die Gitterstruktur von Bildern. Ein Graph Convolutional Network (GCN) verallgemeinert die Faltung auf unregelmäßige Graphen, sodass jeder Knoten seine Repräsentation mithilfe von Informationen aus seinen Nachbarn aktualisieren kann. Damit lassen sich Daten ohne festes Gitter verarbeiten.
Message Passing
GCNs folgen dem Framework des Message Passing: In jeder Schicht (1) sammelt jeder Knoten Nachrichten von seinen Nachbarn, (2) aggregiert diese und (3) aktualisiert sein eigenes Embedding. Durch das Stapeln mehrerer Schichten können Informationen durch den Graphen fließen.
Aggregation von Nachbarn
Die zentrale Operation ist das Aggregieren von Nachbar-Features. Eine einfache GCN-Schicht mittelt die Feature-Vektoren der Nachbarn eines Knotens (einschließlich des Knotens selbst) und wendet anschließend eine gelernte lineare Transformation sowie eine Nichtlinearität an.
# For each node v:
# h_v = activation( W * mean(features of v and its neighbors) )Warum die Adjazenzmatrix normalisiert wird
Knoten mit hohem Grad würden dominieren, wenn die Nachbarn naiv summiert würden. GCNs verwenden die normalisierte Adjazenzmatrix, um die Beiträge zu skalieren und die Größe der Knoten-Embeddings über Knoten mit unterschiedlichem Grad hinweg stabil zu halten.
Die Normalisierungsformel
Bei der symmetrischen Normalisierung werden zunächst Selbstschleifen hinzugefügt und anschließend anhand der Knotengrade skaliert. Dies wird als D^(-1/2) (A + I) D^(-1/2) geschrieben. Das Hinzufügen der Einheitsmatrix I ermöglicht es einem Knoten, seine eigenen Features während der Aggregation beizubehalten.
# A_hat = A + I (add self-loops)
# D_hat = degree matrix of A_hat
# A_norm = D_hat^(-1/2) * A_hat * D_hat^(-1/2)PyTorch Geometric
PyTorch Geometric (PyG) ist die Standardbibliothek für GNNs in PyTorch. Sie stellt fertige Schichten wie GCNConv bereit, die die normalisierte Message-Passing-Faltung für Sie implementieren.
import torch
import torch.nn.functional as F
from torch_geometric.nn import GCNConvEine einzelne GCNConv-Schicht
GCNConv(in_channels, out_channels) erzeugt eine Graph-Faltung. Sie nimmt die Knoten-Feature-Matrix x und edge_index (die Graphverbindungen im COO-Format) entgegen und gibt aktualisierte Knoten-Embeddings zurück.
conv = GCNConv(in_channels=16, out_channels=32)
# x: [num_nodes, 16], edge_index: [2, num_edges]
h = conv(x, edge_index) # -> [num_nodes, 32]Ein GCN mit zwei Schichten
Ein typischer GCN verwendet zwei aufeinanderfolgende Schichten: Die erste projiziert die Features und aggregiert die Nachbarn im Abstand von einem Hop, die zweite aggregiert die Nachbarn im Abstand von zwei Hops. Dadurch erhält jeder Knoten ein rezeptives Feld von zwei Hops.
class GCN(torch.nn.Module):
def __init__(self, in_dim, hid, out):
super().__init__()
self.conv1 = GCNConv(in_dim, hid)
self.conv2 = GCNConv(hid, out)
def forward(self, x, edge_index):
x = F.relu(self.conv1(x, edge_index))
x = F.dropout(x, training=self.training)
return self.conv2(x, edge_index)Das rezeptive Feld wächst mit der Tiefe
Jede GCN-Schicht erweitert das rezeptive Feld eines Knotens um einen Hop. Zwei Schichten erfassen Nachbarschaften im Abstand von zwei Hops, drei Schichten im Abstand von drei Hops und so weiter. Durch größere Tiefe können weit entfernte Informationen einen Knoten erreichen.
Over-Smoothing
Das Stapeln zu vieler Schichten führt jedoch zu Over-Smoothing: Durch wiederholtes Mitteln über Nachbarn konvergieren alle Knoten-Embeddings gegen nahezu denselben Vektor, wodurch die für die Klassifikation erforderlichen Unterschiede verloren gehen. Deshalb verwenden die meisten GCNs nur zwei oder drei Schichten.
Over-Smoothing entgegenwirken
Zu den Techniken gegen Over-Smoothing gehören Residual- beziehungsweise Skip-Verbindungen, Jumping-Knowledge-Netzwerke, die Ausgaben mehrerer Schichten kombinieren, sowie eine bewusst geringe Netzwerktiefe. Flache GCNs erzielen bei Standard-Benchmarks häufig bessere Ergebnisse als tiefe GCNs.
Kurztest
Testen Sie Ihr Wissen über GCNs.
Zusammenfassung
Sie haben Graph Convolutional Networks gelernt:
- GCNs folgen dem Framework des Message Passing: Nachbar-Features aggregieren und anschließend aktualisieren
- Die normalisierte Adjazenzmatrix mit Selbstschleifen hält Embeddings stabil
GCNConvin PyTorch Geometric implementiert eine Faltung- Eine gängige Architektur ist ein GCN mit zwei Schichten
- Zu große Tiefe führt zu Over-Smoothing
Häufig gestellte Fragen
Ist die Lektion „Graph Convolutional Networks (GCN)“ kostenlos?
Ja — der vollständige Text von „Graph Convolutional Networks (GCN)“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn AI with Python-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn AI with Python-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Graph Convolutional Networks (GCN)“?
Message-Passing-Framework, GCNConv, Aggregation von Knoten-Features, Einrichtung von PyTorch Geometric. Du übst Learn AI with Python mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Learn AI with Python zu starten?
Keine Vorkenntnisse erforderlich. Learn AI with Python auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Graph Convolutional Networks (GCN)“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Learn AI with Python-Lektion Code schreiben und ausführen?
Ja. Jede Learn AI with Python-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Graphentheorie für Machine Learning
- Graph Convolutional Networks (GCN)
- Knotenklassifikation mit GNN
- Link Prediction und Graphklassifikation