GCN python

GCN (Graph Convolutional Network) 是一种用于图数据的深度学习模型。下面是一个使用 Python 实现 GCN 的基本示例代码：

import numpy as np
import scipy.sparse as sp
import torch
import torch.nn as nn
import torch.nn.functional as F


class GraphConvolution(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(GraphConvolution, self).__init__()
        self.weight = nn.Parameter(torch.FloatTensor(input_dim, output_dim))
        self.bias = nn.Parameter(torch.FloatTensor(output_dim))

    def forward(self, input, adj):
        support = torch.matmul(input, self.weight)
        output = torch.matmul(adj, support)
        output = output + self.bias
        return output


class GCN(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(GCN, self).__init__()
        self.gc1 = GraphConvolution(input_dim, hidden_dim)
        self.gc2 = GraphConvolution(hidden_dim, output_dim)

    def forward(self, input, adj):
        hidden = F.relu(self.gc1(input, adj))
        output = self.gc2(hidden, adj)
        return output


# 构建图邻接矩阵
def normalize_adjacency(adj):
    adj = sp.coo_matrix(adj)
    rowsum = np.array(adj.sum(1))
    d_inv_sqrt = np.power(rowsum, -0.5).flatten()
    d_inv_sqrt[np.isinf(d_inv_sqrt)] = 0.0
    d_mat_inv_sqrt = sp.diags(d_inv_sqrt)
    normalized_adj = adj.dot(d_mat_inv_sqrt).transpose().dot(d_mat_inv_sqrt).tocoo()
    return normalized_adj


# 转换为稀疏张量
def sparse_to_tensor(sparse_mx):
    sparse_mx = sparse_mx.tocoo().astype(np.float32)
    indices = torch.from_numpy(np.vstack((sparse_mx.row, sparse_mx.col)).astype(np.int64))
    values = torch.from_numpy(sparse_mx.data)
    shape = torch.Size(sparse_mx.shape)
    tensor = torch.sparse.FloatTensor(indices, values, shape)
    return tensor


# 构建模型和数据
adjacency = [[0, 1, 0], [1, 0, 1], [0, 1, 0]]  # 图的邻接矩阵
features = [[1, 0], [0, 1], [1, 1]]  # 图的特征矩阵

adjacency = normalize_adjacency(adjacency)
adjacency_tensor = sparse_to_tensor(adjacency)
features_tensor = torch.FloatTensor(features)

input_dim = features_tensor.shape[1]
hidden_dim = 16
output_dim = 2

model = GCN(input_dim, hidden_dim, output_dim)

# 使用模型进行前向传播
output = model(features_tensor, adjacency_tensor)

这是一个简化的 GCN 实现，包含了图卷积层 `GraphConvolution` 和 GCN 模型 `GCN`。代码中的 `adjacency` 是图的邻接矩阵，`features` 是节点的特征矩阵。模型的前向传播过程通过计算图卷积层的输出得到。

注意，这只是一个基本示例，实际应用中可能需要根据具体情况进行调整和扩展。另外，还需要安装相应的依赖库，例如 NumPy、SciPy 和 PyTorch。