Fix NB3 NB1 filenames and time parsing

nb03_pseudo_labeling.py

@@ -1,35 +1,23 @@
 """
-╔══════════════════════════════════════════════════════════════════════════════╗
-║                    BirdCLEF+ 2026 — Notebook 3 (IMPROVED)                  ║
-║                         PSEUDO-LABELING (Noisy Student)                    ║
-║                                                                              ║
-║  Strategy:                                                                   ║
-║    • Load ALL trained fold models (5 folds × 2 backbones = 10 models)      ║
-║    • Run inference on train_soundscapes (not test — we don't have test!)     ║
-║    • Actually: generate pseudo-labels from test_soundscapes via submission  ║
-║    • Use high-confidence predictions (>0.5) as pseudo-labels                 ║
-║    • Retrain on pseudo-labeled data + original training data                ║
-╚══════════════════════════════════════════════════════════════════════════════╝
-
-IMPORTANT: In Kaggle, you don't have test labels. The standard approach:
-  1. Train on train_audio + train_soundscapes
-  2. Generate predictions on train_soundscapes using models
-  3. Use confident predictions as additional training signal
-  4. OR: use test predictions from a previous submission as pseudo-labels
-
-Since we can't see test labels, this notebook implements "noisy student" 
-by re-training on train_soundscapes with pseudo-labels generated from 
-our own ensemble predictions on those same soundscapes.
+BirdCLEF+ 2026 — Notebook 3 (FIXED)
+Pseudo-label generation using NB2 fold models.
+
+Fixes:
+  1. Uses NB1 output filenames:
+       soundscape_labels_with_folds.csv
+       species_list.csv
+  2. Parses soundscape start/end time strings to numeric seconds.
+  3. Loads whatever fold models exist, so you can run after partial NB2 runs.
 """
 
-import os, gc, math
+import os, gc, random
 import numpy as np
 import pandas as pd
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
 from torch.utils.data import Dataset, DataLoader
-from torch.amp import GradScaler, autocast
+from torch.amp import autocast
 import timm, librosa, torchaudio
 
 # =========================
@@ -42,10 +30,14 @@ class CFG:
     n_samples = int(sr * duration)
     num_classes = 234
     batch_size = 16
-    epochs = 3
     num_workers = 2
-    device = "cuda"
-    spec = dict(n_fft=1024, hop_length=64, n_mels=128, fmin=20, fmax=16000)
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    spec_b0 = dict(n_fft=1024, hop_length=64, n_mels=128, fmin=20, fmax=16000)
+    spec_b3 = dict(n_fft=2048, hop_length=512, n_mels=128, fmin=20, fmax=16000)
+
+random.seed(CFG.seed)
+np.random.seed(CFG.seed)
+torch.manual_seed(CFG.seed)
 
 # =========================
 # PATHS
@@ -53,30 +45,58 @@ class CFG:
 COMP_DIR = "/kaggle/input/competitions/birdclef-2026"
 TRAIN_SC = f"{COMP_DIR}/train_soundscapes"
 
-DATA_DIR = "/kaggle/input/datasets/vivekgaur9972/nb01-dataset/nb01"
+# NB1 output dataset
+DATA_DIR = "/kaggle/input/datasets/adpassward709/birdcleff-nb1-output"
+
+# NB2 model dataset. Update this after saving NB2 outputs as a Kaggle dataset.
 MODEL_DIR = "/kaggle/input/datasets/vivekgaur9972/birdclef-nb02-models/nb02-model/models"
 
 OUTPUT_DIR = "/kaggle/working"
-os.makedirs(f"{OUTPUT_DIR}/models", exist_ok=True)
+os.makedirs(OUTPUT_DIR, exist_ok=True)
 
 # =========================
-# LOAD
+# HELPERS
+# =========================
+def parse_time_col(val):
+    if pd.isna(val):
+        return 0.0
+    try:
+        return float(val)
+    except Exception:
+        s = str(val).strip()
+        parts = s.split(":")
+        try:
+            if len(parts) == 3:
+                return float(parts[0]) * 3600 + float(parts[1]) * 60 + float(parts[2])
+            if len(parts) == 2:
+                return float(parts[0]) * 60 + float(parts[1])
+            return float(parts[0])
+        except Exception:
+            return 0.0
+
+def make_spec(chunk, spec):
+    mel = librosa.feature.melspectrogram(y=chunk, sr=CFG.sr, **spec)
+    mel = librosa.power_to_db(mel)
+    mel = (mel - mel.min()) / (mel.max() - mel.min() + 1e-6)
+    return torch.tensor(mel, dtype=torch.float32).unsqueeze(0).repeat(3, 1, 1)
+
+# =========================
+# LOAD DATA
 # =========================
 species_df = pd.read_csv(f"{DATA_DIR}/species_list.csv")
 SPECIES = species_df["species"].tolist()
-MAP = {s:i for i,s in enumerate(SPECIES)}
+CFG.num_classes = len(SPECIES)
 
-# Load all fold models
-FOLD_MODELS = []
-for name in ["b0", "b3"]:
-    for fold in range(5):
-        path = f"{MODEL_DIR}/{name}_fold{fold}.pt"
-        if os.path.exists(path):
-            FOLD_MODELS.append((name, fold, path))
-        else:
-            print(f"  [WARN] Missing: {path}")
+sc_df = pd.read_csv(f"{DATA_DIR}/soundscape_labels_with_folds.csv")
+if "start" in sc_df.columns:
+    sc_df["start"] = sc_df["start"].apply(parse_time_col)
+else:
+    sc_df["start"] = 0.0
+if "end" in sc_df.columns:
+    sc_df["end"] = sc_df["end"].apply(parse_time_col)
 
-print(f"Loaded {len(FOLD_MODELS)} fold models")
+print("sc_df:", sc_df.shape)
+print("species:", len(SPECIES))
 
 # =========================
 # MODEL
@@ -86,26 +106,25 @@ class Model(nn.Module):
         super().__init__()
         self.backbone = timm.create_model(backbone, pretrained=False, in_chans=3, features_only=True)
         fi = self.backbone.feature_info
-        ch = fi[-2]['num_chs'] + fi[-1]['num_chs']
+        ch = fi[-2]["num_chs"] + fi[-1]["num_chs"]
         self.pool = nn.AdaptiveAvgPool2d(1)
         self.fc = nn.Linear(ch, CFG.num_classes)
 
     def forward(self, x):
-        f = self.backbone(x)
-        f3, f4 = f[-2], f[-1]
+        feats = self.backbone(x)
+        f3, f4 = feats[-2], feats[-1]
         if f3.shape[2:] != f4.shape[2:]:
-            f4 = F.interpolate(f4, size=f3.shape[2:])
+            f4 = F.interpolate(f4, size=f3.shape[2:], mode="bilinear", align_corners=False)
         x = torch.cat([f3, f4], 1)
-        x = self.pool(x).squeeze(-1).squeeze(-1)
+        x = self.pool(x).flatten(1)
         return self.fc(x)
 
 # =========================
-# DATASET for inference on soundscapes
+# DATASET
 # =========================
 class SoundscapeDS(Dataset):
-    def __init__(self, df, spec_cfg):
+    def __init__(self, df):
         self.df = df.reset_index(drop=True)
-        self.spec_cfg = spec_cfg
         self.cache = {}
 
     def __len__(self):
@@ -118,105 +137,82 @@ class SoundscapeDS(Dataset):
                 wav = wav.mean(0).numpy()
                 if sr != CFG.sr:
                     wav = librosa.resample(wav, orig_sr=sr, target_sr=CFG.sr)
-                self.cache[fname] = wav
+                self.cache[fname] = wav.astype(np.float32)
             except Exception:
                 self.cache[fname] = np.zeros(CFG.sr * 60, dtype=np.float32)
         return self.cache[fname]
 
-    def __getitem__(self, i):
-        r = self.df.iloc[i]
+    def __getitem__(self, idx):
+        r = self.df.iloc[idx]
         wav = self.load_audio(r["filename"])
-        start = int(r["start"] * CFG.sr)
+        start = int(float(r["start"]) * CFG.sr)
         chunk = wav[start:start + CFG.n_samples]
         if len(chunk) < CFG.n_samples:
             chunk = np.pad(chunk, (0, CFG.n_samples - len(chunk)))
-        mel = librosa.feature.melspectrogram(y=chunk, sr=CFG.sr, **self.spec_cfg)
-        mel = librosa.power_to_db(mel)
-        mel = (mel - mel.min()) / (mel.max() - mel.min() + 1e-6)
-        x = torch.tensor(mel).unsqueeze(0).repeat(3, 1, 1)
-        return x.float()
-
+        x_b0 = make_spec(chunk, CFG.spec_b0)
+        x_b3 = make_spec(chunk, CFG.spec_b3)
+        return x_b0, x_b3
 
 # =========================
-# GENERATE PSEUDO-LABELS
+# LOAD MODELS
 # =========================
-# Use train_soundscapes as target for pseudo-labeling
-sc_df = pd.read_csv(f"{DATA_DIR}/soundscape_labels_with_folds_fixed.csv")
+models = []
+for name in ["b0", "b3"]:
+    backbone = "tf_efficientnet_b0_ns" if name == "b0" else "tf_efficientnet_b3_ns"
+    for fold in range(5):
+        path = f"{MODEL_DIR}/{name}_fold{fold}.pt"
+        if not os.path.exists(path):
+            print("missing:", path)
+            continue
+        model = Model(backbone).to(CFG.device)
+        state = torch.load(path, map_location=CFG.device)
+        model.load_state_dict(state, strict=False)
+        model.eval()
+        models.append((name, model))
+        print("loaded:", path)
 
-# Create loader
-pseudo_ds = SoundscapeDS(sc_df, CFG.spec)
-pseudo_loader = DataLoader(pseudo_ds, batch_size=CFG.batch_size, shuffle=False,
-                           num_workers=CFG.num_workers, pin_memory=True)
+if len(models) == 0:
+    raise ValueError("No NB2 fold models found. Check MODEL_DIR.")
 
-# Ensemble inference
-all_preds = []
-all_labels = []
+print("ensemble size:", len(models))
 
+# =========================
+# PSEUDO-LABEL INFERENCE
+# =========================
+ds = SoundscapeDS(sc_df)
+dl = DataLoader(ds, batch_size=CFG.batch_size, shuffle=False,
+                num_workers=CFG.num_workers, pin_memory=True)
+
+all_preds = []
 with torch.no_grad():
-    for batch_idx, x in enumerate(pseudo_loader):
-        x = x.to(CFG.device)
-        logits_sum = None
-
-        for name, fold, path in FOLD_MODELS:
-            backbone = "tf_efficientnet_b0_ns" if name == "b0" else "tf_efficientnet_b3_ns"
-            model = Model(backbone).to(CFG.device)
-            state = torch.load(path, map_location=CFG.device)
-            model.load_state_dict(state, strict=False)
-            model.eval()
-
-            # TTA: original + time-reversed
-            out = model(x)
-            # time-reversed (flip mel time dimension)
-            x_rev = torch.flip(x, dims=[3])
-            out_rev = model(x_rev)
-
-            logits_sum = out + out_rev if logits_sum is None else logits_sum + out + out_rev
-
-        # Average across all models and TTA variants
-        avg_logits = logits_sum / (len(FOLD_MODELS) * 2)
-        probs = torch.sigmoid(avg_logits).cpu().numpy()
+    for bi, (x_b0, x_b3) in enumerate(dl):
+        x_b0 = x_b0.to(CFG.device, non_blocking=True)
+        x_b3 = x_b3.to(CFG.device, non_blocking=True)
+        logits_list = []
+        for name, model in models:
+            x = x_b0 if name == "b0" else x_b3
+            with autocast("cuda", dtype=torch.float16, enabled=(CFG.device == "cuda")):
+                logits_list.append(model(x).detach().float().cpu().numpy())
+        avg_logits = np.mean(logits_list, axis=0)
+        probs = 1.0 / (1.0 + np.exp(-avg_logits))
         all_preds.append(probs)
+        if (bi + 1) % 50 == 0:
+            print(f"batch {bi+1}/{len(dl)}")
 
-        if (batch_idx + 1) % 50 == 0:
-            print(f"  Batch {batch_idx+1}/{len(pseudo_loader)}")
-
-        del model
-        gc.collect()
-        torch.cuda.empty_cache()
+preds = np.concatenate(all_preds, axis=0)
 
-all_preds = np.concatenate(all_preds)
-
-# Create pseudo-label dataframe
-pseudo_df = sc_df.copy()
+pseudo_soft = sc_df.copy()
 for i, sp in enumerate(SPECIES):
-    pseudo_df[sp] = all_preds[:, i]
-
-# Save pseudo-labels (soft labels)
-pseudo_df.to_csv(f"{OUTPUT_DIR}/pseudo_labels_soft.csv", index=False)
-print(f"Saved soft pseudo-labels: {OUTPUT_DIR}/pseudo_labels_soft.csv")
+    pseudo_soft[sp] = preds[:, i]
+pseudo_soft.to_csv(f"{OUTPUT_DIR}/pseudo_labels_soft.csv", index=False)
 
-# Also create hard pseudo-labels (threshold > 0.5)
-hard_pseudo = sc_df.copy()
+pseudo_hard = sc_df.copy()
 for i, sp in enumerate(SPECIES):
-    hard_pseudo[sp] = (all_preds[:, i] > 0.5).astype(int)
-
-# Only keep rows with at least one confident prediction
-confident_mask = (all_preds > 0.5).any(axis=1)
-hard_pseudo_confident = hard_pseudo[confident_mask].copy()
-
-print(f"  Total soundscape segments: {len(sc_df)}")
-print(f"  Confident pseudo-labels (>0.5): {confident_mask.sum()}")
-
-hard_pseudo_confident.to_csv(f"{OUTPUT_DIR}/pseudo_labels_hard_confident.csv", index=False)
-print(f"Saved hard confident pseudo-labels")
-
-# =========================
-# NOISY STUDENT RETRAINING (Optional — train one more round)
-# =========================
-# Use soft pseudo-labels as training targets
-# This is a simplified version — you can integrate into NB2 for full retraining
-
-print("\n" + "="*60)
-print("PSEUDO-LABELING COMPLETE")
-print("="*60)
-print("Next: Use pseudo_labels_soft.csv as additional training data in NB2")
+    pseudo_hard[sp] = (preds[:, i] > 0.5).astype(np.int8)
+conf_mask = (preds > 0.5).any(axis=1)
+pseudo_hard_conf = pseudo_hard[conf_mask].copy()
+pseudo_hard_conf.to_csv(f"{OUTPUT_DIR}/pseudo_labels_hard_confident.csv", index=False)
+
+print("saved:", f"{OUTPUT_DIR}/pseudo_labels_soft.csv")
+print("saved:", f"{OUTPUT_DIR}/pseudo_labels_hard_confident.csv")
+print("confident rows:", int(conf_mask.sum()), "/", len(sc_df))