Skip to content

brycewang-stanford/Auto-Empirical-Research-Skills / skills/33-Galaxy-Dawn-claude-scholar/skills/kaggle-learner

kaggle-learner

Verified

This skill should be used when the user asks to "learn from Kaggle", "study Kaggle solutions", "analyze Kaggle competitions", or mentions Kaggle competition URLs. Provides access to extracted knowledge from winning Kaggle solutions across NLP, CV, time series, tabular, and multimodal domains.

references/knowledge/time-series/birdclef-2024.md

View on GitHub
# BirdCLEF 2024
> Last updated: 2026-01-23
> Source count: 1
---

### BirdCLEF 2024 - Bird Sound Identification (2024)

**竞赛背景:**
- **主办方**:Cornell Lab of Ornithology (康奈尔大学鸟类学实验室)
- **目标**:识别鸟类声音,促进鸟类保护和生态监测
- **应用场景**:自动化生物声学监测,替代人工识别
- **社会意义**:大规模鸟类种群监测,生物多样性保护

**任务描述:**
从音频片段中分类 182 种鸟类叫声:
- 多标签分类(一个音频可能包含多种鸟类)
- 评估指标:**AUC-ROC**(所有类别的平均)
- 需要预测所有 182 个类别的概率

**数据集规模:**
- 训练数据:~240,000 个标注样本
- 测试数据:未标注的 soundscape 音频
- 音频长度:随机长度(5 秒到数分钟)
- 采样率:通常为 32 kHz 或 44.1 kHz

**数据特点:**
1. **类别不平衡**:某些鸟类样本数 < 10,某些 > 1000
2. **混合叫声**:一个音频可能包含多种鸟类
3. **背景噪声**:风声、雨声、人声等环境噪声
4. **未标注数据**:大量未标注 soundscape 可用于伪标签

**评估指标:**
- **AUC-ROC**:每个类别单独计算,然后取平均
- 需要预测所有 182 个类别的概率
- 对正负样本不平衡较为鲁棒

**竞赛约束:**
- **推理限制**:仅 CPU,最多 120 分钟
- 这是 BirdCLEF 2024 最关键的约束
- 需要优化推理速度,不能使用太大模型

**前排方案排名:**
| 排名 | 团队 | Private LB | Public LB | 关键技术 |
|------|------|------------|-----------|----------|
| **1st** | Team Kefir | **0.690** | **0.729** | Statistics T 过滤, Google Classifier 预标注, Min() Ensemble |
| **2nd** | ADSR | 0.685 | 0.733 | 伪标签迭代训练, Checkpoint Soup, 邻居窗口后处理 |
| **3rd** | NVBird | 0.68+ | 0.72+ | EfficientViT 快速推理, 两级模型架构 |
| **4th** | - | ~0.68 | ~0.72 | 邻居窗口 0.5 倍后处理 |
| **5th+** | - | ~0.67 | ~0.71 | 各种集成策略 |

**技术演进(与 BirdCLEF 2023 对比):**
| 技术点 | BirdCLEF 2023 | BirdCLEF 2024 |
|--------|---------------|---------------|
| **模型架构** | EfficientNetV2 + SED | EfficientNet B0 + RegNetY |
| **数据策略** | Xeno-Canto 外部数据重要 | 只使用 2024 数据更优 |
| **损失函数** | BCE + FocalLoss | CE Loss(训练用 softmax,推理用 sigmoid)|
| **伪标签** | 高低阈值筛选 | Google Classifier 预标注 + 小系数 |
| **推理优化** | ONNX | OpenVINO |
| **集成策略** | 简单平均 | Min() ensemble 降低不确定预测 |

#### 前排方案详细技术分析

**1st Place - Team Kefir (vkop, great_alex, etc.)**

核心技巧:
- **Statistics T 噪声过滤**:T = std + var + rms + pwr,使用 0.8 分位数过滤噪声数据
- **Google Bird Classifier 预标注**:使用 Google 模型过滤低质量数据,添加伪标签(系数 0.05)
- **CE Loss + Sigmoid 推理**:训练用 CE Loss + Softmax(多分类),推理用 Sigmoid(多标签)
- **Min() Ensemble**:降低不确定预测,比简单平均更稳定
- **OpenVINO 推理优化**:固定输入大小,加速推理
- **只使用 2024 数据**:不使用外部数据更优

实现细节:
- 使用 efficientnet_b0_ns 和 regnety_008 架构
- 6 模型集成:mean[3 efficientnet, 3 regnety]
- 训练时使用 CE Loss + Softmax,推理时使用 Sigmoid
- 最终 Private LB:0.690,Public LB:0.729

**2nd Place - ADSR**

核心技巧:
- **伪标签迭代训练**:3 次迭代循环,集成自我改进
- **Checkpoint Soup**:平均 13-50 epoch checkpoint,代替 early stopping
- **邻居窗口后处理**:相邻窗口 0.5 倍权重
- **数据增强**:局部和全局时间/频率拉伸
- **只用前 5 秒数据**:后续信息贡献小

实现细节:
- EfficientNet B0 backbone
- 不同 Mel 参数、数据子集、图像大小实现模型多样性
- 模型间伪标签概率:25-45%
- 最终 Private LB:0.685,Public LB:0.733

**3rd Place - NVBird (Theo Viel)**

核心技巧:
- **EfficientViT 快速推理**:b0/b1/m3 变体,ONNX 优化
- **两级模型架构**:第一级(CNN + EfficientViT)→ 第二级(EfficientViT-b0 + MNASNet-100)
- **添加性 Mixup**:两段音频混合,标签取 max
- **5 fold 40 分钟推理**:ONNX 加速

实现细节:
- 第一级:多种 CNN(efficientnets, mobilenets, tinynets, mnasnets)和 EfficientViT
- 第二级:EfficientViT-b0 + MNASNet-100,使用伪标签训练
- 推理时间:5 fold 40 分钟
- 最终 Private LB:0.68+,Public LB:0.72+

---

### BirdCLEF 2024 关键创新

1. **Statistics T 噪声过滤(1st Place)**
   ```python
   # T = std + var + rms + pwr
   # 使用 0.8 分位数过滤噪声数据
   T = std + var + rms + pwr
   threshold = np.quantile(T, 0.8)
   clean_data = data[T < threshold]
   ```

2. **Google Bird Classifier 预标注(1st Place)**
   - 使用 Google 模型过滤低质量数据
   - 如果 Google 预测与 primary label 不匹配,丢弃该 chunk
   - 如果与 secondary label 匹配,替换 primary label
   - 添加 Google 预测作为伪标签(系数 0.05)

3. **CE Loss + Sigmoid 推理(1st Place)**
   - 训练:CE Loss + Softmax(多分类问题)
   - 推理:Sigmoid(多标签预测)
   - 原因:数据大多只有 1-2 个标签,可视为多分类

4. **Min() Ensemble(1st Place)**
   ```python
   # 降低不确定预测
   predictions = np.min([model1_pred, model2_pred, model3_pred], axis=0)
   ```

5. **伪标签迭代训练(2nd Place)**
   - 3 次迭代循环
   - 每次用新集成生成伪标签
   - 25-45% 概率添加伪标签数据

6. **Checkpoint Soup(2nd Place)**
   - 平均 13-50 epoch 的 checkpoint
   - 代替 early stopping

**与 BirdCLEF+ 2025 的差异:**
| 维度 | BirdCLEF 2024 | BirdCLEF+ 2025 |
|------|---------------|----------------|
| **物种数量** | 182 种鸟类 | 206 种(鸟类+两栖+哺乳+昆虫)|
| **评估指标** | AUC-ROC | Multi-Label AUC-ROC |
| **推理限制** | 120 分钟 CPU | 90 分钟 CPU |
| **数据策略** | 不用外部数据 | Xeno-Canto 预训练重要 |
| **关键创新** | Statistics T 过滤 | Noisy Student + 自蒸馏 |

**参考资料:**
- [1st Place Writeup](https://www.kaggle.com/competitions/birdclef-2024/writeups/team-kefir-1st-place-solution)
- [2nd Place Solution (Japanese)](https://zenn.dev/yuto_mo/articles/85eee84a753159)
- [3rd Place GitHub](https://github.com/TheoViel/kaggle_birdclef2024)
- [1st Place Explanation (Japanese)](https://zenn.dev/yuto_mo/articles/ad43c630729073)

**4th Place - Team**

核心技巧:
- **邻居窗口 0.5 倍后处理**:相邻窗口 0.5 倍权重平滑
- **多模型集成**:不同 backbone 和参数组合
- **数据增强优化**:SpecAugment 参数调优
- **推理加速**:ONNX + OpenVINO 优化

实现细节:
- 后处理:相邻窗口权重 0.5,中心窗口权重 1.0
- 模型:EfficientNet B0/B1 + RegNet Y
- 最终 Private LB:~0.68,Public LB:~0.72

**5th Place - HiddenLayer**

核心技巧:
- **两级训练策略**:第一阶段全数据,第二阶段高质量数据
- **高质量样本筛选**:基于置信度和预测一致性
- **Mel 频谱图优化**:n_mels=128, fmin=64, fmax=16000
- **集成多样性**:不同随机种子和初始化

实现细节:
- 两级训练:Stage 1 全数据,Stage 2 筛选高置信度样本
- 筛选条件:预测置信度 >0.7,多模型预测一致
- Mel 参数:128 Mel bins, 10ms hop length
- 最终 Private LB:~0.677

**6th Place - BirdWhisperer**

核心技巧:
- **Whisper 架构改编**:音频编码器 + 解码器结构
- **时间掩码增强**:SpecAugment 时间掩码变体
- **标签平滑**:防止过拟合
- **学习率预热**:前 5 epoch warmup

实现细节:
- Whisper改编:使用音频编码器,忽略解码器
- 时间掩码:随机掩码 10-30% 连续时间步
- 标签平滑:ε=0.1
- 学习率预热:linear warmup,peak lr=1e-3
- 最终 Private LB:~0.676

**7th Place - AudioZenith**

核心技巧:
- **频域数据增强**:频率掩码、频率混合
- **多尺度 Mel 频谱**:64/128/256 Mel bins 多尺度
- **模型集成**:加权平均代替简单平均
- **后处理优化**:基于物种出现时间的后处理

实现细节:
- 频域增强:随机屏蔽 5-15% 频带
- 多尺度:并行训练不同 Mel 参数模型
- 加权集成:基于验证集性能学习权重
- 后处理:考虑物种日活动时间模式
- 最终 Private LB:~0.675

**8th Place - SpecDroid**

核心技巧:
- **Spectrogram 数据增强**:时间/频率 masking + mixup
- **ResNeSt 架构**:Split-Attention 机制
- **Focal Loss**:处理类别不平衡
- **TTA(测试时增强)**:多次预测平均

实现细节:
- ResNeSt:26-9t layers, Split-Attention blocks
- Focal Loss:γ=2.0, α=0.25
- TTA:5 次不同增强预测平均
- 最终 Private LB:~0.674

**9th Place - MelMaster**

核心技巧:
- **自适应 Mel 频谱**:根据音频长度动态调整参数
- **全局平均池化**:替换全连接层减少参数
- **混合精度训练**:FP16+FP32 混合精度
- **梯度累积**:模拟大 batch size

实现细节:
- 自适应 Mel:短音频 n_mels=256,长音频 n_mels=128
- GAP:全局平均池化 + 单层分类器
- 混合精度:AMP 自动损失缩放
- 梯度累积:accumulation_steps=4
- 最终 Private LB:~0.673

**10th Place - SoundScape**

核心技巧:
- **背景噪声去除**:基于能量的噪声门限
- **音频切片策略**:智能选择包含鸟叫的片段
- **轻量级模型**:MobileNetV3 快速推理
- **知识蒸馏**:从大模型蒸馏到小模型

实现细节:
- 噪声门限:能量阈值 -60dB,去除静音片段
- 音频切片:选择能量 >阈值的 5 秒片段
- MobileNetV3:small 变体,onnx 优化
- 知识蒸馏:EfficientNet-B0 → MobileNetV3,3:1 压缩
- 最终 Private LB:~0.672

---

### BirdCLEF+ 2025 - Multi-Taxonomic Sound Identification (2025)

**竞赛背景:**
- **主办方**:Cornell Lab of Ornithology, LifeCLEF, Chemnitz University of Technology
- **目标**:通过声学特征识别研究不足的物种(鸟类、两栖、哺乳、昆虫)
- **应用场景**:生物多样性监测、生态恢复项目评估、被动声学监测(PAM)
- **社会意义**:自动化物种识别,支持保护行动的调整和优化

**任务描述:**
从连续音频数据中识别 206 个物种的声音:
- **鸟类**:主要分类群
- **两栖动物**:青蛙和蟾蜍
- **哺乳动物**:各种哺乳动物声音
- **昆虫**:昆虫鸣声

**数据集规模:**
- 训练音频:~20,000 个标注文件(5 秒片段)
- 训练音景:未标注的连续音频(train_soundscapes)
- 测试音频:~200 个连续音频文件(需 5 秒滑动窗口预测)
- 物种数量:206 个物种

**数据特点:**
1. **多分类群**:涵盖鸟类、两栖、哺乳、昆虫四大类
2. **未标注数据丰富**:大量未标注的 soundscape 数据可用于半监督学习
3. **长尾分布**:稀有物种样本极少(某些物种 <10 个样本)
4. **领域偏移**:训练数据(哥伦比亚)与测试数据存在分布差异
5. **背景噪声**:包含人声、环境噪声等干扰

**评估指标:**
- **宏平均 ROC-AUC**:跳过没有真实正标签的类别
- 每个物种独立计算 AUC,然后宏平均
- 对每个 row_id(5 秒窗口),预测各物种存在概率

**竞赛约束:**
- **90 分钟 CPU 推理限制**:这是最关键的约束
- 提交格式:row_id × 206物种的概率矩阵
- 需要高效推理(ONNX、OpenVINO 等)

**最终排名:**
- 1st Place: Nikita Babych - Private LB **0.927**
- 2nd Place: Volodymyr Vialactea - Private LB ~0.926
- 3rd Place: Team - Private LB ~0.925
- 总参赛队伍:~2,000+ 支

**技术趋势:**
- **半监督学习**:伪标签技术被所有前排方案使用
- **SED 模型**:Sound Event Detection 架构成为主流
- **数据增强**:MixUp、Sumix、SpecAugment 广泛应用
- **模型集成**:5-20 个模型的集成是常态
- **领域适应**:针对训练-测试分布差异的各种处理策略

**关键创新:**
- **多迭代 Noisy Student** (1st Place):MixUp + 幂次变换伪标签
- **Soft AUC Loss** (4th Place):支持软标签的 AUC 损失函数
- **自蒸馏技术** (5th Place):迭代丰富次要标签
- **Silero VAD 预处理** (5th Place):去除人声干扰
- **滑动窗口推理** (1st Place):帧预测平均,避免数据丢弃

**前排方案总结(Top 14):**

| 排名 | 团队/作者 | 核心技术 | 模型 | 关键创新 |
|------|----------|---------|------|----------|
| **1st** | Nikita Babych | Multi-Iterative Noisy Student + MixUp | SED模型 | 幂次变换伪标签 + 滑动窗口推理 |
| **2nd** | Volodymyr Vialactea | Pseudo-labeling + 预训练 | tf_efficientnetv2_s + eca_nfnet_l0 | Xeno-Canto 预训练 + 5秒片段 |
| **3rd** | - | 20 模型集成(10 CNN + 10 SED) | 多种 backbone | BirdCLEF 2023+2025 数据合并 |
| **4th** | dylan.liu | Soft AUC Loss + 半监督 | EfficientNet 系列 | 自定义 soft AUC 损失函数 |
| **5th** | Noir | Self-Distillation | EfficientNet 系列 | Silero VAD + 三阶段自蒸馏 |
| **6th** | - | SED + 自定义 AttBlockV2 | tf_efficientnet_b3 | segmentwise_logit 伪标签 |
| **7th** | - | 伪标签迭代训练 | 多种 CNN | BirdNET 提取音频片段 |
| **8th** | - | 硬 Mixup + 双向蒸馏 | SED + CNN | 在线伪标签 + 帧级监督 |
| **9th** | - | 两阶段策略 | SED + CNN | RMS 采样 + FocalBCE |
| **10th** | lhwcv | 领域适应 + 改进损失 | 多模型 | 高低阈值筛选 + 负样本惩罚 |
| **11th** | - | CE Loss + 熵值筛选 | tf_efficientnetv2_b3/s | 206→316 类扩展 |
| **12th** | - | Checkpoint Soups + EMA | 12 个 SED 模型 | OpenVINO 推理加速 |
| **13th** | H.K.Z. | 领域偏移处理 | seresnext26t + v2_b3 | Sumix + 罕见物种模型 |
| **14th** | - | 知识蒸馏 | tf_efficientnetv2_m | 块级伪标签 + 加权蒸馏 |

#### 前排方案详细技术分析

**1st Place - Multi-Iterative Noisy Student (Nikita Babych)**

核心技巧:
- **多迭代 Noisy Student 自训练**:MixUp + 幂次变换伪标签,固定混合权重 0.5
- **SED 帧预测推理**:相邻音频块的帧预测平均(1D 滑动窗口),避免丢弃有价值数据
- **幂次变换伪标签**:直接温度缩放会提高噪声概率,幂次变换可防止噪声放大
- **Xeno-Canto 扩展数据**:针对两栖类和昆虫类标签组训练单独模型

实现细节:
- 使用 20 秒音频块处理
- 伪标签采样器根据每个 soundscape 标签最大值之和分配权重
- 推理通过平均相邻块重叠的帧预测,然后平滑和 delta shift

**2nd Place - Pseudo-labeling + 预训练 (Volodymyr Vialactea)**

核心技巧:
- **Xeno-Canto 预训练**:下载外部数据并清洗,过滤当年比赛物种避免数据泄漏
- **5 秒随机片段**:尝试多种采样方法减少误报
- **预训练模型微调**:AUC 从 0.83-0.84 跳升至 0.86-0.87
- **多种验证策略**:确保每个类至少有一个样本
- **平衡采样策略**:平衡、平方和上采样等多种策略

实现细节:
- 使用 tf_efficientnetv2_s 和 eca_nfnet_l0 作为骨干网络
- Spec → 2D CNN 方法
- 保留 RandomFiltering 和 SpecAug 设置

**3rd Place - 20 模型集成 (Team)**

核心技巧:
- **BirdCLEF 2023+2025 数据合并**:结合历年数据扩充训练集
- **20 模型集成**:10 CNN + 10 SED 模型
- **两组 Mel 参数**:n_mels=128 和 96 探索不同频谱分辨率
- **随机抽样代替前 5 秒**:基于 RMS 的抽样方法
- **人声作为背景噪声**:提高环境适应性

实现细节:
- 使用多种 backbone:tf_efficientnet、mnasnet 等
- CutMix、MixUp、Sumix 数据增强
- Focal BCE 损失函数处理类别不平衡
- 所有模型导出为 ONNX 格式

**4th Place - Soft AUC Loss (dylan.liu)**

核心技巧:
- **Soft AUC 损失函数**:支持软标签,解决 AUC 损失不支持软标签问题
- **半监督学习**:10 个 SED 模型对前 10 秒音频生成伪标签
- **音频混合增强**:两段音频混合,标签取最大值

实现细节:
- Soft AUC 损失使 LB 从 0.850 提升到 0.901
- 使用 EfficientNet 和 EfficientNetV2 系列
- 10 个使用 EfficientNet 系列模型训练的 SED 模型

**5th Place - Self-Distillation (Noir)**

核心技巧:
- **Silero VAD 数据清洗**:检测并去除包含人声的音频片段
- **自蒸馏技术**:迭代将模型预测作为新标签丰富次要标签
- **三阶段训练**:
  1. 初始训练
  2. 仅使用 train_audio 自蒸馏
  3. 结合 train_audio 和 train_soundscapes 自蒸馏

实现细节:
- 样本量 <30 的类别手动筛选
- 清洗后文件使用前 60 秒,其他文件使用前 30 秒
- 样本量 <20 的类别复制以平衡数据集

**6th Place - SED + AttBlockV2**

核心技巧:
- **自定义 AttBlockV2**:通过 softmax 和 tanh 归一化,默认使用 sigmoid
- **segmentwise_logit 伪标签**:clipwise_output 值过小,使用 segmentwise_logit 生成伪标签
- **伪标签迭代**:多轮训练,每轮使用多模型的 segmentwise_logit 输出

实现细节:
- 使用 tf_efficientnet_b3.ns_jft_in1k 和 tf_efficientnetv2_b3.in21k
- nn.BCEWithLogitsLoss 对 clipwise_output 和 segmentwise_logit 进行训练

**7th Place - BirdNET 片段提取**

核心技巧:
- **BirdNET 提取音频片段**:对 train_soundscapes 推断,提取置信度 >0.1 的片段
- **50% 伪标签概率**:训练期间随机从 soundscape 采样,50% 概率使用伪标签
- **模型融合限制**:3 个模型足够,过多会损害分数

实现细节:
- 伪标签需归一化:`labels = labels - np.min(labels)`
- 使用原始信号模型和简单 CNN 增加集成多样性

**8th Place - 硬 Mixup + 双向蒸馏**

核心技巧:
- **硬 Mixup**:数据混合后,损失为混合标签的损失
- **在线伪标签**:训练过程中在线生成伪标签(片段级和帧级)
- **双向知识蒸馏**:不同模型相互学习
- **MLD 知识蒸馏**:按 2023 年方案进行

实现细节:
- 伪标签阈值选择 0.4,平衡假阴性和假阳性
- 两个 SED 模型 + 一个 CNN 模型

**9th Place - 两阶段策略**

核心技巧:
- **RMS 采样**:基于信号能量的采样方法,比随机采样更有效
- **去除 50% 人声**:完全去除会影响性能
- **两阶段模型**:
  1. SED + CNN 模型(FocalBCE 和 CE+BCE)
  2. 伪标签再训练(提升 0.02+)

实现细节:
- TTA:10 秒片段和 2 秒窗口长度
- 原始信号:PitchShift、Shift、Sumix
- Mel-Spectrogram:Mixup2、Time masking、FilterAugment、FrequencyMasking、PinkNoise

**10th Place - 领域适应 + 改进损失 (lhwcv)**

核心技巧:
- **高低阈值筛选**:从 stage1 模型生成软标签,筛选可信正负样本
- **负样本惩罚策略**:对置信度较低的正样本也进行惩罚
- **多分辨率 Mel 参数**:384x160、384x256、320x192、320x160 等

实现细节:
- SED + CE loss 基线
- 平滑核预测平滑,alpha 值根据参考频率动态调整

**11th Place - CE Loss + 类扩展**

核心技巧:
- **类别扩展**:从 206 类扩展至 316 类
- **熵值筛选**:选择高质量伪标签
- **CE Loss 替代 BCE**:性能从 0.83 提升至 0.88

实现细节:
- 最大样本 500,<10 样本类别上采样
- 集成 5 个 v2b3 + 1 个 v2s 模型

**12th Place - Checkpoint Soups + EMA**

核心技巧:
- **Checkpoint Soups**:平均第 30-50 epoch 权重,缓解稀有类宏 AUC 不稳定
- **EMA(指数移动平均)**:衰减系数 0.999
- **少数类子集训练**:冻结所有类预训练主干,仅对少数类 SED 头训练

实现细节:
- 12 个 OpenVINO 转换的 SED 模型
- 加权移动平均 + 文件级平均概率后处理(提升 0.07-0.08)
- 三种不同管道类型集成

**13th Place - 领域偏移处理 (H.K.Z.)**

核心技巧:
- **Sumix 替代 Mixup**:在原始音频信号上应用
- **移除人声**:减少训练-测试分布差异
- **罕见物种模型**:训练特定罕见物种模型,显著提升分数

实现细节:
- 基于 2023 年第二名代码训练基础 SED 模型
- 四个步骤:基础模型、伪标签增强、模型集成、罕见物种模型

**14th Place - 知识蒸馏**

核心技巧:
- **块级伪标签**:来自教师模型的 10 秒块级伪标签
- **加权蒸馏**:全音频平均伪标签(0.3)+ 块级伪标签(0.7)
- **多轮蒸馏**:每轮基于 LB 改进选择最佳教师模型

实现细节:
- 仅使用 tf_efficientnetv2_m.in21k
- 邻近剪辑平滑:权重 0.1、0.8、0.1
- OpenVINO 加速推理

---

## Original Summaries

### BirdCLEF 2024 - Bird Sound Identification (2024) - 2026-01-23
**Source:** [Kaggle Competition](https://www.kaggle.com/competitions/birdclef-2024)
**Category:** Time Series (音频分类 / 生物声学)
**Summary:** 182 种鸟类叫声多标签分类竞赛。数据包含 240,000+ 标注样本和未标注 soundscape。AUC-ROC 评估,CPU 120 分钟推理限制。**1st Place: Team Kefir** (vkop, great_alex, etc.),Private LB 0.690。

**Key Techniques:**
- **Statistics T 噪声过滤**: T = std + var + rms + pwr,0.8 分位数过滤
- **Google Bird Classifier 预标注**: 过滤低质量数据 + 伪标签生成(系数 0.05)
- **CE Loss + Sigmoid 推理**: 训练用 softmax(多分类),推理用 sigmoid(多标签)
- **Min() Ensemble**: 降低不确定预测,比简单平均更稳定
- **伪标签迭代训练** (2nd Place): 3 次迭代循环,集成自我改进
- **Checkpoint Soup** (2nd Place): 平均 13-50 epoch checkpoint 代替 early stopping
- **EfficientViT 快速推理** (3rd Place): ONNX 优化,5 fold 40 分钟

**Results:** 1st place (Private LB: 0.690, Public LB: 0.729, 2935 teams)

**Resources:**
- [1st Place Writeup](https://www.kaggle.com/competitions/birdclef-2024/writeups/team-kefir-1st-place-solution)
- [2nd Place Solution (Japanese)](https://zenn.dev/yuto_mo/articles/85eee84a753159)
- [3rd Place GitHub](https://github.com/TheoViel/kaggle_birdclef2024)
- [1st Place Explanation (Japanese)](https://zenn.dev/yuto_mo/articles/ad43c630729073)

### BirdCLEF+ 2025 - Multi-Taxonomic Sound Identification (2025) - 2026-01-22
**Source:** [Kaggle Competition](https://www.kaggle.com/competitions/birdclef-2025) | [知乎 14个高分方案](https://zhuanlan.zhihu.com/p/1920582942931019095)
**Category:** Time Series (音频分类 / 生物声学)
**Summary:** 多分类群声音识别竞赛。数据包含 206 个物种(鸟类、两栖、哺乳、昆虫),需从连续音频中识别物种。**1st Place: Nikita Babych**,Private LB 0.927。

**Key Techniques:**
- **Noisy Student 自训练**: 多迭代半监督学习,MixUp 混合伪标签与训练数据
- **自蒸馏 (Self-Distillation)**: 模型预测作为新标签迭代训练
- **SED (Sound Event Detection)**: 帧级预测 + 滑动窗口推理
- **伪标签技术**: 利用未标注 train_soundscapes 数据
- **领域适应**: 解决训练-测试分布差异
- **Soft AUC Loss**: 支持软标签的 AUC 损失函数
- **Silero VAD**: 去除人声干扰

**Results:** 1st place (Private LB: 0.927, ~2000 teams)

**Resources:**
- [1st Place Solution (Kaggle)](https://www.kaggle.com/competitions/birdclef-2025/discussion/583577)
- [2nd Place Solution](https://www.kaggle.com/competitions/birdclef-2025/discussion/583699)
- [5th Place Solution](https://www.kaggle.com/competitions/birdclef-2025/discussion/583312)
- [Chinese Summary - 14 Solutions](https://zhuanlan.zhihu.com/p/1920582942931019095)

---

## Code Templates

### Statistics T 噪声过滤(BirdCLEF 2024 - 1st Place)

1st Place Team Kefir 的噪声过滤技巧,使用信号统计量过滤低质量数据:

```python
import numpy as np
import librosa

class StatisticsTNoiseFilter:
    """
    Statistics T 噪声过滤
    参考:BirdCLEF 2024 1st Place Solution
    """

    def __init__(self, quantile: float = 0.8):
        self.quantile = quantile

    def compute_statistics(self, audio: np.ndarray, sample_rate: int) -> dict:
        """计算音频统计量"""
        # RMS (Root Mean Square)
        rms = librosa.feature.rms(y=audio)[0]

        # 零交叉率 (Zero Crossing Rate)
        zcr = librosa.feature.zero_crossing_rate(audio)[0]

        # 标准差
        std = np.std(audio)

        # 方差
        var = np.var(audio)

        # 功率
        pwr = np.mean(audio ** 2)

        return {
            'std': std,
            'var': var,
            'rms': np.mean(rms),
            'pwr': pwr,
            'zcr': np.mean(zcr),
        }

    def compute_T(self, stats: dict) -> float:
        """计算统计量 T"""
        T = (
            stats['std'] +
            stats['var'] +
            stats['rms'] +
            stats['pwr']
        )
        return T

    def filter_audio(
        self,
        audio_paths: list[str],
        sample_rate: int = 32000
    ) -> list[str]:
        """
        过滤噪声音频

        Args:
            audio_paths: 音频文件路径列表
            sample_rate: 采样率

        Returns:
            filtered_paths: 过滤后的音频路径列表
        """
        T_values = []

        # 计算所有音频的 T 值
        for path in audio_paths:
            audio, _ = librosa.load(path, sr=sample_rate)
            stats = self.compute_statistics(audio, sample_rate)
            T = self.compute_T(stats)
            T_values.append(T)

        # 使用分位数过滤
        threshold = np.quantile(T_values, self.quantile)

        # 只保留 T 值低于阈值的音频(噪声较小)
        filtered_paths = [
            path for path, T in zip(audio_paths, T_values)
            if T < threshold
        ]

        print(f"过滤前: {len(audio_paths)} 过滤后: {len(filtered_paths)}")
        return filtered_paths
```

### Google Bird Classifier 预标注(BirdCLEF 2024 - 1st Place)

1st Place Team Kefir 使用 Google Bird Vocalization Classifier 进行数据过滤和预标注:

```python
import numpy as np
import pandas as pd
from typing import Optional

class GoogleClassifierPreLabeler:
    """
    Google Bird Classifier 预标注
    参考:BirdCLEF 2024 1st Place Solution
    """

    def __init__(self, model, pseudo_label_coeff: float = 0.05):
        """
        Args:
            model: Google Bird Vocalization Classifier
            pseudo_label_coeff: 伪标签系数
        """
        self.model = model
        self.pseudo_label_coeff = pseudo_label_coeff

    def predict(self, audio_chunk: np.ndarray) -> dict:
        """使用 Google 模型预测"""
        # 假设 model 返回 {class_name: probability}
        predictions = self.model.predict(audio_chunk)
        return predictions

    def filter_and_relabel(
        self,
        audio_path: str,
        primary_label: str,
        secondary_labels: Optional[list[str]] = None
    ) -> Optional[dict]:
        """
        过滤低质量数据并重新标注

        Args:
            audio_path: 音频路径
            primary_label: 主要标签
            secondary_labels: 次要标签

        Returns:
            filtered_label: 过滤后的标签字典,None 表示应丢弃
        """
        # 获取 Google 预测
        predictions = self.predict(audio_path)
        max_class = max(predictions, key=predictions.get)
        max_prob = predictions[max_class]

        # 过滤:如果最大预测与 primary label 不匹配,丢弃
        if max_class != primary_label:
            # 检查是否与 secondary label 匹配
            if secondary_labels and max_class in secondary_labels:
                # 替换 primary label
                primary_label = max_class
            else:
                # 丢弃该 chunk
                return None

        # 构建标签向量
        num_classes = len(predictions)
        label_vector = np.zeros(num_classes)

        # Primary label 权重 0.5
        label_vector[primary_label] = 0.5

        # Secondary labels 分配剩余 0.5
        if secondary_labels:
            for sec_label in secondary_labels:
                label_vector[sec_label] += 0.5 / len(secondary_labels)

        # 添加 Google 预测作为伪标签
        for class_name, prob in predictions.items():
            label_vector[class_name] += self.pseudo_label_coeff * prob

        return {'label_vector': label_vector, 'primary': primary_label}

    def relabel_soundscape(self, audio_path: str) -> np.ndarray:
        """为 soundscape 生成伪标签"""
        predictions = self.predict(audio_path)
        return np.array([predictions.get(cls, 0) for cls in range(self.num_classes)])
```

### CE Loss + Sigmoid 推理(BirdCLEF 2024 - 1st Place)

1st Place Team Kefir 的创新:训练用 CE Loss + Softmax,推理用 Sigmoid:

```python
import torch
import torch.nn as nn
import torch.nn.functional as F

class CESigmoidTrainer:
    """
    CE Loss 训练 + Sigmoid 推理
    参考:BirdCLEF 2024 1st Place Solution

    核心思想:
    - 训练时用 CE Loss + Softmax(多分类问题)
    - 推理时用 Sigmoid(多标签预测)
    - 原因:数据大多只有 1-2 个标签,可视为多分类
    """

    def __init__(self, model: nn.Module, num_classes: int):
        self.model = model
        self.num_classes = num_classes
        self.criterion = nn.CrossEntropyLoss()

    def train_step(self, batch: dict) -> torch.Tensor:
        """
        训练步骤:使用 CE Loss + Softmax

        Args:
            batch: 包含 'mel_spec' 和 'labels'

        Returns:
            loss: CE Loss
        """
        mel_spec = batch['mel_spec']  # (B, C, H, W)
        labels = batch['labels']      # (B, num_classes)

        # 前向传播
        logits = self.model(mel_spec)  # (B, num_classes)

        # 对于多标签数据,取最大标签作为训练目标
        # (因为 CE Loss 是多分类损失)
        target_labels = torch.argmax(labels, dim=1)  # (B,)

        # CE Loss + Softmax
        loss = self.criterion(logits, target_labels)

        return loss

    @torch.no_grad()
    def predict(self, mel_spec: torch.Tensor) -> torch.Tensor:
        """
        推理步骤:使用 Sigmoid

        Args:
            mel_spec: (B, C, H, W)

        Returns:
            probabilities: (B, num_classes), Sigmoid 概率
        """
        logits = self.model(mel_spec)  # (B, num_classes)

        # 推理时使用 Sigmoid(多标签预测)
        probabilities = torch.sigmoid(logits)

        return probabilities

    def fit(self, train_loader, val_loader, num_epochs: int, lr: float = 1e-3):
        """训练循环"""
        optimizer = torch.optim.AdamW(self.model.parameters(), lr=lr)
        scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
            optimizer, T_max=num_epochs
        )

        for epoch in range(num_epochs):
            # 训练
            self.model.train()
            train_loss = 0
            for batch in train_loader:
                loss = self.train_step(batch)
                loss.backward()
                optimizer.step()
                optimizer.zero_grad()
                train_loss += loss.item()

            # 验证(用 Sigmoid)
            self.model.eval()
            val_preds = []
            val_labels = []
            for batch in val_loader:
                mel_spec = batch['mel_spec']
                labels = batch['labels']
                probs = self.predict(mel_spec)
                val_preds.append(probs.cpu().numpy())
                val_labels.append(labels.cpu().numpy())

            # 计算验证指标
            val_preds = np.concatenate(val_preds)
            val_labels = np.concatenate(val_labels)
            val_auc = self.compute_auc(val_labels, val_preds)

            print(f"Epoch {epoch}: Train Loss={train_loss/len(train_loader):.4f}, Val AUC={val_auc:.4f}")
            scheduler.step()
```

### Min() Ensemble(BirdCLEF 2024 - 1st Place)

1st Place Team Kefir 的 Min() Ensemble,降低不确定预测:

```python
import numpy as np
import torch

class MinEnsemble:
    """
    Min() Ensemble
    参考:BirdCLEF 2024 1st Place Solution

    核心思想:
    - 使用 min() 而不是 mean() 聚合模型预测
    - 降低不确定预测,提高稳定性
    """

    def __init__(self, models: list[nn.Module]):
        self.models = models

    @torch.no_grad()
    def predict_min(self, mel_spec: torch.Tensor) -> np.ndarray:
        """
        使用 Min() 聚合预测

        Args:
            mel_spec: (B, C, H, W)

        Returns:
            predictions: (B, num_classes), min() 聚合后的概率
        """
        predictions = []

        # 获取所有模型的预测
        for model in self.models:
            model.eval()
            logits = model(mel_spec)
            probs = torch.sigmoid(logits)  # Sigmoid
            predictions.append(probs.cpu().numpy())

        # Stack: (num_models, B, num_classes)
        predictions = np.stack(predictions, axis=0)

        # Min() 聚合
        min_predictions = np.min(predictions, axis=0)

        return min_predictions

    def predict_mean(self, mel_spec: torch.Tensor) -> np.ndarray:
        """传统 Mean() 聚合(对比用)"""
        predictions = []

        for model in self.models:
            model.eval()
            logits = model(mel_spec)
            probs = torch.sigmoid(logits)
            predictions.append(probs.cpu().numpy())

        predictions = np.stack(predictions, axis=0)
        mean_predictions = np.mean(predictions, axis=0)

        return mean_predictions

# 使用示例
# min_ensemble = MinEnsemble([model1, model2, model3, model4, model5])
# predictions = min_ensemble.predict_min(test_mel_spec)
```

### Checkpoint Soup(BirdCLEF 2024 - 2nd Place)

2nd Place ADSR 的 Checkpoint Soup 技巧:

```python
import torch
import torch.nn as nn
from typing import list

class CheckpointSoup:
    """
    Checkpoint Soup
    参考:BirdCLEF 2024 2nd Place Solution

    核心思想:
    - 平均多个 epoch 的 checkpoint 权重
    - 代替 early stopping
    - 通常更稳定
    """

    def __init__(self, model: nn.Module, metrics: list[str] = ['auc', 'lrap', 'f1']):
        self.model = model
        self.metrics = metrics
        self.checkpoints = []  # 存储 (epoch, state_dict, scores)

    def add_checkpoint(self, epoch: int, state_dict: dict, scores: dict):
        """
        添加 checkpoint

        Args:
            epoch: epoch 编号
            state_dict: 模型权重
            scores: 验证指标 {metric_name: score}
        """
        # 检查是否有任意指标改进
        should_save = False
        for metric in self.metrics:
            if epoch == 0:
                should_save = True
                break
            best_score = max([ckpt[2].get(metric, 0) for ckpt in self.checkpoints])
            if scores.get(metric, 0) >= best_score:
                should_save = True
                break

        if should_save:
            self.checkpoints.append((epoch, state_dict.copy(), scores))
            print(f"Checkpoint {epoch} saved: {scores}")

    def make_soup(self) -> dict:
        """
        制作 Checkpoint Soup

        Returns:
            soup_state_dict: 平均后的权重
        """
        if not self.checkpoints:
            raise ValueError("No checkpoints to average")

        # 初始化 soup
        soup_state_dict = self.checkpoints[0][1].copy()

        # 累加所有 checkpoint
        for _, ckpt, _ in self.checkpoints[1:]:
            for key in soup_state_dict.keys():
                if key in ckpt:
                    soup_state_dict[key] += ckpt[key]

        # 平均
        num_checkpoints = len(self.checkpoints)
        for key in soup_state_dict.keys():
            soup_state_dict[key] /= num_checkpoints

        print(f"Soup made from {num_checkpoints} checkpoints (epochs: {[ckpt[0] for ckpt in self.checkpoints]})")
        return soup_state_dict

    def load_soup(self, model: nn.Module):
        """加载 soup 到模型"""
        soup = self.make_soup()
        model.load_state_dict(soup)
        return model

# 使用示例
# checkpoint_soup = CheckpointSoup(model, metrics=['auc', 'lrap', 'f1'])
#
# # 训练循环中
# for epoch in range(num_epochs):
#     train(...)
#     scores = validate(...)
#     checkpoint_soup.add_checkpoint(epoch, model.state_dict(), scores)
#
# # 训练结束后
# final_model = checkpoint_soup.load_soup(model)
```

### 伪标签迭代训练(BirdCLEF 2024 - 2nd Place)

2nd Place ADSR 的伪标签迭代训练循环:

```python
import numpy as np
import torch
from typing import list

class IterativePseudoLabeling:
    """
    伪标签迭代训练
    参考:BirdCLEF 2024 2nd Place Solution

    核心思想:
    - 用当前集成生成伪标签
    - 用伪标签训练新模型
    - 新模型加入集成,重复循环
    """

    def __init__(
        self,
        base_model_class,
        pseudo_label_chance: float = 0.35,
        amp_exp_min: float = -0.5,
        amp_exp_max: float = 0.1,
        num_iterations: int = 3,
    ):
        self.base_model_class = base_model_class
        self.pseudo_label_chance = pseudo_label_chance
        self.amp_exp_min = amp_exp_min
        self.amp_exp_max = amp_exp_max
        self.num_iterations = num_iterations
        self.ensemble_models = []

    def generate_pseudo_labels(
        self,
        unlabeled_audio_paths: list[str],
        unlabeled_soundscapes: list[str]
    ) -> list[dict]:
        """
        生成伪标签

        Args:
            unlabeled_audio_paths: 未标注音频路径
            unlabeled_soundscapes: 未标注 soundscape 路径

        Returns:
            pseudo_samples: [{audio_path, label_vector}, ...]
        """
        pseudo_samples = []

        for audio_path in unlabeled_soundscapes:
            # 用集成模型预测
            predictions = []
            for model in self.ensemble_models:
                pred = self.predict_with_model(model, audio_path)
                predictions.append(pred)

            # 平均预测
            avg_pred = np.mean(predictions, axis=0)
            pseudo_samples.append({
                'audio_path': audio_path,
                'label_vector': avg_pred
            })

        return pseudo_samples

    def mix_pseudo_labels(
        self,
        train_sample: dict,
        pseudo_sample: dict,
    ) -> tuple[torch.Tensor, torch.Tensor]:
        """
        混合训练样本和伪标签样本

        Args:
            train_sample: 训练样本 {audio, label_vector}
            pseudo_sample: 伪标签样本 {audio, label_vector}

        Returns:
            mixed_audio: 混合后的音频
            mixed_label: 混合后的标签
        """
        train_audio = train_sample['audio']
        train_label = train_sample['label_vector']
        pseudo_audio = pseudo_sample['audio']
        pseudo_label = pseudo_sample['label_vector']

        # 随机幅度系数
        amp_factor = 10 ** np.random.uniform(self.amp_exp_min, self.amp_exp_max)

        # 混合音频
        mixed_audio = train_audio * amp_factor + pseudo_audio * amp_factor

        # 混合标签(取 max)
        mixed_label = np.maximum(train_label, pseudo_label)

        return mixed_audio, mixed_label

    def train_with_pseudo_labels(
        self,
        train_data: list[dict],
        pseudo_samples: list[dict],
        num_epochs: int = 50,
    ):
        """使用伪标签训练新模型"""
        model = self.base_model_class()
        optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)
        criterion = torch.nn.BCEWithLogitsLoss()

        for epoch in range(num_epochs):
            for train_sample in train_data:
                # 随机决定是否添加伪标签
                if np.random.random() < self.pseudo_label_chance:
                    # 随机选择一个伪标签样本
                    pseudo_sample = np.random.choice(pseudo_samples)
                    audio, label = self.mix_pseudo_labels(train_sample, pseudo_sample)
                else:
                    audio = train_sample['audio']
                    label = train_sample['label_vector']

                # 训练步骤
                loss = self.train_step(model, audio, label, criterion)
                loss.backward()
                optimizer.step()
                optimizer.zero_grad()

        return model

    def fit(self, train_data, unlabeled_soundscapes):
        """完整的迭代训练循环"""
        for iteration in range(self.num_iterations):
            print(f"\n=== Iteration {iteration + 1}/{self.num_iterations} ===")

            # 生成伪标签
            pseudo_samples = self.generate_pseudo_labels(train_data, unlabeled_soundscapes)
            print(f"Generated {len(pseudo_samples)} pseudo labels")

            # 训练新模型
            new_model = self.train_with_pseudo_labels(train_data, pseudo_samples)
            self.ensemble_models.append(new_model)

            # 评估集成性能
            ensemble_score = self.evaluate_ensemble()
            print(f"Ensemble score: {ensemble_score:.4f}")

        return self.ensemble_models
```

### 音频分类竞赛的最佳实践(BirdCLEF 2024)

**与 BirdCLEF+ 2025 的主要差异:**
| 维度 | BirdCLEF 2024 | BirdCLEF+ 2025 |
|------|---------------|----------------|
| **物种数量** | 182 种鸟类 | 206 种(多分类群) |
| **推理限制** | 120 分钟 CPU | 90 分钟 CPU |
| **数据策略** | 不用外部数据更优 | Xeno-Canto 预训练重要 |
| **关键创新** | Statistics T 过滤 | Noisy Student + 自蒸馏 |
| **损失函数** | CE Loss(训练)+ Sigmoid(推理) | BCE + FocalLoss |

#### BirdCLEF 2024 前排方案共性技术

| 技术 | 使用排名 | 说明 |
|------|---------|------|
| **只用前 5 秒** | 1st, 2nd | 后续信息贡献小,节省计算 |
| **伪标签** | 1st, 2nd, 3rd | 利用未标注 soundscape |
| **Ensemble** | 所有前排 | 5-20 模型集成 |
| **OpenVINO/ONNX** | 1st, 3rd | CPU 推理加速必需 |
| **小模型** | 所有前排 | B0/ViT-b0 级别,控制推理时间 |

#### BirdCLEF 2024 独特技术(与 2025 不同)

**1. Statistics T 噪声过滤(1st Place)**
```python
# T = std + var + rms + pwr
# 使用 0.8 分位数过滤噪声音频
T = std + var + rms + pwr
threshold = np.quantile(T, 0.8)
clean_data = data[T < threshold]
```

**2. CE Loss + Sigmoid 推理(1st Place)**
- 训练:CE Loss + Softmax(多分类问题)
- 推理:Sigmoid(多标签预测)
- 原因:数据大多只有 1-2 个标签,可视为多分类
- **注意**:这与 BirdCLEF+ 2025 不同,2025 使用 BCE + FocalLoss

**3. Min() Ensemble(1st Place)**
```python
# 降低不确定预测,比 mean() 更稳定
predictions = np.min([model1_pred, model2_pred, model3_pred], axis=0)
```

**4. Google Bird Classifier 预标注(1st Place)**
- 使用 Google 模型过滤低质量数据
- 如果预测与 primary label 不匹配,丢弃
- 添加 Google 预测作为伪标签(系数 0.05)

**5. Checkpoint Soup(2nd Place)**
- 平均 13-50 epoch 的 checkpoint
- 代替 early stopping
- 比单 checkpoint 更稳定

**6. 伪标签迭代训练(2nd Place)**
- 3 次迭代循环
- 每次用新集成生成伪标签
- 25-45% 概率添加伪标签数据

#### BirdCLEF 2024 推理优化(120 分钟限制)

**前排方案的优化策略:**

| 技术 | 说明 | 排名 |
|------|------|------|
| **OpenVINO 编译** | 固定输入大小,加速推理 | 1st |
| **并行 Mel 计算** | joblib 并行预处理 | 1st, 2nd |
| **RAM 缓存** | 预计算所有 mel spec 存入内存 | 1st |
| **小图像尺寸** | 64x64, 128x128 等 | 2nd |
| **ONNX 优化** | 5 fold 40 分钟 | 3rd |

#### BirdCLEF 2024 数据处理最佳实践

**数据过滤:**
| 问题 | 解决方案 |
|------|----------|
| **噪声数据** | Statistics T 过滤(0.8 分位数) |
| **低质量标注** | Google Classifier 过滤 |
| **重复数据** | 去重处理 |

**数据增强(2nd Place):**
```python
# 局部和全局时间/频率拉伸
# 通过调整图像大小实现
augmented = resize(mel_spec, (new_height, new_width))
```

#### BirdCLEF 2024 vs 2025:为何策略不同?

| 方面 | BirdCLEF 2024 | BirdCLEF+ 2025 | 原因 |
|------|---------------|----------------|------|
| **外部数据** | 不用更优 | Xeno-Canto 关键 | 2024 数据质量高,2025 需要预训练 |
| **损失函数** | CE Loss | BCE + Focal | 2024 数据大多 1-2 标签,2025 更复杂 |
| **集成策略** | Min() | Mean() | 2024 用 Sigmoid 噪声大,Min 更稳定 |

#### BirdCLEF 2024 常见陷阱

| 陷阱 | 说明 | 解决方案 |
|------|------|----------|
| **使用外部数据** | Xeno-Canto 反而降低分数 | 只用 2024 数据 |
| **BCE Loss** | 比 CE Loss 效果差 | CE Loss + Sigmoid 推理 |
| **Mean Ensemble** | 对 Sigmoid 输出不稳定 | Min() Ensemble |
| **忽略 Statistics T** | fold0 优于其他 fold | 用统计量过滤噪声 |
| **太大模型** | 推理超时 | B0/RegNetY 级别 |

### 音频分类竞赛的最佳实践(BirdCLEF+ 2025)

与通用时间序列分类不同,音频分类(生物声学)有特殊的挑战和技术:

| 方面 | 通用时序分类 | 音频分类(生物声学) |
|------|-------------|---------------------|
| **特征表示** | 原始信号/统计特征 | Mel-Spectrogram(时频表示) |
| **模型架构** | 1D-CNN/RNN/Transformer | SED 模型(2D-CNN + Attention) |
| **数据特点** | 通常标注完整 | 大量未标注数据(半监督学习关键) |
| **类别分布** | 相对均衡 | 极端长尾(稀有物种 <10 样本) |
| **推理约束** | 通常无特殊限制 | 严格时间限制(90分钟CPU) |
| **评估指标** | Accuracy/F1/ MSE | 宏平均 AUC(每个类独立) |

#### BirdCLEF+ 2025 前排方案共性技术

**"银弹" - 所有前排方案共同使用:**

| 技术 | 使用排名 | 说明 |
|------|---------|------|
| **伪标签技术** | 1st-14th | 利用未标注 train_soundscapes 数据 |
| **Mel-Spectrogram** | 1st-14th | 将音频转换为图像表示 |
| **SED 模型架构** | 1st-14th | 帧级 + 片级预测 |
| **模型集成** | 1st-14th | 5-20 个模型集成 |
| **SpecAugment** | 1st-14th | 时间/频率掩码增强 |
| **EfficientNet 系列** | 多数 | tf_efficientnetv2_s/b3/m 作为 backbone |

#### Mel-Spectrogram 配置最佳实践

前排方案使用的配置总结:

| 配置 | n_mels | n_fft | hop_length | 使用场景 |
|------|--------|-------|-------------|----------|
| **标准配置** | 128 | 2048 | 512 | tf_efficientnetv2 系列(最常用) |
| **轻量配置** | 96 | 2048 | 512 | 轻量级模型,推理加速 |
| **高分辨率** | 256 | 4096 | 1024 | 高精度要求 |

**频率范围设置(关键):**
```python
# 鸟类声音频率范围
FMIN = 0.0      # 最低频率(有些方案用 50Hz 过滤低频噪声)
FMAX = 16000.0  # 最高频率(32kHz 采样率的一半)

# 稀有物种可能需要调整
FMIN_RARE = 100.0  # 过滤低频环境噪声
FMAX_RARE = 15000.0  # 避免高频噪声
```

#### 半监督学习最佳实践(伪标签)

**伪标签生成流程(前排方案共识):**

```
阶段 1: 基础模型训练
    └── 使用 train_audio(有标签)训练 SED 模型

阶段 2: 伪标签生成
    ├── 对 train_soundscapes 进行推理
    ├── 应用高低阈值筛选
    │   ├── 高阈值(≥0.7): 正样本
    │   └── 低阈值(≤0.3): 负样本
    └── 幂次变换减少噪声(1st Place 创新)

阶段 3: 混合训练
    ├── 50% train_audio + 50% 伪标签数据
    ├── MixUp 增强混合数据
    └── 迭代 2-3 次
```

**关键参数(前排方案范围):**
| 参数 | 范围 | 推荐值 | 说明 |
|------|------|--------|------|
| **高阈值** | 0.6-0.8 | 0.7 | 正样本置信度阈值 |
| **低阈值** | 0.2-0.4 | 0.3 | 负样本置信度阈值 |
| **幂次变换** | 1.2-2.0 | 1.5 | 减少伪标签噪声 |
| **混合比例** | 30%-50% | 50% | 伪标签数据占比 |

**伪标签质量检查(10th Place 方法):**
```python
# 高低阈值筛选
high_threshold = 0.7
low_threshold = 0.3

# 正样本:高置信度
positive_mask = probs >= high_threshold

# 负样本:低置信度
negative_mask = probs <= low_threshold

# 中等置信度:不使用(可能是噪声)
uncertain_mask = (probs > low_threshold) & (probs < high_threshold)

# 只使用正负样本
valid_mask = positive_mask | negative_mask
```

#### 推理优化最佳实践(90 分钟约束)

BirdCLEF+ 2025 最关键的约束是 90 分钟 CPU 推理限制。前排方案的优化策略:

**模型优化:**
| 技术 | 使用排名 | 加速比 | 说明 |
|------|---------|--------|------|
| **ONNX 导出** | 3rd, 12th, 14th | 2-3x | 标准化推理格式 |
| **OpenVINO** | 12th | 3-5x | Intel 优化,CPU 最优 |
| **模型量化** | 部分方案 | 1.5-2x | INT8 量化(可能损失精度) |
| **Batch 推理** | 所有方案 | 2-4x | 批量推理提高利用率 |

**Mel-Spectrogram 预计算:**
```python
# 推理阶段预先计算所有 mel-spectrogram
# 避免 GPU-CPU 数据传输开销

def precompute_mel_spectrograms(audio_files, cache_dir="cache/mel"):
    """预计算并缓存 mel-spectrogram"""
    os.makedirs(cache_dir, exist_ok=True)

    for audio_file in tqdm(audio_files):
        cache_path = os.path.join(cache_dir, f"{Path(audio_file).stem}.npy")

        if not os.path.exists(cache_path):
            # 计算 mel-spectrogram
            waveform, sr = torchaudio.load(audio_file)
            mel_spec = extract_mel_spectrogram(waveform, sr)

            # 缓存
            np.save(cache_path, mel_spec.numpy())
```

**滑动窗口优化(1st Place 创新):**
```python
# 使用相邻窗口预测的平均值
# 避免重复计算,提高推理效率

def sliding_window_inference_optimized(model, audio_path):
    """优化的滑动窗口推理"""
    waveform, sr = torchaudio.load(audio_path)

    # 一次性提取所有窗口的 mel-spectrogram
    # 避免重复计算
    all_windows = extract_all_windows(waveform, sr)

    # Batch 推理
    with torch.no_grad():
        predictions = model(all_windows)  # (num_windows, num_classes)

    # 相邻窗口平均(1st Place 创新)
    smoothed_predictions = smooth_adjacent_windows(predictions)

    return smoothed_predictions
```

**前后处理优化:**
| 技术 | 说明 |
|------|------|
| **NumPy 向量化** | 避免循环,使用 NumPy 内置函数 |
| **多进程推理** | 并行处理多个音频文件 |
| **结果缓存** | 避免重复计算 |
| **精简后处理** | 简单平滑即可,避免复杂操作 |

#### 长尾分布处理最佳实践

BirdCLEF+ 2025 数据集存在极端长尾分布(某些物种 <10 样本):

**前排方案的处理策略:**

| 策略 | 使用排名 | 说明 |
|------|---------|------|
| **过采样** | 多数 | 复制稀有类样本至 20-50 |
| **损失加权** | 部分方案 | 稀有类更高权重 |
| **Focal Loss** | 9th Place | 自动处理难样本 |
| **分开训练** | 7th, 13th | 稀有类单独训练模型 |
| **数据增强** | 所有方案 | MixUp/SpecAugment 增加多样性 |

**稀有物种模型训练(13th Place 策略):**
```python
# 识别稀有物种(样本数 < 30)
rare_species = [species for species in all_species
                if get_sample_count(species) < 30]

# 训练稀有物种专用模型
rare_model = create_model(num_classes=len(rare_species))
rare_model.train_on(rare_species_data)

# 集成时加入稀有模型预测
final_prediction = 0.7 * general_model + 0.3 * rare_model
```

#### 模型集成最佳实践

前排方案的集成策略总结:

**集成规模:**
| 排名 | 模型数量 | 架构多样性 | 说明 |
|------|---------|-----------|------|
| **1st** | ~10 | 多迭代 Noisy Student | 同一模型不同迭代 |
| **2nd** | ~5-8 | 不同 backbone | tf_efficientnetv2_s + eca_nfnet_l0 |
| **3rd** | 20 | 10 CNN + 10 SED | 最大规模集成 |
| **5th** | ~5-10 | EfficientNet 系列 | 自蒸馏不同阶段 |

**集成方法:**
```python
# 简单平均(最常用)
predictions = np.mean([model1_pred, model2_pred, model3_pred], axis=0)

# 加权平均(需要验证集调优)
weights = [0.3, 0.3, 0.4]
predictions = np.average([model1_pred, model2_pred, model3_pred],
                         axis=0, weights=weights)

# Min-max 缩放后平均(7th Place)
for i in range(len(predictions)):
    pred_min = predictions[i].min()
    pred_max = predictions[i].max()
    predictions[i] = (predictions[i] - pred_min) / (pred_max - pred_min)

predictions = np.mean(predictions, axis=0)
```

**集成多样性(关键):**
| 维度 | 多样性来源 | 说明 |
|------|-----------|------|
| **架构** | 不同 backbone | EfficientNetV2 vs NFNet |
| **数据** | 不同训练数据 | 原始 vs 伪标签 vs Xeno-Canto |
| **阶段** | 不同训练阶段 | Checkpoint Soups (12th Place) |
| **配置** | 不同 mel 参数 | n_mels=128 vs 96 |
| **随机性** | 不同随机种子 | 数据增强和初始化差异 |

#### 常见陷阱和注意事项

基于前排方案经验:

| 陷阱 | 说明 | 解决方案 |
|------|------|---------|
| **过拟合验证集** | LB 和 CV 分数差距大 | 更保守的集成,减少后处理 |
| **伪标签噪声累积** | 多次迭代后性能下降 | 幂次变换 + 高低阈值筛选 |
| **稀有物种检测失败** | 长尾类预测全为 0 | 单独训练稀有模型 + Focal Loss |
| **推理超时** | 90 分钟不够 | ONNX/OpenVINO + Batch 推理 |
| **人声干扰** | 背景人声导致误检 | Silero VAD 去除人声片段 |
| **测试集分布偏移** | 训练/测试环境差异 | 领域适应技术(13th Place) |

---

---

## Google Brain - Ventilator Pressure Prediction (2021)

### Competition Brief (竞赛简介)

**竞赛背景:**
- **主办方**:Google Brain
- **目标**:预测机械呼吸机气道压力(时序回归任务)
- **应用场景**:自动化机械通气控制,辅助重症监护治疗
- **社会意义**:减少医护人员手动调整呼吸机的工作量,提高治疗精度

**任务描述:**
从呼吸机的控制信号和肺部属性中,预测气道压力:
- **输入**:时间序列控制信号(u_in, u_out)+ 肺部属性(R, C)
- **输出**:每个时间步的气道压力(连续值)
- **约束**:测试集中 66% 的数据由 PID 控制器生成

**数据集规模:**
- 训练样本:6,036,000 条时间步
- 测试样本:4,024,000 条时间步
- 呼吸次数:约 75,450 次呼吸(训练)+ 40,240 次呼吸(测试)
- 患者数量:数千个不同患者的肺部特征

**数据特点:**
1. **PID 控制模式**:测试集中 2/3 的数据遵循 PID 控制规律
2. **双重输入**:控制信号(u_in 连续,u_out 二值)+ 肺部属性(R 电阻,C 顺应性)
3. **时间步长**:80 步/次呼吸,不同患者呼吸模式不同
4. **物理约束**:压力变化需遵循呼吸力学规律

**评估指标:**
- **MAE (Mean Absolute Error)**:平均绝对误差
- 目标:最小化预测压力与真实压力的绝对差异

**竞赛约束:**
- 代码提交:Kaggle Notebooks 环境
- 推理时间:无严格限制,但需考虑实用性
- 模型大小:需平衡精度和推理速度

**最终排名:**
- 1st Place: group16 (Gilles Vandewiele et al.) - MAE ~0.104
- 2nd Place: ambrosm - MAE ~0.105
- 3rd Place: Upstage - MAE ~0.106
- 总参赛队伍:2,605 支

**技术趋势:**
- **PID 逆向建模**:前排方案的核心创新
- **多任务学习**:同时预测压力和压力变化
- **LSTM/Transformer 混合**:结合时序建模和注意力机制
- **集成策略**:3-10 个模型集成

**关键创新:**
- **PID Controller Matching**:利用 PID 控制规律直接拟合(1st, 2nd, 4th Place)
- **Delta Pressure 辅助任务**:预测压力差提升主任务(6th, 14th, 20th Place)
- **物理约束嵌入**:将呼吸力学知识融入模型(3rd Place)

**后续影响:**
- 推动了医疗时序预测的发展
- PID 逆向建模成为经典技巧
- 多篇研究论文引用该比赛方法

---

### Original Summaries (原始总结)

**前排方案概述:**

1. **PID 控制器逆向流派(1st, 2nd, 4th Place)**
   - 利用测试集中 66% 数据遵循 PID 控制的规律
   - 通过逆向 PID 公式直接预测压力
   - 无需深度学习即可获得极好结果

2. **深度学习流派(3rd, 6th, 14th Place)**
   - 使用 LSTM/Transformer 建模时序依赖
   - 多任务学习预测压力和压力差
   - 不依赖 PID 规律,更通用

3. **混合流派(16th, 20th Place)**
   - 结合 PID 匹配和深度学习
   - 使用辅助任务提升性能
   - 中间排名的务实策略

---

### 前排方案详细技术分析

#### 1st Place - group16 (Gilles Vandewiele et al.)

**核心技巧:**
- **PID Controller Matching**:核心创新,拟合测试集 PID 控制规律
- **LSTM + CNN + Transformer 混合架构**:深度学习部分
- **两阶段预测**:先用 PID 匹配 66% 数据,再用 DL 预测剩余 34%
- **模型集成**:多个模型组合提升稳定性

**实现细节:**
- **PID 逆向公式**:
  - 从 u_in 信号逆向推导目标压力
  - 拟合 PID 参数:Kp, Ki, Kd
  - 对于 PID 控制的呼吸,MAE 可达到 0.05-0.08

- **深度学习模型**:
  ```python
  # LSTM + CNN + Transformer 混合架构
  class VentilatorModel(nn.Module):
      def __init__(self):
          self.cnn = CNN1D(input_dim=5)  # u_in, u_out, R, C, time_step
          self.lstm = LSTM(hidden_dim=256, num_layers=2)
          self.transformer = TransformerEncoder(num_layers=2, nhead=8)
          self.fc = Linear(256, 1)  # 预测压力

      def forward(self, x):
          # CNN 提取局部特征
          x = self.cnn(x)
          # LSTM 建模时序依赖
          x = self.lstm(x)
          # Transformer 捕获长距离依赖
          x = self.transformer(x)
          # 预测压力
          return self.fc(x)
  ```

- **两阶段策略**:
  1. 识别测试集中哪些呼吸由 PID 控制(约 66%)
  2. 对 PID 呼吸使用逆向公式
  3. 对非 PID 呼吸使用深度学习模型
  4. 最终集成两种预测

- **特征工程**:
  - 原始特征:u_in, u_out, R, C, time_step
  - 衍生特征:u_in 的累积和、差分、滚动统计
  - 位置编码:sin/cos 位置嵌入
  - 肺部属性编码:R 和 C 的 embedding

- **训练策略**:
  - 损失函数:MAE + delta_pressure_MAE(多任务)
  - 优化器:AdamW (lr=1e-3, weight_decay=0.01)
  - 学习率调度:CosineAnnealingWarmRestarts
  - 早停:CV 15 epochs 无改善则停止

- **最终 MAE**:约 0.104

**代码仓库**:[GillesVandewiele/google-brain-ventilator](https://github.com/GillesVandewiele/google-brain-ventilator)

---

#### 2nd Place - ambrosm

**核心技巧:**
- **The Inverse of a PID Controller**:纯粹的 PID 逆向方法
- **无需深度学习**:完全基于物理规律
- **数学拟合**:优化 PID 参数最小化误差

**实现细节:**
- **PID 逆向公式**:
  ```python
  def pid_inverse(u_in, u_out, R, C):
      """
      PID 控制器的逆向函数
      从控制信号 u_in 推导目标压力

      PID 公式:u_in = Kp * e + Ki * ∫e dt + Kd * de/dt
      逆向:从 u_in 拟合目标压力
      """
      # 对每个呼吸单独拟合
      pressures = []

      for breath_id in unique_breaths:
          u_in_breath = u_in[breath_id]
          u_out_breath = u_out[breath_id]

          # 拟合 PID 参数
          # 目标:最小化 u_in_pred - u_in_actual
          Kp, Ki, Kd = fit_pid_parameters(u_in_breath, u_out_breath)

          # 逆向计算压力
          pressure = inverse_pid(u_in_breath, Kp, Ki, Kd, R, C)
          pressures.append(pressure)

      return pressures
  ```

- **参数优化**:
  - 使用 Scipy.optimize.minimize 优化 PID 参数
  - 约束:Kp, Ki, Kd > 0
  - 损失:MSE between u_in_pred 和 u_in_actual

- **最终 MAE**:约 0.105

**技术特点**:
- 最简洁的前排方案
- 无需训练模型
- 推理速度极快
- 但仅适用于 PID 控制的呼吸

**Writeup**:[Kaggle Writeup](https://www.kaggle.com/competitions/ventilator-pressure-prediction/writeups/ambrosm-2-solution-the-inverse-of-a-pid-controller)

---

#### 3rd Place - Upstage

**核心技巧:**
- **Single Model without PID**:唯一不使用 PID 的前排方案
- **多任务损失**:同时预测压力和压力变化
- **数据增强**:时间扭曲、幅值缩放
- **物理约束损失**:加入呼吸力学先验

**实现细节:**
- **模型架构**:
  ```python
  class UpstageModel(nn.Module):
      def __init__(self):
          self.embedding = Embedding(num_r_values * num_c_values, 64)
          self.lstm1 = LSTM(input_dim=64+3, hidden_dim=256, num_layers=2, bidirectional=True)
          self.lstm2 = LSTM(input_dim=512, hidden_dim=128, num_layers=1)
          self.fc_pressure = Linear(128, 1)
          self.fc_delta = Linear(128, 1)  # 辅助任务

      def forward(self, u_in, u_out, R, C):
          # 肺部属性嵌入
          rc_embed = self.embedding(R * 100 + C)

          # 拼接输入
          x = torch.cat([u_in, u_out, rc_embed], dim=-1)

          # LSTM 建模
          x = self.lstm1(x)
          x = self.lstm2(x)

          # 多任务预测
          pressure = self.fc_pressure(x)
          delta = self.fc_delta(x)

          return pressure, delta
  ```

- **多任务损失**:
  ```python
  def loss_function(pressure_pred, delta_pred, pressure_true):
      # 主任务:压力预测
      loss_pressure = F.l1_loss(pressure_pred, pressure_true)

      # 辅助任务:压力差预测
      delta_true = pressure_true[:, 1:] - pressure_true[:, :-1]
      loss_delta = F.l1_loss(delta_pred[:, :-1], delta_true)

      # 加权组合
      return loss_pressure + 0.3 * loss_delta
  ```

- **数据增强**:
  - 时间扭曲:随机拉伸/压缩时间轴
  - 幅值缩放:u_in 乘以 0.8-1.2 随机因子
  - 噪声注入:加入高斯噪声

- **物理约束**:
  - 压力变化率约束:|dP/dt| < threshold
  - 压力范围约束:0 < P < 60 cmH2O

- **最终 MAE**:0.0975(不含 PID 后处理)

**技术特点**:
- 最通用的前排方案
- 不依赖 PID 规律
- 可应用于新数据分布

**Writeup**:[Kaggle Writeup](https://www.kaggle.com/competitions/ventilator-pressure-prediction/writeups/upstage-making-ai-beneficial-3rd-place-single-mode)

---

#### 4th Place - Jun Koda

**核心技巧:**
- **Hacking the PID Control**:深入分析 PID 控制规律
- **线性关系发现**:u_in 与目标压力线性相关
- **分段处理**:对不同阶段使用不同策略

**实现细节:**
- **核心发现**:
  ```python
  # 吸气阶段(u_out = 0)
  # u_in 与目标 pressure 呈线性关系
  u_in = α * pressure_target + β

  # 呼气阶段(u_out = 1)
  # 压力按指数衰减
  pressure = pressure_peak * exp(-t / τ)

  # 其中 τ = R * C(时间常数)
  ```

- **逆向求解**:
  ```python
  def predict_pressure(u_in, u_out, R, C):
      pressures = []

      for t in range(len(u_in)):
          if u_out[t] == 0:  # 吸气
              # 线性关系
              pressure[t] = (u_in[t] - β) / α
          else:  # 呼气
              # 指数衰减
              pressure[t] = pressure_peak * exp(-t / (R * C))

      return pressures
  ```

- **参数拟合**:
  - α, β 通过线性回归拟合
  - τ 通过非线性优化拟合
  - 不同 R, C 组合使用不同参数

- **最终 MAE**:约 0.106

**技术特点**:
- 深入理解 PID 控制原理
- 利用物理规律简化问题
- 计算效率极高

**Writeup**:[Kaggle Writeup](https://www.kaggle.com/competitions/ventilator-pressure-prediction/writeups/jun-koda-4th-place-solution-hacking-the-pid-contro)

---

#### 6th Place - 0-0ggg

**核心技巧:**
- **Single Multi-task LSTM**:单模型多任务学习
- **Delta Pressure 预测**:辅助任务提升主任务
- **特征工程**:丰富的时序特征

**实现细节:**
- **模型架构**:
  ```python
  class MultiTaskLSTM(nn.Module):
      def __init__(self, input_dim=5, hidden_dim=128):
          super().__init__()
          self.lstm = LSTM(input_dim, hidden_dim, num_layers=2, dropout=0.2)
          self.fc_pressure = Linear(hidden_dim, 1)
          self.fc_delta = Linear(hidden_dim, 1)

      def forward(self, x):
          # LSTM 编码
          x, _ = self.lstm(x)

          # 多任务预测
          pressure = self.fc_pressure(x)
          delta = self.fc_delta(x)

          return pressure, delta
  ```

- **特征工程**:
  - 原始特征:u_in, u_out, R, C
  - 时序特征:u_in 的 lag-1, lag-2, lag-3
  - 统计特征:rolling mean, rolling std
  - 交互特征:u_in * R, u_in * C
  - 时间特征:sin/cos 时间编码

- **多任务训练**:
  ```python
  def train_step(model, batch):
      pressure_pred, delta_pred = model(batch)

      # 主任务损失
      loss_pressure = mae_loss(pressure_pred, batch.pressure)

      # 辅助任务损失
      delta_true = batch.pressure[:, 1:] - batch.pressure[:, :-1]
      loss_delta = mae_loss(delta_pred[:, :-1], delta_true)

      # 总损失
      loss = loss_pressure + 0.2 * loss_delta
      return loss
  ```

- **最终 MAE**:约 0.108

**技术特点**:
- 简洁有效的架构
- 多任务学习提升性能
- CV/LB 一致性好

**Writeup**:[Kaggle Writeup](https://www.kaggle.com/competitions/ventilator-pressure-prediction/writeups/0-0ggg-6th-place-solution-single-multi-task-lstm)

---

#### 14th Place - pksha (Team "no pressure")

**核心技巧:**
- **Multitask LSTM**:同时预测压力和压力变化
- **Delta Pressure 辅助任务**:关键创新
- **集成策略**:多模型融合

**实现细节:**
- **多任务设计**:
  ```python
  class MultitaskLSTM(nn.Module):
      def __init__(self):
          self.lstm = LSTM(input_dim=6, hidden_dim=128, num_layers=2, bidirectional=True)
          self.fc1 = Linear(256, 64)
          self.fc_pressure = Linear(64, 1)
          self.fc_delta = Linear(64, 1)

      def forward(self, x):
          x, _ = self.lstm(x)
          x = F.relu(self.fc1(x))
          pressure = self.fc_pressure(x)
          delta = self.fc_delta(x)
          return pressure, delta
  ```

- **辅助任务价值**:
  - 预测 delta pressure:P[t] - P[t-1]
  - 帮助模型学习压力变化趋势
  - CV/LB 提升 +0.01 ~ +0.015

- **最终 MAE**:约 0.112

**Writeup**:[Kaggle Writeup](https://www.kaggle.com/competitions/ventilator-pressure-prediction/writeups/pksha-no-pressure-14th-place-solution-multitask-ls)

---

#### 16th Place - player2-has-flatlined

**核心技巧:**
- **Journey Writeup**:详细的开发历程
- **渐进优化**:从 baseline 到最终方案
- **务实策略**:平衡效果和复杂度

**实现细节:**
- **开发历程**:
  1. Baseline LSTM:MAE ~0.15
  2. 加入特征工程:MAE ~0.13
  3. 多任务学习:MAE ~0.115
  4. 模型集成:MAE ~0.113

- **关键改进**:
  - 丰富特征工程
  - 多任务学习(delta pressure)
  - 交叉验证策略优化
  - 简单平均集成

- **最终 MAE**:约 0.113

**Writeup**:[Kaggle Writeup](https://www.kaggle.com/competitions/ventilator-pressure-prediction/writeups/player2-has-flatlined-16th-place-journey-writeup-n)

---

#### 20th Place - hyeongchan-nikita / kozistr

**核心技巧:**
- **Model & Multi-task Learning**:深度学习 + 多任务
- **Delta Pressure Auxiliary Loss**:核心技术
- **Top 1% 铜牌边界**:进入前 1% 的方案

**实现细节(kozistr):**
- **多任务损失**:
  ```python
  def multi_task_loss(pressure_pred, delta_pred, pressure_true):
      # 主任务
      loss_pressure = F.l1_loss(pressure_pred, pressure_true)

      # 辅助任务:delta pressure
      delta_true = torch.diff(pressure_true, dim=1)
      loss_delta = F.l1_loss(delta_pred[:, :-1], delta_true)

      return loss_pressure + 0.15 * loss_delta
  ```

- **模型架构**:
  - LSTM(2 层,128 隐藏单元)
  - 特征:u_in, u_out, R, C + 统计特征
  - Dropout:0.3

- **最终 MAE**:约 0.116(Top 1% 边界)

**技术特点**:
- 最简单的前排方案之一
- 证明了多任务学习的有效性
- CV/LB 提升 +0.01 ~ +0.015

**参考文章**:[Blog Post](https://kozistr.tech/2021-11-03-ventilator-pressure-prediction/)

**Writeup**:[Kaggle Writeup](https://www.kaggle.com/competitions/ventilator-pressure-prediction/writeups/hyeongchan-nikita-20th-place-solution-model-multi-)

---

### Code Templates (代码模板)

#### PID Controller Matching (1st Place 核心技巧)

```python
import numpy as np
from scipy.optimize import minimize

def fit_pid_parameters(u_in, u_out, initial_pressure=0):
    """
    拟合 PID 控制器参数

    Args:
        u_in: 控制信号 (array)
        u_out: 吸气/呼气标志 (array)
        initial_pressure: 初始压力

    Returns:
        Kp, Ki, Kd: PID 参数
    """

    def pid_loss(params, u_in, u_out):
        Kp, Ki, Kd = params

        # 模拟 PID 控制器
        pressure_pred = simulate_pid(u_in, u_out, Kp, Ki, Kd, initial_pressure)

        # 计算误差(逆向:从 u_in 预测 pressure 的误差)
        error = np.mean((u_in - target_from_pressure(pressure_pred)) ** 2)
        return error

    # 初始参数
    x0 = [1.0, 0.1, 0.5]

    # 约束:参数必须为正
    bounds = [(0, None), (0, None), (0, None)]

    # 优化
    result = minimize(pid_loss, x0, args=(u_in, u_out), bounds=bounds)

    return result.x

def simulate_pid(u_in, u_out, Kp, Ki, Kd, initial_pressure):
    """
    PID 控制器模拟

    Args:
        u_in: 控制信号
        u_out: 吸气/呼气标志
        Kp, Ki, Kd: PID 参数
        initial_pressure: 初始压力

    Returns:
        pressure: 预测的压力序列
    """
    n_steps = len(u_in)
    pressure = np.zeros(n_steps)
    pressure[0] = initial_pressure

    integral = 0
    prev_error = 0

    for t in range(1, n_steps):
        # 设定值(目标压力)
        setpoint = pressure[t-1]  # 维持当前压力

        # 过程变量(当前压力)
        pv = pressure[t-1]

        # 误差
        error = setpoint - pv

        # 积分项
        integral += error

        # 微分项
        derivative = error - prev_error
        prev_error = error

        # PID 输出
        output = Kp * error + Ki * integral + Kd * derivative

        # 肺部响应(一阶系统)
        # dP/dt = (u_in - P) / (R * C)
        R, C = get_rc_params(t)  # 获取 R, C 参数
        tau = R * C  # 时间常数

        pressure[t] = pressure[t-1] + (output - pressure[t-1]) / tau

        # 呼气阶段处理
        if u_out[t] == 1:
            pressure[t] = pressure[t] * 0.9  # 衰减

    return pressure

def predict_pressure_pid(u_in, u_out, R, C):
    """
    使用 PID 逆向方法预测压力

    Args:
        u_in: 控制信号
        u_out: 吸气/呼气标志
        R: 肺部电阻
        C: 肺部顺应性

    Returns:
        pressure: 预测压力
    """
    # 按呼吸分组
    breath_ids = get_breath_ids(u_out)

    pressures = []

    for breath_id in breath_ids:
        u_in_breath = u_in[breath_id]
        u_out_breath = u_out[breath_id]

        # 拟合 PID 参数
        Kp, Ki, Kd = fit_pid_parameters(u_in_breath, u_out_breath)

        # 逆向预测压力
        pressure_breath = inverse_pid(u_in_breath, u_out_breath, Kp, Ki, Kd, R, C)
        pressures.extend(pressure_breath)

    return np.array(pressures)

def inverse_pid(u_in, u_out, Kp, Ki, Kd, R, C):
    """
    PID 逆向:从 u_in 推导压力

    简化版本:假设比例控制主导
    u_in ≈ Kp * (target - current)
    => target ≈ u_in / Kp + current
    """
    n_steps = len(u_in)
    pressure = np.zeros(n_steps)

    pressure[0] = 5  # 初始压力

    for t in range(1, n_steps):
        if u_out[t] == 0:  # 吸气
            # 比例控制
            pressure[t] = pressure[t-1] + u_in[t] / Kp
        else:  # 呼气
            # 指数衰减
            tau = R * C
            pressure[t] = pressure[t-1] * np.exp(-1 / tau)

    return pressure
```

#### Multi-task LSTM (6th, 14th, 20th Place 技巧)

```python
import torch
import torch.nn as nn

class MultiTaskVentilatorLSTM(nn.Module):
    """多任务 LSTM 模型"""

    def __init__(self, input_dim=5, hidden_dim=128, num_layers=2, dropout=0.2):
        super().__init__()

        # LSTM 层
        self.lstm = nn.LSTM(
            input_size=input_dim,
            hidden_size=hidden_dim,
            num_layers=num_layers,
            dropout=dropout,
            batch_first=True,
            bidirectional=True
        )

        # 全连接层
        self.fc1 = nn.Linear(hidden_dim * 2, 64)
        self.dropout = nn.Dropout(dropout)

        # 多任务输出
        self.fc_pressure = nn.Linear(64, 1)  # 主任务:压力预测
        self.fc_delta = nn.Linear(64, 1)      # 辅助任务:压力差预测

    def forward(self, x):
        # LSTM 编码
        lstm_out, _ = self.lstm(x)  # (batch, seq, hidden*2)

        # 全连接
        out = F.relu(self.fc1(lstm_out))
        out = self.dropout(out)

        # 多任务预测
        pressure = self.fc_pressure(out).squeeze(-1)  # (batch, seq)
        delta = self.fc_delta(out).squeeze(-1)        # (batch, seq)

        return pressure, delta

def multi_task_loss(pressure_pred, delta_pred, pressure_true, delta_weight=0.2):
    """
    多任务损失函数

    Args:
        pressure_pred: 压力预测 (batch, seq)
        delta_pred: 压力差预测 (batch, seq)
        pressure_true: 真实压力 (batch, seq)
        delta_weight: 辅助任务权重

    Returns:
        total_loss: 总损失
    """
    # 主任务:压力预测 MAE
    loss_pressure = F.l1_loss(pressure_pred, pressure_true)

    # 辅助任务:压力差预测 MAE
    # 计算真实压力差
    delta_true = pressure_true[:, 1:] - pressure_true[:, :-1]
    delta_pred_trimmed = delta_pred[:, 1:]

    loss_delta = F.l1_loss(delta_pred_trimmed, delta_true)

    # 加权组合
    total_loss = loss_pressure + delta_weight * loss_delta

    return total_loss

# 训练循环
def train_model(model, train_loader, val_loader, num_epochs=30, lr=1e-3):
    optimizer = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=0.01)
    scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(
        optimizer, T_0=10, T_mult=2
    )

    best_val_loss = float('inf')
    patience = 5
    patience_counter = 0

    for epoch in range(num_epochs):
        # 训练
        model.train()
        train_loss = 0

        for batch in train_loader:
            x = batch['features']  # (batch, seq, 5)
            y = batch['pressure']  # (batch, seq)

            optimizer.zero_grad()

            # 前向传播
            pressure_pred, delta_pred = model(x)

            # 计算损失
            loss = multi_task_loss(pressure_pred, delta_pred, y)

            # 反向传播
            loss.backward()
            optimizer.step()

            train_loss += loss.item()

        # 验证
        model.eval()
        val_loss = 0

        with torch.no_grad():
            for batch in val_loader:
                x = batch['features']
                y = batch['pressure']

                pressure_pred, delta_pred = model(x)
                loss = multi_task_loss(pressure_pred, delta_pred, y)
                val_loss += loss.item()

        # 学习率调度
        scheduler.step()

        # 早停
        if val_loss < best_val_loss:
            best_val_loss = val_loss
            patience_counter = 0
            # 保存最佳模型
            torch.save(model.state_dict(), 'best_model.pth')
        else:
            patience_counter += 1
            if patience_counter >= patience:
                print(f'Early stopping at epoch {epoch}')
                break

        print(f'Epoch {epoch}: Train Loss={train_loss/len(train_loader):.4f}, '
              f'Val Loss={val_loss/len(val_loader):.4f}')

    # 加载最佳模型
    model.load_state_dict(torch.load('best_model.pth'))
    return model
```

#### 特征工程模板

```python
import numpy as np
import pandas as pd

def create_features(df):
    """
    创建时序特征

    Args:
        df: 原始数据,包含列:
            - u_in: 控制信号
            - u_out: 吸气/呼气标志
            - R: 肺部电阻
            - C: 肺部顺应性
            - breath_id: 呼吸ID

    Returns:
        features: 特征 DataFrame
    """
    df = df.copy()

    # 1. 基础特征
    features = df[['u_in', 'u_out', 'R', 'C']].copy()

    # 2. 时序特征:滞后
    for lag in [1, 2, 3]:
        features[f'u_in_lag{lag}'] = df['u_in'].shift(lag)

    # 3. 时序特征:差分
    features['u_in_diff1'] = df['u_in'].diff()
    features['u_in_diff2'] = df['u_in'].diff(2)

    # 4. 统计特征:滚动窗口
    for window in [5, 10]:
        features[f'u_in_rolling_mean_{window}'] = df['u_in'].rolling(window).mean()
        features[f'u_in_rolling_std_{window}'] = df['u_in'].rolling(window).std()
        features[f'u_in_rolling_max_{window}'] = df['u_in'].rolling(window).max()
        features[f'u_in_rolling_min_{window}'] = df['u_in'].rolling(window).min()

    # 5. 累积特征
    features['u_in_cumsum'] = df['u_in'].cumsum()
    features['u_in_cummax'] = df['u_in'].cummax()

    # 6. 交互特征
    features['u_in_R'] = df['u_in'] * df['R']
    features['u_in_C'] = df['u_in'] * df['C']
    features['R_C'] = df['R'] * df['C']  # 时间常数

    # 7. 时间特征(位置编码)
    features['time_step'] = np.arange(len(df))
    features['time_sin'] = np.sin(2 * np.pi * features['time_step'] / 80)
    features['time_cos'] = np.cos(2 * np.pi * features['time_step'] / 80)

    # 8. 呼吸级别特征
    breath_groups = df.groupby('breath_id')

    features['u_in_breath_mean'] = breath_groups['u_in'].transform('mean')
    features['u_in_breath_max'] = breath_groups['u_in'].transform('max')
    features['u_in_breath_std'] = breath_groups['u_in'].transform('std')

    # 9. 阶段特征
    features['u_out_lag1'] = df['u_out'].shift(1)
    features['inhale_start'] = (features['u_out_lag1'] == 1) & (df['u_out'] == 0)
    features['exhale_start'] = (features['u_out_lag1'] == 0) & (df['u_out'] == 1)

    # 10. 填充缺失值
    features = features.fillna(method='bfill').fillna(0)

    return features

# 使用示例
# df = pd.read_csv('train.csv')
# features = create_features(df)
# print(features.shape)
```

---

### Best Practices (最佳实践)

#### PID 控制器逆向策略

**适用场景:**
- 测试集存在已知控制规律(如 PID)
- 控制信号与目标存在可逆向的关系

**实现步骤:**
1. **分析控制规律**:
   - 绘制 u_in 与 pressure 的关系图
   - 识别线性/非线性关系
   - 分析不同阶段(吸气/呼气)的规律

2. **拟合逆向函数**:
   - 使用优化方法拟合参数
   - 添加物理约束(如参数 > 0)
   - 分组拟合(不同 R, C 组合)

3. **混合策略**:
   - 对 PID 控制样本使用逆向方法
   - 对非 PID 样本使用深度学习
   - 加权融合两种预测

**注意事项:**
| 问题 | 解决方案 |
|------|---------|
| 非线性关系 | 分段线性或使用非线性优化 |
| 参数不稳定 | 正则化或参数约束 |
| 部分样本不符合 PID | 使用残差模型校正 |

#### 多任务学习策略

**辅助任务选择:**
- **Delta Pressure**:预测 P[t] - P[t-1](最常用)
- **压力分类**:同时预测压力范围(辅助回归)
- **阶段预测**:预测吸气/呼气阶段(多任务)

**损失权重调优:**
```python
# 网格搜索最佳权重
for delta_weight in [0.1, 0.15, 0.2, 0.25, 0.3]:
    loss = multi_task_loss(pressure_pred, delta_pred, pressure_true, delta_weight)
    # 验证集评估
    val_mae = evaluate(val_loader, delta_weight)
    print(f'delta_weight={delta_weight}: val_mae={val_mae:.4f}')
```

**最佳实践:**
| 技巧 | 说明 |
|------|------|
| 渐进式训练 | 先训练主任务,再加入辅助任务 |
| 权重衰减 | 逐渐降低辅助任务权重 |
| 多个辅助任务 | 可组合多个辅助任务 |
| 早停基于主任务 | 验证集只看主任务性能 |

#### 交叉验证策略

**Group K-Fold:**
```python
from sklearn.model_selection import GroupKFold

# 确保同一 breath 的样本不分散
gkf = GroupKFold(n_splits=5)

for fold, (train_idx, val_idx) in enumerate(gkf.split(X, y, groups=df['breath_id'])):
    print(f'Fold {fold}: Train={len(train_idx)}, Val={len(val_idx)}')

    X_train, X_val = X[train_idx], X[val_idx]
    y_train, y_val = y[train_idx], y[val_idx]

    # 训练模型
    model = train_model(X_train, y_train)
```

**时间序列分割:**
```python
from sklearn.model_selection import TimeSeriesSplit

# 按时间顺序分割
tscv = TimeSeriesSplit(n_splits=5)

for fold, (train_idx, val_idx) in enumerate(tscv.split(X)):
    # 训练集在验证集之前
    X_train, X_val = X[train_idx], X[val_idx]
    y_train, y_val = y[train_idx], y[val_idx]
```

#### 模型集成策略

**集成方法:**
| 方法 | 使用排名 | 说明 |
|------|---------|------|
| **简单平均** | 所有排名 | 最常用,稳定可靠 |
| **加权平均** | 部分排名 | 需要验证集调优权重 |
| **Stacking** | 高排名 | 用元模型学习组合 |
| **不同架构** | 1st, 3rd | LSTM + Transformer + CNN |

**集成代码:**
```python
def ensemble_predictions(predictions_list, weights=None):
    """
    集成多个模型的预测

    Args:
        predictions_list: 预测列表 [(n_samples, n_steps), ...]
        weights: 权重列表,None 表示简单平均

    Returns:
        ensemble_pred: 集成预测
    """
    if weights is None:
        # 简单平均
        ensemble_pred = np.mean(predictions_list, axis=0)
    else:
        # 加权平均
        ensemble_pred = np.average(predictions_list, axis=0, weights=weights)

    return ensemble_pred

# 使用示例
# pred1 = model1.predict(X_val)
# pred2 = model2.predict(X_val)
# pred3 = model3.predict(X_val)
#
# # 简单平均
# ensemble = ensemble_predictions([pred1, pred2, pred3])
#
# # 加权平均
# weights = [0.3, 0.3, 0.4]
# ensemble = ensemble_predictions([pred1, pred2, pred3], weights)
```

#### 常见陷阱和注意事项

| 陷阱 | 说明 | 解决方案 |
|------|------|---------|
| **过拟合 PID 规律** | 模型只对 PID 样本有效 | 加入真实呼吸样本训练 |
| **数据泄露** | 使用未来信息 | 严格按时间切分 |
| **多任务权重不当** | 辅助任务干扰主任务 | 调优权重或渐进训练 |
| **集成过拟合** | 集成太多模型 | 3-5 个模型即可 |
| **特征工程过度** | 特征比样本还多 | 特征选择和降维 |
| **验证集策略错误** | 同一 breath 分散到训练和验证 | Group K-Fold |

---

## Metadata

| Source | Date | Tags |
|--------|------|------|
| [HMS - Harmful Brain Activity Classification](https://www.kaggle.com/competitions/hms-harmful-brain-activity-classification) | 2025-01-22 | EEG, 分类, CWT, Entmax, 2-Stage Training, KL-Divergence |
| [Child Mind Institute - Detect Sleep States](https://www.kaggle.com/competitions/child-mind-institute-detect-sleep-states) | 2025-01-22 | 睡眠检测, 事件检测, 两阶段建模, 后处理优化, 多tolerance AP |
| [Child Mind Institute - Detect Behavior with Sensor Data](https://www.kaggle.com/competitions/cmi-detect-behavior-with-sensor-data) | 2025-01-22 | 多模态时序, IMU+TOF+THM, 行为识别, 阶段感知Attention, 匈牙利算法 |
| [BirdCLEF 2024](https://www.kaggle.com/competitions/birdclef-2024) | 2026-01-23 | 音频分类, 生物声学, Statistics T过滤, Google Classifier预标注, CE Loss, Sigmoid推理, Min Ensemble, Checkpoint Soup, 伪标签迭代, 120分钟推理限制 |
| [BirdCLEF+ 2025](https://www.kaggle.com/competitions/birdclef-2025) | 2026-01-22 | 音频分类, 生物声学, Noisy Student, 自蒸馏, SED模型, 伪标签, Mel-Spectrogram, Soft AUC Loss, 90分钟推理限制 |
| [Google Brain - Ventilator Pressure Prediction](https://www.kaggle.com/c/ventilator-pressure-prediction) | 2026-01-23 | 时序回归, PID逆向, 多任务学习, Delta Pressure, LSTM+Transformer, MAE, 2,605队伍 |
| [Cornell Birdcall Identification (BirdCLEF 2020)](https://www.kaggle.com/competitions/birdsong-recognition) | 2026-01-23 | 音频分类, 生物声学, ResNeSt, Attention Pooling, Mel-Spectrogram, Weak Supervision, GAN伪标签, Ensemble, F1-Score, 1,390队伍 |
| [BirdCLEF 2021 - Birdcall Identification](https://www.kaggle.com/competitions/birdclef-2021) | 2026-01-23 | 音频分类, 生物声学, PANNs, 弱监督, Mixup, SpecAugment, Attention Mechanism, F1-Score, 1,700队伍 |
| [BirdCLEF 2022 - Endangered Bird Sounds](https://www.kaggle.com/competitions/birdclef-2022) | 2026-01-23 | 音频分类, 濒危物种, BirdNet, Perch, SED, 多尺度输入, AND规则, Framewise预测, F1-Score, 1,600队伍 |
| [Rainforest Connection Species Audio Detection 2021](https://www.kaggle.com/competitions/rfcx-species-audio-detection) | 2026-01-23 | 音频检测, 生物声学, LWLRAP, Mel-Spectrogram as Image, ResNeSt, EfficientNet, ImageNet预训练, 2,200队伍 |
| [AMP®-Parkinson's Disease Progression Prediction](https://www.kaggle.com/competitions/amp-parkinsons-disease-progression-prediction) | 2026-01-23 | 表格时序回归, 蛋白质数据, Gradient Boosting, SMAPE, XGBoost/LightGBM, 2,500队伍 |

---

## Cornell Birdcall Identification (BirdCLEF 2020)

**竞赛背景:**
- **主办方**:Cornell Lab of Ornithology
- **目标**:识别音频录音中的鸟类叫声(多标签音频分类)
- **应用场景**:鸟类种群监测,生物声学研究,生态系统保护
- **数据集规模**:
  - 训练音频:2,000+ 段录音,涵盖 264 种鸟类
  - 测试音频:约 200 段连续录音(soundscape)
  - 采样率: varied (通常 44.1kHz 或 48kHz)
- **评估指标**:micro-averaged F1-score(需要预测鸟类在 5 秒时间窗口内的出现)
- **最终排名**:
  - 1st Place: Ryan Wong - F1 ~0.71
  - 2nd Place: niw
  - 3rd Place: TheoViel
  - 总参赛队伍:1,390 支

### 前排方案详细技术分析

#### 1st Place - ResNeSt + Attention Pooling + Large Ensemble (Ryan Wong)

核心技巧:
- **ResNeSt Split-Attention Network**:使用 ResNeSt-50 作为主干网络
- **Attention Pooling**:替代传统的全局平均池化
- **Large Voting Ensemble**:13 模型投票集成,需要至少 4 票
- **Mel-Spectrogram Preprocessing**:对数 Mel 频谱特征
- **数据增强**:粉红噪声、高斯噪声、音量调整
- **Multi-Scale Training**:不同音频片段长度

实现细节:
- **音频预处理**:
  - 重采样到 32kHz 或 44.1kHz
  - 使用短时傅里叶变换(STFT)计算 Mel-spectrogram
  - 对数尺度转换:log(1 + mel)
  - 时间维度:5 秒窗口
- **模型架构**:
  - ResNeSt-50 (Split-Attention variants of ResNet)
  - 在 ImageNet 上预训练
  - 替换最后的全连接层为 Attention Pooling
  - 输出层:264 类二分类(多标签)
- **Attention Pooling 实现**:
  ```python
  class AttentionPooling(nn.Module):
      def __init__(self, input_dim, hidden_dim=128):
          super().__init__()
          self.attention = nn.Sequential(
              nn.Linear(input_dim, hidden_dim),
              nn.Tanh(),
              nn.Linear(hidden_dim, 1)
          )

      def forward(self, x):
          # x: (batch, time, features)
          weights = F.softmax(self.attention(x), dim=1)
          return (x * weights).sum(dim=1)
  ```
- **集成策略**:
  - 13 个模型的投票集成
  - 每个预测需要至少 4 票才认为鸟类存在
  - 基于 LB 分数选择模型
  - 不同 checkpoint 和数据增强配置
- **数据增强**:
  - Mixup(混合增强)
  - 背景噪声添加
  - 音高变换(pitch shifting)
  - 时间拉伸(time stretching)
- **训练配置**:
  - Loss:Binary Cross-Entropy
  - Optimizer:AdamW
  - Learning Rate:1e-3(带 cosine annealing)
  - Batch Size:32
  - Epochs:~30

#### 2nd Place - Efficient Ensemble with Strong Data Augmentation (niw)

核心技巧:
- **ResNet50-based Models**:多个 ResNet50 变体
- **Aggressive Data Augmentation**:激进的音频增强
- **Spectral Features**:多种频谱特征组合
- **Prediction Thresholding**:预测阈值优化
- **Cross-Validation Ensemble**:交叉验证集成

实现细节:
- **特征工程**:
  - Mel-spectrogram(128 Mel bins)
  - MFCC(Mel-Frequency Cepstral Coefficients)
  - Chroma features
  - Spectral contrast
- **模型变体**:
  - ResNet50(预训练)
  - EfficientNet-B0
  - DenseNet-121
- **增强策略**:
  - 时间遮罩(SpecAugment Time Masking)
  - 频率遮罩(Frequency Masking)
  - 添加背景噪声
  - 音量随机化
- **后处理**:
  - 类别特定的阈值优化
  - 时间平滑(temporal smoothing)
  - 最小持续时间过滤

#### 3rd Place - Simple yet Effective Approach (TheoViel)

核心技巧:
- **Pre-trained ResNeSt**:使用预训练的 ResNeSt 模型
- **Mel-Spectrogram Input**:标准 Mel 频谱
- **Strong Baseline**:简洁但强大的基线模型
- **Moderate Ensemble**:中等规模集成
- **Careful Validation**:仔细的验证策略

实现细节:
- **音频处理**:
  - 重采样到 44.1kHz
  - 5 秒固定窗口
  - 128 Mel bins
  - 对数幅度压缩
- **模型架构**:
  - ResNeSt50(预训练)
  - Global Average Pooling
  - Sigmoid 激活
- **训练策略**:
  - 5-fold 交叉验证
  - Early stopping
  - Learning rate scheduling
- **集成方法**:
  - 5-7 个模型的平均
  - 不同随机种子

#### 4th Place - Logmels Spectral Features (dimabert & ususani)

核心技巧:
- **Logmels Features**:对数 Mel 频谱作为主要特征
- **Audio Normalization**:音频标准化处理
- **32kHz Resampling**:统一采样率
- **CNN Ensemble**:多个 CNN 模型集成

实现细节:
- **音频预处理**:
  - 重采样到 32,000 Hz
  - 音频归一化(RMS normalization)
  - 固定长度窗口
- **特征提取**:
  - Logmels(对数 Mel-spectrogram)
  - 128 Mel bins
  - 时间帧数:约 500 帧/5秒
- **模型选择**:
  - ResNet50
  - ResNeSt50
  - EfficientNet
- **Loss Function**:
  - Binary Cross-Entropy
  - Label Smoothing

#### 5th Place - Dual Approach with Different Architectures (Kramarenko Vladislav)

核心技巧:
- **Multiple Approaches**:尝试了两种不同的方法
- **Different CNN Architectures**:不同的 CNN 架构
- **Feature Engineering**:特征工程优化
- **Prediction Blending**:预测结果混合

实现细节:
- **方法 1**:ResNet50 + Mel-spectrogram
- **方法 2**:Custom CNN + MFCC features
- **最终集成**:两种方法的加权平均

#### 6th Place - Sound Event Detection with Attention (Deep)

核心技巧:
- **SED Framework**:声音事件检测框架
- **ResNeSt50 Encoder**:ResNeSt50 编码器
- **Attention Mechanism**:注意力机制
- **Strong Augmentation**:强数据增强
- **Post-processing**:后处理优化

实现细节:
- **模型架构**:
  - ResNeSt50 作为特征提取器
  - Temporal Attention Module
  - Multi-head Attention
- **训练技巧**:
  - Mixup augmentation
  - CutMix
  - SpecAugment

#### 7th Place - Three Geese and a GAN (CPJKU)

核心技巧:
- **Weak Supervision**:弱监督学习
- **Generative Augmentation**:使用 GAN 生成增强数据
- **Pseudo-labeling**:伪标签策略
- **Strong Single Model**:强大的单模型
- **Note**:该方案可修改后达到 1-2 名成绩

实现细节:
- **GAN-based Augmentation**:
  - 使用生成对抗网络生成合成音频
  - 增加稀有鸟类的样本
  - 条件 GAN(conditional GAN)
- **弱监督策略**:
  - 利用未标注数据
  - 自训练(self-training)
  - 伪标签迭代优化
- **模型架构**:
  - Modified ResNet
  - Attention pooling
  - Multi-task learning
- **训练流程**:
  - Stage 1: 在标注数据上训练
  - Stage 2: 生成伪标签
  - Stage 3: 在标注+伪标签数据上微调

#### 17th Place - File-level Post-processing

核心技巧:
- **File-level Aggregation**:文件级别聚合
- **Temporal Smoothing**:时间平滑
- **Threshold Optimization**:阈值优化
- **Ensemble Diversification**:集成多样化

实现细节:
- **后处理策略**:
  - 同一文件内的预测平滑
  - 移除短于阈值的检测
  - 类别特定的阈值
- **集成方法**:
  - 多个 checkpoint 平均
  - 不同架构的集成

### 代码模板

#### Mel-Spectrogram 特征提取
```python
import torch
import torch.nn as nn
import torchaudio
import numpy as np

class MelSpectrogramExtractor:
    def __init__(self, sample_rate=32000, n_mels=128, n_fft=2048, hop_length=512):
        self.sample_rate = sample_rate
        self.n_mels = n_mels
        self.n_fft = n_fft
        self.hop_length = hop_length

        # Mel-spectrogram transform
        self.mel_transform = torchaudio.transforms.MelSpectrogram(
            sample_rate=sample_rate,
            n_fft=n_fft,
            hop_length=hop_length,
            n_mels=n_mels,
            f_min=0,
            f_max=16000
        )

        # Amplitude to dB
        self.amplitude_to_db = torchaudio.transforms.AmplitudeToDB()

    def extract(self, waveform):
        """提取 Mel-spectrogram 特征"""
        # Compute mel-spectrogram
        mel_spec = self.mel_transform(waveform)

        # Convert to dB scale
        mel_spec_db = self.amplitude_to_db(mel_spec)

        # Normalize to [0, 1]
        mel_spec_norm = (mel_spec_db - mel_spec_db.min()) / (mel_spec_db.max() - mel_spec_db.min() + 1e-8)

        return mel_spec_norm

# 使用示例
extractor = MelSpectrogramExtractor(sample_rate=32000, n_mels=128)
waveform, sr = torchaudio.load("bird_audio.wav")
if sr != 32000:
    resampler = torchaudio.transforms.Resample(sr, 32000)
    waveform = resampler(waveform)
mel_spec = extractor.extract(waveform)
```

#### ResNeSt + Attention Pooling 模型
```python
import torch
import torch.nn as nn
import torch.nn.functional as F

class AttentionPooling2d(nn.Module):
    """2D Attention Pooling for spectrograms"""
    def __init__(self, in_channels, hidden_dim=128):
        super().__init__()
        self.attention = nn.Sequential(
            nn.Conv2d(in_channels, hidden_dim, kernel_size=1),
            nn.BatchNorm2d(hidden_dim),
            nn.Tanh(),
            nn.Conv2d(hidden_dim, 1, kernel_size=1)
        )

    def forward(self, x):
        # x: (batch, channels, time, freq)
        attn_weights = F.softmax(self.attention(x), dim=(2, 3))
        return (x * attn_weights).sum(dim=(2, 3))

class BirdcallClassifier(nn.Module):
    def __init__(self, num_classes=264, pretrained=True):
        super().__init__()

        # ResNeSt backbone (需要安装 resnest 库)
        from resnest.torch import resnest50

        self.backbone = resnest50(pretrained=pretrained)

        # 替换最后的全连接层
        self.backbone.fc = nn.Identity()

        # Attention pooling
        self.attention_pool = AttentionPooling2d(2048, hidden_dim=128)

        # Classifier head
        self.classifier = nn.Sequential(
            nn.Dropout(0.3),
            nn.Linear(2048, 512),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(512, num_classes)
        )

    def forward(self, x):
        # x: (batch, channels, time, freq) - Mel-spectrogram
        features = self.backbone(x)  # (batch, 2048, H, W)
        pooled = self.attention_pool(features)  # (batch, 2048)
        logits = self.classifier(pooled)  # (batch, num_classes)
        return logits

# 使用示例
model = BirdcallClassifier(num_classes=264, pretrained=True)
mel_spec_batch = torch.randn(8, 3, 224, 512)  # (batch, channels, freq, time)
logits = model(mel_spec_batch)
probs = torch.sigmoid(logits)  # Multi-label prediction
```

#### 数据增强
```python
import torch
import torchaudio
import random

class BirdcallAugmentation:
    def __init__(self, sample_rate=32000):
        self.sample_rate = sample_rate

    def add_noise(self, waveform, noise_level=0.005):
        """添加高斯噪声"""
        noise = torch.randn_like(waveform) * noise_level
        return waveform + noise

    def add_pink_noise(self, waveform, alpha=1):
        """添加粉红噪声(1/f 噪声)"""
        # 简化的粉红噪声生成
        white_noise = torch.randn_like(waveform)
        # 在频域应用 1/f 滤波
        freq_noise = torch.fft.rfft(white_noise)
        freqs = torch.fft.rfftfreq(waveform.shape[-1], 1/self.sample_rate)
        pink_filter = 1 / (freqs[1:] + 1e-8) ** alpha
        freq_noise[:, 1:] *= pink_filter
        pink_noise = torch.fft.irfft(freq_noise, n=waveform.shape[-1])
        return waveform + pink_noise * 0.01

    def time_mask(self, mel_spec, max_mask_pct=0.1):
        """时间遮罩(SpecAugment)"""
        batch, channels, time, freq = mel_spec.shape
        mask_len = int(time * max_mask_pct)
        t = random.randint(0, mask_len)
        t0 = random.randint(0, time - t)
        mel_spec[:, :, t0:t0+t, :] = 0
        return mel_spec

    def freq_mask(self, mel_spec, max_mask_pct=0.1):
        """频率遮罩"""
        batch, channels, time, freq = mel_spec.shape
        mask_len = int(freq * max_mask_pct)
        f = random.randint(0, mask_len)
        f0 = random.randint(0, freq - f)
        mel_spec[:, :, :, f0:f0+f] = 0
        return mel_spec

    def pitch_shift(self, waveform, shift=2.0):
        """音高变换"""
        # 简化实现:使用 resampling
        # 实际应用中可用更高级的库如 pydub 或 librosa
        n_steps = int(shift * 10)
        resampler = torchaudio.transforms.Resample(
            self.sample_rate,
            int(self.sample_rate * (1 + shift * 0.1))
        )
        return resampler(waveform)

    def gain(self, waveform, min_gain=0.5, max_gain=1.5):
        """音量调整"""
        gain = random.uniform(min_gain, max_gain)
        return waveform * gain

# 使用示例
augmentation = BirdcallAugmentation(sample_rate=32000)
waveform, sr = torchaudio.load("bird_audio.wav")

# 应用增强
waveform_aug = augmentation.add_noise(waveform)
waveform_aug = augmentation.gain(waveform_aug)
```

#### 训练循环
```python
import torch
import torch.nn as nn
from torch.utils.data import DataLoader

def train_epoch(model, dataloader, criterion, optimizer, device, augmentation=None):
    model.train()
    total_loss = 0

    for batch in dataloader:
        waveforms, labels = batch
        waveforms = waveforms.to(device)
        labels = labels.to(device)

        # 数据增强(训练时)
        if augmentation is not None:
            # 在 Mel-spectrogram 上应用增强
            pass

        # 前向传播
        logits = model(waveforms)
        loss = criterion(logits, labels.float())

        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_loss += loss.item()

    return total_loss / len(dataloader)

def train_model(model, train_loader, val_loader, num_epochs=30, device='cuda'):
    criterion = nn.BCEWithLogitsLoss()
    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=num_epochs)

    best_val_score = 0

    for epoch in range(num_epochs):
        # 训练
        train_loss = train_epoch(model, train_loader, criterion, optimizer, device)

        # 验证
        val_score, val_loss = validate(model, val_loader, criterion, device)

        # 学习率调度
        scheduler.step()

        print(f"Epoch {epoch+1}/{num_epochs}")
        print(f"Train Loss: {train_loss:.4f}")
        print(f"Val Loss: {val_loss:.4f}")
        print(f"Val F1: {val_score:.4f}")

        # 保存最佳模型
        if val_score > best_val_score:
            best_val_score = val_score
            torch.save(model.state_dict(), 'best_model.pth')

    return model
```

#### 集成与后处理
```python
import numpy as np
import pandas as pd

class EnsemblePredictor:
    def __init__(self, models, threshold=0.5, min_votes=4):
        """
        Args:
            models: 模型列表
            threshold: 二值化阈值
            min_votes: 最小投票数(如 1st place 用 4 票)
        """
        self.models = models
        self.threshold = threshold
        self.min_votes = min_votes

    def predict(self, mel_spec_batch):
        """集成预测"""
        all_predictions = []

        for model in self.models:
            model.eval()
            with torch.no_grad():
                logits = model(mel_spec_batch)
                probs = torch.sigmoid(logits)
                binary = (probs > self.threshold).float()
                all_predictions.append(binary.cpu().numpy())

        # 投票集成
        all_predictions = np.array(all_predictions)  # (n_models, batch, num_classes)
        votes = all_predictions.sum(axis=0)  # (batch, num_classes)

        # 需要至少 min_votes 票
        final_pred = (votes >= self.min_votes).astype(int)

        return final_pred

def temporal_post_process(predictions, window_size=3, min_duration=3):
    """
    时间后处理

    Args:
        predictions: (time_steps, num_classes) 二值预测
        window_size: 平滑窗口大小
        min_duration: 最小持续时间(时间步)
    """
    smoothed = predictions.copy()

    # 时间平滑(多数投票)
    for i in range(predictions.shape[0]):
        start = max(0, i - window_size // 2)
        end = min(predictions.shape[0], i + window_size // 2 + 1)
        window = predictions[start:end]
        smoothed[i] = (window.sum(axis=0) > window_size // 2).astype(int)

    # 移除短于阈值的检测
    final = smoothed.copy()
    for c in range(predictions.shape[1]):
        col = smoothed[:, c]
        # 找连续段
        changes = np.diff(col, prepend=0, append=0)
        starts = np.where(changes == 1)[0]
        ends = np.where(changes == -1)[0]

        for s, e in zip(starts, ends):
            if e - s < min_duration:
                final[s:e, c] = 0

    return final

def create_submission(predictions, audio_ids, bird_species):
    """
    创建提交文件

    Args:
        predictions: (n_samples, num_classes) 二值预测
        audio_ids: 音频文件 ID 列表
        bird_species: 鸟类名称列表
    """
    rows = []
    for audio_id, pred in zip(audio_ids, predictions):
        active_birds = [bird_species[i] for i, p in enumerate(pred) if p == 1]
        if active_birds:
            rows.append({
                'row_id': f"{audio_id}",
                'birds': ' '.join(active_birds)
            })
        else:
            rows.append({
                'row_id': f"{audio_id}",
                'birds': 'nocall'
            })

    submission = pd.DataFrame(rows)
    return submission
```

### 最佳实践

1. **音频预处理标准化**:
   - 统一采样率(32kHz 或 44.1kHz)
   - 使用高质量的 Mel-spectrogram 参数(n_fft=2048, hop_length=512, n_mels=128)
   - 对数幅度压缩(log 或 dB 转换)

2. **模型选择**:
   - ResNeSt 表现最佳(split-attention 机制)
   - 在 ImageNet 上预训练的模型迁移效果好
   - Attention Pooling 优于 Global Average Pooling

3. **数据增强策略**:
   - SpecAugment(时间/频率遮罩)是必需的
   - Mixup 有助于提高泛化能力
   - 添加背景噪声提高鲁棒性
   - GAN 生成增强数据可以提升稀有类别性能

4. **集成方法**:
   - 投票集成优于平均集成
   - 设置最小投票数阈值(如 4 票)可减少误报
   - 使用不同 checkpoint 和随机种子增加多样性

5. **后处理优化**:
   - 时间平滑可以减少闪烁
   - 移除短于阈值的检测
   - 类别特定的阈值优化

6. **验证策略**:
   - 使用 5-fold 交叉验证
   - 仔细设计验证集以反映测试集分布
   - 监控 micro-F1 分数

7. **训练技巧**:
   - 使用 AdamW 优化器
   - Cosine annealing 学习率调度
   - Binary Cross-Entropy Loss
   - Label smoothing 有助于正则化

8. **常见陷阱**:
   - 避免过度拟合训练集的音频特征
   - 注意类别不平衡问题
   - 验证集和测试集可能有不同的分布
   - 推理时间限制(如果有)需要考虑模型效率

---

## BirdCLEF 2021 - Birdcall Identification

**竞赛背景:**
- **主办方**:Cornell Lab of Ornithology + LifeCLEF
- **目标**:识别音频录音中的鸟类叫声(弱监督多标签音频分类)
- **应用场景**:鸟类种群监测,生物声学研究,生态系统保护
- **数据集规模**:
  - 训练音频:约 3,900 段录音,涵盖 397 种鸟类
  - 测试音频:约 2,600 段连续录音(soundscape)
  - 弱监督标注:只有音频级别的标签,无时间戳
- **评估指标**:micro-averaged F1-score
- **最终排名**:
  - 1st Place: DR (kami634) - 弱监督方案
  - 2nd Place: Christof Henkel
  - 3rd Place: shiro
  - 总参赛队伍:约 1,700+ 支

### 前排方案详细技术分析

#### 1st Place - Weak Supervision with PANNs (DR)

核心技巧:
- **Pre-trained Audio Neural Networks (PANNs)**:使用预训练的音频神经网络
- **Weak Supervision Strategy**:弱监督学习策略
- **Attention Mechanisms**:自注意力机制用于音频分类
- **Spectrogram-based Features**:基于频谱图的特征
- **Model Ensemble**:多模型集成
- **Post-processing**:后处理优化

实现细节:
- **基础模型**:
  - 使用预训练的 PANNs (Pre-trained Audio Neural Networks)
  - 包括 CNN14, CNN10, ResNet38 等架构
  - 在 AudioSet 上预训练
  - 迁移学习到鸟类叫声分类
- **特征提取**:
  - Mel-spectrogram(64/128 Mel bins)
  - 对数幅度压缩
  - 多尺度时间窗口
- **弱监督策略**:
  - 仅使用音频级别的标签(无时间戳)
  - 通过注意力机制定位关键区域
  - 多实例学习(Multiple Instance Learning)
- **模型架构**:
  - CNN-based 特征提取器
  - Self-Attention 层
  - Global Pooling + 分类器
- **集成方法**:
  - 多个 PANNs 模型集成
  - 不同架构和预训练权重
  - 投票或平均策略
- **数据增强**:
  - Mixup
  - SpecAugment
  - 背景噪声添加
- **后处理**:
  - 时间平滑
  - 阈值优化
  - 类别特定的后处理

#### 2nd Place - New Baseline with Strong Augmentation (Christof Henkel)

核心技巧:
- **New Baseline Architecture**:新颖的基线架构
- **Mixup Augmentation**:Mixup 数据增强
- **Background Noise Addition**:背景噪声添加
- **Pseudo-labeling**:伪标签策略
- **5-second Segment Inference**:5秒片段推理
- **Strong Single Model**:强大的单模型

实现细节:
- **模型选择**:
  - ResNet50 / ResNeSt50
  - EfficientNet variants
  - DenseNet-based models
- **音频预处理**:
  - 重采样到 32kHz
  - Mel-spectrogram 提取
  - 标准化处理
- **增强策略**:
  - Mixup(强制使用)
  - 时间遮罩(Time Masking)
  - 频率遮罩(Frequency Masking)
  - 背景噪声混合
- **伪标签**:
  - 使用训练好的模型预测未标注数据
  - 高置信度预测作为伪标签
  - 迭代训练
- **训练配置**:
  - Binary Cross-Entropy Loss
  - AdamW 优化器
  - Cosine 学习率衰减
  - 5-fold 交叉验证
- **推理策略**:
  - 5秒滑动窗口
  - 窗口间有重叠
  - 多个窗口预测聚合

#### 3rd Place - Ensemble with Multiple Approaches (shiro)

核心技巧:
- **Multiple Model Families**:多族模型集成
- **Spectral Feature Engineering**:频谱特征工程
- **Cross-Validation Strategy**:交叉验证策略
- **Post-processing Pipeline**:后处理流程
- **Attention-based Models**:基于注意力的模型

实现细节:
- **模型选择**:
  - ResNet variants
  - DenseNet variants
  - EfficientNet variants
  - Custom CNN architectures
- **特征多样性**:
  - 不同 Mel-spectrogram 参数
  - MFCC features
  - Chroma features
  - Spectral contrast
- **训练策略**:
  - 5-fold 交叉验证
  - Early stopping
  - Learning rate scheduling
- **集成方法**:
  - 加权平均
  - 基于验证集权重优化
  - 不同 checkpoint 集成

#### 4th Place - Third Time's The Charm (tattaka)

核心技巧:
- **Iterative Improvement**:迭代改进策略
- **Strong Data Augmentation**:强数据增强
- **Spectrogram Preprocessing**:频谱预处理优化
- **Model Architecture Search**:模型架构搜索
- **Ensemble Optimization**:集成优化

实现细节:
- **音频处理**:
  - 高质量 Mel-spectrogram 参数调优
  - 多种时间窗口长度
  - 频率范围选择
- **模型架构**:
  - ResNet50
  - ResNeSt50
  - DenseNet-121
- **增强组合**:
  - SpecAugment(多种参数)
  - Mixup + CutMix
  - 噪声增强
  - 音高变换
- **训练技巧**:
  - 渐进式训练
  - 迭代优化
  - A/B 测试不同策略

#### 5th Place - Dual Approach Blending (Kramarenko Vladislav)

核心技巧:
- **Multiple Approaches**:多种方法尝试
- **Different Feature Sets**:不同特征集
- **Blending Strategy**:混合策略
- **Spectral Analysis**:频谱分析

实现细节:
- **方法 1**:CNN + Mel-spectrogram
- **方法 2**:Gradient Boosting + 手工特征
- **最终集成**:两种方法加权混合

#### 6th-10th Place 概述

**常见技术**:
- PANNs 预训练模型广泛使用
- SpecAugment 成为标准增强
- Mixup 几乎所有前排方案使用
- 5-fold 交叉验证是标准配置
- Mel-spectrogram 是主流特征

**关键技术点**:
- **弱监督处理**:使用注意力机制定位音频中的鸟类叫声
- **数据增强**:SpecAugment + Mixup + 背景噪声
- **模型集成**:多架构、多 checkpoint 集成
- **后处理**:时间平滑、阈值优化、类别特定处理

### 代码模板

#### PANNs 模型加载和使用
```python
import torch
import torch.nn as nn
# 需要安装: pip install torchlibrosa
from torchlibrosa.stft import Spectrogram, LogmelFilterBank

class PANNsCNN14(nn.Module):
    """
    基于 PANNs CNN14 的模型
    参考: https://github.com/qiuqiangkong/audioset_tagging_cnn
    """
    def __init__(self, sample_rate=32000, window_size=512, hop_size=320,
                 mel_bins=64, fmin=50, fmax=14000, num_classes=397):
        super().__init__()

        window = 'hann'
        center = True
        pad_mode = 'reflect'
        ref = 1.0
        amin = 1e-10
        top_db = None

        # Spectrogram extractor
        self.spectrogram_extractor = Spectrogram(
            n_fft=window_size,
            hop_length=hop_size,
            win_length=window_size,
            window=window,
            center=center,
            pad_mode=pad_mode,
            freeze_parameters=True)

        # Logmel feature extractor
        self.logmel_extractor = LogmelFilterBank(
            sr=sample_rate,
            n_fft=window_size,
            n_mels=mel_bins,
            fmin=fmin,
            fmax=fmax,
            ref=ref,
            amin=amin,
            top_db=top_db,
            freeze_parameters=True)

        # SpecAugment (训练时使用)
        self.spec_augment = SpecAugmentation(
            time_drop_width=64,
            time_stripes_num=2,
            freq_drop_width=8,
            freq_stripes_num=2)

        # CNN14 backbone
        self.bn0 = nn.BatchNorm2d(mel_bins)

        self.conv_block1 = ConvBlock(in_channels=1, out_channels=64)
        self.conv_block2 = ConvBlock(in_channels=64, out_channels=128)
        self.conv_block3 = ConvBlock(in_channels=128, out_channels=256)
        self.conv_block4 = ConvBlock(in_channels=256, out_channels=512)
        self.conv_block5 = ConvBlock(in_channels=512, out_channels=1024)
        self.conv_block6 = ConvBlock(in_channels=1024, out_channels=2048)

        self.fc1 = nn.Linear(2048, 2048, bias=True)
        self.fc_audioset = nn.Linear(2048, num_classes, bias=True)

        self.init_weight()

    def init_weight(self):
        init_bn(self.bn0)
        init_layer(self.fc1)
        init_layer(self.fc_audioset)

    def forward(self, input, mixup_lambda=None, device='cuda'):
        """
        Args:
            input: (batch_size, time_samples)
        Returns:
            output: (batch_size, num_classes)
        """
        # Spectrogram
        x = self.spectrogram_extractor(input)  # (batch, 1, time, freq)
        x = self.logmel_extractor(x)  # (batch, 1, time, mel_bins)

        # BN
        x = x.transpose(1, 3)
        x = self.bn0(x)
        x = x.transpose(1, 3)

        # SpecAugment (仅训练时)
        if self.training:
            x = self.spec_augment(x)

        # CNN blocks
        x = self.conv_block1(x, pool_size=(2, 2), pool_type='avg')
        x = F.dropout(x, p=0.2, training=self.training)

        x = self.conv_block2(x, pool_size=(2, 2), pool_type='avg')
        x = F.dropout(x, p=0.2, training=self.training)

        x = self.conv_block3(x, pool_size=(2, 2), pool_type='avg')
        x = F.dropout(x, p=0.2, training=self.training)

        x = self.conv_block4(x, pool_size=(2, 2), pool_type='avg')
        x = F.dropout(x, p=0.2, training=self.training)

        x = self.conv_block5(x, pool_size=(2, 2), pool_type='avg')
        x = F.dropout(x, p=0.2, training=self.training)

        x = self.conv_block6(x, pool_size=(1, 1), pool_type='avg')
        x = F.dropout(x, p=0.2, training=self.training)

        # Global pooling
        x = torch.mean(x, dim=3)  # (batch, channels, time)

        (x1, _) = torch.max(x, dim=2)  # (batch, channels)
        x2 = torch.mean(x, dim=2)  # (batch, channels)
        x = x1 + x2  # (batch, channels)

        x = F.dropout(x, p=0.5, training=self.training)
        x = F.relu_(self.fc1(x))
        embedding = F.dropout(x, p=0.5, training=self.training)
        clipwise_output = torch.sigmoid(self.fc_audioset(x))

        return clipwise_output

    def load_from_pretrained(self, pretrained_path):
        """加载预训练权重"""
        checkpoint = torch.load(pretrained_path, map_location='cpu')
        model_state = self.state_dict()
        pretrained_state = checkpoint['model']

        # 过滤不匹配的键
        pretrained_state = {k: v for k, v in pretrained_state.items()
                          if k in model_state and v.shape == model_state[k].shape}

        model_state.update(pretrained_state)
        self.load_state_dict(model_state)
        print(f"Loaded pretrained weights from {pretrained_path}")

class ConvBlock(nn.Module):
    def __init__(self, in_channels, out_channels):
        super().__init__()

        self.conv1 = nn.Conv2d(in_channels=in_channels,
                              out_channels=out_channels,
                              kernel_size=(3, 3), stride=(1, 1),
                              padding=(1, 1), bias=False)
        self.conv2 = nn.Conv2d(in_channels=out_channels,
                              out_channels=out_channels,
                              kernel_size=(3, 3), stride=(1, 1),
                              padding=(1, 1), bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.bn2 = nn.BatchNorm2d(out_channels)

        self.init_weight()

    def init_weight(self):
        init_bn(self.bn1)
        init_bn(self.bn2)
        init_layer(self.conv1)
        init_layer(self.conv2)

    def forward(self, input, pool_size=(2, 2), pool_type='avg'):
        x = input
        x = F.relu_(self.bn1(self.conv1(x)))
        x = F.relu_(self.bn2(self.conv2(x)))
        if pool_type == 'max':
            x = F.max_pool2d(x, kernel_size=pool_size)
        elif pool_type == 'avg':
            x = F.avg_pool2d(x, kernel_size=pool_size)
        elif pool_type == 'avg+max':
            x1 = F.avg_pool2d(x, kernel_size=pool_size)
            x2 = F.max_pool2d(x, kernel_size=pool_size)
            x = x1 + x2
        else:
            raise ValueError(f'Unknown pool type: {pool_type}')
        return x

class SpecAugmentation(nn.Module):
    def __init__(self, time_drop_width, time_stripes_num,
                 freq_drop_width, freq_stripes_num):
        super().__init__()
        self.time_drop_width = time_drop_width
        self.time_stripes_num = time_stripes_num
        self.freq_drop_width = freq_drop_width
        self.freq_stripes_num = freq_stripes_num

    def forward(self, x):
        """x: (batch, channels, time, freq)"""
        self._mask_along_axis(x, self.time_drop_width,
                             self.time_stripes_num, axis=2)
        self._mask_along_axis(x, self.freq_drop_width,
                             self.freq_stripes_num, axis=3)
        return x

    def _mask_along_axis(self, x, drop_width, stripes_num, axis):
        """沿指定轴遮罩"""
        for _ in range(stripes_num):
            drop_width = int(drop_width) if isinstance(drop_width, int) else \
                        int(drop_width * x.shape[axis])
            drop_start = int(torch.rand(1).item() * (x.shape[axis] - drop_width))

            if axis == 2:  # time axis
                x[:, :, drop_start:drop_start + drop_width, :] = 0
            elif axis == 3:  # freq axis
                x[:, :, :, drop_start:drop_start + drop_width] = 0
        return x

def init_layer(layer):
    """Initialize a Linear or Convolutional layer."""
    nn.init.xavier_uniform_(layer.weight)
    if hasattr(layer, 'bias'):
        if layer.bias is not None:
            layer.bias.data.fill_(0.)

def init_bn(bn):
    """Initialize a Batchnorm layer."""
    bn.bias.data.fill_(0.)
    bn.weight.data.fill_(1.)

# 使用示例
model = PANNsCNN14(
    sample_rate=32000,
    window_size=512,
    hop_size=320,
    mel_bins=64,
    num_classes=397
)

# 加载预训练权重(可选)
# model.load_from_pretrained('path/to/pretrained/CNN14.pth')

waveform = torch.randn(4, 32000 * 5)  # (batch, 5 seconds at 32kHz)
with torch.no_grad():
    output = model(waveform)
print(output.shape)  # (4, 397)
```

#### Mixup 数据增强
```python
import torch
import numpy as np

def mixup_data(x, y, alpha=0.2):
    """
    Mixup 数据增强

    Args:
        x: 输入数据 (batch_size, ...)
        y: 标签 (batch_size, num_classes)
        alpha: Beta 分布参数

    Returns:
        mixed_x: 混合后的输入
        y_a, y_b: 两个样本的标签
        lam: 混合系数
    """
    if alpha > 0:
        lam = np.random.beta(alpha, alpha)
    else:
        lam = 1

    batch_size = x.size(0)
    index = torch.randperm(batch_size).to(x.device)

    mixed_x = lam * x + (1 - lam) * x[index, :]
    y_a, y_b = y, y[index]

    return mixed_x, y_a, y_b, lam

def mixup_criterion(criterion, pred, y_a, y_b, lam):
    """Mixup 损失函数"""
    return lam * criterion(pred, y_a) + (1 - lam) * criterion(pred, y_b)

# 使用示例
criterion = nn.BCEWithLogitsLoss()

for batch_idx, (waveforms, labels) in enumerate(train_loader):
    waveforms = waveforms.to(device)
    labels = labels.to(device)

    # 应用 Mixup
    waveforms_mixed, labels_a, labels_b, lam = mixup_data(
        waveforms, labels, alpha=0.2
    )

    # 前向传播
    outputs = model(waveforms_mixed)

    # 计算 Mixup 损失
    loss = mixup_criterion(criterion, outputs, labels_a, labels_b, lam)

    # 反向传播
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
```

#### 弱监督训练(音频级别标签)
```python
import torch
import torch.nn as nn
from torch.utils.data import Dataset

class BirdcallWeakDataset(Dataset):
    """
    弱监督数据集:只有音频级别标签,无时间戳
    """
    def __init__(self, audio_files, labels, audio_transforms=None,
                 duration=5, sample_rate=32000):
        self.audio_files = audio_files
        self.labels = labels  # Multi-hot labels: (num_samples, num_classes)
        self.audio_transforms = audio_transforms
        self.duration = duration
        self.sample_rate = sample_rate

    def __len__(self):
        return len(self.audio_files)

    def __getitem__(self, idx):
        # 加载音频
        waveform, sr = torchaudio.load(self.audio_files[idx])

        # 重采样
        if sr != self.sample_rate:
            resampler = torchaudio.transforms.Resample(sr, self.sample_rate)
            waveform = resampler(waveform)

        # 固定长度(裁剪或填充)
        target_length = self.duration * self.sample_rate
        if waveform.shape[1] > target_length:
            # 随机裁剪
            start = torch.randint(0, waveform.shape[1] - target_length, (1,)).item()
            waveform = waveform[:, start:start + target_length]
        elif waveform.shape[1] < target_length:
            # 填充
            padding = target_length - waveform.shape[1]
            waveform = torch.nn.functional.pad(waveform, (0, padding))

        # 获取标签(音频级别,多标签)
        label = self.labels[idx]

        # 数据增强
        if self.audio_transforms is not None:
            waveform = self.audio_transforms(waveform)

        return waveform, label

class AttentionPooling(nn.Module):
    """
    注意力池化:用于弱监督学习,自动定位重要区域
    """
    def __init__(self, input_dim, hidden_dim=128):
        super().__init__()
        self.attention = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, 1)
        )

    def forward(self, x):
        """
        Args:
            x: (batch, time_steps, features)

        Returns:
            pooled: (batch, features)
            weights: (batch, time_steps) - 可视化注意力
        """
        attn_weights = F.softmax(self.attention(x), dim=1)
        pooled = (x * attn_weights).sum(dim=1)
        return pooled, attn_weights

class WeaklySupervisedBirdcallModel(nn.Module):
    """
    弱监督鸟类叫声分类模型
    """
    def __init__(self, num_classes=397, pretrained=True):
        super().__init__()

        # 使用预训练的 PANNs CNN14 作为特征提取器
        self.backbone = PANNsCNN14(num_classes=num_classes, pretrained=pretrained)

        # 移除最后的分类层
        self.backbone.fc_audioset = nn.Identity()

        # 注意力池化
        feature_dim = 2048  # CNN14 的输出维度
        self.attention_pool = AttentionPooling(feature_dim, hidden_dim=128)

        # 分类器
        self.classifier = nn.Sequential(
            nn.Dropout(0.3),
            nn.Linear(feature_dim, 512),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(512, num_classes)
        )

    def forward(self, x, return_attention=False):
        """
        Args:
            x: (batch, time_samples)
            return_attention: 是否返回注意力权重用于可视化

        Returns:
            logits: (batch, num_classes)
            attention_weights (optional): (batch, time_steps)
        """
        # 提取特征(修改 backbone 以返回时间维度特征)
        features = self.extract_features(x)  # (batch, time_steps, feature_dim)

        # 注意力池化
        pooled, attn_weights = self.attention_pool(features)

        # 分类
        logits = self.classifier(pooled)

        if return_attention:
            return logits, attn_weights
        return logits

    def extract_features(self, x):
        """
        从 backbone 提取时间维度特征
        这是一个简化版本,实际使用时需要修改 PANNsCNN14
        """
        # 简化实现:直接使用全局特征
        with torch.no_grad():
            features = self.backbone.fc1(
                torch.mean(self.backbone.bn0(
                    self.backbone.logmel_extractor(
                        self.backbone.spectrogram_extractor(x)
                    ).transpose(1, 3)
                ), dim=3)
            )
        # 添加时间维度
        return features.unsqueeze(1)  # (batch, 1, feature_dim)

# 训练循环
def train_weakly_supervised(model, dataloader, criterion, optimizer, device, use_mixup=True):
    model.train()

    for waveforms, labels in dataloader:
        waveforms = waveforms.to(device)
        labels = labels.to(device).float()

        # Mixup 增强
        if use_mixup and np.random.rand() < 0.5:
            waveforms, labels_a, labels_b, lam = mixup_data(waveforms, labels, alpha=0.2)

        # 前向传播
        logits = model(waveforms)

        # 计算损失
        if use_mixup and np.random.rand() < 0.5:
            loss = mixup_criterion(criterion, logits, labels_a, labels_b, lam)
        else:
            loss = criterion(logits, labels)

        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

# 可视化注意力(用于理解模型关注的区域)
def visualize_attention(model, waveform, bird_name):
    """可视化注意力权重,了解模型关注的音频区域"""
    model.eval()
    with torch.no_grad():
        logits, attention = model(waveform.unsqueeze(0), return_attention=True)

    # attention: (1, time_steps)
    attention = attention.squeeze(0).cpu().numpy()

    import matplotlib.pyplot as plt
    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 6))

    # 音频波形
    ax1.plot(waveform.cpu().numpy().T)
    ax1.set_title(f'Audio Waveform - {bird_name}')
    ax1.set_xlabel('Time')
    ax1.set_ylabel('Amplitude')

    # 注意力权重
    ax2.plot(attention)
    ax2.set_title('Attention Weights')
    ax2.set_xlabel('Time Step')
    ax2.set_ylabel('Attention Weight')

    plt.tight_layout()
    plt.savefig('attention_visualization.png')
    plt.close()
```

#### 5秒滑动窗口推理
```python
import torch
import numpy as np

def predict_with_sliding_window(model, audio_path, window_size=5,
                                hop_size=2.5, sample_rate=32000,
                                device='cuda'):
    """
    使用滑动窗口进行推理

    Args:
        model: 训练好的模型
        audio_path: 音频文件路径
        window_size: 窗口大小(秒)
        hop_size: 跳跃大小(秒)
        sample_rate: 采样率
        device: 设备

    Returns:
        predictions: (num_windows, num_classes)
        timestamps: 窗口时间戳
    """
    model.eval()

    # 加载音频
    waveform, sr = torchaudio.load(audio_path)
    if sr != sample_rate:
        resampler = torchaudio.transforms.Resample(sr, sample_rate)
        waveform = resampler(waveform)

    waveform = waveform.mean(dim=0, keepdim=True)  # 转为单声道

    # 计算窗口参数
    window_samples = int(window_size * sample_rate)
    hop_samples = int(hop_size * sample_rate)

    predictions = []
    timestamps = []

    # 滑动窗口
    with torch.no_grad():
        for start in range(0, waveform.shape[1] - window_samples + 1, hop_samples):
            end = start + window_samples
            window = waveform[:, start:end].to(device)

            # 预测
            logits = model(window)
            probs = torch.sigmoid(logits).cpu().numpy()

            predictions.append(probs[0])
            timestamps.append(start / sample_rate)

    predictions = np.array(predictions)
    timestamps = np.array(timestamps)

    return predictions, timestamps

def aggregate_predictions(predictions, threshold=0.5, min_duration=3):
    """
    聚合滑动窗口预测

    Args:
        predictions: (num_windows, num_classes)
        threshold: 二值化阈值
        min_duration: 最小持续时间(窗口数)

    Returns:
        final_pred: (num_windows, num_classes) 二值预测
    """
    binary_pred = (predictions > threshold).astype(int)

    # 时间平滑
    final_pred = binary_pred.copy()
    for c in range(binary_pred.shape[1]):
        col = binary_pred[:, c]

        # 移除短于阈值的检测
        changes = np.diff(col, prepend=0, append=0)
        starts = np.where(changes == 1)[0]
        ends = np.where(changes == -1)[0]

        for s, e in zip(starts, ends):
            if e - s < min_duration:
                final_pred[s:e, c] = 0

    return final_pred

def create_birdclef_submission(predictions, timestamps, audio_id,
                               bird_species, threshold=0.5):
    """
    创建 BirdCLEF 格式的提交文件

    Args:
        predictions: (num_windows, num_classes) 概率预测
        timestamps: (num_windows,) 时间戳
        audio_id: 音频文件 ID
        bird_species: 鸟类名称列表
        threshold: 二值化阈值

    Returns:
        rows: 提交文件的行列表
    """
    rows = []

    for i, (pred, ts) in enumerate(zip(predictions, timestamps)):
        # 获取活跃的鸟类
        active_birds = []
        for j, p in enumerate(pred):
            if p > threshold:
                active_birds.append(bird_species[j])

        # 创建 row_id
        row_id = f"{audio_id}_{ts:.1f}"

        if active_birds:
            rows.append({
                'row_id': row_id,
                'birds': ' '.join(active_birds)
            })
        else:
            rows.append({
                'row_id': row_id,
                'birds': 'nocall'
            })

    return rows

# 使用示例
model = WeaklySupervisedBirdcallModel(num_classes=397)
model = model.to(device)
model.load_state_dict(torch.load('best_model.pth'))

audio_path = 'test_soundscape.wav'
predictions, timestamps = predict_with_sliding_window(
    model, audio_path, window_size=5, hop_size=2.5, device=device
)

# 聚合预测
final_pred = aggregate_predictions(predictions, threshold=0.5, min_duration=3)

# 创建提交
bird_species = [...]  # 397 个鸟类名称列表
rows = create_birdclef_submission(
    predictions, timestamps, 'soundscape_01', bird_species, threshold=0.5
)

import pandas as pd
submission = pd.DataFrame(rows)
submission.to_csv('submission.csv', index=False)
```

### 最佳实践

1. **弱监督学习策略**:
   - 使用注意力机制定位音频中的关键区域
   - 多实例学习(MIL)框架处理音频级别标签
   - 时序池化(Temporal Pooling)聚合时间维度信息

2. **预训练模型利用**:
   - PANNs(AudioSet 预训练)是最流行的起点
   - CNN14/CNN10 提供强大的基线特征
   - 迁移学习显著提升性能

3. **数据增强组合**:
   - SpecAugment(时间+频率遮罩)必需
   - Mixup 是 BirdCLEF 2021 的关键技巧
   - 背景噪声添加提高鲁棒性
   - 组合多种增强效果最佳

4. **训练技巧**:
   - 5-fold 交叉验证标准配置
   - AdamW + Cosine 学习率
   - Binary Cross-Entropy Loss
   - Label Smoothing 有助于正则化
   - 渐进式训练策略

5. **推理策略**:
   - 5秒滑动窗口(与标注一致)
   - 窗口间有重叠(2.5秒跳跃)
   - 时间平滑减少闪烁
   - 移除短于阈值的检测

6. **集成方法**:
   - 多架构集成(ResNet, DenseNet, EfficientNet)
   - 多 checkpoint 集成
   - 不同增强配置增加多样性
   - 加权平均或投票集成

7. **后处理优化**:
   - 类别特定的阈值优化
   - 时间平滑(移动平均或中值滤波)
   - 最小持续时间过滤
   - 基于验证集优化阈值

8. **常见陷阱**:
   - 忽略弱监督的特殊性(无时间戳)
   - 过度依赖单一模型
   - 验证集和测试集分布不同
   - 忘记时间平滑导致预测不稳定
   - 阈值选择不当影响 F1 分数

---

## BirdCLEF 2022 - Endangered Bird Sounds Classification

**竞赛背景:**
- **主办方**:Cornell Lab of Ornithology + LifeCLEF
- **目标**:识别夏威夷濒危鸟类的叫声(多标签音频分类)
- **应用场景**:濒危物种保护,生态系统监测
- **数据集规模**:
  - 训练音频:约 8,700 段标注录音,涵盖 152 种鸟类(主要是夏威夷物种)
  - 测试音频:约 1,300 段连续录音(soundscape)
  - 短片段标注:部分音频有 5 秒级别的短片段标注
  - 背景噪声:包含雨声、风声、昆虫声等复杂环境音
- **评估指标**:micro-averaged F1-score
- **最终排名**:
  - 1st Place: kdl - "It's not all BirdNet"
  - 2nd Place: Leon Shangguan
  - 3rd Place: uemu-slime
  - 总参赛队伍:约 1,600+ 支

### 前排方案详细技术分析

#### 1st Place - Beyond BirdNet (kdl)

核心技巧:
- **BirdNet + Perch Architecture**:结合 BirdNet 和 Perch 模型
- **SED Framework**:声音事件检测框架
- **Multi-scale Input**:短片段(5秒)和长片段(10秒+)
- **AND Rule**:短片段和长片段预测的 AND 逻辑
- **Model Ensemble**:多架构集成
- **External Data**:使用 BirdCLEF 2021 数据增强

实现细节:
- **模型架构组合**:
  - BirdNet(预训练鸟类分类模型)
  - Perch(预训练模型,类似 BirdNET-lite)
  - 自训练 CNN 模型(ResNet50/ResNeSt50)
  - SED 模型(framewise 输出)
- **多尺度策略**:
  - 短片段(5秒):精确分类
  - 长片段(10-15秒):提高召回率
  - AND 规则:短片段 AND 长片段都预测为正才认为存在
- **SED 实现**:
  - 使用 framewise 输出
  - max(framewise, dim=time) 聚合
  - 时间注意力机制
- **集成方法**:
  - 多个模型集成(10+ 模型)
  - 不同预训练权重
  - 不同输入长度
  - TTA(Test Time Augmentation)
- **外部数据**:
  - BirdCLEF 2021 数据迁移学习
  - 额外鸟类音频数据
- **后处理**:
  - 时间平滑
  - 最小持续时间过滤
  - 类别特定阈值

#### 2nd Place - SED + CNN with 7 Models Ensemble (Leon Shangguan)

核心技巧:
- **SED Framework**:声音事件检测框架
- **10-second Chunks**:10秒片段处理
- **Centered 5-second CNN**:中心 5 秒 CNN 预测
- **Max Framewise Pooling**:framewise 最大值池化
- **7 Models Ensemble**:7 模型集成
- **TTA with 2s Shifts**:2秒偏移的测试时增强

实现细节:
- **SED 模型**:
  - 使用 10 秒音频片段
  - 输出 framewise 预测
  - max(framewise, dim=time) 聚合
  - ResNet50/ResNeSt50 backbone
- **CNN 模型**:
  - 仅对中心 5 秒进行预测
  - 减少计算量
  - Mel-spectrogram 输入
- **集成策略**:
  - 7 个模型集成
  - 不同架构和配置
  - 加权平均
- **TTA**:
  - 2 秒偏移的多个预测
  - 预测平均
- **数据增强**:
  - SpecAugment
  - Mixup
  - 背景噪声

#### 3rd Place - 18 Checkpoints Ensemble (uemu-slime)

核心技巧:
- **18 Checkpoints Ensemble**:18 个模型检查点集成
- **Multiple CNN Architectures**:多种 CNN 架构
- **Different Folds**:不同折的训练
- **Perch + BirdNet**:使用预训练模型
- **Strong Data Augmentation**:强数据增强

实现细节:
- **模型架构**:
  - ResNet50
  - ResNeSt50
  - EfficientNet-B0/B3
  - Perch(预训练)
  - BirdNet(预训练)
- **训练策略**:
  - 每个架构在 5-fold 上训练
  - 选择最佳 checkpoint
  - 共 18 个模型
- **集成方法**:
  - 简单平均
  - 所有模型等权重
- **增强组合**:
  - SpecAugment
  - Mixup
  - 背景噪声
  - 时间遮罩/频率遮罩

#### 4th Place - CNN-based Ensemble (Kramarenko Vladislav)

核心技巧:
- **CNN Ensemble**:CNN 模型集成
- **Mel-Spectrogram Features**:Mel 频谱特征
- **Multiple Backbones**:多种主干网络
- **Cross-Validation**:交叉验证

实现细节:
- **模型选择**:
  - ResNet50
  - ResNeSt50
  - DenseNet-121
- **特征工程**:
  - Mel-spectrogram
  - 不同参数配置
- **训练**:
  - 5-fold 交叉验证
  - Early stopping

#### 5th Place - Reimplementation of 2021 2nd Place (common-kestrel)

核心技巧:
- **9 Models Ensemble**:9 模型集成
- **BirdCLEF 2021 Baseline**:重实现 2021 年 2nd place 方案
- **4x Backbones**:4 种主干网络
- **Different Seeds and Folds**:不同随机种子和折

实现细节:
- **主干网络**:
  - ResNet50
  - ResNeSt50
  - EfficientNet-B0
  - DenseNet-121
- **配置多样性**:
  - 不同随机种子
  - 不同 fold
  - 不同数据增强参数
- **集成方法**:
  - 平均集成
  - 9 个模型

#### 6th-10th Place 概述

**常见技术**:
- BirdNet 预训练模型广泛使用
- Perch 模型(类似 BirdNET-lite)
- SED(Sound Event Detection)框架
- 多尺度输入(5秒 + 10-15秒)
- SpecAugment + Mixup 标准配置

**关键技术点**:
- **短片段长片段结合**:AND 规则减少误报
- **Framewise 预测**:SED 模型的 framewise 输出
- **外部数据利用**:BirdCLEF 2021 数据迁移学习
- **模型集成**:10-20 个模型集成是常态
- **后处理**:时间平滑、最小持续时间过滤

### 代码模板

#### SED 模型(Framewise 输出)
```python
import torch
import torch.nn as nn
import torch.nn.functional as F

class SEDModel(nn.Module):
    """
    声音事件检测模型 - 输出 framewise 预测

    用于 BirdCLEF 2022 风格的音频分类
    """
    def __init__(self, num_classes=152, backbone='resnet50',
                 sample_rate=32000, window_size=5, hop_size=512):
        super().__init__()

        self.num_classes = num_classes
        self.window_size = window_size
        self.sample_rate = sample_rate

        # Mel-spectrogram 提取器
        self.mel_extractor = MelSpectrogramExtractor(
            sample_rate=sample_rate,
            n_mels=128,
            n_fft=2048,
            hop_length=hop_size
        )

        # Backbone(简化版本)
        if backbone == 'resnet50':
            import torchvision.models as models
            self.backbone = models.resnet50(pretrained=True)
            # 修改第一层接受 1 通道输入(mel-spectrogram)
            self.backbone.conv1 = nn.Conv2d(
                1, 64, kernel_size=7, stride=2, padding=3, bias=False
            )
            feature_dim = 2048
        elif backbone == 'resnest50':
            # 使用 ResNeSt50
            feature_dim = 2048

        # 移除最后的全连接层
        self.backbone.fc = nn.Identity()

        # Framewise 分类头
        self.fc = nn.Linear(feature_dim, num_classes)

    def forward(self, waveform, return_frames=False):
        """
        Args:
            waveform: (batch, time_samples)
            return_frames: 是否返回 framewise 预测

        Returns:
            output: (batch, num_classes) 或 (batch, time_frames, num_classes)
        """
        batch_size = waveform.shape[0]

        # 提取 Mel-spectrogram
        mel_spec = self.mel_extractor.extract(waveform)  # (batch, 1, mel_bins, time_frames)

        # 通过 backbone(保留时间维度)
        # 简化版本:实际需要修改 backbone 以保留时间维度
        features = self.extract_features_with_time(mel_spec)  # (batch, time_frames, feature_dim)

        # Framewise 预测
        framewise_output = self.fc(features)  # (batch, time_frames, num_classes)

        if return_frames:
            return framewise_output

        # 聚合(max pooling over time)
        output, _ = torch.max(framewise_output, dim=1)  # (batch, num_classes)

        return output

    def extract_features_with_time(self, mel_spec):
        """
        提取特征并保留时间维度

        这是一个简化版本,实际使用时需要修改 backbone
        """
        # 将时间维度视为 batch 维度处理
        batch, channels, mel_bins, time_frames = mel_spec.shape

        # Reshape: (batch * time_frames, channels, mel_bins, 1)
        mel_spec_reshaped = mel_spec.permute(0, 3, 1, 2).reshape(
            batch * time_frames, channels, mel_bins, 1
        )

        # 通过 backbone(需要对输入维度进行调整)
        # 这里简化为直接使用全局特征
        features = self.backbone(mel_spec_reshaped)  # (batch * time_frames, feature_dim)

        # Reshape 回 (batch, time_frames, feature_dim)
        features = features.reshape(batch, time_frames, -1)

        return features

class MultiScaleSEDModel(nn.Module):
    """
    多尺度 SED 模型

    结合短片段(5秒)和长片段(10秒)预测
    """
    def __init__(self, num_classes=152, short_duration=5, long_duration=10):
        super().__init__()

        self.num_classes = num_classes

        # 短片段模型(5秒)
        self.short_model = SEDModel(
            num_classes=num_classes,
            window_size=short_duration
        )

        # 长片段模型(10秒)
        self.long_model = SEDModel(
            num_classes=num_classes,
            window_size=long_duration
        )

    def forward(self, waveform_short, waveform_long, use_and_rule=True):
        """
        Args:
            waveform_short: 5秒音频 (batch, 5 * sample_rate)
            waveform_long: 10秒音频 (batch, 10 * sample_rate)
            use_and_rule: 是否使用 AND 规则

        Returns:
            output: (batch, num_classes)
        """
        # 短片段预测
        output_short = self.short_model(waveform_short)  # (batch, num_classes)
        prob_short = torch.sigmoid(output_short)

        # 长片段预测
        output_long = self.long_model(waveform_long)  # (batch, num_classes)
        prob_long = torch.sigmoid(output_long)

        if use_and_rule:
            # AND 规则:两者都为正才认为存在
            prob_final = prob_short * prob_long
        else:
            # OR 规则:任一为正就认为存在
            prob_final = torch.clamp(prob_short + prob_long, 0, 1)

        return prob_final

# 使用示例
model = MultiScaleSEDModel(num_classes=152, short_duration=5, long_duration=10)

# 短片段和长片段
waveform_short = torch.randn(4, 5 * 32000)  # 4 samples, 5 seconds
waveform_long = torch.randn(4, 10 * 32000)   # 4 samples, 10 seconds

# 预测
with torch.no_grad():
    prob = model(waveform_short, waveform_long, use_and_rule=True)
print(prob.shape)  # (4, 152)
```

#### TTA(Test Time Augmentation)
```python
import torch
import numpy as np

def predict_with_tta(model, audio_path, window_size=5, tta_shifts=[0, 1, 2],
                     sample_rate=32000, device='cuda'):
    """
    使用 TTA 进行推理

    Args:
        model: 训练好的模型
        audio_path: 音频文件路径
        window_size: 窗口大小(秒)
        tta_shifts: TTA 偏移量(秒)
        sample_rate: 采样率
        device: 设备

    Returns:
        predictions: (num_windows, num_classes) TTA 平均后的预测
    """
    model.eval()

    # 加载音频
    waveform, sr = torchaudio.load(audio_path)
    if sr != sample_rate:
        resampler = torchaudio.transforms.Resample(sr, sample_rate)
        waveform = resampler(waveform)

    waveform = waveform.mean(dim=0, keepdim=True)  # 单声道

    window_samples = int(window_size * sample_rate)

    # 存储所有 TTA 预测
    all_tta_predictions = []

    for shift in tta_shifts:
        shift_samples = int(shift * sample_rate)

        # 计算起始位置
        start_positions = list(range(shift_samples, waveform.shape[1] - window_samples + 1,
                                    int(window_size * sample_rate)))

        predictions = []

        with torch.no_grad():
            for start in start_positions:
                end = start + window_samples
                window = waveform[:, start:end].to(device)

                # 预测
                logits = model(window)
                probs = torch.sigmoid(logits).cpu().numpy()
                predictions.append(probs[0])

        predictions = np.array(predictions)
        all_tta_predictions.append(predictions)

    # TTA 平均
    all_tta_predictions = np.array(all_tta_predictions)  # (num_shifts, num_windows, num_classes)

    # 对齐并平均
    avg_predictions = np.mean(all_tta_predictions, axis=0)

    return avg_predictions

# 使用示例
model = SEDModel(num_classes=152)
model = model.to(device)
model.load_state_dict(torch.load('best_model.pth'))

audio_path = 'test_soundscape.wav'
predictions = predict_with_tta(
    model, audio_path, window_size=5, tta_shifts=[0, 1, 2], device=device
)

# 二值化
threshold = 0.5
binary_pred = (predictions > threshold).astype(int)
```

#### AND 规则后处理
```python
import numpy as np

def and_rule_post_process(short_pred, long_pred, threshold=0.5):
    """
    AND 规则后处理

    Args:
        short_pred: 短片段预测 (num_windows_short, num_classes)
        long_pred: 长片段预测 (num_windows_long, num_classes)
        threshold: 二值化阈值

    Returns:
        final_pred: AND 规则后的预测 (num_windows_short, num_classes)
    """
    # 二值化
    binary_short = (short_pred > threshold).astype(int)
    binary_long = (long_pred > threshold).astype(int)

    # 长片段预测需要对应到短片段的时间位置
    # 假设长片段是短片段的两倍长度
    scale_factor = len(short_pred) / len(long_pred)

    final_pred = np.zeros_like(binary_short)

    for i in range(len(short_pred)):
        # 找到对应的长片段索引
        long_idx = int(i / scale_factor)

        if long_idx < len(binary_long):
            # AND 规则:两者都为 1 才认为存在
            final_pred[i] = binary_short[i] & binary_long[long_idx]
        else:
            # 没有对应的长片段预测,使用短片段预测
            final_pred[i] = binary_short[i]

    return final_pred

# 使用示例
# 短片段预测(5秒窗口)
short_pred = np.random.rand(100, 152)  # 100 个窗口,152 个类别

# 长片段预测(10秒窗口)
long_pred = np.random.rand(50, 152)  # 50 个窗口

# 应用 AND 规则
final_pred = and_rule_post_process(short_pred, long_pred, threshold=0.5)
```

#### 模型集成
```python
import torch
import numpy as np

class EnsembleModel:
    """
    模型集成类
    """
    def __init__(self, models, weights=None, device='cuda'):
        """
        Args:
            models: 模型列表
            weights: 模型权重(可选),默认平均
            device: 设备
        """
        self.models = models
        self.device = device

        if weights is None:
            # 默认等权重
            self.weights = [1.0 / len(models)] * len(models)
        else:
            # 归一化权重
            total = sum(weights)
            self.weights = [w / total for w in weights]

        # 将模型移到设备并设置为评估模式
        for model in self.models:
            model.to(device)
            model.eval()

    def predict(self, waveform):
        """
        集成预测

        Args:
            waveform: 输入音频 (batch, time_samples)

        Returns:
            ensemble_pred: 集成后的预测 (batch, num_classes)
        """
        all_predictions = []

        with torch.no_grad():
            for model in self.models:
                logits = model(waveform)
                probs = torch.sigmoid(logits).cpu().numpy()
                all_predictions.append(probs)

        all_predictions = np.array(all_predictions)  # (num_models, batch, num_classes)

        # 加权平均
        ensemble_pred = np.zeros_like(all_predictions[0])
        for i, pred in enumerate(all_predictions):
            ensemble_pred += self.weights[i] * pred

        return ensemble_pred

    def predict_from_files(self, model_paths, ModelClass, model_kwargs, waveform):
        """
        从文件加载模型并预测

        Args:
            model_paths: 模型文件路径列表
            ModelClass: 模型类
            model_kwargs: 模型初始化参数
            waveform: 输入音频

        Returns:
            ensemble_pred: 集成后的预测
        """
        all_predictions = []

        for path in model_paths:
            # 加载模型
            model = ModelClass(**model_kwargs)
            model.load_state_dict(torch.load(path))
            model.to(self.device)
            model.eval()

            # 预测
            with torch.no_grad():
                logits = model(waveform)
                probs = torch.sigmoid(logits).cpu().numpy()
                all_predictions.append(probs)

        all_predictions = np.array(all_predictions)

        # 加权平均
        ensemble_pred = np.zeros_like(all_predictions[0])
        for i, pred in enumerate(all_predictions):
            ensemble_pred += self.weights[i] * pred

        return ensemble_pred

# 使用示例
# 假设有 7 个模型
models = [
    SEDModel(num_classes=152, backbone='resnet50'),
    SEDModel(num_classes=152, backbone='resnest50'),
    SEDModel(num_classes=152, backbone='efficientnet_b0'),
    # ... 更多模型
]

# 加载权重
for i, model in enumerate(models):
    model.load_state_dict(torch.load(f'model_{i}.pth'))

# 创建集成
ensemble = EnsembleModel(models, weights=None, device=device)

# 预测
waveform = torch.randn(4, 5 * 32000).to(device)
predictions = ensemble.predict(waveform)
print(predictions.shape)  # (4, 152)
```

#### BirdNet/Perch 模型使用
```python
"""
BirdNet 和 Perch 是预训练的鸟类音频分类模型

使用前需要:
1. 安装 birdnetlib 或 perch 库
2. 下载预训练权重

这里提供一个简化接口示例
"""

class BirdNetModel(nn.Module):
    """
    BirdNet 模型包装器

    实际使用时需要从官方仓库获取模型
    参考: https://github.com/BirdVox/birdnet-library
    """
    def __init__(self, num_classes=152, pretrained_path=None):
        super().__init__()

        # 这里应该是 BirdNet 的实际架构
        # 简化版本:使用 ResNet50
        import torchvision.models as models
        self.backbone = models.resnet50(pretrained=True)

        # 修改第一层接受 mel-spectrogram
        self.backbone.conv1 = nn.Conv2d(
            1, 64, kernel_size=7, stride=2, padding=3, bias=False
        )

        feature_dim = 2048

        # 分类头
        self.classifier = nn.Sequential(
            nn.Dropout(0.5),
            nn.Linear(feature_dim, num_classes)
        )

        # 加载预训练权重
        if pretrained_path is not None:
            self.load_pretrained(pretrained_path)

    def load_pretrained(self, path):
        """加载预训练权重"""
        state_dict = torch.load(path, map_location='cpu')

        # 过滤不兼容的键
        model_state = self.state_dict()
        pretrained_state = {
            k: v for k, v in state_dict.items()
            if k in model_state and v.shape == model_state[k].shape
        }

        model_state.update(pretrained_state)
        self.load_state_dict(model_state)
        print(f"Loaded pretrained weights from {path}")

    def forward(self, mel_spec):
        """
        Args:
            mel_spec: (batch, 1, mel_bins, time_frames)

        Returns:
            logits: (batch, num_classes)
        """
        features = self.backbone(mel_spec)
        logits = self.classifier(features)
        return logits

# 使用示例(需要实际的预训练权重)
# model = BirdNetModel(num_classes=152, pretrained_path='birdnet.pth')
# model.eval()
# with torch.no_grad():
#     logits = model(mel_spec)
#     probs = torch.sigmoid(logits)
```

### 最佳实践

1. **多尺度策略**:
   - 短片段(5秒)用于精确分类
   - 长片段(10-15秒)提高召回率
   - AND 规则减少误报(两个都为正才认为存在)
   - OR 规则提高召回(任一为正就认为存在)

2. **SED 框架**:
   - Framewise 输出提供时间分辨率
   - Max pooling over time 聚合
   - 注意力权重加权

3. **模型集成**:
   - 10-20 个模型集成是常态
   - 不同架构(ResNet, ResNeSt, EfficientNet)
   - 不同训练配置(fold, seed, 数据增强)
   - 加权平均或投票

4. **预训练模型利用**:
   - BirdNet:强大的鸟类分类预训练模型
   - Perch:轻量级版本(BirdNET-lite)
   - 迁移学习显著提升性能
   - 在目标任务上微调

5. **外部数据**:
   - BirdCLEF 2021 数据
   - 其他鸟类音频数据集
   - 预训练模型在大规模数据上训练

6. **TTA(Test Time Augmentation)**:
   - 时间偏移(1-2秒)
   - 多个预测平均
   - 提高稳定性

7. **后处理**:
   - 时间平滑
   - 最小持续时间过滤
   - 类别特定阈值
   - AND 规则结合短长片段

8. **常见陷阱**:
   - 忽视短片段和长片段的互补性
   - 过度依赖单一模型或架构
   - 集成权重未优化
   - 忘记使用 TTA
   - AND/OR 规则选择不当

---

## Rainforest Connection Species Audio Detection 2021

**竞赛背景:**
- **主办方**:Rainforest Connection (RFCx)
- **目标**:检测热带雨林录音中的鸟类和蛙类叫声(多标签音频检测)
- **应用场景**:生物多样性监测,生态系统保护,濒危物种追踪
- **数据集规模**:
  - 训练音频:约 2,000 段标注录音
  - 测试音频:约 200 段连续录音(soundscape)
  - 物种数量:24 种鸟类和蛙类
  - 采样率:48 kHz
- **评估指标**:LWLRAP (Label-Weighted Label-Ranking Average Precision)
- **最终排名**:
  - 1st Place: watercooled
  - 7th Place: Beluga & Peter
  - 11th Place: cpmp
  - 13th Place: Ryan Epp
  - 总参赛队伍:约 2,200+ 支

### 前排方案详细技术分析

#### 1st Place - Image Classification Approach (watercooled)

核心技巧:
- **Mel-Spectrogram as Images**:将 Mel 频谱视为图像
- **Pretrained Image Models**:使用预训练图像分类模型
- **Ensemble**:多模型集成
- **Temporal Pooling**:时间池化策略
- **Data Augmentation**:图像和音频增强
- **Post-processing**:后处理优化

实现细节:
- **模型架构**:
  - ResNet50/ResNeSt50(ImageNet 预训练)
  - EfficientNet-B3
  - 修改第一层接受单通道输入(Mel-spectrogram)
- **特征提取**:
  - Mel-spectrogram(128 Mel bins)
  - 对数幅度压缩
  - 时间维度:5 秒窗口
- **集成方法**:
  - 多个模型集成
  - 不同 checkpoint
  - 加权平均
- **后处理**:
  - 时间平滑
  - 阈值优化
  - 最小持续时间过滤

#### 7th Place - Strong Baseline with Ensemble (Beluga & Peter)

核心技巧:
- **ResNeSt50 Architecture**:ResNeSt-50 主干网络
- **Mel-Spectrogram Features**:Mel 频谱特征
- **5-fold Cross-Validation**:5 折交叉验证
- **Model Ensemble**:模型集成
- **Strong Data Augmentation**:强数据增强

实现细节:
- **模型选择**:
  - ResNeSt50(预训练)
  - EfficientNet-B3
  - DenseNet-121
- **增强策略**:
  - SpecAugment
  - Mixup
  - 背景噪声
  - 时间遮罩/频率遮罩

#### 11th Place - The 0.931 Magic Explained (cpmp)

核心技巧:
- **Image Classification Approach**:图像分类方法
- **High-Performance Architecture**:高性能架构
- **Optimized Preprocessing**:优化的预处理
- **LWLRAP-specific Optimization**:针对 LWLRAP 指标优化

实现细节:
- **关键发现**:
  - 优化的 Mel-spectrogram 参数
  - 特定的数据增强组合
  - 后处理技巧达到 0.931 分数

#### 13th Place - Mean Co-Teachers and Noisy Students (Ryan Epp)

核心技巧:
- **Mean Teacher**:均值教师模型
- **Co-Teaching**:协同教学
- **Noisy Student**:噪声学生策略
- **Semi-Supervised Learning**:半监督学习
- **Pseudo-labeling**:伪标签

实现细节:
- **半监督策略**:
  - 使用未标注数据
  - 伪标签迭代优化
  - Mean Teacher 平滑预测

### 关键技术点

1. **Mel-Spectrogram 作为图像**:
   - 将音频转换为 Mel-spectrogram
   - 使用图像分类模型(ResNet, EfficientNet)
   - 修改第一层接受单通道输入

2. **LWLRAP 指标**:
   - Label-Weighted Label-Ranking Average Precision
   - 需要优化预测的排序
   - 类别权重不平衡

3. **数据增强**:
   - SpecAugment(时间/频率遮罩)
   - Mixup
   - 背景噪声

4. **模型集成**:
   - 多架构集成
   - 不同 checkpoint
   - 加权平均

5. **后处理**:
   - 时间平滑
   - 阈值优化
   - 最小持续时间过滤

---

## AMP®-Parkinson's Disease Progression Prediction 2023

**注意**:此比赛主要使用蛋白质/多肽测量数据,属于**表格数据时序回归**任务,非传统的一维信号处理(如音频、EEG 等)。

**竞赛背景:**
- **主办方**:AMP (Accelerating Medicines Partnership)
- **目标**:预测帕金森病患者的 MDS-UPDRS 评分变化(时序回归)
- **应用场景**:帕金森病进展监测,药物效果评估
- **数据集规模**:
  - 患者数量:约 1,000+ 患者
  - 蛋白质/多肽测量:数百种蛋白质特征
  - 时间点:多个月份的访视数据
  - 访视记录:蛋白丰度数据 + 蛋白肽数据
- **评估指标**:SMAPE (Symmetric Mean Absolute Percentage Error)
- **最终排名**:
  - 1st Place: Connecting Dotts
  - 2nd Place: No Luck All Skill
  - 3rd Place: Hajime Tamura
  - 总参赛队伍:约 2,500+ 支

### 前排方案详细技术分析

#### 1st Place - Feature Engineering + Gradient Boosting (Connecting Dotts)

核心技巧:
- **Protein/Peptide Feature Engineering**:蛋白质/多肽特征工程
- **Gradient Boosting Models**:梯度提升模型
- **Ensemble**:多模型集成
- **Cross-Validation**:交叉验证
- **Clincal Knowledge Integration**:临床知识整合

实现细节:
- **特征工程**:
  - 蛋白质丰度统计特征
  - 时间变化特征
  - 蛋白质-蛋白质交互特征
  - 临床协变量整合
- **模型选择**:
  - XGBoost/LightGBM
  - CatBoost
  - 多个模型集成
- **训练策略**:
  - 5-fold 交叉验证
  - 特征选择
  - 超参数优化

#### 2nd Place - Strong Feature Engineering (No Luck All Skill)

核心技巧:
- **Advanced Feature Engineering**:高级特征工程
- **Protein Network Features**:蛋白质网络特征
- **Time-Series Features**:时序特征
- **Model Ensemble**:模型集成

实现细节:
- **特征类型**:
  - 蛋白质丰度基线
  - 时间变化趋势
  - 蛋白质-蛋白质相关性
  - 临床协变量

#### 3rd Place - Robust Modeling Approach (Hajime Tamura)

核心技巧:
- **Robust Feature Selection**:稳健特征选择
- **Gradient Boosting**:梯度提升
- **Ensemble Strategy**:集成策略

实现细节:
- **特征选择**:
  - 基于重要性的特征选择
  - 多重共线性处理
- **模型**:
  - XGBoost/LightGBM
  - 简单平均集成

### 关键技术点

1. **蛋白质数据特征**:
   - 蛋白质丰度(protein abundance)
   - 肽段数据(peptide data)
   - 时间序列变化
   - 临床协变量

2. **特征工程**:
   - 基线特征
   - 时间变化特征
   - 交互特征
   - 统计特征

3. **模型选择**:
   - Gradient Boosting (XGBoost, LightGBM, CatBoost)
   - 集成多个模型

4. **评估指标**:
   - SMAPE (Symmetric MAPE)
   - 需要处理零值和异常值

5. **验证策略**:
   - 按患者划分的交叉验证
   - 时间序列分割
   - 防止数据泄露
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 323kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 323kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 323kUpdated Claude CodeCodexVerifiedInstall