657 微生物组深度学习应用¶

# CNN用于微生物组分类（PyTorch实现）
import torch  # 导入PyTorch深度学习框架
import torch.nn as nn  # 导入神经网络模块

class MicrobiomeCNN(nn.Module):  # 定义微生物组CNN分类器
    def __init__(self, n_taxa, n_classes):  # n_taxa=物种数，n_classes=分类数
        super().__init__()
        self.conv1 = nn.Conv1d(1, 32, kernel_size=5, padding=2)  # 第一层卷积，提取局部特征
        self.conv2 = nn.Conv1d(32, 64, kernel_size=3, padding=1)  # 第二层卷积，提取更高级特征
        self.pool = nn.AdaptiveAvgPool1d(1)  # 自适应平均池化，压缩特征
        self.fc = nn.Linear(64, n_classes)  # 全连接层，输出分类结果
        self.dropout = nn.Dropout(0.3)  # Dropout防止过拟合

    def forward(self, x):  # 前向传播
        x = x.unsqueeze(1)  # 增加通道维度 [batch, 1, n_taxa]
        x = torch.relu(self.conv1(x))  # 卷积+ReLU激活
        x = torch.relu(self.conv2(x))  # 第二层卷积+ReLU
        x = self.pool(x).squeeze(-1)  # 池化并去掉多余维度
        x = self.dropout(x)  # 应用Dropout
        return self.fc(x)  # 输出预测

# LSTM用于微生物组时间序列预测
class MicrobiomeLSTM(nn.Module):  # 定义LSTM模型
    def __init__(self, n_taxa, hidden_size=128, n_layers=2):
        super().__init__()
        self.lstm = nn.LSTM(  # LSTM层
            input_size=n_taxa,  # 输入维度=物种数
            hidden_size=hidden_size,  # 隐藏层大小
            num_layers=n_layers,  # LSTM层数
            batch_first=True,  # 批次维度在前
            dropout=0.2  # 层间Dropout
        )
        self.fc = nn.Linear(hidden_size, n_taxa)  # 输出层预测下一时间点丰度

    def forward(self, x):  # x形状: [batch, time_steps, n_taxa]
        lstm_out, _ = self.lstm(x)  # LSTM编码时序信息
        return self.fc(lstm_out[:, -1, :])  # 取最后时间步的输出做预测

# Transformer用于微生物组样本嵌入
class MicrobiomeTransformer(nn.Module):  # 定义Transformer模型
    def __init__(self, n_taxa, d_model=128, nhead=8, n_layers=4):
        super().__init__()
        self.embedding = nn.Linear(1, d_model)  # 将每个物种丰度映射到高维空间
        encoder_layer = nn.TransformerEncoderLayer(  # Transformer编码器层
            d_model=d_model,  # 模型维度
            nhead=nhead,  # 注意力头数
            dim_feedforward=256,  # 前馈网络维度
            dropout=0.1  # Dropout率
        )
        self.transformer = nn.TransformerEncoder(encoder_layer, n_layers)  # 堆叠多层
        self.classifier = nn.Linear(d_model, 2)  # 二分类输出（如健康vs疾病）

    def forward(self, x):  # x形状: [batch, n_taxa]
        x = x.unsqueeze(-1)  # [batch, n_taxa, 1]
        x = self.embedding(x)  # [batch, n_taxa, d_model]
        x = x.permute(1, 0, 2)  # Transformer需要[seq_len, batch, d_model]
        x = self.transformer(x)  # Transformer编码
        x = x.mean(dim=0)  # 对物种维度取平均
        return self.classifier(x)  # 分类预测

# 完整的深度学习微生物组分类流程
import pandas as pd  # 数据处理
import numpy as np  # 数值计算
from sklearn.model_selection import StratifiedKFold  # 分层交叉验证
from sklearn.preprocessing import StandardScaler  # 标准化
from sklearn.metrics import roc_auc_score  # AUC评估指标

# 1. 数据准备
otu_table = pd.read_csv("otu_table.csv", index_col=0)  # 读取OTU表
metadata = pd.read_csv("metadata.csv")  # 读取样本信息
X = otu_table.values.astype(np.float32)  # 转为浮点数数组
y = (metadata["disease"] == "CRC").astype(int).values  # 标签：1=患病，0=健康

# 2. CLR转换（处理组成性数据）
from scipy.stats import gmean  # 几何均值函数
X_pseudo = X + 0.5  # 加伪计数避免零值
X_clr = np.log(X_pseudo / gmean(X_pseudo, axis=1, keepdims=True))  # CLR转换

# 3. 交叉验证训练
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)  # 5折分层CV
aucs = []  # 存储每折AUC

for train_idx, test_idx in skf.split(X_clr, y):  # 遍历每折
    X_train, X_test = X_clr[train_idx], X_clr[test_idx]  # 分割数据
    y_train, y_test = y[train_idx], y[test_idx]

    scaler = StandardScaler()  # 标准化器
    X_train = scaler.fit_transform(X_train)  # 拟合并转换训练集
    X_test = scaler.transform(X_test)  # 只转换测试集（防止数据泄露）

    # 转为PyTorch张量
    X_train_t = torch.FloatTensor(X_train)  # 训练数据张量
    y_train_t = torch.LongTensor(y_train)  # 训练标签张量
    X_test_t = torch.FloatTensor(X_test)  # 测试数据张量

    # 初始化模型和优化器
    model = MicrobiomeCNN(X_train.shape[1], 2)  # CNN模型
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)  # Adam优化器
    criterion = nn.CrossEntropyLoss()  # 交叉熵损失

    # 训练循环
    model.train()  # 训练模式
    for epoch in range(100):  # 训练100轮
        optimizer.zero_grad()  # 梯度清零
        output = model(X_train_t)  # 前向传播
        loss = criterion(output, y_train_t)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 更新参数

    # 评估
    model.eval()  # 评估模式
    with torch.no_grad():  # 不计算梯度
        probs = torch.softmax(model(X_test_t), dim=1)[:, 1].numpy()  # 预测概率
    aucs.append(roc_auc_score(y_test, probs))  # 计算AUC

print(f"平均AUC: {np.mean(aucs):.3f} ± {np.std(aucs):.3f}")  # 输出结果

# 快速选择深度学习架构
横截面数据 + 分类任务    → CNN / MLP
时间序列数据            → LSTM / GRU / Transformer
物种互作网络            → GNN (GCN/GAT)
序列分类/功能预测       → Transformer / LLM
数据增强/生成          → VAE / GAN
小样本学习             → 迁移学习 + 微调

# 关键超参数
学习率: 1e-3 到 1e-4
Batch size: 16-64（根据样本量调整）
Dropout: 0.2-0.5
早停: patience=10-20 epochs