Knotenklassifikation mit GNN
Cora-Dataset, zweischichtiges GCN, Trainingsschleife, maskierter Loss, Testgenauigkeit, Visualisierung von Embeddings.
Knotenklassifikation mit GNN ist eine kostenlose Learn AI with Python-Lektion auf CoddyKit. Dies ist Lektion 3 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.
Die Aufgabe der Knot Klassifikation
Bei der Knotenkklassifikation wird für jeden Knoten anhand seiner Features und der Graphstruktur ein Label vorhergesagt. Ein klassisches Beispiel ist die Zuordnung jedes Papers in einem Zitationsnetzwerk zu einem Forschungsthema – anhand sowohl der Wörter im Paper als auch der Papers, die es zitiert.
Der Cora-Datensatz
Cora ist das MNIST des Graphenlernens. Es handelt sich um einen Zitationsgraphen mit 2.708 Machine-Learning-Papers. Die Kanten sind Zitationen, und jedes Paper verfügt über einen Bag-of-Words-Feature-Vektor der Länge 1433. Ziel ist es, jedes Paper einer von 7 Kategorien zuzuordnen.
# Cora:
# nodes = 2708 papers
# edges = citations
# features per node = 1433
# classes = 7Laden über Planetoid
PyTorch Geometric stellt Cora über den Planetoid-Loader bereit. Dieser lädt die Daten herunter und formatiert sie zu einem einzigen Graphobjekt.
from torch_geometric.datasets import Planetoid
dataset = Planetoid(root="data/Cora", name="Cora")
data = dataset[0]
print(data) # x, edge_index, y, train_mask, test_maskDas Datenobjekt
Das Graphobjekt enthält alles: data.x (Features 2708 x 1433), data.edge_index (Verbindungen), data.y (wahre Labels) und boolesche Masken, die angeben, welche Knoten zum Trainieren, Validieren und Testen verwendet werden.
Ein GCN für 7 Klassen
Wir erstellen einen GCN mit zwei Schichten, der die 1433 Eingangs-Features über eine verborgene Schicht mit 64 Dimensionen auf 7 Klassen-Logits abbildet.
import torch
import torch.nn.functional as F
from torch_geometric.nn import GCNConv
class GCN(torch.nn.Module):
def __init__(self):
super().__init__()
self.conv1 = GCNConv(1433, 64)
self.conv2 = GCNConv(64, 7)
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)Transduktives Lernen
Cora ist transduktiv: Der gesamte Graph (einschließlich Testknoten und ihrer Features) ist während des Trainings sichtbar; verborgen werden nur die Labels der Testknoten. Das Modell nutzt die Verbindungen aller Knoten, lernt aber ausschließlich aus den gelabelten Trainingsknoten.
Die train_mask
Die train_mask ist ein boolescher Vektor, der auswählt, welche Knoten zum Loss beitragen. Wir führen das Modell auf dem gesamten Graphen aus, berechnen die Kreuzentropie jedoch nur für die maskierten Trainingsknoten.
model = GCN()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
def train():
model.train()
optimizer.zero_grad()
out = model(data.x, data.edge_index)
loss = F.cross_entropy(out[data.train_mask], data.y[data.train_mask])
loss.backward()
optimizer.step()
return loss.item()Intuition zum maskierten Loss
Obwohl der Forward-Pass Logits für alle 2708 Knoten erzeugt, beschränkt die Indizierung mit train_mask den Loss auf gelabelte Trainingsknoten. Die ungelabelten Knoten leiten weiterhin Nachrichten weiter und unterstützen dadurch das Modell, steuern den Gradienten jedoch nicht direkt.
Evaluierung mit test_mask
Nach dem Training evaluieren wir die Genauigkeit auf den zurückgehaltenen Knoten in test_mask, die beim Berechnen des Loss nicht berücksichtigt wurden. Dies misst die Generalisierung auf Papers, deren Labels das Modell nie gesehen hat.
@torch.no_grad()
def test():
model.eval()
pred = model(data.x, data.edge_index).argmax(dim=1)
correct = (pred[data.test_mask] == data.y[data.test_mask]).sum()
return int(correct) / int(data.test_mask.sum())Embeddings mit t-SNE visualisieren
Um zu sehen, was der GCN gelernt hat, nehmen Sie die Knoten-Embeddings der verborgenen Schicht und projizieren Sie sie mit t-SNE auf zwei Dimensionen. Ein gut trainierter GCN erzeugt Cluster, in denen sich Knoten derselben Klasse gruppieren.
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
emb = model.conv1(data.x, data.edge_index).detach().numpy()
z = TSNE(n_components=2).fit_transform(emb)
plt.scatter(z[:, 0], z[:, 1], c=data.y, cmap="tab10", s=8)Das t-SNE-Diagramm interpretieren
Deutlich getrennte farbige Cluster bedeuten, dass die Embeddings klassenunterscheidend sind – ein Zeichen dafür, dass der GCN eine nützliche Struktur gelernt hat. Überlappende Bereiche deuten auf unzureichendes Training oder Over-Smoothing hin. t-SNE ist eine qualitative Überprüfung und keine Metrik.
Kurztest
Testen Sie Ihr Wissen über Knotenkklassifikation.
Zusammenfassung
Sie haben Knotenkklassifikation mit einem GNN gelernt:
- Planetoid lädt den Cora-Zitationsgraphen
- Ein GCN mit zwei Schichten bildet 1433 auf 64 und anschließend auf 7 Klassen ab
- train_mask beschränkt den Loss; test_mask misst die Generalisierung
- t-SNE visualisiert Knoten-Embeddings, um die Klassentrennung zu untersuchen
Häufig gestellte Fragen
Ist die Lektion „Knotenklassifikation mit GNN“ kostenlos?
Ja — der vollständige Text von „Knotenklassifikation mit GNN“ 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 „Knotenklassifikation mit GNN“?
Cora-Dataset, zweischichtiges GCN, Trainingsschleife, maskierter Loss, Testgenauigkeit, Visualisierung von Embeddings. 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 3 von 4.
Wie lange dauert die Lektion „Knotenklassifikation mit GNN“?
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