深度度量学习实战：Python实现蛋白质二级结构预测

简介：这份源码包面向生物信息学与深度学习方向的毕业设计学生及软件工程实践者，提供用Python实现深度度量学习预测蛋白质二级结构的完整方案，解决氨基酸序列到α螺旋、β折叠、β转角等局部构象的建模与评估问题。包内共39个文件，以13个py脚本为核心，覆盖数据预处理、ConvNet网络构建、损失函数与训练验证流程；另有7个h5权重文件、7个pyc缓存、3个xml配置、2个md说明及ipynb、pl、sh等辅助文件，压缩包约14.58MB，目录按datasets、networks、loss、embedding等模块清晰划分。已有122人学习下载。读者可据此掌握序列编码、特征嵌入、度量学习损失设计、集成评估与SOV计算等关键环节，并借助训练脚本与评估脚本复现实验、对比单模型与集成模型效果，为后续改进预测精度提供可运行基线。

1. 从一条序列到一张结构图：深度度量学习怎么把蛋白质二级结构预测做准

蛋白质二级结构预测这件事，做的人不少，但真正卡住大家的往往不是模型不够深，而是「相似样本分不开」。一条氨基酸序列里，螺旋、折叠、无规卷曲的边界经常模糊，传统交叉熵训练出来的特征空间里，正负样本挤在一起，模型只能靠记忆硬扛。深度度量学习换了个思路：不直接逼分类头输出标签，而是先把序列片段映射到一个度量空间，让同类结构的片段靠拢、异类拉开，再用最近邻或轻量分类器判结构。这套方案在 Python 里落地并不复杂，核心是三元组采样、距离度量、嵌入维度这三件事。适合已经跑通过基础 CNN/RNN 分类、但发现 Q3 准确率卡在 70% 上下上不去的从业者，也适合想理解度量学习怎么从人脸识别迁移到生物序列的新手。源码包里通常就是这套流程的完整实现，下面把它拆开讲透。

2. 深度度量学习预测二级结构的原理与选型：为什么不用普通分类头

2.1 从交叉熵到三元组损失：特征空间到底差在哪

普通分类做二级结构预测，流程是序列编码器 → 全连接 → softmax → 交叉熵。问题在于，交叉熵只关心「这条样本被分到哪一类」，不关心同类样本在特征空间里离得多近。结果就是：模型对训练集里出现过的模式很自信，一旦遇到边界模糊的片段，嵌入向量就飘了。

深度度量学习把优化目标换成了距离关系。最常用的是三元组损失：选一个锚点样本（anchor）、一个同类正样本（positive）、一个异类负样本（negative），要求锚点到正样本的距离比到负样本的距离小至少一个 margin。公式上就是 max(0, d(a,p) - d(a,n) + margin)。训练完成后，特征空间里同类结构的片段自然聚成簇，预测时用 kNN 或一个极简的线性层就能判类。

这个迁移不是拍脑袋。人脸识别里同一个人不同角度要聚拢，蛋白质里同一类二级结构不同序列上下文也要聚拢，本质都是「类内紧凑、类间分离」的需求。二级结构只有三类（H/E/C）或八类（SS8），类别少但边界复杂，度量学习恰好补上了交叉熵缺失的那部分约束。

2.2 编码器选型：CNN、BiLSTM 还是 Transformer

序列编码器决定了嵌入质量。常见做法有三条路线：

• 一维 CNN：适合捕捉局部 motif，比如几个残基组成的螺旋倾向模式。速度快，显存友好，但长程依赖弱。
• BiLSTM：双向建模上下文，对二级结构这种依赖前后窗口的任务很合适。缺点是训练慢，序列长了显存吃紧。
• Transformer/预训练语言模型：像 ESM 这类蛋白质语言模型直接抽 embedding，效果通常最好，但推理成本高，小数据集上容易过拟合。

我一般会先用 BiLSTM + 注意力池化做 baseline，确认度量学习框架跑通后，再换预训练 embedding 做对比。源码里如果用的是 CNN，别急着否定，先看它的卷积核大小和池化策略，很多实现靠堆叠空洞卷积也能拿到不错的局部感受野。

2.3 三元组采样策略：随机采和硬采差距有多大

三元组怎么选，直接决定训练能不能收敛。随机采样大部分三元组满足 margin 约束，损失为 0，梯度没信息。必须做硬负样本挖掘或半硬采样。

半硬采样（semi-hard）的规则是：选那些 d(a,n) > d(a,p) 但还没超过 margin 太多的负样本。这样梯度稳定，不会一上来就被极端难样本带崩。实现上通常在一个 batch 内计算 pairwise 距离矩阵，对每个锚点挑满足条件的正负对。

批量大小很关键。batch 太小，类内样本不够，三元组质量差；batch 太大，显存扛不住。经验值是每个类别至少 4~8 个样本，总 batch 64~256。如果源码里 batch size 设成 16，大概率是没调好，可以往上加。

3. 用 Python 跑通最小可复现流程：数据、模型、训练三步走

3.1 数据准备：把 PDB 序列和 DSSP 标签对齐

二级结构预测的标准数据来源是 PDB 结构文件配合 DSSP 程序生成标签。流程是：下载 PDB → 跑 DSSP 得到每个残基的二级结构 → 把 H/G/I 归为螺旋、E/B 归为折叠、其余归为卷曲 → 和 FASTA 序列逐残基对齐。

对齐这一步最容易翻车。PDB 里经常有缺失残基，DSSP 输出的编号和 FASTA 不一定一一对应。稳妥做法是用 PDB 的 SEQRES 和 ATOM 记录交叉验证，只保留两者都存在的残基。

import numpy as np # 假设 seq 是氨基酸序列字符串，ss 是 DSSP 输出的二级结构字符 # 映射规则：H/G/I -> H(螺旋)，E/B -> E(折叠)，其余 -> C(卷曲) def map_ss(dssp_char): if dssp_char in ('H', 'G', 'I'): return 'H' elif dssp_char in ('E', 'B'): return 'E' else: return 'C' def align_sequence_and_label(seq, dssp_seq): # 只保留长度一致且无缺失的对齐 assert len(seq) == len(dssp_seq), "序列与标签长度不一致，检查缺失残基" labels = [map_ss(c) for c in dssp_seq] return seq, labels # 示例 seq = "ACDEFGHIKLMNPQRSTVWY" dssp = "HHHEEEECCCCHHHHEEEEC" seq, labels = align_sequence_and_label(seq, dssp) print(labels) # ['H','H','H','E','E','E','E','C','C','C','C','H','H','H','H','E','E','E','E','C']

这段代码做的是标签映射和对齐校验。map_ss把 DSSP 的八类归并成三类，align_sequence_and_label用断言卡住长度不一致的情况。实际项目里，断言之前还要处理 PDB 缺失残基，常见做法是用Bio.PDB解析后只取 CA 原子存在的残基，再和 DSSP 结果取交集。

3.2 模型定义：嵌入网络加三元组损失

下面是一个最小可跑的 PyTorch 实现，编码器用 BiLSTM，输出固定维度嵌入，损失用半硬三元组。

import torch import torch.nn as nn import torch.nn.functional as F class SSEncoder(nn.Module): def __init__(self, vocab_size=21, embed_dim=64, hidden_dim=128, out_dim=64): super().__init__() self.embed = nn.Embedding(vocab_size, embed_dim, padding_idx=0) self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True, bidirectional=True) self.fc = nn.Linear(hidden_dim * 2, out_dim) def forward(self, x): # x: (batch, seq_len) 氨基酸索引 e = self.embed(x) out, _ = self.lstm(e) # 取最后一个时间步的双向拼接作为序列级嵌入 h = out[:, -1, :] z = self.fc(h) return F.normalize(z, p=2, dim=1) # L2 归一化，距离用欧氏等价余弦 def semi_hard_triplet_loss(embeddings, labels, margin=0.3): # embeddings: (B, D) 已归一化 # labels: (B,) 类别索引 dist = torch.cdist(embeddings, embeddings, p=2) # (B, B) loss = [] for i in range(embeddings.size(0)): pos_mask = (labels == labels[i]) & (torch.arange(len(labels)) != i) neg_mask = labels != labels[i] if pos_mask.sum() == 0 or neg_mask.sum() == 0: continue d_pos = dist[i][pos_mask] d_neg = dist[i][neg_mask] # 半硬：选 d_neg > d_pos 且最小的负样本 for dp in d_pos: valid = d_neg[d_neg > dp] if len(valid) == 0: continue dn = valid.min() loss.append(F.relu(dp - dn + margin)) if len(loss) == 0: return torch.tensor(0.0, requires_grad=True) return torch.stack(loss).mean()

SSEncoder里嵌入层加双向 LSTM，最后接一个线性层压到 64 维并做 L2 归一化。归一化之后欧氏距离和余弦距离单调对应，训练更稳。semi_hard_triplet_loss对每个锚点遍历正样本，再挑比正样本距离大且最小的负样本，符合半硬定义。margin 设 0.3 是经验值，太小约束弱，太大训练震荡。

注意：这个实现是双层循环，教学用可以，实际训练要向量化，否则 batch 一大就慢得没法忍。向量化版本可以用torch.nn.TripletMarginLoss配合离线挖掘，或者用pytorch-metric-learning库。

3.3 训练循环与关键参数

训练时把序列切成固定窗口（比如 15~31 个残基），每个窗口一个标签。batch 内要保证每个类别都有样本，否则三元组采不出来。

from torch.utils.data import DataLoader, Dataset class SSWDataset(Dataset): def __init__(self, sequences, labels, window=21): self.samples = [] for seq, lab in zip(sequences, labels): for i in range(0, len(seq) - window + 1, window // 2): self.samples.append((seq[i:i+window], lab[i+window//2])) def __len__(self): return len(self.samples) def __getitem__(self, idx): seq, label = self.samples[idx] # 简化：氨基酸转索引，实际要用词表 idx_seq = [ord(c) % 21 for c in seq] return torch.tensor(idx_seq), torch.tensor(label) # 训练主循环 model = SSEncoder() optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) for epoch in range(50): model.train() total_loss = 0 for x, y in DataLoader(dataset, batch_size=128, shuffle=True): emb = model(x) loss = semi_hard_triplet_loss(emb, y) optimizer.zero_grad() loss.backward() optimizer.step() total_loss += loss.item() print(f"epoch {epoch}, loss {total_loss:.4f}")

窗口取 21 是常见值，覆盖一个二级结构片段的大致长度。步长用窗口一半做重叠，增加样本量。学习率 1e-3 配 Adam 是安全起点，如果 loss 不降，先检查三元组是不是全被 margin 过滤掉了。

训练完成后，验证阶段用 kNN：把验证集样本过编码器得到嵌入，在训练集嵌入里找最近邻，用邻居标签投票。也可以接一个逻辑回归做线性探针，通常比 kNN 更稳。

4. 避坑与排查：二级结构预测里最容易翻车的五件事

4.1 现象：loss 一直不降，准确率随机水平

原因：三元组全被 margin 过滤，损失恒为 0，梯度没回传。常见于随机初始化后嵌入全挤在一起，或者 margin 设得太小。

解决：先打印每个 batch 里有效三元组数量，如果接近 0，把 margin 调大或改用全硬挖掘。也可以先跑几个 epoch 的交叉熵 warmup，让嵌入有初步结构再切三元组。

4.2 现象：训练集准确率很高，验证集掉 10 个点

原因：同源序列泄漏。PDB 里很多蛋白高度相似，随机切分会让训练集和验证集共享同源片段，度量学习对这种泄漏尤其敏感，因为嵌入空间直接记住了同源模式。

解决：按 CATH 或 SCOP 家族切分，确保验证集的家族不在训练集出现。常见做法是用 MMseqs2 做 30% 相似度聚类，按簇切分。

4.3 现象：预测结果里卷曲类特别多，螺旋和折叠被吞

原因：类别不平衡。卷曲通常占 50% 以上，三元组采样时卷曲样本主导，模型倾向于把所有东西拉到卷曲簇附近。

解决：采样时对少数类过采样，或者在三元组构造时按类别配额选锚点。也可以在损失里给少数类加权。

4.4 现象：换更长序列后显存爆了

原因：BiLSTM 对序列长度是线性复杂度，但 batch 内 padding 到最大长度后，实际计算量按最长序列算。

解决：用动态 padding，按 batch 内最大长度截断，而不是全局最大长度。或者改用 CNN 加空洞卷积，显存更可控。

4.5 现象：嵌入维度调到 256 后效果反而变差

原因：维度太高，在小数据集上过拟合，距离度量变得稀疏，最近邻失去区分度。

解决：嵌入维度从 32 或 64 起步，配合 L2 归一化。维度不是越高越好，度量学习里 64~128 通常够用，关键在采样质量。

5. 进阶技巧：用嵌入可视化验证度量空间到底学没学到东西

训练完不能只看 Q3 准确率，那个数字会被类别不平衡糊弄。我习惯用 t-SNE 或 UMAP 把验证集嵌入降到二维，按真实标签上色，直接看三类是不是分开了。如果螺旋和折叠混在一起，说明 margin 或采样还有问题，回去调，别急着加层。

from sklearn.manifold import TSNE import matplotlib.pyplot as plt model.eval() embeddings, true_labels = [], [] with torch.no_grad(): for x, y in DataLoader(val_dataset, batch_size=256): emb = model(x) embeddings.append(emb.cpu().numpy()) true_labels.append(y.numpy()) embeddings = np.concatenate(embeddings) true_labels = np.concatenate(true_labels) tsne = TSNE(n_components=2, perplexity=30, random_state=42) vis = tsne.fit_transform(embeddings) plt.figure(figsize=(8, 6)) for cls, color in zip(['H', 'E', 'C'], ['red', 'blue', 'green']): mask = true_labels == ['H', 'E', 'C'].index(cls) plt.scatter(vis[mask, 0], vis[mask, 1], c=color, label=cls, s=5, alpha=0.6) plt.legend() plt.title("Validation set embedding (t-SNE)") plt.savefig("embedding_tsne.png", dpi=150)

这段代码把验证集嵌入降维后按类别画散点。perplexity 设 30 是常用值，小数据集可以降到 10~15。看的时候关注三点：三类有没有明显分簇、边界区域样本多不多、有没有某一类被完全包住。如果分簇清晰但准确率不高，问题在分类头或 kNN 的 k 值；如果分簇本身就糊，回去查三元组采样。

另一个验证手段是计算类内距离和类间距离的比值。类内平均距离除以类间平均距离，这个值越小说明度量空间越紧凑。训练过程中盯着这个指标，比看 loss 曲线直观。

我自己的习惯是：每次改完采样策略或 margin，先跑 5 个 epoch 看 t-SNE，确认嵌入有分簇趋势再跑完整训练。这个习惯帮我省了无数次白跑一晚上的电费。度量学习这东西，玄学的地方在于超参敏感，但血泪经验是——先把采样搞对，再谈模型深度。希望帮到你。

本文还有配套的精品资源，点击获取