Lär Er AI med Python · Lektion

Nodklassificering med GNN

Cora-datasetet, GCN med två lager, träningsloop, maskerad förlust, testträffsäkerhet, visualisering av embeddingar.

Lektion 3 av 413 steg

Nodklassificering med GNN är en gratis lektion i Lär Er AI med Python på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär Er AI med Python, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär Er AI med Python innehåller totalt 4 lektioner.

Uppgiften nodklassificering

Nodklassificering förutsäger en etikett för varje nod med hjälp av dess egenskaper och grafens struktur. Ett klassiskt exempel är att märka varje artikel i ett citeringsnätverk med dess forskningsområde, med hjälp av både orden i artikeln och vilka artiklar den citerar.

Cora-datasetet

Cora är grafinlärningens MNIST. Det är en citeringsgraf med 2 708 maskininlärningsartiklar. Kanterna representerar citeringar; varje artikel har en bag-of-words-egenskapsvektor med längden 1433; målet är att klassificera varje artikel i en av 7 kategorier.

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

Läs in via Planetoid

PyTorch Geometric tillhandahåller Cora via inläsaren Planetoid, som hämtar och formaterar data till ett enda 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 innehåller allt: data.x (egenskaperna 2708 x 1433), data.edge_index (konnektivitet), data.y (sanna etiketter) och booleska masker som markerar vilka noder som används för träning, validering och testning.

En GCN för 7 klasser

Vi bygger en GCN med två lager som mappar de 1433 indataegenskaperna via ett dolt lager med 64 dimensioner till logits för 7 klasser.

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 inlärning

Cora är transduktivt: hela grafen (inklusive testnoderna och deras egenskaper) är synlig under träningen. Vi döljer endast testetiketterna. Modellen använder alla noders anslutningar men lär sig bara från märkta träningsnoder.

train_mask

train_mask är en boolesk vektor som väljer vilka noder som bidrar till förlusten. Vi kör modellen på hela grafen men beräknar korsentropin endast på de maskerade träningsnoderna.

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 för maskerad förlust

Även om framåtpasseringen producerar logits för alla 2708 noder begränsar indexering med train_mask förlusten till märkta träningsnoder. De omärkta noderna vidarebefordrar fortfarande meddelanden och hjälper modellen, men påverkar inte gradienten direkt.

Utvärdering med test_mask

Efter träningen utvärderar vi noggrannheten på noderna som markeras av test_mask och som hållits undan, vilket innebär att förlusten aldrig har påverkat dem. Detta mäter generaliseringen till artiklar vars etiketter modellen aldrig har sett.

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

Visualisera inbäddningar med t-SNE

För att se vad GCN:n har lärt sig hämtar ni nodinbäddningarna från det dolda lagret och projicerar dem till 2D med t-SNE. En vältränad GCN bildar kluster där noder i samma klass grupperar sig tillsammans.

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)

Tolka t-SNE-diagrammet

Väl åtskilda färgade kluster innebär att inbäddningarna skiljer klasserna åt, vilket tyder på att GCN:n har lärt sig användbar struktur. Överlappande kluster tyder på otillräcklig träning eller over-smoothing. t-SNE är en kvalitativ kontroll, inte ett mått.

Snabbtest

Testa era kunskaper om nodklassificering.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er nodklassificering med en GNN:

Planetoid läser in Cora-citeringsgrafen
En GCN med två lager mappar 1433 till 64 till 7 klasser
train_mask begränsar förlusten; test_mask mäter generaliseringen
t-SNE visualiserar nodinbäddningar för att undersöka klassernas åtskillnad

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 53
Lektioner: 225

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Nodklassificering med GNN” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär Er AI med Python, inklusive ”Nodklassificering med GNN”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär Er AI med Python innehåller totalt 4 lektioner.

Vad lär jag mig i ”Nodklassificering med GNN”?

Cora-datasetet, GCN med två lager, träningsloop, maskerad förlust, testträffsäkerhet, visualisering av embeddingar. Ni övar på Lär Er AI med Python med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Lär Er AI med Python?

Du behöver inga förkunskaper. Utbildningen i Lär Er AI med Python på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Nodklassificering med GNN”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Lär Er AI med Python-lektionen?

Ja. Varje Lär Er AI med Python-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Lär Er AI med Python