from pathlib import Path import numpy as np import pandas as pd import librosa import torch import torch.nn as nn from torch.utils.data import Dataset, DataLoader from sklearn.model_selection import train_test_split from sklearn.metrics import roc_auc_score, confusion_matrix, ConfusionMatrixDisplay import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt import warnings warnings.filterwarnings("ignore") DATA_DIR = Path("output/voiceguard") AUDIO_DIR = DATA_DIR SR = 16_000 DURATION = 4 N_SAMPLES = SR * DURATION N_MELS = 80 N_FFT = 512 HOP = 128 BATCH = 128 EPOCHS = 50 LR = 1e-3 DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") print("Device:", DEVICE) train_df = pd.read_csv(DATA_DIR / "train.csv") train_df["label"] = (train_df["label"] == "fake").astype(int) test_df = pd.read_csv(DATA_DIR / "test.csv") print("Train:", train_df.shape, " Test:", test_df.shape) def load_mel(path, sr=SR, n_samples=N_SAMPLES, n_mels=N_MELS, n_fft=N_FFT, hop=HOP): y, _ = librosa.load(path, sr=sr, mono=True) if len(y) < n_samples: y = np.pad(y, (0, n_samples - len(y))) y = y[:n_samples] mel = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=n_mels, n_fft=n_fft, hop_length=hop) mel_db = librosa.power_to_db(mel, ref=np.max) # per-sample normalization mel_db = (mel_db - mel_db.mean()) / (mel_db.std() + 1e-8) return mel_db.astype(np.float32) # (n_mels, T) # quick shape check _sample = load_mel(AUDIO_DIR / train_df.iloc[0]["id"]) print("Mel shape:", _sample.shape) # expected ~(80, 501) class MelDataset(Dataset): def __init__(self, df, audio_dir, has_labels=True): self.df = df.reset_index(drop=True) self.audio_dir = audio_dir self.has_labels = has_labels def __len__(self): return len(self.df) def __getitem__(self, idx): row = self.df.iloc[idx] mel = load_mel(self.audio_dir / row["id"]) mel = torch.from_numpy(mel).unsqueeze(0) # (1, n_mels, T) if self.has_labels: return mel, torch.tensor(row["label"], dtype=torch.float32) return mel, row["id"] class MelCNN(nn.Module): def __init__(self): super().__init__() self.features = nn.Sequential( nn.Conv2d(1, 64, kernel_size=3, padding=1), nn.BatchNorm2d(64), nn.ReLU(), nn.MaxPool2d(2), nn.Conv2d(64, 128, kernel_size=3, padding=1), nn.BatchNorm2d(128), nn.ReLU(), nn.MaxPool2d(2), nn.Conv2d(128, 256, kernel_size=3, padding=1), nn.BatchNorm2d(256), nn.ReLU(), nn.AdaptiveAvgPool2d((1, 1)), ) self.head = nn.Linear(256, 1) def forward(self, x): x = self.features(x) # (B, 256, 1, 1) x = x.view(x.size(0), -1) # (B, 256) return self.head(x).squeeze(1) # (B,) logits tr_df, val_df = train_test_split(train_df, test_size=0.2, random_state=42, stratify=train_df["label"]) tr_loader = DataLoader(MelDataset(tr_df, AUDIO_DIR), batch_size=BATCH, shuffle=True, num_workers=8, pin_memory=True) val_loader = DataLoader(MelDataset(val_df, AUDIO_DIR), batch_size=BATCH, shuffle=False, num_workers=8, pin_memory=True) test_loader = DataLoader(MelDataset(test_df, AUDIO_DIR, has_labels=False), batch_size=BATCH, shuffle=False, num_workers=8, pin_memory=True) model = MelCNN().to(DEVICE) optimizer = torch.optim.Adam(model.parameters(), lr=LR) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=EPOCHS) criterion = nn.BCEWithLogitsLoss() scaler = torch.cuda.amp.GradScaler() train_losses, val_aurocs = [], [] for epoch in range(1, EPOCHS + 1): model.train() total_loss = 0.0 for mel, label in tr_loader: mel, label = mel.to(DEVICE), label.to(DEVICE) optimizer.zero_grad() with torch.cuda.amp.autocast(): logits = model(mel) loss = criterion(logits, label) scaler.scale(loss).backward() scaler.step(optimizer) scaler.update() total_loss += loss.item() * len(label) scheduler.step() # validation AUROC model.eval() all_probs, all_labels = [], [] with torch.no_grad(): for mel, label in val_loader: mel = mel.to(DEVICE) with torch.cuda.amp.autocast(): logits = model(mel) probs = torch.sigmoid(logits).cpu().numpy() all_probs.extend(probs) all_labels.extend(label.numpy()) auroc = roc_auc_score(all_labels, all_probs) avg_loss = total_loss / len(tr_df) train_losses.append(avg_loss) val_aurocs.append(auroc) print(f"Epoch {epoch:02d}/{EPOCHS} loss={avg_loss:.4f} val_AUROC={auroc:.4f}") fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(11, 4)) ax1.plot(train_losses, marker="o"); ax1.set_title("Train Loss"); ax1.set_xlabel("Epoch") ax2.plot(val_aurocs, marker="o", color="tomato"); ax2.set_title("Val AUROC"); ax2.set_xlabel("Epoch") plt.tight_layout(); plt.savefig("/dev/null") print(f"Best val AUROC: {max(val_aurocs):.4f} at epoch {np.argmax(val_aurocs)+1}") val_preds = (np.array(all_probs) >= 0.5).astype(int) cm = confusion_matrix(all_labels, val_preds) disp = ConfusionMatrixDisplay(cm, display_labels=["real", "fake"]) fig, ax = plt.subplots(figsize=(4, 4)) disp.plot(ax=ax, colorbar=False) ax.set_title(f"Confusion Matrix AUROC={val_aurocs[-1]:.3f}") plt.tight_layout() plt.savefig("/dev/null") torch.save(model.state_dict(), "model_cnn_mel.pt") print("Model saved to model_cnn_mel.pt") model.eval() ids_out, probs_out = [], [] with torch.no_grad(): for mel, ids in test_loader: mel = mel.to(DEVICE) logits = model(mel) probs = torch.sigmoid(logits).cpu().numpy() probs_out.extend(probs) ids_out.extend(ids if isinstance(ids[0], str) else [i.item() for i in ids]) probs_out = np.array(probs_out) np.save("probs_cnn.npy", probs_out) submission = pd.DataFrame({"id": ids_out, "score": probs_out}) submission.to_csv("submission_cnn_mel.csv", index=False) print(submission.head()) print("Saved submission_cnn_mel.csv | probs_cnn.npy")