File size: 7,784 Bytes
54d2b91 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 | """MMDF (test-only) deepfake dataset.
Layout (verified on 2026-06-03):
<root>/test/fake/<generator>/*.mp4 label=1
<root>/test/real/<generator>/*.mp4 label=0 (paired with fake by basename
within each generator)
Each generator has its own paired (real, fake) split — same basename means a
fake video for that real, but different generators DO NOT share basenames.
Audio is embedded in the mp4. We expect wav files pre-extracted to
<root>/_audio/test/fake/<generator>/<basename>.wav
<root>/_audio/test/real/<generator>/<basename>.wav
via scripts/prepare_mmdf_audio.sh. If a wav is missing we fall back to silence
(mirroring FFPPTestDataset behavior); audio-related ablation variants would be
misleading in that case, so prepare audio first.
"""
from __future__ import annotations
import warnings
from pathlib import Path
from typing import Any, Callable, Dict, List, Optional, Sequence
import torch
from torch.utils.data import Dataset
from .fairtalking_dataset import load_video_clip, load_audio_clip
DEFAULT_MMDF_GENERATORS = ("aniportrait", "hunyuan", "megactor-s")
class MMDFTestDataset(Dataset):
"""Test-only dataset for MMDF.
Returns per sample:
video: (T, 3, H, W) float
audio: (S,) float
label: int (0 = real, 1 = fake)
meta: dict with generator + basename + video_path
"""
def __init__(
self,
root: str,
generators: Sequence[str] = DEFAULT_MMDF_GENERATORS,
num_frames: int = 16,
frame_stride: int = 2,
frame_size: int = 224,
audio_seconds: float = 2.56,
audio_sample_rate: int = 16000,
include_real: bool = True,
max_fake_per_generator: Optional[int] = None,
max_real_per_generator: Optional[int] = None,
audio_cache_dir: Optional[str] = None,
video_transform: Optional[Callable] = None,
) -> None:
super().__init__()
self.root = Path(root)
self.generators = tuple(generators)
self.num_frames = num_frames
self.frame_stride = frame_stride
self.frame_size = frame_size
self.audio_seconds = audio_seconds
self.audio_sample_rate = audio_sample_rate
self.video_transform = video_transform
# Audio cache dir defaults to <root>/_audio so the extraction script
# only needs to be told the root.
self.audio_cache_dir = (
Path(audio_cache_dir) if audio_cache_dir is not None
else self.root / "_audio"
)
self.include_real = include_real
self.max_fake_per_generator = max_fake_per_generator
self.max_real_per_generator = max_real_per_generator
self.samples: List[Dict[str, Any]] = self._build_samples()
if not self.samples:
warnings.warn(
f"[MMDFTestDataset] no samples discovered under {self.root}/test/; "
f"check that test/fake/<gen>/*.mp4 exists. Generators={self.generators}"
)
# ------------------------------------------------------------------
def _build_samples(self) -> List[Dict[str, Any]]:
samples: List[Dict[str, Any]] = []
fake_root = self.root / "test" / "fake"
# NOTE: real path is HARD-CODED relative to fake_root. Caller does not
# need to (and cannot) override this from yaml — that's intentional,
# because the previous yaml schema was wrong about real path.
real_root = self.root / "test" / "real"
for generator in self.generators:
fake_dir = fake_root / generator
if not fake_dir.exists():
warnings.warn(
f"[MMDFTestDataset] fake dir not found: {fake_dir}"
)
continue
mp4_files = sorted(fake_dir.glob("*.mp4"))
if self.max_fake_per_generator is not None:
mp4_files = mp4_files[: self.max_fake_per_generator]
for mp4_path in mp4_files:
samples.append({
"video_path": str(mp4_path),
"label": 1,
"generator": generator,
"basename": mp4_path.stem,
})
if self.include_real:
real_dir = real_root / generator
if not real_dir.exists():
warnings.warn(
f"[MMDFTestDataset] real dir not found: {real_dir}; "
f"only fake samples will be used for {generator}, "
f"per-generator AUC will be ill-defined."
)
continue
real_mp4_files = sorted(real_dir.glob("*.mp4"))
if self.max_real_per_generator is not None:
real_mp4_files = real_mp4_files[: self.max_real_per_generator]
for mp4_path in real_mp4_files:
samples.append({
"video_path": str(mp4_path),
"label": 0,
# Tag real videos with the generator they were paired
# against, so per-generator metrics still aggregate
# cleanly. (Same basename is a fake of a different
# generator's pair, but each generator owns its real
# subset here, so this is safe.)
"generator": f"real/{generator}",
"basename": mp4_path.stem,
})
return samples
# ------------------------------------------------------------------
def __len__(self) -> int:
return len(self.samples)
def _audio_path_for(self, video_path: str) -> Optional[str]:
"""Map <root>/test/fake/<gen>/<bn>.mp4 → <audio_cache>/test/fake/<gen>/<bn>.wav."""
if self.audio_cache_dir is None:
return None
try:
rel = Path(video_path).relative_to(self.root)
except ValueError:
rel = Path(Path(video_path).name)
return str(self.audio_cache_dir / rel.with_suffix(".wav"))
def _load_sample(self, vpath: str):
video = load_video_clip(
vpath, self.num_frames, self.frame_stride, self.frame_size,
)
if self.video_transform is not None:
video = self.video_transform(video)
apath = self._audio_path_for(vpath)
if apath is not None and Path(apath).exists():
audio = load_audio_clip(apath, self.audio_seconds, self.audio_sample_rate)
else:
# Audio cache missing → silence. This is correct behavior but
# makes audio-related variants (M2_audio_only / M6_drop_audio_infer
# / etc.) misleading. Run scripts/prepare_mmdf_audio.sh first.
audio = torch.zeros(int(self.audio_seconds * self.audio_sample_rate))
return video, audio
def __getitem__(self, idx: int) -> Dict[str, Any]:
sample = self.samples[idx]
try:
video, audio = self._load_sample(sample["video_path"])
except Exception as e:
warnings.warn(
f"[MMDFTestDataset] skipping bad sample idx={idx} "
f"basename={sample['basename']}: {e}"
)
return self.__getitem__((idx + 1) % len(self))
return {
"video": video,
"audio": audio,
"label": int(sample["label"]),
"meta": {
"basename": sample["basename"],
"generator": sample["generator"],
"num": sample["basename"],
"driving": "",
"video_path": sample["video_path"],
},
}
|