admin/BZJZ_Material

Fork 0

Files

admin 5f555bf342 first commit

2026-06-11 03:33:14 +08:00

156 KiB

Raw Blame History

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

数据特点：

类别不平衡：某些鸟类样本数 < 10，某些 > 1000
混合叫声：一个音频可能包含多种鸟类
背景噪声：风声、雨声、人声等环境噪声
未标注数据：大量未标注 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 关键创新

Statistics T 噪声过滤（1st Place）

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

Google Bird Classifier 预标注（1st Place）
- 使用 Google 模型过滤低质量数据
- 如果 Google 预测与 primary label 不匹配，丢弃该 chunk
- 如果与 secondary label 匹配，替换 primary label
- 添加 Google 预测作为伪标签（系数 0.05）
CE Loss + Sigmoid 推理（1st Place）
- 训练：CE Loss + Softmax（多分类问题）
- 推理：Sigmoid（多标签预测）
- 原因：数据大多只有 1-2 个标签，可视为多分类

Min() Ensemble（1st Place）

# 降低不确定预测
predictions = np.min([model1_pred, model2_pred, model3_pred], axis=0)

伪标签迭代训练（2nd Place）
- 3 次迭代循环
- 每次用新集成生成伪标签
- 25-45% 概率添加伪标签数据
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 + 自蒸馏

参考资料：

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 个物种

数据特点：

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

评估指标：

宏平均 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 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:

BirdCLEF+ 2025 - Multi-Taxonomic Sound Identification (2025) - 2026-01-22

Source: Kaggle Competition | 知乎 14个高分方案 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:

Code Templates

Statistics T 噪声过滤（BirdCLEF 2024 - 1st Place）

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

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 进行数据过滤和预标注：

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：

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，降低不确定预测：

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 技巧：

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 的伪标签迭代训练循环：

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）

# 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）

# 降低不确定预测，比 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）：

# 局部和全局时间/频率拉伸
# 通过调整图像大小实现
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	高精度要求

频率范围设置（关键）：

# 鸟类声音频率范围
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 方法）：

# 高低阈值筛选
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 预计算：

# 推理阶段预先计算所有 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 创新）：

# 使用相邻窗口预测的平均值
# 避免重复计算，提高推理效率

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 策略）：

# 识别稀有物种（样本数 < 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 系列	自蒸馏不同阶段

集成方法：

# 简单平均（最常用）
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 次呼吸（测试）
患者数量：数千个不同患者的肺部特征

数据特点：

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

评估指标：

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 (原始总结)

前排方案概述：

PID 控制器逆向流派（1st, 2nd, 4th Place）
- 利用测试集中 66% 数据遵循 PID 控制的规律
- 通过逆向 PID 公式直接预测压力
- 无需深度学习即可获得极好结果
深度学习流派（3rd, 6th, 14th Place）
- 使用 LSTM/Transformer 建模时序依赖
- 多任务学习预测压力和压力差
- 不依赖 PID 规律，更通用
混合流派（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

深度学习模型：

# 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

2nd Place - ambrosm

核心技巧：

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

实现细节：

PID 逆向公式：

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

3rd Place - Upstage

核心技巧：

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

实现细节：

模型架构：

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

多任务损失：

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

4th Place - Jun Koda

核心技巧：

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

实现细节：

核心发现：

# 吸气阶段（u_out = 0）
# u_in 与目标 pressure 呈线性关系
u_in = α * pressure_target + β

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

# 其中 τ = R * C（时间常数）

逆向求解：

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

6th Place - 0-0ggg

核心技巧：

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

实现细节：

模型架构：

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 时间编码

多任务训练：

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

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

核心技巧：

Multitask LSTM：同时预测压力和压力变化
Delta Pressure 辅助任务：关键创新
集成策略：多模型融合

实现细节：

多任务设计：

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

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

20th Place - hyeongchan-nikita / kozistr

核心技巧：

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

实现细节（kozistr）：

多任务损失：

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

Writeup：Kaggle Writeup

Code Templates (代码模板)

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

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 技巧)

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

特征工程模板

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）
控制信号与目标存在可逆向的关系

实现步骤：

分析控制规律：
- 绘制 u_in 与 pressure 的关系图
- 识别线性/非线性关系
- 分析不同阶段（吸气/呼气）的规律
拟合逆向函数：
- 使用优化方法拟合参数
- 添加物理约束（如参数 > 0）
- 分组拟合（不同 R, C 组合）
混合策略：
- 对 PID 控制样本使用逆向方法
- 对非 PID 样本使用深度学习
- 加权融合两种预测

注意事项：

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

多任务学习策略

辅助任务选择：

Delta Pressure：预测 P[t] - P[t-1]（最常用）
压力分类：同时预测压力范围（辅助回归）
阶段预测：预测吸气/呼气阶段（多任务）

损失权重调优：

# 网格搜索最佳权重
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：

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)

时间序列分割：

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

集成代码：

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	2025-01-22	EEG, 分类, CWT, Entmax, 2-Stage Training, KL-Divergence
Child Mind Institute - Detect Sleep States	2025-01-22	睡眠检测, 事件检测, 两阶段建模, 后处理优化, 多tolerance AP
Child Mind Institute - Detect Behavior with Sensor Data	2025-01-22	多模态时序, IMU+TOF+THM, 行为识别, 阶段感知Attention, 匈牙利算法
BirdCLEF 2024	2026-01-23	音频分类, 生物声学, Statistics T过滤, Google Classifier预标注, CE Loss, Sigmoid推理, Min Ensemble, Checkpoint Soup, 伪标签迭代, 120分钟推理限制
BirdCLEF+ 2025	2026-01-22	音频分类, 生物声学, Noisy Student, 自蒸馏, SED模型, 伪标签, Mel-Spectrogram, Soft AUC Loss, 90分钟推理限制
Google Brain - Ventilator Pressure Prediction	2026-01-23	时序回归, PID逆向, 多任务学习, Delta Pressure, LSTM+Transformer, MAE, 2,605队伍
Cornell Birdcall Identification (BirdCLEF 2020)	2026-01-23	音频分类, 生物声学, ResNeSt, Attention Pooling, Mel-Spectrogram, Weak Supervision, GAN伪标签, Ensemble, F1-Score, 1,390队伍
BirdCLEF 2021 - Birdcall Identification	2026-01-23	音频分类, 生物声学, PANNs, 弱监督, Mixup, SpecAugment, Attention Mechanism, F1-Score, 1,700队伍
BirdCLEF 2022 - Endangered Bird Sounds	2026-01-23	音频分类, 濒危物种, BirdNet, Perch, SED, 多尺度输入, AND规则, Framewise预测, F1-Score, 1,600队伍
Rainforest Connection Species Audio Detection 2021	2026-01-23	音频检测, 生物声学, LWLRAP, Mel-Spectrogram as Image, ResNeSt, EfficientNet, ImageNet预训练, 2,200队伍
AMP®-Parkinson's 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 实现：

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 特征提取

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 模型

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

数据增强

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)

训练循环

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

集成与后处理

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

最佳实践

音频预处理标准化：
- 统一采样率（32kHz 或 44.1kHz）
- 使用高质量的 Mel-spectrogram 参数（n_fft=2048, hop_length=512, n_mels=128）
- 对数幅度压缩（log 或 dB 转换）
模型选择：
- ResNeSt 表现最佳（split-attention 机制）
- 在 ImageNet 上预训练的模型迁移效果好
- Attention Pooling 优于 Global Average Pooling
数据增强策略：
- SpecAugment（时间/频率遮罩）是必需的
- Mixup 有助于提高泛化能力
- 添加背景噪声提高鲁棒性
- GAN 生成增强数据可以提升稀有类别性能
集成方法：
- 投票集成优于平均集成
- 设置最小投票数阈值（如 4 票）可减少误报
- 使用不同 checkpoint 和随机种子增加多样性
后处理优化：
- 时间平滑可以减少闪烁
- 移除短于阈值的检测
- 类别特定的阈值优化
验证策略：
- 使用 5-fold 交叉验证
- 仔细设计验证集以反映测试集分布
- 监控 micro-F1 分数
训练技巧：
- 使用 AdamW 优化器
- Cosine annealing 学习率调度
- Binary Cross-Entropy Loss
- Label smoothing 有助于正则化
常见陷阱：
- 避免过度拟合训练集的音频特征
- 注意类别不平衡问题
- 验证集和测试集可能有不同的分布
- 推理时间限制（如果有）需要考虑模型效率

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 模型加载和使用

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 数据增强

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()

弱监督训练（音频级别标签）

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秒滑动窗口推理

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)

最佳实践

弱监督学习策略：
- 使用注意力机制定位音频中的关键区域
- 多实例学习（MIL）框架处理音频级别标签
- 时序池化（Temporal Pooling）聚合时间维度信息
预训练模型利用：
- PANNs（AudioSet 预训练）是最流行的起点
- CNN14/CNN10 提供强大的基线特征
- 迁移学习显著提升性能
数据增强组合：
- SpecAugment（时间+频率遮罩）必需
- Mixup 是 BirdCLEF 2021 的关键技巧
- 背景噪声添加提高鲁棒性
- 组合多种增强效果最佳
训练技巧：
- 5-fold 交叉验证标准配置
- AdamW + Cosine 学习率
- Binary Cross-Entropy Loss
- Label Smoothing 有助于正则化
- 渐进式训练策略
推理策略：
- 5秒滑动窗口（与标注一致）
- 窗口间有重叠（2.5秒跳跃）
- 时间平滑减少闪烁
- 移除短于阈值的检测
集成方法：
- 多架构集成（ResNet, DenseNet, EfficientNet）
- 多 checkpoint 集成
- 不同增强配置增加多样性
- 加权平均或投票集成
后处理优化：
- 类别特定的阈值优化
- 时间平滑（移动平均或中值滤波）
- 最小持续时间过滤
- 基于验证集优化阈值
常见陷阱：
- 忽略弱监督的特殊性（无时间戳）
- 过度依赖单一模型
- 验证集和测试集分布不同
- 忘记时间平滑导致预测不稳定
- 阈值选择不当影响 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 输出）

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）

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 规则后处理

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)

模型集成

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 模型使用

"""
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)

最佳实践

多尺度策略：
- 短片段（5秒）用于精确分类
- 长片段（10-15秒）提高召回率
- AND 规则减少误报（两个都为正才认为存在）
- OR 规则提高召回（任一为正就认为存在）
SED 框架：
- Framewise 输出提供时间分辨率
- Max pooling over time 聚合
- 注意力权重加权
模型集成：
- 10-20 个模型集成是常态
- 不同架构（ResNet, ResNeSt, EfficientNet）
- 不同训练配置（fold, seed, 数据增强）
- 加权平均或投票
预训练模型利用：
- BirdNet：强大的鸟类分类预训练模型
- Perch：轻量级版本（BirdNET-lite）
- 迁移学习显著提升性能
- 在目标任务上微调
外部数据：
- BirdCLEF 2021 数据
- 其他鸟类音频数据集
- 预训练模型在大规模数据上训练
TTA（Test Time Augmentation）：
- 时间偏移（1-2秒）
- 多个预测平均
- 提高稳定性
后处理：
- 时间平滑
- 最小持续时间过滤
- 类别特定阈值
- AND 规则结合短长片段
常见陷阱：
- 忽视短片段和长片段的互补性
- 过度依赖单一模型或架构
- 集成权重未优化
- 忘记使用 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 平滑预测

关键技术点

Mel-Spectrogram 作为图像：
- 将音频转换为 Mel-spectrogram
- 使用图像分类模型（ResNet, EfficientNet）
- 修改第一层接受单通道输入
LWLRAP 指标：
- Label-Weighted Label-Ranking Average Precision
- 需要优化预测的排序
- 类别权重不平衡
数据增强：
- SpecAugment（时间/频率遮罩）
- Mixup
- 背景噪声
模型集成：
- 多架构集成
- 不同 checkpoint
- 加权平均
后处理：
- 时间平滑
- 阈值优化
- 最小持续时间过滤

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
- 简单平均集成

关键技术点

蛋白质数据特征：
- 蛋白质丰度（protein abundance）
- 肽段数据（peptide data）
- 时间序列变化
- 临床协变量
特征工程：
- 基线特征
- 时间变化特征
- 交互特征
- 统计特征
模型选择：
- Gradient Boosting (XGBoost, LightGBM, CatBoost)
- 集成多个模型
评估指标：
- SMAPE (Symmetric MAPE)
- 需要处理零值和异常值
验证策略：
- 按患者划分的交叉验证
- 时间序列分割
- 防止数据泄露

156 KiB Raw Blame History Unescape Escape

BirdCLEF 2024

BirdCLEF 2024 - Bird Sound Identification (2024)

前排方案详细技术分析

BirdCLEF 2024 关键创新

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

前排方案详细技术分析

Original Summaries

BirdCLEF 2024 - Bird Sound Identification (2024) - 2026-01-23

BirdCLEF+ 2025 - Multi-Taxonomic Sound Identification (2025) - 2026-01-22

Code Templates

Statistics T 噪声过滤（BirdCLEF 2024 - 1st Place）

Google Bird Classifier 预标注（BirdCLEF 2024 - 1st Place）

CE Loss + Sigmoid 推理（BirdCLEF 2024 - 1st Place）

Min() Ensemble（BirdCLEF 2024 - 1st Place）

Checkpoint Soup（BirdCLEF 2024 - 2nd Place）

伪标签迭代训练（BirdCLEF 2024 - 2nd Place）

音频分类竞赛的最佳实践（BirdCLEF 2024）

BirdCLEF 2024 前排方案共性技术

BirdCLEF 2024 独特技术（与 2025 不同）

BirdCLEF 2024 推理优化（120 分钟限制）

BirdCLEF 2024 数据处理最佳实践

BirdCLEF 2024 vs 2025：为何策略不同？

BirdCLEF 2024 常见陷阱

音频分类竞赛的最佳实践（BirdCLEF+ 2025）

BirdCLEF+ 2025 前排方案共性技术

Mel-Spectrogram 配置最佳实践

半监督学习最佳实践（伪标签）

推理优化最佳实践（90 分钟约束）

长尾分布处理最佳实践

模型集成最佳实践

常见陷阱和注意事项

Google Brain - Ventilator Pressure Prediction (2021)

Competition Brief (竞赛简介)

Original Summaries (原始总结)

前排方案详细技术分析

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

2nd Place - ambrosm

3rd Place - Upstage

4th Place - Jun Koda

6th Place - 0-0ggg

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

16th Place - player2-has-flatlined

20th Place - hyeongchan-nikita / kozistr

Code Templates (代码模板)

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

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

特征工程模板

Best Practices (最佳实践)

PID 控制器逆向策略

多任务学习策略

交叉验证策略

模型集成策略

常见陷阱和注意事项

Metadata

Cornell Birdcall Identification (BirdCLEF 2020)

前排方案详细技术分析

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

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

3rd Place - Simple yet Effective Approach (TheoViel)

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

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

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

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

17th Place - File-level Post-processing

代码模板

Mel-Spectrogram 特征提取

ResNeSt + Attention Pooling 模型

数据增强

训练循环

集成与后处理

最佳实践

BirdCLEF 2021 - Birdcall Identification

前排方案详细技术分析

1st Place - Weak Supervision with PANNs (DR)

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

3rd Place - Ensemble with Multiple Approaches (shiro)

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

5th Place - Dual Approach Blending (Kramarenko Vladislav)

6th-10th Place 概述

156 KiB

Raw Blame History