Upload model_checkpoints/Primitive_Extractor/esc50/training_script.md with huggingface_hub

model_checkpoints/Primitive_Extractor/esc50/training_script.md

@@ -0,0 +1,270 @@
+# Primitive Extractor Training Script
+
+## Training Configuration
+- **Model**: PrimitiveExtractor + ClassifierHead
+- **Dataset**: ESC-50 (2000 samples, 50 classes)
+- **Train/Val Split**: 1600 / 400
+- **Feature Extractor**: BEATs (frozen, 768-dim output)
+- **Epochs**: 5
+- **Batch Size**: 16
+- **Optimizer**: AdamW (lr=1e-4, weight_decay=1e-2)
+- **Loss**: Weighted BCEWithLogitsLoss
+- **Checkpoint Metric**: Validation mAP
+
+## Results Summary
+- **Best Val mAP**: 98.29% (Epoch 5)
+- **Best Val Acc**: 95.25% (Epoch 5)
+- **Final Train Loss**: 0.0198
+
+## Training Script
+
+```python
+import os
+import sys
+import json
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torchaudio
+import numpy as np
+from pathlib import Path
+from sklearn.metrics import accuracy_score, average_precision_score
+from huggingface_hub import HfApi
+from google.colab import drive
+
+# ==========================================
+# 1. SETUP & PATHS
+# ==========================================
+drive.mount('/content/drive', force_remount=False)
+
+AUDIO_DIR = '/content/drive/MyDrive/esc50/audio'
+JSON_PATH = '/content/drive/MyDrive/esc50/causal_labels.json'
+BEATS_CKPT = '/content/drive/MyDrive/WindOneSound_300M/training_checkpoints/v2/beats_pretrained_as2m.pt'
+BEATS_SRC = '/content/drive/MyDrive/WindOneSound_300M/model/beats_official'
+CACHE_DIR = '/content/esc50_cache'
+os.makedirs(CACHE_DIR, exist_ok=True)
+
+# Add BEATs source to path
+sys.path.append(BEATS_SRC)
+from BEATs import BEATs, BEATsConfig
+
+# Add WindOne to path
+sys.path.append('/content/drive/MyDrive/WindOneSound_300M')
+from model_v3.primitive_extractor import PrimitiveExtractor
+
+# ==========================================
+# 2. LOAD JSON & BUILD LABEL MAP
+# ==========================================
+with open(JSON_PATH, 'r') as f:
+    label_data = json.load(f)
+
+# Create mapping: clip_id -> integer label (0-49)
+clip_to_label = {item['clip_id']: item['label'] for item in label_data}
+unique_labels = sorted(list(set(clip_to_label.values())))
+label_to_id = {label: idx for idx, label in enumerate(unique_labels)}
+num_classes = len(unique_labels) # Should be 50
+
+print(f"✅ Loaded {len(label_data)} JSON entries. Found {num_classes} unique classes.")
+
+# ==========================================
+# 3. LOAD FROZEN BEATs
+# ==========================================
+print("📦 Loading frozen BEATs...")
+checkpoint = torch.load(BEATS_CKPT, map_location='cpu')
+cfg = BEATsConfig(checkpoint['cfg'])
+beats_model = BEATs(cfg)
+beats_model.load_state_dict(checkpoint['model'])
+beats_model.eval()
+
+for param in beats_model.parameters():
+    param.requires_grad = False
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+beats_model = beats_model.to(device)
+
+# ==========================================
+# 4. FEATURE EXTRACTION & CACHING
+# ==========================================
+print("🔄 Extracting and caching BEATs features (this runs once)...")
+audio_files = [f for f in os.listdir(AUDIO_DIR) if f.endswith('.wav')]
+cached_count = 0
+
+for filename in audio_files:
+    cache_path = os.path.join(CACHE_DIR, f"{filename}.pt")
+    if os.path.exists(cache_path):
+        cached_count += 1
+        continue
+        
+    filepath = os.path.join(AUDIO_DIR, filename)
+    waveform, sr = torchaudio.load(filepath)
+    
+    # Convert to mono and resample to 16kHz for BEATs
+    if waveform.shape[0] > 1:
+        waveform = torch.mean(waveform, dim=0, keepdim=True)
+    if sr != 16000:
+        waveform = torchaudio.functional.resample(waveform, sr, 16000)
+        
+    # Pad or truncate to 5 seconds (80,000 samples)
+    target_len = 80000
+    if waveform.shape[1] < target_len:
+        waveform = torch.nn.functional.pad(waveform, (0, target_len - waveform.shape[1]))
+    else:
+        waveform = waveform[:, :target_len]
+        
+    waveform = waveform.to(device)
+    
+    with torch.no_grad():
+        features, _ = beats_model.extract_features(waveform)
+        
+    # features shape: [1, T, 768]. Squeeze to [T, 768]
+    features = features.squeeze(0).cpu()
+    label_id = label_to_id[clip_to_label[filename]]
+    
+    torch.save({'features': features, 'label': label_id}, cache_path)
+    cached_count += 1
+
+print(f"✅ Cached {cached_count} / {len(audio_files)} files to {CACHE_DIR}")
+
+# ==========================================
+# 5. DATASET & DATALOADER
+# ==========================================
+class ESC50CacheDataset(torch.utils.data.Dataset):
+    def __init__(self, cache_dir, split='train', train_ratio=0.8):
+        self.cache_files = [f for f in os.listdir(cache_dir) if f.endswith('.pt')]
+        self.cache_files.sort()
+        split_idx = int(len(self.cache_files) * train_ratio)
+        self.files = self.cache_files[:split_idx] if split == 'train' else self.cache_files[split_idx:]
+
+    def __len__(self):
+        return len(self.files)
+
+    def __getitem__(self, idx):
+        data = torch.load(os.path.join(CACHE_DIR, self.files[idx]), weights_only=True)
+        return data['features'], data['label']
+
+train_dataset = ESC50CacheDataset(CACHE_DIR, split='train')
+val_dataset = ESC50CacheDataset(CACHE_DIR, split='val')
+
+train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=16, shuffle=True, num_workers=2)
+val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=16, shuffle=False, num_workers=2)
+
+print(f"✅ Train size: {len(train_dataset)}, Val size: {len(val_dataset)}")
+
+# ==========================================
+# 6. MODEL DEFINITION & PARAM COUNT
+# ==========================================
+class PrimitiveTrainModel(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.extractor = PrimitiveExtractor(input_dim=768, hidden_dim=1728, output_dim=512)
+        self.classifier = nn.Linear(512, num_classes)
+
+    def forward(self, x):
+        primitives = self.extractor(x) 
+        pooled = primitives.mean(dim=1) 
+        logits = self.classifier(pooled) 
+        return logits
+
+model = PrimitiveTrainModel().to(device)
+
+# --- PARAMETER COUNTING ---
+extractor_params = sum(p.numel() for p in model.extractor.parameters() if p.requires_grad)
+classifier_params = sum(p.numel() for p in model.classifier.parameters() if p.requires_grad)
+total_trainable_params = extractor_params + classifier_params
+
+print(f"\n📊 PARAMETER COUNTS:")
+print(f"   ├─ Primitive Extractor : {extractor_params:,} params")
+print(f"   ├─ Classifier Head     : {classifier_params:,} params")
+print(f"   └─ Total Trainable     : {total_trainable_params:,} params\n")
+
+# Weighted BCE
+class_counts = np.zeros(num_classes)
+for _, label in train_dataset:
+    class_counts[label] += 1
+pos_weights = torch.tensor((len(train_dataset) - class_counts) / (class_counts + 1e-5), dtype=torch.float32).to(device)
+criterion = nn.BCEWithLogitsLoss(pos_weight=pos_weights)
+optimizer = optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-2)
+
+# ==========================================
+# 7. TRAINING LOOP (MAX 5 EPOCHS)
+# ==========================================
+num_epochs = 5
+best_val_map = -1.0
+api = HfApi()
+repo_id = "Hitelcy/WindoneRepo2"
+
+print("🚀 Starting Training (Max 5 Epochs)...")
+
+for epoch in range(1, num_epochs + 1):
+    model.train()
+    train_losses = []
+    
+    for features, labels in train_loader:
+        features = features.to(device)
+        labels = labels.to(device)
+        
+        targets = torch.nn.functional.one_hot(labels, num_classes=num_classes).float()
+        
+        optimizer.zero_grad()
+        logits = model(features)
+        loss = criterion(logits, targets)
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+        optimizer.step()
+        
+        train_losses.append(loss.item())
+
+    # --- VALIDATION ---
+    model.eval()
+    val_preds = []
+    val_targets = []
+    
+    with torch.no_grad():
+        for features, labels in val_loader:
+            features = features.to(device)
+            labels = labels.to(device)
+            
+            logits = model(features)
+            probs = torch.sigmoid(logits).cpu().numpy()
+            
+            val_preds.append(probs)
+            val_targets.append(torch.nn.functional.one_hot(labels, num_classes=num_classes).cpu().numpy())
+
+    val_preds = np.vstack(val_preds)
+    val_targets = np.vstack(val_targets)
+    
+    # Calculate Metrics as percentages
+    val_acc = accuracy_score(np.argmax(val_targets, axis=1), np.argmax(val_preds, axis=1)) * 100
+    val_map = average_precision_score(val_targets, val_preds, average='macro') * 100
+    
+    print(f"Epoch {epoch}/{num_epochs} | Train Loss: {np.mean(train_losses):.4f} | Val Acc: {val_acc:.2f}% | Val mAP: {val_map:.2f}%")
+
+    # --- CHECKPOINTING ---
+    if val_map > best_val_map:
+        best_val_map = val_map
+        print(f"🌟 New best Val mAP! Saving checkpoint to Hugging Face...")
+        
+        save_path = "model_checkpoints/Primitive_Extractor/esc50/primitive_extractor_esc50_best.pt"
+        
+        torch.save({
+            'epoch': epoch,
+            'model_state_dict': model.state_dict(),
+            'val_map': val_map,
+            'val_acc': val_acc,
+            'label_to_id': label_to_id
+        }, '/tmp/primitive_best.pt')
+        
+        try:
+            api.upload_file(
+                path_or_fileobj='/tmp/primitive_best.pt',
+                path_in_repo=save_path,
+                repo_id=repo_id,
+                repo_type="dataset"
+            )
+            print(f"✅ Successfully uploaded checkpoint to {repo_id}/{save_path}")
+        except Exception as e:
+            print(f"❌ HF Upload failed: {e}")
+
+print("\n🎉 Training complete!")
+print(f"Best Validation mAP achieved: {best_val_map:.2f}%")
+```