scripts/05_rawnet.py

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   # 64 000

BATCH  = 32
EPOCHS = 20
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_waveform(path, sr=SR, n_samples=N_SAMPLES):
    y, _ = librosa.load(path, sr=sr, mono=True)
    if len(y) < n_samples:
        y = np.pad(y, (0, n_samples - len(y)))
    return y[:n_samples].astype(np.float32)


class WaveDataset(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]
        wav = load_waveform(self.audio_dir / row["id"])
        wav = torch.from_numpy(wav)
        if self.has_labels:
            return wav, torch.tensor(row["label"], dtype=torch.float32)
        return wav, row["id"]


class ResBlock1D(nn.Module):
    """Residual block for 1D convolutions."""
    def __init__(self, channels, kernel_size=3, stride=2):
        super().__init__()
        self.conv = nn.Conv1d(channels, channels, kernel_size,
                              stride=stride, padding=kernel_size // 2)
        self.bn   = nn.BatchNorm1d(channels)
        self.act  = nn.LeakyReLU(0.3)
        # shortcut with matching stride
        self.shortcut = nn.Sequential(
            nn.Conv1d(channels, channels, 1, stride=stride),
            nn.BatchNorm1d(channels),
        )

    def forward(self, x):
        return self.act(self.conv(x) + self.shortcut(x))


class RawNet(nn.Module):
    def __init__(self):
        super().__init__()
        # stem
        self.conv1 = nn.Conv1d(1, 128, kernel_size=3, stride=3, padding=1)
        self.bn1   = nn.BatchNorm1d(128)

        # 3 blocks: 128→128, then project 128→256, 256→256
        self.proj = nn.Sequential(
            nn.Conv1d(128, 256, 1), nn.BatchNorm1d(256), nn.LeakyReLU(0.3)
        )
        self.blocks = nn.Sequential(
            ResBlock1D(128, stride=2),
            ResBlock1D(128, stride=2),
        )
        self.blocks2 = nn.Sequential(
            ResBlock1D(256, stride=2),
            ResBlock1D(256, stride=2),
            ResBlock1D(256, stride=2),
        )

        self.gru  = nn.GRU(256, 128, batch_first=True, bidirectional=True)
        self.head = nn.Linear(256, 1)

    def forward(self, x):
        x = x.unsqueeze(1)                          # (B, 1, T)
        x = torch.relu(self.bn1(self.conv1(x)))     # (B, 128, T/3)
        x = self.blocks(x)                          # (B, 128, T')
        x = self.proj(x)                            # (B, 256, T')
        x = self.blocks2(x)                         # (B, 256, T'')
        x = x.permute(0, 2, 1)                      # (B, T'', 256)
        x, _ = self.gru(x)                          # (B, T'', 256)
        x = x.mean(1)                               # (B, 256)
        return self.head(x).squeeze(-1)             # (B,)


# quick shape test
_m = RawNet()
_x = torch.randn(2, N_SAMPLES)
print("Output shape:", _m(_x).shape)   # (2,)


tr_df, val_df = train_test_split(train_df, test_size=0.2,
                                  random_state=42, stratify=train_df["label"])

tr_loader   = DataLoader(WaveDataset(tr_df,  AUDIO_DIR), batch_size=BATCH, shuffle=True,  num_workers=2)
val_loader  = DataLoader(WaveDataset(val_df, AUDIO_DIR), batch_size=BATCH, shuffle=False, num_workers=2)
test_loader = DataLoader(WaveDataset(test_df, AUDIO_DIR, has_labels=False),
                          batch_size=BATCH, shuffle=False, num_workers=2)


model     = RawNet().to(DEVICE)
optimizer = torch.optim.Adam(model.parameters(), lr=LR, weight_decay=1e-4)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=EPOCHS)
criterion = nn.BCEWithLogitsLoss()

train_losses, val_aurocs = [], []

for epoch in range(1, EPOCHS + 1):
    model.train()
    total_loss = 0.0
    for wav, label in tr_loader:
        wav, label = wav.to(DEVICE), label.to(DEVICE)
        optimizer.zero_grad()
        logits = model(wav)
        loss   = criterion(logits, label)
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()
        total_loss += loss.item() * len(label)
    scheduler.step()

    model.eval()
    all_probs, all_labels = [], []
    with torch.no_grad():
        for wav, label in val_loader:
            wav = wav.to(DEVICE)
            probs = torch.sigmoid(model(wav)).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_rawnet.pt")
print("Model saved to model_rawnet.pt")

model.eval()
ids_out, probs_out = [], []
with torch.no_grad():
    for wav, ids in test_loader:
        wav = wav.to(DEVICE)
        probs = torch.sigmoid(model(wav)).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_rawnet.npy", probs_out)

submission = pd.DataFrame({"id": ids_out, "score": probs_out})
submission.to_csv("submission_rawnet.csv", index=False)
print(submission.head())
print("Saved submission_rawnet.csv  |  probs_rawnet.npy")


try:
    probs_cnn = np.load("probs_cnn.npy")
    ensemble_score = 0.5 * probs_out + 0.5 * probs_cnn
    sub_ensemble = pd.DataFrame({"id": ids_out, "score": ensemble_score})
    sub_ensemble.to_csv("submission_ensemble.csv", index=False)
    print("Ensemble submission saved to submission_ensemble.csv")
    print(sub_ensemble.head())
except FileNotFoundError:
    print("probs_cnn.npy not found — run notebook 04 first for ensemble.")