Menyelami Lebih Dalam Rangkaian Neural Graf

Rangkaian Neural Graf (GNN) telah menjadi seni bina pembelajaran mendalam yang kuat untuk memahami data yang kompleks dan saling berkaitan. Tidak seperti rangkaian neural tradisional yang berfungsi pada input bersaiz tetap seperti imej atau urutan, GNN direka untuk memahami hubungan yang menangkap bagaimana entiti berhubung, mempengaruhi, dan berinteraksi dalam sesuatu graf. Ini menjadikannya sangat berharga dalam bidang di mana struktur penting, daripada rangkaian sosial dan kimia molekul hingga enjin cadangan dan pengesanan penipuan.

Dalam artikel ini, kami akan menghuraikan idea-idea utama di sebalik GNN, meneroka bagaimana ia berkembang, dan menyoroti cabaran dunia sebenar yang dapat diselesaikannya. Anda juga akan belajar bagaimana GNN dilaksanakan dalam praktik, dengan contoh praktikal yang dibina menggunakan perpustakaan PyTorch.

Perkara Penting

Rangkaian Neural Graf (GNN) berfungsi dengan baik untuk memodelkan hubungan dalam data yang saling berkaitan, menjadikannya sesuai untuk tugasan di mana struktur dan kebergantungan adalah penting.
GNN mempelbagaikan pembelajaran mendalam tradisional kepada format graf, membolehkan pembelajaran daripada nod, sisi, dan hubungan mereka.
Senibina GNN Popular, seperti Rangkaian Konvolusi Graf (GCN), Rangkaian Perhatian Graf (GAT), dan GraphSAGE, menawarkan pelbagai cara untuk mengagregat dan menyebarkan maklumat merentasi nod.
Penggunaan dunia sebenar GNN merangkumi analisis rangkaian sosial, ramalan sifat molekul, sistem cadangan, pengesanan penipuan, dan graf pengetahuan.
Melaksanakan GNN adalah boleh diakses dengan kerangka moden seperti PyTorch Geometric, yang memudahkan pengurusan data, pemindahan mesej, dan pembinaan model.
Pelaksanaan secara langsung menunjukkan aliran kerja GNN, termasuk memuatkan data graf, mentakrifkan model, latihan, dan menilai keputusan.
GNN terus berkembang dengan pesat, dengan kemajuan yang meningkatkan kebolehskalaan, kecekapan, dan prestasi dalam mengendalikan graf yang semakin besar dan kompleks.

Apakah Rangkaian Neural Graf?

Rangkaian Neural Graf, atau GNN untuk singkatnya, adalah jenis rangkaian neural yang agak baru yang dapat bekerja dengan data yang disusun seperti graf. Graf pada dasarnya adalah sekumpulan objek, yang diwakili sebagai nod, dan hubungan antara objek tersebut, yang diwakili sebagai tepi yang menghubungkan nod, dan GNN boleh mengendalikan kedua-dua graf berarah, di mana tepi mempunyai arah, dan graf tidak berarah, di mana tepi tidak mempunyai arah tertentu. Graf ini juga boleh berbeza secara signifikan dari segi saiz dan bentuk. Seni bina GNN terdiri daripada berbilang lapisan, setiap satu daripadanya mengambil maklumat dari lapisan sebelumnya. Kami memberikan GNN graf yang diwakili sebagai satu set nod dan tepi, bersama dengan ciri-ciri yang berkaitan dengan mereka. Apa yang kita peroleh adalah satu set pengekodan nod untuk setiap nod dalam graf input. Pengekodan ini mewakili ciri-ciri yang dipelajari oleh rangkaian untuk setiap nod. Daripada hanya beroperasi pada vektor, matriks, atau tensor seperti rangkaian neural biasa, GNN boleh bekerja dengan data yang distrukturkan sebagai graf sepenuhnya. Ini menjadikannya sangat fleksibel untuk bekerja dengan data berjejaring, seperti rangkaian sosial, struktur molekul, atau sistem pengangkutan. Matematik yang terlibat adalah kompleks, tetapi idea utamanya ialah mereka berulang melalui graf, menghantar mesej antara nod untuk mempelajari representasi yang berguna.

Bagaimana Rangkaian Neural Graf berfungsi?

Rangkaian neural graf, atau GNN untuk singkatannya, adalah berkaitan dengan pembelajaran corak antara nod dalam sesebuah rangkaian. Idea utama adalah setiap nod menghantar mesej kepada nod jiranannya, berkongsi maklumat tentang dirinya sendiri.

Dalam GNN, setiap nod bertukar maklumat dengan nod yang bersambung dengannya, membantu model memahami struktur graf sepenuhnya secara beransur-ansur.
Setiap nod mencipta sebuah "mesej" menggunakan ciri-cirinya sendiri dan ciri-ciri nod jirannya.
Pada masa yang sama, nod berhampiran menjana dan menghantar mesej mereka sendiri kembali.
Apabila satu nod menerima mesej-mesej ini, ia mengemas kini keadaan dalaman dengan menggabungkan semua maklumat yang diterima.
Pemindahan mesej yang berulang ini membolehkan pengetahuan mengalir melalui graf, membolehkan nod mempelajari bahagian graf di luar jiran terdekat mereka.
Dengan menumpuk beberapa lapisan proses ini, GNN dapat mempelajari hubungan yang lebih kompleks dan mendalam.
Dengan setiap lapisan yang ditambah, model membina representasi ciri graf yang lebih kaya dan bermakna.

Melaksanakan Rangkaian Neural Grafik dalam PyTorch

Set data Cora

Set data Cora ialah penanda aras yang popular yang digunakan oleh penyelidik yang bekerja dalam pembelajaran representasi graf. Set data ini merangkumi sekumpulan penerbitan saintifik yang dibahagikan kepada tujuh kategori seperti "Case Based," "Genetic Algorithms," "Neural Networks," "Probabilistic Methods," "Reinforcement Learning," dan "Rule Learning." Set data Cora telah wujud untuk beberapa waktu dan kekal sebagai sumber utama bagi banyak projek dalam bidang ini. Ia menyediakan kaedah untuk menilai sejauh mana model anda boleh menganalisis kedua-dua kandungan teks dokumen dan rangkaian berhubung petikan di antara mereka. Banyak kertas penyelidikan jaringan neural graf yang terkenal telah menggunakan Cora untuk menilai prestasi dalam kedua-dua tugas ini. Ia dibina sebagai graf dengan penerbitan sebagai nod dan sitasi antara mereka sebagai tepi yang menghubungkan nod tersebut. Setiap dokumen dikaitkan dengan vektor ciri yang mewakili kandungannya. Cabaran di sini adalah untuk membangunkan model yang dapat melihat graf sitasi, vektor kandungan, dan hubungan antara mereka untuk meramalkan kelas mana dari tujuh kelas yang mana-mana penerbitan itu tergolong.

Proproses Data

Kami memasang perpustakaan PyTorch Geometric dengan arahan:

pip install torch_geometric

Kita kemudian boleh menggunakan perpustakaan PyTorch Geometric untuk memuat dan memproses set data tersebut.

from torch_geometric.datasets import Planetoid
import torch_geometric.transforms as T

dataset = Planetoid(root='data/Cora', name='Cora', transform=T.NormalizeFeatures())

Kelas Planetoid memuatkan set data Cora dan menormalkan vektor ciri. Kita boleh mendapatkan data yang telah dipra-proses menggunakan set data tersebut, yang memberi kita objek Data dengan atribut-atribut ini:

x: satu matriks ciri nod dengan bentuk ‘(num_nodes, num_features)’
edge_index: matriks hubungan tepi berbentuk ‘(2, num_edges)’
y: vektor label nod dengan bentuk ‘(num_nodes)’
train_mask, val_mask, test_mask: topeng boolean yang menunjukkan nod mana untuk latihan, pengesahan, dan pengujian.

Senibina Model

Apabila membina rangkaian neural graf, memilih seni bina model yang betul adalah sangat penting. Kami akan menerangkan pelaksanaan asas menggunakan perpustakaan torch_geometric PyTorch. Kami akan menggunakan rangkaian konvolusi graf, yang berfungsi sebagai titik permulaan yang baik untuk pelbagai tugas pembelajaran graf.

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

class GNN(torch.nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels):
        super(GNN, self).__init__()
        # Define the first graph convolutional layer
        self.conv1 = GCNConv(in_channels, hidden_channels)
        # Define the second graph convolutional layer
        self.conv2 = GCNConv(hidden_channels, out_channels)
        # Define the linear layer
        self.linear = torch.nn.Linear(out_channels, out_channels)

    def forward(self, x, edge_index):
        # Apply the first graph convolutional layer
        x = self.conv1(x, edge_index)
        # Apply the ReLU activation function
        x = F.relu(x)
        # Apply the second graph convolutional layer
        x = self.conv2(x, edge_index)
        # Apply the ReLU activation function
        x = F.relu(x)
        # Apply the linear layer
        x = self.linear(x)
        # Apply the log softmax activation function
        return F.log_softmax(x, dim=1)

Dalam kod di atas, kami mengimport torch dan torch.nn.functional untuk mendapatkan akses kepada beberapa modul dan fungsi rangkaian neural yang berguna. Kemudian, kami mendefinisikan kelas GNN yang mewarisi dari torch dan nn.Module.
Dalam kaedah init, kami telah mentakrifkan dua lapisan konvolusi menggunakan modul GCNConv dari PyTorch Geometric. Ini membolehkan pelaksanaan konvolusi graf dengan mudah. Kami telah menambah satu lapisan linear yang ringkas.
Laluan hadapan pertama-tamanya menghantar input melalui dua lapisan konvolusi, setiap kali menggunakan pengaktifan ReLU. Kemudian ia melalui lapisan linear dan akhirnya log softmax untuk menekan output.

Dalam beberapa baris kod, kita boleh membina rangkaian neural graf kecil yang hebat!

Jelas, ini adalah contoh yang mudah, tetapi kita dapat melihat bagaimana PyTorch dan PyTorch Geometric membolehkan kita dengan cepat membina prototaip dan mengulangi arkitektur rangkaian neural graf. Lapisan GCNConv menjadikan ia sangat mudah untuk menggabungkan struktur graf ke dalam model kita.

Latihan

Untuk latihan, kami akan menggunakan kerugian cross-entropy dan pengoptimum Adam. Kami boleh membahagikan data kepada set latihan, pengesahan, dan ujian menggunakan atribut topeng tersebut pada objek Data.

# Set the device to CUDA if available, otherwise use CPU
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# Define the GNN model with the specified input, hidden, and output dimensions, and move it to the device
model = GNN(dataset.num_features, 16, dataset.num_classes).to(device)
# Define the Adam optimizer with the specified learning rate and weight decay
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)

# Define the training function
def train():
    # Set the model to training mode
    model.train()
    # Zero the gradients of the optimizer
    optimizer.zero_grad()
    # Perform a forward pass of the model on the training nodes
    out = model(dataset.x.to(device), dataset.edge_index.to(device))
    # Compute the negative log-likelihood loss on the training nodes
    loss = F.nll_loss(out[dataset.train_mask], dataset.y[dataset.train_mask])
    # Compute the gradients of the loss with respect to the model parameters
    loss.backward()
    # Update the model parameters using the optimizer
    optimizer.step()
    # Return the loss as a scalar value
    return loss.item()

# Define the testing function
@torch.no_grad()
def test():
    # Set the model to evaluation mode
    model.eval()
    # Perform a forward pass of the model on all nodes
    out = model(dataset.x.to(device), dataset.edge_index.to(device))
    # Compute the predicted labels by taking the argmax of the output scores
    pred = out.argmax(dim=1)
    # Compute the training, validation, and testing accuracies
    train_acc = pred[dataset.train_mask].eq(dataset.y[dataset.train_mask]).sum().item() / dataset.train_mask.sum().item()
    val_acc = pred[dataset.val_mask].eq(dataset.y[dataset.val_mask]).sum().item() / dataset.val_mask.sum().item()
    test_acc = pred[dataset.test_mask].eq(dataset.y[dataset.test_mask]).sum().item() / dataset.test_mask.sum().item()
    # Return the accuracies as a tuple
    return train_acc, val_acc, test_acc

# Train the model for 500 epochs
for epoch in range(1, 500):
    # Perform a single training iteration and get the loss
    loss = train()
    # Evaluate the model on the training, validation, and testing sets and get the accuracies
    train_acc, val_acc, test_acc = test()
    # Print the epoch number, loss, and accuracies
    print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}, Train Acc: {train_acc:.4f}, Val Acc: {val_acc:.4f}, Test Acc: {test_acc:.4f}')

Fungsi train menjalankan satu pusingan latihan dan mengembalikan kerugian. Fungsi test memeriksa bagaimana prestasi model pada set latihan, pengesahan, dan ujian serta mengembalikan ketepatan. Kami melatih model selama 500 epoch dan mencetak ketepatan latihan dan ujian pada setiap epoch.

Kira ketepatan model GNN

Kod di bawah mentakrifkan satu fungsi untuk mengira sejauh mana ketepatan model pada keseluruhan set data. Fungsi compute_accuracy() menukar model kepada mod penilaian, melaksanakan laluan ke hadapan, dan meramalkan label untuk setiap nod. Ia membandingkan label yang diramalkan ini dengan label sebenar dan mengira bilangan ramalan yang betul. Kemudian ia membahagikan bilangan ramalan yang betul dengan jumlah nod dalam set data untuk mendapatkan peratusan ketepatan.

@torch.no_grad()
def compute_accuracy():
    model.eval()
    out = model(dataset.x.to(device), dataset.edge_index.to(device))
    pred = out.argmax(dim=1)
    correct = pred.eq(dataset.y.to(device)).sum().item()
    total = dataset.y.shape[0]
    accuracy = correct / total
    return accuracy

accuracy = compute_accuracy()
print(f"Accuracy: {accuracy:.4f}")

Dalam kes ini, ketepatan model pada dataset Cora ialah 0.8006. Ini bermakna kira-kira 80% masa, model mampu meramalkan label kelas dengan betul. Itu agak baik, tetapi tidak sempurna. Ketepatan memberikan kita pandangan keseluruhan yang cepat tentang sejauh mana model berprestasi. Tetapi anda perlu mengkaji lebih mendalam untuk benar-benar memahami di mana ia berjaya dan di mana ia menghadapi kesukaran.

Untuk mendapatkan pemahaman yang lebih mendalam tentang keberkesanan model, adalah disyorkan untuk mempertimbangkan metrik penilaian lain seperti ketepatan, panggilan balik, skor F1, dan matriks kekeliruan. Metrik-metrik ini memberikan pandangan tentang prestasi model dari pelbagai aspek, seperti mengenal pasti kes positif dan negatif dengan betul serta mengendalikan set data yang tidak seimbang. Jadi walaupun ketepatan 80% adalah baik, kita ingin mendapatkan lebih banyak konteks sebelum mengisytiharkan model ini sebagai kejayaan besar. Metrik ketepatan sahaja tidak memberikan gambaran penuh tentang apa yang berlaku di sebalik tabir. Tetapi ia adalah titik permulaan yang baik untuk menilai prestasi.

Penilaian

Kita boleh menilai prestasi GNN menggunakan perkara seperti ketepatan, presisi, panggilan kembali, dan skor F1. Tetapi, kita juga boleh memvisualisasikan penanam node yang dipelajari model menggunakan t-SNE. Ia mengambil penanam berdimensi tinggi dan memproyeksikannya ke dalam 2D, membolehkan kita memvisualisasikannya.

# Import the necessary libraries
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt

# Set the model to evaluation mode
model.eval()

# Perform a forward pass of the model on the dataset
out = model(dataset.x.to(device), dataset.edge_index.to(device))

# Apply t-SNE to the output feature matrix to obtain a 2D embedding
emb = TSNE(n_components=2).fit_transform(out.cpu().detach().numpy())

# Create a figure with a specified size
plt.figure(figsize=(10,10))

# Create a scatter plot of the embeddings, color-coded by the true labels
plt.scatter(emb[:,0], emb[:,1], c=dataset.y, cmap='jet')

# Display the plot
plt.show()

Nota: Pembaca boleh menjalankan kod di atas. Ia akan memaparkan plot sebaran yang boleh ditafsirkan. Kod ini menggunakan t-SNE untuk menunjukkan embedding nod yang dipelajari dalam plot sebaran 2D, yang merupakan cara bijak untuk memvisualisasikan data berdimensi tinggi. Mari kita lihat apa yang sedang berlaku:

Setiap titik dalam graf mewakili satu nod dalam set data. Paksi x dan y adalah dua dimensi di mana t-SNE memampatkan penjelmaan tersebut. Warna setiap titik mewakili label sebenar nod yang sepadan dalam set data itu.
Node yang mempunyai imbangan serupa sepatutnya mempunyai label yang serupa, jadi mereka akan berkumpul bersama pada plot. Sebaliknya, node dengan imbangan yang sangat berbeza mungkin mempunyai label yang berbeza, jadi mereka akan berada lebih jauh antara satu sama lain.
Secara keseluruhan, plot itu memberikan gambaran yang jelas tentang hubungan antara nod berdasarkan embeding yang dipelajari. Anda boleh melihat kumpulan terbentuk yang pasti berkongsi beberapa persamaan asas. Ia adalah cara yang berguna untuk mengintai dalam model dan memahami bagaimana ia menyusun konsep.

Cabaran dan Pertimbangan Potensi

Dengan 2708 nod dan 5429 tepi, set data Cora dianggap agak kecil. Ini mungkin menghalang kecekapan GNN, memerlukan penggunaan kaedah yang lebih canggih seperti augmentasi data dan pembelajaran pemindahan.
Dataset Cora terdiri daripada satu jenis nod dan satu jenis tepi, menjadikannya rangkaian homogen. Ini mungkin mengehadkan kebolehgunaan GNN apabila digunakan pada rangkaian yang lebih kompleks, yang melibatkan pelbagai jenis nod dan tepi.
Memilih nilai yang sesuai untuk hiperparameter, seperti bilangan lapisan tersembunyi, bilangan unit tersembunyi, dan kadar pembelajaran, boleh memberi kesan yang ketara terhadap prestasi GNN dan memerlukan penalaan yang teliti.

Soalan Lazim

1. Apa itu Rangkaian Neural Graf (GNN)?

GNN ialah rangkaian neural yang direka untuk bekerja dengan data berbentuk graf. Ia mempelajari representasi pada tahap nod, tepi, atau graf dengan mengumpul maklumat daripada nod jiran.

2. Bagaimana GNN berbeza daripada rangkaian neural tradisional?

Rangkaian tradisional mengendalikan data berbentuk grid (imej, urutan), manakala GNN boleh memodelkan struktur yang tidak teratur dan saling berkaitan seperti rangkaian sosial atau graf molekul.

3. Jenis masalah apa yang digunakan oleh GNN?

Mereka biasanya digunakan untuk pengelasan nod, ramalan pautan, pengelasan graf, cadangan, pengesanan penipuan, dan ramalan sifat molekul.

4. Apakah penghantaran mesej dalam GNN?

Pemindahan mesej adalah mekanisme teras di mana nod bertukar maklumat dengan jiran mereka, mengemas kini pengekodan, dan mempelajari hubungan kontekstual.

5. Adakah GNN berskala dengan baik untuk graf yang sangat besar?

Penalaan boleh menjadi mencabar disebabkan oleh penggunaan memori dan pengembangan kejiranan. Teknik seperti pensampelan (GraphSAGE), mini-batching, dan latihan diedarkan dapat membantu.

6. Perpustakaan pengaturcaraan manakah yang terbaik untuk melaksanakan GNN?

Rangka kerja yang popular termasuk PyTorch Geometric (PyG) dan Deep Graph Library (DGL), kedua-duanya menawarkan lapisan dan utiliti sedia ada untuk membina model GNN.

7. Adakah GNN sesuai untuk aplikasi masa nyata?

Ya, bergantung pada kerumitan model. Seni bina ringan dan pendekatan berasaskan pensampelan membantu mencapai prestasi hampir masa nyata.

8. Bolehkah GNN mengendalikan graf yang dinamik atau berkembang?

Ya, varian GNN dinamik boleh memproses graf yang berubah dari semasa ke semasa, berguna untuk ramalan trafik, cadangan temporal, dan pengesanan anomali.

9. Apakah prapemprosesan data yang diperlukan untuk GNN?

Anda biasanya perlu menyediakan maklumat keterhubungan, ciri-ciri nod/sisi, dan memastikan graf diformatkan dengan betul untuk pustaka yang anda pilih.

10. Adakah GNN boleh ditafsir?

Kebolehtafsiran semakin bertambah baik dengan alat seperti mekanisme perhatian dan GNNExplainer, yang menonjolkan nod dan tepi yang berpengaruh.

Kesimpulan

Dalam artikel ini, kami menerangkan konsep asas di sebalik Rangkaian Neural Graf (GNNs) dan meneroka bagaimana ia boleh digunakan dalam pelbagai bidang. GNN sangat sesuai untuk bekerja dengan data yang berstruktur graf, membolehkan model menilai hubungan kompleks yang terdapat dalam rangkaian sosial, graf molekul, sistem pengangkutan, dan banyak lagi.

Untuk menunjukkan idea-idea ini dalam praktik, kami menggunakan set data popular Cora—satu penanda aras untuk pembelajaran graf. Dalam set data ini, setiap penerbitan diwakili sebagai satu nod, dan petikan antara penerbitan tersebut membentuk sisi-sisi. Objektif kami adalah untuk menggunakan kedua-dua ciri teks setiap kertas dan pautan petikan untuk meramalkan kategorinya.

Kami menyediakan set data menggunakan perpustakaan PyTorch Geometric, menormalkan vektor ciri dan membahagikan data kepada set latihan, pengesahan, dan ujian. Kami kemudian membina GNN mudah menggunakan lapisan konvolusi graf, diikuti dengan pengelasan linear, dan melatihnya menggunakan kerugian silang-entropy dengan pengoptimum Adam. Akhirnya, kami menilai prestasi model dengan mengukur ketepatannya.

Walaupun terdapat banyak teknik tambahan dan penambahbaikan yang boleh diterokai, projek ini menawarkan pengenalan yang kukuh tentang bagaimana GNN beroperasi dan betapa berkesannya mereka untuk pembelajaran daripada data hubungan yang kompleks.

Sumber

Membina Rangkaian Neural Dari Awal: Bahagian 1
Apa itu Pembelajaran Mendalam? Panduan Pemula untuk Rangkaian Neural
Arkitek Pembelajaran Mendalam Dijelaskan: ResNet, InceptionV3, SqueezeNet
PyTorch 101: Belajar Pembelajaran Mendalam dengan PyTorch

Terima kasih kerana belajar bersama Komuniti Linux-Console.net.