from pathlib import Path import numpy as np import pandas as pd from tqdm import tqdm import librosa import warnings warnings.filterwarnings("ignore") import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import Dataset, DataLoader from sklearn.model_selection import train_test_split from sklearn.preprocessing import LabelEncoder from sklearn.metrics import f1_score, classification_report DATA_DIR = Path("output/linguawave") SAMPLE_RATE = 16_000 DURATION = 10 N_SAMPLES = SAMPLE_RATE * DURATION # 160_000 CLASSES = ["id", "ms", "vi", "th", "en", "zh", "ar", "fr"] N_CLASSES = len(CLASSES) # Mel-spectrogram params N_MELS = 128 N_FFT = 1024 HOP_LENGTH = 256 # expected time frames ≈ N_SAMPLES / HOP_LENGTH = 160000/256 = 625 DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") print("Device:", DEVICE) class MelDataset(Dataset): def __init__(self, df, data_dir, label_encoder, n_mels=N_MELS, n_fft=N_FFT, hop_length=HOP_LENGTH, augment=False): self.df = df.reset_index(drop=True) self.data_dir = data_dir self.le = label_encoder self.n_mels = n_mels self.n_fft = n_fft self.hop_length = hop_length self.augment = augment self.has_labels = "label" in df.columns def __len__(self): return len(self.df) def _load_mel(self, fpath): y, _ = librosa.load(str(fpath), sr=SAMPLE_RATE, duration=DURATION) if len(y) < N_SAMPLES: y = np.pad(y, (0, N_SAMPLES - len(y))) else: y = y[:N_SAMPLES] if self.augment: # Time shift augmentation shift = np.random.randint(-SAMPLE_RATE, SAMPLE_RATE) y = np.roll(y, shift) mel = librosa.feature.melspectrogram( y=y, sr=SAMPLE_RATE, n_mels=self.n_mels, n_fft=self.n_fft, hop_length=self.hop_length ) log_mel = librosa.power_to_db(mel, ref=np.max).astype(np.float32) # Normalise to [-1, 1] log_mel = (log_mel - log_mel.mean()) / (log_mel.std() + 1e-8) return log_mel[np.newaxis, :, :] # (1, n_mels, T) def __getitem__(self, idx): row = self.df.iloc[idx] mel = self._load_mel(self.data_dir / row["id"]) if self.has_labels: label = self.le.transform([row["label"]])[0] return torch.tensor(mel), label return torch.tensor(mel) class ConvBlock(nn.Module): def __init__(self, in_ch, out_ch): super().__init__() self.net = nn.Sequential( nn.Conv2d(in_ch, out_ch, kernel_size=3, padding=1), nn.BatchNorm2d(out_ch), nn.ReLU(inplace=True), nn.Conv2d(out_ch, out_ch, kernel_size=3, padding=1), nn.BatchNorm2d(out_ch), nn.ReLU(inplace=True), nn.MaxPool2d(2, 2), ) def forward(self, x): return self.net(x) class MelCNN(nn.Module): def __init__(self, n_classes=N_CLASSES): super().__init__() self.features = nn.Sequential( ConvBlock(1, 32), # (1, 128, 625) → (32, 64, 312) ConvBlock(32, 64), # → (64, 32, 156) ConvBlock(64, 128), # → (128, 16, 78) ConvBlock(128, 256), # → (256, 8, 39) nn.AdaptiveAvgPool2d(1), # → (256, 1, 1) ) self.head = nn.Sequential( nn.Flatten(), nn.Linear(256, 128), nn.ReLU(inplace=True), nn.Dropout(0.5), nn.Linear(128, n_classes), ) def forward(self, x): x = self.features(x) return self.head(x) model = MelCNN().to(DEVICE) print(model) total_params = sum(p.numel() for p in model.parameters() if p.requires_grad) print(f"Trainable params: {total_params:,}") train_df = pd.read_csv(DATA_DIR / "train.csv") test_df = pd.read_csv(DATA_DIR / "test.csv") le = LabelEncoder() le.fit(CLASSES) tr_df, val_df = train_test_split( train_df, test_size=0.15, random_state=42, stratify=train_df["label"] ) BATCH = 64 train_ds = MelDataset(tr_df, DATA_DIR, le, augment=True) val_ds = MelDataset(val_df, DATA_DIR, le, augment=False) test_ds = MelDataset(test_df, DATA_DIR, le, augment=False) train_loader = DataLoader(train_ds, batch_size=BATCH, shuffle=True, num_workers=4, pin_memory=True) val_loader = DataLoader(val_ds, batch_size=BATCH, shuffle=False, num_workers=4, pin_memory=True) test_loader = DataLoader(test_ds, batch_size=BATCH, shuffle=False, num_workers=4, pin_memory=True) print(f"Train batches: {len(train_loader)} Val batches: {len(val_loader)}") EPOCHS = 5 criterion = nn.CrossEntropyLoss() optimizer = optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4) scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=EPOCHS) scaler = torch.cuda.amp.GradScaler() history = {"train_loss": [], "val_f1": []} best_f1 = 0.0 best_weights = None for epoch in range(1, EPOCHS + 1): # ── train ────────────────────────────────────────────────── model.train() running_loss = 0.0 for X_batch, y_batch in tqdm(train_loader, desc=f"Epoch {epoch:02d} train", leave=False): X_batch = X_batch.to(DEVICE) y_batch = y_batch.to(DEVICE) optimizer.zero_grad() with torch.cuda.amp.autocast(): logits = model(X_batch) loss = criterion(logits, y_batch) scaler.scale(loss).backward() scaler.step(optimizer) scaler.update() running_loss += loss.item() * len(y_batch) train_loss = running_loss / len(train_ds) # ── validate ──────────────────────────────────────────────── model.eval() all_preds, all_labels = [], [] with torch.no_grad(): for X_batch, y_batch in val_loader: X_batch = X_batch.to(DEVICE) with torch.cuda.amp.autocast(): preds = model(X_batch).argmax(dim=1).cpu().numpy() all_preds.extend(preds) all_labels.extend(y_batch.numpy()) val_f1 = f1_score(all_labels, all_preds, average="macro") history["train_loss"].append(train_loss) history["val_f1"].append(val_f1) scheduler.step() if val_f1 > best_f1: best_f1 = val_f1 best_weights = {k: v.clone() for k, v in model.state_dict().items()} print(f"Epoch {epoch:02d}/{EPOCHS} loss={train_loss:.4f} val_F1={val_f1:.4f} best={best_f1:.4f}") print(f"\nBest validation Macro F1: {best_f1:.4f}") import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4)) ax1.plot(history["train_loss"]) ax1.set_title("Training Loss") ax1.set_xlabel("Epoch") ax2.plot(history["val_f1"]) ax2.set_title("Validation Macro F1") ax2.set_xlabel("Epoch") plt.tight_layout() plt.savefig("/dev/null") model.load_state_dict(best_weights) model.eval() all_preds, all_labels = [], [] with torch.no_grad(): for X_batch, y_batch in val_loader: X_batch = X_batch.to(DEVICE) preds = model(X_batch).argmax(dim=1).cpu().numpy() all_preds.extend(preds) all_labels.extend(y_batch.numpy()) print(f"Final validation Macro F1: {f1_score(all_labels, all_preds, average='macro'):.4f}") print() print(classification_report(all_labels, all_preds, target_names=le.classes_)) Path("submissions").mkdir(exist_ok=True) # Save model torch.save(best_weights, "submissions/model_approach4_cnn_mel.pt") print("Model saved.") # Generate test probabilities model.eval() all_probs = [] with torch.no_grad(): for X_batch in tqdm(DataLoader(test_ds, batch_size=64, num_workers=4, pin_memory=True), desc="Test inference"): if isinstance(X_batch, (list, tuple)): X_batch = X_batch[0] X_batch = X_batch.to(DEVICE) with torch.cuda.amp.autocast(): probs = torch.softmax(model(X_batch), dim=1).cpu().numpy() all_probs.append(probs) test_probs = np.vstack(all_probs) np.save("submissions/probs_approach4_cnn_mel.npy", test_probs) print("Test probabilities saved. Shape:", test_probs.shape) # Submission CSV test_preds = le.inverse_transform(test_probs.argmax(axis=1)) sub = pd.DataFrame({"id": test_df["id"], "label": test_preds}) sub.to_csv("submissions/sub_approach4_cnn_mel.csv", index=False) print("Saved submissions/sub_approach4_cnn_mel.csv") sub.head()