Tìm kiếm trang web

Khám Phá Sâu Hơn về Mạng Nơ-ron Đồ Thị

Mạng nơ-ron đồ thị (GNNs) đã trở thành một kiến trúc học sâu mạnh mẽ để hiểu dữ liệu phức tạp, liên kết. Khác với các mạng nơ-ron truyền thống hoạt động trên các đầu vào kích thước cố định như hình ảnh hoặc chuỗi, GNN được thiết kế để hiểu các mối quan hệ nắm bắt cách các thực thể kết nối, ảnh hưởng và tương tác trong một đồ thị. Điều này khiến chúng đặc biệt có giá trị trong các lĩnh vực nơi cấu trúc quan trọng, từ mạng xã hội và hóa học phân tử đến các công cụ gợi ý và phát hiện gian lận.

Trong bài viết này, chúng ta sẽ phân tích những ý tưởng cốt lõi đằng sau các GNN, tìm hiểu cách chúng phát triển, và nhấn mạnh những thách thức thực tế mà chúng giúp giải quyết. Bạn cũng sẽ học cách GNN được triển khai trong thực tế, với một ví dụ thực hành xây dựng bằng thư viện PyTorch.

Điểm chính

  • Mạng nơ-ron đồ thị (GNNs) hoạt động rất tốt trong việc mô hình hóa các mối quan hệ trong dữ liệu liên kết, làm cho chúng trở nên lý tưởng cho các nhiệm vụ mà cấu trúc và sự phụ thuộc quan trọng.
  • GNNs tổng quát hóa học sâu truyền thống sang định dạng đồ thị, cho phép học từ các nút, các cạnh và sự kết nối giữa chúng.
  • Kiến trúc GNN phổ biến, chẳng hạn như Mạng Nơ-ron Tích chập Đồ thị (GCN), Mạng Chú ý Đồ thị (GAT), và GraphSAGE, cung cấp các cách khác nhau để tổng hợp và truyền thông tin giữa các nút.
  • Các ứng dụng thực tế của GNN bao gồm phân tích mạng xã hội, dự đoán đặc tính phân tử, hệ thống gợi ý, phát hiện gian lận và đồ thị tri thức.
  • Triển khai GNN trở nên dễ dàng với các framework hiện đại như PyTorch Geometric, giúp đơn giản hóa việc xử lý dữ liệu, truyền thông điệp và xây dựng mô hình.
  • Một triển khai thực hành minh họa quy trình làm việc của GNN, bao gồm tải dữ liệu đồ thị, định nghĩa mô hình, huấn luyện và đánh giá kết quả.
  • GNNs tiếp tục phát triển nhanh chóng, với những tiến bộ cải thiện khả năng mở rộng, hiệu quả và hiệu suất trong xử lý các đồ thị ngày càng lớn và phức tạp.

Mạng nơ-ron đồ thị là gì?

Mạng nơ-ron đồ thị, hay còn gọi tắt là GNN, là một loại mạng nơ-ron tương đối mới có thể làm việc với dữ liệu được cấu trúc giống như đồ thị. Đồ thị về cơ bản là một tập hợp các đối tượng, được biểu diễn dưới dạng các nút, và các mối quan hệ giữa các đối tượng đó, được biểu diễn dưới dạng các cạnh nối các nút, và GNN có thể xử lý cả đồ thị có hướng, nơi các cạnh có hướng cụ thể, và đồ thị vô hướng, nơi các cạnh không có hướng cố định. Các đồ thị này cũng có thể khác nhau đáng kể về kích thước và hình dạng. Kiến trúc của một GNN bao gồm nhiều lớp, mỗi lớp lấy thông tin từ lớp trước đó. Chúng ta cung cấp cho GNN một đồ thị được biểu diễn dưới dạng tập hợp các nút và cạnh, cùng với các đặc điểm liên quan của chúng. Những gì chúng ta nhận được là một tập hợp các biểu diễn nút cho mỗi nút trong đồ thị đầu vào. Những biểu diễn này thể hiện các đặc trưng mà mạng đã học được cho từng nút. Thay vì chỉ thao tác trên các vec-tơ, ma trận hoặc tensor như một mạng nơ-ron thông thường, GNN có thể làm việc với dữ liệu được cấu trúc dưới dạng đồ thị hoàn chỉnh. Điều này giúp chúng thực sự linh hoạt khi làm việc với dữ liệu mạng, như mạng xã hội, cấu trúc phân tử hoặc hệ thống giao thông. Toán học liên quan khá phức tạp, nhưng ý tưởng tổng quát là chúng lặp qua đồ thị, truyền thông điệp giữa các nút để học các biểu diễn hữu ích.

Mạng nơ-ron đồ thị hoạt động như thế nào?

Mạng nơ-ron đồ thị, hay gọi tắt là GNN, là về việc học các mẫu giữa các nút trong một mạng. Ý tưởng chính là mỗi nút gửi thông điệp đến các nút lân cận của nó, chia sẻ thông tin về chính nó.

  • Trong một mạng nơ-ron đồ thị (GNN), mỗi nút trao đổi thông tin với các nút mà nó được kết nối, giúp mô hình dần dần hiểu được toàn bộ cấu trúc đồ thị.
  • Mỗi nút tạo ra một “thông điệp” sử dụng các đặc trưng của chính nó và các đặc trưng của các nút lân cận.
  • Cùng lúc đó, các nút lân cận tạo ra và gửi các tin nhắn của riêng chúng trở lại.
  • Khi một nút nhận được những tin nhắn này, nó cập nhật trạng thái nội bộ của mình bằng cách tổng hợp tất cả thông tin nhận được.
  • Việc truyền thông điệp lặp đi lặp lại này cho phép kiến thức chảy qua đồ thị, giúp các nút học về những phần của đồ thị vượt ra ngoài các nút lân cận trực tiếp của chúng.
  • Bằng cách xếp chồng nhiều lớp của quá trình này, GNN có thể học được những mối quan hệ phức tạp và sâu hơn.
  • Với mỗi lớp được thêm vào, mô hình xây dựng các biểu diễn đặc trưng phong phú và có ý nghĩa hơn của đồ thị.

Triển khai Mạng Nơ-ron Đồ thị trong PyTorch

Bộ dữ liệu Cora

Bộ dữ liệu Cora là một chuẩn đánh giá phổ biến được các nhà nghiên cứu sử dụng trong học biểu diễn đồ thị. Bộ dữ liệu này bao gồm một loạt các bài báo khoa học được chia thành bảy loại như “Case Based”, “Genetic Algorithms”, “Neural Networks”, “Probabilistic Methods”, “Reinforcement Learning” và “Rule Learning”. Bộ dữ liệu Cora đã tồn tại từ một thời gian và vẫn là nguồn tài nguyên được nhiều dự án trong lĩnh vực này sử dụng. Nó cung cấp một cách để đánh giá hiệu quả của mô hình của bạn trong việc phân tích cả nội dung văn bản của các tài liệu lẫn mạng lưới trích dẫn liên kết giữa chúng. Nhiều bài báo mạng nơ-ron đồ thị đáng chú ý đã sử dụng Cora để đánh giá hiệu suất trên các nhiệm vụ kép này. Nó được xây dựng dưới dạng biểu đồ với các ấn phẩm là nút và trích dẫn giữa chúng là các cạnh kết nối các nút. Mỗi tài liệu được liên kết với một vectơ tính năng đại diện cho nội dung của nó. Thách thức ở đây là phát triển một mô hình có thể xem xét biểu đồ trích dẫn, các vectơ nội dung và mối quan hệ giữa chúng để dự đoán bất kỳ ấn phẩm nào thuộc về lớp nào trong số bảy lớp.

Tiền xử lý dữ liệu

Chúng tôi cài đặt thư viện PyTorch Geometric với lệnh:

pip install torch_geometric

Chúng ta sau đó có thể sử dụng thư viện PyTorch Geometric để tải và xử lý trước bộ dữ liệu.

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

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

Lớp Planetoid tải bộ dữ liệu Cora và chuẩn hóa các vector đặc trưng. Chúng ta có thể lấy dữ liệu đã được xử lý trước bằng cách sử dụng bộ dữ liệu, điều này sẽ cho chúng ta một đối tượng Data với các thuộc tính sau:

  • x: một ma trận các đặc trưng nút có hình dạng ‘(số_nút, số_đặc_trưng)’
  • edge_index: ma trận kết nối cạnh có kích thước ‘(2, num_edges)’
  • y: một vector các nhãn nút có dạng ‘(num_nodes)’
  • train_mask, val_mask, test_mask: các mặt nạ boolean cho biết các nút nào dành cho huấn luyện, xác thực và kiểm tra.

Kết cấu mô hình

Khi xây dựng một mạng nơ-ron đồ thị, việc chọn kiến trúc mô hình phù hợp là vô cùng quan trọng. Chúng ta sẽ đi qua một triển khai cơ bản sử dụng thư viện torch_geometric của PyTorch. Chúng ta sẽ sử dụng mạng tích chập đồ thị, đây là một điểm khởi đầu vững chắc cho các nhiệm vụ học đồ thị khác nhau.

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)
  • Trong đoạn mã trên, chúng ta đã nhập torch và torch.nn.functional để truy cập một số mô-đun và hàm mạng nơ-ron hữu ích. Sau đó, chúng ta định nghĩa một lớp GNN kế thừa từ torch và nn.Module.
  • Trong phương thức init, chúng tôi đã định nghĩa hai lớp tích chập sử dụng module GCNConv từ PyTorch Geometric. Điều này cho phép triển khai dễ dàng các phép tích chập đồ thị. Chúng tôi cũng đã thêm một lớp tuyến tính đơn giản.
  • Lượt truyền tiến đầu tiên truyền đầu vào qua hai lớp convolution, mỗi lần đều áp dụng hàm kích hoạt ReLU. Sau đó nó đi qua lớp tuyến tính và cuối cùng là log softmax để nén các đầu ra.

Chỉ với vài dòng mã, chúng ta có thể xây dựng một mạng nơ-ron đồ thị nhỏ nhưng rất đẹp!

Rõ ràng, đây là một ví dụ đơn giản, nhưng chúng ta có thể thấy cách PyTorch và PyTorch Geometric cho phép chúng ta nhanh chóng tạo nguyên mẫu và lặp lại trên các kiến trúc mạng nơ-ron đồ thị. Các lớp GCNConv làm cho việc tích hợp cấu trúc đồ thị vào mô hình của chúng ta trở nên rất dễ dàng.

Đào tạo

Đối với việc huấn luyện, chúng ta sẽ sử dụng hàm mất mát cross-entropy và bộ tối ưu Adam. Chúng ta có thể chia dữ liệu thành các tập huấn luyện, kiểm tra và thử nghiệm bằng cách sử dụng các thuộc tính mask trên đối tượng 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}')

Hàm train thực hiện một vòng huấn luyện và trả về giá trị loss. Hàm test kiểm tra hiệu suất của mô hình trên các tập huấn luyện, xác thực và kiểm tra, và trả về độ chính xác. Chúng tôi đã huấn luyện mô hình trong 500 epoch và in ra độ chính xác khi huấn luyện và kiểm tra ở mỗi epoch.

Tính độ chính xác của mô hình GNN

Đoạn mã dưới đây định nghĩa một hàm để tính độ chính xác của mô hình trên toàn bộ tập dữ liệu. Hàm compute_accuracy() chuyển mô hình sang chế độ đánh giá, thực hiện một lượt tiến (forward pass), và dự đoán nhãn cho từng nút. Nó so sánh các nhãn dự đoán này với nhãn thực tế và tính số dự đoán đúng. Sau đó, nó chia số dự đoán đúng cho tổng số nút trong tập dữ liệu để lấy phần trăm độ chính xác.

@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}")

Trong trường hợp này, độ chính xác của mô hình trên bộ dữ liệu Cora là 0.8006. Điều này có nghĩa là khoảng 80% thời gian, mô hình có thể dự đoán đúng nhãn lớp. Điều đó khá tốt, nhưng không hoàn hảo. Độ chính xác cung cấp cho chúng ta một cái nhìn tổng quan nhanh về mức độ hoạt động của mô hình. Nhưng bạn cần phải đi sâu hơn để thực sự hiểu được nơi nào nó thành công và nơi nào nó gặp khó khăn.

Để hiểu rõ hơn về hiệu quả của mô hình, nên cân nhắc các chỉ số đánh giá khác như độ chính xác, độ hồi nhớ, điểm F1 và ma trận nhầm lẫn. Những chỉ số này cung cấp cái nhìn sâu hơn về hiệu suất của mô hình trên các khía cạnh khác nhau, chẳng hạn như xác định đúng các trường hợp dương tính và âm tính, cũng như xử lý các bộ dữ liệu không cân bằng. Vì vậy, mặc dù độ chính xác 80% là khá tốt, chúng ta vẫn cần thêm bối cảnh trước khi tuyên bố mô hình này là một thành công vang dội. Chỉ số độ chính xác một mình không cung cấp đầy đủ bức tranh về những gì đang xảy ra bên trong. Nhưng nó là một điểm khởi đầu tốt để đánh giá hiệu suất.

Đánh giá

Chúng ta có thể đánh giá hiệu suất của GNN bằng các chỉ số như độ chính xác, độ chính xác nhạy cảm, hồi tưởng và điểm F1. Nhưng chúng ta cũng có thể trực quan hóa các embedding của nút mà mô hình học được bằng t-SNE. Nó lấy các embedding đa chiều và chiếu chúng xuống 2D, cho phép chúng ta trực quan hóa chúng.

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

Lưu ý: Người đọc có thể chạy đoạn mã trên. Nó sẽ hiển thị một biểu đồ phân tán có thể được diễn giải. Mã sử dụng t-SNE để hiển thị các nhúng nút đã học trong biểu đồ phân tán 2D, đây là một cách thông minh để trực quan hóa dữ liệu đa chiều. Hãy cùng tìm hiểu những gì đang diễn ra:

  • Mỗi điểm trong biểu đồ đại diện cho một nút trong tập dữ liệu. Trục x và trục y là hai chiều mà t-SNE đã nén các embedding vào. Màu sắc của mỗi điểm đại diện cho nhãn thực sự của nút tương ứng trong tập dữ liệu.
  • Các nút có nhúng giống nhau nên có nhãn giống nhau, vì vậy chúng sẽ nhóm lại với nhau trên biểu đồ. Ngược lại, các nút có nhúng rất khác nhau có thể sẽ có nhãn khác nhau, nên chúng sẽ cách xa nhau.
  • Nhìn chung, cốt truyện cung cấp một hình ảnh rõ ràng về các mối quan hệ giữa các nút dựa trên các embedding đã học của chúng. Bạn có thể thấy các nhóm hình thành mà chắc chắn phải chia sẻ một số điểm tương đồng cơ bản. Đây là một cách tiện lợi để nhìn vào bên trong mô hình và hiểu cách nó tổ chức các khái niệm.

Những Thách Thức và Cân Nhắc Tiềm Năng

  • Với 2708 nút và 5429 cạnh, bộ dữ liệu Cora được coi là khá nhỏ. Điều này có thể làm giảm hiệu quả của GNN, đòi hỏi việc áp dụng các phương pháp tiên tiến hơn như tăng cường dữ liệu và học chuyển giao.
  • Bộ dữ liệu Cora bao gồm một loại nút và một loại cạnh, tạo thành một mạng đồng nhất. Điều này có thể hạn chế khả năng ứng dụng của GNN khi áp dụng vào các mạng phức tạp hơn, có nhiều loại nút và cạnh khác nhau.
  • Việc lựa chọn các giá trị phù hợp cho các siêu tham số, chẳng hạn như số lượng lớp ẩn, số lượng đơn vị ẩn và tỷ lệ học, có thể ảnh hưởng đáng kể đến hiệu suất của GNN và yêu cầu phải tinh chỉnh cẩn thận.

Câu hỏi thường gặp

  • 1. Mạng Nơ-ron Đồ thị (GNN) là gì?

GNN là một mạng nơ-ron được thiết kế để làm việc với dữ liệu có cấu trúc đồ thị. Nó học các biểu diễn ở cấp nút, cạnh hoặc đồ thị bằng cách tổng hợp thông tin từ các nút lân cận.

  • 2. GNN khác với mạng nơ-ron truyền thống như thế nào?

Mạng truyền thống xử lý dữ liệu dạng lưới (hình ảnh, chuỗi), trong khi GNN có thể mô hình hóa các cấu trúc không đều, có kết nối như mạng xã hội hoặc đồ thị phân tử.

  • 3. GNN được sử dụng cho những loại vấn đề nào?

Chúng thường được sử dụng cho phân loại nút, dự đoán liên kết, phân loại đồ thị, gợi ý, phát hiện gian lận và dự đoán tính chất phân tử.

  • 4. Truyền thông điệp trong GNN là gì?

Truyền tin là cơ chế cốt lõi, nơi các nút trao đổi thông tin với các nút lân cận, cập nhật biểu diễn và học các mối quan hệ ngữ cảnh.

  • 5. Liệu GNN có mở rộng tốt đối với các đồ thị rất lớn không?

Việc mở rộng quy mô có thể gặp khó khăn do bộ nhớ và sự mở rộng của các lân cận. Các kỹ thuật như lấy mẫu (GraphSAGE), chia nhỏ lô và huấn luyện phân tán sẽ giúp ích.

  • 6. Thư viện lập trình nào tốt nhất để triển khai GNNs?

Các framework phổ biến bao gồm PyTorch Geometric (PyG) và Deep Graph Library (DGL), cả hai đều cung cấp sẵn các lớp và tiện ích để xây dựng các mô hình GNN.

  • 7. Liệu GNN có phù hợp cho các ứng dụng thời gian thực không?

Vâng, tùy thuộc vào độ phức tạp của mô hình. Các kiến trúc nhẹ và phương pháp dựa trên lấy mẫu giúp đạt hiệu suất gần thời gian thực.

  • 8. GNN có thể xử lý các đồ thị động hoặc đang phát triển không?

Đúng, các biến thể GNN động có thể xử lý các đồ thị thay đổi theo thời gian, hữu ích cho dự báo giao thông, gợi ý theo thời gian và phát hiện bất thường.

  • 9. Những bước tiền xử lý dữ liệu nào cần thiết cho GNN?

Bạn thường cần chuẩn bị thông tin liền kề, các đặc trưng của nút/cạnh, và đảm bảo đồ thị được định dạng đúng cho thư viện mà bạn chọn.

  • 10. GNN có thể giải thích được không?

Khả năng giải thích đang được cải thiện với các công cụ như cơ chế chú ý và GNNExplainer, giúp làm nổi bật các nút và cạnh có ảnh hưởng.

Kết luận

Trong bài viết này, chúng tôi đã đi qua các khái niệm cốt lõi về Mạng Nơ-ron Đồ thị (GNNs) và khám phá cách chúng có thể được áp dụng vào các lĩnh vực khác nhau. GNNs đặc biệt phù hợp để làm việc với dữ liệu có cấu trúc đồ thị, cho phép các mô hình suy luận về các mối quan hệ phức tạp tồn tại trong mạng xã hội, đồ thị phân tử, hệ thống giao thông và nhiều lĩnh vực khác.

Để minh họa những ý tưởng này trong thực tiễn, chúng tôi đã sử dụng bộ dữ liệu Cora phổ biến—một chuẩn tham chiếu cho học đồ thị. Trong bộ dữ liệu này, mỗi bài báo được biểu diễn như một nút, và các trích dẫn giữa chúng tạo thành các cạnh. Mục tiêu của chúng tôi là sử dụng cả đặc trưng văn bản của mỗi bài báo và các liên kết trích dẫn để dự đoán danh mục của nó.

Chúng tôi đã chuẩn bị bộ dữ liệu bằng cách sử dụng thư viện PyTorch Geometric, chuẩn hóa các vector đặc trưng và chia dữ liệu thành các tập huấn luyện, xác thực và kiểm tra. Sau đó, chúng tôi xây dựng một mạng GNN đơn giản sử dụng các lớp tích chập đồ thị, tiếp theo là một bộ phân loại tuyến tính, và huấn luyện nó bằng hàm mất mát cross-entropy với trình tối ưu Adam. Cuối cùng, chúng tôi đánh giá hiệu suất của mô hình bằng cách đo độ chính xác của nó.

Mặc dù có nhiều kỹ thuật và cải tiến bổ sung mà người ta có thể khám phá, dự án này cung cấp một giới thiệu vững chắc về cách hoạt động của GNN và mức độ hiệu quả của chúng trong việc học từ dữ liệu quan hệ phức tạp.

Tài nguyên

  • Xây dựng Mạng Nơ-ron Từ Đầu: Phần 1
  • Học Sâu là gì? Hướng Dẫn Cho Người Mới Bắt Đầu về Mạng Nơ-ron
  • Giải thích các Kiến trúc Học Sâu: ResNet, InceptionV3, SqueezeNet
  • PyTorch 101: Học Học máy sâu với PyTorch

Cảm ơn bạn đã học cùng cộng đồng Linux-Console.net.