Graph Convolutional Networks (GCNs) telah merevolusi cara kita menangani data berbasis graf. Dengan kemampuannya mempelajari representasi node yang kuat, GCN menjadi pilihan utama untuk berbagai tugas, termasuk klasifikasi node. Tutorial ini akan memandu Anda langkah demi langkah dalam membangun model GCN untuk klasifikasi node menggunakan PyTorch Geometric, salah satu library Python terpopuler untuk deep learning pada graf.
Apa Itu Klasifikasi Node?
Klasifikasi node adalah proses memprediksi label atau kategori dari sebuah node dalam graf. Bayangkan sebuah jaringan citation network, di mana setiap node adalah artikel ilmiah dan edge merepresentasikan sitasi antar artikel. Tugas klasifikasi node dalam kasus ini adalah menentukan kategori setiap artikel (misalnya, machine learning, computer vision, atau natural language processing) berdasarkan konten artikel dan bagaimana artikel tersebut terhubung dengan artikel lain dalam jaringan. Contoh lain adalah deteksi fraud dalam transaksi keuangan, di mana node adalah akun dan edge adalah transaksi. Klasifikasi node dapat membantu mengidentifikasi akun mana yang terlibat dalam aktivitas penipuan.
Graph Convolutional Networks (GCN) adalah solusi yang sangat efektif untuk masalah klasifikasi node. GCN bekerja dengan memanfaatkan struktur graf dan fitur-fitur node untuk mempelajari representasi embedding yang kaya informasi. Beberapa Kelebihan GCN antara lain kemampuannya untuk menangani data non-Euclidean (seperti graf), dan efisiensinya dalam Semi-Supervised Learning GCN, di mana hanya sebagian kecil node dalam graf yang memiliki label.
Dalam tutorial ini, kita akan menggunakan PyTorch Geometric, library yang menyediakan berbagai alat dan fungsi untuk mempermudah implementasi GCN dan model graph neural network lainnya.
Memahami Konsep Dasar GCN
Sebelum masuk ke implementasi, mari kita pahami dulu beberapa konsep dasar terkait graf. Graf terdiri dari node (atau vertex) dan edge (atau link) yang menghubungkan antar node. Dalam representasi matriks, graf seringkali direpresentasikan menggunakan adjacency matrix A. Jika ada edge dari node i ke node j, maka elemen Aij bernilai 1, dan 0 jika tidak ada edge.
Intuisi di balik Graph Convolutional Network adalah bahwa informasi tentang sebuah node dapat diperoleh dari node itu sendiri dan tetangga-tetangganya dalam graf. GCN melakukan ini melalui dua proses utama: agregasi dan update. Pada tahap agregasi, setiap node mengumpulkan informasi dari tetangga-tetangganya. Informasi ini kemudian digabungkan dengan informasi node itu sendiri pada tahap update untuk menghasilkan representasi node yang baru.
Baca juga: Panduan Lengkap Graph Neural Networks (GNN): Konsep, Cara Kerja & Aplikasi
Perbedaan GCN dan Graph Neural Network lainnya terletak pada cara melakukan agregasi dan update. GCN menggunakan operasi konvolusi yang dimodifikasi untuk graf, sedangkan model lain mungkin menggunakan pendekatan yang berbeda, seperti attention mechanism atau recurrent neural network.
Langkah-langkah Implementasi dengan PyTorch Geometric
Persiapan Dataset Cora
Untuk tutorial ini, kita akan menggunakan dataset Cora. Dataset Cora adalah dataset citation network yang populer, di mana node merepresentasikan artikel ilmiah dan edge merepresentasikan sitasi antar artikel. Dataset ini memiliki 2708 node, 5429 edge, 1433 fitur (fitur setiap node adalah bag-of-words representation dari artikel), dan 7 kelas (setiap kelas merepresentasikan bidang ilmu dari artikel). Dataset Klasifikasi Node ini sangat cocok untuk demonstrasi karena ukurannya yang relatif kecil namun tetap representatif.
Mari kita mulai dengan menginstal library yang diperlukan:
# Instal PyTorch Geometric (pastikan PyTorch sudah terinstal)
# Sesuaikan versi CUDA dengan konfigurasi sistem Anda
# pip install torch-scatter -f https://data.pyg.org/whl/torch-1.13.0+cu116.html
# pip install torch-sparse -f https://data.pyg.org/whl/torch-1.13.0+cu116.html
# pip install torch-geometric
# Library lain yang diperlukan
# pip install torch
# pip install numpy
# pip install scikit-learn
Note: Pastikan Anda menyesuaikan dengan enviroment anda. Kode instalasi di atas mungkin perlu dimodifikasi
Selanjutnya, kita muat dan proses dataset Cora:
import torch
from torch_geometric.datasets import Planetoid
from torch_geometric.transforms import NormalizeFeatures
# Muat dataset Cora
dataset = Planetoid(root='data/Cora', name='Cora', transform=NormalizeFeatures())
print(f'Dataset: {dataset}')
print('=' * 20)
print(f'Jumlah graf: {len(dataset)}')
print(f'Jumlah fitur: {dataset.num_features}')
print(f'Jumlah kelas: {dataset.num_classes}')
data = dataset[0] # Ambil graf pertama (dan satu-satunya) dalam dataset
print(data)
print('=' * 20)
print(f'Jumlah node: {data.num_nodes}')
print(f'Jumlah edge: {data.num_edges}')
print(f'Apakah graf memiliki node yang terisolasi?: {data.has_isolated_nodes()}')
print(f'Apakah graf memiliki self-loop?: {data.has_self_loops()}')
print(f'Apakah graf directed?: {data.is_directed()}')
# Bagi data menjadi data latih, validasi, dan uji
# PyTorch Geometric sudah menyediakan mask untuk ini
print(data.train_mask.sum().item(), 'training nodes')
print(data.val_mask.sum().item(), 'validation nodes')
print(data.test_mask.sum().item(), 'test nodes')
Kode di atas memuat dataset Cora, melakukan normalisasi fitur (NormalizeFeatures), dan menampilkan informasi tentang dataset, termasuk jumlah node, edge, fitur, kelas, dan pembagian data latih, validasi, dan uji.
Membangun Model GCN
Sekarang, mari kita definisikan model GCN kita menggunakan PyTorch Geometric. Implementasi GCN PyTorch ini akan terdiri dari dua layer GCNConv, diikuti oleh fungsi aktivasi ReLU, dan sebuah layer linear sebagai output.
import torch.nn.functional as F
from torch_geometric.nn import GCNConv
class GCN(torch.nn.Module):
def __init__(self, num_features, num_classes, hidden_channels):
super(GCN, self).__init__()
torch.manual_seed(12345) # Untuk reproducibility
self.conv1 = GCNConv(num_features, hidden_channels)
self.conv2 = GCNConv(hidden_channels, num_classes)
def forward(self, x, edge_index):
x = self.conv1(x, edge_index)
x = x.relu()
x = F.dropout(x, p=0.5, training=self.training)
x = self.conv2(x, edge_index)
return x
# Inisialisasi model
model = GCN(num_features=dataset.num_features, num_classes=dataset.num_classes, hidden_channels=16)
print(model)
Dalam kode di atas, GCNConv adalah layer konvolusi graf yang disediakan oleh PyTorch Geometric. Fungsi forward mendefinisikan bagaimana data mengalir melalui model. Kita menggunakan fungsi aktivasi ReLU dan dropout untuk regularisasi.
Sebagai fungsi loss, kita akan menggunakan Cross-Entropy Loss, dan sebagai optimizer, kita akan menggunakan Adam.
# Definisikan loss function dan optimizer
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
Melatih dan Mengevaluasi Model GCN
Berikut adalah kode untuk melatih model GCN. Tutorial GCN Python ini mendefinisikan hyperparameter seperti learning rate (lr) dan jumlah epoch.
def train():
model.train()
optimizer.zero_grad() # Bersihkan gradien
out = model(data.x, data.edge_index) # Forward pass
loss = criterion(out[data.train_mask], data.y[data.train_mask]) # Hitung loss hanya pada node latih
loss.backward() # Backpropagation
optimizer.step() # Update parameter
return loss
def test(mask):
model.eval()
out = model(data.x, data.edge_index)
pred = out.argmax(dim=1) # Ambil kelas dengan probabilitas tertinggi
correct = pred[mask] == data.y[mask] # Hitung jumlah prediksi yang benar
acc = int(correct.sum()) / int(mask.sum()) # Hitung akurasi
return acc
# Latih model
for epoch in range(1, 201):
loss = train()
val_acc = test(data.val_mask)
test_acc = test(data.test_mask)
print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}, Val Acc: {val_acc:.4f}, Test Acc: {test_acc:.4f}')
Kode di atas melatih model selama 200 epoch. Pada setiap epoch, kita melakukan forward pass, menghitung loss, melakukan backpropagation, dan mengupdate parameter model. Kita juga memantau loss dan akurasi pada data validasi dan data uji. Setelah pelatihan, kita evaluasi model pada data uji:
test_acc = test(data.test_mask)
print(f'Test Accuracy: {test_acc:.4f}')
Kode di atas menghitung akurasi model pada data uji. Akurasi yang baik (biasanya di atas 70% untuk dataset Cora) menunjukkan bahwa model berhasil mempelajari representasi node yang berguna untuk klasifikasi.
Memprediksi Label Node Baru
Untuk melakukan prediksi pada node baru, kita perlu membuat tensor yang merepresentasikan fitur node baru tersebut dan edge index yang menghubungkannya dengan node lain dalam graf. Kemudian, kita bisa menggunakan model yang telah dilatih untuk memprediksi label node tersebut:
# Contoh Prediksi label untuk node ke-0 (anggap node ini terhubung ke node 1 dan 2)
new_node_features = data.x[0].unsqueeze(0) # Ambil fitur node ke-0
new_edge_index = torch.tensor([[0, 1], [0, 2]], dtype=torch.long) # Edge index yang menghubungkan node baru ke node 1 dan 2
model.eval()
with torch.no_grad():
out = model(new_node_features, new_edge_index)
pred = out.argmax(dim=1) # Ambil kelas dengan probabilitas tertinggi
print(f'Predicted class: {pred.item()}')
Perlu diingat bahwa contoh di atas hanyalah ilustrasi. Dalam skenario nyata, Anda mungkin perlu memproses data node baru dengan cara yang sama seperti Anda memproses data latih.
Penerapan dan Pengembangan Lanjutan
Dalam tutorial ini, kita telah berhasil membangun, melatih, dan mengevaluasi model GCN untuk klasifikasi node pada dataset Cora. Hasil yang diperoleh menunjukkan bahwa GCN mampu memanfaatkan struktur graf dan fitur node untuk menghasilkan prediksi yang akurat.
Aplikasi GCN sangat luas, mencakup berbagai bidang seperti:
- Rekomendasi: Memprediksi item apa yang mungkin diminati oleh pengguna berdasarkan history interaksi mereka.
- Deteksi Komunitas: Mengidentifikasi kelompok-kelompok node yang saling terhubung erat dalam jaringan sosial.
- Bioinformatika: Memprediksi fungsi protein atau mengidentifikasi interaksi antar molekul.
- Pemrosesan Bahasa Alami: Memodelkan hubungan antar kata dalam dokumen.
- Serta Link Prediction: memprediksi edge atau link baru.
Untuk pengembangan lebih lanjut, Anda bisa mencoba arsitektur GCN yang berbeda (misalnya, dengan jumlah layer atau hidden units yang berbeda), menggunakan dataset yang lebih besar, atau menggabungkan GCN dengan model lain. Dengan menggunakan frasa transisi, alur transisi dari pembahasan aplikasi ke pengembangan lebih halus.
Dengan platform Kirim.ai, Anda dapat mengimplementasikan dan mengoptimalkan solusi berbasis AI seperti GCN dengan lebih mudah dan efisien. Kirim.ai menawarkan pengembangan platform yang komprehensif, termasuk aplikasi mobile (iOS & Android) dan website, serta solusi AI yang dapat disesuaikan dengan kebutuhan bisnis Anda. Pelajari lebih lanjut tentang bagaimana Kirim.ai dapat membantu Anda memanfaatkan kekuatan AI untuk mengembangkan bisnis Anda.
Kesimpulan
Klasifikasi node adalah tugas penting dalam analisis graf, dan Graph Convolutional Networks (GCN) telah terbukti menjadi solusi yang sangat efektif. Dalam tutorial ini, kita telah mempelajari cara membangun model GCN untuk klasifikasi node menggunakan PyTorch Geometric. Kita mulai dari konsep dasar GCN, persiapan data, definisi model, pelatihan, evaluasi, hingga prediksi pada node baru. Dengan pemahaman yang baik tentang GCN dan alat yang tepat, Anda dapat menerapkan graph machine learning untuk berbagai masalah dunia nyata.
Tanggapan (0 )