Lær AI med Python · leksjon

Grafkonvolusjonsnettverk (GCN)

Rammeverk for meldingsformidling, GCNConv, aggregering av nodeegenskaper og oppsett av PyTorch Geometric.

Leksjon 2 av 413 trinn

Grafkonvolusjonsnettverk (GCN) er en gratis leksjon i Lær AI med Python på CoddyKit. Dette er leksjon 2 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Lær AI med Python, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Lær AI med Python inneholder totalt 4 leksjoner.

Fra CNN-er til GCN-er

CNN-er utnytter gitterstrukturen i bilder. Et grafkonvolusjonsnettverk (GCN) generaliserer konvolusjon til uregelmessige grafer, slik at hver node kan oppdatere representasjonen sin ved hjelp av informasjon fra naboene. Dette håndterer data uten et fast gitter.

Meldingspassing

GCN-er følger rammeverket for meldingspassing: I hvert lag (1) samler hver node inn meldinger fra naboene, (2) aggregerer dem og (3) oppdaterer sin egen embedding. Når lag stables, kan informasjon flyte gjennom grafen.

Aggregering av naboer

Kjerneoperasjonen er å aggregere naboeegenskaper. Et enkelt GCN-lag beregner gjennomsnittet av featurevektorene til en nodes naboer (samt noden selv), og bruker deretter en lært lineær transformasjon og en ikke-linearitet.

# For each node v:
#   h_v = activation( W * mean(features of v and its neighbors) )

Hvorfor nabomatrisen normaliseres

Noder med høy grad ville dominert hvis vi summerte naboene naivt. GCN bruker den normaliserte nabomatrisen til å skalere bidragene, slik at størrelsen på nodeembeddingene holder seg stabil på tvers av noder med ulik grad.

Normaliseringsformelen

Den symmetriske normaliseringen legger til selvsløyfer og skalerer deretter med nodenes grader, og skrives D^(-1/2) (A + I) D^(-1/2). Når identitetsmatrisen I legges til, kan en node beholde sine egne egenskaper under aggregeringen.

# 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) er standardbiblioteket for GNN-er i PyTorch. Det tilbyr ferdige lag som GCNConv, som implementerer den normaliserte konvolusjonen med meldingspassing for deg.

import torch
import torch.nn.functional as F
from torch_geometric.nn import GCNConv

Ett GCNConv-lag

GCNConv(in_channels, out_channels) oppretter én grafkonvolusjon. Det tar inn nodeegenskapsmatrisen x og edge_index (grafens forbindelser i COO-format), og returnerer oppdaterte nodeembeddinger.

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]

Et GCN med to lag

Et typisk GCN stabler to lag: Det første projiserer egenskaper og aggregerer naboer med ett hopp, mens det andre aggregerer naboer med to hopp. Dermed får hver node et reseptivt felt på to hopp.

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)

Det reseptive feltet vokser med dybden

Hvert GCN-lag utvider en nodes reseptive felt med ett hopp. To lag ser nabolag på to hopp, tre lag ser nabolag på tre hopp, og så videre. Dybden gjør at informasjon fra fjerne noder kan nå en node.

Oversmoothing

Hvis du derimot stabler for mange lag, oppstår oversmoothing: Gjentatt gjennomsnittsberegning av naboer gjør at alle nodeembeddinger nærmer seg nesten samme vektor, slik at skillene som trengs for klassifisering, forsvinner. Derfor bruker de fleste GCN-er bare 2 eller 3 lag.

Slik begrenses oversmoothing

Teknikker for å motvirke oversmoothing omfatter residual- eller skip-forbindelser, Jumping Knowledge-nettverk som kombinerer utdata fra lagene, og ganske enkelt å holde nettverket grunt. Grunne GCN-er gir ofte bedre resultater enn dype på standardreferanser.

Kunnskapssjekk

Test kunnskapen din om GCN-er.

Besvar den i den interaktive leksjonen

Oppsummering

Du har lært om grafkonvolusjonsnettverk:

GCN-er følger rammeverket for meldingspassing: De aggregerer naboeegenskaper og oppdaterer deretter noden
Den normaliserte nabomatrisen med selvsløyfer holder embeddingene stabile
GCNConv i PyTorch Geometric implementerer én konvolusjon
En vanlig arkitektur er et GCN med to lag
For stor dybde fører til oversmoothing

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 53
Leksjoner: 225

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Grafkonvolusjonsnettverk (GCN)» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Lær AI med Python, inkludert «Grafkonvolusjonsnettverk (GCN)», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Lær AI med Python inneholder totalt 4 leksjoner.

Hva lærer jeg i «Grafkonvolusjonsnettverk (GCN)»?

Rammeverk for meldingsformidling, GCNConv, aggregering av nodeegenskaper og oppsett av PyTorch Geometric. Du øver på Lær AI med Python med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Lær AI med Python?

Ingen tidligere erfaring er nødvendig. Lær AI med Python på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Grafkonvolusjonsnettverk (GCN)»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

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

Ja. Alle Lær AI med Python-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Lær AI med Python