import live www.sillylaird.ca webrootHEADmain

1 files changed, 2312 insertions, 0 deletions

diff --git a/.agents/skills/kaggle-learner/references/knowledge/time-series/birdclef-plus-2025.md b/.agents/skills/kaggle-learner/references/knowledge/time-series/birdclef-plus-2025.md
new file mode 100644
index 0000000..b25b5b1
--- /dev/null
+++ b/.agents/skills/kaggle-learner/references/knowledge/time-series/birdclef-plus-2025.md
@@ -0,0 +1,2312 @@
+# BirdCLEF\+ 2025
+> Last updated: 2026-01-23
+> Source count: 1
+---
+
+### Mel-Spectrogram 特征提取（BirdCLEF+ 2025）
+
+基于前排方案，统一的 mel-spectrogram 提取流程：
+
+```python
+import torch
+import torchaudio
+import torch.nn as nn
+import numpy as np
+
+class MelSpectrogramExtractor:
+    """统一的 Mel-Spectrogram 提取器"""
+
+    def __init__(
+        self,
+        sample_rate: int = 32000,
+        n_mels: int = 128,
+        n_fft: int = 2048,
+        hop_length: int = 512,
+        fmin: float = 0.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": {  # tf_efficientnet 系列
+        "n_mels": 128,
+        "n_fft": 2048,
+        "hop_length": 512,
+        "fmin": 0.0,
+        "fmax": 16000.0,
+    },
+    "config_96": {  # 轻量级模型
+        "n_mels": 96,
+        "n_fft": 2048,
+        "hop_length": 512,
+        "fmin": 0.0,
+        "fmax": 16000.0,
+    },
+    "config_256": {  # 高分辨率
+        "n_mels": 256,
+        "n_fft": 4096,
+        "hop_length": 1024,
+        "fmin": 0.0,
+        "fmax": 16000.0,
+    },
+}
+
+# 使用示例
+extractor = MelSpectrogramExtractor(**CONFIGS["config_128"])
+waveform, sr = torchaudio.load("audio.wav")
+mel_spec = extractor.extract_fixed_length(waveform.squeeze(0), target_length=313)  # 5秒 -> 313帧
+```
+
+### 伪标签生成（BirdCLEF+ 2025）
+
+```python
+import torch
+import torch.nn as nn
+import numpy as np
+from pathlib import Path
+
+class PseudoLabelGenerator:
+    """伪标签生成器 - 基于前排方案"""
+
+    def __init__(
+        self,
+        model: nn.Module,
+        threshold: float = 0.4,
+        use_segmentwise: bool = True,
+        power_transform: float = 1.0,
+    ):
+        """
+        Args:
+            model: 训练好的模型
+            threshold: 置信度阈值（前排方案使用 0.3-0.5）
+            use_segmentwise: 是否使用 segmentwise_logit（更细粒度）
+            power_transform: 幂次变换参数（1st Place 使用）
+        """
+        self.model = model
+        self.model.eval()
+        self.threshold = threshold
+        self.use_segmentwise = use_segmentwise
+        self.power_transform = power_transform
+
+    @torch.no_grad()
+    def generate_pseudo_labels(
+        self,
+        audio_path: str,
+        segment_duration: int = 5,
+        overlap: float = 0.5,
+    ) -> list[dict]:
+        """
+        生成伪标签
+
+        Returns:
+            List of {"start": float, "end": float, "labels": np.ndarray}
+        """
+        # 加载音频
+        waveform, sr = torchaudio.load(audio_path)
+
+        # 分段处理
+        samples_per_segment = int(segment_duration * sr)
+        hop_length = int(samples_per_segment * (1 - overlap))
+
+        pseudo_labels = []
+
+        for start_idx in range(0, len(waveform) - samples_per_segment, hop_length):
+            end_idx = start_idx + samples_per_segment
+            segment = waveform[:, start_idx:end_idx]
+
+            # 提取特征
+            mel_spec = self.extract_mel(segment)
+
+            # 模型预测
+            if self.use_segmentwise:
+                # segmentwise_logit: 更细粒度的预测
+                logits = self.model(mel_spec, return_segmentwise=True)
+                # 时间维度平均
+                logits = logits.mean(dim=1)  # (batch, num_classes)
+            else:
+                logits = self.model(mel_spec)
+
+            # Sigmoid 激活
+            probs = torch.sigmoid(logits).squeeze(0).cpu().numpy()
+
+            # 幂次变换（1st Place 创新）
+            if self.power_transform != 1.0:
+                probs = np.power(probs, self.power_transform)
+
+            # 高低阈值筛选（10th Place 方法）
+            mask = self._apply_threshold(probs)
+
+            if mask.sum() > 0:
+                pseudo_labels.append({
+                    "start": start_idx / sr,
+                    "end": end_idx / sr,
+                    "labels": probs,
+                    "mask": mask,
+                })
+
+        return pseudo_labels
+
+    def _apply_threshold(self, probs: np.ndarray) -> np.ndarray:
+        """应用高低阈值筛选"""
+        # 高阈值：正样本
+        high_threshold = 0.7
+        # 低阈值：负样本
+        low_threshold = 0.3
+
+        mask = np.zeros_like(probs, dtype=bool)
+        mask[probs >= high_threshold] = True  # 高置信度正样本
+        mask[probs <= low_threshold] = True   # 低置信度负样本
+
+        return mask
+
+    def extract_mel(self, waveform: torch.Tensor) -> torch.Tensor:
+        """提取 mel-spectrogram（简化版本）"""
+        # 实际使用中应该与训练时的提取器一致
+        pass
+
+
+# 使用示例（前排方案风格）
+generator = PseudoLabelGenerator(
+    model=model,
+    threshold=0.4,
+    use_segmentwise=True,  # 6th Place 关键
+    power_transform=1.5,   # 1st Place 幂次变换
+)
+
+pseudo_labels = generator.generate_pseudo_labels("train_soundscape_01.wav")
+```
+
+### MixUp 数据增强（BirdCLEF+ 2025）
+
+```python
+import torch
+import torch.nn as nn
+import numpy as np
+
+class AudioMixUp:
+    """音频 MixUp 增强 - 前排方案风格"""
+
+    def __init__(
+        self,
+        alpha: float = 0.5,
+        mixup_type: str = "hard",  # "hard" 或 "soft"
+        probability: float = 0.5,
+    ):
+        """
+        Args:
+            alpha: Beta 分布参数
+            mixup_type:
+                - "soft": 标准混合标签（MixUp）
+                - "hard": 硬混合标签（8th Place 创新）
+            probability: 应用 MixUp 的概率
+        """
+        self.alpha = alpha
+        self.mixup_type = mixup_type
+        self.probability = probability
+
+    def __call__(
+        self,
+        batch: dict,
+    ) -> dict:
+        """
+        应用 MixUp
+
+        Args:
+            batch: {"mel": (B, C, H, W), "labels": (B, num_classes)}
+
+        Returns:
+            Mixed batch
+        """
+        if torch.rand(1).item() > self.probability:
+            return batch
+
+        mel = batch["mel"]
+        labels = batch["labels"]
+
+        batch_size = mel.size(0)
+
+        # 生成混合权重
+        lam = np.random.beta(self.alpha, self.alpha)
+
+        # 随机排列
+        index = torch.randperm(batch_size)
+
+        # 混合特征
+        mixed_mel = lam * mel + (1 - lam) * mel[index]
+
+        # 混合标签
+        if self.mixup_type == "soft":
+            # 标准 MixUp: 软标签混合
+            mixed_labels = lam * labels + (1 - lam) * labels[index]
+        elif self.mixup_type == "hard":
+            # 硬 MixUp (8th Place): 混合标签的最大值
+            mixed_labels = torch.maximum(labels, labels[index])
+        else:
+            raise ValueError(f"Unknown mixup_type: {self.mixup_type}")
+
+        return {
+            "mel": mixed_mel,
+            "labels": mixed_labels,
+            "lam": lam,  # 可能用于损失调整
+        }
+
+
+# Sumix 增强（13th Place 使用）
+class Sumix:
+    """Sumix: 原始信号上的 MixUp"""
+
+    def __init__(self, alpha: float = 0.5, probability: float = 1.0):
+        self.alpha = alpha
+        self.probability = probability
+
+    def __call__(
+        self,
+        waveform: torch.Tensor,
+        labels: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        在原始波形上应用 Sumix
+
+        Args:
+            waveform: (batch, num_samples)
+            labels: (batch, num_classes)
+
+        Returns:
+            Mixed waveform and labels
+        """
+        if torch.rand(1).item() > self.probability:
+            return waveform, labels
+
+        batch_size = waveform.size(0)
+        lam = np.random.beta(self.alpha, self.alpha)
+        index = torch.randperm(batch_size)
+
+        # 混合波形
+        mixed_waveform = lam * waveform + (1 - lam) * waveform[index]
+
+        # 混合标签（最大值）
+        mixed_labels = torch.maximum(labels, labels[index])
+
+        return mixed_waveform, mixed_labels
+
+
+# 使用示例
+mixup = AudioMixUp(alpha=0.5, mixup_type="hard", probability=0.5)
+sumix = Sumix(alpha=0.5, probability=1.0)
+
+# 训练循环中
+for batch in dataloader:
+    # Sumix 在原始波形
+    waveform, labels = sumix(batch["waveform"], batch["labels"])
+
+    # 提取 mel-spectrogram
+    mel = extract_mel(waveform)
+
+    # MixUp 在 mel-spectrogram
+    batch = mixup({"mel": mel, "labels": labels})
+```
+
+### Soft AUC Loss（BirdCLEF+ 2025 - 4th Place）
+
+支持软标签的 AUC 损失函数：
+
+```python
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class SoftAUCLoss(nn.Module):
+    """
+    Soft AUC Loss - 4th Place 创新
+
+    支持 soft labels，适用于知识蒸馏和半监督学习
+    """
+
+    def __init__(self, reduction: str = "mean"):
+        super().__init__()
+        self.reduction = reduction
+
+    def forward(
+        self,
+        predictions: torch.Tensor,
+        targets: torch.Tensor,
+    ) -> torch.Tensor:
+        """
+        Args:
+            predictions: (batch, num_classes) - 原始 logits
+            targets: (batch, num_classes) - 软标签 [0, 1]
+
+        Returns:
+            AUC loss
+        """
+        # Sigmoid 激活
+        probs = torch.sigmoid(predictions)
+
+        # 计算 AUC loss
+        # 对每个类别独立计算
+        num_classes = predictions.size(1)
+        losses = []
+
+        for c in range(num_classes):
+            # 当前类别的预测和目标
+            prob_c = probs[:, c]
+            target_c = targets[:, c]
+
+            # 按目标值排序（软标签）
+            sorted_indices = torch.argsort(target_c, descending=True)
+
+            # 计算正负样本的得分差异
+            # 对于软标签，我们需要加权处理
+            positive_scores = prob_c[sorted_indices[:len(sorted_indices)//2]]
+            negative_scores = prob_c[sorted_indices[len(sorted_indices)//2:]]
+
+            # AUC 近似：正样本得分应该高于负样本
+            # 使用 sigmoid 差异
+            diff = positive_scores.unsqueeze(1) - negative_scores.unsqueeze(0)
+            loss_c = torch.sigmoid(-diff).mean()
+
+            losses.append(loss_c)
+
+        losses = torch.stack(losses)
+
+        if self.reduction == "mean":
+            return losses.mean()
+        elif self.reduction == "sum":
+            return losses.sum()
+        else:
+            return losses
+
+
+# 改进的 AUC Loss（更稳定）
+class ImprovedAUCLoss(nn.Module):
+    """
+    改进的 AUC Loss - 更稳定且支持软标签
+    """
+
+    def __init__(self, margin: float = 1.0):
+        super().__init__()
+        self.margin = margin
+
+    def forward(
+        self,
+        predictions: torch.Tensor,
+        targets: torch.Tensor,
+    ) -> torch.Tensor:
+        """
+        Args:
+            predictions: (batch, num_classes)
+            targets: (batch, num_classes) - 软标签
+        """
+        probs = torch.sigmoid(predictions)
+        num_classes = predictions.size(1)
+
+        losses = []
+        for c in range(num_classes):
+            prob_c = probs[:, c]
+            target_c = targets[:, c]
+
+            # 计算成对损失
+            # 对于每个样本对 (i, j):
+            # 如果 target_i > target_j，则希望 prob_i > prob_j
+            n = prob_c.size(0)
+            if n < 2:
+                continue
+
+            # 创建样本对矩阵
+            target_diff = target_c.unsqueeze(1) - target_c.unsqueeze(0)
+            prob_diff = prob_c.unsqueeze(1) - prob_c.unsqueeze(0)
+
+            # 只考虑 target_i > target_j 的对
+            mask = target_diff > 0
+
+            if mask.sum() > 0:
+                # Hinge loss: max(0, margin - (prob_i - prob_j))
+                loss_c = F.relu(self.margin - prob_diff)[mask].mean()
+                losses.append(loss_c)
+
+        if len(losses) == 0:
+            return torch.tensor(0.0, device=predictions.device)
+
+        return torch.stack(losses).mean()
+
+
+# 使用示例
+criterion = SoftAUCLoss(reduction="mean")
+
+# 训练循环
+for batch in dataloader:
+    predictions = model(batch["mel"])
+
+    # 支持软标签
+    loss = criterion(predictions, batch["labels"])
+
+    loss.backward()
+    optimizer.step()
+```
+
+### 滑动窗口推理（BirdCLEF+ 2025 - 1st Place）
+
+```python
+import torch
+import torch.nn as nn
+from scipy.ndimage import gaussian_filter1d
+
+class SlidingWindowInference:
+    """
+    滑动窗口推理 - 1st Place 创新
+
+    使用帧预测的平均值，而不是仅使用中心窗口的最大值
+    """
+
+    def __init__(
+        self,
+        model: nn.Module,
+        window_size: int = 5,  # 秒
+        hop_size: int = 5,     # 秒（步长）
+        sample_rate: int = 32000,
+        smoothing_sigma: float = 1.0,
+    ):
+        self.model = model
+        self.model.eval()
+        self.window_size = window_size
+        self.hop_size = hop_size
+        self.sample_rate = sample_rate
+        self.smoothing_sigma = smoothing_sigma
+
+    @torch.no_grad()
+    def predict(
+        self,
+        audio_path: str,
+    ) -> dict[str, float]:
+        """
+        对整个音频进行预测，返回 5 秒窗口的预测
+
+        Returns:
+            Dict of {row_id: {species_id: probability}}
+        """
+        # 加载音频
+        waveform, sr = torchaudio.load(audio_path)
+
+        # 计算窗口参数
+        samples_per_window = int(self.window_size * sr)
+        samples_per_hop = int(self.hop_size * sr)
+
+        # 存储所有帧预测
+        all_frame_predictions = []
+
+        # 滑动窗口
+        window_id = 0
+        for start_idx in range(0, len(waveform) - samples_per_window, samples_per_hop):
+            end_idx = start_idx + samples_per_window
+            window = waveform[:, start_idx:end_idx]
+
+            # 提取特征
+            mel_spec = self.extract_mel(window)
+
+            # 模型预测
+            frame_output = self.model(mel_spec)
+
+            # 如果是 SED 模型，可能有 clipwise 和 segmentwise 输出
+            if isinstance(frame_output, dict):
+                frame_pred = frame_output["clipwise_output"]
+            else:
+                frame_pred = frame_output
+
+            all_frame_predictions.append(frame_pred.cpu().numpy())
+
+            window_id += 1
+
+        # 转换为 numpy array
+        all_frame_predictions = np.array(all_frame_predictions)  # (num_windows, num_classes)
+
+        # 1st Place 创新: 相邻窗口帧预测平均
+        # 这是一种 1D 滑动窗口分割，类似于大图像的 2D 滑动窗口分割
+        smoothed_predictions = self._smooth_predictions(all_frame_predictions)
+
+        # 生成最终预测
+        predictions = {}
+        for window_id in range(len(smoothed_predictions)):
+            row_id = f"soundscape_{window_id}_{self.window_size}"
+            predictions[row_id] = {
+                f"species_{i}": float(prob)
+                for i, prob in enumerate(smoothed_predictions[window_id])
+            }
+
+        return predictions
+
+    def _smooth_predictions(
+        self,
+        predictions: np.ndarray,
+    ) -> np.ndarray:
+        """
+        平滑预测 - 使用高斯滤波和时间平均
+
+        Args:
+            predictions: (num_windows, num_classes)
+
+        Returns:
+            Smoothed predictions
+        """
+        # 1. 时间维度高斯平滑
+        if self.smoothing_sigma > 0:
+            smoothed = gaussian_filter1d(
+                predictions,
+                sigma=self.smoothing_sigma,
+                axis=0,
+                mode="nearest",
+            )
+        else:
+            smoothed = predictions
+
+        # 2. 相邻窗口平均（1st Place 创新）
+        # 使用相邻 3 个窗口的平均
+        kernel_size = 3
+        if len(smoothed) >= kernel_size:
+            # Padding
+            padded = np.pad(
+                smoothed,
+                ((kernel_size // 2, kernel_size // 2), (0, 0)),
+                mode="edge",
+            )
+
+            # 一维卷积平均
+            kernel = np.ones(kernel_size) / kernel_size
+            averaged = np.zeros_like(smoothed)
+
+            for c in range(smoothed.shape[1]):
+                averaged[:, c] = np.convolve(
+                    padded[:, c],
+                    kernel,
+                    mode="valid",
+                )
+
+            return averaged
+        else:
+            return smoothed
+
+    def extract_mel(self, waveform: torch.Tensor) -> torch.Tensor:
+        """提取 mel-spectrogram"""
+        # 实际使用中应该与训练时的提取器一致
+        pass
+
+
+# 使用示例
+inference = SlidingWindowInference(
+    model=model,
+    window_size=5,
+    hop_size=5,
+    smoothing_sigma=1.0,
+)
+
+predictions = inference.predict("test_soundscape_01.wav")
+
+# 后处理（可选）
+# - Delta shift: 调整低置信度类别的概率
+# - Min-max 缩放
+# - 频率范围调整
+```
+
+### SED 模型架构（BirdCLEF+ 2025 标准）
+
+前排方案广泛使用的 SED (Sound Event Detection) 模型架构：
+
+```python
+import torch
+import torch.nn as nn
+import timm
+
+class SEDModel(nn.Module):
+    """
+    Sound Event Detection 模型
+
+    参考 BirdCLEF 2023 2nd Place 和 BirdCLEF+ 2025 前排方案
+    """
+
+    def __init__(
+        self,
+        backbone: str = "tf_efficientnetv2_s.in21k",
+        num_classes: int = 206,
+        in_channels: int = 1,
+        pretrained: bool = True,
+    ):
+        super().__init__()
+
+        self.num_classes = num_classes
+
+        # 使用 timm 的 EfficientNet 作为 backbone
+        self.backbone = timm.create_model(
+            backbone,
+            pretrained=pretrained,
+            in_chans=in_channels,
+            num_classes=0,  # 移除分类头
+        )
+
+        # 获取 backbone 输出特征维度
+        self.features_dim = self.backbone.num_features
+
+        # 自定义注意力块 (6th Place AttBlockV2)
+        self.att_block = AttBlockV2(
+            self.features_dim,
+            num_classes,
+            activation="sigmoid",
+        )
+
+    def forward(self, x, return_segmentwise=False):
+        """
+        Args:
+            x: (batch, in_channels, n_mels, time)
+            return_segmentwise: 是否返回 segmentwise_logit
+
+        Returns:
+            如果 return_segmentwise=False:
+                clipwise_output: (batch, num_classes)
+            如果 return_segmentwise=True:
+                dict with:
+                    clipwise_output: (batch, num_classes)
+                    segmentwise_output: (batch, num_classes, time_frames)
+        """
+        # Backbone 特征提取
+        features = self.backbone(x)  # (batch, features_dim, time_frames)
+
+        # 全局池化
+        pooled_features = features.mean(dim=[2])  # (batch, features_dim)
+
+        # 片级预测
+        clipwise_output = self.att_block(pooled_features)  # (batch, num_classes)
+
+        if not return_segmentwise:
+            return clipwise_output
+
+        # 帧级预测（用于伪标签生成）
+        segmentwise_output = self.att_block(features)  # (batch, num_classes, time_frames)
+
+        return {
+            "clipwise_output": clipwise_output,
+            "segmentwise_output": segmentwise_output,
+        }
+
+
+class AttBlockV2(nn.Module):
+    """
+    自定义注意力块 - 6th Place 创新
+
+    使用 softmax 和 tanh 进行归一化，结合非线性变换
+    """
+
+    def __init__(
+        self,
+        in_features: int,
+        out_features: int,
+        activation: str = "sigmoid",
+    ):
+        super().__init__()
+
+        self.activation = activation
+        self.att = nn.Conv1d(in_features, out_features, kernel_size=1)
+        self.cla = nn.Conv1d(in_features, out_features, kernel_size=1)
+
+        # 初始化权重（6th Place 关键）
+        self.apply(self._init_weights)
+
+    def _init_weights(self, m):
+        if isinstance(m, nn.Conv1d):
+            nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
+            if m.bias is not None:
+                nn.init.constant_(m.bias, 0)
+
+    def forward(self, x):
+        """
+        Args:
+            x: (batch, in_features, time_frames) 或 (batch, in_features)
+
+        Returns:
+            output: (batch, out_features) 或 (batch, out_features, time_frames)
+        """
+        if x.dim() == 2:
+            # 全局池化特征
+            x = x.unsqueeze(-1)  # (batch, in_features, 1)
+
+        # 注意力权重
+        att = self.att(x)
+        att = torch.softmax(att, dim=1)  # 时间维度归一化
+
+        # 分类特征
+        cla = self.cla(x)
+
+        # 加权求和
+        output = torch.clamp(torch.clamp((cla * att).sum(dim=-1), min=1e-7, max=1-1e-7), min=1e-7)
+
+        # 激活函数
+        if self.activation == "sigmoid":
+            output = torch.sigmoid(output)
+        elif self.activation == "none":
+            pass
+        else:
+            raise ValueError(f"Unknown activation: {self.activation}")
+
+        return output.squeeze(-1) if output.size(-1) == 1 else output
+
+
+# 常用 backbone 配置（前排方案）
+BACKBONES = {
+    "tf_efficientnetv2_s.in21k": {
+        "features_dim": 1280,
+        "description": "2nd Place 使用，平衡性能和速度",
+    },
+    "tf_efficientnetv2_b3.in21k": {
+        "features_dim": 1536,
+        "description": "6th Place 使用，更强性能",
+    },
+    "tf_efficientnetv2_m.in21k": {
+        "features_dim": 2048,
+        "description": "14th Place 使用，更高精度",
+    },
+    "eca_nfnet_l0": {
+        "features_dim": 2304,
+        "description": "2nd Place 使用，增加多样性",
+    },
+}
+
+# 使用示例
+model = SEDModel(
+    backbone="tf_efficientnetv2_s.in21k",
+    num_classes=206,
+    in_channels=1,
+    pretrained=True,
+)
+
+# 训练时：片级预测
+clipwise_output = model(mel_spec)
+loss = criterion(clipwise_output, labels)
+
+# 伪标签生成时：帧级预测
+output = model(mel_spec, return_segmentwise=True)
+segmentwise_logits = output["segmentwise_output"]  # (batch, 206, time_frames)
+segmentwise_probs = torch.sigmoid(segmentwise_logits)
+# 时间维度平均得到更稳定的伪标签
+avg_segmentwise_probs = segmentwise_probs.mean(dim=-1)  # (batch, 206)
+```
+
+### 前排方案详细技术分析
+
+#### 2nd Place - Xeno-Canto 预训练详细流程
+
+**作者**: Volodymyr Vialactea
+**核心创新**: 使用外部数据预训练 + 5秒音频片段训练
+
+**完整流程：**
+
+```python
+import torch
+import torchaudio
+import pandas as pd
+from pathlib import Path
+
+class XenoCantoPretraining:
+    """
+    2nd Place 方案：Xeno-Canto 预训练流程
+
+    关键点：
+    1. 下载额外的 Xeno-Canto 数据
+    2. 数据清洗和预处理
+    3. 预训练
+    4. 在主数据集上微调
+    """
+
+    def __init__(
+        self,
+        species_list: list,
+        target_sample_rate: int = 32000,
+        segment_duration: int = 5,
+    ):
+        self.species_list = species_list
+        self.target_sample_rate = target_sample_rate
+        self.segment_duration = segment_duration
+
+    def download_xeno_canto_data(self, output_dir: str = "data/xeno_canto"):
+        """
+        步骤 1: 从 Xeno-Canto 下载数据
+
+        注意事项：
+        - 过滤掉当年比赛中的物种（避免数据泄漏）
+        - 只下载高质量录音（评分 ≥ 3.0）
+        - 限制每个物种的下载量（避免数据不平衡）
+        """
+        # 使用 xeno-canto-api 或手动下载
+        # 这里提供框架代码
+
+        xc_species = [s for s in self.species_list if self._should_download(s)]
+
+        for species in xc_species:
+            # 调用 Xeno-Canto API
+            # 下载音频文件
+            # 保存到 output_dir/species_name/
+            pass
+
+    def _should_download(self, species: str) -> bool:
+        """检查物种是否应该下载（避免数据泄漏）"""
+        # 过滤比赛数据集中的物种
+        competition_species = set(self._get_competition_species())
+        return species not in competition_species
+
+    def preprocess_xeno_canto(self, audio_dir: str):
+        """
+        步骤 2: 数据清洗和预处理
+
+        2nd Place 的关键步骤：
+        1. 去除人声（如果可能）
+        2. 统一采样率到 32kHz
+        3. 音频归一化
+        4. 质量检查（SNR、时长等）
+        """
+        audio_files = list(Path(audio_dir).rglob("*.mp3"))
+
+        cleaned_data = []
+
+        for audio_file in audio_files:
+            # 加载音频
+            waveform, sr = torchaudio.load(audio_file)
+
+            # 重采样到 32kHz
+            if sr != self.target_sample_rate:
+                resampler = torchaudio.transforms.Resample(sr, self.target_sample_rate)
+                waveform = resampler(waveform)
+
+            # 质量检查
+            if self._check_quality(waveform):
+                # 提取 5 秒片段
+                segments = self._extract_segments(waveform)
+
+                for segment in segments:
+                    cleaned_data.append({
+                        "file_path": str(audio_file),
+                        "species": audio_file.parent.name,
+                        "waveform": segment,
+                    })
+
+        return cleaned_data
+
+    def _check_quality(self, waveform: torch.Tensor) -> bool:
+        """质量检查"""
+        # 检查 1: 时长至少 5 秒
+        if waveform.shape[1] < self.target_sample_rate * self.segment_duration:
+            return False
+
+        # 检查 2: SNR（信噪比）
+        # snr = self._calculate_snr(waveform)
+        # if snr < 10:  # 最低 10dB
+        #     return False
+
+        # 检查 3: 削波检测
+        if torch.abs(waveform).max() > 0.99:
+            return False
+
+        return True
+
+    def _extract_segments(self, waveform: torch.Tensor) -> list:
+        """
+        提取 5 秒音频片段
+
+        2nd Place 使用了多种采样策略：
+        1. 随机采样
+        2. 基于能量的采样（RMS）
+        3. 重叠采样
+        """
+        segment_samples = self.segment_duration * self.target_sample_rate
+
+        if waveform.shape[1] <= segment_samples:
+            # 填充到 5 秒
+            padding = segment_samples - waveform.shape[1]
+            waveform = torch.nn.functional.pad(waveform, (0, padding))
+            return [waveform]
+
+        # 方法 1: 随机采样
+        # 2nd Place 尝试了多种方法，最终发现随机采样效果最好
+
+        # 方法 2: 基于能量的采样（RMS）
+        # 计算每个 5 秒窗口的 RMS 能量
+        # 选择能量最高的窗口
+
+        # 方法 3: 重叠采样
+        # 滑动窗口，hop_size = 2.5 秒
+
+        # 这里实现随机采样
+        max_start = waveform.shape[1] - segment_samples
+        start_idx = torch.randint(0, max_start, (1,)).item()
+
+        segment = waveform[:, start_idx:start_idx + segment_samples]
+        return [segment]
+
+    def pretrain(self, xc_data, model, save_path: str = "checkpoints/pretrained.pth"):
+        """
+        步骤 3: 预训练
+
+        2nd Place 的预训练策略：
+        - 使用 Xeno-Canto 数据训练
+        - BCE Loss
+        - SpecAugment 增强
+        - 50-100 epochs
+        """
+        # 创建 dataloader
+        train_loader = self._create_dataloader(xc_data)
+
+        # 优化器
+        optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)
+
+        # 学习率调度器
+        scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
+            optimizer, T_max=50, eta_min=1e-6
+        )
+
+        # 损失函数
+        criterion = nn.BCEWithLogitsLoss()
+
+        # 训练循环
+        model.train()
+        for epoch in range(50):  # 50 epochs
+            for batch in train_loader:
+                mel_spec = self._extract_mel(batch["waveform"])
+                labels = batch["labels"]
+
+                # 前向传播
+                logits = model(mel_spec)
+                loss = criterion(logits, labels)
+
+                # 反向传播
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+
+            scheduler.step()
+
+            print(f"Epoch {epoch+1}/50, Loss: {loss.item():.4f}")
+
+        # 保存预训练模型
+        torch.save(model.state_dict(), save_path)
+        print(f"Pretrained model saved to {save_path}")
+
+    def finetune(self, model, train_data, val_data, pretrained_path: str):
+        """
+        步骤 4: 微调
+
+        2nd Place 的微调策略：
+        - 加载预训练权重
+        - 使用更小的学习率
+        - 选择最佳 checkpoint（不是最后一个）
+        - 关键：AUC 从 0.83-0.84 跳升至 0.86-0.87
+        """
+        # 加载预训练权重
+        model.load_state_dict(torch.load(pretrained_path))
+
+        # 优化器（更小的学习率）
+        optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4)
+
+        # 学习率调度器
+        scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
+            optimizer, T_max=30, eta_min=1e-7
+        )
+
+        # 损失函数
+        criterion = nn.BCEWithLogitsLoss()
+
+        best_val_score = 0
+        best_epoch = 0
+
+        # 微调循环
+        model.train()
+        for epoch in range(30):  # 30 epochs
+            # 训练
+            for batch in train_data:
+                mel_spec = self._extract_mel(batch["waveform"])
+                labels = batch["labels"]
+
+                logits = model(mel_spec)
+                loss = criterion(logits, labels)
+
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+
+            # 验证
+            val_score = self._validate(model, val_data)
+
+            print(f"Epoch {epoch+1}/30, Val AUC: {val_score:.4f}")
+
+            # 保存最佳模型
+            if val_score > best_val_score:
+                best_val_score = val_score
+                best_epoch = epoch
+                torch.save(model.state_dict(), f"checkpoints/best_finetuned_epoch{epoch}.pth")
+
+            scheduler.step()
+
+        print(f"Best epoch: {best_epoch}, Best Val AUC: {best_val_score:.4f}")
+
+    def _extract_mel(self, waveform: torch.Tensor) -> torch.Tensor:
+        """提取 mel-spectrogram（应该与训练时一致）"""
+        # 实现 mel-spectrogram 提取
+        pass
+
+    def _create_dataloader(self, data):
+        """创建 dataloader"""
+        pass
+
+    def _validate(self, model, val_data):
+        """验证"""
+        pass
+
+    def _get_competition_species(self) -> list:
+        """获取竞赛数据集中的物种（避免数据泄漏）"""
+        pass
+
+    def _calculate_snr(self, waveform: torch.Tensor) -> float:
+        """计算 SNR"""
+        pass
+
+
+# 2nd Place 关键技术总结
+"""
+关键发现（来自 2nd Place writeup）：
+
+1. **预训练效果显著**：
+   - 无预训练：AUC 0.83-0.84
+   - 有预训练：AUC 0.86-0.87
+   - 提升：+0.02-0.03 AUC
+
+2. **Checkpoint 选择很重要**：
+   - 不是最后一个 epoch 最好
+   - 需要验证集选择最佳 checkpoint
+   - 通常在 epoch 10-20 之间
+
+3. **采样策略**：
+   - 随机采样效果最好
+   - 基于能量的采样没有明显优势
+   - 5 秒片段是最佳长度
+
+4. **数据增强**：
+   - SpecAugment 必须保留
+   - RandomFiltering 有效
+   - 即使关闭略微提高 CV，但保留确保 LB 稳定性
+"""
+```
+
+#### 5th Place - Self-Distillation 详细实现
+
+**作者**: Noir
+**核心创新**: 三阶段自蒸馏 + Silero VAD 数据清洗
+
+**完整流程：**
+
+```python
+import torch
+import torch.nn as nn
+import numpy as np
+
+class SelfDistillationTrainer:
+    """
+    5th Place 方案：Self-Distillation 三阶段训练
+
+    核心思想：
+    1. 使用 Silero VAD 去除人声
+    2. 三阶段自蒸馏训练
+    3. 迭代丰富次要标签
+    """
+
+    def __init__(
+        self,
+        model: nn.Module,
+        num_classes: int = 206,
+    ):
+        self.model = model
+        self.num_classes = num_classes
+
+    def stage1_initial_training(self, train_loader, val_loader, epochs=30):
+        """
+        阶段 1: 初始训练
+
+        使用清洗后的训练音频（train_audio）进行初始训练
+        """
+        print("=== Stage 1: Initial Training ===")
+
+        optimizer = torch.optim.AdamW(self.model.parameters(), lr=1e-3)
+        scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
+            optimizer, T_max=epochs, eta_min=1e-6
+        )
+        criterion = nn.BCEWithLogitsLoss()
+
+        best_val_loss = float('inf')
+
+        for epoch in range(epochs):
+            self.model.train()
+            train_loss = 0
+
+            for batch in train_loader:
+                mel_spec = batch['mel_spec']
+                labels = batch['labels']
+
+                # 前向传播
+                logits = self.model(mel_spec)
+                loss = criterion(logits, labels)
+
+                # 反向传播
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+
+                train_loss += loss.item()
+
+            # 验证
+            val_loss = self._validate(self.model, val_loader, criterion)
+
+            # 学习率更新
+            scheduler.step()
+
+            print(f"Epoch {epoch+1}/{epochs}, Train Loss: {train_loss/len(train_loader):.4f}, "
+                  f"Val Loss: {val_loss:.4f}")
+
+            # 保存最佳模型
+            if val_loss < best_val_loss:
+                best_val_loss = val_loss
+                torch.save(self.model.state_dict(), "checkpoints/stage1_best.pth")
+
+        print(f"Stage 1 complete. Best Val Loss: {best_val_loss:.4f}")
+
+        # 加载最佳模型用于下一阶段
+        self.model.load_state_dict(torch.load("checkpoints/stage1_best.pth"))
+
+    def stage2_self_distillation_train_audio(
+        self,
+        train_loader,
+        epochs=20,
+        temperature=3.0,
+        alpha=0.7,
+    ):
+        """
+        阶段 2: 使用 train_audio 的自蒸馏
+
+        使用 stage 1 模型的预测作为软标签进行蒸馏
+        """
+        print("=== Stage 2: Self-Distillation on train_audio ===")
+
+        # stage 1 模型作为教师
+        teacher_model = type(self.model)(
+            backbone=self.model.backbone,
+            num_classes=self.num_classes,
+        )
+        teacher_model.load_state_dict(torch.load("checkpoints/stage1_best.pth"))
+        teacher_model.eval()
+
+        # 学生模型（可以重置权重或继续训练）
+        # 5th Place 选择继续训练
+
+        optimizer = torch.optim.AdamW(self.model.parameters(), lr=5e-4)  # 更小的学习率
+        scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
+            optimizer, T_max=epochs, eta_min=1e-7
+        )
+
+        # 蒸馏损失
+        distillation_criterion = nn.KLDivLoss(reduction="batchmean")
+        bce_criterion = nn.BCEWithLogitsLoss()
+
+        best_val_loss = float('inf')
+
+        for epoch in range(epochs):
+            self.model.train()
+            train_loss = 0
+
+            for batch in train_loader:
+                mel_spec = batch['mel_spec']
+                hard_labels = batch['labels']
+
+                with torch.no_grad():
+                    # 教师模型预测（软标签）
+                    teacher_logits = teacher_model(mel_spec)
+                    teacher_probs = torch.sigmoid(teacher_logits / temperature)
+
+                # 学生模型预测
+                student_logits = self.model(mel_spec)
+                student_log_probs = torch.log_softmax(student_logits / temperature, dim=-1)
+
+                # 蒸馏损失
+                distill_loss = distillation_criterion(student_log_probs, teacher_probs)
+
+                # 硬标签损失
+                bce_loss = bce_criterion(student_logits, hard_labels)
+
+                # 组合损失
+                loss = alpha * (temperature ** 2) * distill_loss + (1 - alpha) * bce_loss
+
+                # 反向传播
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+
+                train_loss += loss.item()
+
+            # 验证
+            val_loss = self._validate(self.model, train_loader, bce_criterion)  # 用训练集验证
+
+            scheduler.step()
+
+            print(f"Epoch {epoch+1}/{epochs}, Train Loss: {train_loss/len(train_loader):.4f}, "
+                  f"Val Loss: {val_loss:.4f}")
+
+            if val_loss < best_val_loss:
+                best_val_loss = val_loss
+                torch.save(self.model.state_dict(), "checkpoints/stage2_best.pth")
+
+        print(f"Stage 2 complete. Best Val Loss: {best_val_loss:.4f}")
+
+        self.model.load_state_dict(torch.load("checkpoints/stage2_best.pth"))
+
+    def stage3_self_distillation_soundscape(
+        self,
+        train_audio_loader,
+        soundscape_files,
+        epochs=20,
+        temperature=3.0,
+        alpha=0.5,  # 更重视伪标签
+    ):
+        """
+        阶段 3: 结合 train_audio 和 train_soundscapes 的自蒸馏
+
+        关键创新：丰富次要标签
+        - 许多音频包含未标注的鸟叫声
+        - 通过自蒸馏发现这些次要标签
+        """
+        print("=== Stage 3: Self-Distillation with soundscape ===")
+
+        # stage 2 模型作为教师
+        teacher_model = type(self.model)(
+            backbone=self.model.backbone,
+            num_classes=self.num_classes,
+        )
+        teacher_model.load_state_dict(torch.load("checkpoints/stage2_best.pth"))
+        teacher_model.eval()
+
+        optimizer = torch.optim.AdamW(self.model.parameters(), lr=3e-4)
+        scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
+            optimizer, T_max=epochs, eta_min=1e-7
+        )
+
+        distillation_criterion = nn.KLDivLoss(reduction="batchmean")
+        bce_criterion = nn.BCEWithLogitsLoss()
+
+        # 生成 soundscape 的伪标签
+        soundscape_pseudo_labels = self._generate_pseudo_labels(
+            teacher_model, soundscape_files
+        )
+
+        # 合并 train_audio 和 soundscape 数据
+        # 50% train_audio + 50% soundscape
+
+        best_val_loss = float('inf')
+
+        for epoch in range(epochs):
+            self.model.train()
+            train_loss = 0
+
+            # 训练 train_audio（带硬标签）
+            for batch in train_audio_loader:
+                if np.random.rand() > 0.5:
+                    continue  # 50% 概率使用 train_audio
+
+                mel_spec = batch['mel_spec']
+                hard_labels = batch['labels']
+
+                with torch.no_grad():
+                    teacher_logits = teacher_model(mel_spec)
+                    teacher_probs = torch.sigmoid(teacher_logits / temperature)
+
+                student_logits = self.model(mel_spec)
+                student_log_probs = torch.log_softmax(student_logits / temperature, dim=-1)
+
+                distill_loss = distillation_criterion(student_log_probs, teacher_probs)
+                bce_loss = bce_criterion(student_logits, hard_labels)
+                loss = alpha * (temperature ** 2) * distill_loss + (1 - alpha) * bce_loss
+
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+
+                train_loss += loss.item()
+
+            # 训练 soundscape（伪标签）
+            for batch in soundscape_pseudo_labels:
+                if np.random.rand() <= 0.5:
+                    continue  # 50% 概率使用 soundscape
+
+                mel_spec = batch['mel_spec']
+                pseudo_labels = batch['labels']  # 软标签
+
+                with torch.no_grad():
+                    teacher_logits = teacher_model(mel_spec)
+                    teacher_probs = torch.sigmoid(teacher_logits / temperature)
+
+                student_logits = self.model(mel_spec)
+                student_log_probs = torch.log_softmax(student_logits / temperature, dim=-1)
+
+                # 只使用蒸馏损失（没有硬标签）
+                distill_loss = distillation_criterion(student_log_probs, teacher_probs)
+
+                optimizer.zero_grad()
+                distill_loss.backward()
+                optimizer.step()
+
+                train_loss += distill_loss.item()
+
+            scheduler.step()
+
+            print(f"Epoch {epoch+1}/{epochs}, Train Loss: {train_loss:.4f}")
+
+            # 保存检查点
+            if epoch % 5 == 0:
+                torch.save(self.model.state_dict(), f"checkpoints/stage3_epoch{epoch}.pth")
+
+        print("Stage 3 complete")
+
+    def _generate_pseudo_labels(
+        self,
+        model: nn.Module,
+        audio_files: list,
+    ) -> list:
+        """
+        生成 soundscape 的伪标签
+
+        关键：丰富次要标签
+        - 使用帧级预测（segmentwise）
+        - 时间维度平均
+        """
+        model.eval()
+        pseudo_labels = []
+
+        with torch.no_grad():
+            for audio_file in audio_files:
+                # 加载音频
+                waveform, sr = torchaudio.load(audio_file)
+
+                # 分段处理（5秒窗口）
+                segments = self._split_audio(waveform, sr)
+
+                for segment in segments:
+                    mel_spec = self._extract_mel(segment)
+
+                    # 获取帧级预测
+                    output = model(mel_spec, return_segmentwise=True)
+                    segmentwise_logits = output["segmentwise_output"]  # (1, 206, time)
+                    segmentwise_probs = torch.sigmoid(segmentwise_logits)
+
+                    # 时间维度平均（关键：丰富次要标签）
+                    avg_probs = segmentwise_probs.mean(dim=-1).squeeze(0)  # (206,)
+
+                    pseudo_labels.append({
+                        "mel_spec": mel_spec,
+                        "labels": avg_probs,
+                    })
+
+        return pseudo_labels
+
+    def _split_audio(self, waveform: torch.Tensor, sr: int) -> list:
+        """分段处理音频"""
+        segment_samples = 5 * sr
+        segments = []
+
+        for i in range(0, waveform.shape[1], segment_samples):
+            segment = waveform[:, i:i+segment_samples]
+            if segment.shape[1] == segment_samples:
+                segments.append(segment)
+            else:
+                # 填充
+                padding = segment_samples - segment.shape[1]
+                segment = torch.nn.functional.pad(segment, (0, padding))
+                segments.append(segment)
+
+        return segments
+
+    def _extract_mel(self, waveform: torch.Tensor) -> torch.Tensor:
+        """提取 mel-spectrogram"""
+        pass
+
+    def _validate(self, model, val_loader, criterion):
+        """验证"""
+        model.eval()
+        total_loss = 0
+
+        with torch.no_grad():
+            for batch in val_loader:
+                mel_spec = batch['mel_spec']
+                labels = batch['labels']
+
+                logits = model(mel_spec)
+                loss = criterion(logits, labels)
+                total_loss += loss.item()
+
+        return total_loss / len(val_loader)
+
+
+class SileroVADDataCleaner:
+    """
+    Silero VAD 数据清洗
+
+    5th Place 使用 Silero VAD 检测并去除人声片段
+    """
+
+    def __init__(self):
+        # 加载 Silero VAD 模型
+        self.model, utils = torch.hub.load(
+            repo_or_dir='snakers4/silero-vad',
+            model='silero_vad',
+            force_reload=False,
+            onnx=False
+        )
+        self.model.eval()
+
+    def clean_audio(self, audio_path: str, output_path: str):
+        """
+        去除包含人声的音频片段
+
+        Returns:
+            清洗后的音频（去除人声部分）
+        """
+        waveform, sr = torchaudio.load(audio_path)
+
+        # 转换为单声道
+        if waveform.shape[0] > 1:
+            waveform = waveform.mean(dim=0, keepdim=True)
+
+        # 重采样到 16kHz（Silero VAD 要求）
+        if sr != 16000:
+            resampler = torchaudio.transforms.Resample(sr, 16000)
+            waveform = resampler(waveform)
+            sr = 16000
+
+        # VAD 检测
+        speech_chunks = self._detect_speech(waveform, sr)
+
+        # 如果检测到人声，去除这些片段
+        if speech_chunks:
+            cleaned_waveform = self._remove_speech_chunks(waveform, speech_chunks)
+        else:
+            cleaned_waveform = waveform
+
+        # 保存清洗后的音频
+        torchaudio.save(output_path, cleaned_waveform, sr)
+
+        return cleaned_waveform
+
+    def _detect_speech(self, waveform: torch.Tensor, sr: int) -> list:
+        """
+        检测人声片段
+
+        Returns:
+            List of (start_ms, end_ms) tuples
+        """
+        # 获取语音概率
+        speech_probs = []
+        window_size = 512  # 32ms at 16kHz
+
+        for i in range(0, waveform.shape[1], window_size):
+            chunk = waveform[:, i:i+window_size]
+            if chunk.shape[1] < window_size:
+                continue
+
+            with torch.no_grad():
+                speech_prob = self.model(chunk, sr).item()
+                speech_probs.append(speech_prob)
+
+        # 阈值检测（人声概率 > 0.5）
+        speech_chunks = []
+        in_speech = False
+        start_idx = 0
+
+        for i, prob in enumerate(speech_probs):
+            if prob > 0.5 and not in_speech:
+                in_speech = True
+                start_idx = i * window_size
+            elif prob <= 0.5 and in_speech:
+                in_speech = False
+                end_idx = i * window_size
+                speech_chunks.append((start_idx, end_idx))
+
+        # 转换为毫秒
+        speech_chunks_ms = [(s * 1000 / sr, e * 1000 / sr) for s, e in speech_chunks]
+
+        return speech_chunks_ms
+
+    def _remove_speech_chunks(
+        self,
+        waveform: torch.Tensor,
+        speech_chunks: list,
+    ) -> torch.Tensor:
+        """去除人声片段"""
+        sr = 16000
+
+        # 将时间转换为样本索引
+        speech_ranges = [(int(s * sr / 1000), int(e * sr / 1000)) for s, e in speech_chunks]
+
+        # 创建掩码（True 表示保留）
+        mask = torch.ones(waveform.shape[1], dtype=torch.bool)
+
+        for start, end in speech_ranges:
+            mask[start:end] = False
+
+        # 应用掩码
+        cleaned_waveform = waveform[:, mask]
+
+        return cleaned_waveform
+
+
+# 5th Place 关键技术总结
+"""
+关键发现（来自 5th Place writeup）：
+
+1. **Silero VAD 有效**：
+   - 去除人声减少误检
+   - 清洗后数据质量提升
+
+2. **三阶段自蒸馏**：
+   - Stage 1: 基础训练
+   - Stage 2: train_audio 自蒸馏
+   - Stage 3: 加入 soundscape 伪标签
+   - 每个阶段都带来提升
+
+3. **丰富次要标签**：
+   - 许多音频包含未标注的鸟叫声
+   - 使用帧级预测和时间平均
+   - 迭代训练发现更多标签
+
+4. **数据平衡重要**：
+   - 样本 <20 的类别复制到 20
+   - 样本 <30 的类别手动筛选
+   - 使用前 30/60 秒数据
+"""
+```
+
+#### 1st Place - Multi-Iterative Noisy Student 详细流程
+
+**作者**: Nikita Babych
+**核心创新**: 多迭代 Noisy Student + MixUp + 幂次变换
+
+**完整流程：**
+
+```python
+import torch
+import torch.nn as nn
+import numpy as np
+
+class MultiIterativeNoisyStudent:
+    """
+    1st Place 方案：多迭代 Noisy Student 自训练
+
+    核心创新：
+    1. 多迭代自训练，每次使用 MixUp
+    2. 伪标签幂次变换减少噪声
+    3. 滑动窗口推理，帧预测平均
+    """
+
+    def __init__(
+        self,
+        model: nn.Module,
+        num_classes: int = 206,
+        num_iterations: int = 3,
+    ):
+        self.model = model
+        self.num_classes = num_classes
+        self.num_iterations = num_iterations
+
+        # 1st Place 关键参数
+        self.mixup_alpha = 0.5
+        self.power_transform = 1.5  # 幂次变换参数（减少伪标签噪声）
+
+    def train_iteration(
+        self,
+        train_audio_loader,
+        train_soundscape_files,
+        iteration: int,
+        epochs=30,
+    ):
+        """
+        执行一次 Noisy Student 迭代
+
+        Args:
+            iteration: 当前迭代编号（0, 1, 2, ...）
+        """
+        print(f"=== Noisy Student Iteration {iteration + 1} ===")
+
+        # 准备数据
+        # 50% train_audio + 50% 伪标签 soundscape
+        if iteration == 0:
+            # 第一次迭代：只使用 train_audio
+            train_loader = train_audio_loader
+        else:
+            # 后续迭代：混合 train_audio 和伪标签
+            train_loader = self._prepare_mixed_data(
+                train_audio_loader,
+                train_soundscape_files,
+                iteration,
+            )
+
+        # 优化器
+        optimizer = torch.optim.AdamW(self.model.parameters(), lr=1e-3)
+        scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
+            optimizer, T_max=epochs, eta_min=1e-6
+        )
+        criterion = nn.BCEWithLogitsLoss()
+
+        best_val_loss = float('inf')
+
+        for epoch in range(epochs):
+            self.model.train()
+            train_loss = 0
+
+            for batch in train_loader:
+                mel_spec = batch['mel_spec']
+                labels = batch['labels']
+
+                # MixUp 数据增强（1st Place 关键）
+                if np.random.rand() < 0.5:  # 50% 概率应用 MixUp
+                    mel_spec, labels = self._apply_mixup(mel_spec, labels)
+
+                # 前向传播
+                logits = self.model(mel_spec)
+                loss = criterion(logits, labels)
+
+                # 反向传播
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+
+                train_loss += loss.item()
+
+            # 验证（使用训练集的一个子集）
+            val_loss = self._quick_validate(train_audio_loader, criterion)
+
+            scheduler.step()
+
+            print(f"Iteration {iteration+1}, Epoch {epoch+1}/{epochs}, "
+                  f"Train Loss: {train_loss/len(train_loader):.4f}, "
+                  f"Val Loss: {val_loss:.4f}")
+
+            if val_loss < best_val_loss:
+                best_val_loss = val_loss
+                torch.save(self.model.state_dict(),
+                          f"checkpoints/noisy_student_iter{iteration}_best.pth")
+
+        print(f"Iteration {iteration+1} complete. Best Val Loss: {best_val_loss:.4f}")
+
+    def _prepare_mixed_data(
+        self,
+        train_audio_loader,
+        soundscape_files,
+        iteration: int,
+    ):
+        """
+        准备混合数据：train_audio + 伪标签 soundscape
+
+        关键：幂次变换减少伪标签噪声（1st Place 创新）
+        """
+        # 生成伪标签
+        pseudo_labels = self._generate_pseudo_labels_power_transform(
+            soundscape_files,
+            self.power_transform,
+        )
+
+        # 创建混合 dataloader
+        mixed_data = []
+
+        # 添加 train_audio
+        for batch in train_audio_loader:
+            mixed_data.append(batch)
+
+        # 添加伪标签 soundscape
+        for item in pseudo_labels:
+            mixed_data.append(item)
+
+        # 打乱顺序
+        np.random.shuffle(mixed_data)
+
+        return mixed_data
+
+    def _generate_pseudo_labels_power_transform(
+        self,
+        audio_files: list,
+        power: float = 1.5,
+    ) -> list:
+        """
+        生成伪标签并应用幂次变换
+
+        1st Place 关键创新：幂次变换减少噪声
+
+        原理：
+        - 直接对概率进行温度缩放会提高噪声的概率
+        - 通过幂次变换，防止噪声的放大，并保留重要的标签信号
+        """
+        self.model.eval()
+        pseudo_labels = []
+
+        with torch.no_grad():
+            for audio_file in audio_files:
+                waveform, sr = torchaudio.load(audio_file)
+
+                # 分段处理（5秒窗口）
+                segments = self._split_audio(waveform, sr)
+
+                for segment in segments:
+                    mel_spec = self._extract_mel(segment)
+
+                    # 获取预测
+                    logits = self.model(mel_spec)
+                    probs = torch.sigmoid(logits).squeeze(0).cpu().numpy()  # (206,)
+
+                    # 幂次变换（1st Place 创新）
+                    # power > 1: 压缩低概率，扩展高概率
+                    # power < 1: 扩展低概率，压缩高概率
+                    probs_transformed = np.power(probs, power)
+
+                    pseudo_labels.append({
+                        "mel_spec": mel_spec,
+                        "labels": torch.tensor(probs_transformed, dtype=torch.float32),
+                    })
+
+        return pseudo_labels
+
+    def _apply_mixup(
+        self,
+        mel_spec: torch.Tensor,
+        labels: torch.Tensor,
+    ) -> tuple:
+        """
+        MixUp 数据增强
+
+        1st Place 关键：使用固定混合权重 0.5
+        """
+        batch_size = mel_spec.size(0)
+
+        # 生成混合权重
+        lam = np.random.beta(self.mixup_alpha, self.mixup_alpha)
+        # 1st Place 发现固定权重 0.5 效果更好
+        # lam = 0.5
+
+        # 随机排列
+        index = torch.randperm(batch_size)
+
+        # 混合特征
+        mixed_mel = lam * mel_spec + (1 - lam) * mel_spec[index]
+
+        # 混合标签（取最大值）
+        mixed_labels = torch.maximum(labels, labels[index])
+
+        return mixed_mel, mixed_labels
+
+    def _split_audio(self, waveform: torch.Tensor, sr: int) -> list:
+        """分段处理音频"""
+        segment_samples = 5 * sr
+        segments = []
+
+        for i in range(0, waveform.shape[1], segment_samples):
+            segment = waveform[:, i:i+segment_samples]
+            if segment.shape[1] == segment_samples:
+                segments.append(segment)
+            else:
+                padding = segment_samples - segment.shape[1]
+                segment = torch.nn.functional.pad(segment, (0, padding))
+                segments.append(segment)
+
+        return segments
+
+    def _extract_mel(self, waveform: torch.Tensor) -> torch.Tensor:
+        """提取 mel-spectrogram"""
+        pass
+
+    def _quick_validate(self, val_loader, criterion):
+        """快速验证"""
+        self.model.eval()
+        total_loss = 0
+        count = 0
+
+        with torch.no_grad():
+            for i, batch in enumerate(val_loader):
+                if i >= 10:  # 只验证前 10 个 batch
+                    break
+
+                mel_spec = batch['mel_spec']
+                labels = batch['labels']
+
+                logits = self.model(mel_spec)
+                loss = criterion(logits, labels)
+                total_loss += loss.item()
+                count += 1
+
+        return total_loss / max(count, 1)
+
+
+# 1st Place 关键技术总结
+"""
+关键发现（来自 1st Place writeup）：
+
+1. **多迭代 Noisy Student 有效**：
+   - 每次迭代都带来提升
+   - 3 次迭代是最优的
+   - 更多迭代可能导致噪声累积
+
+2. **幂次变换是关键**：
+   - 直接使用伪标签：性能提升有限
+   - 幂次变换（power=1.5）：显著提升
+   - 防止噪声放大，保留信号
+
+3. **MixUp 策略**：
+   - 固定权重 0.5 比随机权重更稳定
+   - 迫使模型学习更鲁棒的特征
+   - 减少过拟合
+
+4. **滑动窗口推理**：
+   - 使用帧预测的平均值
+   - 避免丢弃有价值的预测数据
+   - 类似图像的 2D 滑动窗口分割
+"""
+
+
+# 1st Place 完整训练流程示例
+def train_noisy_student_full_pipeline():
+    """
+    完整的 Noisy Student 训练流程
+    """
+    # 初始化
+    model = SEDModel(num_classes=206)
+    trainer = MultiIterativeNoisyStudent(model, num_iterations=3)
+
+    # 准备数据
+    train_audio_loader = ...  # 训练音频 loader
+    soundscape_files = ...    # soundscape 文件列表
+
+    # 迭代 0: 只使用 train_audio
+    print("=== Iteration 0: Training on train_audio only ===")
+    trainer.train_iteration(train_audio_loader, soundscape_files, iteration=0, epochs=30)
+
+    # 迭代 1: 加入伪标签 soundscape
+    print("=== Iteration 1: Adding pseudo-labeled soundscape ===")
+    trainer.train_iteration(train_audio_loader, soundscape_files, iteration=1, epochs=30)
+
+    # 迭代 2: 使用新的伪标签
+    print("=== Iteration 2: Refreshing pseudo labels ===")
+    trainer.train_iteration(train_audio_loader, soundscape_files, iteration=2, epochs=30)
+
+    # 最终集成：使用不同迭代的模型
+    model_iter0 = SEDModel(num_classes=206)
+    model_iter0.load_state_dict(torch.load("checkpoints/noisy_student_iter0_best.pth"))
+
+    model_iter1 = SEDModel(num_classes=206)
+    model_iter1.load_state_dict(torch.load("checkpoints/noisy_student_iter1_best.pth"))
+
+    model_iter2 = SEDModel(num_classes=206)
+    model_iter2.load_state_dict(torch.load("checkpoints/noisy_student_iter2_best.pth"))
+
+    # 集成预测
+    def ensemble_predict(mel_spec):
+        pred0 = torch.sigmoid(model_iter0(mel_spec))
+        pred1 = torch.sigmoid(model_iter1(mel_spec))
+        pred2 = torch.sigmoid(model_iter2(mel_spec))
+
+        # 简单平均
+        ensemble_pred = (pred0 + pred1 + pred2) / 3
+        return ensemble_pred
+
+    return ensemble_predict
+```
+
+#### 4th Place - Soft AUC Loss 详细分析
+
+**作者**: dylan.liu
+**核心创新**: 支持软标签的 AUC 损失函数
+
+**问题背景：**
+- 标准 AUC 损失函数不支持软标签（适用于知识蒸馏和半监督学习）
+- 4th Place 通过自定义 soft AUC loss 解决这个问题
+- 效果：从 11 名跃升至 4 名（LB 从 0.850 → 0.901）
+
+```python
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class SoftAUCLoss_v4(nn.Module):
+    """
+    4th Place Soft AUC Loss 实现
+
+    参考：4th Place writeup
+    效果：LB 从 0.850 → 0.901（显著提升）
+
+    核心思想：
+    1. 支持 soft labels（适用于知识蒸馏和半监督学习）
+    2. 通过正负样本对的排序关系优化 AUC
+    3. 减少 overfitting
+    """
+
+    def __init__(
+        self,
+        margin: float = 1.0,
+        reduction: str = "mean",
+    ):
+        super().__init__()
+        self.margin = margin
+        self.reduction = reduction
+
+    def forward(
+        self,
+        predictions: torch.Tensor,
+        targets: torch.Tensor,
+    ) -> torch.Tensor:
+        """
+        Args:
+            predictions: (batch, num_classes) - 原始 logits
+            targets: (batch, num_classes) - 软标签 [0, 1]
+
+        Returns:
+            AUC loss
+        """
+        probs = torch.sigmoid(predictions)
+        num_classes = predictions.size(1)
+        losses = []
+
+        for c in range(num_classes):
+            prob_c = probs[:, c]      # (batch,)
+            target_c = targets[:, c]  # (batch,)
+
+            # 计算所有样本对的差异
+            # 对于软标签，我们需要加权处理
+
+            # 创建样本对矩阵
+            # target_diff > 0 表示 target_i > target_j
+            target_diff = target_c.unsqueeze(1) - target_c.unsqueeze(0)  # (batch, batch)
+            prob_diff = prob_c.unsqueeze(1) - prob_c.unsqueeze(0)        # (batch, batch)
+
+            # 只考虑 target_i > target_j 的对
+            # 即正样本（高 target）应该有更高的预测概率
+            mask = target_diff > 0
+
+            if mask.sum() > 0:
+                # Hinge loss: max(0, margin - (prob_i - prob_j))
+                # 理想情况：prob_i > prob_j（正样本预测高于负样本）
+                # margin - (prob_i - prob_j) 应该 <= 0
+                # 如果 > 0，说明违反了排序关系
+
+                loss_c = F.relu(self.margin - prob_diff)[mask].mean()
+
+                # 4th Place 发现加权版本更有效
+                # 使用 target_diff 作为权重
+                # weight = target_diff[mask]
+                # weighted_loss = F.relu(self.margin - prob_diff)[mask] * weight
+                # loss_c = weighted_loss.sum() / weight.sum()
+
+                losses.append(loss_c)
+
+        if len(losses) == 0:
+            return torch.tensor(0.0, device=predictions.device, requires_grad=True)
+
+        losses = torch.stack(losses)
+
+        if self.reduction == "mean":
+            return losses.mean()
+        elif self.reduction == "sum":
+            return losses.sum()
+        else:
+            return losses
+
+
+class SoftAUCLoss_Advanced(nn.Module):
+    """
+    改进的 Soft AUC Loss
+
+    结合 4th Place 的发现和其他优化：
+    1. 温度缩放
+    2. 自适应 margin
+    3. 类别加权
+    """
+
+    def __init__(
+        self,
+        margin: float = 1.0,
+        temperature: float = 1.0,
+        use_class_weighting: bool = True,
+    ):
+        super().__init__()
+        self.margin = margin
+        self.temperature = temperature
+        self.use_class_weighting = use_class_weighting
+
+    def forward(
+        self,
+        predictions: torch.Tensor,
+        targets: torch.Tensor,
+    ) -> torch.Tensor:
+        """
+        Args:
+            predictions: (batch, num_classes)
+            targets: (batch, num_classes) - 软标签
+        """
+        # 温度缩放
+        probs = torch.sigmoid(predictions / self.temperature)
+        num_classes = predictions.size(1)
+
+        losses = []
+
+        for c in range(num_classes):
+            prob_c = probs[:, c]
+            target_c = targets[:, c]
+
+            # 样本对矩阵
+            target_diff = target_c.unsqueeze(1) - target_c.unsqueeze(0)
+            prob_diff = prob_c.unsqueeze(1) - prob_c.unsqueeze(0)
+
+            # mask: target_i > target_j
+            mask = target_diff > 0
+
+            if mask.sum() > 0:
+                # Hinge loss
+                base_loss = F.relu(self.margin - prob_diff)[mask]
+
+                # 可选：使用 target_diff 作为权重
+                # 这给予高 target 差异的样本对更高权重
+                weights = target_diff[mask]
+                weighted_loss = base_loss * weights
+
+                loss_c = weighted_loss.sum() / weights.sum()
+
+                # 可选：类别权重（处理长尾分布）
+                if self.use_class_weighting:
+                    # 稀有类别更高权重
+                    class_weight = self._get_class_weight(c, num_classes)
+                    loss_c = loss_c * class_weight
+
+                losses.append(loss_c)
+
+        if len(losses) == 0:
+            return torch.tensor(0.0, device=predictions.device, requires_grad=True)
+
+        return torch.stack(losses).mean()
+
+    def _get_class_weight(self, class_idx: int, num_classes: int) -> float:
+        """
+        计算类别权重（处理长尾分布）
+
+        简单版本：可以基于样本频率
+        """
+        # 这里使用简单策略：可以替换为实际的类别频率
+        #稀有类获得更高权重
+        return 1.0  # 可以自定义
+
+
+# 4th Place 关键发现总结
+"""
+关键发现（来自 4th Place writeup）：
+
+1. **Soft AUC Loss 显著提升性能**：
+   - LB 从 0.850 → 0.901
+   - 排名从 11 名 → 4 名
+   - +0.05 AUC 提升是巨大的
+
+2. **为什么 Soft AUC Loss 有效**：
+   - 标准 AUC loss 只支持硬标签（0 或 1）
+   - Soft AUC Loss 支持软标签（0 到 1 之间）
+   - 适用于知识蒸馏和半监督学习
+   - 减少 overfitting
+
+3. **实现细节**：
+   - 使用样本对的排序关系
+   - Hinge loss: max(0, margin - (prob_i - prob_j))
+   - 只考虑 target_i > target_j 的对
+   - margin 通常设为 1.0
+
+4. **适用场景**：
+   - 半监督学习（伪标签）
+   - 知识蒸馏（软标签）
+   - 长尾分布（稀有类别）
+   - 标签噪声（软标签更鲁棒）
+
+5. **与其他损失函数对比**：
+   - BCE Loss: 简单但易过拟合
+   - Focal Loss: 处理类别不平衡，但不优化 AUC
+   - Soft AUC Loss: 直接优化 AUC，支持软标签
+"""
+
+
+# 使用示例
+def train_with_soft_auc_loss():
+    """使用 Soft AUC Loss 训练"""
+
+    model = SEDModel(num_classes=206)
+
+    # 标准训练：BCE Loss
+    criterion_bce = nn.BCEWithLogitsLoss()
+
+    # 半监督训练：Soft AUC Loss
+    criterion_soft_auc = SoftAUCLoss_v4(margin=1.0)
+
+    # 优化器
+    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)
+
+    # 训练循环
+    for epoch in range(30):
+        model.train()
+
+        for batch in train_loader:
+            mel_spec = batch['mel_spec']
+            labels = batch['labels']  # 可能是软标签
+
+            # 选择损失函数
+            if batch.get('is_pseudo', False):  # 伪标签数据
+                # 使用 Soft AUC Loss
+                loss = criterion_soft_auc(model(mel_spec), labels)
+            else:  # 真实标签
+                # 可以使用 BCE Loss 或 Soft AUC Loss
+                loss = criterion_bce(model(mel_spec), labels)
+
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+
+        print(f"Epoch {epoch+1}/30, Loss: {loss.item():.4f}")
+```
+
+---
+
+## Best Practices
+
+### 时间序列分类竞赛策略
+
+| 策略 | 何时使用 | 说明 |
+|------|---------|------|
+| **CWT over STFT** | 非平稳信号 | CWT提供更好的时间-频率局部化 |
+| **Entmax over Softmax** | 标签稀疏时 | Entmax产生更稀疏的输出 |
+| **非负线性回归集成** | 多模型集成时 | 即使过拟合也能保持相关性 |
+| **2-Stage Training** | 标签质量不均时 | Stage1全数据，Stage2高质量样本 |
+| **Group K-Fold** | 有重复样本时 | 确保同一patient/EEG不分散 |
+| **仅用高质量样本** | 评估时 | 使用votes≥10的样本建立验证集 |
+
+### 时频分析方法对比
+
+| 方法 | 优点 | 缺点 | 适用场景 |
+|------|------|------|---------|
+| **STFT** | 简单，易实现 | 固定窗口，时频分辨率权衡 | 平稳信号 |
+| **CWT** | 多分辨率分析，捕捉局部特征 | 需要选择小波函数 | 非平稳信号，EEG |
+| **Superlet** | 最高时频分辨率 | 计算成本高 | 复杂脑波模式 |
+
+### 频率配置经验
+
+| 配置 | 范围 | 说明 |
+|------|------|------|
+| **标准CWT** | 0.5-20 Hz | Kaggle提供的spectrogram默认范围 |
+| **扩展CWT** | 0.5-40 Hz | 更好的结果 (suguuuuu) |
+| **带通滤波** | 0.5-40 Hz | 高频噪声增加'other'投票 |
+
+### 数据增强策略
+
+**时间序列 (1D):**
+- 随机时间偏移 (±5秒)
+- 随机带通滤波 (不同频率范围)
+- 通道翻转 (水平/垂直)
+- 幅值缩放
+
+**Scalogram/Spectrogram (2D):**
+- XYMasking (随机遮挡)
+- Mixup
+- 时间方向翻转
+
+### Backbone选择
+
+**时间序列 (1D):**
+- 1D CNN + GRU
+- Transformer (Time-series Transformer)
+- LSTM/GRU
+
+**Scalogram (2D):**
+- SwinV2: swinv2_tiny_window16 (最佳: CV 0.2229)
+- MaxVIT: maxvit_base_tf_512
+- ConvNeXt: convnextv2_atto
+
+### 标签处理技巧
+
+| 技巧 | 效果 |
+|------|------|
+| 标签平滑 (加0.02 offset) | 使低投票数标签获得更强正则化 |
+| 仅用votes≥10评估 | CV/LB相关性接近1:1 |
+| 投票数归一化 | 多专家投票转换为分布 |
+
+### 常见误区
+
+| 误区 | 正确做法 |
+|------|---------|
+| STFT不够好就放弃时频分析 | 尝试CWT或Superlet |
+| Softmax输出不够稀疏 | 使用Entmax |
+| 集成权重手动调参 | 使用非负线性回归 |
+| 用全部样本验证 | 仅用高质量样本 (votes≥10) |
+| 忽略Group K-Fold | 防止同一patient的数据泄露 |
+