Pelajari AI dengan Python · Pelajaran

Pengelasan Nod dengan GNN

Dataset Cora, GCN 2 lapisan, gelung latihan, kehilangan bertopeng, ketepatan ujian, memvisualkan benaman.

Pelajaran 3 daripada 413 langkah

Pengelasan Nod dengan GNN ialah pelajaran Pelajari AI dengan Python percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Pelajari AI dengan Python, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Pelajari AI dengan Python merangkumi sejumlah 4 pelajaran.

Tugas Pengelasan Nod

Pengelasan nod meramalkan label bagi setiap nod menggunakan cirinya dan struktur graf. Contoh klasiknya ialah melabelkan setiap kertas dalam rangkaian petikan mengikut topik penyelidikannya, menggunakan perkataan dalam kertas serta kertas yang dipetiknya.

Set Data Cora

Cora ialah MNIST bagi pembelajaran graf. Ia merupakan graf petikan yang mengandungi 2,708 kertas pembelajaran mesin. Sisi ialah petikan; setiap kertas mempunyai vektor ciri beg-perkataan sepanjang 1433; matlamatnya ialah mengelaskan setiap kertas kepada salah satu daripada 7 topik.

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

Memuatkan melalui Planetoid

PyTorch Geometric menyediakan Cora melalui pemuat Planetoid, yang memuat turun dan memformatkan data menjadi satu objek graf.

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

Objek Data

Objek graf menyimpan segala-galanya: data.x (ciri 2708 x 1433), data.edge_index (kesalinghubungan), data.y (label sebenar), serta topeng Boolean yang menandakan nod untuk latihan, pengesahan dan ujian.

GCN untuk 7 Kelas

Kita membina GCN dua lapisan yang memetakan 1433 ciri input melalui lapisan tersembunyi 64 dimensi kepada 7 logit kelas.

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)

Pembelajaran Transduktif

Cora bersifat transduktif: keseluruhan graf (termasuk nod ujian dan cirinya) dapat dilihat semasa latihan; kita hanya menyembunyikan label ujian. Model menggunakan semua sambungan nod tetapi belajar daripada nod latihan berlabel sahaja.

Topeng Latihan

Topeng latihan ialah vektor Boolean yang memilih nod yang menyumbang kepada kehilangan. Kita menjalankan model pada keseluruhan graf tetapi mengira entropi silang hanya pada nod latihan bertopeng.

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

Intuisi Kehilangan Bertopeng

Walaupun laluan forward menghasilkan logit bagi kesemua 2708 nod, pengindeksan dengan train_mask mengehadkan kehilangan kepada nod latihan berlabel. Nod yang tidak berlabel masih menghantar mesej dan membantu model, tetapi tidak memacu kecerunan secara langsung.

Menilai dengan Topeng Ujian

Selepas latihan, kita menilai ketepatan pada nod topeng ujian yang diketepikan, yang tidak pernah disentuh oleh kehilangan. Ini mengukur pengitlakan kepada kertas yang labelnya tidak pernah dilihat oleh model.

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

Memvisualkan Pembenaman dengan t-SNE

Untuk melihat perkara yang dipelajari GCN, ambil pembenaman nod daripada lapisan tersembunyi dan unjurkannya kepada 2D dengan t-SNE. GCN yang dilatih dengan baik menghasilkan kelompok yang mengumpulkan nod daripada kelas yang sama.

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)

Mentafsir Plot t-SNE

Kelompok berwarna yang terpisah dengan jelas bermaksud pembenaman dapat membezakan kelas, iaitu tanda bahawa GCN mempelajari struktur yang berguna. Gumpalan yang bertindih mencadangkan latihan tidak mencukupi atau pelicinan berlebihan. t-SNE ialah semakan kualitatif, bukan metrik.

Semakan Pantas

Uji pengetahuan anda tentang pengelasan nod.

Jawab dalam pelajaran interaktif

Imbas Kembali

Anda telah mempelajari pengelasan nod dengan GNN:

Planetoid memuatkan graf petikan Cora
GCN dua lapisan memetakan 1433 kepada 64 kepada 7 kelas
Topeng latihan mengehadkan kehilangan; topeng ujian mengukur pengitlakan
t-SNE memvisualkan pembenaman nod untuk memeriksa pemisahan kelas

Percuma untuk bermula

Pelajari Python dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 53
Pelajaran: 225

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Pengelasan Nod dengan GNN” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Pelajari AI dengan Python, termasuk “Pengelasan Nod dengan GNN”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Pelajari AI dengan Python merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Pengelasan Nod dengan GNN”?

Dataset Cora, GCN 2 lapisan, gelung latihan, kehilangan bertopeng, ketepatan ujian, memvisualkan benaman. Anda berlatih Pelajari AI dengan Python menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Pelajari AI dengan Python?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Pelajari AI dengan Python di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Pengelasan Nod dengan GNN” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Pelajari AI dengan Python ini?

Ya. Setiap pelajaran Pelajari AI dengan Python menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Pelajari AI dengan Python