Upload 5 files

config.json

@@ -0,0 +1,77 @@
+{
+  "_name_or_path": "facebook/wav2vec2-base-960h",
+  "activation_dropout": 0.1,
+  "apply_spec_augment": true,
+  "architectures": [
+    "Wav2Vec2ForCTC"
+  ],
+  "attention_dropout": 0.1,
+  "bos_token_id": 1,
+  "codevector_dim": 256,
+  "contrastive_logits_temperature": 0.1,
+  "conv_bias": false,
+  "conv_dim": [
+    512,
+    512,
+    512,
+    512,
+    512,
+    512,
+    512
+  ],
+  "conv_kernel": [
+    10,
+    3,
+    3,
+    3,
+    3,
+    2,
+    2
+  ],
+  "conv_stride": [
+    5,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2
+  ],
+  "ctc_loss_reduction": "sum",
+  "ctc_zero_infinity": false,
+  "diversity_loss_weight": 0.1,
+  "do_stable_layer_norm": false,
+  "eos_token_id": 2,
+  "feat_extract_activation": "gelu",
+  "feat_extract_dropout": 0.0,
+  "feat_extract_norm": "group",
+  "feat_proj_dropout": 0.1,
+  "feat_quantizer_dropout": 0.0,
+  "final_dropout": 0.1,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout": 0.1,
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "layer_norm_eps": 1e-05,
+  "layerdrop": 0.1,
+  "mask_feature_length": 10,
+  "mask_feature_prob": 0.0,
+  "mask_time_length": 10,
+  "mask_time_prob": 0.05,
+  "model_type": "wav2vec2",
+  "num_attention_heads": 12,
+  "num_codevector_groups": 2,
+  "num_codevectors_per_group": 320,
+  "num_conv_pos_embedding_groups": 16,
+  "num_conv_pos_embeddings": 128,
+  "num_feat_extract_layers": 7,
+  "num_hidden_layers": 12,
+  "num_negatives": 100,
+  "pad_token_id": 0,
+  "proj_codevector_dim": 256,
+  "transformers_version": "4.7.0.dev0",
+  "vocab_size": 32
+}

preprocessor_config.json

@@ -0,0 +1,8 @@
+{
+  "do_normalize": true,
+  "feature_size": 1,
+  "padding_side": "right",
+  "padding_value": 0.0,
+  "return_attention_mask": false,
+  "sampling_rate": 16000
+}

pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c34f9827b034a1b9141dbf6f652f8a60eda61cdf5771c9e05bfa99033c92cd96
+size 377667514

train_wav2vec_base.py

@@ -0,0 +1,379 @@
+# train_wav2vec2_stream_4090_winfix.py
+import os
+# ✅ 关键修复：禁止 torch.compile/torchdynamo 触发 cProfile/profile 冲突
+os.environ["TORCHDYNAMO_DISABLE"] = "1"
+os.environ["TORCH_COMPILE_DISABLE"] = "1"
+
+import json
+import time
+import math
+import argparse
+from glob import glob
+import io
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+
+from datasets import load_dataset, Audio
+from transformers import AutoFeatureExtractor, Wav2Vec2ForSequenceClassification
+
+import soundfile as sf
+
+
+# ==============
+# 默认：离线 + 国内环境
+# ==============
+os.environ.setdefault("HF_HUB_OFFLINE", "1")
+os.environ.setdefault("TRANSFORMERS_OFFLINE", "1")
+
+# ✅ 再保险：显式 disable dynamo（某些 torch 版本更稳）
+try:
+    import torch._dynamo
+    torch._dynamo.disable()
+except Exception:
+    pass
+
+AUDIO_COL = "wav"
+PARQUET_KEY_COL = "__key__"
+JSONL_KEY_COL = "member"
+JSONL_LABEL_COL = "key"
+
+
+def parse_args():
+    p = argparse.ArgumentParser()
+
+    p.add_argument("--data_dir", type=str, default=r"./ASV_Spoof_2019_LA_SNR_50MB")
+    p.add_argument("--model_dir", type=str, default=r"./wav2vecbase")
+    p.add_argument("--out", type=str, default="./wav2vec2_stream_out_4090")
+
+    p.add_argument("--sr", type=int, default=16000)
+    p.add_argument("--max_sec", type=float, default=6.0)
+
+    p.add_argument("--epochs", type=int, default=3)
+    p.add_argument("--batch", type=int, default=16)
+    p.add_argument("--grad_accum", type=int, default=1)
+
+    p.add_argument("--lr", type=float, default=2e-5)
+    p.add_argument("--weight_decay", type=float, default=0.01)
+
+    p.add_argument("--log_every", type=int, default=20)
+    p.add_argument("--eval_every_epoch", action="store_true", default=True)
+
+    p.add_argument("--train_buffer_shuffle", type=int, default=50000)
+
+    p.add_argument("--val_take", type=int, default=0)
+    p.add_argument("--fp16", action="store_true", default=True)
+
+    # Windows 更稳：2~4
+    p.add_argument("--num_workers", type=int, default=2)
+    p.add_argument("--pin_memory", action="store_true", default=True)
+
+    p.add_argument("--train_size_hint", type=int, default=45600)
+
+    return p.parse_args()
+
+
+def find_parquet_files(data_dir: str, split: str):
+    base = os.path.join(data_dir, "default")
+    pat = {"train": "partial-train", "validation": "partial-validation", "test": "partial-test"}[split]
+    files = sorted(glob(os.path.join(base, pat, "*.parquet")))
+    if not files:
+        raise FileNotFoundError(f"没找到 {split} parquet: {os.path.join(base, pat)}/*.parquet")
+    return files
+
+
+def find_jsonl(data_dir: str, split: str):
+    cands = [
+        os.path.join(data_dir, "index", f"{split}.jsonl"),
+        os.path.join(data_dir, f"{split}.jsonl"),
+        os.path.join(data_dir, "default", "index", f"{split}.jsonl"),
+        os.path.join(data_dir, "default", f"{split}.jsonl"),
+    ]
+    for p in cands:
+        if os.path.isfile(p):
+            return p
+    raise FileNotFoundError(f"找不到 {split}.jsonl（建议放到 {data_dir}/index/{split}.jsonl）")
+
+
+def load_member2label(jsonl_path: str):
+    m2l = {}
+    with open(jsonl_path, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            obj = json.loads(line)
+            m = obj.get(JSONL_KEY_COL, None)
+            k = obj.get(JSONL_LABEL_COL, None)
+            if m is None or k is None:
+                continue
+
+            if isinstance(k, (int, np.integer)):
+                label = 1 if int(k) == 1 else 0
+            else:
+                s = str(k).lower()
+                label = 1 if s == "bonafide" else 0
+
+            m2l[str(m)] = int(label)
+
+    if not m2l:
+        raise ValueError(f"{jsonl_path} 没读到任何 member->label")
+    return m2l
+
+
+def decode_wav_any(w, target_sr: int):
+    if isinstance(w, dict):
+        if "bytes" in w and w["bytes"] is not None:
+            x, sr0 = sf.read(io.BytesIO(w["bytes"]), dtype="float32")
+            return x, sr0
+        if "array" in w and w["array"] is not None:
+            x = np.asarray(w["array"], dtype=np.float32)
+            sr0 = int(w.get("sampling_rate", target_sr))
+            return x, sr0
+
+    if isinstance(w, (bytes, bytearray)):
+        x, sr0 = sf.read(io.BytesIO(w), dtype="float32")
+        return x, sr0
+
+    x = np.asarray(w, dtype=np.float32)
+    return x, target_sr
+
+
+def cheap_resample(x: np.ndarray, sr0: int, sr1: int):
+    if sr0 == sr1:
+        return x
+    n1 = int(round(len(x) * (sr1 / sr0)))
+    if n1 <= 1:
+        return x[:1]
+    idx = np.linspace(0, len(x) - 1, n1).astype(np.float64)
+    x0 = np.arange(len(x), dtype=np.float64)
+    y = np.interp(idx, x0, x).astype(np.float32)
+    return y
+
+
+def disable_audio_decoding(ds, audio_col: str, sr: int):
+    if hasattr(ds, "decode"):
+        try:
+            return ds.decode(False)
+        except TypeError:
+            pass
+
+    if hasattr(ds, "cast_column"):
+        try:
+            return ds.cast_column(audio_col, Audio(decode=False))
+        except TypeError:
+            return ds.cast_column(audio_col, Audio(sampling_rate=sr))
+
+    return ds
+
+
+class StreamCollator:
+    def __init__(self, feature_extractor, member2label, sr=16000, max_sec=6.0):
+        self.fe = feature_extractor
+        self.m2l = member2label
+        self.sr = sr
+        self.max_len = int(sr * max_sec)
+
+    def __call__(self, batch):
+        audios = []
+        labels = []
+
+        for ex in batch:
+            kk = str(ex.get(PARQUET_KEY_COL, "")) + ".wav"
+            if kk == "" or kk not in self.m2l:
+                raise ValueError(f"jsonl 找不到 member={kk} 的标签（检查 parquet.__key__ 与 jsonl.member 是否一致）")
+            labels.append(self.m2l[kk])
+
+            w = ex.get(AUDIO_COL, None)
+            if w is None:
+                raise ValueError(f"样本缺少音频列 {AUDIO_COL}")
+
+            x, sr0 = decode_wav_any(w, self.sr)
+            x = np.asarray(x, dtype=np.float32)
+            if x.ndim > 1:
+                x = x.mean(axis=-1)
+
+            if sr0 != self.sr:
+                x = cheap_resample(x, sr0, self.sr)
+
+            if len(x) >= self.max_len:
+                x = x[: self.max_len]
+            else:
+                x = np.pad(x, (0, self.max_len - len(x)))
+
+            audios.append(x)
+
+        inputs = self.fe(audios, sampling_rate=self.sr, return_tensors="pt", padding=True)
+        inputs["labels"] = torch.tensor(labels, dtype=torch.long)
+        return inputs
+
+
+@torch.no_grad()
+def eval_loop(model, dl, device, fp16: bool):
+    model.eval()
+    all_probs, all_preds, all_labels = [], [], []
+
+    for batch in dl:
+        batch = {k: v.to(device, non_blocking=True) for k, v in batch.items()}
+        with torch.amp.autocast("cuda", enabled=fp16):
+            logits = model(**batch).logits
+
+        probs = F.softmax(logits, dim=-1)[:, 1]
+        preds = torch.argmax(logits, dim=-1)
+
+        all_probs.append(probs.detach().cpu().numpy())
+        all_preds.append(preds.detach().cpu().numpy())
+        all_labels.append(batch["labels"].detach().cpu().numpy())
+
+    probs = np.concatenate(all_probs) if all_probs else np.array([], dtype=np.float32)
+    preds = np.concatenate(all_preds) if all_preds else np.array([], dtype=np.int64)
+    labels = np.concatenate(all_labels) if all_labels else np.array([], dtype=np.int64)
+
+    acc = float((preds == labels).mean()) if len(labels) else float("nan")
+
+    tp = int(((preds == 1) & (labels == 1)).sum())
+    fp = int(((preds == 1) & (labels == 0)).sum())
+    fn = int(((preds == 0) & (labels == 1)).sum())
+    precision = tp / (tp + fp + 1e-9)
+    recall = tp / (tp + fn + 1e-9)
+    f1 = float(2 * precision * recall / (precision + recall + 1e-9))
+
+    roc_auc = float("nan")
+    if len(labels) and len(np.unique(labels)) == 2:
+        order = np.argsort(probs)
+        y = labels[order]
+        n_pos = (y == 1).sum()
+        n_neg = (y == 0).sum()
+        if n_pos > 0 and n_neg > 0:
+            ranks = np.arange(1, len(y) + 1)
+            sum_ranks_pos = ranks[y == 1].sum()
+            roc_auc = float((sum_ranks_pos - n_pos * (n_pos + 1) / 2) / (n_pos * n_neg))
+
+    model.train()
+    return {"acc": acc, "f1": f1, "roc_auc": roc_auc, "n": int(len(labels))}
+
+
+def main():
+    args = parse_args()
+
+    assert torch.cuda.is_available(), "CUDA 不可用"
+    device = torch.device("cuda")
+    print("CUDA OK:", torch.cuda.get_device_name(0))
+
+    torch.backends.cudnn.benchmark = True
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+
+    train_files = find_parquet_files(args.data_dir, "train")
+    val_files = find_parquet_files(args.data_dir, "validation")
+    train_jsonl = find_jsonl(args.data_dir, "train")
+    val_jsonl = find_jsonl(args.data_dir, "validation")
+
+    train_m2l = load_member2label(train_jsonl)
+    val_m2l = load_member2label(val_jsonl)
+    print("labels loaded:", len(train_m2l), len(val_m2l))
+
+    train_stream = load_dataset("parquet", data_files={"train": train_files}, streaming=True)["train"]
+    train_stream = disable_audio_decoding(train_stream, AUDIO_COL, args.sr)
+    train_stream = train_stream.shuffle(buffer_size=args.train_buffer_shuffle, seed=42)
+
+    val_stream = load_dataset("parquet", data_files={"validation": val_files}, streaming=True)["validation"]
+    val_stream = disable_audio_decoding(val_stream, AUDIO_COL, args.sr)
+    if args.val_take and args.val_take > 0:
+        val_stream = val_stream.take(int(args.val_take))
+
+    fe = AutoFeatureExtractor.from_pretrained(args.model_dir, local_files_only=True)
+
+    model = Wav2Vec2ForSequenceClassification.from_pretrained(
+        args.model_dir,
+        num_labels=2,
+        id2label={0: "spoof", 1: "bonafide"},
+        label2id={"spoof": 0, "bonafide": 1},
+        ignore_mismatched_sizes=True,
+        local_files_only=True,
+    ).to(device)
+
+    model.train()
+
+    train_collator = StreamCollator(fe, train_m2l, sr=args.sr, max_sec=args.max_sec)
+    val_collator = StreamCollator(fe, val_m2l, sr=args.sr, max_sec=args.max_sec)
+
+    train_dl = DataLoader(
+        train_stream,
+        batch_size=args.batch,
+        num_workers=args.num_workers,
+        pin_memory=args.pin_memory,
+        collate_fn=train_collator,
+    )
+    val_dl = DataLoader(
+        val_stream,
+        batch_size=args.batch,
+        num_workers=args.num_workers,
+        pin_memory=args.pin_memory,
+        collate_fn=val_collator,
+    )
+
+    # ✅ 这里现在不会再触发 torch._dynamo -> cProfile 了
+    optim = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=args.weight_decay)
+    scaler = torch.amp.GradScaler("cuda", enabled=args.fp16)
+
+    os.makedirs(args.out, exist_ok=True)
+
+    best_auc = -1.0
+    global_step = 0
+
+    steps_per_epoch = max(1, math.ceil(args.train_size_hint / max(1, args.batch)))
+    print(f"steps_per_epoch={steps_per_epoch} (train_size_hint={args.train_size_hint}, batch={args.batch})")
+
+    for epoch in range(1, args.epochs + 1):
+        print(f"\n===== EPOCH {epoch}/{args.epochs} =====")
+        t0 = time.time()
+        running = 0.0
+        seen = 0
+
+        it = iter(train_dl)
+        optim.zero_grad(set_to_none=True)
+
+        for step_in_epoch in range(steps_per_epoch):
+            batch = next(it)
+            batch = {k: v.to(device, non_blocking=True) for k, v in batch.items()}
+
+            with torch.amp.autocast("cuda", enabled=args.fp16):
+                loss = model(**batch).loss
+                loss_scaled = loss / args.grad_accum
+
+            scaler.scale(loss_scaled).backward()
+
+            if (step_in_epoch + 1) % args.grad_accum == 0:
+                scaler.step(optim)
+                scaler.update()
+                optim.zero_grad(set_to_none=True)
+
+            running += float(loss.item()) * batch["labels"].size(0)
+            seen += int(batch["labels"].size(0))
+            global_step += 1
+
+            if global_step % args.log_every == 0:
+                avg = running / max(1, seen)
+                dt = time.time() - t0
+                spd = seen / max(1e-9, dt)
+                mem = torch.cuda.memory_allocated() / (1024**3)
+                print(f"step {global_step:6d} | loss(avg)={avg:.4f} | samples={seen} | {spd:.1f} samp/s | mem={mem:.2f} GB")
+
+        if args.eval_every_epoch:
+            metrics = eval_loop(model, val_dl, device, fp16=args.fp16)
+            print(f"[VAL] n={metrics['n']} acc={metrics['acc']:.4f} f1={metrics['f1']:.4f} roc_auc={metrics['roc_auc']:.4f}")
+
+        last_dir = os.path.join(args.out, "last")
+        os.makedirs(last_dir, exist_ok=True)
+        model.save_pretrained(last_dir)
+        fe.save_pretrained(last_dir)
+        print(f"saved last to: {last_dir}")
+
+    print("\nDONE.")
+
+
+if __name__ == "__main__":
+    main()

verify_wav2vecbase.py

@@ -0,0 +1,209 @@
+import os
+import io
+import time
+import numpy as np
+import torch
+import soundfile as sf
+from tqdm import tqdm
+import pyarrow.parquet as pq
+
+from transformers import (
+    Wav2Vec2FeatureExtractor,
+    Wav2Vec2ForSequenceClassification,
+)
+
+# =========================
+# 0) 配置
+# =========================
+PARQUET_DIR = r"D:\capstone\asv_spoof\parquet"
+
+# ✅ 如果是原始模型
+MODEL_DIR = r"D:\capstone\wav2vecbase"
+# ✅ 如果是你 fine-tune 后的模型
+# MODEL_DIR = r"D:\capstone\models\wav2vec2_snr"
+
+SPLIT = "test"
+BATCH_SIZE = 32        # RTX 4060 推荐 16~32
+CPU_THREADS = 8
+
+KEY_SPOOF_VALUE = 1    # key=1 → spoof
+
+PARQUET_FILE = os.path.join(PARQUET_DIR, f"{SPLIT}-00000-of-00001.parquet")
+CHECK_LABEL_CONSISTENCY = True
+
+
+# =========================
+# 1) 音频解码
+# =========================
+def decode_audio(bytes_blob, path_str):
+    if bytes_blob is not None:
+        wav, sr = sf.read(io.BytesIO(bytes_blob), dtype="float32")
+    else:
+        wav, sr = sf.read(path_str, dtype="float32")
+
+    if wav.ndim > 1:
+        wav = wav.mean(axis=1)
+    return wav.astype(np.float32), int(sr)
+
+
+def resample(wav, sr, target_sr):
+    if sr == target_sr:
+        return wav
+    x_old = np.linspace(0, 1, len(wav), endpoint=False)
+    new_len = int(len(wav) * target_sr / sr)
+    x_new = np.linspace(0, 1, new_len, endpoint=False)
+    return np.interp(x_new, x_old, wav).astype(np.float32)
+
+
+def key_to_label(k):
+    return 1 if int(k) == KEY_SPOOF_VALUE else 0
+
+
+def system_id_to_label(sid):
+    return 0 if str(sid).strip() == "-" else 1
+
+
+# =========================
+# 2) 设备 & 模型
+# =========================
+torch.set_num_threads(CPU_THREADS)
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print("Device:", device)
+if device.type == "cuda":
+    print("GPU:", torch.cuda.get_device_name(0))
+    torch.backends.cudnn.benchmark = True
+
+use_amp = device.type == "cuda"
+
+feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(MODEL_DIR)
+model = Wav2Vec2ForSequenceClassification.from_pretrained(MODEL_DIR).to(device).eval()
+
+target_sr = feature_extractor.sampling_rate  # 16000
+
+
+# =========================
+# 3) 读 parquet
+# =========================
+pf = pq.ParquetFile(PARQUET_FILE)
+num_rows = pf.metadata.num_rows
+num_batches = (num_rows + BATCH_SIZE - 1) // BATCH_SIZE
+
+print(f"Parquet: {PARQUET_FILE}")
+print(f"Rows: {num_rows}, Batches: {num_batches}")
+
+
+# =========================
+# 4) 推理
+# =========================
+tp = fp = tn = fn = 0
+correct = total = 0
+mismatch = checked = 0
+
+t0 = time.time()
+with torch.no_grad():
+    pbar = tqdm(total=num_batches, desc=f"Predicting [{SPLIT}]", unit="batch")
+
+    for rb in pf.iter_batches(batch_size=BATCH_SIZE, columns=["audio", "key", "system_id"]):
+        audio_struct = rb.column(rb.schema.get_field_index("audio"))
+        key_arr = rb.column(rb.schema.get_field_index("key"))
+        sys_arr = rb.column(rb.schema.get_field_index("system_id"))
+
+        bytes_arr = audio_struct.field("bytes")
+        path_arr  = audio_struct.field("path")
+
+        waves, labels = [], []
+
+        for b, p, k, sid in zip(
+            bytes_arr.to_pylist(),
+            path_arr.to_pylist(),
+            key_arr.to_pylist(),
+            sys_arr.to_pylist(),
+        ):
+            y = key_to_label(k)
+            labels.append(y)
+
+            if CHECK_LABEL_CONSISTENCY:
+                checked += 1
+                if y != system_id_to_label(sid):
+                    mismatch += 1
+
+            wav, sr = decode_audio(b, p)
+            wav = resample(wav, sr, target_sr)
+            waves.append(wav)
+
+        inputs = feature_extractor(
+            waves,
+            sampling_rate=target_sr,
+            padding=True,
+            return_tensors="pt",
+        )
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+        labels_t = torch.tensor(labels, device=device)
+
+        if use_amp:
+            with torch.amp.autocast("cuda"):
+                logits = model(**inputs).logits
+        else:
+            logits = model(**inputs).logits
+
+        preds = logits.argmax(dim=-1)
+
+        total += labels_t.numel()
+        correct += (preds == labels_t).sum().item()
+
+        tp += ((preds == 1) & (labels_t == 1)).sum().item()
+        fp += ((preds == 1) & (labels_t == 0)).sum().item()
+        tn += ((preds == 0) & (labels_t == 0)).sum().item()
+        fn += ((preds == 0) & (labels_t == 1)).sum().item()
+
+        pbar.update(1)
+
+    pbar.close()
+
+elapsed = time.time() - t0
+
+
+# =========================
+# 5) 指标
+# =========================
+eps = 1e-12
+acc = correct / max(total, 1)
+precision = tp / (tp + fp + eps)
+recall = tp / (tp + fn + eps)
+f1 = 2 * precision * recall / (precision + recall + eps)
+fnr = fn / (fn + tp + eps)
+fpr = fp / (fp + tn + eps)
+
+print("\n===== Summary =====")
+print(f"Accuracy   : {acc:.6f} ({correct}/{total})")
+print(f"TP={tp}, FP={fp}, TN={tn}, FN={fn}")
+print(f"Time       : {elapsed:.2f}s, {total/elapsed:.2f} samples/s")
+
+if CHECK_LABEL_CONSISTENCY:
+    print(f"Label check: key vs system_id mismatches = {mismatch}/{checked}")
+
+print("\n===== Metrics (pos=spoof=1) =====")
+print(f"Precision  : {precision:.6f}")
+print(f"Recall     : {recall:.6f}")
+print(f"FNR        : {fnr:.6f}")
+print(f"FPR        : {fpr:.6f}")
+print(f"F1-score   : {f1:.6f}")
+
+'''
+===== Summary =====
+Accuracy   : 0.896753 (63882/71237)
+TP=63882, FP=7355, TN=0, FN=0
+Time       : 4266.32s, 16.70 samples/s
+Label check: key vs system_id mismatches = 0/71237
+
+===== Metrics (pos=spoof=1) =====
+Precision  : 0.896753
+Recall     : 1.000000
+FNR        : 0.000000
+FPR        : 1.000000
+F1-score   : 0.945567
+
+进程已结束，退出代码为 0
+
+'''