Lær AI med Python · Lektion

Nodeklassifikation med GNN

Cora-datasæt, 2-lags GCN, træningsloop, masked loss, testnøjagtighed, visualisering af embeddings.

Lektion 3 af 413 trin

Nodeklassifikation med GNN er en gratis Lær AI med Python-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lær AI med Python, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lær AI med Python-kurset indeholder 4 lektioner i alt.

Opgaven med knudeklassifikation

Knudeklassifikation forudsiger en etiket for hver knude ved hjælp af dens egenskaber og grafens struktur. Et klassisk eksempel er at tildele hver artikel i et citationsnetværk et forskningsemne ved hjælp af både artiklens ord og de artikler, den citerer.

Datasættet Cora

Cora er grafmaskinlæringens MNIST. Det er en citationsgraf med 2.708 artikler om maskinlæring. Kanterne er citeringer; hver artikel har en egenskabsvektor med ordforekomster og længden 1433; målet er at klassificere hver artikel i ét af 7 emner.

# Cora:
#   nodes  = 2708 papers
#   edges  = citations
#   features per node = 1433
#   classes = 7

Indlæsning via Planetoid

PyTorch Geometric leverer Cora gennem indlæseren Planetoid, som downloader og formaterer dataene til ét grafobjekt.

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_mask

Dataobjektet

Grafobjektet indeholder alt: data.x (egenskaber, 2708 x 1433), data.edge_index (forbindelser), data.y (sande etiketter) samt booleske masker, der angiver, hvilke knuder der bruges til træning, validering og test.

En GCN til 7 klasser

Vi bygger en GCN med to lag, der fører de 1433 inputegenskaber gennem et skjult lag på 64 dimensioner til 7 klasselogitværdier.

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)

Transduktiv læring

Cora er transduktiv: Hele grafen, inklusive testknuderne og deres egenskaber, er synlig under træningen; vi skjuler kun testetiketterne. Modellen bruger alle knudernes forbindelser, men lærer kun fra mærkede træningsknuder.

train_mask

train_mask er en boolesk vektor, der udvælger, hvilke knuder der bidrager til tabet. Vi kører modellen på hele grafen, men beregner kun krydsentropitabet på de maskerede træningsknuder.

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 bag maskeret tab

Selvom den fremadrettede beregning producerer logitværdier for alle 2708 knuder, begrænser indeksering med train_mask tabet til de mærkede træningsknuder. De umærkede knuder sender stadig meddelelser, hvilket hjælper modellen, men driver ikke gradienten direkte.

Evaluering med test_mask

Efter træningen evaluerer vi nøjagtigheden på de tilbageholdte test_mask-knuder, som aldrig indgik i tabet. Det måler modellens generalisering til artikler, hvis etiketter modellen aldrig har set.

@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())

Visualisering af indlejringer med t-SNE

Hvis du vil se, hvad GCN'en har lært, kan du tage knudeindlejringerne fra det skjulte lag og projicere dem til 2D med t-SNE. En veltrænet GCN danner klynger, hvor knuder i samme klasse samles.

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)

Fortolkning af t-SNE-plottet

Tydeligt adskilte, farvede klynger betyder, at indlejringerne kan skelne mellem klasserne, hvilket tyder på, at GCN'en har lært en nyttig struktur. Overlappende områder tyder på utilstrækkelig træning eller overudjævning. t-SNE er en kvalitativ kontrol, ikke en metrik.

Hurtigt tjek

Test din viden om knudeklassifikation.

Besvar den i den interaktive lektion

Opsummering

Du har lært knudeklassifikation med en GNN:

Planetoid indlæser Cora-citationsgrafen
En GCN med to lag fører 1433 til 64 til 7 klasser
train_mask begrænser tabet; test_mask måler generaliseringen
t-SNE visualiserer knudeindlejringer, så klassernes adskillelse kan undersøges

Gratis at komme i gang

Lær Python med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 53
Lektioner: 225

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Nodeklassifikation med GNN” gratis?

Ja — alle 3 lektioner i læringssporet Lær AI med Python, inklusive “Nodeklassifikation med GNN”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lær AI med Python-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Nodeklassifikation med GNN”?

Cora-datasæt, 2-lags GCN, træningsloop, masked loss, testnøjagtighed, visualisering af embeddings. Du øver dig i Lær AI med Python med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Lær AI med Python?

Der kræves ingen tidligere erfaring. Lær AI med Python på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Nodeklassifikation med GNN”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Lær AI med Python-lektion?

Ja. Alle Lær AI med Python-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Lær AI med Python