图神经网络在蛋白质药物相互作用预测中的建模方法与应用拓展

    from torch_geometric.nn import GCNConv
    from torch_geometric.data import Data
    from torch_geometric.utils import add_self_loops
    
    # 数据预处理
    def preprocess_data(protein_features, drug_features, edge_index):
    data = Data(x=protein_features, edge_index=edge_index)
    data.y = drug_features
    data = add_self_loops(data, num_nodes=protein_features.size(0))
    return data
    
    # 模型实现
    class GCNModel(nn.Module):
    def __init__(self, nfeat, nhid, nclass):
        super(GCNModel, self).__init__()
        self.conv1 = GCNConv(nfeat, nhid)
        self.conv2 = GCNConv(nhid, nclass)
    
    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = self.conv2(x, edge_index)
        return F.log_softmax(x, dim=1)
    
    # 训练和评估
    def train_model(model, data, optimizer, num_epochs):
    model.train()
    for epoch in range(num_epochs):
        optimizer.zero_grad()
        out = model(data)
        loss = F.nll_loss(out, data.y)
        loss.backward()
        optimizer.step()
        if (epoch+1) % 10 == 0:
            print(f'Epoch {epoch+1}: loss = {loss.item()}')
    
    model.eval()
    _, pred = model(data).max(dim=1)
    correct = float((pred == data.y).sum().item())
    accuracy = correct / len(data)
    print(f'Final Test Accuracy: {accuracy}')
    
    # 实例化模型并训练
    protein_features = torch.randn(100, 64)
    drug_features = torch.randn(100, 64)
    edge_index = torch.randint(0, 100, (2, 1000))
    
    data = preprocess_data(protein_features, drug_features, edge_index)
    model = GCNModel(nfeat=64, nhid=128, nclass=1)
    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
    
    train_model(model, data, optimizer, num_epochs=200)

    from torch_geometric.nn import GATConv
    from torch_geometric.data import Data
    from torch_geometric.utils import add_self_loops
    
    # 数据预处理
    def preprocess_data(protein_features, drug_features, edge_index):
    data = Data(x=protein_features, edge_index=edge_index)
    data.y = drug_features
    data = add_self_loops(data, num_nodes=protein_features.size(0))
    return data
    
    # 模型实现
    class GATModel(nn.Module):
    def __init__(self, nfeat, nheads, nclass):
        super(GATModel, self).__init__()
        self.conv1 = GATConv(nfeat, nheads, heads=nheads)
        self.conv2 = GATConv(nheads, nclass, heads=nheads)
    
    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = self.conv2(x, edge_index)
        return F.log_softmax(x, dim=1)
    
    # 训练和评估
    def train_model(model, data, optimizer, num_epochs):
    model.train()
    for epoch in range(num_epochs):
        optimizer.zero_grad()
        out = model(data)
        loss = F.nll_loss(out, data.y)
        loss.backward()
        optimizer.step()
        if (epoch+1) % 10 == 0:
            print(f'Epoch {epoch+1}: loss = {loss.item()}')
    
    model.eval()
    _, pred = model(data).max(dim=1)
    correct = float((pred == data.y).sum().item())
    accuracy = correct / len(data)
    print(f'Final Test Accuracy: {accuracy}')
    
    # 实例化模型并训练
    protein_features = torch.randn(100, 64)
    drug_features = torch.randn(100, 64)
    edge_index = torch.randint(0, 100, (2, 1000))
    
    data = preprocess_data(protein_features, drug_features, edge_index)
    model = GATModel(nfeat=64, nheads=8, nclass=1)
    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
    
    train_model(model, data, optimizer, num_epochs=200)

    import torch
    from torch_geometric.nn import GCNConv
    from torch_geometric.data import Data
    from torch_geometric.utils import add_self_loops
    
    # 数据预处理
    def preprocess_data(texts, labels):
    node_features = torch.tensor([tokenization.encode(text) for text in texts], dtype=torch.long)
    edge_index = torch.tensor([[i, j] for i, j in pairwise(node_features)], dtype=torch.long)
    labels = torch.tensor(labels, dtype=torch.long)
    return Data(x=node_features, edge_index=edge_index, y=labels)
    
    # 模型实现
    class GCNModel(nn.Module):
    def __init__(self, nfeat, nhid, nclass):
        super(GCNModel, self).__init__()
        self.conv1 = GCNConv(nfeat, nhid)
        self.conv2 = GCNConv(nhid, nclass)
    
    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = self.conv2(x, edge_index)
        return F.log_softmax(x, dim=1)
    
    # 训练和评估
    def train_model(model, data, optimizer, num_epochs):
    model.train()
    for epoch in range(num_epochs):
        optimizer.zero_grad()
        out = model(data)
        loss = F.nll_loss(out, data.y)
        loss.backward()
        optimizer.step()
        if (epoch+1) % 10 == 0:
            print(f'Epoch {epoch+1}: loss = {loss.item()}')
    
    model.eval()
    _, pred = model(data).max(dim=1)
    correct = float((pred == data.y).sum().item())
    accuracy = correct / len(data)
    print(f'Final Test Accuracy: {accuracy}')
    
    # 实例化模型并训练
    texts = ["I love this movie", "This is a terrible movie"]
    labels = [1, 0]
    data = preprocess_data(texts, labels)
    
    model = GCNModel(nfeat=100, nhid=64, nclass=2)
    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
    
    train_model(model, data, optimizer, num_epochs=200)

    graph TD
    A[图神经网络基础]
    B[数学模型与算法原理]
    C[应用拓展]
    D[项目实战]
    E[总结与展望]
    F[附录]
    A --> B
    B --> C
    C --> D
    D --> E
    E --> F

    # 图卷积网络（GCN）的基本结构
    def GCN_layer(A, H, activation='ReLU'):
    # A:邻接矩阵，H:节点特征矩阵
    # H':更新后的节点特征矩阵
    # 计算邻接矩阵的拉普拉斯矩阵L
    L = calculate_Laplacian_matrix(A)
    # 使用L和H计算新的节点特征H'
    H' = (L + I) @ H
    # 应用激活函数
    if activation == 'ReLU':
        H' = activation_function(H')
    return H'
    
    # 图注意力网络（GAT）的基本结构
    def GAT_layer(A, H, heads, activation='ReLU'):
    # A:邻接矩阵，H:节点特征矩阵
    # W:权重矩阵
    # H':更新后的节点特征矩阵
    for head in range(heads):
        # 计算头部的注意力权重
        alpha = attention_weights(A, H)
        # 使用注意力权重更新节点特征
        H' = (alpha @ W[head] @ H) / sqrt(heads)
        # 应用激活函数
        if activation == 'ReLU':
            H' = activation_function(H')
    return H'

    import torch
    import torch_geometric.nn as gn
    from torch_geometric.data import Data
    from torch_geometric.utils import add_self_loops
    
    # 数据预处理
    def preprocess_data(protein_features, drug_features, edge_index):
    data = Data(x=protein_features, edge_index=edge_index)
    data.y = drug_features
    data = add_self_loops(data, num_nodes=protein_features.size(0))
    return data
    
    # 模型实现
    class GCNModel(torch.nn.Module):
    def __init__(self, nfeat, nhid, nclass):
        super(GCNModel, self).__init__()
        self.conv1 = gn.GCNConv(nfeat, nhid)
        self.conv2 = gn.GCNConv(nhid, nclass)
    
    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index)
        x = torch.relu(x)
        x = self.conv2(x, edge_index)
        return torch.log_softmax(x, dim=1)
    
    # 训练模型
    def train_model(model, data, optimizer, num_epochs):
    model.train()
    for epoch in range(num_epochs):
        optimizer.zero_grad()
        out = model(data)
        loss = torch.nn.functional.nll_loss(out[data.train_mask], data.y[data.train_mask])
        loss.backward()
        optimizer.step()
        if epoch % 10 == 0:
            train_loss = loss.item()
            print(f"Epoch: {epoch} Train Loss: {train_loss}")
    
    # 实例化模型并训练
    protein_features = torch.randn(100, 64)
    drug_features = torch.randn(100, 64)
    edge_index = torch.randint(0, 100, (2, 1000))
    
    data = preprocess_data(protein_features, drug_features, edge_index)
    model = GCNModel(nfeat=64, nhid=128, nclass=1)
    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
    
    train_model(model, data, optimizer, num_epochs=200)

    import torch
    import torch_geometric.nn as gn
    from torch_geometric.data import Data
    from torch_geometric.utils import add_self_loops
    
    # 数据预处理
    def preprocess_data(protein_features, drug_features, edge_index):
    data = Data(x=protein_features, edge_index=edge_index)
    data.y = drug_features
    data = add_self_loops(data, num_nodes=protein_features.size(0))
    return data
    
    # 模型实现
    class GATModel(torch.nn.Module):
    def __init__(self, nfeat, nheads, nclass):
        super(GATModel, self).__init__()
        self.conv1 = gn.GATConv(nfeat, nheads, heads=nheads)
        self.conv2 = gn.GATConv(nheads, nclass, heads=nheads)
    
    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index)
        x = torch.relu(x)
        x = self.conv2(x, edge_index)
        return torch.log_softmax(x, dim=1)
    
    # 训练模型
    def train_model(model, data, optimizer, num_epochs):
    model.train()
    for epoch in range(num_epochs):
        optimizer.zero_grad()
        out = model(data)
        loss = torch.nn.functional.nll_loss(out[data.train_mask], data.y[data.train_mask])
        loss.backward()
        optimizer.step()
        if epoch % 10 == 0:
            train_loss = loss.item()
            print(f"Epoch: {epoch} Train Loss: {train_loss}")
    
    # 实例化模型并训练
    protein_features = torch.randn(100, 64)
    drug_features = torch.randn(100, 64)
    edge_index = torch.randint(0, 100, (2, 1000))
    
    data = preprocess_data(protein_features, drug_features, edge_index)
    model = GATModel(nfeat=64, nheads=8, nclass=1)
    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
    
    train_model(model, data, optimizer, num_epochs=200)

    import torch
    import torch_geometric.nn as gn
    from torch_geometric.data import Data
    from torch_geometric.utils import add_self_loops
    
    # 数据预处理
    def preprocess_data(texts, labels):
    node_features = torch.tensor([tokenization.encode(text) for text in texts], dtype=torch.long)
    edge_index = torch.tensor([[i, j] for i, j in pairwise(node_features)], dtype=torch.long)
    labels = torch.tensor(labels, dtype=torch.long)
    return Data(x=node_features, edge_index=edge_index, y=labels)
    
    # 模型实现
    class GCNModel(torch.nn.Module):
    def __init__(self, nfeat, nhid, nclass):
        super(GCNModel, self).__init__()
        self.conv1 = gn.GCNConv(nfeat, nhid)
        self.conv2 = gn.GCNConv(nhid, nclass)
    
    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index)
        x = torch.relu(x)
        x = self.conv2(x, edge_index)
        return torch.log_softmax(x, dim=1)
    
    # 训练模型
    def train_model(model, data, optimizer, num_epochs):
    model.train()
    for epoch in range(num_epochs):
        optimizer.zero_grad()
        out = model(data)
        loss = torch.nn.functional.nll_loss(out[data.train_mask], data.y[data.train_mask])
        loss.backward()
        optimizer.step()
        if epoch % 10 == 0:
            train_loss = loss.item()
            print(f"Epoch: {epoch} Train Loss: {train_loss}")
    
    # 实例化模型并训练
    texts = ["I love this movie", "This is a terrible movie"]
    labels = [1, 0]
    data = preprocess_data(texts, labels)
    
    model = GCNModel(nfeat=100, nhid=64, nclass=2)
    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
    
    train_model(model, data, optimizer, num_epochs=200)

    graph TD
    A[数据预处理]
    B[模型构建]
    C[模型训练]
    D[模型评估]
    A --> B
    B --> C
    C --> D