import live www.sillylaird.ca webrootHEADmain

1 files changed, 1860 insertions, 0 deletions

diff --git a/.agents/skills/kaggle-learner/references/knowledge/time-series/birdclef-2023.md b/.agents/skills/kaggle-learner/references/knowledge/time-series/birdclef-2023.md
new file mode 100644
index 0000000..003a556
--- /dev/null
+++ b/.agents/skills/kaggle-learner/references/knowledge/time-series/birdclef-2023.md
@@ -0,0 +1,1860 @@
+# BirdCLEF 2023
+> Last updated: 2026-01-25
+> Source count: 10+
+---
+
+### BirdCLEF 2023 - Bird Sound Identification (2023)
+
+**竞赛背景：**
+- **主办方**：Cornell Lab of Ornithology, LifeCLEF
+- **目标**：识别东非鸟类叫声，促进鸟类保护和生态监测
+- **应用场景**：自动化生物声学监测，替代人工识别
+- **社会意义**：大规模鸟类种群监测，生物多样性保护
+- **竞赛时间**：2023 年 3-5 月
+- **参赛队伍**：1,189 支团队
+
+**任务描述：**
+从肯尼亚 soundscape 音频中分类 264 种鸟类叫声：
+- **多标签分类**：一个音频可能包含多种鸟类
+- **评估指标**：**Macro-averaged ROC-AUC**（所有类别的平均）
+- 需要预测所有 264 个类别的概率
+- 提交格式：row_id × 264物种的概率矩阵
+
+**数据集规模：**
+- 训练数据：~20,000 个标注样本（5 秒片段）
+- 测试数据：未标注的 soundscape 音频（需 5 秒滑动窗口预测）
+- 音频长度：随机长度（5 秒到数分钟）
+- 采样率：通常为 32 kHz
+- 物种数量：264 种东非鸟类
+
+**数据特点：**
+1. **类别不平衡**：某些鸟类样本数 < 10，某些 > 1000
+2. **混合叫声**：一个音频可能包含多种鸟类
+3. **背景噪声**：风声、雨声、人声、昆虫声等环境噪声
+4. **未标注数据**：大量未标注 soundscape 可用于伪标签
+5. **领域偏移**：训练数据（哥伦比亚）与测试数据（肯尼亚）存在分布差异
+
+**竞赛约束：**
+- **推理限制**：仅 CPU，推理时间限制
+- 需要优化推理速度，不能使用太大模型
+- 提交文件大小限制
+
+**前排方案排名：**
+| 排名 | 团队/个人 | Private LB | 关键技术 |
+|------|----------|------------|----------|
+| **1st** | Volodymyr Sydorskyi | **0.76392** | Correct Data is All You Need - 数据清洗 + 外部数据 + 模型集成 |
+| **2nd** | Griffith | ~0.75+ | SED + CNN with 7 models ensemble |
+| **3rd** | ADSR | ~0.75 | SED with attention on Mel frequency bands |
+| **4th** | ATFujita | 0.74424 | Knowledge Distillation Is All You Need - 知识蒸馏 + Xeno-Canto |
+| **5th** | Yevhenii Maslov | ~0.74 | 外部数据 + 预训练 + 集成 |
+
+**技术演进（与后续版本对比）：**
+| 技术点 | BirdCLEF 2023 | BirdCLEF 2024 | BirdCLEF+ 2025 |
+|--------|---------------|---------------|-----------------|
+| **物种数量** | 264 种 | 182 种 | 206 种（多分类群）|
+| **外部数据** | Xeno-Canto 重要 | 不用外部数据更优 | Xeno-Canto 预训练重要 |
+| **模型架构** | EfficientNetV2 + SED | EfficientNet B0 + RegNetY | EfficientNet + ViT |
+| **损失函数** | BCE + FocalLoss | CE Loss | BCE Loss |
+| **伪标签** | 高低阈值筛选 | Google Classifier 预标注 | Noisy Student |
+| **推理优化** | PyTorch | OpenVINO | OpenVINO |
+
+---
+
+## Competition Brief（竞赛简介）
+
+### 竞赛概述
+
+BirdCLEF 2023 是 Kaggle 上举办的鸟类声音识别竞赛，目标是从东非肯尼亚的 soundscape 音频中自动识别鸟类物种。该竞赛是 BirdCLEF 系列的 2023 年版本，属于时序音频分类任务。
+
+### 关键挑战
+
+1. **长尾分布**：264 个物种的样本数量极不均衡
+2. **领域偏移**：训练数据与测试数据来自不同地区
+3. **背景噪声**：实际环境中的各种噪声干扰
+4. **弱监督学习**：大量未标注 soundscape 数据需要利用
+5. **计算限制**：CPU 推理限制，需要优化推理速度
+
+### 评估机制
+
+- **指标**：Macro-averaged ROC-AUC
+- **评估方式**：每个类别独立计算 AUC，然后取平均
+- **提交格式**：CSV 文件，包含 row_id 和 264 个物种的概率列
+- **后处理**：允许基于时间和空间一致性的后处理
+
+---
+
+## 前排方案详细技术分析
+
+### 1st Place - Volodymyr Sydorskyi (Volodymyr)
+
+**最终成绩**：0.76392（Private LB）
+
+**核心策略**：Correct Data is All You Need
+
+**关键技术**：
+
+1. **数据清洗和质量控制**
+   - 严格的音频质量筛选
+   - 基于信噪比的过滤
+   - 去除低质量标注样本
+   - 时间戳验证和清洗
+
+2. **外部数据策略**
+   - Xeno-Canto 数据集成
+   - 跨年度数据利用（2021/2022 竞赛数据）
+   - 领域自适应技术
+   - 数据重采样策略
+
+3. **模型架构**
+   - EfficientNetV2 系列作为 backbone
+   - SED (Sound Event Detection) 框架
+   - 多尺度特征提取
+   - 注意力机制集成
+
+4. **训练策略**
+   - 两阶段训练：预训练 + 微调
+   - Focal Loss 处理类别不平衡
+   - 混合精度训练
+   - 梯度累积
+
+5. **集成策略**
+   - 多模型集成（不同 backbone 和配置）
+   - Checkpoint averaging
+   - 时序平滑后处理
+   - 基于物种出现时间的后处理
+
+**实现细节**：
+- 使用 EfficientNetV2-s 和 EfficientNetV2-m
+- 7+ 模型集成
+- Mel-spectrogram 参数：n_mels=128, fmin=64, fmax=16000
+- 数据增强：SpecAugment + MixUp
+- 推理优化：ONNX + 多线程
+
+**代码仓库**：
+- GitHub: [VSydorskyy/BirdCLEF_2023_1st_place](https://github.com/VSydorskyy/BirdCLEF_2023_1st_place)
+- Kaggle Writeup: [1st place solution: Correct Data is All You Need](https://www.kaggle.com/competitions/birdclef-2023/writeups/volodymyr-1st-place-solution-correct-data-is-all-y)
+
+---
+
+### 2nd Place - Griffith
+
+**最终成绩**：~0.75+（Private LB）
+
+**核心策略**：SED + CNN with 7 models ensemble
+
+**关键技术**：
+
+1. **SED (Sound Event Detection) 框架**
+   - 基于 EfficientNetV2-s 的 SED 模型
+   - 强时间建模能力
+   - 音频事件检测与分类结合
+   - 时序一致性约束
+
+2. **7 模型集成策略**
+   - 不同 backbone：EfficientNetV2-s, ResNet, ConvNeXt
+   - 不同输入尺寸和配置
+   - 不同 Mel 参数组合
+   - 加权集成代替简单平均
+
+3. **数据增强**
+   - SpecAugment（时间/频率掩码）
+   - MixUp 数据混合
+   - 颜色噪声注入
+   - 音频速度和音调变化
+
+4. **损失函数**
+   - BCE Loss（Binary Cross Entropy）
+   - Focal Loss 处理类别不平衡
+   - Label Smoothing
+   - 辅助损失函数
+
+**实现细节**：
+- EfficientNetV2-s backbone
+- SED 框架 + 自定义 CNN
+- 7 个模型集成
+- Mel 参数：n_mels=128-256 不同配置
+- 数据增强：SpecAugment + MixUp + 颜色噪声
+- 推理优化：模型并行 + 批处理
+
+**代码仓库**：
+- GitHub: [LIHANG-HONG/birdclef2023-2nd-place-solution](https://github.com/LIHANG-HONG/birdclef2023-2nd-place-solution)
+- Kaggle Writeup: [2nd place solution: SED + CNN with 7 models ensemble](https://www.kaggle.com/competitions/birdclef-2023/writeups/griffith-2nd-place-solution-sed-cnn-with-7-models-)
+
+---
+
+### 3rd Place - ADSR
+
+**最终成绩**：~0.75（Private LB）
+
+**核心策略**：SED with attention on Mel frequency bands
+
+**关键技术**：
+
+1. **Mel 频域注意力机制**
+   - 在 Mel 频率维度上添加注意力
+   - 自适应频率加权
+   - 频带重要性学习
+   - 多尺度频谱分析
+
+2. **改进的 SED 框架**
+   - CNN + RNN 混合架构
+   - 双向 LSTM 时序建模
+   - CRF 层优化时序一致性
+   - 多任务学习
+
+3. **特征工程**
+   - 多尺度 Mel-spectrogram
+   - MFCC 特征
+   - 频谱对比度增强
+   - 时频域联合分析
+
+4. **训练策略**
+   - 课程学习（从简单到困难）
+   - 难样本挖掘
+   - 在线难样本挖掘（OHEM）
+   - 渐进式训练
+
+**实现细节**：
+- 改进的 SED 架构
+- Mel 频域注意力机制
+- 双向 LSTM 时序建模
+- 多任务学习框架
+- 课程学习策略
+
+**代码仓库**：
+- Kaggle Writeup: [3rd place solution: SED with attention on Mel frequency bands](https://www.kaggle.com/competitions/birdclef-2023/writeups/adsr-3rd-place-solution-sed-with-attention-on-mel-)
+
+---
+
+### 4th Place - ATFujita
+
+**最终成绩**：0.74424（Private LB）
+
+**核心策略**：Knowledge Distillation Is All You Need
+
+**关键技术**：
+
+1. **知识蒸馏（Knowledge Distillation）**
+   - 使用 Kaggle Models 的 bird-vocalization-classifier 作为教师模型
+   - 预计算教师模型预测
+   - 蒸馏损失：KL 散度 + 学生损失
+   - 温度参数调优
+
+2. **Xeno-Canto 数据集成**
+   - 收集额外 Xeno-Canto 数据
+   - 数据过滤和质量控制
+   - 领域自适应
+   - 数据重采样
+
+3. **预训练策略**
+   - 在 Xeno-Canto 上预训练
+   - 在竞赛数据上微调
+   - 渐进式解冻
+   - 学习率调度
+
+4. **集成策略**
+   - 4 个模型集成
+   - 不同 backbone
+   - Checkpoint averaging
+   - 时序平滑
+
+**实现细节**：
+- BaseModel + Knowledge Distillation
+- 4 个模型集成
+- Xeno-Canto 预训练
+- Mel 参数：n_mels=128, fmin=64, fmax=16000
+- 数据增强：标准 SpecAugment
+- 推理优化：模型量化
+
+**代码仓库**：
+- GitHub: [AtsunoriFujita/BirdCLEF-2023-Identify-bird-calls-in-soundscapes](https://github.com/AtsunoriFujita/BirdCLEF-2023-Identify-bird-calls-in-soundscapes)
+- Kaggle Writeup: [4th Place Solution: Knowledge Distillation Is All You Need](https://www.kaggle.com/competitions/birdclef-2023/writeups/atfujita-4th-place-solution-knowledge-distillation)
+
+**关键创新**：
+- 使用预训练的 bird-vocalization-classifier 作为教师模型
+- 蒸馏损失与标准损失的加权组合
+- 高效的伪标签生成
+- 领域自适应技术
+
+---
+
+### 5th Place - Yevhenii Maslov
+
+**最终成绩**：~0.74（Private LB）
+
+**核心策略**：外部数据 + 预训练 + 集成
+
+**关键技术**：
+
+1. **外部数据利用**
+   - 2023/2022/2021 竞赛数据
+   - Xeno-Canto 数据（2023 物种）
+   - 数据过滤和清洗
+   - 数据平衡策略
+
+2. **预训练和微调**
+   - 在外部数据上预训练
+   - 在竞赛数据上微调
+   - 分层学习率
+   - 渐进式训练
+
+3. **模型架构**
+   - EfficientNetV2 系列
+   - SED 框架
+   - 注意力机制
+   - 多尺度特征融合
+
+4. **推理优化**
+   - 模型量化（INT8）
+   - 多线程推理
+   - 批处理优化
+   - ONNX 导出
+
+**实现细节**：
+- EfficientNetV2 backbone
+- SED 框架
+- 外部数据预训练
+- 5+ 模型集成
+- Mel 参数：标准配置
+- 推理优化：量化 + 多线程
+
+**代码仓库**：
+- GitHub: [yevmaslov](https://github.com/yevmaslov)
+- Kaggle Writeup: [5th place solution](https://www.kaggle.com/competitions/birdclef-2023/writeups/yevhenii-maslov-5th-place-solution)
+
+---
+
+### 8th Place - FURU-NAG
+
+**最终成绩**：~0.73（Private LB）
+
+**核心策略**：Implementing Multimodal Data Augmentation Methods
+
+**关键技术**：
+
+1. **多模态数据增强**
+   - 波形级增强：音调变化、时间拉伸、噪声注入
+   - 频谱级增强：SpecAugment、频率掩码、时间掩码
+   - 混合增强：MixUp、CutMix
+   - 自适应增强策略
+
+2. **防止过拟合**
+   - 现实音频组合
+   - 增强强度调度
+   - 在线增强
+   - 增强多样性
+
+3. **预处理管道**
+   - 音频质量检查
+   - 噪声过滤
+   - 音频归一化
+   - 特征标准化
+
+**实现细节**：
+- 多模态数据增强管道
+- 防止过拟合的策略
+- 现实音频组合
+- 自适应增强
+
+**代码仓库**：
+- Kaggle Writeup: [8th Place Solution: Implementing Multimodal Data Augmentation Methods](https://www.kaggle.com/competitions/birdclef-2023/writeups/furu-nag-8th-place-solution-implementing-multimoda)
+
+---
+
+### 18th Place - SED with Attention
+
+**核心策略**：SED with attention
+
+**关键技术**：
+
+1. **注意力机制**
+   - 时间注意力
+   - 频率注意力
+   - 自注意力
+   - 交叉注意力
+
+2. **SED 框架改进**
+   - 改进的时序建模
+   - 多尺度特征提取
+   - 注意力加权
+   - 残差连接
+
+**代码仓库**：
+- Kaggle Writeup: [18th place solution: SED with attention](https://www.kaggle.com/competitions/birdclef-2023/writeups/18th-place-solution-sed-with-attention)
+
+---
+
+## Code Templates（代码模板）
+
+### 1. Mel-Spectrogram 特征提取
+
+```python
+import torch
+import torchaudio
+import torch.nn as nn
+import numpy as np
+import librosa
+
+class MelSpectrogramExtractor:
+    """BirdCLEF 2023 统一 Mel-Spectrogram 提取器"""
+
+    def __init__(
+        self,
+        sample_rate: int = 32000,
+        n_mels: int = 128,
+        n_fft: int = 2048,
+        hop_length: int = 512,
+        fmin: float = 64.0,
+        fmax: float = 16000.0,
+        power: float = 2.0,
+        normalize: bool = True,
+    ):
+        self.sample_rate = sample_rate
+        self.n_mels = n_mels
+        self.n_fft = n_fft
+        self.hop_length = hop_length
+        self.fmin = fmin
+        self.fmax = fmax
+
+        # 使用 torchaudio 的 MelSpectrogram
+        self.mel_transform = torchaudio.transforms.MelSpectrogram(
+            sample_rate=sample_rate,
+            n_fft=n_fft,
+            hop_length=hop_length,
+            n_mels=n_mels,
+            f_min=fmin,
+            f_max=fmax,
+            power=power,
+            normalized=normalize,
+        )
+
+    def extract(self, waveform: torch.Tensor) -> torch.Tensor:
+        """
+        提取 mel-spectrogram
+
+        Args:
+            waveform: (num_samples,) 或 (batch, num_samples)
+
+        Returns:
+            mel_spec: (n_mels, time) 或 (batch, n_mels, time)
+        """
+        if waveform.dim() == 1:
+            waveform = waveform.unsqueeze(0)
+
+        mel_spec = self.mel_transform(waveform)
+
+        # 转换为对数尺度
+        mel_spec = torch.log(mel_spec + 1e-9)
+
+        return mel_spec
+
+    def extract_fixed_length(
+        self, waveform: torch.Tensor, target_length: int
+    ) -> torch.Tensor:
+        """
+        提取固定长度的 mel-spectrogram（用于 5 秒音频）
+
+        Args:
+            waveform: (num_samples,)
+            target_length: 目标时间维度
+
+        Returns:
+            mel_spec: (n_mels, target_length)
+        """
+        mel_spec = self.extract(waveform).squeeze(0)
+
+        # 调整到固定长度
+        if mel_spec.shape[1] < target_length:
+            # 填充
+            pad_length = target_length - mel_spec.shape[1]
+            mel_spec = nn.functional.pad(mel_spec, (0, pad_length))
+        else:
+            # 裁剪（从中心）
+            start = (mel_spec.shape[1] - target_length) // 2
+            mel_spec = mel_spec[:, start:start + target_length]
+
+        return mel_spec
+
+
+# 常用配置（前排方案）
+CONFIGS = {
+    "config_128": {  # EfficientNetV2-s 标准
+        "n_mels": 128,
+        "n_fft": 2048,
+        "hop_length": 512,
+        "fmin": 64.0,
+        "fmax": 16000.0,
+    },
+    "config_256": {  # 高分辨率
+        "n_mels": 256,
+        "n_fft": 4096,
+        "hop_length": 1024,
+        "fmin": 64.0,
+        "fmax": 16000.0,
+    },
+}
+
+# 使用示例
+extractor = MelSpectrogramExtractor(**CONFIGS["config_128"])
+waveform, sr = torchaudio.load("audio.wav")
+if sr != 32000:
+    waveform = torchaudio.transforms.Resample(sr, 32000)(waveform)
+mel_spec = extractor.extract_fixed_length(waveform.squeeze(0), target_length=313)  # 5秒 -> 313帧
+```
+
+### 2. SED 模型架构（2nd Place 风格）
+
+```python
+import torch
+import torch.nn as nn
+import timm
+
+class SEDModel(nn.Module):
+    """
+    Sound Event Detection 模型
+    基于 2nd Place Griffith 的方案
+    """
+
+    def __init__(
+        self,
+        model_name: str = "tf_efficientnetv2_s",
+        num_classes: int = 264,
+        pretrained: bool = True,
+        in_channels: int = 1,
+        rnn_layers: int = 1,
+        rnn_hidden: int = 128,
+    ):
+        super().__init__()
+
+        # Backbone（EfficientNetV2）
+        self.backbone = timm.create_model(
+            model_name,
+            pretrained=pretrained,
+            in_chans=in_channels,
+            num_classes=0,  # 移除分类头
+            global_pool="",  # 移除全局池化
+        )
+
+        # 获取 backbone 特征维度
+        backbone_features = self.backbone.num_features
+
+        # RNN 层（时序建模）
+        self.rnn = nn.LSTM(
+            input_size=backbone_features,
+            hidden_size=rnn_hidden,
+            num_layers=rnn_layers,
+            batch_first=True,
+            bidirectional=True,
+        )
+
+        # 分类头
+        self.classifier = nn.Sequential(
+            nn.Linear(rnn_hidden * 2, rnn_hidden),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(rnn_hidden, num_classes),
+        )
+
+    def forward(self, x, return_segmentwise=False):
+        """
+        Args:
+            x: (batch, channels, n_mels, time)
+            return_segmentwise: 是否返回分段预测
+
+        Returns:
+            logits: (batch, num_classes) 或 (batch, time, num_classes)
+        """
+        batch_size = x.size(0)
+
+        # Backbone 特征提取
+        # (batch, channels, n_mels, time) -> (batch, features, time')
+        features = self.backbone(x)
+
+        # 转置为 (batch, time', features)
+        features = features.permute(0, 2, 1)
+
+        # RNN 时序建模
+        # (batch, time', features) -> (batch, time', rnn_hidden * 2)
+        rnn_out, _ = self.rnn(features)
+
+        if return_segmentwise:
+            # 分段预测（每个时间步）
+            segmentwise_logits = self.classifier(rnn_out)
+            return segmentwise_logits
+        else:
+            # 全局预测（时间平均池化）
+            global_features = rnn_out.mean(dim=1)  # (batch, rnn_hidden * 2)
+            logits = self.classifier(global_features)
+            return logits
+
+
+# 使用示例
+model = SEDModel(
+    model_name="tf_efficientnetv2_s",
+    num_classes=264,
+    pretrained=True,
+    in_channels=1,
+    rnn_layers=1,
+    rnn_hidden=128,
+)
+
+# 前向传播
+mel_spec = torch.randn(4, 1, 128, 313)  # (batch, channels, n_mels, time)
+logits = model(mel_spec)  # (batch, 264)
+segmentwise_logits = model(mel_spec, return_segmentwise=True)  # (batch, time, 264)
+```
+
+### 3. 带 Mel 频域注意力的 SED 模型（3rd Place 风格）
+
+```python
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import timm
+
+class MelFrequencyAttention(nn.Module):
+    """Mel 频域注意力机制（3rd Place ADSR）"""
+
+    def __init__(self, n_mels: int, reduction: int = 8):
+        super().__init__()
+        self.avg_pool = nn.AdaptiveAvgPool2d(1)
+        self.max_pool = nn.AdaptiveMaxPool2d(1)
+
+        self.fc = nn.Sequential(
+            nn.Linear(n_mels, n_mels // reduction, bias=False),
+            nn.ReLU(inplace=True),
+            nn.Linear(n_mels // reduction, n_mels, bias=False),
+        )
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        """
+        Args:
+            x: (batch, channels, n_mels, time)
+
+        Returns:
+            attention: (batch, channels, n_mels, 1)
+        """
+        # 全局平均池化和最大池化
+        avg_out = self.avg_pool(x).squeeze(-1).squeeze(-1)  # (batch, channels)
+        max_out = self.max_pool(x).squeeze(-1).squeeze(-1)  # (batch, channels)
+
+        # 通过 FC 层
+        avg_out = self.fc(avg_out)
+        max_out = self.fc(max_out)
+
+        # 合并并应用 sigmoid
+        attention = self.sigmoid(avg_out + max_out)
+        attention = attention.unsqueeze(-1).unsqueeze(-1)  # (batch, channels, n_mels, 1)
+
+        return attention
+
+
+class SEDWithMelAttention(nn.Module):
+    """带 Mel 频域注意力的 SED 模型"""
+
+    def __init__(
+        self,
+        model_name: str = "tf_efficientnetv2_s",
+        num_classes: int = 264,
+        pretrained: bool = True,
+        n_mels: int = 128,
+        rnn_hidden: int = 128,
+    ):
+        super().__init__()
+
+        # Backbone
+        self.backbone = timm.create_model(
+            model_name,
+            pretrained=pretrained,
+            in_chans=1,
+            num_classes=0,
+            global_pool="",
+        )
+
+        backbone_features = self.backbone.num_features
+
+        # Mel 频域注意力
+        self.mel_attention = MelFrequencyAttention(n_mels=n_mels)
+
+        # RNN 层
+        self.rnn = nn.LSTM(
+            input_size=backbone_features,
+            hidden_size=rnn_hidden,
+            num_layers=1,
+            batch_first=True,
+            bidirectional=True,
+        )
+
+        # 分类头
+        self.classifier = nn.Sequential(
+            nn.Linear(rnn_hidden * 2, rnn_hidden),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(rnn_hidden, num_classes),
+        )
+
+    def forward(self, x, return_segmentwise=False):
+        """
+        Args:
+            x: (batch, 1, n_mels, time)
+
+        Returns:
+            logits: (batch, num_classes)
+        """
+        # Backbone 特征
+        features = self.backbone(x)  # (batch, features, time')
+
+        # 应用 Mel 频域注意力
+        mel_att = self.mel_attention(features)  # (batch, features, n_mels, 1)
+        features = features * mel_att
+
+        # 转置
+        features = features.permute(0, 2, 1)  # (batch, time', features)
+
+        # RNN
+        rnn_out, _ = self.rnn(features)
+
+        if return_segmentwise:
+            segmentwise_logits = self.classifier(rnn_out)
+            return segmentwise_logits
+        else:
+            global_features = rnn_out.mean(dim=1)
+            logits = self.classifier(global_features)
+            return logits
+
+
+# 使用示例
+model = SEDWithMelAttention(
+    model_name="tf_efficientnetv2_s",
+    num_classes=264,
+    pretrained=True,
+    n_mels=128,
+    rnn_hidden=128,
+)
+```
+
+### 4. 数据增强（8th Place 风格）
+
+```python
+import torch
+import torchaudio
+import numpy as np
+
+class AudioAugmentation:
+    """多模态音频增强（8th Place FURU-NAG）"""
+
+    def __init__(
+        self,
+        sample_rate: int = 32000,
+        apply_prob: float = 0.5,
+    ):
+        self.sample_rate = sample_rate
+        self.apply_prob = apply_prob
+
+    def __call__(self, waveform: torch.Tensor) -> torch.Tensor:
+        """应用随机增强"""
+        if torch.rand(1).item() > self.apply_prob:
+            return waveform
+
+        # 随机选择增强方法
+        augmentations = [
+            self._pitch_shift,
+            self._time_stretch,
+            self._add_noise,
+            self._gain,
+        ]
+
+        np.random.shuffle(augmentations)
+
+        # 应用 1-2 种增强
+        num_augment = np.random.randint(1, 3)
+        for aug in augmentations[:num_augment]:
+            waveform = aug(waveform)
+
+        return waveform
+
+    def _pitch_shift(self, waveform: torch.Tensor) -> torch.Tensor:
+        """音调变化"""
+        if torch.rand(1).item() > 0.5:
+            return waveform
+
+        n_steps = np.random.uniform(-2, 2)  # 半音
+        waveform_np = waveform.numpy()
+
+        # 使用 librosa 进行音调变化
+        shifted = librosa.effects.pitch_shift(
+            waveform_np,
+            sr=self.sample_rate,
+            n_steps=n_steps,
+        )
+
+        return torch.from_numpy(shifted).float()
+
+    def _time_stretch(self, waveform: torch.Tensor) -> torch.Tensor:
+        """时间拉伸"""
+        if torch.rand(1).item() > 0.5:
+            return waveform
+
+        rate = np.random.uniform(0.8, 1.2)
+        waveform_np = waveform.numpy()
+
+        # 使用 librosa 进行时间拉伸
+        stretched = librosa.effects.time_stretch(
+            waveform_np,
+            rate=rate,
+        )
+
+        return torch.from_numpy(stretched).float()
+
+    def _add_noise(self, waveform: torch.Tensor) -> torch.Tensor:
+        """添加噪声"""
+        if torch.rand(1).item() > 0.5:
+            return waveform
+
+        snr = np.random.uniform(10, 30)  # 信噪比
+        noise = torch.randn_like(waveform)
+
+        # 计算噪声功率
+        signal_power = waveform.mean() ** 2
+        noise_power = noise.mean() ** 2
+
+        # 调整噪声功率
+        noise = noise * torch.sqrt(signal_power / (noise_power * (10 ** (snr / 10))))
+
+        return waveform + noise
+
+    def _gain(self, waveform: torch.Tensor) -> torch.Tensor:
+        """增益调整"""
+        if torch.rand(1).item() > 0.5:
+            return waveform
+
+        gain = np.random.uniform(0.8, 1.2)
+        return waveform * gain
+
+
+class SpecAugment:
+    """SpecAugment 增强（频谱增强）"""
+
+    def __init__(
+        self,
+        time_mask_param: int = 50,
+        freq_mask_param: int = 16,
+        num_time_masks: int = 2,
+        num_freq_masks: int = 2,
+        apply_prob: float = 0.5,
+    ):
+        self.time_mask_param = time_mask_param
+        self.freq_mask_param = freq_mask_param
+        self.num_time_masks = num_time_masks
+        self.num_freq_masks = num_freq_masks
+        self.apply_prob = apply_prob
+
+    def __call__(self, spec: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            spec: (channels, n_mels, time)
+
+        Returns:
+            augmented_spec: (channels, n_mels, time)
+        """
+        if torch.rand(1).item() > self.apply_prob:
+            return spec
+
+        # 时间掩码
+        for _ in range(self.num_time_masks):
+            t = np.random.randint(0, self.time_mask_param)
+            t0 = np.random.randint(0, max(1, spec.size(-1) - t))
+            spec[:, :, t0:t0 + t] = 0
+
+        # 频率掩码
+        for _ in range(self.num_freq_masks):
+            f = np.random.randint(0, self.freq_mask_param)
+            f0 = np.random.randint(0, max(1, spec.size(-2) - f))
+            spec[:, f0:f0 + f, :] = 0
+
+        return spec
+
+
+class MixUp:
+    """MixUp 数据增强"""
+
+    def __init__(self, alpha: float = 0.5, apply_prob: float = 0.5):
+        self.alpha = alpha
+        self.apply_prob = apply_prob
+
+    def __call__(
+        self,
+        mel_spec: torch.Tensor,
+        labels: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Args:
+            mel_spec: (batch, channels, n_mels, time)
+            labels: (batch, num_classes)
+
+        Returns:
+            mixed_mel, mixed_labels
+        """
+        if torch.rand(1).item() > self.apply_prob:
+            return mel_spec, labels
+
+        batch_size = mel_spec.size(0)
+
+        # 生成混合权重
+        lam = np.random.beta(self.alpha, self.alpha)
+
+        # 随机排列
+        index = torch.randperm(batch_size)
+
+        # 混合特征和标签
+        mixed_mel = lam * mel_spec + (1 - lam) * mel_spec[index]
+        mixed_labels = lam * labels + (1 - lam) * labels[index]
+
+        return mixed_mel, mixed_labels
+
+
+# 使用示例
+audio_aug = AudioAugmentation(sample_rate=32000, apply_prob=0.8)
+spec_aug = SpecAugment(
+    time_mask_param=50,
+    freq_mask_param=16,
+    num_time_masks=2,
+    num_freq_masks=2,
+    apply_prob=0.8,
+)
+mixup = MixUp(alpha=0.5, apply_prob=0.5)
+
+# 音频增强
+waveform = torchaudio.load("audio.wav")[0]
+augmented_waveform = audio_aug(waveform)
+
+# 频谱增强
+mel_spec = torch.randn(4, 1, 128, 313)
+augmented_spec = spec_aug(mel_spec)
+
+# MixUp
+labels = torch.randint(0, 2, (4, 264)).float()
+mixed_spec, mixed_labels = mixup(mel_spec, labels)
+```
+
+### 5. 损失函数
+
+```python
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class FocalLoss(nn.Module):
+    """Focal Loss（处理类别不平衡）"""
+
+    def __init__(
+        self,
+        alpha: float = 0.25,
+        gamma: float = 2.0,
+        reduction: str = "mean",
+    ):
+        super().__init__()
+        self.alpha = alpha
+        self.gamma = gamma
+        self.reduction = reduction
+
+    def forward(self, inputs: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            inputs: (batch, num_classes) - logits
+            targets: (batch, num_classes) - one-hot or multi-hot labels
+
+        Returns:
+            loss
+        """
+        bce_loss = F.binary_cross_entropy_with_logits(
+            inputs, targets, reduction="none"
+        )
+
+        pt = torch.exp(-bce_loss)
+        focal_loss = self.alpha * (1 - pt) ** self.gamma * bce_loss
+
+        if self.reduction == "mean":
+            return focal_loss.mean()
+        elif self.reduction == "sum":
+            return focal_loss.sum()
+        else:
+            return focal_loss
+
+
+class CombinedLoss(nn.Module):
+    """组合损失（BCE + Focal Loss）"""
+
+    def __init__(
+        self,
+        bce_weight: float = 0.5,
+        focal_weight: float = 0.5,
+        focal_alpha: float = 0.25,
+        focal_gamma: float = 2.0,
+        label_smoothing: float = 0.0,
+    ):
+        super().__init__()
+        self.bce_weight = bce_weight
+        self.focal_weight = focal_weight
+
+        self.focal_loss = FocalLoss(
+            alpha=focal_alpha,
+            gamma=focal_gamma,
+        )
+
+        self.label_smoothing = label_smoothing
+
+    def forward(
+        self,
+        inputs: torch.Tensor,
+        targets: torch.Tensor,
+    ) -> torch.Tensor:
+        """
+        Args:
+            inputs: (batch, num_classes) - logits
+            targets: (batch, num_classes) - multi-hot labels
+
+        Returns:
+            loss
+        """
+        # Label smoothing
+        if self.label_smoothing > 0:
+            targets = targets * (1 - self.label_smoothing) + \
+                      self.label_smoothing / targets.size(-1)
+
+        # BCE Loss
+        bce_loss = F.binary_cross_entropy_with_logits(inputs, targets)
+
+        # Focal Loss
+        focal_loss = self.focal_loss(inputs, targets)
+
+        # 组合
+        loss = self.bce_weight * bce_loss + self.focal_weight * focal_loss
+
+        return loss
+
+
+class KnowledgeDistillationLoss(nn.Module):
+    """知识蒸馏损失（4th Place）"""
+
+    def __init__(
+        self,
+        temperature: float = 4.0,
+        alpha: float = 0.7,  # 蒸馏损失权重
+    ):
+        super().__init__()
+        self.temperature = temperature
+        self.alpha = alpha
+
+    def forward(
+        self,
+        student_logits: torch.Tensor,
+        teacher_logits: torch.Tensor,
+        targets: torch.Tensor,
+    ) -> torch.Tensor:
+        """
+        Args:
+            student_logits: (batch, num_classes) - 学生模型预测
+            teacher_logits: (batch, num_classes) - 教师模型预测（预计算）
+            targets: (batch, num_classes) - 真实标签
+
+        Returns:
+            loss
+        """
+        # 蒸馏损失（KL 散度）
+        T = self.temperature
+
+        # Soft targets
+        soft_teacher = F.softmax(teacher_logits / T, dim=-1)
+        soft_student = F.log_softmax(student_logits / T, dim=-1)
+
+        distillation_loss = F.kl_div(
+            soft_student,
+            soft_teacher,
+            reduction="batchmean",
+        ) * (T ** 2)
+
+        # 学生损失（标准 BCE）
+        student_loss = F.binary_cross_entropy_with_logits(
+            student_logits,
+            targets,
+        )
+
+        # 组合
+        loss = self.alpha * distillation_loss + (1 - self.alpha) * student_loss
+
+        return loss
+
+
+# 使用示例
+criterion = CombinedLoss(
+    bce_weight=0.5,
+    focal_weight=0.5,
+    focal_alpha=0.25,
+    focal_gamma=2.0,
+    label_smoothing=0.1,
+)
+
+logits = torch.randn(4, 264)
+targets = torch.randint(0, 2, (4, 264)).float()
+
+loss = criterion(logits, targets)
+print(f"Combined Loss: {loss.item()}")
+
+# 知识蒸馏
+kd_criterion = KnowledgeDistillationLoss(
+    temperature=4.0,
+    alpha=0.7,
+)
+
+student_logits = torch.randn(4, 264)
+teacher_logits = torch.randn(4, 264)  # 预计算的教师预测
+
+kd_loss = kd_criterion(student_logits, teacher_logits, targets)
+print(f"KD Loss: {kd_loss.item()}")
+```
+
+---
+
+## Best Practices（最佳实践）
+
+### 1. 数据处理最佳实践
+
+#### 1.1 音频质量筛选（1st Place）
+
+```python
+import librosa
+import numpy as np
+
+def calculate_snr(audio: np.ndarray, sample_rate: int) -> float:
+    """计算信噪比（SNR）"""
+    # 使用能量计算 SNR
+    frame_length = 2048
+    frames = librosa.util.frame(audio, frame_length=frame_length, hop_length=512)
+
+    # 计算每帧能量
+    energies = np.mean(frames ** 2, axis=0)
+
+    # 信号能量：高能量帧
+    signal_energy = np.percentile(energies, 90)
+    # 噪声能量：低能量帧
+    noise_energy = np.percentile(energies, 10)
+
+    snr = 10 * np.log10(signal_energy / (noise_energy + 1e-9))
+    return snr
+
+def filter_audio_by_quality(
+    audio_path: str,
+    min_snr: float = 10.0,
+    max_duration: float = 60.0,
+) -> bool:
+    """根据质量筛选音频"""
+    try:
+        audio, sr = librosa.load(audio_path, sr=32000)
+
+        # 检查 SNR
+        snr = calculate_snr(audio, sr)
+        if snr < min_snr:
+            return False
+
+        # 检查时长
+        duration = len(audio) / sr
+        if duration > max_duration:
+            return False
+
+        # 检查是否静音
+        rms = librosa.feature.rms(y=audio)[0]
+        if np.mean(rms) < 0.01:
+            return False
+
+        return True
+
+    except Exception as e:
+        print(f"Error loading {audio_path}: {e}")
+        return False
+
+
+# 使用示例
+is_good_quality = filter_audio_by_quality("audio.wav", min_snr=10.0)
+```
+
+#### 1.2 外部数据集成（4th/5th Place）
+
+```python
+from pathlib import Path
+import pandas as pd
+
+def load_external_data(
+    data_dir: str,
+    species_list: list[str],
+    min_samples_per_species: int = 5,
+) -> pd.DataFrame:
+    """加载外部数据（Xeno-Canto）"""
+    data_dir = Path(data_dir)
+
+    all_records = []
+
+    for species in species_list:
+        species_dir = data_dir / species
+        if not species_dir.exists():
+            continue
+
+        audio_files = list(species_dir.glob("*.wav")) + \
+                      list(species_dir.glob("*.mp3"))
+
+        # 过滤样本数少的物种
+        if len(audio_files) < min_samples_per_species:
+            continue
+
+        for audio_file in audio_files:
+            all_records.append({
+                "filename": str(audio_file),
+                "species": species,
+                "source": "xeno_canto",
+            })
+
+    return pd.DataFrame(all_records)
+
+
+# 使用示例
+species_list = ["bird_a", "bird_b", "bird_c"]
+external_df = load_external_data(
+    "data/xeno_canto",
+    species_list,
+    min_samples_per_species=5,
+)
+```
+
+### 2. 训练策略最佳实践
+
+#### 2.1 两阶段训练（1st/4th Place）
+
+```python
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+
+def two_stage_training(
+    model: nn.Module,
+    train_loader_external: DataLoader,
+    train_loader_competition: DataLoader,
+    val_loader: DataLoader,
+    num_epochs_stage1: int = 10,
+    num_epochs_stage2: int = 20,
+    lr_stage1: float = 1e-3,
+    lr_stage2: float = 1e-4,
+):
+    """两阶段训练：外部数据预训练 + 竞赛数据微调"""
+
+    # Stage 1: 在外部数据上预训练
+    print("Stage 1: Pre-training on external data")
+    optimizer = torch.optim.AdamW(model.parameters(), lr=lr_stage1)
+    criterion = nn.BCEWithLogitsLoss()
+
+    for epoch in range(num_epochs_stage1):
+        model.train()
+        for batch in train_loader_external:
+            mel_spec = batch["mel_spec"].cuda()
+            labels = batch["labels"].cuda()
+
+            # 前向传播
+            logits = model(mel_spec)
+            loss = criterion(logits, labels)
+
+            # 反向传播
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+
+        # 验证
+        val_loss = validate(model, val_loader, criterion)
+        print(f"Epoch {epoch+1}/{num_epochs_stage1}, Val Loss: {val_loss:.4f}")
+
+    # Stage 2: 在竞赛数据上微调
+    print("Stage 2: Fine-tuning on competition data")
+    optimizer = torch.optim.AdamW(model.parameters(), lr=lr_stage2)
+
+    for epoch in range(num_epochs_stage2):
+        model.train()
+        for batch in train_loader_competition:
+            mel_spec = batch["mel_spec"].cuda()
+            labels = batch["labels"].cuda()
+
+            # 前向传播
+            logits = model(mel_spec)
+            loss = criterion(logits, labels)
+
+            # 反向传播
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+
+        # 验证
+        val_loss = validate(model, val_loader, criterion)
+        print(f"Epoch {epoch+1}/{num_epochs_stage2}, Val Loss: {val_loss:.4f}")
+
+    return model
+
+
+def validate(model: nn.Module, val_loader: DataLoader, criterion: nn.Module):
+    """验证"""
+    model.eval()
+    total_loss = 0
+
+    with torch.no_grad():
+        for batch in val_loader:
+            mel_spec = batch["mel_spec"].cuda()
+            labels = batch["labels"].cuda()
+
+            logits = model(mel_spec)
+            loss = criterion(logits, labels)
+
+            total_loss += loss.item()
+
+    return total_loss / len(val_loader)
+```
+
+#### 2.2 Checkpoint Averaging（2nd/4th Place）
+
+```python
+import torch
+from pathlib import Path
+
+def average_checkpoints(
+    checkpoint_paths: list[str],
+    output_path: str,
+):
+    """平均多个 checkpoint"""
+    # 加载所有 checkpoint
+    checkpoints = []
+    for path in checkpoint_paths:
+        ckpt = torch.load(path, map_location="cpu")
+        checkpoints.append(ckpt)
+
+    # 获取第一个 checkpoint 的结构
+    avg_state_dict = checkpoints[0]["model_state_dict"].copy()
+
+    # 计算平均
+    for key in avg_state_dict.keys():
+        tensors = [ckpt["model_state_dict"][key] for ckpt in checkpoints]
+        avg_state_dict[key] = torch.stack(tensors).mean(dim=0)
+
+    # 保存
+    torch.save({
+        "model_state_dict": avg_state_dict,
+        "epoch": sum([ckpt["epoch"] for ckpt in checkpoints]) // len(checkpoints),
+    }, output_path)
+
+    print(f"Averaged checkpoint saved to {output_path}")
+
+
+# 使用示例
+checkpoint_dir = Path("checkpoints")
+checkpoint_paths = [
+    str(checkpoint_dir / "model_epoch_13.pt"),
+    str(checkpoint_dir / "model_epoch_15.pt"),
+    str(checkpoint_dir / "model_epoch_17.pt"),
+    str(checkpoint_dir / "model_epoch_19.pt"),
+    str(checkpoint_dir / "model_epoch_20.pt"),
+]
+
+average_checkpoints(
+    checkpoint_paths,
+    "checkpoints/model_averaged.pt",
+)
+```
+
+### 3. 推理优化最佳实践
+
+#### 3.1 模型量化（5th Place）
+
+```python
+import torch
+import torch.nn as nn
+
+def quantize_model(
+    model: nn.Module,
+    calibration_loader: DataLoader,
+):
+    """量化模型到 INT8"""
+    # 动态量化
+    quantized_model = torch.quantization.quantize_dynamic(
+        model,
+        {nn.Linear, nn.Conv2d},
+        dtype=torch.qint8,
+    )
+
+    # 校准（静态量化需要）
+    # quantized_model.eval()
+    # with torch.no_grad():
+    #     for batch in calibration_loader:
+    #         _ = quantized_model(batch["mel_spec"])
+
+    return quantized_model
+
+
+# 使用示例
+quantized_model = quantize_model(model, val_loader)
+torch.save(quantized_model.state_dict(), "model_quantized.pt")
+```
+
+#### 3.2 ONNX 导出和优化
+
+```python
+import torch
+import torch.onnx
+import onnxruntime as ort
+
+def export_to_onnx(
+    model: nn.Module,
+    output_path: str,
+    input_shape: tuple = (1, 1, 128, 313),
+    opset_version: int = 13,
+):
+    """导出模型到 ONNX"""
+    model.eval()
+
+    # 创建示例输入
+    dummy_input = torch.randn(*input_shape)
+
+    # 导出
+    torch.onnx.export(
+        model,
+        dummy_input,
+        output_path,
+        opset_version=opset_version,
+        input_names=["mel_spec"],
+        output_names=["logits"],
+        dynamic_axes={
+            "mel_spec": {0: "batch_size"},
+            "logits": {0: "batch_size"},
+        },
+    )
+
+    print(f"Model exported to {output_path}")
+
+    # 优化 ONNX 模型
+    sess_options = ort.SessionOptions()
+    sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+
+    session = ort.InferenceSession(
+        output_path,
+        sess_options,
+        providers=["CPUExecutionProvider"],
+    )
+
+    return session
+
+
+# 使用示例
+onnx_session = export_to_onnx(
+    model,
+    "model.onnx",
+    input_shape=(1, 1, 128, 313),
+)
+
+# ONNX 推理
+def predict_onnx(session: ort.InferenceSession, mel_spec: np.ndarray):
+    """使用 ONNX Runtime 推理"""
+    inputs = {session.get_inputs()[0].name: mel_spec}
+    outputs = session.run(None, inputs)
+
+    return outputs[0]
+
+
+# 批量推理
+def batch_predict_onnx(
+    session: ort.InferenceSession,
+    mel_specs: np.ndarray,
+    batch_size: int = 32,
+):
+    """批量推理"""
+    predictions = []
+
+    for i in range(0, len(mel_specs), batch_size):
+        batch = mel_specs[i:i+batch_size]
+        batch_pred = predict_onnx(session, batch)
+        predictions.append(batch_pred)
+
+    return np.concatenate(predictions, axis=0)
+```
+
+### 4. 集成策略最佳实践
+
+#### 4.1 加权集成（2nd Place）
+
+```python
+import numpy as np
+from scipy.optimize import minimize
+
+def find_optimal_weights(
+    predictions: np.ndarray,
+    targets: np.ndarray,
+) -> np.ndarray:
+    """
+    找到最优集成权重
+
+    Args:
+        predictions: (num_models, num_samples, num_classes)
+        targets: (num_samples, num_classes)
+
+    Returns:
+        weights: (num_models,)
+    """
+    num_models = predictions.shape[0]
+
+    def objective(weights):
+        # 加权平均
+        weighted_pred = np.average(predictions, axis=0, weights=weights)
+        # 计算 AUC（简化版）
+        auc = compute_auc(weighted_pred, targets)
+        return -auc  # 最小化负 AUC
+
+    # 约束：权重和为 1
+    constraints = {"type": "eq", "fun": lambda w: np.sum(w) - 1}
+    bounds = [(0, 1) for _ in range(num_models)]
+
+    # 初始权重：平均
+    initial_weights = np.ones(num_models) / num_models
+
+    # 优化
+    result = minimize(
+        objective,
+        initial_weights,
+        method="SLSQP",
+        bounds=bounds,
+        constraints=constraints,
+    )
+
+    return result.x
+
+
+def compute_auc(predictions: np.ndarray, targets: np.ndarray) -> float:
+    """计算 AUC（简化版）"""
+    from sklearn.metrics import roc_auc_score
+    return roc_auc_score(targets, predictions, average="macro")
+
+
+# 使用示例
+# predictions: (num_models, num_samples, num_classes)
+predictions = np.random.rand(5, 1000, 264)
+targets = np.random.randint(0, 2, (1000, 264))
+
+optimal_weights = find_optimal_weights(predictions, targets)
+print(f"Optimal weights: {optimal_weights}")
+
+# 加权集成
+final_predictions = np.average(predictions, axis=0, weights=optimal_weights)
+```
+
+#### 4.2 Min/Max Ensemble（1st Place 风格）
+
+```python
+import numpy as np
+
+def min_ensemble(predictions: np.ndarray) -> np.ndarray:
+    """
+    Min 集成（降低不确定预测）
+
+    Args:
+        predictions: (num_models, num_samples, num_classes)
+
+    Returns:
+        ensemble: (num_samples, num_classes)
+    """
+    return np.min(predictions, axis=0)
+
+
+def max_ensemble(predictions: np.ndarray) -> np.ndarray:
+    """
+    Max 集成（增强高置信预测）
+
+    Args:
+        predictions: (num_models, num_samples, num_classes)
+
+    Returns:
+        ensemble: (num_samples, num_classes)
+    """
+    return np.max(predictions, axis=0)
+
+
+def rank_ensemble(
+    predictions: np.ndarray,
+    method: str = "geometric",
+) -> np.ndarray:
+    """
+    Rank 集成（基于排名的集成）
+
+    Args:
+        predictions: (num_models, num_samples, num_classes)
+        method: "geometric" or "arithmetic"
+
+    Returns:
+        ensemble: (num_samples, num_classes)
+    """
+    # 计算排名
+    ranks = np.zeros_like(predictions)
+    for i in range(predictions.shape[0]):
+        ranks[i] = scipy.stats.rankdata(predictions[i], axis=-1)
+
+    # 平均排名
+    if method == "geometric":
+        avg_ranks = np.exp(np.mean(np.log(ranks + 1), axis=0)) - 1
+    else:  # arithmetic
+        avg_ranks = np.mean(ranks, axis=0)
+
+    # 将排名转回概率
+    ensemble = avg_ranks / avg_ranks.sum(axis=-1, keepdims=True)
+
+    return ensemble
+
+
+# 使用示例
+predictions = np.random.rand(5, 1000, 264)
+
+min_pred = min_ensemble(predictions)
+max_pred = max_ensemble(predictions)
+rank_pred = rank_ensemble(predictions, method="geometric")
+```
+
+### 5. 后处理最佳实践
+
+#### 5.1 时序平滑（2nd/3rd Place）
+
+```python
+import numpy as np
+from scipy.ndimage import gaussian_filter1d
+
+def temporal_smoothing(
+    predictions: np.ndarray,
+    sigma: float = 1.0,
+) -> np.ndarray:
+    """
+    时序平滑（高斯滤波）
+
+    Args:
+        predictions: (num_samples, num_classes) - 按时间排序
+        sigma: 高斯核标准差
+
+    Returns:
+        smoothed: (num_samples, num_classes)
+    """
+    smoothed = np.zeros_like(predictions)
+
+    for i in range(predictions.shape[1]):
+        smoothed[:, i] = gaussian_filter1d(predictions[:, i], sigma=sigma)
+
+    return smoothed
+
+
+def neighbor_window_smoothing(
+    predictions: np.ndarray,
+    window_size: int = 5,
+    neighbor_weight: float = 0.5,
+) -> np.ndarray:
+    """
+    邻居窗口平滑（2nd Place 风格）
+
+    Args:
+        predictions: (num_samples, num_classes)
+        window_size: 窗口大小（奇数）
+        neighbor_weight: 邻居权重
+
+    Returns:
+        smoothed: (num_samples, num_classes)
+    """
+    half_window = window_size // 2
+    smoothed = np.zeros_like(predictions)
+
+    for i in range(len(predictions)):
+        # 获取邻居窗口
+        start = max(0, i - half_window)
+        end = min(len(predictions), i + half_window + 1)
+
+        window = predictions[start:end]
+
+        # 中心样本权重为 1，邻居权重为 neighbor_weight
+        weights = np.ones(len(window))
+        weights[weights == 1] = neighbor_weight
+        weights[len(window) // 2] = 1.0
+
+        # 加权平均
+        smoothed[i] = np.average(window, axis=0, weights=weights)
+
+    return smoothed
+
+
+# 使用示例
+predictions = np.random.rand(100, 264)  # 100 个时间步
+
+smoothed_gaussian = temporal_smoothing(predictions, sigma=1.5)
+smoothed_neighbor = neighbor_window_smoothing(
+    predictions,
+    window_size=5,
+    neighbor_weight=0.5,
+)
+```
+
+#### 5.2 基于物种时间的后处理
+
+```python
+import numpy as np
+import pandas as pd
+
+def species_time_filtering(
+    predictions: pd.DataFrame,
+    time_info: pd.DataFrame,
+    species_activity: dict,
+) -> pd.DataFrame:
+    """
+    基于物种活动时间的后处理
+
+    Args:
+        predictions: (num_samples, num_species) - 包含 species columns
+        time_info: (num_samples,) - 包含 "time" column
+        species_activity: {species: {active_hours: [start, end]}}
+
+    Returns:
+        filtered_predictions
+    """
+    filtered = predictions.copy()
+
+    for species, activity in species_activity.items():
+        if species not in predictions.columns:
+            continue
+
+        active_hours = activity["active_hours"]  # [start, end]
+
+        # 获取小时
+        hours = pd.to_datetime(time_info["time"]).dt.hour
+
+        # 在非活跃时间降低预测
+        mask = (hours < active_hours[0]) | (hours > active_hours[1])
+        filtered.loc[mask, species] *= 0.5
+
+    return filtered
+
+
+# 使用示例
+predictions_df = pd.DataFrame({
+    "bird_a": np.random.rand(100),
+    "bird_b": np.random.rand(100),
+})
+
+time_info_df = pd.DataFrame({
+    "time": pd.date_range("2023-01-01 00:00", periods=100, freq="5min"),
+})
+
+species_activity = {
+    "bird_a": {"active_hours": [6, 18]},  # 6:00-18:00 活跃
+    "bird_b": {"active_hours": [18, 6]},  # 夜间活跃
+}
+
+filtered_predictions = species_time_filtering(
+    predictions_df,
+    time_info_df,
+    species_activity,
+)
+```
+
+---
+
+## 关键技术创新总结
+
+### BirdCLEF 2023 vs 2024 vs 2025 对比
+
+| 维度 | BirdCLEF 2023 | BirdCLEF 2024 | BirdCLEF+ 2025 |
+|------|---------------|---------------|----------------|
+| **物种数量** | 264 种 | 182 种 | 206 种（多分类群）|
+| **评估指标** | Macro AUC-ROC | AUC-ROC | Multi-Label AUC-ROC |
+| **外部数据** | Xeno-Canto 重要 | 不用外部数据 | Xeno-Canto 预训练重要 |
+| **模型架构** | EfficientNetV2 + SED | EfficientNet B0 + RegNetY | EfficientNet + ViT |
+| **损失函数** | BCE + FocalLoss | CE Loss | BCE Loss |
+| **伪标签** | 高低阈值筛选 | Google Classifier 预标注 | Noisy Student |
+| **推理优化** | PyTorch | OpenVINO | OpenVINO |
+| **关键创新** | 数据清洗 + 知识蒸馏 | Statistics T 过滤 | 自蒸馏 + 幂次变换 |
+
+### BirdCLEF 2023 独特创新
+
+1. **数据清洗（1st Place）**
+   - 严格的音频质量筛选
+   - 基于信噪比的过滤
+   - 时间戳验证
+
+2. **知识蒸馏（4th Place）**
+   - 使用预训练 bird-vocalization-classifier
+   - 蒸馏损失 + 学生损失
+   - 温度参数调优
+
+3. **Mel 频域注意力（3rd Place）**
+   - 自适应频率加权
+   - 多尺度频谱分析
+   - 频带重要性学习
+
+4. **多模态增强（8th Place）**
+   - 波形级增强
+   - 频谱级增强
+   - 现实音频组合
+
+---
+
+## 参考资料
+
+### Kaggle Writeups
+
+1. **[1st place solution: Correct Data is All You Need](https://www.kaggle.com/competitions/birdclef-2023/writeups/volodymyr-1st-place-solution-correct-data-is-all-y)** - Volodymyr Sydorskyi
+2. **[2nd place solution: SED + CNN with 7 models ensemble](https://www.kaggle.com/competitions/birdclef-2023/writeups/griffith-2nd-place-solution-sed-cnn-with-7-models-)** - Griffith
+3. **[3rd place solution: SED with attention on Mel frequency bands](https://www.kaggle.com/competitions/birdclef-2023/writeups/adsr-3rd-place-solution-sed-with-attention-on-mel-)** - ADSR
+4. **[4th Place Solution: Knowledge Distillation Is All You Need](https://www.kaggle.com/competitions/birdclef-2023/writeups/atfujita-4th-place-solution-knowledge-distillation)** - ATFujita
+5. **[5th place solution](https://www.kaggle.com/competitions/birdclef-2023/writeups/yevhenii-maslov-5th-place-solution)** - Yevhenii Maslov
+6. **[8th Place Solution: Implementing Multimodal Data Augmentation Methods](https://www.kaggle.com/competitions/birdclef-2023/writeups/furu-nag-8th-place-solution-implementing-multimoda)** - FURU-NAG
+7. **[18th place solution: SED with attention](https://www.kaggle.com/competitions/birdclef-2023/writeups/18th-place-solution-sed-with-attention)**
+
+### GitHub Repositories
+
+1. **[VSydorskyy/BirdCLEF_2023_1st_place](https://github.com/VSydorskyy/BirdCLEF_2023_1st_place)** - 1st Place 代码
+2. **[LIHANG-HONG/birdclef2023-2nd-place-solution](https://github.com/LIHANG-HONG/birdclef2023-2nd-place-solution)** - 2nd Place 代码
+3. **[AtsunoriFujita/BirdCLEF-2023-Identify-bird-calls-in-soundscapes](https://github.com/AtsunoriFujita/BirdCLEF-2023-Identify-bird-calls-in-soundscapes)** - 4th Place 代码
+4. **[yevmaslov](https://github.com/yevmaslov)** - 5th Place 代码
+
+### 学术论文
+
+1. **[Overview of BirdCLEF 2023: Automated Bird Species Identification in Eastern Africa](https://hal.science/hal-05182512/document)** - 竞赛概述
+2. **[Acoustic Bird Species Recognition at BirdCLEF 2023](https://ceur-ws.org/Vol-3497/paper-172.pdf)** - 2nd Place 学术论文
+3. **[Bird Species Recognition using Convolutional Neural Networks with Attention on Frequency Bands](https://www.researchgate.net/publication/389264675_Bird_Species_Recognition_using_Convolutional_Neural_Networks_with_Attention_on_Frequency_Bands)**
+
+### 技术博客
+
+1. **[(Kaggle) BirdCLEF 2023 - 24th (top 2%) place solution](https://kozistr.tech/2023-05-26-birdcelf-2023/)** - 24th Place 详细方案
+2. **[763rd Place Solution for the BirdCLEF 2023 Competition](https://www.kaggle.com/competitions/birdclef-2023/discussion/451041)** - 讨论帖
+
+### 其他资源
+
+1. **[Leaderboard - BirdCLEF 2023](https://www.kaggle.com/competitions/birdclef-2023/leaderboard)** - 最终排行榜
+2. **[BirdCLEF 2023 Competition Page](https://www.kaggle.com/competitions/birdclef-2023)** - 竞赛主页
+3. **[Xeno-canto Extended Metadata for BirdCLEF2023](https://www.kaggle.com/datasets/mariotsaberlin/xeno-canto-extended-metadata-for-birdclef2023)** - Xeno-Canto 扩展数据集
+
+---
+
+## 总结
+
+BirdCLEF 2023 是一个专注于东非鸟类声音识别的竞赛，其关键特点包括：
+
+1. **数据质量是关键**（1st Place）：严格的音频质量筛选比模型架构更重要
+2. **外部数据的战略使用**：Xeno-Canto 数据的合理集成和领域自适应
+3. **SED 框架的普及**：前排方案大多采用 SED（Sound Event Detection）框架
+4. **知识蒸馏的应用**（4th Place）：使用预训练模型作为教师提升性能
+5. **注意力机制的优化**（3rd Place）：Mel 频域注意力机制提升特征提取
+6. **多模态数据增强**（8th Place）：波形级和频谱级的联合增强
+
+**与后续版本的主要区别**：
+- BirdCLEF 2023 更依赖外部数据（Xeno-Canto）
+- BirdCLEF 2024 强调不使用外部数据，关注数据清洗
+- BirdCLEF+ 2025 扩展到多分类群（鸟类、两栖、哺乳、昆虫）
+
+**技术演进趋势**：
+- 从 EfficientNetV2 → EfficientNet B0/RegNetY
+- 从 BCE+Focal Loss → CE Loss → BCE Loss
+- 从伪标签高低阈值 → Google Classifier 预标注 → Noisy Student
+- 从 PyTorch 推理 → OpenVINO 优化