Learn AI with Python · Pelajaran

Klasifikasi Simpul dengan GNN

Dataset Cora, GCN 2 lapis, loop pelatihan, loss bermasker, akurasi pengujian, memvisualisasikan embedding.

Klasifikasi Simpul dengan GNN adalah pelajaran Learn AI with Python gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn AI with Python, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn AI with Python mencakup 4 pelajaran total.

Tugas Klasifikasi Simpul

Klasifikasi simpul memprediksi label untuk setiap simpul menggunakan fiturnya dan struktur graf. Contoh klasiknya adalah memberi label setiap makalah dalam jaringan sitasi berdasarkan topik penelitiannya, dengan menggunakan kata-kata dalam makalah serta makalah yang disitasi.

Kumpulan Data Cora

Cora adalah MNIST dalam pembelajaran graf. Cora merupakan graf sitasi yang terdiri dari 2.708 makalah pembelajaran mesin. Sisi-sisinya adalah sitasi; setiap makalah memiliki vektor fitur model kantong kata sepanjang 1433; tujuannya adalah mengklasifikasikan setiap makalah ke dalam salah satu dari 7 topik.

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

Memuat melalui Planetoid

PyTorch Geometric menyediakan Cora melalui pemuat Planetoid, yang mengunduh dan memformat 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 semuanya: data.x (fitur berukuran 2708 x 1433), data.edge_index (keterhubungan), data.y (label sebenarnya), dan masker boolean yang menandai simpul yang digunakan untuk pelatihan, validasi, dan pengujian.

GCN untuk 7 Kelas

Kita membangun GCN 2 lapisan yang memetakan 1433 fitur masukan melalui lapisan tersembunyi berdimensi 64 menjadi 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: seluruh graf (termasuk simpul pengujian dan fiturnya) terlihat selama pelatihan; kita hanya menyembunyikan label pengujian. Model menggunakan semua koneksi simpul, tetapi belajar hanya dari simpul pelatihan berlabel.

train_mask

train_mask adalah vektor boolean yang memilih simpul mana yang berkontribusi terhadap kerugian. Kita menjalankan model pada seluruh graf, tetapi menghitung entropi silang hanya pada simpul pelatihan yang dipilih oleh masker.

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 Kerugian Bermasker

Meskipun lintasan forward menghasilkan logit untuk semua 2708 simpul, pengindeksan dengan train_mask membatasi kerugian pada simpul pelatihan berlabel. Simpul tanpa label tetap meneruskan pesan sehingga membantu model, tetapi tidak secara langsung menggerakkan gradien.

Mengevaluasi dengan test_mask

Setelah pelatihan, kita mengevaluasi akurasi pada simpul test_mask yang disisihkan dan tidak pernah digunakan oleh kerugian. Hal ini mengukur kemampuan generalisasi terhadap makalah yang labelnya belum pernah dilihat 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())

Memvisualisasikan Penyematan dengan t-SNE

Untuk melihat apa yang dipelajari GCN, ambil penyematan simpul dari lapisan tersembunyi dan proyeksikan ke 2D dengan t-SNE. GCN yang terlatih dengan baik menghasilkan klaster tempat simpul-simpul dari kelas yang sama berkumpul.

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)

Menafsirkan Plot t-SNE

Klaster berwarna yang terpisah dengan baik berarti penyematan dapat membedakan kelas, yang menandakan bahwa GCN mempelajari struktur yang berguna. Gumpalan yang saling tumpang tindih menunjukkan pelatihan yang kurang atau penghalusan berlebihan. t-SNE adalah pemeriksaan kualitatif, bukan metrik.

Uji Cepat

Uji pengetahuan Anda tentang klasifikasi simpul.

Rangkuman

Anda telah mempelajari klasifikasi simpul dengan GNN:

Planetoid memuat graf sitasi Cora
GCN 2 lapisan memetakan kelas 1433 ke 64 ke 7
train_mask membatasi kerugian; test_mask mengukur generalisasi
t-SNE memvisualisasikan penyematan simpul untuk memeriksa pemisahan kelas

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Klasifikasi Simpul dengan GNN” gratis?

Ya — teks lengkap “Klasifikasi Simpul dengan GNN” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn AI with Python, upgrade ke CoddyKit PRO. Kursus Learn AI with Python mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Klasifikasi Simpul dengan GNN”?

Dataset Cora, GCN 2 lapis, loop pelatihan, loss bermasker, akurasi pengujian, memvisualisasikan embedding. Kamu berlatih Learn AI with Python dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn AI with Python?

Tidak diperlukan pengalaman sebelumnya. Learn AI with Python di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Klasifikasi Simpul dengan GNN” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn AI with Python ini?

Ya. Setiap pelajaran Learn AI with Python menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Learn AI with Python