# Python临床医学病态图学习

<details>

<summary>关键词</summary>

Python | 数学 | 临床 | 诊断 | 图谱 | 点云 | 三维 | 图神经 | 文本 | 感知 | 语言模型 | 疾病 | 异构图 | 预测 | 转录组 | 细胞 | 分子 | 多态融合 | 药物 | 病态 | 算法

</details>

{% embed url="https://viadean.notion.site/Python-e49e09b762614e4486b6444c3b8713f2" %}

{% content-ref url="../zhi-dian-mi-jin-brief" %}
[zhi-dian-mi-jin-brief](../zhi-dian-mi-jin-brief)
{% endcontent-ref %}

### 📜用例

📜[Python社群纽带关系谱和图神经](../gong-cheng-engineering/python-she-qun-niu-dai-guan-xi-pu-he-tu-shen-jing) | 📜问答知识图谱 | 📜点云三维对象检测图神经 | 📜文本中图结构感知语言模型 | 📜疾病预测图学习 | 📜转录组预测疾病状态 | 📜空间细胞邻域图学习 | 📜预测分子生长抑制图学习 | 📜多态融合算法药物再利用 | 📜病态融合临床诊断 。

### ✒️Python图学习

我们将摄取 Planetoid Cora 数据集，并对词袋输入特征进行行标准化。之后，我们将分析数据集和第一个图形对象。

```python
 from torch_geometric.datasets import Planetoid
 from torch_geometric.transforms import NormalizeFeatures
 ​
 dataset = Planetoid(root='data/Planetoid', name='Cora', transform=NormalizeFeatures())
 ​
 print(f'Dataset: {dataset}:')
 print('======================')
 print(f'Number of graphs: {len(dataset)}')
 print(f'Number of features: {dataset.num_features}')
 print(f'Number of classes: {dataset.num_classes}')
 ​
 data = dataset[0]  # Get the first graph object.
 print(data)
```

Cora 数据集有 2708 个节点、10,556 个边、1433 个特征和 7 个类。第一个对象有 2708 个训练、验证和测试掩模。我们将使用这些掩模来训练和评估模型。

```python
 Dataset: Cora():
 ======================
 Number of graphs: 1
 Number of features: 1433
 Number of classes: 7
 Data(x=[2708, 1433], edge_index=[2, 10556], y=[2708], train_mask=[2708], val_mask=[2708], test_mask=[2708])
```

我们将创建一个图卷积网络模型结构，其中包含两个 GCNConv 层 relu 激活和 0.5 的 dropout 率。该模型由 16 个隐藏通道组成。

GCNConv 层 ：

$$
x _v^{(\ell+1)}= W ^{(\ell+1)} \sum_{w \in N (v) \cup\{v\}} \frac{1}{c_{w, v}} \cdot x _w^{(\ell)}
$$

$$W(\ell+1)$$ 是上式中的可转换权重矩阵，C W, v 为每条边指定一个固定的归一化系数。

```python
 from torch_geometric.nn import GCNConv
 import torch.nn.functional as F
 ​
 class GCN(torch.nn.Module):
     def __init__(self, hidden_channels):
         super().__init__()
         torch.manual_seed(1234567)
         self.conv1 = GCNConv(dataset.num_features, hidden_channels)
         self.conv2 = GCNConv(hidden_channels, dataset.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
 ​
 model = GCN(hidden_channels=16)
 print(model)
 ​
 >>> GCN(
     (conv1): GCNConv(1433, 16)
     (conv2): GCNConv(16, 7)
   )
```

让我们使用 sklearn.manifold.TSNE 和 matplotlib.pyplot 可视化未经训练的 GCN 网络的节点嵌入。它将绘制一个嵌入 2D 散点图的 7 维节点。

```python
 %matplotlib inline
 import matplotlib.pyplot as plt
 from sklearn.manifold import TSNE
 ​
 def visualize(h, color):
     z = TSNE(n_components=2).fit_transform(h.detach().cpu().numpy())
 ​
     plt.figure(figsize=(10,10))
     plt.xticks([])
     plt.yticks([])
 ​
     plt.scatter(z[:, 0], z[:, 1], s=70, c=color, cmap="Set2")
     plt.show()
```

我们将评估模型，然后将训练数据添加到未经训练的模型中，以可视化各种节点和类别。

```python
 model.eval()
 ​
 out = model(data.x, data.edge_index)
 visualize(out, color=data.y)
```

我们将使用 Adam 优化和交叉熵损失函数在 100 个 Epoch 上训练我们的模型。

```python
 model = GCN(hidden_channels=16)
 optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
 criterion = torch.nn.CrossEntropyLoss()
 ​
 def train():
       model.train()
       optimizer.zero_grad()
       out = model(data.x, data.edge_index)
       loss = criterion(out[data.train_mask], data.y[data.train_mask])
       loss.backward()
       optimizer.step()
       return loss
 ​
 def test():
       model.eval()
       out = model(data.x, data.edge_index)
       pred = out.argmax(dim=1)
       test_correct = pred[data.test_mask] == data.y[data.test_mask]
       test_acc = int(test_correct.sum()) / int(data.test_mask.sum())
       return test_acc
 ​
 ​
 for epoch in range(1, 101):
     loss = train()
     print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}')
 GAT(
   (conv1): GATConv(1433, 8, heads=8)
   (conv2): GATConv(64, 7, heads=8)
 )
 ​
 .. .. .. ..
 .. .. .. ..
 Epoch: 098, Loss: 0.5989
 Epoch: 099, Loss: 0.6021
 Epoch: 100, Loss: 0.5799
```

现在，我们将使用测试函数在未见过的数据集上评估模型，如您所见，我们得到了相当不错的结果，准确率达到 81.5%。

```python
 test_acc = test()
 print(f'Test Accuracy: {test_acc:.4f}')
 ​
 ​
 >>> Test Accuracy: 0.8150
```
