每日基础课

【通俗讲解】 1. 生活类比： 想象你在整理部门会议录音。大部分时候大家轮流发言，你只要记名字就行。但有时两个人争论起来、同时讲话，声音叠在了一起。如果你当成一个人在说话，会议纪要就会全乱套。重叠语音检测，就像一个专门在旁边盯着的助手，一旦发现有人“抢麦同时讲”，立刻在时间轴上贴一张“两人重叠”的便利贴。

2. 必要公式： 对输入音频特征序列 $X = [x_1, x_2, \dots, x_T]$，OSD 模型对每一帧 $t$ 输出一个重叠概率： $$\hat {y}_t = \sigma(W \cdot h_t + b)$$ 判定逻辑： $$\text{Label}_t = \begin{cases} 1 (\text{重叠}), & \text{若 } \hat{y}_t \ge \theta \\ 0 (\text{非重叠/单人/静音}), & \text{若 } \hat{y}_t < \theta \end{cases}$$

• 符号逐个拆解：
• $T$：音频被切片后的总帧数（比如 1 秒切成 100 帧）。
• $x_t$：第 $t$ 帧的声音特征（如梅尔频谱）。
• $h_t$：模型对该帧提取到的深层上下文表征。
• $W, b$：线性分类层的权重和偏置。
• $\sigma$：Sigmoid 激活函数，把输出压到 0 到 1 之间，代表重叠的概率。
• $\hat{y}_t$：模型预测第 $t$ 帧是重叠语音的概率值。
• $\theta$：判决门限阈值（通常取 0.5，但为了召回更多重叠帧常会适当调低，如 0.35）。

4. 它解决什么问题？没有它会怎样？ 真实会议和日常对话中，10%~20% 的时间都在抢话。 传统说话人日志（谁在什么时候说了什么）默认“同一时刻只有一个人发声”。 如果没有 OSD： - 混淆声纹：模型会把两个人的混合声音当成一个“第三者新说话人”。 - 漏掉说话人：模型只能把这段时间分给其中某一个人，导致另一个人彻底漏记，说话人错误率（DER）大幅飙升。

【实现思路】 1. 搭建一个轻量模型：1维卷积提取局部帧间频谱特征 -> 双向 GRU 捕获长程前后文时序 -> 线性全连接层输出逐帧未归一化对数概率（Logits）。 2. 使用 `BCEWithLogitsLoss`（二元交叉熵）计算帧级损失，兼顾数值稳定性与类别权重（重叠帧通常较少）。 3. 设定阈值后处理，将概率转化为 0/1 判定矩阵。

【完整代码】

import torch
import torch.nn as nn
import torch.nn.functional as F

# 1. 定义轻量级 OSD 模型
class LightweightOSD(nn.Module):
    def __init__(self, input_dim=80, hidden_dim=64, num_layers=2):
        super().__init__()
        # 1D 卷积沿时间轴抽取局部特征 (保留时序长度)
        self.conv = nn.Sequential(
            nn.Conv1d(in_channels=input_dim, out_channels=hidden_dim, kernel_size=5, padding=2),
            nn.BatchNorm1d(hidden_dim),
            nn.ReLU(),
            nn.Dropout(0.1)
        )
        # 双向 GRU 建模上下文
        self.gru = nn.GRU(
            input_size=hidden_dim,
            hidden_size=hidden_dim,
            num_layers=num_layers,
            batch_first=True,
            bidirectional=True
        )
        # 输出层：将双向 GRU 隐藏维度映射到标量 (Logits)
        self.fc = nn.Linear(hidden_dim * 2, 1)

    def forward(self, x):
        # x 形状: (Batch, Time, Feat_Dim)
        # Conv1d 期待形状: (Batch, Channels, Time)
        x = x.transpose(1, 2)
        feat = self.conv(x)
        feat = feat.transpose(1, 2)  # 还原回 (Batch, Time, Hidden)

        gru_out, _ = self.gru(feat)  # (Batch, Time, Hidden*2)
        logits = self.fc(gru_out).squeeze(-1)  # (Batch, Time)
        return logits

# 2. 模拟训练与推理过程
if __name__ == "__main__":
    torch.manual_seed(42)

    # 模拟数据：Batch=4, Time=200 帧 (约2秒音频), Feat_Dim=80
    batch_size = 4
    time_steps = 200
    feat_dim = 80
    
    dummy_input = torch.randn(batch_size, time_steps, feat_dim)
    # 模拟真实标签：大部分是单人(0)，部分是重叠(1)
    dummy_targets = (torch.rand(batch_size, time_steps) > 0.8).float()

    # 实例化模型
    model = LightweightOSD(input_dim=feat_dim, hidden_dim=64)
    model.train()

    # 重叠样本一般较少，设置 pos_weight 给正例（重叠）更高权重
    pos_weight = torch.tensor([2.0])
    criterion = nn.BCEWithLogitsLoss(pos_weight=pos_weight)

    # 前向传播
    logits = model(dummy_input)
    loss = criterion(logits, dummy_targets)

    print(f"输入特征形状: {dummy_input.shape}")
    print(f"输出 Logits 形状: {logits.shape}")
    print(f"计算所得帧级 BCE Loss: {loss.item():.4f}\n")

    # 推理阶段：计算重叠概率与决策
    model.eval()
    with torch.no_grad():
        test_logits = model(dummy_input)
        overlap_probs = torch.sigmoid(test_logits)  # 转为 0~1 概率
        
        # 判定门限设置为 0.4 (偏向更多召回重叠)
        threshold = 0.4
        predictions = (overlap_probs >= threshold).int()

    print(f"第一条样本前10帧重叠概率: {overlap_probs[0, :10].tolist()}")
    print(f"第一条样本前10帧判定结果 (阈值={threshold}): {predictions[0, :10].tolist()}")
    print(f"第一条样本前10帧真实标签: {dummy_targets[0, :10].int().tolist()}")