Add files using upload-large-folder tool

.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+__pycache__
+.vscode/

GUIDE.md

@@ -0,0 +1,338 @@
+# FT_work 数据集预处理完整指南
+
+## 📋 目录
+
+1. [参数详解](#参数详解)
+2. [数据集结构对比](#数据集结构对比)
+3. [使用流程](#使用流程)
+4. [文件说明](#文件说明)
+5. [示例与计算](#示例与计算)
+6. [常见问题](#常见问题)
+
+---
+
+## 参数详解
+
+### 1. N_EXTRACT = 10
+**含义**: 从**每个视频**中提取的窗口数量
+
+**详细解释**:
+- 代码会在视频帧范围内均匀选择 10 个起始点
+- 每个起始点对应一个时间窗口
+- 例如：视频有 300 帧，会选择 10 个起始位置（如：0, 33, 66, 99, 132, 165, 198, 231, 264, 297）
+
+**影响**:
+- 值越大 → 每个视频生成的样本越多 → 数据集越大
+- 值越小 → 每个视频生成的样本越少 → 可能丢失信息
+
+### 2. WINDOW_LEN = 5
+**含义**: 每个窗口包含的**连续帧数**
+
+**详细解释**:
+- 从每个起始点开始，连续提取 5 帧图像
+- 这 5 帧会水平拼接成一张图（宽 2500px = 5 × 500px）
+- 例如：起始帧为 0，则提取帧 [0, 1, 2, 3, 4]
+
+**影响**:
+- 值越大 → 每个样本包含更多时间信息 → 但单张图片更宽
+- 值越小 → 每个样本时间跨度短 → 可能捕捉不到完整动作
+
+### 3. MAX_SAMPLE = 100 (建议改为 0)
+**含义**: 限制的**最大视频处理数量**
+
+**⚠️ 注意**: 原代码中这个参数有 bug，建议使用改进版脚本（`preprocess_improved.py`）
+- `MAX_SAMPLE = 0`: 处理所有视频（无限制）
+- `MAX_SAMPLE = 100`: 只处理前 100 个视频
+
+**建议**: 设置为 0（无限制）或根据实际情况调整
+
+---
+
+## 数据集结构对比
+
+### FT_work 原始结构
+```
+/apdcephfs_gy5/share_303628665/joyewu/dataset/FT_work/videos/
+├── train/
+│   ├── real/Real/*.mp4
+│   └── fake/{AniPortrait,Joyvasa,Ditto,Hallo,Sonic}/*.mp4
+├── test/
+│   ├── real/Real/*.mp4
+│   └── fake/{SadTalk,EDTalk,Float}/*.mp4
+└── val/
+    ├── real/Real/*.mp4
+    └── fake/{AniPortrait,Joyvasa,Ditto,Hallo,Sonic}/*.mp4
+```
+
+**特点**:
+- 按 train/test/val 分割
+- fake 视频按方法分类在不同子文件夹
+- **没有单独的音频文件**（需要从视频中提取）
+
+### AVLips 目标结构（preprocess.py 需要）
+```
+AVLips/
+├── 0_real/*.mp4           # 所有真实视频
+├── 1_fake/*.mp4           # 所有假视频
+└── wav/
+    ├── 0_real/*.wav       # 真实视频的音频
+    └── 1_fake/*.wav       # 假视频的音频
+```
+
+**特点**:
+- 不区分 train/test/val（所有数据合并）
+- 真实和假视频分开存放
+- **需要单独的 WAV 音频文件**
+
+---
+
+## 使用流程
+
+### 快速开始（推荐）
+
+```bash
+cd /apdcephfs_gy4/share_303628665/joywu/research/LipFD
+
+# 方式 1: 使用自动化脚本（需要手动添加执行权限）
+chmod +x run_preprocess.sh
+./run_preprocess.sh
+
+# 方式 2: 手动执行步骤
+```
+
+### 手动执行步骤
+
+#### 步骤 1: 转换数据集格式
+
+```bash
+python convert_ft_work.py
+```
+
+**功能**:
+- 将 FT_work 的所有视频（train/test/val）合并
+- 分为 `0_real/` 和 `1_fake/` 两类
+- 从视频中提取音频保存为 WAV 格式
+- 输出到 `./AVLips/` 目录
+
+**输出**:
+```
+AVLips/
+├── 0_real/  (真实视频)
+├── 1_fake/  (假视频)
+└── wav/
+    ├── 0_real/  (真实音频)
+    └── 1_fake/  (假音频)
+```
+
+#### 步骤 2: 修改参数（可选）
+
+编辑 `preprocess_improved.py`：
+
+```python
+############ Custom parameter ##############
+N_EXTRACT = 10   # 每个视频提取10个窗口
+WINDOW_LEN = 5   # 每个窗口5帧
+MAX_SAMPLE = 0   # 0 = 处理所有视频
+############################################
+
+audio_root = "./AVLips/wav"
+video_root = "./AVLips"
+output_root = "./datasets/AVLips"
+```
+
+#### 步骤 3: 运行预处理
+
+```bash
+# 使用改进版（推荐）
+python preprocess_improved.py
+
+# 或使用原版
+python preprocess.py
+```
+
+**功能**:
+- 从每个视频中提取帧
+- 生成音频的梅尔频谱图
+- 将帧和频谱图拼接成最终图片
+- 输出到 `./datasets/AVLips/` 目录
+
+---
+
+## 文件说明
+
+### 1. `convert_ft_work.py`
+**功能**: 数据集格式转换
+
+**输入**: `/apdcephfs_gy5/share_303628665/joyewu/dataset/FT_work/videos/`
+
+**输出**: `./AVLips/`
+
+**依赖**:
+- `ffmpeg` (用于从视频提取音频)
+- `shutil`, `os`, `tqdm`
+
+### 2. `preprocess_improved.py` (推荐)
+**功能**: 预处理脚本（改进版）
+
+**改进点**:
+- ✅ 修复 `dtype=np.uint8` 导致的索引错误
+- ✅ 添加详细的错误处理
+- ✅ 添加进度显示
+- ✅ 检查视频长度是否足够
+- ✅ 检查音频文件是否存在
+- ✅ 清理临时文件
+
+**输入**: `./AVLips/`
+
+**输出**: `./datasets/AVLips/`
+
+### 3. `preprocess.py` (原版)
+**功能**: 原始预处理脚本
+
+**⚠️ 已知问题**:
+- `dtype=np.uint8` 可能导致索引错误（视频帧数 > 255 时）
+- 错误处理不完善
+- 日志输��不够详细
+
+### 4. `run_preprocess.sh`
+**功能**: 自动化执行脚本
+
+**使用**:
+```bash
+chmod +x run_preprocess.sh
+./run_preprocess.sh
+```
+
+---
+
+## 示例与计算
+
+### 示例 1: 单个视频的处理
+
+**输入**: `video_001.mp4` (300 帧，10秒 @ 30fps)
+
+**参数**: `N_EXTRACT=10`, `WINDOW_LEN=5`
+
+**处理流程**:
+
+1. **选择起始点** (10个):
+   ```
+   [0, 33, 66, 99, 132, 165, 198, 231, 264, 297]
+   ```
+
+2. **提取窗口** (每个窗口5帧):
+   ```
+   窗口 0: 帧 [0, 1, 2, 3, 4]
+   窗口 1: 帧 [33, 34, 35, 36, 37]
+   ...
+   窗口 9: 帧 [297, 298, 299, 300, 301]  ← 会报错！(超出范围)
+   ```
+
+3. **生成输出** (10张图片):
+   ```
+   video_001_0.png  (频谱图 + 5帧图像)
+   video_001_1.png
+   ...
+   video_001_9.png
+   ```
+
+**每张图片的格式**:
+```
++------------------------+
+|   音频频谱图 (500x2500)  |  ← 对应这5帧的时间段
++------------------------+
+|   帧0   |   帧1   | ... |  ← 5帧水平拼接 (500x2500)
++------------------------+
+```
+
+### 示例 2: 计算总输出数量
+
+**假设**:
+- 真实视频: 500 个
+- 假视频: 500 个
+- `N_EXTRACT = 10`
+
+**计算**:
+```
+总视频数 = 500 + 500 = 1000 个
+总输出图片数 = 1000 × 10 = 10,000 张
+```
+
+**每张图片大小** (估算):
+```
+分辨率: 1000px × 2500px (高×宽)
+RGB: 3 channels
+文件大小: ~200-500KB (取决于压缩)
+总大小: ~2-5GB
+```
+
+---
+
+## 常见问题
+
+### Q1: 视频帧数不足怎么办？
+
+**A**: 改进版脚本会自动跳过帧数不足的视频，并显示警告。
+
+**建议**: 可以：
+1. 减小 `WINDOW_LEN` (如改为 3)
+2. 或只使用长视频
+
+### Q2: 为什么需要提取音频？
+
+**A**: `preprocess.py` 需要单独的 WAV 文件来生成梅尔频谱图。
+
+**解决方案**: `convert_ft_work.py` 会自动使用 ffmpeg 提取音频。
+
+### Q3: 如何只处理部分数据？
+
+**A**: 设置 `MAX_SAMPLE` 参数：
+
+```python
+MAX_SAMPLE = 100  # 只处理前100个视频
+```
+
+或使用改进版脚本的命令行参数（需要自行添加）。
+
+### Q4: 输出的图片格式是什么？
+
+**A**: PNG 格式，RGB 色彩空间。
+
+**尺寸**:
+- 高度: 1000px (频谱图 500px + 帧 500px)
+- 宽度: 2500px (5帧 × 500px)
+
+### Q5: 能否处理其他数据集？
+
+**A**: 可以，但需要：
+
+1. 将数据集转换为 AVLips 格式
+2. 确保有对应的音频文件
+3. 修改 `audio_root` 和 `video_root` 参数
+
+### Q6: 处理速度如何？
+
+**A**: 取决于：
+- 视频数量
+- 视频长度
+- `N_EXTRACT` 和 `WINDOW_LEN` 参数
+- CPU/GPU 性能
+
+**估算**:
+- 1个视频 ~ 1-5秒
+- 1000个视频 ~ 15-80分钟
+
+**加速建议**:
+- 使用多进程 (`multiprocessing`)
+- 减小 `N_EXTRACT`
+- 使用更快的硬盘（SSD）
+
+---
+
+## 联系与反馈
+
+如有问题或建议，请提出 Issue 或联系开发者。
+
+---
+
+**最后更新**: 2026-06-18

LipFD.yml

@@ -0,0 +1,95 @@
+name: LipFD
+channels:
+  - defaults
+dependencies:
+  - _libgcc_mutex=0.1=main
+  - _openmp_mutex=5.1=52_gnu
+  - bzip2=1.0.8=h5eee18b_6
+  - ca-certificates=2026.5.14=h06a4308_0
+  - ld_impl_linux-64=2.44=h9e0c5a2_3
+  - libffi=3.3=he6710b0_2
+  - libgcc=15.2.0=h69a1729_8
+  - libgcc-ng=15.2.0=h166f726_8
+  - libstdcxx=15.2.0=h39759b7_8
+  - libstdcxx-ng=15.2.0=hc03a8fd_8
+  - libuuid=1.41.5=h5eee18b_0
+  - libxcb=1.17.0=h9b100fa_0
+  - libzlib=1.3.2=h47b2149_0
+  - ncurses=6.5=h7934f7d_0
+  - openssl=1.1.1w=h7f8727e_0
+  - packaging=26.0=py310h06a4308_0
+  - pip=26.1.1=pyhc872135_1
+  - pthread-stubs=0.3=h0ce48e5_1
+  - python=3.10.0=h12debd9_5
+  - readline=8.3=hc2a1206_0
+  - sqlite=3.53.2=h795bf6d_0
+  - tk=8.6.15=h54e0aa7_0
+  - wheel=0.46.3=py310h06a4308_0
+  - xorg-libx11=1.8.12=h9b100fa_1
+  - xorg-libxau=1.0.12=h9b100fa_0
+  - xorg-libxdmcp=1.1.5=h9b100fa_0
+  - xorg-xorgproto=2024.1=h5eee18b_1
+  - xz=5.8.2=h448239c_0
+  - zlib=1.3.2=h47b2149_0
+  - pip:
+      - certifi==2026.6.17
+      - cffi==2.0.0
+      - charset-normalizer==3.4.7
+      - contourpy==1.3.2
+      - cycler==0.12.1
+      - decorator==5.3.1
+      - filelock==3.29.4
+      - fonttools==4.63.0
+      - fsspec==2026.6.0
+      - ftfy==6.1.1
+      - idna==3.18
+      - jinja2==3.1.6
+      - kiwisolver==1.5.0
+      - librosa==0.10.1
+      - llvmlite==0.47.0
+      - markupsafe==3.0.3
+      - matplotlib==3.8.0
+      - mpmath==1.3.0
+      - msgpack==1.2.0
+      - networkx==3.4.2
+      - numba==0.65.1
+      - numpy==1.25.2
+      - nvidia-cublas-cu12==12.1.3.1
+      - nvidia-cuda-cupti-cu12==12.1.105
+      - nvidia-cuda-nvrtc-cu12==12.1.105
+      - nvidia-cuda-runtime-cu12==12.1.105
+      - nvidia-cudnn-cu12==8.9.2.26
+      - nvidia-cufft-cu12==11.0.2.54
+      - nvidia-curand-cu12==10.3.2.106
+      - nvidia-cusolver-cu12==11.4.5.107
+      - nvidia-cusparse-cu12==12.1.0.106
+      - nvidia-nccl-cu12==2.18.1
+      - nvidia-nvjitlink-cu12==12.9.86
+      - nvidia-nvtx-cu12==12.1.105
+      - opencv-contrib-python==4.8.1.78
+      - opencv-python==4.8.1.78
+      - pandas==2.3.3
+      - pillow==12.2.0
+      - platformdirs==4.10.0
+      - pycparser==3.0
+      - pyparsing==3.3.2
+      - python-dateutil==2.9.0.post0
+      - pytz==2026.2
+      - regex==2026.5.9
+      - requests==2.34.2
+      - scikit-learn==1.3.1
+      - scipy==1.15.3
+      - setuptools==69.5.1
+      - six==1.17.0
+      - soundfile==0.14.0
+      - soxr==1.1.0
+      - sympy==1.14.0
+      - torch==2.1.0
+      - torchvision==0.16.0
+      - tqdm==4.66.1
+      - triton==2.1.0
+      - typing-extensions==4.15.0
+      - tzdata==2026.2
+      - urllib3==2.7.0
+      - wcwidth==0.8.1
+prefix: /opt/conda/envs/LipFD

README.md

@@ -0,0 +1,127 @@
+# [NeruIPS 2024] Lips Are Lying: Spotting the Temporal Inconsistency between Audio and Visual in Lip-syncing DeepFakes
+
+<a href='https://arxiv.org/abs/2401.15668v2'><img alt="Static Badge" src="https://img.shields.io/badge/arXiv-2401.15668v2-grey?style=flat&labelColor=red">
+<a href='https://drive.google.com/file/d/1fEiUo22GBSnWD7nfEwDW86Eiza-pOEJm/view?usp=share_link'><img alt="Static Badge" src="https://img.shields.io/badge/dataset-AVLips-grey?style=flat&labelColor=blue">
+
+
+
+![headline](README.assets/headline.png)
+
+> **Abstract.**  In recent years, DeepFake technology has achieved unprecedented success in high-quality video synthesis, but these methods also pose potential and severe security threats to humanity. DeepFake can be bifurcated into entertainment applications like face swapping and illicit uses such as lip-syncing fraud. However, lip-forgery videos, which neither change identity nor have discernible visual artifacts, present a formidable challenge to existing DeepFake detection methods. Our preliminary experiments have shown that the effectiveness of the existing methods often drastically decrease or even fail when tackling lip-syncing videos.
+> In this paper, for the first time, we propose a novel approach dedicated to lip-forgery identification that exploits the inconsistency between lip movements and audio signals. We also mimic human natural cognition by capturing subtle biological links between lips and head regions to boost accuracy. To better illustrate the effectiveness and advances of our proposed method, we create a high-quality LipSync dataset, AVLips, by employing the state-of-the-art lip generators. We hope this high-quality and diverse dataset could be well served the further research on this challenging and interesting field. Experimental results show that our approach gives an average accuracy of more than 95.3% in spotting lip-syncing videos, significantly outperforming the baselines. Extensive experiments demonstrate the capability to tackle deepfakes and the robustness in surviving diverse input transformations. Our method achieves an accuracy of up to 90.2% in real-world scenarios (e.g., WeChat video call) and shows its powerful capabilities in real scenario deployment.
+
+![pipeline](README.assets/pipeline.png)
+
+
+
+## 🔥 AVLips: A high-quality audio-visual dataset for LipSync detection
+
+To the best of our knowledge, the majority of public DeepFake datasets consist solely of videos or images, with no specialized one specifically dedicated to LipSync detection available. To fill this gap, we construct a high-quality **A**udio-**V**isual **Lip**-syncing Dataset, **AVLips**, which contains up to 340,000 audio-visual samples generated by several SOTA LipSync methods. The workflow is demonstrated below.
+
+**High quality.** We employed a combination of static MakeItTalk and dynamic Wav2Lip, TalkLip, SadTalker generation methods to simulate realistic lip movements. These methods are widely recognized as high-quality work, capable of generating high-resolution videos while ensuring accurate lip movements. We applied a noise reduction algorithm to all audio samples before synthesis to reduce irrelevant background noise, ensuring the models can focus on speech content. 
+
+**Diversity.** Our dataset encompasses a wide range of scenarios, covering not only well-known public datasets but also real-world data. Our aim is for this collection to act as a catalyst for advancing real-time forgery detection. To better simulate the nuances of real-world conditions, we have employed six perturbation techniques — saturation, contrast, compression, Gaussian noise, Gaussian blur, and pixelation — at various degrees, thus ensuring the dataset's realism and practical relevance.
+
+**Download Link: [AVLips v1.0](https://drive.google.com/file/d/1fEiUo22GBSnWD7nfEwDW86Eiza-pOEJm/view?usp=share_link)**
+
+<div align=center><img src="README.assets/dataset.png" width="300"></div>
+
+
+
+## :gear: ​Requirements
+
+~~~bash
+conda create -n LipFD python==3.10
+conda activate LipFD
+pip install -r requirements.txt
+~~~
+
+
+
+## :wrench: Dataset Preprocess
+
+**You can skip this section, if you only want to perform validation.**
+
+Download AVLips dataset and put it in the root directory. 
+
+AVLips dataset folder structure.
+
+~~~
+AVLips
+├── 0_real
+│   ├── 0.mp4
+│    ...
+├── 1_fake
+│   ├── 0.mp4
+│   └── ...
+└── wav
+    ├── 0_real
+    │   ├── 0.wav
+    │   └── ...
+    └── 1_fake
+        ├── 0.wav
+        └── ...
+~~~
+
+Preprocess the dataset for training. 
+
+~~~bash
+python preprocess.py
+~~~
+
+Preprocessed AVLips dataset folder structure.
+
+~~~bash
+datasets
+└── AVLips
+    ├── 0_real
+    │   ├── 0_0.png
+    │   └── ...
+    └── 1_fake
+        ├── 0_0.png
+        └── ...
+~~~
+
+The data sample is showed as follow, and **the fully processed dataset is approximately 60 GB.**
+
+![image-20241004221023777](README.assets/image-20241004221023777.png)
+
+
+
+## :tada: Validation
+
+- Download our [pertained weights](https://drive.google.com/file/d/1NPAcx0QS8N9v_9qUr-51jBaL9kGDT-cp/view?usp=share_link) and save it in to `checkpoints/ckpt.pth`. 
+
+- Download [validation set](https://drive.google.com/file/d/1gZjzps5_rbr6CeBqBke8l2Gs8xXx_Ctb/view?usp=share_link) and extract it into `datasets/val`.
+
+~~~bash
+python validate.py --real_list_path ./datasets/val/0_real --fake_list_path ./datasets/val/1_fake --ckpt ./checkpoints/ckpt.pth
+~~~
+
+
+
+## :rocket: Train
+
+First, edit `--fake_list_path` and `--real_list_path`  in `options/base_options.py`.
+
+Then, run `python train.py`.
+
+
+
+## :mailbox: Citation
+
+If you find this repo useful for your research, please consider citing our work:
+
+~~~
+@inproceedings{liu2024lips,
+ author = {Liu, Weifeng and She, Tianyi and Liu, Jiawei and Li, Boheng and Yao, Dongyu and Liang, Ziyou and Wang, Run},
+ booktitle = {Advances in Neural Information Processing Systems},
+ editor = {A. Globerson and L. Mackey and D. Belgrave and A. Fan and U. Paquet and J. Tomczak and C. Zhang},
+ pages = {91131--91155},
+ publisher = {Curran Associates, Inc.},
+ title = {Lips Are Lying: Spotting the Temporal Inconsistency between Audio and Visual in Lip-Syncing DeepFakes},
+ url = {https://proceedings.neurips.cc/paper_files/paper/2024/file/a5a5b0ff87c59172a13342d428b1e033-Paper-Conference.pdf},
+ volume = {37},
+ year = {2024}
+}
+~~~

README_CONVERT.md

@@ -0,0 +1,140 @@
+# FT_work 数据集转换指南
+
+## 参数说明
+
+在 `preprocess.py` 中，有三个重要参数：
+
+### 1. N_EXTRACT = 10
+**含义**: 从每个视频中提取的**窗口数量**
+
+**工作流程**:
+- 代码会在视频的总帧数中均匀选择 10 个起始点
+- 每个起始点会提取一个连续的帧窗口
+- 例如：视频有 300 帧，会随机选择 10 个起始位置（如帧 0, 33, 66, 99, ...）
+
+### 2. WINDOW_LEN = 5
+**含义**: 每个窗口包含的**连续帧数**
+
+**工作流程**:
+- 从每个起始点开始，连续提取 5 帧图像
+- 这 5 帧会拼接成一张宽图（水平拼接）
+- 例如：起始帧为 0，则提取帧 0, 1, 2, 3, 4
+
+### 3. MAX_SAMPLE = 100
+**含义**: 限制的**最大视频处理数量**（按代码逻辑，实际是限制处理的类别数）
+
+**注意**: 代码中的实现有点问题，这个参数可能不能按预期工作。建议设置为更大的值或删除这个限制。
+
+---
+
+## 输出示例
+
+假设有一个视频 `video_001.mp4`，包含 300 帧：
+
+1. **选择起始点**: 10 个起始点 = [0, 33, 66, 99, 132, 165, 198, 231, 264, 297]
+2. **提取窗口**: 每个起始点提取 5 帧
+   - 窗口 1: 帧 [0, 1, 2, 3, 4]
+   - 窗口 2: 帧 [33, 34, 35, 36, 37]
+   - ...
+   - 窗口 10: 帧 [297, 298, 299, 300, 301] (如果超出会报错)
+3. **生成输出**: 每个窗口生成一张图片
+   - `video_001_0.png`: 包含窗口1的5帧图像 + 对应音频频谱图
+   - `video_001_1.png`: 包含窗口2的5帧图像 + 对应音频频谱图
+   - ...
+   - `video_001_9.png`: 包含窗口10的5帧图像 + 对应音频频谱图
+
+**每个输出图片的格式**:
+- 上半部分: 音频频谱图（时间轴对应这5帧的时间）
+- 下半部分: 5帧图像水平拼接（500x500 每帧，总宽 2500px）
+
+---
+
+## 使用步骤
+
+### 步骤 1: 转换数据集格式
+
+运行转换脚本，将 FT_work 数据集转换为 AVLips 格式：
+
+```bash
+cd /apdcephfs_gy4/share_303628665/joywu/research/LipFD
+python convert_ft_work.py
+```
+
+这将创建 `./AVLips/` 目录，包含：
+```
+AVLips/
+├── 0_real/*.mp4      # 真实视频
+├── 1_fake/*.mp4      # 假视频
+└── wav/
+    ├── 0_real/*.wav  # 真实视频的音频
+    └── 1_fake/*.wav  # 假视频的音频
+```
+
+### 步骤 2: 修改 preprocess.py 参数
+
+根据你的需求调整参数：
+
+```python
+############ Custom parameter ##############
+N_EXTRACT = 10   # 每个视频提取10个窗口
+WINDOW_LEN = 5   # 每个窗口5帧
+MAX_SAMPLE = 1000  # 增加这个值以处理更多视频（或设为0表示不限制）
+############################################
+
+audio_root = "./AVLips/wav"
+video_root = "./AVLips"
+output_root = "./datasets/AVLips"
+```
+
+### 步骤 3: 运行预处理
+
+```bash
+python preprocess.py
+```
+
+---
+
+## 计算输出数量
+
+如果你有 N 个视频，那么：
+
+- **总输出图片数** = N × N_EXTRACT
+- **每个视频的输出数** = N_EXTRACT = 10 张图片
+- **每张图片包含的帧数** = WINDOW_LEN = 5 帧
+
+例如：
+- 100 个视频 → 100 × 10 = 1000 张输出图片
+- 1000 个视频 → 1000 × 10 = 10000 张输出图片
+
+---
+
+## 注意事项
+
+1. **视频帧数要求**: 视频至少需要 `WINDOW_LEN` 帧（5帧），否则会报错
+2. **音频提取**: 需要安装 ffmpeg (`pip install ffmpeg-python` 或系统安装 ffmpeg)
+3. **磁盘空间**: 输出图片可能很大（每张约 500x3000 像素），确保有足够空间
+4. **处理时间**: 每个视频需要提取音频、读取帧、生成频谱图，可能需要较长时间
+
+---
+
+## 自定义调整
+
+如果你想修改提取策略，可以调整以下代码（在 `preprocess.py` 的第 47-52 行）：
+
+```python
+# 原始：均匀选择起始点
+frame_idx = np.linspace(
+    0,
+    frame_count - WINDOW_LEN - 1,
+    N_EXTRACT,
+    endpoint=True,
+    dtype=np.uint8,
+).tolist()
+
+# 改为：随机选择起始点（可能更有代表性）
+frame_idx = np.random.choice(
+    frame_count - WINDOW_LEN,
+    size=N_EXTRACT,
+    replace=False
+).tolist()
+```

_diag_perturb.py

@@ -0,0 +1,64 @@
+"""Diagnostic: for one real test image, apply each perturbation at L5, then
+- report pixel-level diff stats on the perturbed strip,
+- crop the SAME way data.AVLip does, report diff stats on what the model
+  actually sees,
+- save side-by-side PNGs to robustnessv3/_diag/."""
+import os
+import sys
+import numpy as np
+import cv2
+import torch
+import torchvision.transforms as T
+
+sys.path.insert(0, "/apdcephfs_gy4/share_303628665/joywu/research/LipFD")
+from evaluate_robustness import perturb_bgr, SEVERITY
+
+OUT = "/apdcephfs_gy4/share_303628665/joywu/research/LipFD/robustnessv3/_diag"
+os.makedirs(OUT, exist_ok=True)
+
+img_path = "/apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/test/0_real/2358_Real_CelebV-HQ_0.png"
+img_cv = cv2.imread(img_path)
+print(f"loaded: {img_cv.shape} {img_cv.dtype}  min={img_cv.min()} max={img_cv.max()}")
+H, W = img_cv.shape[:2]
+print(f"H={H} W={W}")
+
+# Same crop logic as data.AVLip / validate.py
+def lipfd_crops(img_uint8):
+    """Replicates data/datasets.py:25-71. Returns list of crops the model sees."""
+    img = torch.tensor(img_uint8, dtype=torch.float32).permute(2, 0, 1)  # (3, H, W)
+    # Note the slicing: img[:, 500:, i:i+500] for i in range(5)
+    # range(5) => i = 0,1,2,3,4 — so 5 crops are NEARLY THE SAME, shifted by 1 px.
+    base_crops = [img[:, 500:, i:i + 500] for i in range(5)]
+    return [c.numpy().astype(np.uint8).transpose(1, 2, 0) for c in base_crops]
+
+clean_strip = img_cv[500:, :, :].copy()
+clean_crops = lipfd_crops(img_cv)
+print(f"\nclean: bottom strip shape={clean_strip.shape} -> 5 crops of shape {clean_crops[0].shape}")
+
+print(f"\n5 crop offsets (i in range(5) → cols i:i+500): only LEFT {500+4}={504} of {W} cols ever reach model")
+print(f"  crop0 covers cols 0:500, crop1 covers cols 1:501, ..., crop4 covers cols 4:504")
+print(f"  crops are nearly IDENTICAL — model effectively sees 1 region, not 5 spatial faces\n")
+
+print("="*100)
+print(f"{'perturbation':<18} {'L5 param':>10}  {'strip Δ mean abs':>18} {'strip max diff':>14}  {'crop0 Δ mean abs':>18}")
+print("-"*100)
+for p in ["color_saturation", "color_contrast", "block_wise", "gaussian_noise",
+          "gaussian_blur", "pixelate", "jpeg_quality"]:
+    perturbed_strip = perturb_bgr(clean_strip, p, 5, base_seed=42)
+    diff_strip = np.abs(perturbed_strip.astype(int) - clean_strip.astype(int))
+
+    img_pert = img_cv.copy()
+    img_pert[500:, :, :] = perturbed_strip
+    crops_pert = lipfd_crops(img_pert)
+    diff_crop0 = np.abs(crops_pert[0].astype(int) - clean_crops[0].astype(int))
+
+    print(f"{p:<18} {str(SEVERITY[p][4]):>10}  {diff_strip.mean():>18.3f} {diff_strip.max():>14d}  {diff_crop0.mean():>18.3f}")
+
+    # save side-by-side png for visual check (resize for compactness)
+    side = np.concatenate([clean_strip, perturbed_strip], axis=0)
+    side_small = cv2.resize(side, (1000, 400))
+    cv2.imwrite(f"{OUT}/L5_{p}_strip.png", side_small)
+    cv2.imwrite(f"{OUT}/L5_{p}_crop0.png",
+                np.concatenate([clean_crops[0], crops_pert[0]], axis=1))
+print("="*100)
+print(f"\nSide-by-side PNGs saved to {OUT}/")

convert_ft_work.py

@@ -0,0 +1,177 @@
+import os
+import shutil
+from tqdm import tqdm
+import librosa
+import soundfile as sf
+import subprocess
+
+"""
+将FT_work数据集转换为AVLips格式
+
+FT_work原始结构:
+videos/
+├── train/
+│   ├── real/Real/*.mp4
+│   └── fake/{AniPortrait,Joyvasa,Ditto,Hallo,Sonic}/*.mp4
+├── test/
+│   ├── real/Real/*.mp4
+│   └── fake/{SadTalk,EDTalk,Float}/*.mp4
+└── val/
+    ├── real/Real/*.mp4
+    └── fake/{AniPortrait,Joyvasa,Ditto,Hallo,Sonic}/*.mp4
+
+目标AVLips结构:
+AVLips/
+├── 0_real/*.mp4
+├── 1_fake/*.mp4
+└── wav/
+    ├── 0_real/*.wav
+    └── 1_fake/*.wav
+
+注意：需要先从视频中提取音频
+"""
+
+# 配置参数
+FT_WORK_ROOT = "/apdcephfs_gy5/share_303628665/joyewu/dataset/FT_work"
+OUTPUT_ROOT = "./AVLips"  # 输出为AVLips格式
+EXTRACT_AUDIO = True  # 是否从视频中提取音频
+
+
+def extract_audio_from_video(video_path, audio_path):
+    """使用ffmpeg从视频中提取音频"""
+    try:
+        cmd = [
+            "ffmpeg", "-i", video_path,
+            "-vn",  # 不要视频
+            "-acodec", "pcm_s16le",  # WAV格式
+            "-ar", "16000",  # 采样率16kHz（librosa默认）
+            "-ac", "1",  # 单声道
+            "-y",  # 覆盖已存在文件
+            audio_path
+        ]
+        subprocess.run(cmd, capture_output=True, check=True)
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"音频提取失败: {video_path}")
+        print(f"错误: {e.stderr.decode() if e.stderr else 'Unknown error'}")
+        return False
+    except Exception as e:
+        print(f"音频提取异常: {video_path}")
+        print(f"错误: {str(e)}")
+        return False
+
+
+def process_split(split_name, output_video_real, output_video_fake, output_audio_real, output_audio_fake):
+    """
+    处理一个数据集分割（train/test/val）
+    
+    Args:
+        split_name: 分割名称 ('train', 'test', 'val')
+        output_video_real: 输出真实视频目录
+        output_video_fake: 输出假视频目录
+        output_audio_real: 输出真实音频目录
+        output_audio_fake: 输出假音频目录
+    """
+    split_path = os.path.join(FT_WORK_ROOT, "videos", split_name)
+    
+    if not os.path.exists(split_path):
+        print(f"警告: {split_path} 不存在，跳过")
+        return
+    
+    # 处理真实视频
+    real_path = os.path.join(split_path, "real", "Real")
+    if os.path.exists(real_path):
+        print(f"\n处理 {split_name}/real...")
+        video_files = [f for f in os.listdir(real_path) if f.endswith('.mp4')]
+        
+        for video_file in tqdm(video_files, desc="真实视频"):
+            src_video = os.path.join(real_path, video_file)
+            dst_video = os.path.join(output_video_real, video_file)
+            
+            # 复制视频文件
+            if not os.path.exists(dst_video):
+                shutil.copy2(src_video, dst_video)
+            
+            # 提取音频
+            if EXTRACT_AUDIO:
+                audio_file = video_file.replace('.mp4', '.wav')
+                dst_audio = os.path.join(output_audio_real, audio_file)
+                if not os.path.exists(dst_audio):
+                    extract_audio_from_video(src_video, dst_audio)
+    
+    # 处理假视频
+    fake_path = os.path.join(split_path, "fake")
+    if os.path.exists(fake_path):
+        print(f"\n处理 {split_name}/fake...")
+        fake_methods = os.listdir(fake_path)
+        
+        for method in fake_methods:
+            method_path = os.path.join(fake_path, method)
+            if not os.path.isdir(method_path):
+                continue
+            
+            video_files = [f for f in os.listdir(method_path) if f.endswith('.mp4')]
+            
+            for video_file in tqdm(video_files, desc=f"假视频/{method}"):
+                src_video = os.path.join(method_path, video_file)
+                
+                # 为了避免文件名冲突，添加方法前缀
+                new_name = f"{method}_{video_file}"
+                dst_video = os.path.join(output_video_fake, new_name)
+                
+                # 复制视频文件
+                if not os.path.exists(dst_video):
+                    shutil.copy2(src_video, dst_video)
+                
+                # 提取音频
+                if EXTRACT_AUDIO:
+                    audio_file = new_name.replace('.mp4', '.wav')
+                    dst_audio = os.path.join(output_audio_fake, audio_file)
+                    if not os.path.exists(dst_audio):
+                        extract_audio_from_video(src_video, dst_audio)
+
+
+def main():
+    # 创建输出目录结构
+    print("创建输出目录结构...")
+    dirs = [
+        os.path.join(OUTPUT_ROOT, "0_real"),
+        os.path.join(OUTPUT_ROOT, "1_fake"),
+        os.path.join(OUTPUT_ROOT, "wav", "0_real"),
+        os.path.join(OUTPUT_ROOT, "wav", "1_fake"),
+    ]
+    
+    for d in dirs:
+        os.makedirs(d, exist_ok=True)
+        print(f"  创建: {d}")
+    
+    # 处理各个分割
+    splits = ['train', 'test', 'val']
+    
+    for split in splits:
+        print(f"\n{'='*50}")
+        print(f"处理分割: {split}")
+        print(f"{'='*50}")
+        
+        process_split(
+            split_name=split,
+            output_video_real=os.path.join(OUTPUT_ROOT, "0_real"),
+            output_video_fake=os.path.join(OUTPUT_ROOT, "1_fake"),
+            output_audio_real=os.path.join(OUTPUT_ROOT, "wav", "0_real"),
+            output_audio_fake=os.path.join(OUTPUT_ROOT, "wav", "1_fake")
+        )
+    
+    print(f"\n{'='*50}")
+    print("转换完成！")
+    print(f"{'='*50}")
+    print(f"\n输出目录: {OUTPUT_ROOT}")
+    print(f"目录结构:")
+    print(f"├── 0_real/  ({len(os.listdir(os.path.join(OUTPUT_ROOT, '0_real')))} 个视频)")
+    print(f"├── 1_fake/  ({len(os.listdir(os.path.join(OUTPUT_ROOT, '1_fake')))} 个视频)")
+    print(f"└── wav/")
+    print(f"    ├── 0_real/  ({len(os.listdir(os.path.join(OUTPUT_ROOT, 'wav', '0_real')))} 个音频)")
+    print(f"    └── 1_fake/  ({len(os.listdir(os.path.join(OUTPUT_ROOT, 'wav', '1_fake')))} 个音频)")
+
+
+if __name__ == "__main__":
+    main()

evaluate_robustness.py

@@ -0,0 +1,621 @@
+"""evaluate_robustness.py
+
+Run robustness evaluation on LipFD: in-memory perturb the bottom face strip
+(rows 500: of the 1000x2500 composite) and re-evaluate AUROC / per-fake-vs-real /
+fairness. ZERO additional disk: perturbation is applied inside __getitem__,
+only the metrics JSON is written.
+
+Perturbation set (paper-aligned, 7 frame-level subset):
+  color_saturation | color_contrast | block_wise | gaussian_noise |
+  gaussian_blur   | pixelate        | jpeg_quality
+Levels: 1..5  (level 1 = no-op for all 7 in SEVERITY, level 5 = heaviest).
+
+Aggregation: clip-level by basename (e.g. '2358_Real', '1681_Fake').
+Demographics (gender / race4 / age_group) joined from a CSV that maps
+basename -> demo attributes.
+
+============================================================================
+Commands actually executed in this session (cwd = /apdcephfs_gy4/share_303628665/joywu/research/LipFD)
+============================================================================
+# (a) Smoke test 1 — level=1 (no-op) clean baseline:
+#     /opt/conda/envs/LipFD/bin/python evaluate_robustness.py \
+#         --real_list_path datasets/FairTalking-Bench/test/0_real \
+#         --fake_list_path datasets/FairTalking-Bench/test/1_fake \
+#         --ckpt          checkpoints/lipfd_train/model_epoch_44.pth \
+#         --demographics_csv /apdcephfs_gy4/share_303628665/joywu/research/test.csv \
+#         --perturbation gaussian_noise --level 1 \
+#         --batch_size 16 --loader_workers 4 --gpu 0 \
+#         --save_json /apdcephfs_gy4/share_303628665/joywu/research/LipFD/robustness/runs.json
+#     -> overall_clip AUROC=0.9958  AP=0.9956  Acc=0.9484  n_clips=581  n_samples=11610
+#
+# (b) Smoke test 2 — gaussian_noise level=3 (verify perturbation actually bites):
+#     /opt/conda/envs/LipFD/bin/python evaluate_robustness.py \
+#         --real_list_path datasets/FairTalking-Bench/test/0_real \
+#         --fake_list_path datasets/FairTalking-Bench/test/1_fake \
+#         --ckpt          checkpoints/lipfd_train/model_epoch_44.pth \
+#         --demographics_csv /apdcephfs_gy4/share_303628665/joywu/research/test.csv \
+#         --perturbation gaussian_noise --level 3 \
+#         --batch_size 16 --loader_workers 4 --gpu 0 \
+#         --save_json /apdcephfs_gy4/share_303628665/joywu/research/LipFD/robustness/runs.json
+#     -> overall_clip AUROC=0.9772 (down 0.019)  TPR@1%FPR=0.4966 (down 0.34) — perturbation works
+#
+# (c) Full sweep (7 perturbations x 5 levels = 35 combos, level=1 only run once):
+#     nohup bash run_robustness.sh > robustness/sweep.log 2>&1 &
+#     # run_robustness.sh internally calls this script 29 times (1 baseline + 7*4 levels),
+#     # appending each run to robustness/runs.json. ~2.7h on a single 100GB-class GPU.
+
+Usage (single perturbation x level):
+    python evaluate_robustness.py \
+        --real_list_path datasets/FairTalking-Bench/test/0_real \
+        --fake_list_path datasets/FairTalking-Bench/test/1_fake \
+        --ckpt           checkpoints/lipfd_train/model_epoch_44.pth \
+        --demographics_csv /apdcephfs_gy4/share_303628665/joywu/research/test.csv \
+        --perturbation gaussian_noise --level 3 \
+        --save_json    robustness/runs.json
+"""
+
+import argparse
+import collections
+import csv as _csv
+import json
+import math
+import os
+import random as _rng_mod
+import re
+import sys
+import time
+
+import cv2
+import numpy as np
+import torch
+import torchvision.transforms as transforms
+from sklearn.metrics import (
+    accuracy_score,
+    average_precision_score,
+    classification_report,
+    confusion_matrix,
+    roc_auc_score,
+    roc_curve,
+)
+from torch.utils.data import DataLoader, Dataset
+from tqdm import tqdm
+
+_REPO_ROOT = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, _REPO_ROOT)
+
+from models import build_model  # noqa: E402
+import utils as _u  # noqa: E402
+
+
+# ============================================================================
+# Perturbation parameters — verbatim from X-AVDT/train/evaluate_robustness.py
+# (originally from AVH-Align/robustness/distortions.py).
+# ============================================================================
+SEVERITY = {
+    "color_saturation":  [1.0,   0.8,   1.2,   1.5,   2.0],
+    "color_contrast":    [1.0,   0.85,  1.2,   1.4,   1.6],
+    "block_wise":        [0,     8,     16,    24,    32],
+    "gaussian_noise":    [0.0,   0.001, 0.005, 0.01,  0.05],
+    "gaussian_blur":     [1,     3,     7,     11,    15],
+    "pixelate":          [1,     2,     4,     6,     8],
+    "jpeg_quality":      [100,   85,    70,    50,    30],
+}
+PERTURBATIONS = list(SEVERITY.keys())
+DEMO_DIMS = ("gender", "race4", "age_group")
+
+
+# ----- frame-level perturbation primitives (BGR uint8) -----
+def _bgr2ycbcr(img_bgr):
+    img = img_bgr.astype(np.float32) / 255.0
+    M = np.array([
+        [ 0.299,    0.587,    0.114],
+        [-0.16874, -0.33126,  0.5],
+        [ 0.5,    -0.41869, -0.08131],
+    ], dtype=np.float32)
+    yuv = img @ M.T
+    yuv[..., 1:] += 0.5
+    return yuv
+
+
+def _ycbcr2bgr(ycbcr):
+    yuv = ycbcr.copy()
+    yuv[..., 1:] -= 0.5
+    M = np.array([
+        [1.0,  0.0,      1.402],
+        [1.0, -0.34414, -0.71414],
+        [1.0,  1.772,    0.0],
+    ], dtype=np.float32)
+    return np.clip(yuv @ M.T * 255.0, 0, 255)
+
+
+def _apply_color_saturation(b, p):
+    if abs(p - 1.0) < 1e-6:
+        return b
+    y = _bgr2ycbcr(b)
+    y[..., 1] = 0.5 + (y[..., 1] - 0.5) * p
+    y[..., 2] = 0.5 + (y[..., 2] - 0.5) * p
+    return np.clip(_ycbcr2bgr(y), 0, 255).astype(np.uint8)
+
+
+def _apply_color_contrast(b, p):
+    if abs(p - 1.0) < 1e-6:
+        return b
+    return np.clip(b.astype(np.float32) * p, 0, 255).astype(np.uint8)
+
+
+def _apply_block_wise(b, p, rng):
+    if p <= 0:
+        return b
+    width = 8
+    block = np.ones((width, width, 3), dtype=np.uint8) * 128
+    n = max(1, min(b.shape[0], b.shape[1]) // 256 * int(p))
+    out = b.copy()
+    H, W = b.shape[:2]
+    for _ in range(n):
+        rw = rng.randint(0, W - 1 - width)
+        rh = rng.randint(0, H - 1 - width)
+        out[rh:rh + width, rw:rw + width, :] = block
+    return out
+
+
+def _apply_gaussian_noise(b, p, rng_np):
+    if p <= 0:
+        return b
+    y = _bgr2ycbcr(b)
+    h, w, c = y.shape
+    noise = math.sqrt(p) * rng_np.standard_normal((h, w, c)).astype(np.float32)
+    return np.clip(_ycbcr2bgr(y + noise), 0, 255).astype(np.uint8)
+
+
+def _apply_gaussian_blur(b, k):
+    k = int(k)
+    if k <= 1:
+        return b
+    if k % 2 == 0:
+        k += 1
+    return cv2.GaussianBlur(b, (k, k), k / 6.0)
+
+
+def _apply_pixelate(b, f):
+    f = int(f)
+    if f <= 1:
+        return b
+    h, w = b.shape[:2]
+    sw, sh = max(1, w // f), max(1, h // f)
+    small = cv2.resize(b, (sw, sh), interpolation=cv2.INTER_AREA)
+    return cv2.resize(small, (w, h), interpolation=cv2.INTER_LINEAR)
+
+
+def _apply_jpeg(b, q):
+    q = int(q)
+    if q >= 100:
+        return b
+    ok, buf = cv2.imencode(".jpg", b, [int(cv2.IMWRITE_JPEG_QUALITY), q])
+    if not ok:
+        return b
+    dec = cv2.imdecode(buf, cv2.IMREAD_COLOR)
+    return dec if dec is not None else b
+
+
+def perturb_bgr(bgr_uint8, perturbation, level, base_seed=42):
+    """Apply perturbation to a single BGR uint8 region. Returns BGR uint8."""
+    param = SEVERITY[perturbation][level - 1]
+    seed = (hash((base_seed, perturbation, level)) & 0xFFFFFFFF)
+    py_rng = _rng_mod.Random(seed)
+    np_rng = np.random.RandomState(seed)
+    if perturbation == "color_saturation":
+        return _apply_color_saturation(bgr_uint8, param)
+    elif perturbation == "color_contrast":
+        return _apply_color_contrast(bgr_uint8, param)
+    elif perturbation == "block_wise":
+        return _apply_block_wise(bgr_uint8, param, py_rng)
+    elif perturbation == "gaussian_noise":
+        return _apply_gaussian_noise(bgr_uint8, param, np_rng)
+    elif perturbation == "gaussian_blur":
+        return _apply_gaussian_blur(bgr_uint8, param)
+    elif perturbation == "pixelate":
+        return _apply_pixelate(bgr_uint8, param)
+    elif perturbation == "jpeg_quality":
+        return _apply_jpeg(bgr_uint8, param)
+    raise ValueError(f"unsupported perturbation: {perturbation}")
+
+
+# ============================================================================
+# Wrapper Dataset — replicate AVLip preprocessing, perturbing only the bottom
+# face strip (rows 500: of the 1000x2500 composite).
+# ============================================================================
+_BASENAME_RE = re.compile(r"(\d+_(?:Real|Fake))")
+
+
+def _extract_basename(img_path):
+    """'/.../2358_Real_CelebV-HQ_0.png' -> '2358_Real'
+       '/.../EDTalk_1681_Fake_EDTalk_0.png' -> '1681_Fake'."""
+    m = _BASENAME_RE.search(os.path.basename(img_path))
+    return m.group(1) if m else os.path.basename(img_path).rsplit(".", 1)[0]
+
+
+def _extract_model_id(img_path, label):
+    """Real -> 'Real'; fake -> the prefix model name (EDTalk / Float / SadTalk / ...)."""
+    if label == 0:
+        return "Real"
+    return os.path.basename(img_path).split("_", 1)[0]
+
+
+class PerturbedAVLip(Dataset):
+    """Mirrors data.AVLip preprocessing exactly, but perturbs the bottom 500
+    rows (face strip) before slicing into crops at 3 scales."""
+
+    def __init__(self, real_dir, fake_dir, perturbation, level, base_seed=42):
+        self.real_list = _u.get_list(real_dir)
+        self.fake_list = _u.get_list(fake_dir)
+        self.label_dict = {p: 0 for p in self.real_list}
+        self.label_dict.update({p: 1 for p in self.fake_list})
+        self.total_list = self.real_list + self.fake_list
+        self.perturbation = perturbation
+        self.level = level
+        self.base_seed = base_seed
+        self._is_noop = level == 1   # level 1 is no-op for every perturbation
+
+    def __len__(self):
+        return len(self.total_list)
+
+    def _read_with_skip(self, idx, tried):
+        if len(tried) >= len(self.total_list):
+            raise RuntimeError("All samples are corrupted or cannot be read!")
+        tried.add(idx)
+        path = self.total_list[idx]
+        if not os.path.exists(path):
+            print(f"WARNING: File not found, skipping: {path}")
+            return self._read_with_skip((idx + 1) % len(self.total_list), tried)
+        img_cv = cv2.imread(path)
+        if img_cv is None:
+            print(f"WARNING: Failed to read image, skipping: {path}")
+            return self._read_with_skip((idx + 1) % len(self.total_list), tried)
+        return img_cv, self.label_dict[path], path
+
+    def __getitem__(self, idx):
+        img_cv, label, path = self._read_with_skip(idx, set())   # BGR (H,W,3) uint8
+
+        # ---- perturb only the bottom face strip (rows 500:) ----
+        if not self._is_noop:
+            face_strip = img_cv[500:, :, :]
+            perturbed = perturb_bgr(face_strip, self.perturbation, self.level, self.base_seed)
+            img_cv = img_cv.copy()
+            img_cv[500:, :, :] = perturbed
+
+        # ---- preprocessing — bit-faithful with data/datasets.py:AVLip.__getitem__ ----
+        img = torch.tensor(img_cv, dtype=torch.float32).permute(2, 0, 1)
+        # NB: original AVLip computes Normalize(img) then immediately overwrites
+        # `crops` with un-normalized strips, so the normalize is dead. We omit it.
+        # FIX: 5-crop slicing was `i:i+500 for i in range(5)` (5 near-identical
+        # 1-px-shifted views of face0); changed to `i*500:(i+1)*500` so 5 distinct
+        # 500x500 face patches reach the model. Same fix in data/datasets.py:64.
+        crops = [[transforms.Resize((224, 224))(img[:, 500:, i*500:(i+1)*500]) for i in range(5)], [], []]
+        crop_idx = [(28, 196), (61, 163)]
+        for i in range(len(crops[0])):
+            crops[1].append(transforms.Resize((224, 224))(
+                crops[0][i][:, crop_idx[0][0]:crop_idx[0][1], crop_idx[0][0]:crop_idx[0][1]]))
+            crops[2].append(transforms.Resize((224, 224))(
+                crops[0][i][:, crop_idx[1][0]:crop_idx[1][1], crop_idx[1][0]:crop_idx[1][1]]))
+        big = transforms.Resize((1120, 1120))(img)
+        return big, crops, label, path
+
+
+def custom_collate(batch):
+    """Same collate as validate.py — flattens the (scales x crops) list-of-tensors
+    into per-(scale, crop) batched tensors of shape (B, 3, 224, 224)."""
+    imgs = torch.stack([item[0] for item in batch])
+    num_scales = len(batch[0][1])
+    num_crops = len(batch[0][1][0])
+    crops = []
+    for s in range(num_scales):
+        scale_crops = []
+        for c in range(num_crops):
+            tensors = [batch[i][1][s][c] for i in range(len(batch))]
+            scale_crops.append(torch.stack(tensors))
+        crops.append(scale_crops)
+    labels = torch.tensor([item[2] for item in batch])
+    paths = [item[3] for item in batch]
+    return imgs, crops, labels, paths
+
+
+# ============================================================================
+# metric helpers (X-AVDT-compatible)
+# ============================================================================
+def _tpr_at_fpr(y_true, y_score, fpr_target):
+    fpr, tpr, _ = roc_curve(y_true, y_score)
+    if (fpr <= fpr_target).any():
+        return float(tpr[fpr <= fpr_target].max())
+    return 0.0
+
+
+def _compute_eer_threshold(y_true, y_score):
+    fpr, tpr, thresholds = roc_curve(y_true, y_score)
+    fnr = 1 - tpr
+    return float(thresholds[int(np.argmin(np.abs(fpr - fnr)))])
+
+
+def _metrics_block(y_true, y_score, threshold=0.5):
+    y_true = np.asarray(y_true)
+    y_score = np.asarray(y_score)
+    y_pred = (y_score >= threshold).astype(int)
+
+    out = {}
+    try:
+        out["AUROC"] = float(roc_auc_score(y_true, y_score))
+    except Exception:
+        out["AUROC"] = None
+    try:
+        out["AP"] = float(average_precision_score(y_true, y_score))
+    except Exception:
+        out["AP"] = None
+    out[f"Accuracy@{threshold:.2f}"] = float(accuracy_score(y_true, y_pred))
+    out["Confusion Matrix"] = confusion_matrix(y_true, y_pred, labels=[0, 1]).tolist()
+    out["Classification Report"] = classification_report(
+        y_true, y_pred, labels=[0, 1], output_dict=True, zero_division=0
+    )
+    try:
+        thr = _compute_eer_threshold(y_true, y_score)
+        out["EER_threshold"] = thr
+        out["Acc@EER"] = float(accuracy_score(y_true, (y_score >= thr).astype(int)))
+    except Exception:
+        out["EER_threshold"] = None
+        out["Acc@EER"] = None
+    try:
+        out["TPR@FPR=1%"] = _tpr_at_fpr(y_true, y_score, 0.01)
+        out["TPR@FPR=0.1%"] = _tpr_at_fpr(y_true, y_score, 0.001)
+    except Exception:
+        out["TPR@FPR=1%"] = None
+        out["TPR@FPR=0.1%"] = None
+    return out
+
+
+def _fmt4(v):
+    try:
+        return f"{float(v):.4f}"
+    except Exception:
+        return "n/a"
+
+
+def _set_seed(seed):
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+
+def load_ckpt(model, ckpt_path):
+    ckpt = torch.load(ckpt_path, map_location="cpu", weights_only=False)
+    state = ckpt.get("model", ckpt) if isinstance(ckpt, dict) else ckpt
+    cleaned = collections.OrderedDict()
+    for k, v in state.items():
+        if k.startswith("module."):
+            k = k[len("module."):]
+        cleaned[k] = v
+    info = model.load_state_dict(cleaned, strict=False)
+    out = {"missing_count": len(info.missing_keys),
+           "unexpected_count": len(info.unexpected_keys)}
+    if not info.missing_keys and not info.unexpected_keys:
+        print(f"[OK] Strict checkpoint match: all {len(cleaned)} keys consumed.")
+    else:
+        print(f"[WARN] missing={len(info.missing_keys)} unexpected={len(info.unexpected_keys)}")
+    return out
+
+
+def compute_fairness(y_true, y_score, groups):
+    y_true = np.asarray(y_true)
+    y_score = np.asarray(y_score)
+    groups = np.asarray(groups)
+    pred = (y_score > 0.5).astype(int)
+
+    def _g_fpr(g):
+        m = (groups == g) & (y_true == 0)
+        return float(pred[m].mean()) if m.sum() else 0.0
+
+    def _g_tpr(g):
+        m = (groups == g) & (y_true == 1)
+        return float(pred[m].mean()) if m.sum() else 0.0
+
+    def _g_acc(g):
+        m = (groups == g)
+        return float((pred[m] == y_true[m]).mean()) if m.sum() else 0.0
+
+    def _g_dp(g):
+        m = (groups == g)
+        return float(pred[m].mean()) if m.sum() else 0.0
+
+    uniq = sorted(set(groups.tolist()))
+    if not uniq:
+        return None
+    fprs = [_g_fpr(g) for g in uniq]
+    tprs = [_g_tpr(g) for g in uniq]
+    accs = [_g_acc(g) for g in uniq]
+    dps  = [_g_dp(g)  for g in uniq]
+    ns   = [int((groups == g).sum()) for g in uniq]
+    return {
+        "F_FPR": float(np.std(fprs)) * 100,
+        "F_MEO": (max(max(fprs) - min(fprs), max(tprs) - min(tprs))) * 100,
+        "F_DP":  float(np.std(dps))  * 100,
+        "F_OAE": float(np.std(accs)) * 100,
+        "groups": {g: {"n": n, "fpr": f, "tpr": t, "acc": a, "dp": d}
+                   for g, n, f, t, a, d in zip(uniq, ns, fprs, tprs, accs, dps)},
+    }
+
+
+def load_demographics(csv_path):
+    out = {}
+    with open(csv_path, newline="") as f:
+        for row in _csv.DictReader(f):
+            base = row["basename"].strip()
+            if base:
+                out[base] = {
+                    "gender":    (row.get("gender") or "").strip(),
+                    "race4":     (row.get("race4") or "").strip(),
+                    "age_group": (row.get("age_group") or "").strip(),
+                }
+    return out
+
+
+# ============================================================================
+# main
+# ============================================================================
+def parse_args():
+    p = argparse.ArgumentParser()
+    p.add_argument("--real_list_path", type=str, required=True)
+    p.add_argument("--fake_list_path", type=str, required=True)
+    p.add_argument("--ckpt", type=str, required=True)
+    p.add_argument("--demographics_csv", type=str, required=True)
+    p.add_argument("--perturbation", type=str, required=True, choices=PERTURBATIONS)
+    p.add_argument("--level", type=int, required=True, choices=[1, 2, 3, 4, 5])
+    p.add_argument("--arch", type=str, default="CLIP:ViT-L/14")
+    p.add_argument("--batch_size", type=int, default=8)
+    p.add_argument("--loader_workers", type=int, default=4)
+    p.add_argument("--gpu", type=int, default=0)
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument("--save_json", type=str, default=None)
+    return p.parse_args()
+
+
+def main():
+    args = parse_args()
+    _set_seed(args.seed)
+    device = torch.device(f"cuda:{args.gpu}" if torch.cuda.is_available() else "cpu")
+    print(f"[robustness] perturbation={args.perturbation} level={args.level} "
+          f"param={SEVERITY[args.perturbation][args.level - 1]} ckpt={args.ckpt}")
+
+    model = build_model(args.arch)
+    load_info = load_ckpt(model, args.ckpt)
+    model.to(device).eval()
+
+    demographics = load_demographics(args.demographics_csv)
+
+    dataset = PerturbedAVLip(args.real_list_path, args.fake_list_path,
+                             args.perturbation, args.level, args.seed)
+    loader = DataLoader(
+        dataset, batch_size=args.batch_size, shuffle=False,
+        num_workers=args.loader_workers, pin_memory=torch.cuda.is_available(),
+        collate_fn=custom_collate,
+        persistent_workers=args.loader_workers > 0,
+        prefetch_factor=2 if args.loader_workers > 0 else None,
+    )
+
+    all_scores, all_labels, all_paths = [], [], []
+    with torch.inference_mode():
+        for imgs, crops, labels, paths in tqdm(
+                loader, desc=f"{args.perturbation}/L{args.level}", leave=False):
+            imgs = imgs.to(device)
+            crops = [[t.to(device) for t in sc] for sc in crops]
+            features = model.get_features(imgs).to(device)
+            logits = model(crops, features)[0]
+            prob = torch.sigmoid(logits.flatten()).cpu().numpy()
+            all_scores.extend(prob.tolist())
+            all_labels.extend(labels.numpy().tolist())
+            all_paths.extend(paths)
+
+    # ----- clip-level aggregation by basename -----
+    bag_scores = collections.defaultdict(list)
+    bag_meta = {}
+    for path, lab, sc in zip(all_paths, all_labels, all_scores):
+        basename = _extract_basename(path)
+        bag_scores[basename].append(sc)
+        if basename not in bag_meta:
+            mid = _extract_model_id(path, lab)
+            demo = demographics.get(basename, {"gender": "", "race4": "", "age_group": ""})
+            bag_meta[basename] = {"label": int(lab), "model_id": mid, **demo}
+
+    clip_keys = sorted(bag_scores)
+    clip_scores = np.array([float(np.mean(bag_scores[k])) for k in clip_keys])
+    clip_labels = np.array([bag_meta[k]["label"] for k in clip_keys])
+    clip_models = [bag_meta[k]["model_id"] for k in clip_keys]
+    clip_demos  = {d: [bag_meta[k][d] for k in clip_keys] for d in DEMO_DIMS}
+
+    result = {
+        "perturbation": args.perturbation,
+        "level": args.level,
+        "param": SEVERITY[args.perturbation][args.level - 1],
+        "n_clips": len(clip_keys),
+        "n_samples": len(all_scores),
+    }
+
+    # overall (clip-level)
+    o = _metrics_block(clip_labels.tolist(), clip_scores.tolist())
+    o["Accuracy"] = o["Accuracy@0.50"]
+    result["overall_clip"] = o
+
+    # per-fake-vs-real (clip-level)
+    real_idx = [i for i, y in enumerate(clip_labels) if y == 0]
+    real_scores = clip_scores[real_idx].tolist()
+    real_labels = clip_labels[real_idx].tolist()
+
+    fake_models = sorted({m for m, l in zip(clip_models, clip_labels) if l == 1})
+    per_fake = {}
+    for fm in fake_models:
+        idxs = [i for i, (m, l) in enumerate(zip(clip_models, clip_labels))
+                if m == fm and l == 1]
+        joint_s = clip_scores[idxs].tolist() + real_scores
+        joint_l = clip_labels[idxs].tolist() + real_labels
+        block = _metrics_block(joint_l, joint_s)
+        block["Accuracy"] = block["Accuracy@0.50"]
+        per_fake[fm] = block
+    result["per_fake_vs_real"] = per_fake
+
+    # fairness (whole test, clip-level)
+    result["fairness_overall"] = {}
+    for d in DEMO_DIMS:
+        groups = clip_demos[d]
+        valid = [i for i, g in enumerate(groups) if g]
+        if not valid:
+            continue
+        fb = compute_fairness(
+            [clip_labels[i] for i in valid],
+            [clip_scores[i] for i in valid],
+            [groups[i] for i in valid],
+        )
+        result["fairness_overall"][d] = fb
+
+    # ----- console summary -----
+    print(f"\n[{args.perturbation} L{args.level}]  overall_clip "
+          f"AUROC={_fmt4(o['AUROC'])} AP={_fmt4(o['AP'])} Acc={_fmt4(o['Accuracy'])} "
+          f"Acc@EER={_fmt4(o['Acc@EER'])} TPR@1%FPR={_fmt4(o['TPR@FPR=1%'])} "
+          f"TPR@0.1%FPR={_fmt4(o['TPR@FPR=0.1%'])}  "
+          f"(n_clips={result['n_clips']} n_samples={result['n_samples']})")
+    for fm, blk in per_fake.items():
+        print(f"  [{fm}+Real] AUROC={_fmt4(blk['AUROC'])} AP={_fmt4(blk['AP'])} "
+              f"Acc={_fmt4(blk['Accuracy'])} Acc@EER={_fmt4(blk['Acc@EER'])}")
+    for d in DEMO_DIMS:
+        fb = result["fairness_overall"].get(d)
+        if fb:
+            print(f"  fairness[{d}] F_FPR={fb['F_FPR']:.2f} F_MEO={fb['F_MEO']:.2f} "
+                  f"F_DP={fb['F_DP']:.2f} F_OAE={fb['F_OAE']:.2f}")
+
+    # ----- save / append json -----
+    if args.save_json:
+        os.makedirs(os.path.dirname(args.save_json) or ".", exist_ok=True)
+        existing = []
+        if os.path.exists(args.save_json):
+            try:
+                with open(args.save_json) as f:
+                    blob = json.load(f)
+                existing = blob.get("runs", []) if isinstance(blob, dict) else []
+            except Exception:
+                existing = []
+        run = {
+            "ckpt": args.ckpt,
+            "saved_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+            "load_info": load_info,
+            "real_list_path": args.real_list_path,
+            "fake_list_path": args.fake_list_path,
+            "demographics_csv": args.demographics_csv,
+            "seed": args.seed,
+            **result,
+        }
+        existing.append(run)
+        with open(args.save_json, "w") as f:
+            json.dump({"runs": existing}, f, indent=2, default=float)
+        print(f"\n>>> Appended run to {args.save_json}")
+
+
+if __name__ == "__main__":
+    main()

evaluate_test.py

@@ -0,0 +1,251 @@
+"""evaluate_test.py
+
+Plain test-set evaluation for LipFD: load a trained ckpt, run inference on
+the FairTalking-Bench test split, and report:
+  - overall (clip-level): AUROC / AP / Accuracy / Acc@EER / TPR@1%FPR / TPR@0.1%FPR
+  - per-fake-vs-real (each fake model paired with all reals)
+  - fairness (gender / race4 / age_group): F_FPR, F_MEO, F_DP, F_OAE
+Clip-level aggregation: mean prob over all frames sharing the same basename
+(e.g. '2358_Real', '1681_Fake').
+
+NO perturbation, NO sweeping — single pass over the test set.
+
+============================================================================
+Usage
+============================================================================
+    cd /apdcephfs_gy4/share_303628665/joywu/research/LipFD
+    /opt/conda/envs/LipFD/bin/python evaluate_test.py \
+        --real_list_path datasets/FairTalking-Bench/test/0_real \
+        --fake_list_path datasets/FairTalking-Bench/test/1_fake \
+        --ckpt          checkpoints/lipfd_train/model_epoch_44.pth \
+        --demographics_csv /apdcephfs_gy4/share_303628665/joywu/research/test.csv \
+        --batch_size 16 --loader_workers 4 --gpu 0 \
+        --save_json     robustness/test_clean.json
+"""
+
+import argparse
+import collections
+import csv as _csv
+import json
+import os
+import sys
+import time
+
+import cv2
+import numpy as np
+import torch
+import torchvision.transforms as transforms
+from sklearn.metrics import (
+    accuracy_score,
+    average_precision_score,
+    classification_report,
+    confusion_matrix,
+    roc_auc_score,
+    roc_curve,
+)
+from torch.utils.data import DataLoader, Dataset
+from tqdm import tqdm
+
+_REPO_ROOT = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, _REPO_ROOT)
+
+from models import build_model  # noqa: E402
+import utils as _u  # noqa: E402
+from evaluate_robustness import (  # noqa: E402  reuse the helpers
+    DEMO_DIMS,
+    _extract_basename,
+    _extract_model_id,
+    _metrics_block,
+    _fmt4,
+    _set_seed,
+    load_ckpt,
+    compute_fairness,
+    load_demographics,
+    custom_collate,
+)
+
+
+class TestAVLip(Dataset):
+    """Mirrors data.AVLip preprocessing; no perturbation."""
+
+    def __init__(self, real_dir, fake_dir):
+        self.real_list = _u.get_list(real_dir)
+        self.fake_list = _u.get_list(fake_dir)
+        self.label_dict = {p: 0 for p in self.real_list}
+        self.label_dict.update({p: 1 for p in self.fake_list})
+        self.total_list = self.real_list + self.fake_list
+
+    def __len__(self):
+        return len(self.total_list)
+
+    def _read_with_skip(self, idx, tried):
+        if len(tried) >= len(self.total_list):
+            raise RuntimeError("All samples are corrupted or cannot be read!")
+        tried.add(idx)
+        path = self.total_list[idx]
+        if not os.path.exists(path):
+            print(f"WARNING: File not found, skipping: {path}")
+            return self._read_with_skip((idx + 1) % len(self.total_list), tried)
+        img_cv = cv2.imread(path)
+        if img_cv is None:
+            print(f"WARNING: Failed to read image, skipping: {path}")
+            return self._read_with_skip((idx + 1) % len(self.total_list), tried)
+        return img_cv, self.label_dict[path], path
+
+    def __getitem__(self, idx):
+        img_cv, label, path = self._read_with_skip(idx, set())
+        img = torch.tensor(img_cv, dtype=torch.float32).permute(2, 0, 1)
+        # FIX: 5-crop slicing — see evaluate_robustness.py:286 for context.
+        crops = [[transforms.Resize((224, 224))(img[:, 500:, i*500:(i+1)*500]) for i in range(5)], [], []]
+        crop_idx = [(28, 196), (61, 163)]
+        for i in range(len(crops[0])):
+            crops[1].append(transforms.Resize((224, 224))(
+                crops[0][i][:, crop_idx[0][0]:crop_idx[0][1], crop_idx[0][0]:crop_idx[0][1]]))
+            crops[2].append(transforms.Resize((224, 224))(
+                crops[0][i][:, crop_idx[1][0]:crop_idx[1][1], crop_idx[1][0]:crop_idx[1][1]]))
+        big = transforms.Resize((1120, 1120))(img)
+        return big, crops, label, path
+
+
+def parse_args():
+    p = argparse.ArgumentParser()
+    p.add_argument("--real_list_path", type=str, required=True)
+    p.add_argument("--fake_list_path", type=str, required=True)
+    p.add_argument("--ckpt", type=str, required=True)
+    p.add_argument("--demographics_csv", type=str, required=True)
+    p.add_argument("--arch", type=str, default="CLIP:ViT-L/14")
+    p.add_argument("--batch_size", type=int, default=16)
+    p.add_argument("--loader_workers", type=int, default=4)
+    p.add_argument("--gpu", type=int, default=0)
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument("--save_json", type=str, default=None,
+                   help="Output JSON. Overwrites if exists (single test = single object, not a list).")
+    return p.parse_args()
+
+
+def main():
+    args = parse_args()
+    _set_seed(args.seed)
+    device = torch.device(f"cuda:{args.gpu}" if torch.cuda.is_available() else "cpu")
+    print(f"[test] ckpt={args.ckpt}")
+
+    model = build_model(args.arch)
+    load_info = load_ckpt(model, args.ckpt)
+    model.to(device).eval()
+
+    demographics = load_demographics(args.demographics_csv)
+
+    dataset = TestAVLip(args.real_list_path, args.fake_list_path)
+    loader = DataLoader(
+        dataset, batch_size=args.batch_size, shuffle=False,
+        num_workers=args.loader_workers, pin_memory=torch.cuda.is_available(),
+        collate_fn=custom_collate,
+        persistent_workers=args.loader_workers > 0,
+        prefetch_factor=2 if args.loader_workers > 0 else None,
+    )
+
+    all_scores, all_labels, all_paths = [], [], []
+    with torch.inference_mode():
+        for imgs, crops, labels, paths in tqdm(loader, desc="test", leave=False):
+            imgs = imgs.to(device)
+            crops = [[t.to(device) for t in sc] for sc in crops]
+            features = model.get_features(imgs).to(device)
+            logits = model(crops, features)[0]
+            prob = torch.sigmoid(logits.flatten()).cpu().numpy()
+            all_scores.extend(prob.tolist())
+            all_labels.extend(labels.numpy().tolist())
+            all_paths.extend(paths)
+
+    # ----- clip-level aggregation by basename -----
+    bag_scores = collections.defaultdict(list)
+    bag_meta = {}
+    for path, lab, sc in zip(all_paths, all_labels, all_scores):
+        basename = _extract_basename(path)
+        bag_scores[basename].append(sc)
+        if basename not in bag_meta:
+            mid = _extract_model_id(path, lab)
+            demo = demographics.get(basename, {"gender": "", "race4": "", "age_group": ""})
+            bag_meta[basename] = {"label": int(lab), "model_id": mid, **demo}
+
+    clip_keys = sorted(bag_scores)
+    clip_scores = np.array([float(np.mean(bag_scores[k])) for k in clip_keys])
+    clip_labels = np.array([bag_meta[k]["label"] for k in clip_keys])
+    clip_models = [bag_meta[k]["model_id"] for k in clip_keys]
+    clip_demos  = {d: [bag_meta[k][d] for k in clip_keys] for d in DEMO_DIMS}
+
+    result = {
+        "n_clips": len(clip_keys),
+        "n_samples": len(all_scores),
+    }
+
+    # overall (clip-level)
+    o = _metrics_block(clip_labels.tolist(), clip_scores.tolist())
+    o["Accuracy"] = o["Accuracy@0.50"]
+    result["overall_clip"] = o
+
+    # per-fake-vs-real
+    real_idx = [i for i, y in enumerate(clip_labels) if y == 0]
+    real_scores = clip_scores[real_idx].tolist()
+    real_labels = clip_labels[real_idx].tolist()
+
+    fake_models = sorted({m for m, l in zip(clip_models, clip_labels) if l == 1})
+    per_fake = {}
+    for fm in fake_models:
+        idxs = [i for i, (m, l) in enumerate(zip(clip_models, clip_labels))
+                if m == fm and l == 1]
+        joint_s = clip_scores[idxs].tolist() + real_scores
+        joint_l = clip_labels[idxs].tolist() + real_labels
+        block = _metrics_block(joint_l, joint_s)
+        block["Accuracy"] = block["Accuracy@0.50"]
+        per_fake[fm] = block
+    result["per_fake_vs_real"] = per_fake
+
+    # fairness
+    result["fairness_overall"] = {}
+    for d in DEMO_DIMS:
+        groups = clip_demos[d]
+        valid = [i for i, g in enumerate(groups) if g]
+        if not valid:
+            continue
+        fb = compute_fairness(
+            [clip_labels[i] for i in valid],
+            [clip_scores[i] for i in valid],
+            [groups[i] for i in valid],
+        )
+        result["fairness_overall"][d] = fb
+
+    # ----- console summary -----
+    print(f"\n[test]  overall_clip "
+          f"AUROC={_fmt4(o['AUROC'])} AP={_fmt4(o['AP'])} Acc={_fmt4(o['Accuracy'])} "
+          f"Acc@EER={_fmt4(o['Acc@EER'])} TPR@1%FPR={_fmt4(o['TPR@FPR=1%'])} "
+          f"TPR@0.1%FPR={_fmt4(o['TPR@FPR=0.1%'])}  "
+          f"(n_clips={result['n_clips']} n_samples={result['n_samples']})")
+    for fm, blk in per_fake.items():
+        print(f"  [{fm}+Real] AUROC={_fmt4(blk['AUROC'])} AP={_fmt4(blk['AP'])} "
+              f"Acc={_fmt4(blk['Accuracy'])} Acc@EER={_fmt4(blk['Acc@EER'])}")
+    for d in DEMO_DIMS:
+        fb = result["fairness_overall"].get(d)
+        if fb:
+            print(f"  fairness[{d}] F_FPR={fb['F_FPR']:.2f} F_MEO={fb['F_MEO']:.2f} "
+                  f"F_DP={fb['F_DP']:.2f} F_OAE={fb['F_OAE']:.2f}")
+
+    # ----- save json (single test = one object, not a list) -----
+    if args.save_json:
+        os.makedirs(os.path.dirname(args.save_json) or ".", exist_ok=True)
+        run = {
+            "ckpt": args.ckpt,
+            "saved_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+            "load_info": load_info,
+            "real_list_path": args.real_list_path,
+            "fake_list_path": args.fake_list_path,
+            "demographics_csv": args.demographics_csv,
+            "seed": args.seed,
+            **result,
+        }
+        with open(args.save_json, "w") as f:
+            json.dump(run, f, indent=2, default=float)
+        print(f"\n>>> Saved test result to {args.save_json}")
+
+
+if __name__ == "__main__":
+    main()

models/LipFD.py

@@ -0,0 +1,42 @@
+import torch
+import numpy as np
+import torch.nn as nn
+from .clip import clip
+from .region_awareness import get_backbone
+
+
+class LipFD(nn.Module):
+    def __init__(self, name, num_classes=1):
+        super(LipFD, self).__init__()
+
+        self.conv1 = nn.Conv2d(
+            3, 3, kernel_size=5, stride=5
+        )  # (1120, 1120) -> (224, 224)
+        self.encoder, self.preprocess = clip.load(name, device="cpu")
+        self.backbone = get_backbone()
+
+    def forward(self, x, feature):
+        return self.backbone(x, feature)
+
+    def get_features(self, x):
+        x = self.conv1(x)
+        features = self.encoder.encode_image(x)
+        return features
+
+
+class RALoss(nn.Module):
+    def __init__(self):
+        super(RALoss, self).__init__()
+
+    def forward(self, alphas_max, alphas_org):
+        loss = 0.0
+        batch_size = alphas_org[0].shape[0]
+        for i in range(len(alphas_org)):
+            loss_wt = 0.0
+            for j in range(batch_size):
+                loss_wt += torch.Tensor([10]).to(alphas_max[i][j].device) / torch.exp(
+                    alphas_max[i][j] - alphas_org[i][j]
+                )
+            loss += loss_wt / batch_size
+        return loss
+ 

models/__init__.py

@@ -0,0 +1,28 @@
+from .clip_models import CLIPModel
+from .LipFD import LipFD, RALoss
+
+VALID_NAMES = [
+    "CLIP:ViT-B/32",
+    "CLIP:ViT-B/16",
+    "CLIP:ViT-L/14",
+]
+
+
+def get_model(name):
+    assert name in VALID_NAMES
+    if name.startswith("CLIP:"):
+        return CLIPModel(name[5:])
+    else:
+        assert False
+
+
+def build_model(transformer_name):
+    assert transformer_name in VALID_NAMES
+    if transformer_name.startswith("CLIP:"):
+        return LipFD(transformer_name[5:])
+    else:
+        assert False
+
+
+def get_loss():
+    return RALoss()

models/clip_models.py

@@ -0,0 +1,24 @@
+from .clip import clip 
+from PIL import Image
+import torch.nn as nn
+
+
+CHANNELS = {
+    "RN50" : 1024,
+    "ViT-L/14" : 768
+}
+
+class CLIPModel(nn.Module):
+    def __init__(self, name, num_classes=1):
+        super(CLIPModel, self).__init__()
+
+        self.model, self.preprocess = clip.load(name, device="cpu") # self.preprecess will not be used during training, which is handled in Dataset class 
+        self.fc = nn.Linear( CHANNELS[name], num_classes )
+ 
+
+    def forward(self, x, return_feature=False):
+        features = self.model.encode_image(x) 
+        if return_feature:
+            return features
+        return self.fc(features)
+

models/region_awareness.py

@@ -0,0 +1,303 @@
+import torch
+from torch import Tensor
+import torch.nn as nn
+from typing import Type, Any, Callable, Union, List, Optional
+from torch.nn.functional import softmax
+
+try:
+    from torch.hub import load_state_dict_from_url
+except ImportError:
+    from torch.utils.model_zoo import load_url as load_state_dict_from_url
+
+model_urls = {
+    'resnet18': 'https://download.pytorch.org/models/resnet18-f37072fd.pth',
+    'resnet34': 'https://download.pytorch.org/models/resnet34-b627a593.pth',
+    'resnet50': 'https://download.pytorch.org/models/resnet50-0676ba61.pth',
+    'resnet101': 'https://download.pytorch.org/models/resnet101-63fe2227.pth',
+    'resnet152': 'https://download.pytorch.org/models/resnet152-394f9c45.pth',
+    'resnext50_32x4d': 'https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth',
+    'resnext101_32x8d': 'https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth',
+    'wideget_backbone50_2': 'https://download.pytorch.org/models/wideget_backbone50_2-95faca4d.pth',
+    'wideget_backbone101_2': 'https://download.pytorch.org/models/wideget_backbone101_2-32ee1156.pth',
+}
+
+
+def conv3x3(in_planes: int, out_planes: int, stride: int = 1, groups: int = 1, dilation: int = 1) -> nn.Conv2d:
+    """3x3 convolution with padding"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
+                     padding=dilation, groups=groups, bias=False, dilation=dilation)
+
+
+def conv1x1(in_planes: int, out_planes: int, stride: int = 1) -> nn.Conv2d:
+    """1x1 convolution"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
+
+
+class BasicBlock(nn.Module):
+    expansion: int = 1
+
+    def __init__(
+            self,
+            inplanes: int,
+            planes: int,
+            stride: int = 1,
+            downsample: Optional[nn.Module] = None,
+            groups: int = 1,
+            base_width: int = 64,
+            dilation: int = 1,
+            norm_layer: Optional[Callable[..., nn.Module]] = None
+    ) -> None:
+        super(BasicBlock, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        if groups != 1 or base_width != 64:
+            raise ValueError('BasicBlock only supports groups=1 and base_width=64')
+        if dilation > 1:
+            raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
+        # Both self.conv1 and self.downsample layers downsample the input when stride != 1
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = norm_layer(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = norm_layer(planes)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x: Tensor) -> Tensor:
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion: int = 4
+
+    def __init__(
+            self,
+            inplanes: int,
+            planes: int,
+            stride: int = 1,
+            downsample: Optional[nn.Module] = None,
+            groups: int = 1,
+            base_width: int = 64,
+            dilation: int = 1,
+            norm_layer: Optional[Callable[..., nn.Module]] = None
+    ) -> None:
+        super(Bottleneck, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        width = int(planes * (base_width / 64.)) * groups
+        # Both self.conv2 and self.downsample layers downsample the input when stride != 1
+        self.conv1 = conv1x1(inplanes, width)
+        self.bn1 = norm_layer(width)
+        self.conv2 = conv3x3(width, width, stride, groups, dilation)
+        self.bn2 = norm_layer(width)
+        self.conv3 = conv1x1(width, planes * self.expansion)
+        self.bn3 = norm_layer(planes * self.expansion)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x: Tensor) -> Tensor:
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu(out)
+
+        return out
+
+
+class ResNet(nn.Module):
+
+    def __init__(
+            self,
+            block: Type[Union[BasicBlock, Bottleneck]],
+            layers: List[int],
+            num_classes: int = 1000,
+            zero_init_residual: bool = False,
+            groups: int = 1,
+            width_per_group: int = 64,
+            replace_stride_with_dilation: Optional[List[bool]] = None,
+            norm_layer: Optional[Callable[..., nn.Module]] = None
+    ) -> None:
+        super(ResNet, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        self._norm_layer = norm_layer
+
+        self.inplanes = 64
+        self.dilation = 1
+        if replace_stride_with_dilation is None:
+            # each element in the tuple indicates if we should replace
+            # the 2x2 stride with a dilated convolution instead
+            replace_stride_with_dilation = [False, False, False]
+        if len(replace_stride_with_dilation) != 3:
+            raise ValueError("replace_stride_with_dilation should be None "
+                             "or a 3-element tuple, got {}".format(replace_stride_with_dilation))
+        self.groups = groups
+        self.base_width = width_per_group
+        self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3,
+                               bias=False)
+        self.bn1 = norm_layer(self.inplanes)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2,
+                                       dilate=replace_stride_with_dilation[0])
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=2,
+                                       dilate=replace_stride_with_dilation[1])
+        self.layer4 = self._make_layer(block, 512, layers[3], stride=2,
+                                       dilate=replace_stride_with_dilation[2])
+        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+        self.get_weight = nn.Sequential(
+            nn.Linear(512 * block.expansion + 768, 1),  # TODO: 768 is the length of global feature
+            nn.Sigmoid()
+        )
+        self.fc = nn.Linear(512 * block.expansion + 768, 1)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+        # Zero-initialize the last BN in each residual branch,
+        # so that the residual branch starts with zeros, and each residual block behaves like an identity.
+        # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
+        if zero_init_residual:
+            for m in self.modules():
+                if isinstance(m, Bottleneck):
+                    nn.init.constant_(m.bn3.weight, 0)  # type: ignore[arg-type]
+                elif isinstance(m, BasicBlock):
+                    nn.init.constant_(m.bn2.weight, 0)  # type: ignore[arg-type]
+
+    def _make_layer(self, block: Type[Union[BasicBlock, Bottleneck]], planes: int, blocks: int,
+                    stride: int = 1, dilate: bool = False) -> nn.Sequential:
+        norm_layer = self._norm_layer
+        downsample = None
+        previous_dilation = self.dilation
+        if dilate:
+            self.dilation *= stride
+            stride = 1
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                conv1x1(self.inplanes, planes * block.expansion, stride),
+                norm_layer(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample, self.groups,
+                            self.base_width, previous_dilation, norm_layer))
+        self.inplanes = planes * block.expansion
+        for _ in range(1, blocks):
+            layers.append(block(self.inplanes, planes, groups=self.groups,
+                                base_width=self.base_width, dilation=self.dilation,
+                                norm_layer=norm_layer))
+
+        return nn.Sequential(*layers)
+
+    def _forward_impl(self, x, feature):
+        # The comment resolution is based on input size is 224*224 imagenet
+        # f.shape: (batch_size, 3, 224, 224), feature.shape: (batch_size, 768)
+        features, weights, parts, weights_org, weights_max = [list() for i in range(5)]
+        for i in range(len(x[0])):
+            features.clear()
+            weights.clear()
+            for j in range(len(x)):
+                f = x[j][i]
+                f = self.conv1(f)
+                f = self.bn1(f)
+                f = self.relu(f)
+                f = self.maxpool(f)
+                f = self.layer1(f)
+                f = self.layer2(f)
+                f = self.layer3(f)
+                f = self.layer4(f)
+                f = self.avgpool(f)
+                f = torch.flatten(f, 1)
+
+                # features.append(f)
+                features.append(torch.cat([f, feature], dim=1))  # concat regional feature with global feature
+                weights.append(self.get_weight(features[-1]))
+
+            features_stack = torch.stack(features, dim=2)
+            weights_stack = torch.stack(weights, dim=2)
+            weights_stack = softmax(weights_stack, dim=2)
+
+            weights_max.append(weights_stack[:, :, :len(x)].max(dim=2)[0])
+            weights_org.append(weights_stack[:, :, 0])
+            parts.append(features_stack.mul(weights_stack).sum(2).div(weights_stack.sum(2)))
+        parts_stack = torch.stack(parts, dim=0)
+        out = parts_stack.sum(0).div(parts_stack.shape[0])
+
+        pred_score = self.fc(out)
+
+        return pred_score, weights_max, weights_org
+
+    def forward(self, x, feature):
+        return self._forward_impl(x, feature)
+
+
+def _get_backbone(
+        arch: str,
+        block: Type[Union[BasicBlock, Bottleneck]],
+        layers: List[int],
+        pretrained: bool,
+        progress: bool,
+        **kwargs: Any
+) -> ResNet:
+    model = ResNet(block, layers, num_classes=1, **kwargs)
+    if pretrained:
+        state_dict = load_state_dict_from_url(model_urls[arch], progress=progress)
+        model.load_state_dict(state_dict)
+    return model
+
+
+def get_backbone(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> ResNet:
+    r"""ResNet-50 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _get_backbone('resnet50', Bottleneck, [3, 4, 6, 3], pretrained, progress, **kwargs)
+
+
+if __name__ == '__main__':
+    model = get_backbone()
+    data = [[] for i in range(3)]
+    for i in range(3):
+        for j in range(5):
+            data[i].append(torch.rand((10, 3, 224, 224)))
+    feature = torch.rand((10, 768))
+    pred_score, weights_max, weights_org = model(data, feature)
+    pass

models/resnet.py

@@ -0,0 +1,336 @@
+import torch
+from torch import Tensor
+import torch.nn as nn
+from typing import Type, Any, Callable, Union, List, Optional
+
+try:
+    from torch.hub import load_state_dict_from_url
+except ImportError:
+    from torch.utils.model_zoo import load_url as load_state_dict_from_url
+
+
+model_urls = {
+    'resnet18': 'https://download.pytorch.org/models/resnet18-f37072fd.pth',
+    'resnet34': 'https://download.pytorch.org/models/resnet34-b627a593.pth',
+    'resnet50': 'https://download.pytorch.org/models/resnet50-0676ba61.pth',
+    'resnet101': 'https://download.pytorch.org/models/resnet101-63fe2227.pth',
+    'resnet152': 'https://download.pytorch.org/models/resnet152-394f9c45.pth',
+    'resnext50_32x4d': 'https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth',
+    'resnext101_32x8d': 'https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth',
+    'wide_resnet50_2': 'https://download.pytorch.org/models/wide_resnet50_2-95faca4d.pth',
+    'wide_resnet101_2': 'https://download.pytorch.org/models/wide_resnet101_2-32ee1156.pth',
+}
+
+
+
+
+def conv3x3(in_planes: int, out_planes: int, stride: int = 1, groups: int = 1, dilation: int = 1) -> nn.Conv2d:
+    """3x3 convolution with padding"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
+                     padding=dilation, groups=groups, bias=False, dilation=dilation)
+
+
+def conv1x1(in_planes: int, out_planes: int, stride: int = 1) -> nn.Conv2d:
+    """1x1 convolution"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
+
+
+class BasicBlock(nn.Module):
+    expansion: int = 1
+
+    def __init__(
+        self,
+        inplanes: int,
+        planes: int,
+        stride: int = 1,
+        downsample: Optional[nn.Module] = None,
+        groups: int = 1,
+        base_width: int = 64,
+        dilation: int = 1,
+        norm_layer: Optional[Callable[..., nn.Module]] = None
+    ) -> None:
+        super(BasicBlock, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        if groups != 1 or base_width != 64:
+            raise ValueError('BasicBlock only supports groups=1 and base_width=64')
+        if dilation > 1:
+            raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
+        # Both self.conv1 and self.downsample layers downsample the input when stride != 1
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = norm_layer(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = norm_layer(planes)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x: Tensor) -> Tensor:
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(nn.Module):
+    # Bottleneck in torchvision places the stride for downsampling at 3x3 convolution(self.conv2)
+    # while original implementation places the stride at the first 1x1 convolution(self.conv1)
+    # according to "Deep residual learning for image recognition"https://arxiv.org/abs/1512.03385.
+    # This variant is also known as ResNet V1.5 and improves accuracy according to
+    # https://ngc.nvidia.com/catalog/model-scripts/nvidia:resnet_50_v1_5_for_pytorch.
+
+    expansion: int = 4
+
+    def __init__(
+        self,
+        inplanes: int,
+        planes: int,
+        stride: int = 1,
+        downsample: Optional[nn.Module] = None,
+        groups: int = 1,
+        base_width: int = 64,
+        dilation: int = 1,
+        norm_layer: Optional[Callable[..., nn.Module]] = None
+    ) -> None:
+        super(Bottleneck, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        width = int(planes * (base_width / 64.)) * groups
+        # Both self.conv2 and self.downsample layers downsample the input when stride != 1
+        self.conv1 = conv1x1(inplanes, width)
+        self.bn1 = norm_layer(width)
+        self.conv2 = conv3x3(width, width, stride, groups, dilation)
+        self.bn2 = norm_layer(width)
+        self.conv3 = conv1x1(width, planes * self.expansion)
+        self.bn3 = norm_layer(planes * self.expansion)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x: Tensor) -> Tensor:
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu(out)
+
+        return out
+
+
+class ResNet(nn.Module):
+
+    def __init__(
+        self,
+        block: Type[Union[BasicBlock, Bottleneck]],
+        layers: List[int],
+        num_classes: int = 1000,
+        zero_init_residual: bool = False,
+        groups: int = 1,
+        width_per_group: int = 64,
+        replace_stride_with_dilation: Optional[List[bool]] = None,
+        norm_layer: Optional[Callable[..., nn.Module]] = None
+    ) -> None:
+        super(ResNet, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        self._norm_layer = norm_layer
+
+        self.inplanes = 64
+        self.dilation = 1
+        if replace_stride_with_dilation is None:
+            # each element in the tuple indicates if we should replace
+            # the 2x2 stride with a dilated convolution instead
+            replace_stride_with_dilation = [False, False, False]
+        if len(replace_stride_with_dilation) != 3:
+            raise ValueError("replace_stride_with_dilation should be None "
+                             "or a 3-element tuple, got {}".format(replace_stride_with_dilation))
+        self.groups = groups
+        self.base_width = width_per_group
+        self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3,
+                               bias=False)
+        self.bn1 = norm_layer(self.inplanes)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2,
+                                       dilate=replace_stride_with_dilation[0])
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=2,
+                                       dilate=replace_stride_with_dilation[1])
+        self.layer4 = self._make_layer(block, 512, layers[3], stride=2,
+                                       dilate=replace_stride_with_dilation[2])
+        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+        self.fc = nn.Linear(512 * block.expansion, num_classes)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+        # Zero-initialize the last BN in each residual branch,
+        # so that the residual branch starts with zeros, and each residual block behaves like an identity.
+        # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
+        if zero_init_residual:
+            for m in self.modules():
+                if isinstance(m, Bottleneck):
+                    nn.init.constant_(m.bn3.weight, 0)  # type: ignore[arg-type]
+                elif isinstance(m, BasicBlock):
+                    nn.init.constant_(m.bn2.weight, 0)  # type: ignore[arg-type]
+
+    def _make_layer(self, block: Type[Union[BasicBlock, Bottleneck]], planes: int, blocks: int,
+                    stride: int = 1, dilate: bool = False) -> nn.Sequential:
+        norm_layer = self._norm_layer
+        downsample = None
+        previous_dilation = self.dilation
+        if dilate:
+            self.dilation *= stride
+            stride = 1
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                conv1x1(self.inplanes, planes * block.expansion, stride),
+                norm_layer(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample, self.groups,
+                            self.base_width, previous_dilation, norm_layer))
+        self.inplanes = planes * block.expansion
+        for _ in range(1, blocks):
+            layers.append(block(self.inplanes, planes, groups=self.groups,
+                                base_width=self.base_width, dilation=self.dilation,
+                                norm_layer=norm_layer))
+
+        return nn.Sequential(*layers)
+
+    def _forward_impl(self, x):
+        # The comment resolution is based on input size is 224*224 imagenet
+        out = {}
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+        out['f0'] = x # N*64*56*56 
+
+        x = self.layer1(x)
+        out['f1'] = x # N*64*56*56
+
+        x = self.layer2(x)
+        out['f2'] = x # N*128*28*28
+
+        x = self.layer3(x)
+        out['f3'] = x # N*256*14*14
+        
+        x = self.layer4(x)
+        out['f4'] = x # N*512*7*7
+
+        x = self.avgpool(x)
+        x = torch.flatten(x, 1)
+        out['penultimate'] = x # N*512
+
+        x = self.fc(x)
+        out['logits'] = x # N*1000
+
+        # return all features 
+        return out
+
+        # return final classification result 
+        # return x
+
+    def forward(self, x):
+        return self._forward_impl(x)
+
+
+def _resnet(
+    arch: str,
+    block: Type[Union[BasicBlock, Bottleneck]],
+    layers: List[int],
+    pretrained: bool,
+    progress: bool,
+    **kwargs: Any
+) -> ResNet:
+    model = ResNet(block, layers, **kwargs)
+    if pretrained:
+        state_dict = load_state_dict_from_url(model_urls[arch], progress=progress)
+        model.load_state_dict(state_dict)
+    return model
+
+
+def resnet18(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> ResNet:
+    r"""ResNet-18 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet18', BasicBlock, [2, 2, 2, 2], pretrained, progress, **kwargs)
+
+
+def resnet34(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> ResNet:
+    r"""ResNet-34 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet34', BasicBlock, [3, 4, 6, 3], pretrained, progress, **kwargs)
+
+
+def resnet50(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> ResNet:
+    r"""ResNet-50 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet50', Bottleneck, [3, 4, 6, 3], pretrained, progress, **kwargs)
+
+
+def resnet101(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> ResNet:
+    r"""ResNet-101 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet101', Bottleneck, [3, 4, 23, 3], pretrained, progress, **kwargs)
+
+
+def resnet152(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> ResNet:
+    r"""ResNet-152 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet152', Bottleneck, [3, 8, 36, 3], pretrained, progress, **kwargs)

models/vision_transformer.py

@@ -0,0 +1,481 @@
+import math
+from collections import OrderedDict
+from functools import partial
+from typing import Any, Callable, List, NamedTuple, Optional
+
+import torch
+import torch.nn as nn
+
+# from .._internally_replaced_utils import load_state_dict_from_url
+from .vision_transformer_misc import ConvNormActivation
+from .vision_transformer_utils import _log_api_usage_once
+
+try:
+    from torch.hub import load_state_dict_from_url
+except ImportError:
+    from torch.utils.model_zoo import load_url as load_state_dict_from_url
+
+# __all__ = [
+#     "VisionTransformer",
+#     "vit_b_16",
+#     "vit_b_32",
+#     "vit_l_16",
+#     "vit_l_32",
+# ]
+
+model_urls = {
+    "vit_b_16": "https://download.pytorch.org/models/vit_b_16-c867db91.pth",
+    "vit_b_32": "https://download.pytorch.org/models/vit_b_32-d86f8d99.pth",
+    "vit_l_16": "https://download.pytorch.org/models/vit_l_16-852ce7e3.pth",
+    "vit_l_32": "https://download.pytorch.org/models/vit_l_32-c7638314.pth",
+}
+
+
+class ConvStemConfig(NamedTuple):
+    out_channels: int
+    kernel_size: int
+    stride: int
+    norm_layer: Callable[..., nn.Module] = nn.BatchNorm2d
+    activation_layer: Callable[..., nn.Module] = nn.ReLU
+
+
+class MLPBlock(nn.Sequential):
+    """Transformer MLP block."""
+
+    def __init__(self, in_dim: int, mlp_dim: int, dropout: float):
+        super().__init__()
+        self.linear_1 = nn.Linear(in_dim, mlp_dim)
+        self.act = nn.GELU()
+        self.dropout_1 = nn.Dropout(dropout)
+        self.linear_2 = nn.Linear(mlp_dim, in_dim)
+        self.dropout_2 = nn.Dropout(dropout)
+
+        nn.init.xavier_uniform_(self.linear_1.weight)
+        nn.init.xavier_uniform_(self.linear_2.weight)
+        nn.init.normal_(self.linear_1.bias, std=1e-6)
+        nn.init.normal_(self.linear_2.bias, std=1e-6)
+
+
+class EncoderBlock(nn.Module):
+    """Transformer encoder block."""
+
+    def __init__(
+        self,
+        num_heads: int,
+        hidden_dim: int,
+        mlp_dim: int,
+        dropout: float,
+        attention_dropout: float,
+        norm_layer: Callable[..., torch.nn.Module] = partial(nn.LayerNorm, eps=1e-6),
+    ):
+        super().__init__()
+        self.num_heads = num_heads
+
+        # Attention block
+        self.ln_1 = norm_layer(hidden_dim)
+        self.self_attention = nn.MultiheadAttention(hidden_dim, num_heads, dropout=attention_dropout, batch_first=True)
+        self.dropout = nn.Dropout(dropout)
+
+        # MLP block
+        self.ln_2 = norm_layer(hidden_dim)
+        self.mlp = MLPBlock(hidden_dim, mlp_dim, dropout)
+
+    def forward(self, input: torch.Tensor):
+        torch._assert(input.dim() == 3, f"Expected (seq_length, batch_size, hidden_dim) got {input.shape}")
+        x = self.ln_1(input)
+        x, _ = self.self_attention(query=x, key=x, value=x, need_weights=False)
+        x = self.dropout(x)
+        x = x + input
+
+        y = self.ln_2(x)
+        y = self.mlp(y)
+        return x + y
+
+
+class Encoder(nn.Module):
+    """Transformer Model Encoder for sequence to sequence translation."""
+
+    def __init__(
+        self,
+        seq_length: int,
+        num_layers: int,
+        num_heads: int,
+        hidden_dim: int,
+        mlp_dim: int,
+        dropout: float,
+        attention_dropout: float,
+        norm_layer: Callable[..., torch.nn.Module] = partial(nn.LayerNorm, eps=1e-6),
+    ):
+        super().__init__()
+        # Note that batch_size is on the first dim because
+        # we have batch_first=True in nn.MultiAttention() by default
+        self.pos_embedding = nn.Parameter(torch.empty(1, seq_length, hidden_dim).normal_(std=0.02))  # from BERT
+        self.dropout = nn.Dropout(dropout)
+        layers: OrderedDict[str, nn.Module] = OrderedDict()
+        for i in range(num_layers):
+            layers[f"encoder_layer_{i}"] = EncoderBlock(
+                num_heads,
+                hidden_dim,
+                mlp_dim,
+                dropout,
+                attention_dropout,
+                norm_layer,
+            )
+        self.layers = nn.Sequential(layers)
+        self.ln = norm_layer(hidden_dim)
+
+    def forward(self, input: torch.Tensor):
+        torch._assert(input.dim() == 3, f"Expected (batch_size, seq_length, hidden_dim) got {input.shape}")
+        input = input + self.pos_embedding
+        return self.ln(self.layers(self.dropout(input)))
+
+
+class VisionTransformer(nn.Module):
+    """Vision Transformer as per https://arxiv.org/abs/2010.11929."""
+
+    def __init__(
+        self,
+        image_size: int,
+        patch_size: int,
+        num_layers: int,
+        num_heads: int,
+        hidden_dim: int,
+        mlp_dim: int,
+        dropout: float = 0.0,
+        attention_dropout: float = 0.0,
+        num_classes: int = 1000,
+        representation_size: Optional[int] = None,
+        norm_layer: Callable[..., torch.nn.Module] = partial(nn.LayerNorm, eps=1e-6),
+        conv_stem_configs: Optional[List[ConvStemConfig]] = None,
+    ):
+        super().__init__()
+        _log_api_usage_once(self)
+        torch._assert(image_size % patch_size == 0, "Input shape indivisible by patch size!")
+        self.image_size = image_size
+        self.patch_size = patch_size
+        self.hidden_dim = hidden_dim
+        self.mlp_dim = mlp_dim
+        self.attention_dropout = attention_dropout
+        self.dropout = dropout
+        self.num_classes = num_classes
+        self.representation_size = representation_size
+        self.norm_layer = norm_layer
+
+        if conv_stem_configs is not None:
+            # As per https://arxiv.org/abs/2106.14881
+            seq_proj = nn.Sequential()
+            prev_channels = 3
+            for i, conv_stem_layer_config in enumerate(conv_stem_configs):
+                seq_proj.add_module(
+                    f"conv_bn_relu_{i}",
+                    ConvNormActivation(
+                        in_channels=prev_channels,
+                        out_channels=conv_stem_layer_config.out_channels,
+                        kernel_size=conv_stem_layer_config.kernel_size,
+                        stride=conv_stem_layer_config.stride,
+                        norm_layer=conv_stem_layer_config.norm_layer,
+                        activation_layer=conv_stem_layer_config.activation_layer,
+                    ),
+                )
+                prev_channels = conv_stem_layer_config.out_channels
+            seq_proj.add_module(
+                "conv_last", nn.Conv2d(in_channels=prev_channels, out_channels=hidden_dim, kernel_size=1)
+            )
+            self.conv_proj: nn.Module = seq_proj
+        else:
+            self.conv_proj = nn.Conv2d(
+                in_channels=3, out_channels=hidden_dim, kernel_size=patch_size, stride=patch_size
+            )
+
+        seq_length = (image_size // patch_size) ** 2
+
+        # Add a class token
+        self.class_token = nn.Parameter(torch.zeros(1, 1, hidden_dim))
+        seq_length += 1
+
+        self.encoder = Encoder(
+            seq_length,
+            num_layers,
+            num_heads,
+            hidden_dim,
+            mlp_dim,
+            dropout,
+            attention_dropout,
+            norm_layer,
+        )
+        self.seq_length = seq_length
+
+        heads_layers: OrderedDict[str, nn.Module] = OrderedDict()
+        if representation_size is None:
+            heads_layers["head"] = nn.Linear(hidden_dim, num_classes)
+        else:
+            heads_layers["pre_logits"] = nn.Linear(hidden_dim, representation_size)
+            heads_layers["act"] = nn.Tanh()
+            heads_layers["head"] = nn.Linear(representation_size, num_classes)
+
+        self.heads = nn.Sequential(heads_layers)
+
+        if isinstance(self.conv_proj, nn.Conv2d):
+            # Init the patchify stem
+            fan_in = self.conv_proj.in_channels * self.conv_proj.kernel_size[0] * self.conv_proj.kernel_size[1]
+            nn.init.trunc_normal_(self.conv_proj.weight, std=math.sqrt(1 / fan_in))
+            if self.conv_proj.bias is not None:
+                nn.init.zeros_(self.conv_proj.bias)
+        elif self.conv_proj.conv_last is not None and isinstance(self.conv_proj.conv_last, nn.Conv2d):
+            # Init the last 1x1 conv of the conv stem
+            nn.init.normal_(
+                self.conv_proj.conv_last.weight, mean=0.0, std=math.sqrt(2.0 / self.conv_proj.conv_last.out_channels)
+            )
+            if self.conv_proj.conv_last.bias is not None:
+                nn.init.zeros_(self.conv_proj.conv_last.bias)
+
+        if hasattr(self.heads, "pre_logits") and isinstance(self.heads.pre_logits, nn.Linear):
+            fan_in = self.heads.pre_logits.in_features
+            nn.init.trunc_normal_(self.heads.pre_logits.weight, std=math.sqrt(1 / fan_in))
+            nn.init.zeros_(self.heads.pre_logits.bias)
+
+        if isinstance(self.heads.head, nn.Linear):
+            nn.init.zeros_(self.heads.head.weight)
+            nn.init.zeros_(self.heads.head.bias)
+
+    def _process_input(self, x: torch.Tensor) -> torch.Tensor:
+        n, c, h, w = x.shape
+        p = self.patch_size
+        torch._assert(h == self.image_size, "Wrong image height!")
+        torch._assert(w == self.image_size, "Wrong image width!")
+        n_h = h // p
+        n_w = w // p
+
+        # (n, c, h, w) -> (n, hidden_dim, n_h, n_w)
+        x = self.conv_proj(x)
+        # (n, hidden_dim, n_h, n_w) -> (n, hidden_dim, (n_h * n_w))
+        x = x.reshape(n, self.hidden_dim, n_h * n_w)
+
+        # (n, hidden_dim, (n_h * n_w)) -> (n, (n_h * n_w), hidden_dim)
+        # The self attention layer expects inputs in the format (N, S, E)
+        # where S is the source sequence length, N is the batch size, E is the
+        # embedding dimension
+        x = x.permute(0, 2, 1)
+
+        return x
+
+    def forward(self, x: torch.Tensor):
+        out = {}
+
+        # Reshape and permute the input tensor
+        x = self._process_input(x)
+        n = x.shape[0]
+
+        # Expand the class token to the full batch
+        batch_class_token = self.class_token.expand(n, -1, -1)
+        x = torch.cat([batch_class_token, x], dim=1)
+
+        
+        x = self.encoder(x)
+        img_feature = x[:,1:]
+        H = W = int(self.image_size / self.patch_size)
+        out['f4'] = img_feature.view(n, H, W, self.hidden_dim).permute(0,3,1,2)
+
+        # Classifier "token" as used by standard language architectures
+        x = x[:, 0]
+        out['penultimate'] = x 
+
+        x = self.heads(x) # I checked that for all pretrained ViT, this is just a fc 
+        out['logits'] = x 
+
+        return out
+
+
+def _vision_transformer(
+    arch: str,
+    patch_size: int,
+    num_layers: int,
+    num_heads: int,
+    hidden_dim: int,
+    mlp_dim: int,
+    pretrained: bool,
+    progress: bool,
+    **kwargs: Any,
+) -> VisionTransformer:
+    image_size = kwargs.pop("image_size", 224)
+
+    model = VisionTransformer(
+        image_size=image_size,
+        patch_size=patch_size,
+        num_layers=num_layers,
+        num_heads=num_heads,
+        hidden_dim=hidden_dim,
+        mlp_dim=mlp_dim,
+        **kwargs,
+    )
+
+    if pretrained:
+        if arch not in model_urls:
+            raise ValueError(f"No checkpoint is available for model type '{arch}'!")
+        state_dict = load_state_dict_from_url(model_urls[arch], progress=progress)
+        model.load_state_dict(state_dict)
+
+    return model
+
+
+def vit_b_16(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> VisionTransformer:
+    """
+    Constructs a vit_b_16 architecture from
+    `"An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale" <https://arxiv.org/abs/2010.11929>`_.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _vision_transformer(
+        arch="vit_b_16",
+        patch_size=16,
+        num_layers=12,
+        num_heads=12,
+        hidden_dim=768,
+        mlp_dim=3072,
+        pretrained=pretrained,
+        progress=progress,
+        **kwargs,
+    )
+
+
+def vit_b_32(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> VisionTransformer:
+    """
+    Constructs a vit_b_32 architecture from
+    `"An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale" <https://arxiv.org/abs/2010.11929>`_.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _vision_transformer(
+        arch="vit_b_32",
+        patch_size=32,
+        num_layers=12,
+        num_heads=12,
+        hidden_dim=768,
+        mlp_dim=3072,
+        pretrained=pretrained,
+        progress=progress,
+        **kwargs,
+    )
+
+
+def vit_l_16(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> VisionTransformer:
+    """
+    Constructs a vit_l_16 architecture from
+    `"An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale" <https://arxiv.org/abs/2010.11929>`_.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _vision_transformer(
+        arch="vit_l_16",
+        patch_size=16,
+        num_layers=24,
+        num_heads=16,
+        hidden_dim=1024,
+        mlp_dim=4096,
+        pretrained=pretrained,
+        progress=progress,
+        **kwargs,
+    )
+
+
+def vit_l_32(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> VisionTransformer:
+    """
+    Constructs a vit_l_32 architecture from
+    `"An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale" <https://arxiv.org/abs/2010.11929>`_.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _vision_transformer(
+        arch="vit_l_32",
+        patch_size=32,
+        num_layers=24,
+        num_heads=16,
+        hidden_dim=1024,
+        mlp_dim=4096,
+        pretrained=pretrained,
+        progress=progress,
+        **kwargs,
+    )
+
+
+def interpolate_embeddings(
+    image_size: int,
+    patch_size: int,
+    model_state: "OrderedDict[str, torch.Tensor]",
+    interpolation_mode: str = "bicubic",
+    reset_heads: bool = False,
+) -> "OrderedDict[str, torch.Tensor]":
+    """This function helps interpolating positional embeddings during checkpoint loading,
+    especially when you want to apply a pre-trained model on images with different resolution.
+
+    Args:
+        image_size (int): Image size of the new model.
+        patch_size (int): Patch size of the new model.
+        model_state (OrderedDict[str, torch.Tensor]): State dict of the pre-trained model.
+        interpolation_mode (str): The algorithm used for upsampling. Default: bicubic.
+        reset_heads (bool): If true, not copying the state of heads. Default: False.
+
+    Returns:
+        OrderedDict[str, torch.Tensor]: A state dict which can be loaded into the new model.
+    """
+    # Shape of pos_embedding is (1, seq_length, hidden_dim)
+    pos_embedding = model_state["encoder.pos_embedding"]
+    n, seq_length, hidden_dim = pos_embedding.shape
+    if n != 1:
+        raise ValueError(f"Unexpected position embedding shape: {pos_embedding.shape}")
+
+    new_seq_length = (image_size // patch_size) ** 2 + 1
+
+    # Need to interpolate the weights for the position embedding.
+    # We do this by reshaping the positions embeddings to a 2d grid, performing
+    # an interpolation in the (h, w) space and then reshaping back to a 1d grid.
+    if new_seq_length != seq_length:
+        # The class token embedding shouldn't be interpolated so we split it up.
+        seq_length -= 1
+        new_seq_length -= 1
+        pos_embedding_token = pos_embedding[:, :1, :]
+        pos_embedding_img = pos_embedding[:, 1:, :]
+
+        # (1, seq_length, hidden_dim) -> (1, hidden_dim, seq_length)
+        pos_embedding_img = pos_embedding_img.permute(0, 2, 1)
+        seq_length_1d = int(math.sqrt(seq_length))
+        torch._assert(seq_length_1d * seq_length_1d == seq_length, "seq_length is not a perfect square!")
+
+        # (1, hidden_dim, seq_length) -> (1, hidden_dim, seq_l_1d, seq_l_1d)
+        pos_embedding_img = pos_embedding_img.reshape(1, hidden_dim, seq_length_1d, seq_length_1d)
+        new_seq_length_1d = image_size // patch_size
+
+        # Perform interpolation.
+        # (1, hidden_dim, seq_l_1d, seq_l_1d) -> (1, hidden_dim, new_seq_l_1d, new_seq_l_1d)
+        new_pos_embedding_img = nn.functional.interpolate(
+            pos_embedding_img,
+            size=new_seq_length_1d,
+            mode=interpolation_mode,
+            align_corners=True,
+        )
+
+        # (1, hidden_dim, new_seq_l_1d, new_seq_l_1d) -> (1, hidden_dim, new_seq_length)
+        new_pos_embedding_img = new_pos_embedding_img.reshape(1, hidden_dim, new_seq_length)
+
+        # (1, hidden_dim, new_seq_length) -> (1, new_seq_length, hidden_dim)
+        new_pos_embedding_img = new_pos_embedding_img.permute(0, 2, 1)
+        new_pos_embedding = torch.cat([pos_embedding_token, new_pos_embedding_img], dim=1)
+
+        model_state["encoder.pos_embedding"] = new_pos_embedding
+
+        if reset_heads:
+            model_state_copy: "OrderedDict[str, torch.Tensor]" = OrderedDict()
+            for k, v in model_state.items():
+                if not k.startswith("heads"):
+                    model_state_copy[k] = v
+            model_state = model_state_copy
+
+    return model_state

models/vision_transformer_misc.py

@@ -0,0 +1,163 @@
+from typing import Callable, List, Optional
+
+import torch
+from torch import Tensor
+
+from .vision_transformer_utils import _log_api_usage_once
+
+
+interpolate = torch.nn.functional.interpolate
+
+
+# This is not in nn
+class FrozenBatchNorm2d(torch.nn.Module):
+    """
+    BatchNorm2d where the batch statistics and the affine parameters are fixed
+
+    Args:
+        num_features (int): Number of features ``C`` from an expected input of size ``(N, C, H, W)``
+        eps (float): a value added to the denominator for numerical stability. Default: 1e-5
+    """
+
+    def __init__(
+        self,
+        num_features: int,
+        eps: float = 1e-5,
+    ):
+        super().__init__()
+        _log_api_usage_once(self)
+        self.eps = eps
+        self.register_buffer("weight", torch.ones(num_features))
+        self.register_buffer("bias", torch.zeros(num_features))
+        self.register_buffer("running_mean", torch.zeros(num_features))
+        self.register_buffer("running_var", torch.ones(num_features))
+
+    def _load_from_state_dict(
+        self,
+        state_dict: dict,
+        prefix: str,
+        local_metadata: dict,
+        strict: bool,
+        missing_keys: List[str],
+        unexpected_keys: List[str],
+        error_msgs: List[str],
+    ):
+        num_batches_tracked_key = prefix + "num_batches_tracked"
+        if num_batches_tracked_key in state_dict:
+            del state_dict[num_batches_tracked_key]
+
+        super()._load_from_state_dict(
+            state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs
+        )
+
+    def forward(self, x: Tensor) -> Tensor:
+        # move reshapes to the beginning
+        # to make it fuser-friendly
+        w = self.weight.reshape(1, -1, 1, 1)
+        b = self.bias.reshape(1, -1, 1, 1)
+        rv = self.running_var.reshape(1, -1, 1, 1)
+        rm = self.running_mean.reshape(1, -1, 1, 1)
+        scale = w * (rv + self.eps).rsqrt()
+        bias = b - rm * scale
+        return x * scale + bias
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.weight.shape[0]}, eps={self.eps})"
+
+
+class ConvNormActivation(torch.nn.Sequential):
+    """
+    Configurable block used for Convolution-Normalzation-Activation blocks.
+
+    Args:
+        in_channels (int): Number of channels in the input image
+        out_channels (int): Number of channels produced by the Convolution-Normalzation-Activation block
+        kernel_size: (int, optional): Size of the convolving kernel. Default: 3
+        stride (int, optional): Stride of the convolution. Default: 1
+        padding (int, tuple or str, optional): Padding added to all four sides of the input. Default: None, in wich case it will calculated as ``padding = (kernel_size - 1) // 2 * dilation``
+        groups (int, optional): Number of blocked connections from input channels to output channels. Default: 1
+        norm_layer (Callable[..., torch.nn.Module], optional): Norm layer that will be stacked on top of the convolutiuon layer. If ``None`` this layer wont be used. Default: ``torch.nn.BatchNorm2d``
+        activation_layer (Callable[..., torch.nn.Module], optinal): Activation function which will be stacked on top of the normalization layer (if not None), otherwise on top of the conv layer. If ``None`` this layer wont be used. Default: ``torch.nn.ReLU``
+        dilation (int): Spacing between kernel elements. Default: 1
+        inplace (bool): Parameter for the activation layer, which can optionally do the operation in-place. Default ``True``
+        bias (bool, optional): Whether to use bias in the convolution layer. By default, biases are included if ``norm_layer is None``.
+
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: int = 3,
+        stride: int = 1,
+        padding: Optional[int] = None,
+        groups: int = 1,
+        norm_layer: Optional[Callable[..., torch.nn.Module]] = torch.nn.BatchNorm2d,
+        activation_layer: Optional[Callable[..., torch.nn.Module]] = torch.nn.ReLU,
+        dilation: int = 1,
+        inplace: Optional[bool] = True,
+        bias: Optional[bool] = None,
+    ) -> None:
+        if padding is None:
+            padding = (kernel_size - 1) // 2 * dilation
+        if bias is None:
+            bias = norm_layer is None
+        layers = [
+            torch.nn.Conv2d(
+                in_channels,
+                out_channels,
+                kernel_size,
+                stride,
+                padding,
+                dilation=dilation,
+                groups=groups,
+                bias=bias,
+            )
+        ]
+        if norm_layer is not None:
+            layers.append(norm_layer(out_channels))
+        if activation_layer is not None:
+            params = {} if inplace is None else {"inplace": inplace}
+            layers.append(activation_layer(**params))
+        super().__init__(*layers)
+        _log_api_usage_once(self)
+        self.out_channels = out_channels
+
+
+class SqueezeExcitation(torch.nn.Module):
+    """
+    This block implements the Squeeze-and-Excitation block from https://arxiv.org/abs/1709.01507 (see Fig. 1).
+    Parameters ``activation``, and ``scale_activation`` correspond to ``delta`` and ``sigma`` in in eq. 3.
+
+    Args:
+        input_channels (int): Number of channels in the input image
+        squeeze_channels (int): Number of squeeze channels
+        activation (Callable[..., torch.nn.Module], optional): ``delta`` activation. Default: ``torch.nn.ReLU``
+        scale_activation (Callable[..., torch.nn.Module]): ``sigma`` activation. Default: ``torch.nn.Sigmoid``
+    """
+
+    def __init__(
+        self,
+        input_channels: int,
+        squeeze_channels: int,
+        activation: Callable[..., torch.nn.Module] = torch.nn.ReLU,
+        scale_activation: Callable[..., torch.nn.Module] = torch.nn.Sigmoid,
+    ) -> None:
+        super().__init__()
+        _log_api_usage_once(self)
+        self.avgpool = torch.nn.AdaptiveAvgPool2d(1)
+        self.fc1 = torch.nn.Conv2d(input_channels, squeeze_channels, 1)
+        self.fc2 = torch.nn.Conv2d(squeeze_channels, input_channels, 1)
+        self.activation = activation()
+        self.scale_activation = scale_activation()
+
+    def _scale(self, input: Tensor) -> Tensor:
+        scale = self.avgpool(input)
+        scale = self.fc1(scale)
+        scale = self.activation(scale)
+        scale = self.fc2(scale)
+        return self.scale_activation(scale)
+
+    def forward(self, input: Tensor) -> Tensor:
+        scale = self._scale(input)
+        return scale * input

models/vision_transformer_utils.py

@@ -0,0 +1,549 @@
+import math
+import pathlib
+import warnings
+from types import FunctionType
+from typing import Any, BinaryIO, List, Optional, Tuple, Union
+
+import numpy as np
+import torch
+from PIL import Image, ImageColor, ImageDraw, ImageFont
+
+__all__ = [
+    "make_grid",
+    "save_image",
+    "draw_bounding_boxes",
+    "draw_segmentation_masks",
+    "draw_keypoints",
+    "flow_to_image",
+]
+
+
+@torch.no_grad()
+def make_grid(
+    tensor: Union[torch.Tensor, List[torch.Tensor]],
+    nrow: int = 8,
+    padding: int = 2,
+    normalize: bool = False,
+    value_range: Optional[Tuple[int, int]] = None,
+    scale_each: bool = False,
+    pad_value: float = 0.0,
+    **kwargs,
+) -> torch.Tensor:
+    """
+    Make a grid of images.
+
+    Args:
+        tensor (Tensor or list): 4D mini-batch Tensor of shape (B x C x H x W)
+            or a list of images all of the same size.
+        nrow (int, optional): Number of images displayed in each row of the grid.
+            The final grid size is ``(B / nrow, nrow)``. Default: ``8``.
+        padding (int, optional): amount of padding. Default: ``2``.
+        normalize (bool, optional): If True, shift the image to the range (0, 1),
+            by the min and max values specified by ``value_range``. Default: ``False``.
+        value_range (tuple, optional): tuple (min, max) where min and max are numbers,
+            then these numbers are used to normalize the image. By default, min and max
+            are computed from the tensor.
+        range (tuple. optional):
+            .. warning::
+                This parameter was deprecated in ``0.12`` and will be removed in ``0.14``. Please use ``value_range``
+                instead.
+        scale_each (bool, optional): If ``True``, scale each image in the batch of
+            images separately rather than the (min, max) over all images. Default: ``False``.
+        pad_value (float, optional): Value for the padded pixels. Default: ``0``.
+
+    Returns:
+        grid (Tensor): the tensor containing grid of images.
+    """
+    if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+        _log_api_usage_once(make_grid)
+    if not (torch.is_tensor(tensor) or (isinstance(tensor, list) and all(torch.is_tensor(t) for t in tensor))):
+        raise TypeError(f"tensor or list of tensors expected, got {type(tensor)}")
+
+    if "range" in kwargs.keys():
+        warnings.warn(
+            "The parameter 'range' is deprecated since 0.12 and will be removed in 0.14. "
+            "Please use 'value_range' instead."
+        )
+        value_range = kwargs["range"]
+
+    # if list of tensors, convert to a 4D mini-batch Tensor
+    if isinstance(tensor, list):
+        tensor = torch.stack(tensor, dim=0)
+
+    if tensor.dim() == 2:  # single image H x W
+        tensor = tensor.unsqueeze(0)
+    if tensor.dim() == 3:  # single image
+        if tensor.size(0) == 1:  # if single-channel, convert to 3-channel
+            tensor = torch.cat((tensor, tensor, tensor), 0)
+        tensor = tensor.unsqueeze(0)
+
+    if tensor.dim() == 4 and tensor.size(1) == 1:  # single-channel images
+        tensor = torch.cat((tensor, tensor, tensor), 1)
+
+    if normalize is True:
+        tensor = tensor.clone()  # avoid modifying tensor in-place
+        if value_range is not None:
+            assert isinstance(
+                value_range, tuple
+            ), "value_range has to be a tuple (min, max) if specified. min and max are numbers"
+
+        def norm_ip(img, low, high):
+            img.clamp_(min=low, max=high)
+            img.sub_(low).div_(max(high - low, 1e-5))
+
+        def norm_range(t, value_range):
+            if value_range is not None:
+                norm_ip(t, value_range[0], value_range[1])
+            else:
+                norm_ip(t, float(t.min()), float(t.max()))
+
+        if scale_each is True:
+            for t in tensor:  # loop over mini-batch dimension
+                norm_range(t, value_range)
+        else:
+            norm_range(tensor, value_range)
+
+    assert isinstance(tensor, torch.Tensor)
+    if tensor.size(0) == 1:
+        return tensor.squeeze(0)
+
+    # make the mini-batch of images into a grid
+    nmaps = tensor.size(0)
+    xmaps = min(nrow, nmaps)
+    ymaps = int(math.ceil(float(nmaps) / xmaps))
+    height, width = int(tensor.size(2) + padding), int(tensor.size(3) + padding)
+    num_channels = tensor.size(1)
+    grid = tensor.new_full((num_channels, height * ymaps + padding, width * xmaps + padding), pad_value)
+    k = 0
+    for y in range(ymaps):
+        for x in range(xmaps):
+            if k >= nmaps:
+                break
+            # Tensor.copy_() is a valid method but seems to be missing from the stubs
+            # https://pytorch.org/docs/stable/tensors.html#torch.Tensor.copy_
+            grid.narrow(1, y * height + padding, height - padding).narrow(  # type: ignore[attr-defined]
+                2, x * width + padding, width - padding
+            ).copy_(tensor[k])
+            k = k + 1
+    return grid
+
+
+@torch.no_grad()
+def save_image(
+    tensor: Union[torch.Tensor, List[torch.Tensor]],
+    fp: Union[str, pathlib.Path, BinaryIO],
+    format: Optional[str] = None,
+    **kwargs,
+) -> None:
+    """
+    Save a given Tensor into an image file.
+
+    Args:
+        tensor (Tensor or list): Image to be saved. If given a mini-batch tensor,
+            saves the tensor as a grid of images by calling ``make_grid``.
+        fp (string or file object): A filename or a file object
+        format(Optional):  If omitted, the format to use is determined from the filename extension.
+            If a file object was used instead of a filename, this parameter should always be used.
+        **kwargs: Other arguments are documented in ``make_grid``.
+    """
+
+    if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+        _log_api_usage_once(save_image)
+    grid = make_grid(tensor, **kwargs)
+    # Add 0.5 after unnormalizing to [0, 255] to round to nearest integer
+    ndarr = grid.mul(255).add_(0.5).clamp_(0, 255).permute(1, 2, 0).to("cpu", torch.uint8).numpy()
+    im = Image.fromarray(ndarr)
+    im.save(fp, format=format)
+
+
+@torch.no_grad()
+def draw_bounding_boxes(
+    image: torch.Tensor,
+    boxes: torch.Tensor,
+    labels: Optional[List[str]] = None,
+    colors: Optional[Union[List[Union[str, Tuple[int, int, int]]], str, Tuple[int, int, int]]] = None,
+    fill: Optional[bool] = False,
+    width: int = 1,
+    font: Optional[str] = None,
+    font_size: int = 10,
+) -> torch.Tensor:
+
+    """
+    Draws bounding boxes on given image.
+    The values of the input image should be uint8 between 0 and 255.
+    If fill is True, Resulting Tensor should be saved as PNG image.
+
+    Args:
+        image (Tensor): Tensor of shape (C x H x W) and dtype uint8.
+        boxes (Tensor): Tensor of size (N, 4) containing bounding boxes in (xmin, ymin, xmax, ymax) format. Note that
+            the boxes are absolute coordinates with respect to the image. In other words: `0 <= xmin < xmax < W` and
+            `0 <= ymin < ymax < H`.
+        labels (List[str]): List containing the labels of bounding boxes.
+        colors (color or list of colors, optional): List containing the colors
+            of the boxes or single color for all boxes. The color can be represented as
+            PIL strings e.g. "red" or "#FF00FF", or as RGB tuples e.g. ``(240, 10, 157)``.
+            By default, random colors are generated for boxes.
+        fill (bool): If `True` fills the bounding box with specified color.
+        width (int): Width of bounding box.
+        font (str): A filename containing a TrueType font. If the file is not found in this filename, the loader may
+            also search in other directories, such as the `fonts/` directory on Windows or `/Library/Fonts/`,
+            `/System/Library/Fonts/` and `~/Library/Fonts/` on macOS.
+        font_size (int): The requested font size in points.
+
+    Returns:
+        img (Tensor[C, H, W]): Image Tensor of dtype uint8 with bounding boxes plotted.
+    """
+
+    if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+        _log_api_usage_once(draw_bounding_boxes)
+    if not isinstance(image, torch.Tensor):
+        raise TypeError(f"Tensor expected, got {type(image)}")
+    elif image.dtype != torch.uint8:
+        raise ValueError(f"Tensor uint8 expected, got {image.dtype}")
+    elif image.dim() != 3:
+        raise ValueError("Pass individual images, not batches")
+    elif image.size(0) not in {1, 3}:
+        raise ValueError("Only grayscale and RGB images are supported")
+
+    num_boxes = boxes.shape[0]
+
+    if labels is None:
+        labels: Union[List[str], List[None]] = [None] * num_boxes  # type: ignore[no-redef]
+    elif len(labels) != num_boxes:
+        raise ValueError(
+            f"Number of boxes ({num_boxes}) and labels ({len(labels)}) mismatch. Please specify labels for each box."
+        )
+
+    if colors is None:
+        colors = _generate_color_palette(num_boxes)
+    elif isinstance(colors, list):
+        if len(colors) < num_boxes:
+            raise ValueError(f"Number of colors ({len(colors)}) is less than number of boxes ({num_boxes}). ")
+    else:  # colors specifies a single color for all boxes
+        colors = [colors] * num_boxes
+
+    colors = [(ImageColor.getrgb(color) if isinstance(color, str) else color) for color in colors]
+
+    # Handle Grayscale images
+    if image.size(0) == 1:
+        image = torch.tile(image, (3, 1, 1))
+
+    ndarr = image.permute(1, 2, 0).cpu().numpy()
+    img_to_draw = Image.fromarray(ndarr)
+    img_boxes = boxes.to(torch.int64).tolist()
+
+    if fill:
+        draw = ImageDraw.Draw(img_to_draw, "RGBA")
+    else:
+        draw = ImageDraw.Draw(img_to_draw)
+
+    txt_font = ImageFont.load_default() if font is None else ImageFont.truetype(font=font, size=font_size)
+
+    for bbox, color, label in zip(img_boxes, colors, labels):  # type: ignore[arg-type]
+        if fill:
+            fill_color = color + (100,)
+            draw.rectangle(bbox, width=width, outline=color, fill=fill_color)
+        else:
+            draw.rectangle(bbox, width=width, outline=color)
+
+        if label is not None:
+            margin = width + 1
+            draw.text((bbox[0] + margin, bbox[1] + margin), label, fill=color, font=txt_font)
+
+    return torch.from_numpy(np.array(img_to_draw)).permute(2, 0, 1).to(dtype=torch.uint8)
+
+
+@torch.no_grad()
+def draw_segmentation_masks(
+    image: torch.Tensor,
+    masks: torch.Tensor,
+    alpha: float = 0.8,
+    colors: Optional[Union[List[Union[str, Tuple[int, int, int]]], str, Tuple[int, int, int]]] = None,
+) -> torch.Tensor:
+
+    """
+    Draws segmentation masks on given RGB image.
+    The values of the input image should be uint8 between 0 and 255.
+
+    Args:
+        image (Tensor): Tensor of shape (3, H, W) and dtype uint8.
+        masks (Tensor): Tensor of shape (num_masks, H, W) or (H, W) and dtype bool.
+        alpha (float): Float number between 0 and 1 denoting the transparency of the masks.
+            0 means full transparency, 1 means no transparency.
+        colors (color or list of colors, optional): List containing the colors
+            of the masks or single color for all masks. The color can be represented as
+            PIL strings e.g. "red" or "#FF00FF", or as RGB tuples e.g. ``(240, 10, 157)``.
+            By default, random colors are generated for each mask.
+
+    Returns:
+        img (Tensor[C, H, W]): Image Tensor, with segmentation masks drawn on top.
+    """
+
+    if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+        _log_api_usage_once(draw_segmentation_masks)
+    if not isinstance(image, torch.Tensor):
+        raise TypeError(f"The image must be a tensor, got {type(image)}")
+    elif image.dtype != torch.uint8:
+        raise ValueError(f"The image dtype must be uint8, got {image.dtype}")
+    elif image.dim() != 3:
+        raise ValueError("Pass individual images, not batches")
+    elif image.size()[0] != 3:
+        raise ValueError("Pass an RGB image. Other Image formats are not supported")
+    if masks.ndim == 2:
+        masks = masks[None, :, :]
+    if masks.ndim != 3:
+        raise ValueError("masks must be of shape (H, W) or (batch_size, H, W)")
+    if masks.dtype != torch.bool:
+        raise ValueError(f"The masks must be of dtype bool. Got {masks.dtype}")
+    if masks.shape[-2:] != image.shape[-2:]:
+        raise ValueError("The image and the masks must have the same height and width")
+
+    num_masks = masks.size()[0]
+    if colors is not None and num_masks > len(colors):
+        raise ValueError(f"There are more masks ({num_masks}) than colors ({len(colors)})")
+
+    if colors is None:
+        colors = _generate_color_palette(num_masks)
+
+    if not isinstance(colors, list):
+        colors = [colors]
+    if not isinstance(colors[0], (tuple, str)):
+        raise ValueError("colors must be a tuple or a string, or a list thereof")
+    if isinstance(colors[0], tuple) and len(colors[0]) != 3:
+        raise ValueError("It seems that you passed a tuple of colors instead of a list of colors")
+
+    out_dtype = torch.uint8
+
+    colors_ = []
+    for color in colors:
+        if isinstance(color, str):
+            color = ImageColor.getrgb(color)
+        colors_.append(torch.tensor(color, dtype=out_dtype))
+
+    img_to_draw = image.detach().clone()
+    # TODO: There might be a way to vectorize this
+    for mask, color in zip(masks, colors_):
+        img_to_draw[:, mask] = color[:, None]
+
+    out = image * (1 - alpha) + img_to_draw * alpha
+    return out.to(out_dtype)
+
+
+@torch.no_grad()
+def draw_keypoints(
+    image: torch.Tensor,
+    keypoints: torch.Tensor,
+    connectivity: Optional[List[Tuple[int, int]]] = None,
+    colors: Optional[Union[str, Tuple[int, int, int]]] = None,
+    radius: int = 2,
+    width: int = 3,
+) -> torch.Tensor:
+
+    """
+    Draws Keypoints on given RGB image.
+    The values of the input image should be uint8 between 0 and 255.
+
+    Args:
+        image (Tensor): Tensor of shape (3, H, W) and dtype uint8.
+        keypoints (Tensor): Tensor of shape (num_instances, K, 2) the K keypoints location for each of the N instances,
+            in the format [x, y].
+        connectivity (List[Tuple[int, int]]]): A List of tuple where,
+            each tuple contains pair of keypoints to be connected.
+        colors (str, Tuple): The color can be represented as
+            PIL strings e.g. "red" or "#FF00FF", or as RGB tuples e.g. ``(240, 10, 157)``.
+        radius (int): Integer denoting radius of keypoint.
+        width (int): Integer denoting width of line connecting keypoints.
+
+    Returns:
+        img (Tensor[C, H, W]): Image Tensor of dtype uint8 with keypoints drawn.
+    """
+
+    if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+        _log_api_usage_once(draw_keypoints)
+    if not isinstance(image, torch.Tensor):
+        raise TypeError(f"The image must be a tensor, got {type(image)}")
+    elif image.dtype != torch.uint8:
+        raise ValueError(f"The image dtype must be uint8, got {image.dtype}")
+    elif image.dim() != 3:
+        raise ValueError("Pass individual images, not batches")
+    elif image.size()[0] != 3:
+        raise ValueError("Pass an RGB image. Other Image formats are not supported")
+
+    if keypoints.ndim != 3:
+        raise ValueError("keypoints must be of shape (num_instances, K, 2)")
+
+    ndarr = image.permute(1, 2, 0).cpu().numpy()
+    img_to_draw = Image.fromarray(ndarr)
+    draw = ImageDraw.Draw(img_to_draw)
+    img_kpts = keypoints.to(torch.int64).tolist()
+
+    for kpt_id, kpt_inst in enumerate(img_kpts):
+        for inst_id, kpt in enumerate(kpt_inst):
+            x1 = kpt[0] - radius
+            x2 = kpt[0] + radius
+            y1 = kpt[1] - radius
+            y2 = kpt[1] + radius
+            draw.ellipse([x1, y1, x2, y2], fill=colors, outline=None, width=0)
+
+        if connectivity:
+            for connection in connectivity:
+                start_pt_x = kpt_inst[connection[0]][0]
+                start_pt_y = kpt_inst[connection[0]][1]
+
+                end_pt_x = kpt_inst[connection[1]][0]
+                end_pt_y = kpt_inst[connection[1]][1]
+
+                draw.line(
+                    ((start_pt_x, start_pt_y), (end_pt_x, end_pt_y)),
+                    width=width,
+                )
+
+    return torch.from_numpy(np.array(img_to_draw)).permute(2, 0, 1).to(dtype=torch.uint8)
+
+
+# Flow visualization code adapted from https://github.com/tomrunia/OpticalFlow_Visualization
+@torch.no_grad()
+def flow_to_image(flow: torch.Tensor) -> torch.Tensor:
+
+    """
+    Converts a flow to an RGB image.
+
+    Args:
+        flow (Tensor): Flow of shape (N, 2, H, W) or (2, H, W) and dtype torch.float.
+
+    Returns:
+        img (Tensor): Image Tensor of dtype uint8 where each color corresponds
+            to a given flow direction. Shape is (N, 3, H, W) or (3, H, W) depending on the input.
+    """
+
+    if flow.dtype != torch.float:
+        raise ValueError(f"Flow should be of dtype torch.float, got {flow.dtype}.")
+
+    orig_shape = flow.shape
+    if flow.ndim == 3:
+        flow = flow[None]  # Add batch dim
+
+    if flow.ndim != 4 or flow.shape[1] != 2:
+        raise ValueError(f"Input flow should have shape (2, H, W) or (N, 2, H, W), got {orig_shape}.")
+
+    max_norm = torch.sum(flow ** 2, dim=1).sqrt().max()
+    epsilon = torch.finfo((flow).dtype).eps
+    normalized_flow = flow / (max_norm + epsilon)
+    img = _normalized_flow_to_image(normalized_flow)
+
+    if len(orig_shape) == 3:
+        img = img[0]  # Remove batch dim
+    return img
+
+
+@torch.no_grad()
+def _normalized_flow_to_image(normalized_flow: torch.Tensor) -> torch.Tensor:
+
+    """
+    Converts a batch of normalized flow to an RGB image.
+
+    Args:
+        normalized_flow (torch.Tensor): Normalized flow tensor of shape (N, 2, H, W)
+    Returns:
+       img (Tensor(N, 3, H, W)): Flow visualization image of dtype uint8.
+    """
+
+    N, _, H, W = normalized_flow.shape
+    device = normalized_flow.device
+    flow_image = torch.zeros((N, 3, H, W), dtype=torch.uint8, device=device)
+    colorwheel = _make_colorwheel().to(device)  # shape [55x3]
+    num_cols = colorwheel.shape[0]
+    norm = torch.sum(normalized_flow ** 2, dim=1).sqrt()
+    a = torch.atan2(-normalized_flow[:, 1, :, :], -normalized_flow[:, 0, :, :]) / torch.pi
+    fk = (a + 1) / 2 * (num_cols - 1)
+    k0 = torch.floor(fk).to(torch.long)
+    k1 = k0 + 1
+    k1[k1 == num_cols] = 0
+    f = fk - k0
+
+    for c in range(colorwheel.shape[1]):
+        tmp = colorwheel[:, c]
+        col0 = tmp[k0] / 255.0
+        col1 = tmp[k1] / 255.0
+        col = (1 - f) * col0 + f * col1
+        col = 1 - norm * (1 - col)
+        flow_image[:, c, :, :] = torch.floor(255 * col)
+    return flow_image
+
+
+def _make_colorwheel() -> torch.Tensor:
+    """
+    Generates a color wheel for optical flow visualization as presented in:
+    Baker et al. "A Database and Evaluation Methodology for Optical Flow" (ICCV, 2007)
+    URL: http://vision.middlebury.edu/flow/flowEval-iccv07.pdf.
+
+    Returns:
+        colorwheel (Tensor[55, 3]): Colorwheel Tensor.
+    """
+
+    RY = 15
+    YG = 6
+    GC = 4
+    CB = 11
+    BM = 13
+    MR = 6
+
+    ncols = RY + YG + GC + CB + BM + MR
+    colorwheel = torch.zeros((ncols, 3))
+    col = 0
+
+    # RY
+    colorwheel[0:RY, 0] = 255
+    colorwheel[0:RY, 1] = torch.floor(255 * torch.arange(0, RY) / RY)
+    col = col + RY
+    # YG
+    colorwheel[col : col + YG, 0] = 255 - torch.floor(255 * torch.arange(0, YG) / YG)
+    colorwheel[col : col + YG, 1] = 255
+    col = col + YG
+    # GC
+    colorwheel[col : col + GC, 1] = 255
+    colorwheel[col : col + GC, 2] = torch.floor(255 * torch.arange(0, GC) / GC)
+    col = col + GC
+    # CB
+    colorwheel[col : col + CB, 1] = 255 - torch.floor(255 * torch.arange(CB) / CB)
+    colorwheel[col : col + CB, 2] = 255
+    col = col + CB
+    # BM
+    colorwheel[col : col + BM, 2] = 255
+    colorwheel[col : col + BM, 0] = torch.floor(255 * torch.arange(0, BM) / BM)
+    col = col + BM
+    # MR
+    colorwheel[col : col + MR, 2] = 255 - torch.floor(255 * torch.arange(MR) / MR)
+    colorwheel[col : col + MR, 0] = 255
+    return colorwheel
+
+
+def _generate_color_palette(num_objects: int):
+    palette = torch.tensor([2 ** 25 - 1, 2 ** 15 - 1, 2 ** 21 - 1])
+    return [tuple((i * palette) % 255) for i in range(num_objects)]
+
+
+def _log_api_usage_once(obj: Any) -> None:
+
+    """
+    Logs API usage(module and name) within an organization.
+    In a large ecosystem, it's often useful to track the PyTorch and
+    TorchVision APIs usage. This API provides the similar functionality to the
+    logging module in the Python stdlib. It can be used for debugging purpose
+    to log which methods are used and by default it is inactive, unless the user
+    manually subscribes a logger via the `SetAPIUsageLogger method <https://github.com/pytorch/pytorch/blob/eb3b9fe719b21fae13c7a7cf3253f970290a573e/c10/util/Logging.cpp#L114>`_.
+    Please note it is triggered only once for the same API call within a process.
+    It does not collect any data from open-source users since it is no-op by default.
+    For more information, please refer to
+    * PyTorch note: https://pytorch.org/docs/stable/notes/large_scale_deployments.html#api-usage-logging;
+    * Logging policy: https://github.com/pytorch/vision/issues/5052;
+
+    Args:
+        obj (class instance or method): an object to extract info from.
+    """
+    if not obj.__module__.startswith("torchvision"):
+        return
+    name = obj.__class__.__name__
+    if isinstance(obj, FunctionType):
+        name = obj.__name__
+    torch._C._log_api_usage_once(f"{obj.__module__}.{name}")

options/base_options.py

@@ -0,0 +1,108 @@
+import os
+import argparse
+import torch
+
+
+class BaseOptions:
+    def __init__(self):
+        self.initialized = False
+
+    def initialize(self, parser):
+        parser.add_argument("--arch", type=str, default="CLIP:ViT-L/14", help="see models/__init__.py")
+        parser.add_argument("--fix_backbone", default=False)
+        parser.add_argument("--fix_encoder", default=True)
+
+        parser.add_argument("--real_list_path", default="/apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/0_real")
+        parser.add_argument("--fake_list_path", default="/apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake")
+        parser.add_argument("--data_label", default="train", help="label to decide whether train or validation dataset",)
+
+        parser.add_argument( "--batch_size", type=int, default=10, help="input batch size")
+        parser.add_argument("--gpu_ids", type=str, default="1", help="gpu ids: e.g. 0  0,1,2, 0,2. use -1 for CPU",)
+        parser.add_argument("--name", type=str, default="experiment_name", help="name of the experiment. It decides where to store samples and models",)
+        parser.add_argument("--num_threads", default=0, type=int, help="# threads for loading data")
+        parser.add_argument("--checkpoints_dir", type=str, default="./checkpoints", help="models are saved here",)
+        parser.add_argument("--serial_batches",action="store_true",help="if true, takes images in order to make batches, otherwise takes them randomly",)
+        parser.add_argument("--suffix", type=str, default="", help="customized suffix: opt.name = opt.name + suffix, e.g., {batch_size}",)
+        
+        # Data augmentation parameters
+        parser.add_argument("--rz_interp", type=str, default="bilinear", help="resize interpolation method")
+        parser.add_argument("--blur_sig", type=str, default="0", help="blur sigma (comma-separated for range)")
+        parser.add_argument("--jpg_method", type=str, default="cv2", help="JPEG compression method")
+        parser.add_argument("--jpg_qual", type=str, default="75", help="JPEG quality (comma-separated for range)")
+        
+        # Data loading parameters
+        parser.add_argument("--class_bal", action="store_true", help="whether to use class-balanced sampling")
+        
+        self.initialized = True
+        return parser
+
+    def gather_options(self):
+        # initialize parser with basic options
+        if not self.initialized:
+            parser = argparse.ArgumentParser(
+                formatter_class=argparse.ArgumentDefaultsHelpFormatter
+            )
+            parser = self.initialize(parser)
+
+        # get the basic options
+        opt, _ = parser.parse_known_args()
+        self.parser = parser
+
+        return parser.parse_args()
+
+    def print_options(self, opt):
+        message = ""
+        message += "----------------- Options ---------------\n"
+        for k, v in sorted(vars(opt).items()):
+            comment = ""
+            default = self.parser.get_default(k)
+            if v != default:
+                comment = "\t[default: %s]" % str(default)
+            message += "{:>25}: {:<30}{}\n".format(str(k), str(v), comment)
+        message += "----------------- End -------------------"
+        print(message)
+
+        # save to the disk
+        expr_dir = os.path.join(opt.checkpoints_dir, opt.name)
+        os.makedirs(expr_dir, exist_ok=True)
+        # util.mkdirs(expr_dir)
+        file_name = os.path.join(expr_dir, "opt.txt")
+        with open(file_name, "wt") as opt_file:
+            opt_file.write(message)
+            opt_file.write("\n")
+
+    def parse(self, print_options=True):
+        opt = self.gather_options()
+        opt.isTrain = self.isTrain  # train or test
+
+        # process opt.suffix
+        if opt.suffix:
+            suffix = ("_" + opt.suffix.format(**vars(opt))) if opt.suffix != "" else ""
+            opt.name = opt.name + suffix
+
+        if print_options:
+            self.print_options(opt)
+
+        # set gpu ids
+        str_ids = opt.gpu_ids.split(",")
+        opt.gpu_ids = []
+        for str_id in str_ids:
+            id = int(str_id)
+            if id >= 0:
+                opt.gpu_ids.append(id)
+        if len(opt.gpu_ids) > 0:
+            torch.cuda.set_device(opt.gpu_ids[0])
+
+        # additional
+        # opt.classes = opt.classes.split(',')
+        opt.rz_interp = opt.rz_interp.split(",")
+        opt.blur_sig = [float(s) for s in opt.blur_sig.split(",")]
+        opt.jpg_method = opt.jpg_method.split(",")
+        opt.jpg_qual = [int(s) for s in opt.jpg_qual.split(",")]
+        if len(opt.jpg_qual) == 2:
+            opt.jpg_qual = list(range(opt.jpg_qual[0], opt.jpg_qual[1] + 1))
+        elif len(opt.jpg_qual) > 2:
+            raise ValueError("Shouldn't have more than 2 values for --jpg_qual.")
+
+        self.opt = opt
+        return self.opt

options/test_options.py

@@ -0,0 +1,11 @@
+from .base_options import BaseOptions
+
+
+class TestOptions(BaseOptions):
+    def initialize(self, parser):
+        parser = BaseOptions.initialize(self, parser)
+        parser.add_argument('--model_path')
+        parser.add_argument('--eval', action='store_true', help='use eval mode during test time.')
+
+        self.isTrain = False
+        return parser

options/train_options.py

@@ -0,0 +1,21 @@
+from .base_options import BaseOptions
+
+
+class TrainOptions(BaseOptions):
+    def initialize(self, parser):
+        parser = BaseOptions.initialize(self, parser)
+        parser.add_argument('--optim', type=str, default='adam', help='optim to use [sgd, adam]')
+        parser.add_argument('--loss_freq', type=int, default=100, help='frequency of showing loss on tensorboard')
+        parser.add_argument('--save_epoch_freq', type=int, default=1,
+                            help='frequency of saving checkpoints at the end of epochs')
+        parser.add_argument('--train_split', type=str, default='train', help='train, val, test, etc')
+        parser.add_argument('--val_split', type=str, default='val', help='train, val, test, etc')
+        parser.add_argument('--epoch', type=int, default=100, help='total epoches')
+        parser.add_argument('--beta1', type=float, default=0.9, help='momentum term of adam')
+        parser.add_argument('--lr', type=float, default=2e-9, help='initial learning rate for adam')
+        parser.add_argument('--pretrained_model', type=str, default='./checkpoints/experiment_name/model_epoch_29.pth', help='model will fine tune on it if fine_tune is True')
+        parser.add_argument('--fine_tune', action='store_true', help='whether to fine-tune from pretrained model')
+        parser.add_argument('--weight_decay', type=float, default=1e-4, help='weight decay for optimizer')
+        self.isTrain = True
+
+        return parser

plot_compare_with_lipfd.py

@@ -0,0 +1,149 @@
+"""plot_compare_with_lipfd.py — merge LipFD v4 results into X-AVDT's
+merged_long_table.csv, then produce a multi-method comparison figure
+matching the reference grid_auroc.png layout (2x4, 1 empty cell).
+
+Usage:
+    /opt/conda/envs/LipFD/bin/python plot_compare_with_lipfd.py
+"""
+import csv
+import json
+import os
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+X_AVDT_CSV = "/apdcephfs_gy4/share_303628665/joywu/research/X-AVDT/results/robustness/compare/merged_long_table.csv"
+LIPFD_RUNS = "/apdcephfs_gy4/share_303628665/joywu/research/LipFD/robustnessv4/runs.json"
+OUT_DIR    = "/apdcephfs_gy4/share_303628665/joywu/research/LipFD/robustnessv4/compare"
+os.makedirs(OUT_DIR, exist_ok=True)
+
+# Order and display labels mirror the reference figure.
+PERTURBATIONS = [
+    ("gaussian_noise",   "Gaussian noise"),
+    ("block_wise",       "Block occlusion"),
+    ("jpeg_quality",     "JPEG compression"),
+    ("pixelate",         "Pixelation"),
+    ("gaussian_blur",    "Gaussian blur"),
+    ("color_saturation", "Color saturation"),
+    ("color_contrast",   "Color contrast"),
+]
+
+# Methods + styling (reference: CTA red circle, X-AVDT blue square, AVH-Align green tri).
+METHODS = [
+    ("CTA",       "#d62728", "o"),
+    ("X-AVDT",    "#1f77b4", "s"),
+    ("AVH-Align", "#2ca02c", "^"),
+    ("LipFD",     "#9467bd", "D"),  # purple diamond — new method
+]
+
+
+def load_xavdt_rows(path):
+    with open(path) as f:
+        return list(csv.DictReader(f))
+
+
+def lipfd_to_rows(runs_json):
+    """Convert LipFD v4 runs.json to long rows in the same schema as X-AVDT's CSV."""
+    runs = json.load(open(runs_json))["runs"]
+    # Identify the level=1 baseline (no-op). In LipFD it lives under gaussian_noise/L1.
+    baseline = next(r for r in runs if r["level"] == 1)
+    bl_metrics = baseline["overall_clip"]
+
+    rows = []
+    perturbs = sorted({r["perturbation"] for r in runs})
+    for p in perturbs:
+        # Level=1 is the SAME clean baseline for every perturbation.
+        rows.append({
+            "model": "LipFD", "perturbation": p, "level": "1", "param": "0.0",
+            "AUROC": bl_metrics["AUROC"], "AP": bl_metrics["AP"],
+            "Accuracy": bl_metrics["Accuracy"], "Acc@EER": bl_metrics["Acc@EER"],
+        })
+        for r in runs:
+            if r["perturbation"] != p or r["level"] == 1:
+                continue
+            o = r["overall_clip"]
+            rows.append({
+                "model": "LipFD", "perturbation": p, "level": str(r["level"]),
+                "param": str(r["param"]),
+                "AUROC": o["AUROC"], "AP": o["AP"],
+                "Accuracy": o["Accuracy"], "Acc@EER": o["Acc@EER"],
+            })
+    return rows
+
+
+def write_merged(xavdt_rows, lipfd_rows, out_path):
+    cols = ["model", "perturbation", "level", "param",
+            "AUROC", "AP", "Accuracy", "Acc@EER"]
+    with open(out_path, "w", newline="") as f:
+        w = csv.DictWriter(f, fieldnames=cols)
+        w.writeheader()
+        for r in xavdt_rows:
+            w.writerow({k: r[k] for k in cols})
+        for r in lipfd_rows:
+            w.writerow(r)
+    print(f"  wrote {out_path}  ({len(xavdt_rows) + len(lipfd_rows)} rows)")
+
+
+def index_by(rows, metric):
+    """{model: {perturbation: {level: float}}} for the requested metric."""
+    out = {}
+    for r in rows:
+        out.setdefault(r["model"], {}).setdefault(r["perturbation"], {})[
+            int(r["level"])] = float(r[metric])
+    return out
+
+
+def plot_grid(rows, metric, out_path, title=None):
+    idx = index_by(rows, metric)
+    levels = [1, 2, 3, 4, 5]
+
+    # 2x4 grid (7 perturbations + 1 empty); reference figure layout.
+    fig, axes = plt.subplots(2, 4, figsize=(20, 9), sharey=False)
+    for ax in axes.flatten():
+        ax.set_visible(False)
+
+    for i, (key, label) in enumerate(PERTURBATIONS):
+        ax = axes.flatten()[i]
+        ax.set_visible(True)
+        for method, color, marker in METHODS:
+            ys = [idx.get(method, {}).get(key, {}).get(L, np.nan) for L in levels]
+            ax.plot(levels, ys, marker=marker, color=color, label=method,
+                    linewidth=2.0, markersize=8)
+        ax.set_title(label, fontsize=14)
+        ax.set_xlabel("Perturbation level (1 = clean, 5 = strongest)", fontsize=11)
+        ax.set_ylabel(metric, fontsize=11)
+        ax.set_xticks(levels)
+        ax.grid(alpha=0.3, linestyle=":")
+
+    handles, labels = axes.flatten()[0].get_legend_handles_labels()
+    fig.legend(handles, labels, loc="upper center", ncol=len(METHODS),
+               fontsize=13, frameon=False, bbox_to_anchor=(0.5, 1.02))
+    if title:
+        fig.suptitle(title, fontsize=14, y=1.05)
+    plt.tight_layout()
+    plt.savefig(out_path, dpi=140, bbox_inches="tight")
+    plt.close()
+    print(f"  wrote {out_path}")
+
+
+def main():
+    print(f"Loading X-AVDT rows from {X_AVDT_CSV}")
+    xavdt_rows = load_xavdt_rows(X_AVDT_CSV)
+    print(f"  {len(xavdt_rows)} rows ({len({r['model'] for r in xavdt_rows})} methods)")
+
+    print(f"\nLoading LipFD v4 from {LIPFD_RUNS}")
+    lipfd_rows = lipfd_to_rows(LIPFD_RUNS)
+    print(f"  {len(lipfd_rows)} rows from LipFD")
+
+    merged_csv = os.path.join(OUT_DIR, "merged_long_table.csv")
+    write_merged(xavdt_rows, lipfd_rows, merged_csv)
+
+    all_rows = xavdt_rows + lipfd_rows
+    for metric in ["AUROC", "AP", "Accuracy", "Acc@EER"]:
+        out_path = os.path.join(OUT_DIR, f"grid_{metric.lower().replace('@','_')}.png")
+        plot_grid(all_rows, metric, out_path)
+
+
+if __name__ == "__main__":
+    main()

plot_robustness.py

@@ -0,0 +1,219 @@
+"""plot_robustness.py — visualize robustness sweep results.
+
+Reads robustnessv3/runs.json and produces:
+  - robustness_overall.png : 4 metrics x 7 perturbations, line plot per metric
+  - robustness_per_fake.png: AUROC per (fake-model x perturbation), 1 row per fake
+  - robustness_table.csv   : flat CSV (perturbation, level, param, metrics)
+
+Run:
+    /opt/conda/envs/LipFD/bin/python plot_robustness.py \
+        --runs robustnessv3/runs.json --out_dir robustnessv3
+"""
+import argparse
+import csv as _csv
+import json
+import os
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+# Same order as evaluate_robustness.py SEVERITY dict
+PERTURBATIONS = ["color_saturation", "color_contrast", "block_wise",
+                 "gaussian_noise", "gaussian_blur", "pixelate", "jpeg_quality"]
+
+# Visual styling — distinct color per perturbation, consistent across plots
+COLORS = {
+    "color_saturation": "#1f77b4",
+    "color_contrast":   "#ff7f0e",
+    "block_wise":       "#2ca02c",
+    "gaussian_noise":   "#d62728",
+    "gaussian_blur":    "#9467bd",
+    "pixelate":         "#8c564b",
+    "jpeg_quality":     "#e377c2",
+}
+MARKERS = {
+    "color_saturation": "o",
+    "color_contrast":   "s",
+    "block_wise":       "^",
+    "gaussian_noise":   "D",
+    "gaussian_blur":    "v",
+    "pixelate":         "P",
+    "jpeg_quality":     "X",
+}
+
+
+def load_runs(path):
+    with open(path) as f:
+        return json.load(f)["runs"]
+
+
+def organize(runs):
+    """{perturbation: {level: run_dict}} — level 1 baseline copied to every perturbation."""
+    out = {p: {} for p in PERTURBATIONS}
+    baseline = None
+    for r in runs:
+        if r["level"] == 1:
+            baseline = r
+            break
+    for r in runs:
+        out[r["perturbation"]][r["level"]] = r
+    if baseline is not None:
+        for p in PERTURBATIONS:
+            out[p][1] = baseline
+    return out, baseline
+
+
+def write_csv(runs, csv_path):
+    rows = []
+    for r in runs:
+        o = r["overall_clip"]
+        rows.append({
+            "perturbation": r["perturbation"],
+            "level":        r["level"],
+            "param":        r["param"],
+            "n_clips":      r["n_clips"],
+            "AUROC":        o["AUROC"],
+            "AP":           o["AP"],
+            "Accuracy":     o["Accuracy"],
+            "Acc@EER":      o["Acc@EER"],
+            "TPR@FPR=1%":   o["TPR@FPR=1%"],
+            "TPR@FPR=0.1%": o["TPR@FPR=0.1%"],
+        })
+    rows.sort(key=lambda x: (x["perturbation"], x["level"]))
+    with open(csv_path, "w", newline="") as f:
+        w = _csv.DictWriter(f, fieldnames=list(rows[0].keys()))
+        w.writeheader()
+        w.writerows(rows)
+    print(f"  wrote {csv_path}  ({len(rows)} rows)")
+
+
+def plot_overall(by_pert, out_path, baseline):
+    """4 panels: AUROC / Accuracy / Acc@EER / TPR@FPR=1%, level on X axis."""
+    metrics = [
+        ("AUROC",       "AUROC"),
+        ("Accuracy",    "Accuracy"),
+        ("Acc@EER",     "Acc@EER"),
+        ("TPR@FPR=1%",  "TPR@FPR=1%"),
+    ]
+    fig, axes = plt.subplots(2, 2, figsize=(13, 9))
+    axes = axes.flatten()
+    levels = [1, 2, 3, 4, 5]
+
+    for ax, (key, title) in zip(axes, metrics):
+        for p in PERTURBATIONS:
+            ys = []
+            for L in levels:
+                r = by_pert[p].get(L)
+                if r is None:
+                    ys.append(np.nan)
+                else:
+                    ys.append(r["overall_clip"][key])
+            ax.plot(levels, ys, marker=MARKERS[p], color=COLORS[p],
+                    label=p, linewidth=1.8, markersize=7)
+        if baseline is not None:
+            bl = baseline["overall_clip"][key]
+            ax.axhline(bl, color="grey", linestyle="--", alpha=0.5, linewidth=1,
+                       label=f"clean baseline = {bl:.4f}")
+        ax.set_title(title, fontsize=12)
+        ax.set_xlabel("perturbation level (1=clean, 5=heaviest)")
+        ax.set_ylabel(title)
+        ax.set_xticks(levels)
+        ax.grid(alpha=0.3)
+
+    # one shared legend on top-right axis
+    handles, labels = axes[0].get_legend_handles_labels()
+    fig.legend(handles, labels, loc="lower center", ncol=4, fontsize=9,
+               frameon=False, bbox_to_anchor=(0.5, -0.02))
+    fig.suptitle("LipFD robustness — overall (clip-level), epoch_44 ckpt", fontsize=14)
+    plt.tight_layout(rect=[0, 0.04, 1, 0.97])
+    plt.savefig(out_path, dpi=140, bbox_inches="tight")
+    plt.close()
+    print(f"  wrote {out_path}")
+
+
+def plot_per_fake(by_pert, out_path, baseline):
+    """1 row per fake model (EDTalk / Float / SadTalk),
+    each row = AUROC vs level for every perturbation."""
+    fakes = sorted(set(baseline["per_fake_vs_real"].keys()))
+    fig, axes = plt.subplots(1, len(fakes), figsize=(5 * len(fakes), 4.5),
+                             sharey=True)
+    if len(fakes) == 1:
+        axes = [axes]
+    levels = [1, 2, 3, 4, 5]
+
+    for ax, fm in zip(axes, fakes):
+        for p in PERTURBATIONS:
+            ys = []
+            for L in levels:
+                r = by_pert[p].get(L)
+                ys.append(r["per_fake_vs_real"][fm]["AUROC"] if r else np.nan)
+            ax.plot(levels, ys, marker=MARKERS[p], color=COLORS[p],
+                    label=p, linewidth=1.6, markersize=6)
+        if baseline is not None:
+            bl = baseline["per_fake_vs_real"][fm]["AUROC"]
+            ax.axhline(bl, color="grey", linestyle="--", alpha=0.5, linewidth=1)
+        ax.set_title(f"{fm} + Real (AUROC)")
+        ax.set_xlabel("level")
+        ax.set_xticks(levels)
+        ax.grid(alpha=0.3)
+    axes[0].set_ylabel("AUROC")
+    handles, labels = axes[0].get_legend_handles_labels()
+    fig.legend(handles, labels, loc="lower center", ncol=4, fontsize=9,
+               frameon=False, bbox_to_anchor=(0.5, -0.04))
+    fig.suptitle("LipFD robustness — per-fake AUROC, epoch_44 ckpt", fontsize=14)
+    plt.tight_layout(rect=[0, 0.06, 1, 0.95])
+    plt.savefig(out_path, dpi=140, bbox_inches="tight")
+    plt.close()
+    print(f"  wrote {out_path}")
+
+
+def plot_fairness(by_pert, out_path):
+    """3 panels (gender/race4/age_group), each shows F_MEO trend per perturbation."""
+    dims = ["gender", "race4", "age_group"]
+    fig, axes = plt.subplots(1, 3, figsize=(15, 4.5))
+    levels = [1, 2, 3, 4, 5]
+    for ax, d in zip(axes, dims):
+        for p in PERTURBATIONS:
+            ys = []
+            for L in levels:
+                r = by_pert[p].get(L)
+                fb = r["fairness_overall"].get(d) if r else None
+                ys.append(fb["F_MEO"] if fb else np.nan)
+            ax.plot(levels, ys, marker=MARKERS[p], color=COLORS[p],
+                    label=p, linewidth=1.6, markersize=6)
+        ax.set_title(f"F_MEO ({d})  — lower is fairer")
+        ax.set_xlabel("level")
+        ax.set_xticks(levels)
+        ax.grid(alpha=0.3)
+    axes[0].set_ylabel("F_MEO (%)")
+    handles, labels = axes[0].get_legend_handles_labels()
+    fig.legend(handles, labels, loc="lower center", ncol=4, fontsize=9,
+               frameon=False, bbox_to_anchor=(0.5, -0.04))
+    fig.suptitle("LipFD robustness — fairness F_MEO across perturbations", fontsize=14)
+    plt.tight_layout(rect=[0, 0.06, 1, 0.95])
+    plt.savefig(out_path, dpi=140, bbox_inches="tight")
+    plt.close()
+    print(f"  wrote {out_path}")
+
+
+def parse_args():
+    p = argparse.ArgumentParser()
+    p.add_argument("--runs", required=True)
+    p.add_argument("--out_dir", required=True)
+    return p.parse_args()
+
+
+def main():
+    args = parse_args()
+    runs = load_runs(args.runs)
+    by_pert, baseline = organize(runs)
+    os.makedirs(args.out_dir, exist_ok=True)
+    write_csv(runs, os.path.join(args.out_dir, "robustness_table.csv"))
+    plot_overall(by_pert,  os.path.join(args.out_dir, "robustness_overall.png"), baseline)
+    plot_per_fake(by_pert, os.path.join(args.out_dir, "robustness_per_fake.png"), baseline)
+    plot_fairness(by_pert, os.path.join(args.out_dir, "robustness_fairness.png"))
+
+
+if __name__ == "__main__":
+    main()

preprocess.py

@@ -0,0 +1,125 @@
+import os
+import cv2
+import numpy as np
+import librosa
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+from librosa import feature as audio
+
+
+"""
+Structure of the AVLips dataset:
+AVLips
+├── 0_real
+├── 1_fake
+└── wav
+    ├── 0_real
+    └── 1_fake
+"""
+
+############ Custom parameter ##############
+N_EXTRACT = 10   # number of extracted images from video
+WINDOW_LEN = 5   # frames of each window
+MAX_SAMPLE = 100 
+
+audio_root = "./AVLips/wav"
+video_root = "./AVLips"
+output_root = "./datasets/AVLips"
+############################################
+
+labels = [(0, "0_real"), (1, "1_fake")]
+
+def get_spectrogram(audio_file):
+    data, sr = librosa.load(audio_file)
+    mel = librosa.power_to_db(audio.melspectrogram(y=data, sr=sr), ref=np.min)
+    plt.imsave("./temp/mel.png", mel)
+
+
+def run():
+    i = 0
+    for label, dataset_name in labels:
+        if not os.path.exists(dataset_name):
+            os.makedirs(f"{output_root}/{dataset_name}", exist_ok=True)
+
+        if i == MAX_SAMPLE:
+            break
+        root = f"{video_root}/{dataset_name}"
+        video_list = os.listdir(root)
+        print(f"Handling {dataset_name}...")
+        for j in tqdm(range(len(video_list))):
+            v = video_list[j]
+            # load video
+            video_capture = cv2.VideoCapture(f"{root}/{v}")
+            fps = video_capture.get(cv2.CAP_PROP_FPS)
+            frame_count = int(video_capture.get(cv2.CAP_PROP_FRAME_COUNT))
+
+            # select 10 starting point from frames
+            frame_idx = np.linspace(
+                0,
+                frame_count - WINDOW_LEN - 1,
+                N_EXTRACT,
+                endpoint=True,
+                dtype=np.uint8,
+            ).tolist()
+            frame_idx.sort()
+            # selected frames
+            frame_sequence = [
+                i for num in frame_idx for i in range(num, num + WINDOW_LEN)
+            ]
+            frame_list = []
+            current_frame = 0
+            while current_frame <= frame_sequence[-1]:
+                ret, frame = video_capture.read()
+                if not ret:
+                    print(f"Error in reading frame {v}: {current_frame}")
+                    break
+                if current_frame in frame_sequence:
+                    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGBA)
+                    frame_list.append(cv2.resize(frame, (500, 500)))  # to floating num
+                current_frame += 1
+            video_capture.release()
+
+            # load audio
+            name = v.split(".")[0]
+            a = f"{audio_root}/{dataset_name}/{name}.wav"
+
+            group = 0
+            get_spectrogram(a)
+            mel = plt.imread("./temp/mel.png") * 255  # load spectrogram (int)
+            mel = mel.astype(np.uint8)
+            mapping = mel.shape[1] / frame_count
+            for i in range(len(frame_list)):
+                idx = i % WINDOW_LEN
+                if idx == 0:
+                    try:
+                        begin = np.round(frame_sequence[i] * mapping)
+                        end = np.round((frame_sequence[i] + WINDOW_LEN) * mapping)
+                        sub_mel = cv2.resize(
+                            (mel[:, int(begin) : int(end)]), (500 * WINDOW_LEN, 500)
+                        )
+                        x = np.concatenate(frame_list[i : i + WINDOW_LEN], axis=1)
+                        # print(x.shape)
+                        # print(sub_mel.shape)
+                        x = np.concatenate((sub_mel[:, :, :3], x[:, :, :3]), axis=0)
+                        # print(x.shape)
+                        plt.imsave(
+                            f"{output_root}/{dataset_name}/{name}_{group}.png", x
+                        )
+                        group = group + 1
+                    except ValueError:
+                        print(f"ValueError: {name}")
+                        continue
+            # print(frame_sequence)
+            # print(frame_count)
+            # print(mel.shape[1])
+            # print(mapping)
+            # exit(0)
+        i += 1
+
+
+if __name__ == "__main__":
+    if not os.path.exists(output_root):
+        os.makedirs(output_root, exist_ok=True)
+    if not os.path.exists("./temp"):
+        os.makedirs("./temp", exist_ok=True)
+    run()

preprocess_improved.py

@@ -0,0 +1,258 @@
+import os
+import cv2
+import numpy as np
+import librosa
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+from librosa import feature as audio
+import sys
+
+"""
+Structure of the AVLips dataset:
+AVLips
+├── 0_real
+├── 1_fake
+└── wav
+    ├── 0_real
+    └── 1_fake
+"""
+
+############ Custom parameter ##############
+N_EXTRACT = 10   # number of extracted windows from video
+WINDOW_LEN = 5   # frames of each window
+MAX_SAMPLE = 0   # maximum number of videos to process (0 means no limit)
+############################################
+
+audio_root = "./AVLips/wav"
+video_root = "./AVLips"
+output_root = "./datasets/AVLips"
+
+# 确保临时目录存在
+os.makedirs("./temp", exist_ok=True)
+os.makedirs(output_root, exist_ok=True)
+
+
+def get_spectrogram(audio_file, output_path="./temp/mel.png"):
+    """
+    Generate mel-spectrogram from audio file
+    
+    Args:
+        audio_file: path to audio file
+        output_path: path to save spectrogram image
+    """
+    try:
+        data, sr = librosa.load(audio_file, sr=16000)
+        mel = librosa.power_to_db(audio.melspectrogram(y=data, sr=sr), ref=np.min)
+        plt.imsave(output_path, mel)
+        return True
+    except Exception as e:
+        print(f"Error generating spectrogram for {audio_file}: {str(e)}")
+        return False
+
+
+def run():
+    labels = [(0, "0_real"), (1, "1_fake")]
+    
+    for label, dataset_name in labels:
+        # Create output directory
+        os.makedirs(f"{output_root}/{dataset_name}", exist_ok=True)
+        
+        root = f"{video_root}/{dataset_name}"
+        if not os.path.exists(root):
+            print(f"Warning: {root} does not exist, skipping...")
+            continue
+            
+        video_list = os.listdir(root)
+        print(f"\nHandling {dataset_name}... (Total: {len(video_list)} videos)")
+        
+        # Limit number of samples if MAX_SAMPLE > 0
+        if MAX_SAMPLE > 0:
+            video_list = video_list[:MAX_SAMPLE]
+            print(f"Limiting to {MAX_SAMPLE} videos")
+        
+        # 断点续传：检查已处理的文件
+        output_dir = f"{output_root}/{dataset_name}"
+        processed_files = set()
+        if os.path.exists(output_dir):
+            # 获取已处理的所有输出文件
+            for f in os.listdir(output_dir):
+                if f.endswith('.png'):
+                    # 提取视频文件名（去掉 _group.png 后缀）
+                    parts = f.rsplit('_', 1)
+                    if len(parts) == 2 and parts[1].startswith('0') and parts[1].endswith('.png'):
+                        processed_files.add(parts[0] + '.mp4')
+        
+        print(f"  - Already processed: {len(processed_files)} videos")
+        
+        # 过滤掉已处理的视频
+        video_list = [v for v in video_list if v not in processed_files]
+        print(f"  - Remaining to process: {len(video_list)} videos")
+        
+        processed_count = 0
+        error_count = 0
+        skip_count = 0
+        
+        for j in tqdm(range(len(video_list)), desc=dataset_name):
+            v = video_list[j]
+            
+            # Check if video file exists
+            video_path = f"{root}/{v}"
+            if not os.path.exists(video_path):
+                print(f"\nWarning: Video file not found: {video_path}")
+                skip_count += 1
+                continue
+            
+            # Load video
+            video_capture = cv2.VideoCapture(video_path)
+            if not video_capture.isOpened():
+                print(f"\nError: Cannot open video {video_path}")
+                error_count += 1
+                continue
+                
+            fps = video_capture.get(cv2.CAP_PROP_FPS)
+            frame_count = int(video_capture.get(cv2.CAP_PROP_FRAME_COUNT))
+            
+            # Skip if video is too short
+            if frame_count < WINDOW_LEN:
+                print(f"\nWarning: Video {v} has only {frame_count} frames (need {WINDOW_LEN}), skipping...")
+                video_capture.release()
+                skip_count += 1
+                continue
+            
+            # Select N_EXTRACT starting points from frames
+            # Ensure we don't go beyond frame_count - WINDOW_LEN
+            max_start = frame_count - WINDOW_LEN
+            if max_start <= 0:
+                print(f"\nWarning: Video {v} is too short, skipping...")
+                video_capture.release()
+                error_count += 1
+                continue
+            
+            frame_idx = np.linspace(
+                0,
+                max_start,
+                N_EXTRACT,
+                endpoint=True,
+            ).astype(int).tolist()
+            frame_idx.sort()
+            
+            # Selected frames
+            frame_sequence = [
+                i for num in frame_idx for i in range(num, num + WINDOW_LEN)
+            ]
+            frame_list = []
+            current_frame = 0
+            
+            # Read frames
+            while current_frame <= frame_sequence[-1]:
+                ret, frame = video_capture.read()
+                if not ret:
+                    print(f"\nWarning: Error reading frame {current_frame} from {v}")
+                    break
+                if current_frame in frame_sequence:
+                    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    frame_list.append(cv2.resize(frame, (500, 500)))
+                current_frame += 1
+            video_capture.release()
+            
+            # Check if we got all frames
+            if len(frame_list) != len(frame_sequence):
+                print(f"\nWarning: Could not read all frames from {v} ({len(frame_list)}/{len(frame_sequence)}), skipping...")
+                skip_count += 1
+                continue
+            
+            # Load audio
+            name = os.path.splitext(v)[0]
+            audio_path = f"{audio_root}/{dataset_name}/{name}.wav"
+            
+            if not os.path.exists(audio_path):
+                print(f"\nWarning: Audio file not found for {v}: {audio_path}")
+                skip_count += 1
+                continue
+            
+            # Generate spectrogram
+            if not get_spectrogram(audio_path):
+                print(f"\nWarning: Could not generate spectrogram for {v}, skipping...")
+                skip_count += 1
+                continue
+            
+            # Load spectrogram
+            mel = plt.imread("./temp/mel.png") * 255  # load spectrogram (int)
+            mel = mel.astype(np.uint8)
+            
+            # Calculate mapping from video frames to spectrogram time axis
+            mapping = mel.shape[1] / frame_count
+            
+            # Process each window
+            group = 0
+            for i in range(0, len(frame_list), WINDOW_LEN):
+                idx = i // WINDOW_LEN
+                try:
+                    begin = int(np.round(frame_sequence[i] * mapping))
+                    end = int(np.round((frame_sequence[i] + WINDOW_LEN) * mapping))
+                    
+                    # Ensure bounds are valid
+                    begin = max(0, begin)
+                    end = min(mel.shape[1], end)
+                    
+                    if end <= begin:
+                        print(f"\nWarning: Invalid spectrogram bounds for {name}, skipping window {group}")
+                        continue
+                    
+                    # Extract and resize spectrogram for this window
+                    sub_mel = cv2.resize(
+                        mel[:, begin:end], (500 * WINDOW_LEN, 500)
+                    )
+                    
+                    # Concatenate frames horizontally
+                    x = np.concatenate(frame_list[i:i + WINDOW_LEN], axis=1)
+                    
+                    # Concatenate spectrogram (top) and frames (bottom)
+                    x = np.concatenate((sub_mel[:, :, :3], x[:, :, :3]), axis=0)
+                    
+                    # Save output image
+                    output_path = f"{output_root}/{dataset_name}/{name}_{group}.png"
+                    plt.imsave(output_path, x)
+                    group += 1
+                    
+                except Exception as e:
+                    print(f"\nError processing window {group} for {name}: {str(e)}")
+                    continue
+            
+            processed_count += 1
+            
+            # Clean up temp file periodically
+            if processed_count % 100 == 0:
+                if os.path.exists("./temp/mel.png"):
+                    os.remove("./temp/mel.png")
+        
+        print(f"\n{dataset_name}:")
+        print(f"  - Processed: {processed_count} videos")
+        print(f"  - Skipped: {skip_count} videos")
+        print(f"  - Errors: {error_count} videos")
+
+
+if __name__ == "__main__":
+    print("="*50)
+    print("AVLips Preprocessing Script")
+    print("="*50)
+    print(f"Parameters:")
+    print(f"  - N_EXTRACT: {N_EXTRACT} windows per video")
+    print(f"  - WINDOW_LEN: {WINDOW_LEN} frames per window")
+    print(f"  - MAX_SAMPLE: {MAX_SAMPLE} (0 = no limit)")
+    print(f"  - Video root: {video_root}")
+    print(f"  - Audio root: {audio_root}")
+    print(f"  - Output root: {output_root}")
+    print("="*50)
+    
+    # Create necessary directories
+    if not os.path.exists(output_root):
+        os.makedirs(output_root, exist_ok=True)
+    if not os.path.exists("./temp"):
+        os.makedirs("./temp", exist_ok=True)
+    
+    run()
+    
+    print("\n" + "="*50)
+    print("Processing complete!")
+    print("="*50)

requirements.txt

@@ -0,0 +1,10 @@
+ftfy==6.1.1
+librosa==0.10.1
+matplotlib==3.8.0
+numpy==1.25.2
+opencv-contrib-python==4.8.1.78
+opencv-python==4.8.1.78
+scikit-learn==1.3.1
+torch==2.1.0
+torchvision==0.16.0
+tqdm==4.66.1

robustness/runs.json.20260625_142029.bak

@@ -0,0 +1,638 @@
+{
+  "runs": [
+    {
+      "ckpt": "checkpoints/lipfd_train/model_epoch_44.pth",
+      "saved_at": "2026-06-25 13:39:24",
+      "load_info": {
+        "missing_count": 0,
+        "unexpected_count": 0
+      },
+      "real_list_path": "datasets/FairTalking-Bench/test/0_real",
+      "fake_list_path": "datasets/FairTalking-Bench/test/1_fake",
+      "demographics_csv": "/apdcephfs_gy4/share_303628665/joywu/research/test.csv",
+      "seed": 42,
+      "perturbation": "gaussian_noise",
+      "level": 1,
+      "param": 0.0,
+      "n_clips": 581,
+      "n_samples": 11610,
+      "overall_clip": {
+        "AUROC": 0.99578149069795,
+        "AP": 0.9955530611412413,
+        "Accuracy@0.50": 0.9483648881239243,
+        "Confusion Matrix": [
+          [
+            261,
+            30
+          ],
+          [
+            0,
+            290
+          ]
+        ],
+        "Classification Report": {
+          "0": {
+            "precision": 1.0,
+            "recall": 0.8969072164948454,
+            "f1-score": 0.9456521739130436,
+            "support": 291.0
+          },
+          "1": {
+            "precision": 0.90625,
+            "recall": 1.0,
+            "f1-score": 0.9508196721311475,
+            "support": 290.0
+          },
+          "accuracy": 0.9483648881239243,
+          "macro avg": {
+            "precision": 0.953125,
+            "recall": 0.9484536082474226,
+            "f1-score": 0.9482359230220956,
+            "support": 581.0
+          },
+          "weighted avg": {
+            "precision": 0.9532056798623064,
+            "recall": 0.9483648881239243,
+            "f1-score": 0.9482314759496187,
+            "support": 581.0
+          }
+        },
+        "EER_threshold": 0.7245295996467273,
+        "Acc@EER": 0.9690189328743546,
+        "TPR@FPR=1%": 0.8344827586206897,
+        "TPR@FPR=0.1%": 0.7206896551724138,
+        "Accuracy": 0.9483648881239243
+      },
+      "per_fake_vs_real": {
+        "EDTalk": {
+          "AUROC": 0.9955924099805767,
+          "AP": 0.9867113482687109,
+          "Accuracy@0.50": 0.9216710182767625,
+          "Confusion Matrix": [
+            [
+              261,
+              30
+            ],
+            [
+              0,
+              92
+            ]
+          ],
+          "Classification Report": {
+            "0": {
+              "precision": 1.0,
+              "recall": 0.8969072164948454,
+              "f1-score": 0.9456521739130436,
+              "support": 291.0
+            },
+            "1": {
+              "precision": 0.7540983606557377,
+              "recall": 1.0,
+              "f1-score": 0.8598130841121495,
+              "support": 92.0
+            },
+            "accuracy": 0.9216710182767625,
+            "macro avg": {
+              "precision": 0.8770491803278688,
+              "recall": 0.9484536082474226,
+              "f1-score": 0.9027326290125965,
+              "support": 383.0
+            },
+            "weighted avg": {
+              "precision": 0.9409322432906733,
+              "recall": 0.9216710182767625,
+              "f1-score": 0.9250328625248392,
+              "support": 383.0
+            }
+          },
+          "EER_threshold": 0.6978994131088256,
+          "Acc@EER": 0.9608355091383812,
+          "TPR@FPR=1%": 0.8586956521739131,
+          "TPR@FPR=0.1%": 0.7391304347826086,
+          "Accuracy": 0.9216710182767625
+        },
+        "Float": {
+          "AUROC": 0.9957375099127677,
+          "AP": 0.9882197470249718,
+          "Accuracy@0.50": 0.9240506329113924,
+          "Confusion Matrix": [
+            [
+              261,
+              30
+            ],
+            [
+              0,
+              104
+            ]
+          ],
+          "Classification Report": {
+            "0": {
+              "precision": 1.0,
+              "recall": 0.8969072164948454,
+              "f1-score": 0.9456521739130436,
+              "support": 291.0
+            },
+            "1": {
+              "precision": 0.7761194029850746,
+              "recall": 1.0,
+              "f1-score": 0.8739495798319328,
+              "support": 104.0
+            },
+            "accuracy": 0.9240506329113924,
+            "macro avg": {
+              "precision": 0.8880597014925373,
+              "recall": 0.9484536082474226,
+              "f1-score": 0.9098008768724881,
+              "support": 395.0
+            },
+            "weighted avg": {
+              "precision": 0.9410542225580957,
+              "recall": 0.9240506329113924,
+              "f1-score": 0.9267735162309284,
+              "support": 395.0
+            }
+          },
+          "EER_threshold": 0.7245295996467273,
+          "Acc@EER": 0.9696202531645569,
+          "TPR@FPR=1%": 0.8269230769230769,
+          "TPR@FPR=0.1%": 0.7403846153846154,
+          "Accuracy": 0.9240506329113924
+        },
+        "SadTalk": {
+          "AUROC": 0.9960152080134532,
+          "AP": 0.9872312860680599,
+          "Accuracy@0.50": 0.922077922077922,
+          "Confusion Matrix": [
+            [
+              261,
+              30
+            ],
+            [
+              0,
+              94
+            ]
+          ],
+          "Classification Report": {
+            "0": {
+              "precision": 1.0,
+              "recall": 0.8969072164948454,
+              "f1-score": 0.9456521739130436,
+              "support": 291.0
+            },
+            "1": {
+              "precision": 0.7580645161290323,
+              "recall": 1.0,
+              "f1-score": 0.8623853211009175,
+              "support": 94.0
+            },
+            "accuracy": 0.922077922077922,
+            "macro avg": {
+              "precision": 0.8790322580645161,
+              "recall": 0.9484536082474226,
+              "f1-score": 0.9040187475069805,
+              "support": 385.0
+            },
+            "weighted avg": {
+              "precision": 0.9409300377042312,
+              "recall": 0.922077922077922,
+              "f1-score": 0.9253220851744985,
+              "support": 385.0
+            }
+          },
+          "EER_threshold": 0.7151398360729218,
+          "Acc@EER": 0.9636363636363636,
+          "TPR@FPR=1%": 0.8191489361702128,
+          "TPR@FPR=0.1%": 0.6808510638297872,
+          "Accuracy": 0.922077922077922
+        }
+      },
+      "fairness_overall": {
+        "gender": {
+          "F_FPR": 0.7227208313651395,
+          "F_MEO": 1.445441662730279,
+          "F_DP": 0.28440062568138025,
+          "F_OAE": 0.3709058159927947,
+          "groups": {
+            "Female": {
+              "n": 289,
+              "fpr": 0.1103448275862069,
+              "tpr": 1.0,
+              "acc": 0.9446366782006921,
+              "dp": 0.5536332179930796
+            },
+            "Male": {
+              "n": 292,
+              "fpr": 0.0958904109589041,
+              "tpr": 1.0,
+              "acc": 0.952054794520548,
+              "dp": 0.547945205479452
+            }
+          }
+        },
+        "race4": {
+          "F_FPR": 6.209116070676719,
+          "F_MEO": 16.216216216216218,
+          "F_DP": 2.491691050830286,
+          "F_OAE": 3.139413058000952,
+          "groups": {
+            "Asian": {
+              "n": 143,
+              "fpr": 0.1388888888888889,
+              "tpr": 1.0,
+              "acc": 0.9300699300699301,
+              "dp": 0.5664335664335665
+            },
+            "Black": {
+              "n": 146,
+              "fpr": 0.16216216216216217,
+              "tpr": 1.0,
+              "acc": 0.9178082191780822,
+              "dp": 0.5753424657534246
+            },
+            "Indian": {
+              "n": 145,
+              "fpr": 0.0,
+              "tpr": 1.0,
+              "acc": 1.0,
+              "dp": 0.5103448275862069
+            },
+            "White": {
+              "n": 147,
+              "fpr": 0.10810810810810811,
+              "tpr": 1.0,
+              "acc": 0.9455782312925171,
+              "dp": 0.5510204081632653
+            }
+          }
+        },
+        "age_group": {
+          "F_FPR": 12.845213079874917,
+          "F_MEO": 37.5,
+          "F_DP": 6.479476581570534,
+          "F_OAE": 6.4214750331720065,
+          "groups": {
+            "0-9": {
+              "n": 96,
+              "fpr": 0.0,
+              "tpr": 1.0,
+              "acc": 1.0,
+              "dp": 0.5
+            },
+            "10-19": {
+              "n": 97,
+              "fpr": 0.02040816326530612,
+              "tpr": 1.0,
+              "acc": 0.9896907216494846,
+              "dp": 0.5051546391752577
+            },
+            "20-29": {
+              "n": 96,
+              "fpr": 0.020833333333333332,
+              "tpr": 1.0,
+              "acc": 0.9895833333333334,
+              "dp": 0.5104166666666666
+            },
+            "30-39": {
+              "n": 98,
+              "fpr": 0.08163265306122448,
+              "tpr": 1.0,
+              "acc": 0.9591836734693877,
+              "dp": 0.5408163265306123
+            },
+            "40-49": {
+              "n": 98,
+              "fpr": 0.12244897959183673,
+              "tpr": 1.0,
+              "acc": 0.9387755102040817,
+              "dp": 0.5612244897959183
+            },
+            "50+": {
+              "n": 96,
+              "fpr": 0.375,
+              "tpr": 1.0,
+              "acc": 0.8125,
+              "dp": 0.6875
+            }
+          }
+        }
+      }
+    },
+    {
+      "ckpt": "checkpoints/lipfd_train/model_epoch_44.pth",
+      "saved_at": "2026-06-25 14:19:44",
+      "load_info": {
+        "missing_count": 0,
+        "unexpected_count": 0
+      },
+      "real_list_path": "datasets/FairTalking-Bench/test/0_real",
+      "fake_list_path": "datasets/FairTalking-Bench/test/1_fake",
+      "demographics_csv": "/apdcephfs_gy4/share_303628665/joywu/research/test.csv",
+      "seed": 42,
+      "perturbation": "gaussian_noise",
+      "level": 3,
+      "param": 0.005,
+      "n_clips": 581,
+      "n_samples": 11610,
+      "overall_clip": {
+        "AUROC": 0.9772366394122525,
+        "AP": 0.9742001425382162,
+        "Accuracy@0.50": 0.919104991394148,
+        "Confusion Matrix": [
+          [
+            249,
+            42
+          ],
+          [
+            5,
+            285
+          ]
+        ],
+        "Classification Report": {
+          "0": {
+            "precision": 0.9803149606299213,
+            "recall": 0.8556701030927835,
+            "f1-score": 0.9137614678899082,
+            "support": 291.0
+          },
+          "1": {
+            "precision": 0.8715596330275229,
+            "recall": 0.9827586206896551,
+            "f1-score": 0.9238249594813615,
+            "support": 290.0
+          },
+          "accuracy": 0.919104991394148,
+          "macro avg": {
+            "precision": 0.9259372968287221,
+            "recall": 0.9192143618912193,
+            "f1-score": 0.9187932136856348,
+            "support": 581.0
+          },
+          "weighted avg": {
+            "precision": 0.9260308900538533,
+            "recall": 0.919104991394148,
+            "f1-score": 0.9187845531937316,
+            "support": 581.0
+          }
+        },
+        "EER_threshold": 0.6816619575023651,
+        "Acc@EER": 0.9156626506024096,
+        "TPR@FPR=1%": 0.496551724137931,
+        "TPR@FPR=0.1%": 0.3,
+        "Accuracy": 0.919104991394148
+      },
+      "per_fake_vs_real": {
+        "EDTalk": {
+          "AUROC": 0.9786717466009263,
+          "AP": 0.9356621957045247,
+          "Accuracy@0.50": 0.8877284595300261,
+          "Confusion Matrix": [
+            [
+              249,
+              42
+            ],
+            [
+              1,
+              91
+            ]
+          ],
+          "Classification Report": {
+            "0": {
+              "precision": 0.996,
+              "recall": 0.8556701030927835,
+              "f1-score": 0.920517560073937,
+              "support": 291.0
+            },
+            "1": {
+              "precision": 0.6842105263157895,
+              "recall": 0.9891304347826086,
+              "f1-score": 0.8088888888888889,
+              "support": 92.0
+            },
+            "accuracy": 0.8877284595300261,
+            "macro avg": {
+              "precision": 0.8401052631578947,
+              "recall": 0.922400268937696,
+              "f1-score": 0.864703224481413,
+              "support": 383.0
+            },
+            "weighted avg": {
+              "precision": 0.9211054005771608,
+              "recall": 0.8877284595300261,
+              "f1-score": 0.8937033622958053,
+              "support": 383.0
+            }
+          },
+          "EER_threshold": 0.6643097837766011,
+          "Acc@EER": 0.9242819843342036,
+          "TPR@FPR=1%": 0.5217391304347826,
+          "TPR@FPR=0.1%": 0.30434782608695654,
+          "Accuracy": 0.8877284595300261
+        },
+        "Float": {
+          "AUROC": 0.9747885276235791,
+          "AP": 0.9299015308451564,
+          "Accuracy@0.50": 0.8860759493670886,
+          "Confusion Matrix": [
+            [
+              249,
+              42
+            ],
+            [
+              3,
+              101
+            ]
+          ],
+          "Classification Report": {
+            "0": {
+              "precision": 0.9880952380952381,
+              "recall": 0.8556701030927835,
+              "f1-score": 0.9171270718232044,
+              "support": 291.0
+            },
+            "1": {
+              "precision": 0.7062937062937062,
+              "recall": 0.9711538461538461,
+              "f1-score": 0.8178137651821862,
+              "support": 104.0
+            },
+            "accuracy": 0.8860759493670886,
+            "macro avg": {
+              "precision": 0.8471944721944722,
+              "recall": 0.9134119746233148,
+              "f1-score": 0.8674704185026954,
+              "support": 395.0
+            },
+            "weighted avg": {
+              "precision": 0.9138993917474929,
+              "recall": 0.8860759493670886,
+              "f1-score": 0.8909787581759492,
+              "support": 395.0
+            }
+          },
+          "EER_threshold": 0.6720969811081886,
+          "Acc@EER": 0.9215189873417722,
+          "TPR@FPR=1%": 0.4807692307692308,
+          "TPR@FPR=0.1%": 0.27884615384615385,
+          "Accuracy": 0.8860759493670886
+        },
+        "SadTalk": {
+          "AUROC": 0.978540615632083,
+          "AP": 0.9313019980822816,
+          "Accuracy@0.50": 0.8883116883116883,
+          "Confusion Matrix": [
+            [
+              249,
+              42
+            ],
+            [
+              1,
+              93
+            ]
+          ],
+          "Classification Report": {
+            "0": {
+              "precision": 0.996,
+              "recall": 0.8556701030927835,
+              "f1-score": 0.920517560073937,
+              "support": 291.0
+            },
+            "1": {
+              "precision": 0.6888888888888889,
+              "recall": 0.9893617021276596,
+              "f1-score": 0.812227074235808,
+              "support": 94.0
+            },
+            "accuracy": 0.8883116883116883,
+            "macro avg": {
+              "precision": 0.8424444444444444,
+              "recall": 0.9225159026102215,
+              "f1-score": 0.8663723171548725,
+              "support": 385.0
+            },
+            "weighted avg": {
+              "precision": 0.9210170274170275,
+              "recall": 0.8883116883116883,
+              "f1-score": 0.8940778050900822,
+              "support": 385.0
+            }
+          },
+          "EER_threshold": 0.6858754555384318,
+          "Acc@EER": 0.9246753246753247,
+          "TPR@FPR=1%": 0.48936170212765956,
+          "TPR@FPR=0.1%": 0.3191489361702128,
+          "Accuracy": 0.8883116883116883
+        }
+      },
+      "fairness_overall": {
+        "gender": {
+          "F_FPR": 6.235238545111006,
+          "F_MEO": 12.470477090222012,
+          "F_DP": 3.9051760913874025,
+          "F_OAE": 2.2793525145755336,
+          "groups": {
+            "Female": {
+              "n": 289,
+              "fpr": 0.20689655172413793,
+              "tpr": 1.0,
+              "acc": 0.8961937716262975,
+              "dp": 0.6020761245674741
+            },
+            "Male": {
+              "n": 292,
+              "fpr": 0.0821917808219178,
+              "tpr": 0.9657534246575342,
+              "acc": 0.9417808219178082,
+              "dp": 0.523972602739726
+            }
+          }
+        },
+        "race4": {
+          "F_FPR": 6.769850575850797,
+          "F_MEO": 16.627543035993742,
+          "F_DP": 2.418668958109545,
+          "F_OAE": 3.900207180603046,
+          "groups": {
+            "Asian": {
+              "n": 143,
+              "fpr": 0.19444444444444445,
+              "tpr": 0.9859154929577465,
+              "acc": 0.8951048951048951,
+              "dp": 0.5874125874125874
+            },
+            "Black": {
+              "n": 146,
+              "fpr": 0.16216216216216217,
+              "tpr": 0.9722222222222222,
+              "acc": 0.9041095890410958,
+              "dp": 0.5616438356164384
+            },
+            "Indian": {
+              "n": 145,
+              "fpr": 0.028169014084507043,
+              "tpr": 1.0,
+              "acc": 0.9862068965517241,
+              "dp": 0.5241379310344828
+            },
+            "White": {
+              "n": 147,
+              "fpr": 0.1891891891891892,
+              "tpr": 0.9726027397260274,
+              "acc": 0.891156462585034,
+              "dp": 0.5782312925170068
+            }
+          }
+        },
+        "age_group": {
+          "F_FPR": 10.871458596442137,
+          "F_MEO": 31.335034013605444,
+          "F_DP": 5.353741021611331,
+          "F_OAE": 5.606466598928446,
+          "groups": {
+            "0-9": {
+              "n": 96,
+              "fpr": 0.041666666666666664,
+              "tpr": 0.9791666666666666,
+              "acc": 0.96875,
+              "dp": 0.5104166666666666
+            },
+            "10-19": {
+              "n": 97,
+              "fpr": 0.04081632653061224,
+              "tpr": 1.0,
+              "acc": 0.979381443298969,
+              "dp": 0.5154639175257731
+            },
+            "20-29": {
+              "n": 96,
+              "fpr": 0.08333333333333333,
+              "tpr": 0.9791666666666666,
+              "acc": 0.9479166666666666,
+              "dp": 0.53125
+            },
+            "30-39": {
+              "n": 98,
+              "fpr": 0.16326530612244897,
+              "tpr": 0.9795918367346939,
+              "acc": 0.9081632653061225,
+              "dp": 0.5714285714285714
+            },
+            "40-49": {
+              "n": 98,
+              "fpr": 0.1836734693877551,
+              "tpr": 0.9795918367346939,
+              "acc": 0.8979591836734694,
+              "dp": 0.5816326530612245
+            },
+            "50+": {
+              "n": 96,
+              "fpr": 0.3541666666666667,
+              "tpr": 0.9791666666666666,
+              "acc": 0.8125,
+              "dp": 0.6666666666666666
+            }
+          }
+        }
+      }
+    }
+  ]
+}

robustness/sweepv2.log

@@ -0,0 +1,40 @@
+nohup: ignoring input
+===== baseline (no-op, level=1) =====
+[robustness] perturbation=gaussian_noise level=1 param=0.0 ckpt=checkpoints/lipfd_train/model_epoch_10.pth
+[OK] Strict checkpoint match: all 770 keys consumed.
+
+  warnings.warn(
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+
                                                                    
+[gaussian_noise L1]  overall_clip AUROC=0.9710 AP=0.9624 Acc=0.9053 Acc@EER=0.9191 TPR@1%FPR=0.6103 TPR@0.1%FPR=0.0931  (n_clips=581 n_samples=11610)
+  [EDTalk+Real] AUROC=0.9696 AP=0.8996 Acc=0.8799 Acc@EER=0.9217
+  [Float+Real] AUROC=0.9706 AP=0.9096 Acc=0.8810 Acc@EER=0.9241
+  [SadTalk+Real] AUROC=0.9728 AP=0.8992 Acc=0.8857 Acc@EER=0.9091
+  fairness[gender] F_FPR=2.45 F_MEO=4.91 F_DP=1.14 F_OAE=1.25
+  fairness[race4] F_FPR=5.13 F_MEO=13.81 F_DP=1.99 F_OAE=3.10
+  fairness[age_group] F_FPR=9.97 F_MEO=29.29 F_DP=5.91 F_OAE=4.33
+
+>>> Appended run to /apdcephfs_gy4/share_303628665/joywu/research/LipFD/robustnessv2/runs.json
+
                                                                      
+[color_saturation L2]  overall_clip AUROC=0.9337 AP=0.9299 Acc=0.8451 Acc@EER=0.8520 TPR@1%FPR=0.5069 TPR@0.1%FPR=0.0345  (n_clips=581 n_samples=11610)
+  [EDTalk+Real] AUROC=0.9379 AP=0.8596 Acc=0.8668 Acc@EER=0.8433
+  [Float+Real] AUROC=0.9299 AP=0.8253 Acc=0.8430 Acc@EER=0.8456
+  [SadTalk+Real] AUROC=0.9338 AP=0.8289 Acc=0.8623 Acc@EER=0.8597
+  fairness[gender] F_FPR=1.42 F_MEO=6.65 F_DP=2.31 F_OAE=0.95
+  fairness[race4] F_FPR=4.88 F_MEO=13.29 F_DP=2.17 F_OAE=2.68
+  fairness[age_group] F_FPR=8.98 F_MEO=29.17 F_DP=5.14 F_OAE=4.95
+
+>>> Appended run to /apdcephfs_gy4/share_303628665/joywu/research/LipFD/robustnessv2/runs.json

robustness/test_clean.json

@@ -0,0 +1,314 @@
+{
+  "ckpt": "/apdcephfs_gy4/share_303628665/joywu/research/LipFD/checkpoints/lipfd_train/model_epoch_5.pth",
+  "saved_at": "2026-06-25 21:18:28",
+  "load_info": {
+    "missing_count": 0,
+    "unexpected_count": 0
+  },
+  "real_list_path": "datasets/FairTalking-Bench/test/0_real",
+  "fake_list_path": "datasets/FairTalking-Bench/test/1_fake",
+  "demographics_csv": "/apdcephfs_gy4/share_303628665/joywu/research/test.csv",
+  "seed": 42,
+  "n_clips": 581,
+  "n_samples": 11610,
+  "overall_clip": {
+    "AUROC": 0.9333807323142551,
+    "AP": 0.9327153892461657,
+    "Accuracy@0.50": 0.8450946643717728,
+    "Confusion Matrix": [
+      [
+        242,
+        49
+      ],
+      [
+        41,
+        249
+      ]
+    ],
+    "Classification Report": {
+      "0": {
+        "precision": 0.8551236749116607,
+        "recall": 0.8316151202749141,
+        "f1-score": 0.843205574912892,
+        "support": 291.0
+      },
+      "1": {
+        "precision": 0.8355704697986577,
+        "recall": 0.8586206896551725,
+        "f1-score": 0.8469387755102041,
+        "support": 290.0
+      },
+      "accuracy": 0.8450946643717728,
+      "macro avg": {
+        "precision": 0.8453470723551593,
+        "recall": 0.8451179049650432,
+        "f1-score": 0.8450721752115481,
+        "support": 581.0
+      },
+      "weighted avg": {
+        "precision": 0.8453638995540517,
+        "recall": 0.8450946643717728,
+        "f1-score": 0.8450689624743731,
+        "support": 581.0
+      }
+    },
+    "EER_threshold": 0.5060416251420975,
+    "Acc@EER": 0.8433734939759037,
+    "TPR@FPR=1%": 0.5137931034482759,
+    "TPR@FPR=0.1%": 0.0896551724137931,
+    "Accuracy": 0.8450946643717728
+  },
+  "per_fake_vs_real": {
+    "EDTalk": {
+      "AUROC": 0.9378828626923652,
+      "AP": 0.8637361754335757,
+      "Accuracy@0.50": 0.8407310704960835,
+      "Confusion Matrix": [
+        [
+          242,
+          49
+        ],
+        [
+          12,
+          80
+        ]
+      ],
+      "Classification Report": {
+        "0": {
+          "precision": 0.952755905511811,
+          "recall": 0.8316151202749141,
+          "f1-score": 0.8880733944954128,
+          "support": 291.0
+        },
+        "1": {
+          "precision": 0.6201550387596899,
+          "recall": 0.8695652173913043,
+          "f1-score": 0.7239819004524886,
+          "support": 92.0
+        },
+        "accuracy": 0.8407310704960835,
+        "macro avg": {
+          "precision": 0.7864554721357504,
+          "recall": 0.8505901688331092,
+          "f1-score": 0.8060276474739507,
+          "support": 383.0
+        },
+        "weighted avg": {
+          "precision": 0.8728622247254006,
+          "recall": 0.8407310704960835,
+          "f1-score": 0.8486571609394101,
+          "support": 383.0
+        }
+      },
+      "EER_threshold": 0.5170380979776382,
+      "Acc@EER": 0.8746736292428199,
+      "TPR@FPR=1%": 0.5760869565217391,
+      "TPR@FPR=0.1%": 0.10869565217391304,
+      "Accuracy": 0.8407310704960835
+    },
+    "Float": {
+      "AUROC": 0.9278680941052074,
+      "AP": 0.8317222383016976,
+      "Accuracy@0.50": 0.8354430379746836,
+      "Confusion Matrix": [
+        [
+          242,
+          49
+        ],
+        [
+          16,
+          88
+        ]
+      ],
+      "Classification Report": {
+        "0": {
+          "precision": 0.937984496124031,
+          "recall": 0.8316151202749141,
+          "f1-score": 0.8816029143897997,
+          "support": 291.0
+        },
+        "1": {
+          "precision": 0.6423357664233577,
+          "recall": 0.8461538461538461,
+          "f1-score": 0.7302904564315352,
+          "support": 104.0
+        },
+        "accuracy": 0.8354430379746836,
+        "macro avg": {
+          "precision": 0.7901601312736943,
+          "recall": 0.8388844832143801,
+          "f1-score": 0.8059466854106674,
+          "support": 395.0
+        },
+        "weighted avg": {
+          "precision": 0.8601428052661323,
+          "recall": 0.8354430379746836,
+          "f1-score": 0.841763684952687,
+          "support": 395.0
+        }
+      },
+      "EER_threshold": 0.5007072478532791,
+      "Acc@EER": 0.8379746835443038,
+      "TPR@FPR=1%": 0.46153846153846156,
+      "TPR@FPR=0.1%": 0.07692307692307693,
+      "Accuracy": 0.8354430379746836
+    },
+    "SadTalk": {
+      "AUROC": 0.9350734810265409,
+      "AP": 0.8440944635739278,
+      "Accuracy@0.50": 0.8389610389610389,
+      "Confusion Matrix": [
+        [
+          242,
+          49
+        ],
+        [
+          13,
+          81
+        ]
+      ],
+      "Classification Report": {
+        "0": {
+          "precision": 0.9490196078431372,
+          "recall": 0.8316151202749141,
+          "f1-score": 0.8864468864468865,
+          "support": 291.0
+        },
+        "1": {
+          "precision": 0.6230769230769231,
+          "recall": 0.8617021276595744,
+          "f1-score": 0.7232142857142857,
+          "support": 94.0
+        },
+        "accuracy": 0.8389610389610389,
+        "macro avg": {
+          "precision": 0.7860482654600301,
+          "recall": 0.8466586239672442,
+          "f1-score": 0.8048305860805861,
+          "support": 385.0
+        },
+        "weighted avg": {
+          "precision": 0.86943879649762,
+          "recall": 0.8389610389610389,
+          "f1-score": 0.8465926930212644,
+          "support": 385.0
+        }
+      },
+      "EER_threshold": 0.5093957483768463,
+      "Acc@EER": 0.8519480519480519,
+      "TPR@FPR=1%": 0.5106382978723404,
+      "TPR@FPR=0.1%": 0.0851063829787234,
+      "Accuracy": 0.8389610389610389
+    }
+  },
+  "fairness_overall": {
+    "gender": {
+      "F_FPR": 1.776098252243742,
+      "F_MEO": 3.552196504487484,
+      "F_DP": 1.297577854671278,
+      "F_OAE": 0.42423093330805073,
+      "groups": {
+        "Female": {
+          "n": 289,
+          "fpr": 0.18620689655172415,
+          "tpr": 0.8680555555555556,
+          "acc": 0.8408304498269896,
+          "dp": 0.5259515570934256
+        },
+        "Male": {
+          "n": 292,
+          "fpr": 0.1506849315068493,
+          "tpr": 0.8493150684931506,
+          "acc": 0.8493150684931506,
+          "dp": 0.5
+        }
+      }
+    },
+    "race4": {
+      "F_FPR": 7.01785844183937,
+      "F_MEO": 19.366197183098592,
+      "F_DP": 1.852662982397705,
+      "F_OAE": 4.772497070437377,
+      "groups": {
+        "Asian": {
+          "n": 143,
+          "fpr": 0.25,
+          "tpr": 0.8169014084507042,
+          "acc": 0.7832167832167832,
+          "dp": 0.5314685314685315
+        },
+        "Black": {
+          "n": 146,
+          "fpr": 0.17567567567567569,
+          "tpr": 0.8611111111111112,
+          "acc": 0.8424657534246576,
+          "dp": 0.5136986301369864
+        },
+        "Indian": {
+          "n": 145,
+          "fpr": 0.056338028169014086,
+          "tpr": 0.8918918918918919,
+          "acc": 0.9172413793103448,
+          "dp": 0.4827586206896552
+        },
+        "White": {
+          "n": 147,
+          "fpr": 0.1891891891891892,
+          "tpr": 0.863013698630137,
+          "acc": 0.8367346938775511,
+          "dp": 0.5238095238095238
+        }
+      }
+    },
+    "age_group": {
+      "F_FPR": 9.584439474572948,
+      "F_MEO": 31.25,
+      "F_DP": 4.933464365664702,
+      "F_OAE": 5.285015605545574,
+      "groups": {
+        "0-9": {
+          "n": 96,
+          "fpr": 0.041666666666666664,
+          "tpr": 0.8125,
+          "acc": 0.8854166666666666,
+          "dp": 0.4270833333333333
+        },
+        "10-19": {
+          "n": 97,
+          "fpr": 0.12244897959183673,
+          "tpr": 0.875,
+          "acc": 0.8762886597938144,
+          "dp": 0.4948453608247423
+        },
+        "20-29": {
+          "n": 96,
+          "fpr": 0.14583333333333334,
+          "tpr": 0.875,
+          "acc": 0.8645833333333334,
+          "dp": 0.5104166666666666
+        },
+        "30-39": {
+          "n": 98,
+          "fpr": 0.14285714285714285,
+          "tpr": 0.9183673469387755,
+          "acc": 0.8877551020408163,
+          "dp": 0.5306122448979592
+        },
+        "40-49": {
+          "n": 98,
+          "fpr": 0.20408163265306123,
+          "tpr": 0.8367346938775511,
+          "acc": 0.8163265306122449,
+          "dp": 0.5204081632653061
+        },
+        "50+": {
+          "n": 96,
+          "fpr": 0.3541666666666667,
+          "tpr": 0.8333333333333334,
+          "acc": 0.7395833333333334,
+          "dp": 0.59375
+        }
+      }
+    }
+  }
+}

robustnessv2/runs.json

@@ -0,0 +1,638 @@
+{
+  "runs": [
+    {
+      "ckpt": "checkpoints/lipfd_train/model_epoch_5.pth",
+      "saved_at": "2026-06-25 21:26:12",
+      "load_info": {
+        "missing_count": 0,
+        "unexpected_count": 0
+      },
+      "real_list_path": "datasets/FairTalking-Bench/test/0_real",
+      "fake_list_path": "datasets/FairTalking-Bench/test/1_fake",
+      "demographics_csv": "/apdcephfs_gy4/share_303628665/joywu/research/test.csv",
+      "seed": 42,
+      "perturbation": "color_saturation",
+      "level": 2,
+      "param": 0.8,
+      "n_clips": 581,
+      "n_samples": 11610,
+      "overall_clip": {
+        "AUROC": 0.9336769759450173,
+        "AP": 0.9299403760888295,
+        "Accuracy@0.50": 0.8450946643717728,
+        "Confusion Matrix": [
+          [
+            253,
+            38
+          ],
+          [
+            52,
+            238
+          ]
+        ],
+        "Classification Report": {
+          "0": {
+            "precision": 0.8295081967213115,
+            "recall": 0.8694158075601375,
+            "f1-score": 0.8489932885906042,
+            "support": 291.0
+          },
+          "1": {
+            "precision": 0.8623188405797102,
+            "recall": 0.8206896551724138,
+            "f1-score": 0.8409893992932863,
+            "support": 290.0
+          },
+          "accuracy": 0.8450946643717728,
+          "macro avg": {
+            "precision": 0.8459135186505109,
+            "recall": 0.8450527313662757,
+            "f1-score": 0.8449913439419452,
+            "support": 581.0
+          },
+          "weighted avg": {
+            "precision": 0.8458852822960716,
+            "recall": 0.8450946643717728,
+            "f1-score": 0.8449982319706004,
+            "support": 581.0
+          }
+        },
+        "EER_threshold": 0.49212807714939116,
+        "Acc@EER": 0.8519793459552496,
+        "TPR@FPR=1%": 0.506896551724138,
+        "TPR@FPR=0.1%": 0.034482758620689655,
+        "Accuracy": 0.8450946643717728
+      },
+      "per_fake_vs_real": {
+        "EDTalk": {
+          "AUROC": 0.9378828626923652,
+          "AP": 0.8595528671515583,
+          "Accuracy@0.50": 0.8668407310704961,
+          "Confusion Matrix": [
+            [
+              253,
+              38
+            ],
+            [
+              13,
+              79
+            ]
+          ],
+          "Classification Report": {
+            "0": {
+              "precision": 0.9511278195488722,
+              "recall": 0.8694158075601375,
+              "f1-score": 0.9084380610412927,
+              "support": 291.0
+            },
+            "1": {
+              "precision": 0.6752136752136753,
+              "recall": 0.8586956521739131,
+              "f1-score": 0.7559808612440192,
+              "support": 92.0
+            },
+            "accuracy": 0.8668407310704961,
+            "macro avg": {
+              "precision": 0.8131707473812737,
+              "recall": 0.8640557298670253,
+              "f1-score": 0.8322094611426559,
+              "support": 383.0
+            },
+            "weighted avg": {
+              "precision": 0.8848507927111747,
+              "recall": 0.8668407310704961,
+              "f1-score": 0.8718164882440363,
+              "support": 383.0
+            }
+          },
+          "EER_threshold": 0.4876908928155899,
+          "Acc@EER": 0.8433420365535248,
+          "TPR@FPR=1%": 0.5760869565217391,
+          "TPR@FPR=0.1%": 0.06521739130434782,
+          "Accuracy": 0.8668407310704961
+        },
+        "Float": {
+          "AUROC": 0.9298506476341527,
+          "AP": 0.8253371406949079,
+          "Accuracy@0.50": 0.8430379746835444,
+          "Confusion Matrix": [
+            [
+              253,
+              38
+            ],
+            [
+              24,
+              80
+            ]
+          ],
+          "Classification Report": {
+            "0": {
+              "precision": 0.9133574007220217,
+              "recall": 0.8694158075601375,
+              "f1-score": 0.8908450704225351,
+              "support": 291.0
+            },
+            "1": {
+              "precision": 0.6779661016949152,
+              "recall": 0.7692307692307693,
+              "f1-score": 0.7207207207207208,
+              "support": 104.0
+            },
+            "accuracy": 0.8430379746835444,
+            "macro avg": {
+              "precision": 0.7956617512084685,
+              "recall": 0.8193232883954533,
+              "f1-score": 0.805782895571628,
+              "support": 395.0
+            },
+            "weighted avg": {
+              "precision": 0.851380957433872,
+              "recall": 0.8430379746835444,
+              "f1-score": 0.846052836576994,
+              "support": 395.0
+            }
+          },
+          "EER_threshold": 0.49075316786766054,
+          "Acc@EER": 0.8455696202531645,
+          "TPR@FPR=1%": 0.4519230769230769,
+          "TPR@FPR=0.1%": 0.028846153846153848,
+          "Accuracy": 0.8430379746835444
+        },
+        "SadTalk": {
+          "AUROC": 0.9337939606638883,
+          "AP": 0.8288933459986066,
+          "Accuracy@0.50": 0.8623376623376623,
+          "Confusion Matrix": [
+            [
+              253,
+              38
+            ],
+            [
+              15,
+              79
+            ]
+          ],
+          "Classification Report": {
+            "0": {
+              "precision": 0.9440298507462687,
+              "recall": 0.8694158075601375,
+              "f1-score": 0.9051878354203937,
+              "support": 291.0
+            },
+            "1": {
+              "precision": 0.6752136752136753,
+              "recall": 0.8404255319148937,
+              "f1-score": 0.7488151658767773,
+              "support": 94.0
+            },
+            "accuracy": 0.8623376623376623,
+            "macro avg": {
+              "precision": 0.809621762979972,
+              "recall": 0.8549206697375156,
+              "f1-score": 0.8270015006485856,
+              "support": 385.0
+            },
+            "weighted avg": {
+              "precision": 0.8783968104863626,
+              "recall": 0.8623376623376623,
+              "f1-score": 0.8670085342850693,
+              "support": 385.0
+            }
+          },
+          "EER_threshold": 0.49250459372997285,
+          "Acc@EER": 0.8597402597402597,
+          "TPR@FPR=1%": 0.5,
+          "TPR@FPR=0.1%": 0.010638297872340425,
+          "Accuracy": 0.8623376623376623
+        }
+      },
+      "fairness_overall": {
+        "gender": {
+          "F_FPR": 1.4194615021256505,
+          "F_MEO": 6.649543378995427,
+          "F_DP": 2.310755083661184,
+          "F_OAE": 0.9527420960326105,
+          "groups": {
+            "Female": {
+              "n": 289,
+              "fpr": 0.14482758620689656,
+              "tpr": 0.8541666666666666,
+              "acc": 0.8546712802768166,
+              "dp": 0.4982698961937716
+            },
+            "Male": {
+              "n": 292,
+              "fpr": 0.11643835616438356,
+              "tpr": 0.7876712328767124,
+              "acc": 0.8356164383561644,
+              "dp": 0.4520547945205479
+            }
+          }
+        },
+        "race4": {
+          "F_FPR": 4.878132134683478,
+          "F_MEO": 13.285116102017511,
+          "F_DP": 2.1747435496448455,
+          "F_OAE": 2.679472364199921,
+          "groups": {
+            "Asian": {
+              "n": 143,
+              "fpr": 0.1527777777777778,
+              "tpr": 0.8028169014084507,
+              "acc": 0.8251748251748252,
+              "dp": 0.4755244755244755
+            },
+            "Black": {
+              "n": 146,
+              "fpr": 0.12162162162162163,
+              "tpr": 0.8055555555555556,
+              "acc": 0.8424657534246576,
+              "dp": 0.4589041095890411
+            },
+            "Indian": {
+              "n": 145,
+              "fpr": 0.056338028169014086,
+              "tpr": 0.8378378378378378,
+              "acc": 0.8896551724137931,
+              "dp": 0.45517241379310347
+            },
+            "White": {
+              "n": 147,
+              "fpr": 0.1891891891891892,
+              "tpr": 0.8356164383561644,
+              "acc": 0.8231292517006803,
+              "dp": 0.5102040816326531
+            }
+          }
+        },
+        "age_group": {
+          "F_FPR": 8.981716988241686,
+          "F_MEO": 29.166666666666668,
+          "F_DP": 5.135692464910353,
+          "F_OAE": 4.948782010229553,
+          "groups": {
+            "0-9": {
+              "n": 96,
+              "fpr": 0.020833333333333332,
+              "tpr": 0.75,
+              "acc": 0.8645833333333334,
+              "dp": 0.3854166666666667
+            },
+            "10-19": {
+              "n": 97,
+              "fpr": 0.10204081632653061,
+              "tpr": 0.875,
+              "acc": 0.8865979381443299,
+              "dp": 0.4845360824742268
+            },
+            "20-29": {
+              "n": 96,
+              "fpr": 0.08333333333333333,
+              "tpr": 0.8333333333333334,
+              "acc": 0.875,
+              "dp": 0.4583333333333333
+            },
+            "30-39": {
+              "n": 98,
+              "fpr": 0.14285714285714285,
+              "tpr": 0.8775510204081632,
+              "acc": 0.8673469387755102,
+              "dp": 0.5102040816326531
+            },
+            "40-49": {
+              "n": 98,
+              "fpr": 0.12244897959183673,
+              "tpr": 0.7959183673469388,
+              "acc": 0.8367346938775511,
+              "dp": 0.45918367346938777
+            },
+            "50+": {
+              "n": 96,
+              "fpr": 0.3125,
+              "tpr": 0.7916666666666666,
+              "acc": 0.7395833333333334,
+              "dp": 0.5520833333333334
+            }
+          }
+        }
+      }
+    },
+    {
+      "ckpt": "checkpoints/lipfd_train/model_epoch_10.pth",
+      "saved_at": "2026-06-25 21:27:17",
+      "load_info": {
+        "missing_count": 0,
+        "unexpected_count": 0
+      },
+      "real_list_path": "datasets/FairTalking-Bench/test/0_real",
+      "fake_list_path": "datasets/FairTalking-Bench/test/1_fake",
+      "demographics_csv": "/apdcephfs_gy4/share_303628665/joywu/research/test.csv",
+      "seed": 42,
+      "perturbation": "gaussian_noise",
+      "level": 1,
+      "param": 0.0,
+      "n_clips": 581,
+      "n_samples": 11610,
+      "overall_clip": {
+        "AUROC": 0.9710036734210215,
+        "AP": 0.9624283772952034,
+        "Accuracy@0.50": 0.9053356282271945,
+        "Confusion Matrix": [
+          [
+            250,
+            41
+          ],
+          [
+            14,
+            276
+          ]
+        ],
+        "Classification Report": {
+          "0": {
+            "precision": 0.946969696969697,
+            "recall": 0.8591065292096219,
+            "f1-score": 0.900900900900901,
+            "support": 291.0
+          },
+          "1": {
+            "precision": 0.8706624605678234,
+            "recall": 0.9517241379310345,
+            "f1-score": 0.9093904448105437,
+            "support": 290.0
+          },
+          "accuracy": 0.9053356282271945,
+          "macro avg": {
+            "precision": 0.9088160787687602,
+            "recall": 0.9054153335703282,
+            "f1-score": 0.9051456728557223,
+            "support": 581.0
+          },
+          "weighted avg": {
+            "precision": 0.908881747646903,
+            "recall": 0.9053356282271945,
+            "f1-score": 0.9051383668798965,
+            "support": 581.0
+          }
+        },
+        "EER_threshold": 0.5720391809940338,
+        "Acc@EER": 0.919104991394148,
+        "TPR@FPR=1%": 0.6103448275862069,
+        "TPR@FPR=0.1%": 0.09310344827586207,
+        "Accuracy": 0.9053356282271945
+      },
+      "per_fake_vs_real": {
+        "EDTalk": {
+          "AUROC": 0.9696324518153294,
+          "AP": 0.8995520129228476,
+          "Accuracy@0.50": 0.8798955613577023,
+          "Confusion Matrix": [
+            [
+              250,
+              41
+            ],
+            [
+              5,
+              87
+            ]
+          ],
+          "Classification Report": {
+            "0": {
+              "precision": 0.9803921568627451,
+              "recall": 0.8591065292096219,
+              "f1-score": 0.9157509157509157,
+              "support": 291.0
+            },
+            "1": {
+              "precision": 0.6796875,
+              "recall": 0.9456521739130435,
+              "f1-score": 0.7909090909090909,
+              "support": 92.0
+            },
+            "accuracy": 0.8798955613577023,
+            "macro avg": {
+              "precision": 0.8300398284313726,
+              "recall": 0.9023793515613328,
+              "f1-score": 0.8533300033300033,
+              "support": 383.0
+            },
+            "weighted avg": {
+              "precision": 0.9081602288434956,
+              "recall": 0.8798955613577023,
+              "f1-score": 0.885762801167501,
+              "support": 383.0
+            }
+          },
+          "EER_threshold": 0.5730031251907348,
+          "Acc@EER": 0.9216710182767625,
+          "TPR@FPR=1%": 0.6304347826086957,
+          "TPR@FPR=0.1%": 0.09782608695652174,
+          "Accuracy": 0.8798955613577023
+        },
+        "Float": {
+          "AUROC": 0.9705921226539783,
+          "AP": 0.9096209876444205,
+          "Accuracy@0.50": 0.8810126582278481,
+          "Confusion Matrix": [
+            [
+              250,
+              41
+            ],
+            [
+              6,
+              98
+            ]
+          ],
+          "Classification Report": {
+            "0": {
+              "precision": 0.9765625,
+              "recall": 0.8591065292096219,
+              "f1-score": 0.9140767824497257,
+              "support": 291.0
+            },
+            "1": {
+              "precision": 0.7050359712230215,
+              "recall": 0.9423076923076923,
+              "f1-score": 0.8065843621399178,
+              "support": 104.0
+            },
+            "accuracy": 0.8810126582278481,
+            "macro avg": {
+              "precision": 0.8407992356115108,
+              "recall": 0.9007071107586571,
+              "f1-score": 0.8603305722948218,
+              "support": 395.0
+            },
+            "weighted avg": {
+              "precision": 0.9050719709042893,
+              "recall": 0.8810126582278481,
+              "f1-score": 0.8857749806466372,
+              "support": 395.0
+            }
+          },
+          "EER_threshold": 0.5760782033205032,
+          "Acc@EER": 0.9240506329113924,
+          "TPR@FPR=1%": 0.5769230769230769,
+          "TPR@FPR=0.1%": 0.10576923076923077,
+          "Accuracy": 0.8810126582278481
+        },
+        "SadTalk": {
+          "AUROC": 0.9728010528624699,
+          "AP": 0.899161539979738,
+          "Accuracy@0.50": 0.8857142857142857,
+          "Confusion Matrix": [
+            [
+              250,
+              41
+            ],
+            [
+              3,
+              91
+            ]
+          ],
+          "Classification Report": {
+            "0": {
+              "precision": 0.9881422924901185,
+              "recall": 0.8591065292096219,
+              "f1-score": 0.9191176470588235,
+              "support": 291.0
+            },
+            "1": {
+              "precision": 0.6893939393939394,
+              "recall": 0.9680851063829787,
+              "f1-score": 0.8053097345132745,
+              "support": 94.0
+            },
+            "accuracy": 0.8857142857142857,
+            "macro avg": {
+              "precision": 0.838768115942029,
+              "recall": 0.9135958177963004,
+              "f1-score": 0.8622136907860489,
+              "support": 385.0
+            },
+            "weighted avg": {
+              "precision": 0.9152011361497527,
+              "recall": 0.8857142857142857,
+              "f1-score": 0.8913307800996504,
+              "support": 385.0
+            }
+          },
+          "EER_threshold": 0.5509923934936524,
+          "Acc@EER": 0.9090909090909091,
+          "TPR@FPR=1%": 0.6276595744680851,
+          "TPR@FPR=0.1%": 0.07446808510638298,
+          "Accuracy": 0.8857142857142857
+        }
+      },
+      "fairness_overall": {
+        "gender": {
+          "F_FPR": 2.4539442607463395,
+          "F_MEO": 4.907888521492679,
+          "F_DP": 1.142342513153527,
+          "F_OAE": 1.2537327582120672,
+          "groups": {
+            "Female": {
+              "n": 289,
+              "fpr": 0.16551724137931034,
+              "tpr": 0.9513888888888888,
+              "acc": 0.8927335640138409,
+              "dp": 0.5570934256055363
+            },
+            "Male": {
+              "n": 292,
+              "fpr": 0.11643835616438356,
+              "tpr": 0.952054794520548,
+              "acc": 0.9178082191780822,
+              "dp": 0.5342465753424658
+            }
+          }
+        },
+        "race4": {
+          "F_FPR": 5.130508985141023,
+          "F_MEO": 13.810641627543035,
+          "F_DP": 1.991767150590385,
+          "F_OAE": 3.099992139753374,
+          "groups": {
+            "Asian": {
+              "n": 143,
+              "fpr": 0.19444444444444445,
+              "tpr": 0.9295774647887324,
+              "acc": 0.8671328671328671,
+              "dp": 0.5594405594405595
+            },
+            "Black": {
+              "n": 146,
+              "fpr": 0.16216216216216217,
+              "tpr": 0.9861111111111112,
+              "acc": 0.910958904109589,
+              "dp": 0.5684931506849316
+            },
+            "Indian": {
+              "n": 145,
+              "fpr": 0.056338028169014086,
+              "tpr": 0.9594594594594594,
+              "acc": 0.9517241379310345,
+              "dp": 0.5172413793103449
+            },
+            "White": {
+              "n": 147,
+              "fpr": 0.14864864864864866,
+              "tpr": 0.9315068493150684,
+              "acc": 0.891156462585034,
+              "dp": 0.5374149659863946
+            }
+          }
+        },
+        "age_group": {
+          "F_FPR": 9.972494132228265,
+          "F_MEO": 29.29421768707483,
+          "F_DP": 5.911077463330453,
+          "F_OAE": 4.3314141493955916,
+          "groups": {
+            "0-9": {
+              "n": 96,
+              "fpr": 0.0625,
+              "tpr": 0.8958333333333334,
+              "acc": 0.9166666666666666,
+              "dp": 0.4791666666666667
+            },
+            "10-19": {
+              "n": 97,
+              "fpr": 0.061224489795918366,
+              "tpr": 0.9583333333333334,
+              "acc": 0.9484536082474226,
+              "dp": 0.5051546391752577
+            },
+            "20-29": {
+              "n": 96,
+              "fpr": 0.10416666666666667,
+              "tpr": 0.9583333333333334,
+              "acc": 0.9270833333333334,
+              "dp": 0.53125
+            },
+            "30-39": {
+              "n": 98,
+              "fpr": 0.12244897959183673,
+              "tpr": 0.9591836734693877,
+              "acc": 0.9183673469387755,
+              "dp": 0.5408163265306123
+            },
+            "40-49": {
+              "n": 98,
+              "fpr": 0.14285714285714285,
+              "tpr": 0.9591836734693877,
+              "acc": 0.9081632653061225,
+              "dp": 0.5510204081632653
+            },
+            "50+": {
+              "n": 96,
+              "fpr": 0.3541666666666667,
+              "tpr": 0.9791666666666666,
+              "acc": 0.8125,
+              "dp": 0.6666666666666666
+            }
+          }
+        }
+      }
+    }
+  ]
+}

robustnessv2/runs.json.20260625_212207.bak

@@ -0,0 +1,321 @@
+{
+  "runs": [
+    {
+      "ckpt": "checkpoints/lipfd_train/model_epoch_5.pth",
+      "saved_at": "2026-06-25 21:20:39",
+      "load_info": {
+        "missing_count": 0,
+        "unexpected_count": 0
+      },
+      "real_list_path": "datasets/FairTalking-Bench/test/0_real",
+      "fake_list_path": "datasets/FairTalking-Bench/test/1_fake",
+      "demographics_csv": "/apdcephfs_gy4/share_303628665/joywu/research/test.csv",
+      "seed": 42,
+      "perturbation": "gaussian_noise",
+      "level": 1,
+      "param": 0.0,
+      "n_clips": 581,
+      "n_samples": 11610,
+      "overall_clip": {
+        "AUROC": 0.9333807323142551,
+        "AP": 0.9327153892461657,
+        "Accuracy@0.50": 0.8450946643717728,
+        "Confusion Matrix": [
+          [
+            242,
+            49
+          ],
+          [
+            41,
+            249
+          ]
+        ],
+        "Classification Report": {
+          "0": {
+            "precision": 0.8551236749116607,
+            "recall": 0.8316151202749141,
+            "f1-score": 0.843205574912892,
+            "support": 291.0
+          },
+          "1": {
+            "precision": 0.8355704697986577,
+            "recall": 0.8586206896551725,
+            "f1-score": 0.8469387755102041,
+            "support": 290.0
+          },
+          "accuracy": 0.8450946643717728,
+          "macro avg": {
+            "precision": 0.8453470723551593,
+            "recall": 0.8451179049650432,
+            "f1-score": 0.8450721752115481,
+            "support": 581.0
+          },
+          "weighted avg": {
+            "precision": 0.8453638995540517,
+            "recall": 0.8450946643717728,
+            "f1-score": 0.8450689624743731,
+            "support": 581.0
+          }
+        },
+        "EER_threshold": 0.5060416251420975,
+        "Acc@EER": 0.8433734939759037,
+        "TPR@FPR=1%": 0.5137931034482759,
+        "TPR@FPR=0.1%": 0.0896551724137931,
+        "Accuracy": 0.8450946643717728
+      },
+      "per_fake_vs_real": {
+        "EDTalk": {
+          "AUROC": 0.9378828626923652,
+          "AP": 0.8637361754335757,
+          "Accuracy@0.50": 0.8407310704960835,
+          "Confusion Matrix": [
+            [
+              242,
+              49
+            ],
+            [
+              12,
+              80
+            ]
+          ],
+          "Classification Report": {
+            "0": {
+              "precision": 0.952755905511811,
+              "recall": 0.8316151202749141,
+              "f1-score": 0.8880733944954128,
+              "support": 291.0
+            },
+            "1": {
+              "precision": 0.6201550387596899,
+              "recall": 0.8695652173913043,
+              "f1-score": 0.7239819004524886,
+              "support": 92.0
+            },
+            "accuracy": 0.8407310704960835,
+            "macro avg": {
+              "precision": 0.7864554721357504,
+              "recall": 0.8505901688331092,
+              "f1-score": 0.8060276474739507,
+              "support": 383.0
+            },
+            "weighted avg": {
+              "precision": 0.8728622247254006,
+              "recall": 0.8407310704960835,
+              "f1-score": 0.8486571609394101,
+              "support": 383.0
+            }
+          },
+          "EER_threshold": 0.5170380979776382,
+          "Acc@EER": 0.8746736292428199,
+          "TPR@FPR=1%": 0.5760869565217391,
+          "TPR@FPR=0.1%": 0.10869565217391304,
+          "Accuracy": 0.8407310704960835
+        },
+        "Float": {
+          "AUROC": 0.9278680941052074,
+          "AP": 0.8317222383016976,
+          "Accuracy@0.50": 0.8354430379746836,
+          "Confusion Matrix": [
+            [
+              242,
+              49
+            ],
+            [
+              16,
+              88
+            ]
+          ],
+          "Classification Report": {
+            "0": {
+              "precision": 0.937984496124031,
+              "recall": 0.8316151202749141,
+              "f1-score": 0.8816029143897997,
+              "support": 291.0
+            },
+            "1": {
+              "precision": 0.6423357664233577,
+              "recall": 0.8461538461538461,
+              "f1-score": 0.7302904564315352,
+              "support": 104.0
+            },
+            "accuracy": 0.8354430379746836,
+            "macro avg": {
+              "precision": 0.7901601312736943,
+              "recall": 0.8388844832143801,
+              "f1-score": 0.8059466854106674,
+              "support": 395.0
+            },
+            "weighted avg": {
+              "precision": 0.8601428052661323,
+              "recall": 0.8354430379746836,
+              "f1-score": 0.841763684952687,
+              "support": 395.0
+            }
+          },
+          "EER_threshold": 0.5007072478532791,
+          "Acc@EER": 0.8379746835443038,
+          "TPR@FPR=1%": 0.46153846153846156,
+          "TPR@FPR=0.1%": 0.07692307692307693,
+          "Accuracy": 0.8354430379746836
+        },
+        "SadTalk": {
+          "AUROC": 0.9350734810265409,
+          "AP": 0.8440944635739278,
+          "Accuracy@0.50": 0.8389610389610389,
+          "Confusion Matrix": [
+            [
+              242,
+              49
+            ],
+            [
+              13,
+              81
+            ]
+          ],
+          "Classification Report": {
+            "0": {
+              "precision": 0.9490196078431372,
+              "recall": 0.8316151202749141,
+              "f1-score": 0.8864468864468865,
+              "support": 291.0
+            },
+            "1": {
+              "precision": 0.6230769230769231,
+              "recall": 0.8617021276595744,
+              "f1-score": 0.7232142857142857,
+              "support": 94.0
+            },
+            "accuracy": 0.8389610389610389,
+            "macro avg": {
+              "precision": 0.7860482654600301,
+              "recall": 0.8466586239672442,
+              "f1-score": 0.8048305860805861,
+              "support": 385.0
+            },
+            "weighted avg": {
+              "precision": 0.86943879649762,
+              "recall": 0.8389610389610389,
+              "f1-score": 0.8465926930212644,
+              "support": 385.0
+            }
+          },
+          "EER_threshold": 0.5093957483768463,
+          "Acc@EER": 0.8519480519480519,
+          "TPR@FPR=1%": 0.5106382978723404,
+          "TPR@FPR=0.1%": 0.0851063829787234,
+          "Accuracy": 0.8389610389610389
+        }
+      },
+      "fairness_overall": {
+        "gender": {
+          "F_FPR": 1.776098252243742,
+          "F_MEO": 3.552196504487484,
+          "F_DP": 1.297577854671278,
+          "F_OAE": 0.42423093330805073,
+          "groups": {
+            "Female": {
+              "n": 289,
+              "fpr": 0.18620689655172415,
+              "tpr": 0.8680555555555556,
+              "acc": 0.8408304498269896,
+              "dp": 0.5259515570934256
+            },
+            "Male": {
+              "n": 292,
+              "fpr": 0.1506849315068493,
+              "tpr": 0.8493150684931506,
+              "acc": 0.8493150684931506,
+              "dp": 0.5
+            }
+          }
+        },
+        "race4": {
+          "F_FPR": 7.01785844183937,
+          "F_MEO": 19.366197183098592,
+          "F_DP": 1.852662982397705,
+          "F_OAE": 4.772497070437377,
+          "groups": {
+            "Asian": {
+              "n": 143,
+              "fpr": 0.25,
+              "tpr": 0.8169014084507042,
+              "acc": 0.7832167832167832,
+              "dp": 0.5314685314685315
+            },
+            "Black": {
+              "n": 146,
+              "fpr": 0.17567567567567569,
+              "tpr": 0.8611111111111112,
+              "acc": 0.8424657534246576,
+              "dp": 0.5136986301369864
+            },
+            "Indian": {
+              "n": 145,
+              "fpr": 0.056338028169014086,
+              "tpr": 0.8918918918918919,
+              "acc": 0.9172413793103448,
+              "dp": 0.4827586206896552
+            },
+            "White": {
+              "n": 147,
+              "fpr": 0.1891891891891892,
+              "tpr": 0.863013698630137,
+              "acc": 0.8367346938775511,
+              "dp": 0.5238095238095238
+            }
+          }
+        },
+        "age_group": {
+          "F_FPR": 9.584439474572948,
+          "F_MEO": 31.25,
+          "F_DP": 4.933464365664702,
+          "F_OAE": 5.285015605545574,
+          "groups": {
+            "0-9": {
+              "n": 96,
+              "fpr": 0.041666666666666664,
+              "tpr": 0.8125,
+              "acc": 0.8854166666666666,
+              "dp": 0.4270833333333333
+            },
+            "10-19": {
+              "n": 97,
+              "fpr": 0.12244897959183673,
+              "tpr": 0.875,
+              "acc": 0.8762886597938144,
+              "dp": 0.4948453608247423
+            },
+            "20-29": {
+              "n": 96,
+              "fpr": 0.14583333333333334,
+              "tpr": 0.875,
+              "acc": 0.8645833333333334,
+              "dp": 0.5104166666666666
+            },
+            "30-39": {
+              "n": 98,
+              "fpr": 0.14285714285714285,
+              "tpr": 0.9183673469387755,
+              "acc": 0.8877551020408163,
+              "dp": 0.5306122448979592
+            },
+            "40-49": {
+              "n": 98,
+              "fpr": 0.20408163265306123,
+              "tpr": 0.8367346938775511,
+              "acc": 0.8163265306122449,
+              "dp": 0.5204081632653061
+            },
+            "50+": {
+              "n": 96,
+              "fpr": 0.3541666666666667,
+              "tpr": 0.8333333333333334,
+              "acc": 0.7395833333333334,
+              "dp": 0.59375
+            }
+          }
+        }
+      }
+    }
+  ]
+}

robustnessv4/robustness_table.csv

@@ -0,0 +1,30 @@
+perturbation,level,param,n_clips,AUROC,AP,Accuracy,Acc@EER,TPR@FPR=1%,TPR@FPR=0.1%
+block_wise,2,8,581,0.9706363313188766,0.961842625956055,0.9087779690189329,0.9173838209982789,0.596551724137931,0.09310344827586207
+block_wise,3,16,581,0.9706244815736462,0.9616343179834019,0.9036144578313253,0.9173838209982789,0.5758620689655173,0.06896551724137931
+block_wise,4,24,581,0.9684322787060078,0.9601029786120157,0.8967297762478486,0.9104991394148021,0.5793103448275863,0.07931034482758621
+block_wise,5,32,581,0.9685744756487735,0.9606156625435756,0.9070567986230637,0.9156626506024096,0.5551724137931034,0.10344827586206896
+color_contrast,2,0.85,581,0.9703400876881146,0.9618131893858384,0.8984509466437177,0.9208261617900172,0.503448275862069,0.07931034482758621
+color_contrast,3,1.2,581,0.9726981869889797,0.9663464125394221,0.8967297762478486,0.9122203098106713,0.596551724137931,0.05517241379310345
+color_contrast,4,1.4,581,0.9721649484536082,0.9677725431587463,0.891566265060241,0.9139414802065404,0.5379310344827586,0.12413793103448276
+color_contrast,5,1.6,581,0.9712643678160919,0.969733587406969,0.8812392426850258,0.9139414802065404,0.6344827586206897,0.23448275862068965
+color_saturation,2,0.8,581,0.9709325749496386,0.9625726687169951,0.9104991394148021,0.919104991394148,0.5827586206896552,0.06551724137931035
+color_saturation,3,1.2,581,0.9710866216376348,0.9644582868698658,0.8950086058519794,0.9139414802065404,0.5793103448275863,0.13793103448275862
+color_saturation,4,1.5,581,0.9706363313188766,0.9678130998911674,0.8881239242685026,0.9036144578313253,0.5310344827586206,0.2896551724137931
+color_saturation,5,2.0,581,0.9643322668562626,0.9659882006624247,0.8640275387263339,0.8967297762478486,0.5862068965517241,0.5482758620689655
+gaussian_blur,2,3,581,0.9700793932930442,0.9616367530805014,0.9053356282271945,0.9173838209982789,0.5862068965517241,0.09310344827586207
+gaussian_blur,3,7,581,0.9657779357743809,0.9599197695711028,0.9036144578313253,0.9070567986230637,0.5103448275862069,0.1310344827586207
+gaussian_blur,4,11,581,0.960149306789904,0.9546642897795196,0.8777969018932874,0.8967297762478486,0.4724137931034483,0.12758620689655173
+gaussian_blur,5,15,581,0.9516174902239602,0.947260960348703,0.810671256454389,0.8881239242685026,0.41379310344827586,0.1310344827586207
+gaussian_noise,1,0.0,581,0.9711695698542482,0.963284813670888,0.9070567986230637,0.919104991394148,0.6103448275862069,0.10344827586206896
+gaussian_noise,2,0.001,581,0.9589998815025477,0.9546247005388946,0.8760757314974182,0.8967297762478486,0.3758620689655172,0.2655172413793103
+gaussian_noise,3,0.005,581,0.9300628036497215,0.9246039218517703,0.8347676419965576,0.8519793459552496,0.3137931034482759,0.16896551724137931
+gaussian_noise,4,0.01,581,0.9182723071453963,0.9116952521947262,0.7676419965576592,0.8450946643717728,0.2,0.05862068965517241
+gaussian_noise,5,0.05,581,0.7283445905913023,0.7018203772621896,0.5008605851979346,0.6764199655765921,0.05862068965517241,0.034482758620689655
+jpeg_quality,2,85,581,0.9713828652683967,0.9640729017480663,0.9053356282271945,0.919104991394148,0.6068965517241379,0.09655172413793103
+jpeg_quality,3,70,581,0.9711103211280957,0.9635534900234138,0.9053356282271945,0.9173838209982789,0.6068965517241379,0.10689655172413794
+jpeg_quality,4,50,581,0.971015523166252,0.9622118164633725,0.9053356282271945,0.9208261617900172,0.6137931034482759,0.07241379310344828
+jpeg_quality,5,30,581,0.9702571394715014,0.9600982030270745,0.9018932874354562,0.9139414802065404,0.5793103448275863,0.05862068965517241
+pixelate,2,2,581,0.9672710036734209,0.9609417769511195,0.9036144578313253,0.9104991394148021,0.5310344827586206,0.12413793103448276
+pixelate,3,4,581,0.9586206896551723,0.9525942217545772,0.8657487091222031,0.8932874354561101,0.4586206896551724,0.09655172413793103
+pixelate,4,6,581,0.9445194928309042,0.9409031038006339,0.7521514629948365,0.8657487091222031,0.3758620689655172,0.15172413793103448
+pixelate,5,8,581,0.9223012205237587,0.9204455559793818,0.621342512908778,0.8313253012048193,0.29310344827586204,0.23448275862068965

run_preprocess.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+
+# FT_work 数据集预处理快速开始脚本
+
+echo "=========================================="
+echo "FT_work 数据集预处理流程"
+echo "=========================================="
+
+# 步骤 1: 转换数据集格式
+echo ""
+echo "步骤 1/3: 转换数据集格式"
+echo "将 FT_work 格式转换为 AVLips 格式..."
+python convert_ft_work.py
+
+if [ $? -ne 0 ]; then
+    echo "错误: 数据集转换失败!"
+    exit 1
+fi
+
+echo "✓ 数据集转换完成"
+echo ""
+
+# 步骤 2: 检查转换结果
+echo "步骤 2/3: 检查转换结果"
+echo "检查 AVLips 目录结构..."
+
+if [ ! -d "./AVLips" ]; then
+    echo "错误: AVLips 目录不存在!"
+    exit 1
+fi
+
+real_count=$(ls -1 ./AVLips/0_real/*.mp4 2>/dev/null | wc -l)
+fake_count=$(ls -1 ./AVLips/1_fake/*.mp4 2>/dev/null | wc -l)
+real_audio_count=$(ls -1 ./AVLips/wav/0_real/*.wav 2>/dev/null | wc -l)
+fake_audio_count=$(ls -1 ./AVLips/wav/1_fake/*.wav 2>/dev/null | wc -l)
+
+echo "  真实视频: $real_count 个"
+echo "  假视频: $fake_count 个"
+echo "  真实音频: $real_audio_count 个"
+echo "  假音频: $fake_audio_count 个"
+echo ""
+
+# 步骤 3: 运行预处理
+echo "步骤 3/3: 运行预处理"
+echo "开始提取帧和生成频谱图..."
+echo ""
+
+# 你可以选择使用原版或改进版
+# 原版: python preprocess.py
+# 改进版: python preprocess_improved.py
+
+python preprocess_improved.py
+
+if [ $? -ne 0 ]; then
+    echo "错误: 预处理失败!"
+    exit 1
+fi
+
+echo ""
+echo "=========================================="
+echo "✓ 全部完成!"
+echo "=========================================="
+echo ""
+echo "输出目录: ./datasets/AVLips"
+echo " - 真实样本: ./datasets/AVLips/0_real/"
+echo " - 假样本: ./datasets/AVLips/1_fake/"
+echo ""

run_robustness.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+# run_robustness.sh — sweep all 7 perturbations × 5 levels on the LipFD test set.
+#
+# Note: level=1 is a no-op for every perturbation in SEVERITY, so we only run
+# it once (under "gaussian_noise") and treat that as the clean baseline. The
+# runs.json output appends one entry per (perturbation, level) call.
+
+set -e
+cd /apdcephfs_gy4/share_303628665/joywu/research/LipFD
+
+PYTHON=/opt/conda/envs/LipFD/bin/python
+CKPT=checkpoints/lipfd_train/model_epoch_44.pth
+REAL=datasets/FairTalking-Bench/test/0_real
+FAKE=datasets/FairTalking-Bench/test/1_fake
+CSV=/apdcephfs_gy4/share_303628665/joywu/research/test.csv
+OUT_DIR=/apdcephfs_gy4/share_303628665/joywu/research/LipFD/robustness
+JSON=$OUT_DIR/runs.json
+
+mkdir -p "$OUT_DIR"
+
+PERTURBATIONS=(color_saturation color_contrast block_wise gaussian_noise gaussian_blur pixelate jpeg_quality)
+GPU=${GPU:-0}
+BATCH=${BATCH:-16}
+WORKERS=${WORKERS:-4}
+
+# Clean any prior runs.json so this sweep is self-contained.
+if [ -f "$JSON" ]; then
+    mv "$JSON" "${JSON}.$(date +%Y%m%d_%H%M%S).bak"
+fi
+
+# Single clean baseline (level=1 of any perturbation is no-op).
+echo "===== baseline (no-op, level=1) ====="
+$PYTHON evaluate_robustness.py \
+    --real_list_path "$REAL" --fake_list_path "$FAKE" \
+    --ckpt "$CKPT" --demographics_csv "$CSV" \
+    --perturbation gaussian_noise --level 1 \
+    --batch_size $BATCH --loader_workers $WORKERS --gpu $GPU \
+    --save_json "$JSON"
+
+# Sweep level 2..5 for every perturbation.
+for P in "${PERTURBATIONS[@]}"; do
+    for L in 2 3 4 5; do
+        echo "===== $P  level=$L ====="
+        $PYTHON evaluate_robustness.py \
+            --real_list_path "$REAL" --fake_list_path "$FAKE" \
+            --ckpt "$CKPT" --demographics_csv "$CSV" \
+            --perturbation "$P" --level $L \
+            --batch_size $BATCH --loader_workers $WORKERS --gpu $GPU \
+            --save_json "$JSON"
+    done
+done
+
+echo
+echo ">>> Sweep done. Results: $JSON"

run_robustness_v4.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+# run_robustness_v4.sh — sweep all 7 perturbations × 5 levels with the
+# 5-crop-bug-fixed pipeline (see data/datasets.py:64 + evaluate_robustness.py).
+#
+# Same ckpt as v3 (model_epoch_10.pth) so v3 vs v4 isolates the bug fix.
+
+set -e
+cd /apdcephfs_gy4/share_303628665/joywu/research/LipFD
+
+PYTHON=/opt/conda/envs/LipFD/bin/python
+CKPT=checkpoints/lipfd_train/model_epoch_10.pth
+REAL=datasets/FairTalking-Bench/test/0_real
+FAKE=datasets/FairTalking-Bench/test/1_fake
+CSV=/apdcephfs_gy4/share_303628665/joywu/research/test.csv
+OUT_DIR=/apdcephfs_gy4/share_303628665/joywu/research/LipFD/robustnessv4
+JSON=$OUT_DIR/runs.json
+
+mkdir -p "$OUT_DIR"
+
+PERTURBATIONS=(color_saturation color_contrast block_wise gaussian_noise gaussian_blur pixelate jpeg_quality)
+GPU=${GPU:-2}
+BATCH=${BATCH:-32}
+WORKERS=${WORKERS:-8}
+
+if [ -f "$JSON" ]; then
+    mv "$JSON" "${JSON}.$(date +%Y%m%d_%H%M%S).bak"
+fi
+
+echo "===== baseline (no-op, level=1) ====="
+$PYTHON evaluate_robustness.py \
+    --real_list_path "$REAL" --fake_list_path "$FAKE" \
+    --ckpt "$CKPT" --demographics_csv "$CSV" \
+    --perturbation gaussian_noise --level 1 \
+    --batch_size $BATCH --loader_workers $WORKERS --gpu $GPU \
+    --save_json "$JSON"
+
+for P in "${PERTURBATIONS[@]}"; do
+    for L in 2 3 4 5; do
+        echo "===== $P  level=$L ====="
+        $PYTHON evaluate_robustness.py \
+            --real_list_path "$REAL" --fake_list_path "$FAKE" \
+            --ckpt "$CKPT" --demographics_csv "$CSV" \
+            --perturbation "$P" --level $L \
+            --batch_size $BATCH --loader_workers $WORKERS --gpu $GPU \
+            --save_json "$JSON"
+    done
+done
+
+echo
+echo ">>> Sweep done. Results: $JSON"

run_robustnessv2.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+# run_robustness.sh — sweep all 7 perturbations × 5 levels on the LipFD test set.
+#
+# Note: level=1 is a no-op for every perturbation in SEVERITY, so we only run
+# it once (under "gaussian_noise") and treat that as the clean baseline. The
+# runs.json output appends one entry per (perturbation, level) call.
+
+set -e
+cd /apdcephfs_gy4/share_303628665/joywu/research/LipFD
+
+PYTHON=/opt/conda/envs/LipFD/bin/python
+CKPT=checkpoints/lipfd_train/model_epoch_10.pth
+REAL=datasets/FairTalking-Bench/test/0_real
+FAKE=datasets/FairTalking-Bench/test/1_fake
+CSV=/apdcephfs_gy4/share_303628665/joywu/research/test.csv
+OUT_DIR=/apdcephfs_gy4/share_303628665/joywu/research/LipFD/robustnessv3
+JSON=$OUT_DIR/runs.json
+
+mkdir -p "$OUT_DIR"
+
+PERTURBATIONS=(color_saturation color_contrast block_wise gaussian_noise gaussian_blur pixelate jpeg_quality)
+GPU=${GPU:-0}
+BATCH=${BATCH:-16}
+WORKERS=${WORKERS:-4}
+
+# Clean any prior runs.json so this sweep is self-contained.
+if [ -f "$JSON" ]; then
+    mv "$JSON" "${JSON}.$(date +%Y%m%d_%H%M%S).bak"
+fi
+
+# Single clean baseline (level=1 of any perturbation is no-op).
+echo "===== baseline (no-op, level=1) ====="
+$PYTHON evaluate_robustness.py \
+    --real_list_path "$REAL" --fake_list_path "$FAKE" \
+    --ckpt "$CKPT" --demographics_csv "$CSV" \
+    --perturbation gaussian_noise --level 1 \
+    --batch_size $BATCH --loader_workers $WORKERS --gpu $GPU \
+    --save_json "$JSON"
+
+# Sweep level 2..5 for every perturbation.
+for P in "${PERTURBATIONS[@]}"; do
+    for L in 2 3 4 5; do
+        echo "===== $P  level=$L ====="
+        $PYTHON evaluate_robustness.py \
+            --real_list_path "$REAL" --fake_list_path "$FAKE" \
+            --ckpt "$CKPT" --demographics_csv "$CSV" \
+            --perturbation "$P" --level $L \
+            --batch_size $BATCH --loader_workers $WORKERS --gpu $GPU \
+            --save_json "$JSON"
+    done
+done
+
+echo
+echo ">>> Sweep done. Results: $JSON"

split_dataset.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+根据 FairTalking-Bench 的 CSV 文件划分数据集
+将预处理后的数据（datasets/AVLips/）按照 CSV 中的 basename 划分为 train/val/test
+匹配规则：文件名包含 basename 即可（模糊匹配）
+"""
+
+import os
+import shutil
+import pandas as pd
+from pathlib import Path
+from tqdm import tqdm
+
+# 路径配置
+DATASET_DIR = "/apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets"
+AVLIPS_DIR = os.path.join(DATASET_DIR, "AVLips")
+CSV_DIR = "/apdcephfs_gy4/share_303628665/joywu/dataset/FairTalking-Bench"
+
+# CSV 文件
+TRAIN_CSV = os.path.join(CSV_DIR, "train.csv")
+VAL_CSV = os.path.join(CSV_DIR, "val.csv")
+TEST_CSV = os.path.join(CSV_DIR, "test.csv")
+
+# 输出目录
+OUTPUT_DIR = os.path.join(DATASET_DIR, "FairTalking-Bench")
+
+
+def load_basenames(csv_path):
+    """从 CSV 文件加载 basename 列表和对应的 label"""
+    df = pd.read_csv(csv_path)
+    # 返回 basename -> label 的字典
+    basename_dict = {}
+    for _, row in df.iterrows():
+        basename = row['basename']
+        label = row['Label']  # 0=Real, 1=Fake
+        basename_dict[basename] = label
+    return basename_dict
+
+
+def find_and_copy_files(avlips_dir, basename_dict, output_split_dir):
+    """
+    在 AVLips 目录中查找匹配的文件，并复制到输出目录
+    匹配规则：文件名包含 basename 即可
+    优化：使用反向索引，先构建文件列表，然后直接匹配 basename
+    """
+    # 创建输出目录
+    real_output_dir = os.path.join(output_split_dir, "0_real")
+    fake_output_dir = os.path.join(output_split_dir, "1_fake")
+    os.makedirs(real_output_dir, exist_ok=True)
+    os.makedirs(fake_output_dir, exist_ok=True)
+    
+    # 统计
+    real_count = 0
+    fake_count = 0
+    matched_files = set()  # 记录已匹配的文件，避免重复
+    
+    # 获取所有 basename
+    basenames = list(basename_dict.keys())
+    
+    print(f"  开始匹配 {len(basenames)} 个 basename...")
+    
+    # 遍历每个 basename，在 AVLips 目录中查找匹配的文件
+    for basename in tqdm(basenames, desc="  匹配进度"):
+        label = basename_dict[basename]  # 0=Real, 1=Fake
+        
+        # 根据 label 确定要搜索的目录
+        if label == 0:
+            search_dirs = [os.path.join(avlips_dir, '0_real')]
+            dst_dir = real_output_dir
+        else:
+            search_dirs = [os.path.join(avlips_dir, '1_fake')]
+            dst_dir = fake_output_dir
+        
+        # 在每个目录中查找匹配的文件
+        for search_dir in search_dirs:
+            if not os.path.exists(search_dir):
+                continue
+            
+            # 查找包含 basename 的文件
+            files = os.listdir(search_dir)
+            for filename in files:
+                if basename in filename and filename.endswith('.png'):
+                    # 找到匹配！
+                    src_path = os.path.join(search_dir, filename)
+                    dst_path = os.path.join(dst_dir, filename)
+                    
+                    if not os.path.exists(dst_path):
+                        shutil.copy2(src_path, dst_path)
+                    
+                    # 统计
+                    if label == 0:
+                        real_count += 1
+                    else:
+                        fake_count += 1
+                    
+                    matched_files.add(filename)
+    
+    print(f"  匹配完成: {len(matched_files)} 个文件")
+    
+    return real_count, fake_count
+
+
+def main():
+    print("=" * 60)
+    print("开始划分 FairTalking-Bench 数据集")
+    print("=" * 60)
+    
+    # 1. 加载 CSV 文件中的 basename
+    print("\n1. 加载 CSV 文件...")
+    train_dict = load_basenames(TRAIN_CSV)
+    val_dict = load_basenames(VAL_CSV)
+    test_dict = load_basenames(TEST_CSV)
+    
+    print(f"  Train: {len(train_dict)} 个样本")
+    print(f"  Val:   {len(val_dict)} 个样本")
+    print(f"  Test:  {len(test_dict)} 个样本")
+    
+    # 2. 查找并复制文件
+    print("\n2. 查找并复制文件...")
+    print(f"  输出目录: {OUTPUT_DIR}")
+    
+    # 训练集
+    print("\n  处理训练集...")
+    train_real, train_fake = find_and_copy_files(
+        AVLIPS_DIR, train_dict, os.path.join(OUTPUT_DIR, "train")
+    )
+    
+    # 验证集
+    print("\n  处理验证集...")
+    val_real, val_fake = find_and_copy_files(
+        AVLIPS_DIR, val_dict, os.path.join(OUTPUT_DIR, "val")
+    )
+    
+    # 测试集
+    print("\n  处理测试集...")
+    test_real, test_fake = find_and_copy_files(
+        AVLIPS_DIR, test_dict, os.path.join(OUTPUT_DIR, "test")
+    )
+    
+    # 3. 打印统计信息
+    print("\n" + "=" * 60)
+    print("数据集划分完成！")
+    print("=" * 60)
+    print(f"\n训练集: Real={train_real}, Fake={train_fake}, Total={train_real + train_fake}")
+    print(f"验证集: Real={val_real}, Fake={val_fake}, Total={val_real + val_fake}")
+    print(f"测试集: Real={test_real}, Fake={test_fake}, Total={test_real + test_fake}")
+    
+    # 4. 创建数据集信息文件
+    print("\n3. 创建数据集信息文件...")
+    create_dataset_info(OUTPUT_DIR, train_real, train_fake, val_real, val_fake, test_real, test_fake)
+    
+    print("\n✅ 全部完成！")
+    print(f"\n数据集已保存到: {OUTPUT_DIR}")
+
+
+def create_dataset_info(output_dir, train_real, train_fake, val_real, val_fake, test_real, test_fake):
+    """创建数据集信息文件"""
+    info_path = os.path.join(output_dir, "dataset_info.txt")
+    
+    with open(info_path, 'w') as f:
+        f.write("FairTalking-Bench 数据集划分信息\n")
+        f.write("=" * 60 + "\n\n")
+        
+        f.write("数据来源:\n")
+        f.write(f"  CSV 目录: {CSV_DIR}\n")
+        f.write(f"  预处理数据: {AVLIPS_DIR}\n\n")
+        
+        f.write("匹配规则:\n")
+        f.write("  文件名包含 basename 即可（模糊匹配）\n\n")
+        
+        f.write("数据集划分:\n")
+        f.write(f"  训练集: Real={train_real}, Fake={train_fake}, Total={train_real + train_fake}\n")
+        f.write(f"  验证集: Real={val_real}, Fake={val_fake}, Total={val_real + val_fake}\n")
+        f.write(f"  测试集: Real={test_real}, Fake={test_fake}, Total={test_real + test_fake}\n\n")
+        
+        f.write("目录结构:\n")
+        f.write(f"  {output_dir}/\n")
+        f.write(f"    ├── train/\n")
+        f.write(f"    │   ├── 0_real/  ({train_real} 张图片)\n")
+        f.write(f"    │   └── 1_fake/  ({train_fake} 张图片)\n")
+        f.write(f"    ├── val/\n")
+        f.write(f"    │   ├── 0_real/  ({val_real} 张图片)\n")
+        f.write(f"    │   └── 1_fake/  ({val_fake} 张图片)\n")
+        f.write(f"    └── test/\n")
+        f.write(f"        ├── 0_real/  ({test_real} 张图片)\n")
+        f.write(f"        └── 1_fake/  ({test_fake} 张图片)\n")
+    
+    print(f"  信息文件已保存: {info_path}")
+
+
+if __name__ == "__main__":
+    main()

train.log

@@ -0,0 +1,1126 @@
+nohup: ignoring input
+----------------- Options ---------------
+                     arch: CLIP:ViT-L/14                 
+               batch_size: 32                            	[default: 10]
+                    beta1: 0.9                           
+                 blur_sig: 0                             
+          checkpoints_dir: ./checkpoints                 
+                class_bal: False                         
+               data_label: train                         
+                    epoch: 50                            	[default: 100]
+           fake_list_path: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake
+                fine_tune: False                         
+             fix_backbone: False                         
+              fix_encoder: False                         
+                  gpu_ids: 1                             
+                  isTrain: True                          	[default: None]
+               jpg_method: cv2                           
+                 jpg_qual: 75                            
+                loss_freq: 100                           
+                       lr: 2e-09                         
+                     name: lipfd_train                   	[default: experiment_name]
+              num_threads: 0                             
+                    optim: adam                          
+         pretrained_model: ./checkpoints/experiment_name/model_epoch_29.pth
+           real_list_path: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/0_real
+                rz_interp: bilinear                      
+          save_epoch_freq: 1                             
+           serial_batches: False                         
+                   suffix:                               
+              train_split: train                         
+                val_split: val                           
+             weight_decay: 0.0001                        
+----------------- End -------------------
+Length of data loader: 1483
+Length of val  loader: 189
+epoch:  0
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 109.3497085571289	step: 100
+Train loss: 115.77810668945312	step: 200
+Train loss: 87.44400787353516	step: 300
+Train loss: 121.6205062866211	step: 400
+Train loss: 98.32791137695312	step: 500
+Train loss: 105.16156005859375	step: 600
+Train loss: 126.1203384399414	step: 700
+Train loss: 97.93379211425781	step: 800
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 115.77715301513672	step: 900
+Train loss: 102.43711853027344	step: 1000
+Train loss: 98.23110961914062	step: 1100
+Train loss: 107.89041137695312	step: 1200
+Train loss: 121.88636779785156	step: 1300
+Train loss: 93.9386978149414	step: 1400
+saving the model at the end of epoch 0
+validating...
+(Val @ epoch 0) acc: 0.5619205298013245 ap: 0.5358050929646152 fpr: 0.5423841059602649 fnr: 0.3337748344370861
+epoch:  1
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 80.58499145507812	step: 1500
+Train loss: 93.76890563964844	step: 1600
+Train loss: 99.49382019042969	step: 1700
+Train loss: 114.85481262207031	step: 1800
+Train loss: 111.15044403076172	step: 1900
+Train loss: 98.20150756835938	step: 2000
+Train loss: 108.94288635253906	step: 2100
+Train loss: 97.31046295166016	step: 2200
+Train loss: 111.14601135253906	step: 2300
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 99.89578247070312	step: 2400
+Train loss: 104.52080535888672	step: 2500
+Train loss: 102.98640441894531	step: 2600
+Train loss: 110.73353576660156	step: 2700
+Train loss: 110.9141616821289	step: 2800
+Train loss: 102.97096252441406	step: 2900
+saving the model at the end of epoch 1
+validating...
+(Val @ epoch 1) acc: 0.5668874172185431 ap: 0.5403939443490584 fpr: 0.6112582781456953 fnr: 0.25496688741721857
+epoch:  2
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 103.4789810180664	step: 3000
+Train loss: 103.80142211914062	step: 3100
+Train loss: 104.60528564453125	step: 3200
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 104.47315979003906	step: 3300
+Train loss: 117.82144165039062	step: 3400
+Train loss: 107.26661682128906	step: 3500
+Train loss: 107.14081573486328	step: 3600
+Train loss: 120.1827163696289	step: 3700
+Train loss: 106.52513122558594	step: 3800
+Train loss: 113.37628173828125	step: 3900
+Train loss: 95.05484008789062	step: 4000
+Train loss: 103.19268035888672	step: 4100
+Train loss: 98.6756591796875	step: 4200
+Train loss: 95.58908081054688	step: 4300
+Train loss: 109.18098449707031	step: 4400
+saving the model at the end of epoch 2
+validating...
+(Val @ epoch 2) acc: 0.7384105960264901 ap: 0.6719250858323706 fpr: 0.22251655629139072 fnr: 0.30066225165562915
+epoch:  3
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 95.00332641601562	step: 4500
+Train loss: 99.6748046875	step: 4600
+Train loss: 92.31637573242188	step: 4700
+Train loss: 116.52984619140625	step: 4800
+Train loss: 127.14207458496094	step: 4900
+Train loss: 109.15467834472656	step: 5000
+Train loss: 116.30558776855469	step: 5100
+Train loss: 109.86700439453125	step: 5200
+Train loss: 109.25109100341797	step: 5300
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 104.51777648925781	step: 5400
+Train loss: 113.69713592529297	step: 5500
+Train loss: 111.95301818847656	step: 5600
+Train loss: 103.20728302001953	step: 5700
+Train loss: 94.30152130126953	step: 5800
+Train loss: 98.17637634277344	step: 5900
+saving the model at the end of epoch 3
+validating...
+(Val @ epoch 3) acc: 0.7683774834437086 ap: 0.7047433801685381 fpr: 0.22119205298013245 fnr: 0.24205298013245033
+epoch:  4
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 105.40957641601562	step: 6000
+Train loss: 90.19412231445312	step: 6100
+Train loss: 119.46781158447266	step: 6200
+Train loss: 111.60482788085938	step: 6300
+Train loss: 91.49681854248047	step: 6400
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 105.05416870117188	step: 6500
+Train loss: 93.8360595703125	step: 6600
+Train loss: 113.2322998046875	step: 6700
+Train loss: 94.4849853515625	step: 6800
+Train loss: 104.68202209472656	step: 6900
+Train loss: 109.71572875976562	step: 7000
+Train loss: 101.18453216552734	step: 7100
+Train loss: 110.65788269042969	step: 7200
+Train loss: 94.93778991699219	step: 7300
+Train loss: 98.08305358886719	step: 7400
+saving the model at the end of epoch 4
+validating...
+(Val @ epoch 4) acc: 0.8084437086092715 ap: 0.7422743564712114 fpr: 0.15132450331125827 fnr: 0.23178807947019867
+epoch:  5
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 119.11969757080078	step: 7500
+Train loss: 101.54550170898438	step: 7600
+Train loss: 125.54096221923828	step: 7700
+Train loss: 107.59408569335938	step: 7800
+Train loss: 90.32762145996094	step: 7900
+Train loss: 105.04289245605469	step: 8000
+Train loss: 118.83558654785156	step: 8100
+Train loss: 108.56706237792969	step: 8200
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 79.27407836914062	step: 8300
+Train loss: 78.02943420410156	step: 8400
+Train loss: 100.42111206054688	step: 8500
+Train loss: 111.81028747558594	step: 8600
+Train loss: 87.120849609375	step: 8700
+Train loss: 95.80047607421875	step: 8800
+saving the model at the end of epoch 5
+validating...
+(Val @ epoch 5) acc: 0.8337748344370861 ap: 0.7723560796362805 fpr: 0.1380794701986755 fnr: 0.1943708609271523
+epoch:  6
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 101.03681945800781	step: 8900
+Train loss: 100.72366333007812	step: 9000
+Train loss: 100.6364517211914	step: 9100
+Train loss: 92.65306854248047	step: 9200
+Train loss: 90.16053771972656	step: 9300
+Train loss: 96.73390197753906	step: 9400
+Train loss: 106.46004486083984	step: 9500
+Train loss: 103.21466064453125	step: 9600
+Train loss: 116.55767822265625	step: 9700
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 85.55316162109375	step: 9800
+Train loss: 96.09256744384766	step: 9900
+Train loss: 102.47693634033203	step: 10000
+Train loss: 81.52528381347656	step: 10100
+Train loss: 108.37000274658203	step: 10200
+Train loss: 103.06450653076172	step: 10300
+saving the model at the end of epoch 6
+validating...
+(Val @ epoch 6) acc: 0.8528145695364239 ap: 0.7921117857965466 fpr: 0.10927152317880795 fnr: 0.18509933774834436
+epoch:  7
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 98.67803955078125	step: 10400
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 76.78703308105469	step: 10500
+Train loss: 85.51482391357422	step: 10600
+Train loss: 92.47024536132812	step: 10700
+Train loss: 114.7383804321289	step: 10800
+Train loss: 102.96634674072266	step: 10900
+Train loss: 87.48692321777344	step: 11000
+Train loss: 90.52207946777344	step: 11100
+Train loss: 111.1252212524414	step: 11200
+Train loss: 87.54425811767578	step: 11300
+Train loss: 105.98014831542969	step: 11400
+Train loss: 90.05438232421875	step: 11500
+Train loss: 113.97802734375	step: 11600
+Train loss: 102.34657287597656	step: 11700
+Train loss: 84.95005798339844	step: 11800
+saving the model at the end of epoch 7
+validating...
+(Val @ epoch 7) acc: 0.8683774834437086 ap: 0.8040541849307241 fpr: 0.06556291390728476 fnr: 0.19768211920529802
+epoch:  8
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 85.20083618164062	step: 11900
+Train loss: 87.54823303222656	step: 12000
+Train loss: 113.52896881103516	step: 12100
+Train loss: 129.43238830566406	step: 12200
+Train loss: 114.55952453613281	step: 12300
+Train loss: 103.117431640625	step: 12400
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 91.63424682617188	step: 12500
+Train loss: 95.65892028808594	step: 12600
+Train loss: 90.61808776855469	step: 12700
+Train loss: 96.25401306152344	step: 12800
+Train loss: 97.88920593261719	step: 12900
+Train loss: 86.9149398803711	step: 13000
+Train loss: 102.21635437011719	step: 13100
+Train loss: 109.04608917236328	step: 13200
+Train loss: 125.03392028808594	step: 13300
+saving the model at the end of epoch 8
+validating...
+(Val @ epoch 8) acc: 0.8783112582781457 ap: 0.8186793368354413 fpr: 0.06920529801324503 fnr: 0.1741721854304636
+epoch:  9
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 82.39558410644531	step: 13400
+Train loss: 95.42220306396484	step: 13500
+Train loss: 86.77865600585938	step: 13600
+Train loss: 85.80287170410156	step: 13700
+Train loss: 90.50550842285156	step: 13800
+Train loss: 117.10944366455078	step: 13900
+Train loss: 101.46859741210938	step: 14000
+Train loss: 129.0438995361328	step: 14100
+Train loss: 91.16072845458984	step: 14200
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 101.34473419189453	step: 14300
+Train loss: 111.5604019165039	step: 14400
+Train loss: 113.9402847290039	step: 14500
+Train loss: 102.88592529296875	step: 14600
+Train loss: 91.57630920410156	step: 14700
+Train loss: 105.73886108398438	step: 14800
+saving the model at the end of epoch 9
+validating...
+(Val @ epoch 9) acc: 0.8816225165562914 ap: 0.8196018733092221 fpr: 0.052980132450331126 fnr: 0.1837748344370861
+epoch:  10
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 97.87602233886719	step: 14900
+Train loss: 95.77507781982422	step: 15000
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 95.00900268554688	step: 15100
+Train loss: 107.40650939941406	step: 15200
+Train loss: 96.98809814453125	step: 15300
+Train loss: 112.39302062988281	step: 15400
+Train loss: 88.38487243652344	step: 15500
+Train loss: 101.34196472167969	step: 15600
+Train loss: 102.19132995605469	step: 15700
+Train loss: 113.40335845947266	step: 15800
+Train loss: 89.87989044189453	step: 15900
+Train loss: 104.63227081298828	step: 16000
+Train loss: 98.57897186279297	step: 16100
+Train loss: 86.28732299804688	step: 16200
+Train loss: 101.2440185546875	step: 16300
+saving the model at the end of epoch 10
+validating...
+(Val @ epoch 10) acc: 0.8892384105960265 ap: 0.8295498309705669 fpr: 0.04933774834437086 fnr: 0.17218543046357615
+epoch:  11
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 108.46096801757812	step: 16400
+Train loss: 105.14181518554688	step: 16500
+Train loss: 93.53913116455078	step: 16600
+Train loss: 116.83553314208984	step: 16700
+Train loss: 90.81753540039062	step: 16800
+Train loss: 125.16203308105469	step: 16900
+Train loss: 93.55419921875	step: 17000
+Train loss: 86.73138427734375	step: 17100
+Train loss: 94.1943588256836	step: 17200
+Train loss: 82.45521545410156	step: 17300
+Train loss: 96.87867736816406	step: 17400
+Train loss: 79.26760864257812	step: 17500
+Train loss: 99.71473693847656	step: 17600
+Train loss: 101.4261474609375	step: 17700
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+saving the model at the end of epoch 11
+validating...
+(Val @ epoch 11) acc: 0.895364238410596 ap: 0.8384289589972633 fpr: 0.04933774834437086 fnr: 0.15993377483443708
+epoch:  12
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 99.41751861572266	step: 17800
+Train loss: 100.92225646972656	step: 17900
+Train loss: 100.92166900634766	step: 18000
+Train loss: 80.60731506347656	step: 18100
+Train loss: 84.21905517578125	step: 18200
+Train loss: 99.12002563476562	step: 18300
+Train loss: 97.47544860839844	step: 18400
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 95.96418762207031	step: 18500
+Train loss: 92.93983459472656	step: 18600
+Train loss: 102.73402404785156	step: 18700
+Train loss: 115.28011322021484	step: 18800
+Train loss: 78.9912109375	step: 18900
+Train loss: 96.33280944824219	step: 19000
+Train loss: 86.17536926269531	step: 19100
+Train loss: 99.39048767089844	step: 19200
+saving the model at the end of epoch 12
+validating...
+(Val @ epoch 12) acc: 0.8948675496688742 ap: 0.8358056681580142 fpr: 0.041721854304635764 fnr: 0.16854304635761588
+epoch:  13
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 97.01101684570312	step: 19300
+Train loss: 99.92607116699219	step: 19400
+Train loss: 94.14410400390625	step: 19500
+Train loss: 108.56205749511719	step: 19600
+Train loss: 100.33192443847656	step: 19700
+Train loss: 119.96015167236328	step: 19800
+Train loss: 100.62596130371094	step: 19900
+Train loss: 89.90122985839844	step: 20000
+Train loss: 104.45906066894531	step: 20100
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 109.33349609375	step: 20200
+Train loss: 104.80198669433594	step: 20300
+Train loss: 101.63945770263672	step: 20400
+Train loss: 93.26719665527344	step: 20500
+Train loss: 89.44151306152344	step: 20600
+Train loss: 88.83653259277344	step: 20700
+saving the model at the end of epoch 13
+validating...
+(Val @ epoch 13) acc: 0.9021523178807948 ap: 0.8468278718816762 fpr: 0.04304635761589404 fnr: 0.15264900662251657
+epoch:  14
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 92.56515502929688	step: 20800
+Train loss: 112.10537719726562	step: 20900
+Train loss: 92.1612548828125	step: 21000
+Train loss: 100.8740234375	step: 21100
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 89.64739227294922	step: 21200
+Train loss: 105.49078369140625	step: 21300
+Train loss: 81.24507904052734	step: 21400
+Train loss: 93.61893463134766	step: 21500
+Train loss: 105.0328369140625	step: 21600
+Train loss: 81.52472686767578	step: 21700
+Train loss: 82.63867950439453	step: 21800
+Train loss: 93.63219451904297	step: 21900
+Train loss: 88.57166290283203	step: 22000
+Train loss: 95.90657806396484	step: 22100
+Train loss: 103.16031646728516	step: 22200
+saving the model at the end of epoch 14
+validating...
+(Val @ epoch 14) acc: 0.9026490066225166 ap: 0.8462686098988782 fpr: 0.0380794701986755 fnr: 0.1566225165562914
+epoch:  15
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 114.83440399169922	step: 22300
+Train loss: 108.83474731445312	step: 22400
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 88.62757873535156	step: 22500
+Train loss: 96.61287689208984	step: 22600
+Train loss: 115.21736145019531	step: 22700
+Train loss: 89.04222106933594	step: 22800
+Train loss: 88.95414733886719	step: 22900
+Train loss: 85.84208679199219	step: 23000
+Train loss: 114.43083190917969	step: 23100
+Train loss: 111.42693328857422	step: 23200
+Train loss: 101.97541809082031	step: 23300
+Train loss: 103.68124389648438	step: 23400
+Train loss: 88.98529052734375	step: 23500
+Train loss: 88.13697814941406	step: 23600
+Train loss: 96.48775482177734	step: 23700
+saving the model at the end of epoch 15
+validating...
+(Val @ epoch 15) acc: 0.904635761589404 ap: 0.8482638373065826 fpr: 0.03443708609271523 fnr: 0.1562913907284768
+epoch:  16
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 82.79197692871094	step: 23800
+Train loss: 92.29851531982422	step: 23900
+Train loss: 101.32656860351562	step: 24000
+Train loss: 82.86312866210938	step: 24100
+Train loss: 99.44190979003906	step: 24200
+Train loss: 114.21587371826172	step: 24300
+Train loss: 93.10935974121094	step: 24400
+Train loss: 110.8064193725586	step: 24500
+Train loss: 107.86590576171875	step: 24600
+Train loss: 104.00509643554688	step: 24700
+Train loss: 105.76403045654297	step: 24800
+Train loss: 107.95489501953125	step: 24900
+Train loss: 103.10502624511719	step: 25000
+Train loss: 96.59196472167969	step: 25100
+Train loss: 99.68357849121094	step: 25200
+saving the model at the end of epoch 16
+validating...
+(Val @ epoch 16) acc: 0.9076158940397351 ap: 0.852086660247679 fpr: 0.032119205298013244 fnr: 0.15264900662251657
+epoch:  17
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 92.31273651123047	step: 25300
+Train loss: 84.96509552001953	step: 25400
+Train loss: 86.664306640625	step: 25500
+Train loss: 108.47801208496094	step: 25600
+Train loss: 84.15589904785156	step: 25700
+Train loss: 106.80313873291016	step: 25800
+Train loss: 100.79236602783203	step: 25900
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 103.33578491210938	step: 26000
+Train loss: 88.80908966064453	step: 26100
+Train loss: 99.35258483886719	step: 26200
+Train loss: 92.63272094726562	step: 26300
+Train loss: 99.22555541992188	step: 26400
+Train loss: 81.28981018066406	step: 26500
+Train loss: 92.94877624511719	step: 26600
+saving the model at the end of epoch 17
+validating...
+(Val @ epoch 17) acc: 0.9135761589403973 ap: 0.8610761985014281 fpr: 0.032119205298013244 fnr: 0.14072847682119205
+epoch:  18
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 104.60865783691406	step: 26700
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 88.01316833496094	step: 26800
+Train loss: 95.64061737060547	step: 26900
+Train loss: 96.63502502441406	step: 27000
+Train loss: 97.56912231445312	step: 27100
+Train loss: 96.4901123046875	step: 27200
+Train loss: 96.18511962890625	step: 27300
+Train loss: 85.32862854003906	step: 27400
+Train loss: 102.43637084960938	step: 27500
+Train loss: 101.28318786621094	step: 27600
+Train loss: 110.92155456542969	step: 27700
+Train loss: 92.72991943359375	step: 27800
+Train loss: 100.44973754882812	step: 27900
+Train loss: 99.80447387695312	step: 28000
+Train loss: 98.5571517944336	step: 28100
+saving the model at the end of epoch 18
+validating...
+(Val @ epoch 18) acc: 0.9124172185430464 ap: 0.8580459269467713 fpr: 0.02748344370860927 fnr: 0.147682119205298
+epoch:  19
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 89.30645751953125	step: 28200
+Train loss: 95.78688049316406	step: 28300
+Train loss: 100.19153594970703	step: 28400
+Train loss: 89.90309143066406	step: 28500
+Train loss: 103.15199279785156	step: 28600
+Train loss: 95.88514709472656	step: 28700
+Train loss: 77.65068817138672	step: 28800
+Train loss: 95.78532409667969	step: 28900
+Train loss: 91.47555541992188	step: 29000
+Train loss: 102.67447662353516	step: 29100
+Train loss: 85.68608093261719	step: 29200
+Train loss: 81.28839111328125	step: 29300
+Train loss: 87.3929672241211	step: 29400
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 127.06197357177734	step: 29500
+Train loss: 88.83319854736328	step: 29600
+saving the model at the end of epoch 19
+validating...
+(Val @ epoch 19) acc: 0.9149006622516557 ap: 0.8619897276184927 fpr: 0.028145695364238412 fnr: 0.14205298013245032
+epoch:  20
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 103.29493713378906	step: 29700
+Train loss: 95.25360107421875	step: 29800
+Train loss: 95.465576171875	step: 29900
+Train loss: 87.75604248046875	step: 30000
+Train loss: 92.74017333984375	step: 30100
+Train loss: 86.07817077636719	step: 30200
+Train loss: 98.4383544921875	step: 30300
+Train loss: 95.09693908691406	step: 30400
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 93.51901245117188	step: 30500
+Train loss: 93.16593933105469	step: 30600
+Train loss: 94.72856140136719	step: 30700
+Train loss: 96.36589050292969	step: 30800
+Train loss: 81.53694152832031	step: 30900
+Train loss: 111.12959289550781	step: 31000
+Train loss: 91.42665100097656	step: 31100
+saving the model at the end of epoch 20
+validating...
+(Val @ epoch 20) acc: 0.9147350993377483 ap: 0.8610072160162654 fpr: 0.025496688741721854 fnr: 0.14503311258278145
+epoch:  21
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 98.46931457519531	step: 31200
+Train loss: 88.39454650878906	step: 31300
+Train loss: 86.25625610351562	step: 31400
+Train loss: 91.50813293457031	step: 31500
+Train loss: 103.72244262695312	step: 31600
+Train loss: 96.97940063476562	step: 31700
+Train loss: 129.3763427734375	step: 31800
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 87.54872131347656	step: 31900
+Train loss: 110.87643432617188	step: 32000
+Train loss: 94.82489013671875	step: 32100
+Train loss: 91.09426879882812	step: 32200
+Train loss: 141.98573303222656	step: 32300
+Train loss: 91.30592346191406	step: 32400
+Train loss: 91.48355102539062	step: 32500
+Train loss: 84.7899169921875	step: 32600
+saving the model at the end of epoch 21
+validating...
+(Val @ epoch 21) acc: 0.9175496688741722 ap: 0.8655735635765534 fpr: 0.026490066225165563 fnr: 0.13841059602649006
+epoch:  22
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 81.1429443359375	step: 32700
+Train loss: 80.49852752685547	step: 32800
+Train loss: 103.57378387451172	step: 32900
+Train loss: 115.09785461425781	step: 33000
+Train loss: 100.0188980102539	step: 33100
+Train loss: 117.90495300292969	step: 33200
+Train loss: 115.60507202148438	step: 33300
+Train loss: 95.4669189453125	step: 33400
+Train loss: 92.07056427001953	step: 33500
+Train loss: 94.75532531738281	step: 33600
+Train loss: 104.36040496826172	step: 33700
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 102.83029174804688	step: 33800
+Train loss: 107.6717529296875	step: 33900
+Train loss: 95.68386840820312	step: 34000
+Train loss: 99.3794174194336	step: 34100
+saving the model at the end of epoch 22
+validating...
+(Val @ epoch 22) acc: 0.9193708609271524 ap: 0.8676197734205308 fpr: 0.02384105960264901 fnr: 0.13741721854304637
+epoch:  23
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 107.59786987304688	step: 34200
+Train loss: 114.41547393798828	step: 34300
+Train loss: 98.87919616699219	step: 34400
+Train loss: 103.96318054199219	step: 34500
+Train loss: 100.78030395507812	step: 34600
+Train loss: 102.7208480834961	step: 34700
+Train loss: 107.3170166015625	step: 34800
+Train loss: 70.77960205078125	step: 34900
+Train loss: 107.55149841308594	step: 35000
+Train loss: 95.44448852539062	step: 35100
+Train loss: 94.88804626464844	step: 35200
+Train loss: 86.25000762939453	step: 35300
+Train loss: 102.06913757324219	step: 35400
+Train loss: 92.03421020507812	step: 35500
+saving the model at the end of epoch 23
+validating...
+(Val @ epoch 23) acc: 0.9218543046357616 ap: 0.871453551393735 fpr: 0.02384105960264901 fnr: 0.13245033112582782
+epoch:  24
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 101.97744750976562	step: 35600
+Train loss: 81.46246337890625	step: 35700
+Train loss: 94.9013671875	step: 35800
+Train loss: 91.16714477539062	step: 35900
+Train loss: 95.36466979980469	step: 36000
+Train loss: 106.69194030761719	step: 36100
+Train loss: 95.71537780761719	step: 36200
+Train loss: 95.00849914550781	step: 36300
+Train loss: 104.0283203125	step: 36400
+Train loss: 98.74684143066406	step: 36500
+Train loss: 102.49458312988281	step: 36600
+Train loss: 77.29928588867188	step: 36700
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 98.31216430664062	step: 36800
+Train loss: 99.293212890625	step: 36900
+Train loss: 83.95875549316406	step: 37000
+saving the model at the end of epoch 24
+validating...
+(Val @ epoch 24) acc: 0.919205298013245 ap: 0.8667115617611424 fpr: 0.02152317880794702 fnr: 0.1400662251655629
+epoch:  25
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 106.17198181152344	step: 37100
+Train loss: 95.02005004882812	step: 37200
+Train loss: 95.54281616210938	step: 37300
+Train loss: 85.25819396972656	step: 37400
+Train loss: 95.11949157714844	step: 37500
+Train loss: 99.20923614501953	step: 37600
+Train loss: 107.23602294921875	step: 37700
+Train loss: 87.11701965332031	step: 37800
+Train loss: 94.58992004394531	step: 37900
+Train loss: 121.3162841796875	step: 38000
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 91.7796401977539	step: 38100
+Train loss: 107.27289581298828	step: 38200
+Train loss: 94.27934265136719	step: 38300
+Train loss: 95.79428100585938	step: 38400
+Train loss: 103.22969055175781	step: 38500
+saving the model at the end of epoch 25
+validating...
+(Val @ epoch 25) acc: 0.9216887417218543 ap: 0.8704344488944431 fpr: 0.02119205298013245 fnr: 0.13543046357615893
+epoch:  26
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 96.3729476928711	step: 38600
+Train loss: 98.09357452392578	step: 38700
+Train loss: 95.33633422851562	step: 38800
+Train loss: 108.59393310546875	step: 38900
+Train loss: 90.77816772460938	step: 39000
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 106.17906188964844	step: 39100
+Train loss: 98.71460723876953	step: 39200
+Train loss: 107.44701385498047	step: 39300
+Train loss: 102.05140686035156	step: 39400
+Train loss: 90.86222839355469	step: 39500
+Train loss: 83.28683471679688	step: 39600
+Train loss: 95.26985168457031	step: 39700
+Train loss: 92.15057373046875	step: 39800
+Train loss: 99.08290100097656	step: 39900
+Train loss: 88.71820068359375	step: 40000
+saving the model at the end of epoch 26
+validating...
+(Val @ epoch 26) acc: 0.9230132450331126 ap: 0.8722919306182526 fpr: 0.02052980132450331 fnr: 0.13344370860927152
+epoch:  27
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 95.718505859375	step: 40100
+Train loss: 83.5436019897461	step: 40200
+Train loss: 90.60633850097656	step: 40300
+Train loss: 95.76900482177734	step: 40400
+Train loss: 77.22334289550781	step: 40500
+Train loss: 106.1387939453125	step: 40600
+Train loss: 105.90230560302734	step: 40700
+Train loss: 98.82454681396484	step: 40800
+Train loss: 80.53895568847656	step: 40900
+Train loss: 96.0670166015625	step: 41000
+Train loss: 96.09965515136719	step: 41100
+Train loss: 102.98234558105469	step: 41200
+Train loss: 94.43991088867188	step: 41300
+Train loss: 82.52233123779297	step: 41400
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 99.63735961914062	step: 41500
+saving the model at the end of epoch 27
+validating...
+(Val @ epoch 27) acc: 0.9231788079470199 ap: 0.8720708628922907 fpr: 0.018874172185430464 fnr: 0.1347682119205298
+epoch:  28
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 94.73419189453125	step: 41600
+Train loss: 86.86043548583984	step: 41700
+Train loss: 94.25665283203125	step: 41800
+Train loss: 87.87420654296875	step: 41900
+Train loss: 94.3466796875	step: 42000
+Train loss: 87.02870178222656	step: 42100
+Train loss: 94.72970581054688	step: 42200
+Train loss: 73.56180572509766	step: 42300
+Train loss: 107.19182586669922	step: 42400
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 86.6338882446289	step: 42500
+Train loss: 90.05741882324219	step: 42600
+Train loss: 96.47938537597656	step: 42700
+Train loss: 87.6587142944336	step: 42800
+Train loss: 99.31858825683594	step: 42900
+Train loss: 88.81858825683594	step: 43000
+saving the model at the end of epoch 28
+validating...
+(Val @ epoch 28) acc: 0.9263245033112583 ap: 0.8769619526443624 fpr: 0.018874172185430464 fnr: 0.12847682119205298
+epoch:  29
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 109.44593811035156	step: 43100
+Train loss: 84.59053039550781	step: 43200
+Train loss: 84.24394226074219	step: 43300
+Train loss: 119.02490234375	step: 43400
+Train loss: 101.92208862304688	step: 43500
+Train loss: 105.8259048461914	step: 43600
+Train loss: 98.34077453613281	step: 43700
+Train loss: 105.81497192382812	step: 43800
+Train loss: 91.91256713867188	step: 43900
+Train loss: 99.22040557861328	step: 44000
+Train loss: 94.55714416503906	step: 44100
+Train loss: 97.93988037109375	step: 44200
+Train loss: 84.58506774902344	step: 44300
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 80.71188354492188	step: 44400
+saving the model at the end of epoch 29
+validating...
+(Val @ epoch 29) acc: 0.9253311258278145 ap: 0.875024502327229 fpr: 0.017549668874172187 fnr: 0.1317880794701987
+epoch:  30
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 107.75877380371094	step: 44500
+Train loss: 99.62721252441406	step: 44600
+Train loss: 98.58932495117188	step: 44700
+Train loss: 80.76273345947266	step: 44800
+Train loss: 95.53893280029297	step: 44900
+Train loss: 94.35447692871094	step: 45000
+Train loss: 98.68751525878906	step: 45100
+Train loss: 91.52035522460938	step: 45200
+Train loss: 85.08636474609375	step: 45300
+Train loss: 99.96929931640625	step: 45400
+Train loss: 110.87091064453125	step: 45500
+Train loss: 102.12557983398438	step: 45600
+Train loss: 80.78931427001953	step: 45700
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 99.07274627685547	step: 45800
+Train loss: 88.63421630859375	step: 45900
+saving the model at the end of epoch 30
+validating...
+(Val @ epoch 30) acc: 0.9245033112582781 ap: 0.873643483930774 fpr: 0.017218543046357615 fnr: 0.1337748344370861
+epoch:  31
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 95.41173553466797	step: 46000
+Train loss: 91.78175354003906	step: 46100
+Train loss: 99.63282775878906	step: 46200
+Train loss: 126.46421813964844	step: 46300
+Train loss: 91.29084777832031	step: 46400
+Train loss: 94.41521453857422	step: 46500
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 87.62366485595703	step: 46600
+Train loss: 83.82557678222656	step: 46700
+Train loss: 119.25001525878906	step: 46800
+Train loss: 80.16643524169922	step: 46900
+Train loss: 96.1780014038086	step: 47000
+Train loss: 94.11321258544922	step: 47100
+Train loss: 69.96588134765625	step: 47200
+Train loss: 97.95004272460938	step: 47300
+Train loss: 91.87395477294922	step: 47400
+saving the model at the end of epoch 31
+validating...
+(Val @ epoch 31) acc: 0.9253311258278145 ap: 0.8743518106575674 fpr: 0.015231788079470199 fnr: 0.13410596026490065
+epoch:  32
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 94.93876647949219	step: 47500
+Train loss: 74.20389556884766	step: 47600
+Train loss: 93.996337890625	step: 47700
+Train loss: 91.61723327636719	step: 47800
+Train loss: 80.5855484008789	step: 47900
+Train loss: 105.62805938720703	step: 48000
+Train loss: 77.38821411132812	step: 48100
+Train loss: 90.43487548828125	step: 48200
+Train loss: 104.10159301757812	step: 48300
+Train loss: 96.5937271118164	step: 48400
+Train loss: 115.57551574707031	step: 48500
+Train loss: 83.31884002685547	step: 48600
+Train loss: 94.00515747070312	step: 48700
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 91.11808013916016	step: 48800
+Train loss: 95.9767074584961	step: 48900
+saving the model at the end of epoch 32
+validating...
+(Val @ epoch 32) acc: 0.9326158940397351 ap: 0.8868095052590573 fpr: 0.018543046357615896 fnr: 0.1162251655629139
+epoch:  33
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 77.57847595214844	step: 49000
+Train loss: 114.95893859863281	step: 49100
+Train loss: 89.53807830810547	step: 49200
+Train loss: 102.10774993896484	step: 49300
+Train loss: 91.46820068359375	step: 49400
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 107.26177978515625	step: 49500
+Train loss: 79.87150573730469	step: 49600
+Train loss: 80.25978088378906	step: 49700
+Train loss: 86.90876007080078	step: 49800
+Train loss: 108.16836547851562	step: 49900
+Train loss: 84.42555236816406	step: 50000
+Train loss: 98.3057632446289	step: 50100
+Train loss: 94.54742431640625	step: 50200
+Train loss: 105.42430114746094	step: 50300
+Train loss: 76.19158935546875	step: 50400
+saving the model at the end of epoch 33
+validating...
+(Val @ epoch 33) acc: 0.9317880794701987 ap: 0.8850802343352012 fpr: 0.017218543046357615 fnr: 0.11920529801324503
+epoch:  34
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 125.81848907470703	step: 50500
+Train loss: 92.07084655761719	step: 50600
+Train loss: 73.8358383178711	step: 50700
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 125.55552673339844	step: 50800
+Train loss: 83.88774108886719	step: 50900
+Train loss: 90.35460662841797	step: 51000
+Train loss: 93.7743148803711	step: 51100
+Train loss: 102.3692626953125	step: 51200
+Train loss: 87.55474090576172	step: 51300
+Train loss: 105.97702026367188	step: 51400
+Train loss: 76.19060516357422	step: 51500
+Train loss: 94.39215087890625	step: 51600
+Train loss: 108.25830078125	step: 51700
+Train loss: 86.64149475097656	step: 51800
+Train loss: 94.81710815429688	step: 51900
+saving the model at the end of epoch 34
+validating...
+(Val @ epoch 34) acc: 0.9312913907284768 ap: 0.8838867964195967 fpr: 0.015894039735099338 fnr: 0.12152317880794702
+epoch:  35
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 76.47958374023438	step: 52000
+Train loss: 102.25346374511719	step: 52100
+Train loss: 100.02899169921875	step: 52200
+Train loss: 76.23573303222656	step: 52300
+Train loss: 90.76263427734375	step: 52400
+Train loss: 96.04088592529297	step: 52500
+Train loss: 95.24079895019531	step: 52600
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 97.91497802734375	step: 52700
+Train loss: 97.41355895996094	step: 52800
+Train loss: 97.85961151123047	step: 52900
+Train loss: 114.14883422851562	step: 53000
+Train loss: 94.67399597167969	step: 53100
+Train loss: 102.08966064453125	step: 53200
+Train loss: 91.06591796875	step: 53300
+saving the model at the end of epoch 35
+validating...
+(Val @ epoch 35) acc: 0.9319536423841059 ap: 0.8851402935697372 fpr: 0.016556291390728478 fnr: 0.1195364238410596
+epoch:  36
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 105.64775848388672	step: 53400
+Train loss: 109.65997314453125	step: 53500
+Train loss: 105.07560729980469	step: 53600
+Train loss: 107.36741638183594	step: 53700
+Train loss: 83.0212631225586	step: 53800
+Train loss: 90.62057495117188	step: 53900
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 106.80844116210938	step: 54000
+Train loss: 94.00015258789062	step: 54100
+Train loss: 97.37210083007812	step: 54200
+Train loss: 100.07282257080078	step: 54300
+Train loss: 86.8153076171875	step: 54400
+Train loss: 98.42520141601562	step: 54500
+Train loss: 84.40351867675781	step: 54600
+Train loss: 94.61422729492188	step: 54700
+Train loss: 94.72000122070312	step: 54800
+saving the model at the end of epoch 36
+validating...
+(Val @ epoch 36) acc: 0.9354304635761589 ap: 0.890912769477931 fpr: 0.017218543046357615 fnr: 0.1119205298013245
+epoch:  37
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 91.30091857910156	step: 54900
+Train loss: 91.02377319335938	step: 55000
+Train loss: 105.36109924316406	step: 55100
+Train loss: 100.18766784667969	step: 55200
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 87.48077392578125	step: 55300
+Train loss: 90.96659851074219	step: 55400
+Train loss: 102.36908721923828	step: 55500
+Train loss: 93.92560577392578	step: 55600
+Train loss: 98.06395721435547	step: 55700
+Train loss: 87.72573852539062	step: 55800
+Train loss: 106.69154357910156	step: 55900
+Train loss: 104.80895233154297	step: 56000
+Train loss: 113.35851287841797	step: 56100
+Train loss: 94.14604187011719	step: 56200
+Train loss: 86.715576171875	step: 56300
+saving the model at the end of epoch 37
+validating...
+(Val @ epoch 37) acc: 0.9336092715231789 ap: 0.8871650741233064 fpr: 0.01456953642384106 fnr: 0.11821192052980133
+epoch:  38
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 94.313232421875	step: 56400
+Train loss: 94.04849243164062	step: 56500
+Train loss: 109.79649353027344	step: 56600
+Train loss: 98.18072509765625	step: 56700
+Train loss: 89.97587585449219	step: 56800
+Train loss: 109.39126586914062	step: 56900
+Train loss: 83.82635498046875	step: 57000
+Train loss: 109.32949829101562	step: 57100
+Train loss: 97.58815002441406	step: 57200
+Train loss: 99.30084228515625	step: 57300
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 82.94303894042969	step: 57400
+Train loss: 99.66937255859375	step: 57500
+Train loss: 82.54581451416016	step: 57600
+Train loss: 90.79081726074219	step: 57700
+Train loss: 93.85063171386719	step: 57800
+saving the model at the end of epoch 38
+validating...
+(Val @ epoch 38) acc: 0.93658940397351 ap: 0.8921524878940557 fpr: 0.015231788079470199 fnr: 0.11158940397350993
+epoch:  39
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 101.46546936035156	step: 57900
+Train loss: 86.85536193847656	step: 58000
+Train loss: 86.88607788085938	step: 58100
+Train loss: 94.00170135498047	step: 58200
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 101.704833984375	step: 58300
+Train loss: 86.93431854248047	step: 58400
+Train loss: 106.63441467285156	step: 58500
+Train loss: 105.39498138427734	step: 58600
+Train loss: 102.37200927734375	step: 58700
+Train loss: 98.33232879638672	step: 58800
+Train loss: 94.26693725585938	step: 58900
+Train loss: 106.35066223144531	step: 59000
+Train loss: 98.30419921875	step: 59100
+Train loss: 79.83206176757812	step: 59200
+Train loss: 90.36638641357422	step: 59300
+saving the model at the end of epoch 39
+validating...
+(Val @ epoch 39) acc: 0.9347682119205298 ap: 0.8886050604448648 fpr: 0.013245033112582781 fnr: 0.11721854304635762
+epoch:  40
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 83.80421447753906	step: 59400
+Train loss: 97.71980285644531	step: 59500
+Train loss: 86.69020080566406	step: 59600
+Train loss: 114.35474395751953	step: 59700
+Train loss: 97.22096252441406	step: 59800
+Train loss: 88.50094604492188	step: 59900
+Train loss: 97.62434387207031	step: 60000
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 97.61849212646484	step: 60100
+Train loss: 118.01669311523438	step: 60200
+Train loss: 83.99238586425781	step: 60300
+Train loss: 86.89488983154297	step: 60400
+Train loss: 98.79199981689453	step: 60500
+Train loss: 78.77233123779297	step: 60600
+Train loss: 83.23431396484375	step: 60700
+Train loss: 86.27637481689453	step: 60800
+saving the model at the end of epoch 40
+validating...
+(Val @ epoch 40) acc: 0.9346026490066225 ap: 0.8877273707600164 fpr: 0.011258278145695364 fnr: 0.1195364238410596
+epoch:  41
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 91.28060913085938	step: 60900
+Train loss: 105.48225402832031	step: 61000
+Train loss: 97.78602600097656	step: 61100
+Train loss: 105.30380249023438	step: 61200
+Train loss: 105.22386169433594	step: 61300
+Train loss: 94.03921508789062	step: 61400
+Train loss: 75.66316223144531	step: 61500
+Train loss: 83.37248992919922	step: 61600
+Train loss: 82.9482192993164	step: 61700
+Train loss: 105.40867614746094	step: 61800
+Train loss: 117.3250732421875	step: 61900
+Train loss: 87.09813690185547	step: 62000
+Train loss: 116.06901550292969	step: 62100
+Train loss: 94.27781677246094	step: 62200
+saving the model at the end of epoch 41
+validating...
+(Val @ epoch 41) acc: 0.9352649006622517 ap: 0.8892963302952812 fpr: 0.012913907284768211 fnr: 0.11655629139072848
+epoch:  42
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 109.22545623779297	step: 62300
+Train loss: 90.06454467773438	step: 62400
+Train loss: 97.81288146972656	step: 62500
+Train loss: 94.01913452148438	step: 62600
+Train loss: 89.94760131835938	step: 62700
+Train loss: 113.94859313964844	step: 62800
+Train loss: 109.82142639160156	step: 62900
+Train loss: 94.44390869140625	step: 63000
+Train loss: 121.51100158691406	step: 63100
+Train loss: 90.37667846679688	step: 63200
+Train loss: 90.16975402832031	step: 63300
+Train loss: 101.73966979980469	step: 63400
+Train loss: 77.35667419433594	step: 63500
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 90.05270385742188	step: 63600
+Train loss: 102.1438980102539	step: 63700
+saving the model at the end of epoch 42
+validating...
+(Val @ epoch 42) acc: 0.9407284768211921 ap: 0.8985567058009383 fpr: 0.01423841059602649 fnr: 0.10430463576158941
+epoch:  43
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 94.28565979003906	step: 63800
+Train loss: 88.5025405883789	step: 63900
+Train loss: 84.7755126953125	step: 64000
+Train loss: 95.95376586914062	step: 64100
+Train loss: 83.29885864257812	step: 64200
+Train loss: 94.64238739013672	step: 64300
+Train loss: 97.70860290527344	step: 64400
+Train loss: 96.45343780517578	step: 64500
+Train loss: 94.48623657226562	step: 64600
+Train loss: 117.8350830078125	step: 64700
+Train loss: 96.92566680908203	step: 64800
+Train loss: 77.26060485839844	step: 64900
+Train loss: 102.19673156738281	step: 65000
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 94.15009307861328	step: 65100
+Train loss: 97.46650695800781	step: 65200
+saving the model at the end of epoch 43
+validating...
+(Val @ epoch 43) acc: 0.9400662251655629 ap: 0.8972597832630945 fpr: 0.013576158940397352 fnr: 0.10629139072847682
+epoch:  44
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 105.65857696533203	step: 65300
+Train loss: 85.96650695800781	step: 65400
+Train loss: 95.0820541381836	step: 65500
+Train loss: 94.70610809326172	step: 65600
+Train loss: 93.39395141601562	step: 65700
+Train loss: 100.08433532714844	step: 65800
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 101.28034973144531	step: 65900
+Train loss: 89.05029296875	step: 66000
+Train loss: 90.05953216552734	step: 66100
+Train loss: 87.03773498535156	step: 66200
+Train loss: 109.26770782470703	step: 66300
+Train loss: 82.67086791992188	step: 66400
+Train loss: 76.64437103271484	step: 66500
+Train loss: 86.54629516601562	step: 66600
+Train loss: 76.48202514648438	step: 66700
+saving the model at the end of epoch 44
+validating...
+(Val @ epoch 44) acc: 0.938907284768212 ap: 0.8951623726650679 fpr: 0.012913907284768211 fnr: 0.10927152317880795
+epoch:  45
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 102.70532989501953	step: 66800
+Train loss: 98.54911804199219	step: 66900
+Train loss: 80.60196685791016	step: 67000
+Train loss: 89.60649108886719	step: 67100
+Train loss: 101.90727233886719	step: 67200
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 110.23324584960938	step: 67300
+Train loss: 90.51313781738281	step: 67400
+Train loss: 82.82902526855469	step: 67500
+Train loss: 114.34927368164062	step: 67600
+Train loss: 104.7222671508789	step: 67700
+Train loss: 104.95767211914062	step: 67800
+Train loss: 93.2955322265625	step: 67900
+Train loss: 103.30267333984375	step: 68000
+Train loss: 101.23458862304688	step: 68100
+Train loss: 90.28176879882812	step: 68200
+saving the model at the end of epoch 45
+validating...
+(Val @ epoch 45) acc: 0.9380794701986755 ap: 0.8932968424573797 fpr: 0.011258278145695364 fnr: 0.11258278145695365
+epoch:  46
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 97.50723266601562	step: 68300
+Train loss: 97.13092803955078	step: 68400
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 89.87747192382812	step: 68500
+Train loss: 90.36524963378906	step: 68600
+Train loss: 101.256591796875	step: 68700
+Train loss: 99.16970825195312	step: 68800
+Train loss: 109.6037826538086	step: 68900
+Train loss: 105.37516784667969	step: 69000
+Train loss: 94.57360076904297	step: 69100
+Train loss: 97.98590850830078	step: 69200
+Train loss: 97.60783386230469	step: 69300
+Train loss: 85.90118408203125	step: 69400
+Train loss: 97.27726745605469	step: 69500
+Train loss: 116.9710922241211	step: 69600
+Train loss: 97.3941650390625	step: 69700
+saving the model at the end of epoch 46
+validating...
+(Val @ epoch 46) acc: 0.9397350993377483 ap: 0.895867613538835 fpr: 0.010927152317880795 fnr: 0.10960264900662252
+epoch:  47
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 97.43257141113281	step: 69800
+Train loss: 94.33767700195312	step: 69900
+Train loss: 101.50326538085938	step: 70000
+Train loss: 76.67514038085938	step: 70100
+Train loss: 90.25025939941406	step: 70200
+Train loss: 82.4213638305664	step: 70300
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 105.03654479980469	step: 70400
+Train loss: 92.296630859375	step: 70500
+Train loss: 91.99394989013672	step: 70600
+Train loss: 76.64805603027344	step: 70700
+Train loss: 95.92701721191406	step: 70800
+Train loss: 90.02147674560547	step: 70900
+Train loss: 90.73638153076172	step: 71000
+Train loss: 89.86149597167969	step: 71100
+saving the model at the end of epoch 47
+validating...
+(Val @ epoch 47) acc: 0.9405629139072847 ap: 0.897211416794766 fpr: 0.010927152317880795 fnr: 0.10794701986754966
+epoch:  48
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 97.4541015625	step: 71200
+Train loss: 102.45660400390625	step: 71300
+Train loss: 69.94125366210938	step: 71400
+Train loss: 109.10926818847656	step: 71500
+Train loss: 97.28998565673828	step: 71600
+Train loss: 100.94027709960938	step: 71700
+Train loss: 94.3294677734375	step: 71800
+Train loss: 79.23173522949219	step: 71900
+Train loss: 107.92404174804688	step: 72000
+Train loss: 96.29600524902344	step: 72100
+Train loss: 93.08766174316406	step: 72200
+Train loss: 98.92930603027344	step: 72300
+Train loss: 102.63845825195312	step: 72400
+Train loss: 93.48680114746094	step: 72500
+Train loss: 105.561767578125	step: 72600
+saving the model at the end of epoch 48
+validating...
+(Val @ epoch 48) acc: 0.9395695364238411 ap: 0.8954934582458408 fpr: 0.010596026490066225 fnr: 0.11026490066225166
+epoch:  49
+/opt/conda/envs/LipFD/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).
+  warnings.warn(
+Train loss: 89.19844818115234	step: 72700
+Train loss: 105.79002380371094	step: 72800
+Train loss: 94.37416076660156	step: 72900
+Train loss: 97.48074340820312	step: 73000
+Train loss: 76.3938980102539	step: 73100
+Train loss: 93.292236328125	step: 73200
+Train loss: 93.73245239257812	step: 73300
+Train loss: 111.39205932617188	step: 73400
+Train loss: 79.65298461914062	step: 73500
+Train loss: 83.60038757324219	step: 73600
+Train loss: 90.1827392578125	step: 73700
+Train loss: 86.8857421875	step: 73800
+WARNING: Failed to read image, skipping: /apdcephfs_gy4/share_303628665/joywu/research/LipFD/datasets/FairTalking-Bench/train/1_fake/Sonic_1135_Fake_Sonic_7.png
+Train loss: 89.89358520507812	step: 73900
+Train loss: 97.02238464355469	step: 74000
+Train loss: 101.51692962646484	step: 74100
+saving the model at the end of epoch 49
+validating...
+(Val @ epoch 49) acc: 0.9405629139072847 ap: 0.896998055371985 fpr: 0.010264900662251655 fnr: 0.10860927152317881

train.py

@@ -0,0 +1,56 @@
+from validate import validate
+from data import create_dataloader
+from trainer.trainer import Trainer
+from options.train_options import TrainOptions
+
+
+def get_val_opt():
+    val_opt = TrainOptions().parse(print_options=False)
+    val_opt.isTrain = False
+    val_opt.data_label = "val"
+    val_opt.real_list_path = "./datasets/FairTalking-Bench/val/0_real"
+    val_opt.fake_list_path = "./datasets/FairTalking-Bench/val/1_fake"
+    return val_opt
+
+
+if __name__ == "__main__":
+    opt = TrainOptions().parse()
+    val_opt = get_val_opt()
+    model = Trainer(opt)
+
+    data_loader = create_dataloader(opt)
+    val_loader = create_dataloader(val_opt)
+
+    print("Length of data loader: %d" % (len(data_loader)))
+    print("Length of val  loader: %d" % (len(val_loader)))
+
+    for epoch in range(opt.epoch):
+        model.train()
+        print("epoch: ", epoch + model.step_bias)
+        for i, (img, crops, label) in enumerate(data_loader):
+            model.total_steps += 1
+
+            model.set_input((img, crops, label))
+            model.forward()
+            loss = model.get_loss()
+
+            model.optimize_parameters()
+
+            if model.total_steps % opt.loss_freq == 0:
+                print(
+                    "Train loss: {}\tstep: {}".format(
+                        model.get_loss(), model.total_steps
+                    )
+                )
+
+        if epoch % opt.save_epoch_freq == 0:
+            print("saving the model at the end of epoch %d" % (epoch + model.step_bias))
+            model.save_networks("model_epoch_%s.pth" % (epoch + model.step_bias))
+
+        model.eval()
+        ap, fpr, fnr, acc = validate(model.model, val_loader, opt.gpu_ids)
+        print(
+            "(Val @ epoch {}) acc: {} ap: {} fpr: {} fnr: {}".format(
+                epoch + model.step_bias, acc, ap, fpr, fnr
+            )
+        )

trainer/trainer.py

@@ -0,0 +1,113 @@
+import os
+import torch
+import torch.nn as nn
+from models import build_model, get_loss
+
+
+class Trainer(nn.Module):
+    def __init__(self, opt):
+        super().__init__()  # 必须先调用父类的 __init__
+        self.opt = opt
+        self.total_steps = 0
+        self.save_dir = os.path.join(opt.checkpoints_dir, opt.name)
+        self.device = (
+            torch.device("cuda:{}".format(opt.gpu_ids[0]))
+            if opt.gpu_ids
+            else torch.device("cpu")
+        )
+        self.opt = opt
+        self.model = build_model(opt.arch)
+
+        self.step_bias = (
+            0
+            if not opt.fine_tune
+            else int(opt.pretrained_model.split("_")[-1].split(".")[0]) + 1
+        )
+        if opt.fine_tune:
+            state_dict = torch.load(opt.pretrained_model, map_location="cpu")
+            self.model.load_state_dict(state_dict["model"])
+            self.total_steps = state_dict["total_steps"]
+            print(f"Model loaded @ {opt.pretrained_model.split('/')[-1]}")
+
+        if opt.fix_encoder:
+            params = []
+            for name, p in self.model.named_parameters():
+                if name.split(".")[0] in ["encoder"]:
+                    p.requires_grad = False
+                else:
+                    p.requires_grad = False
+            params = self.model.parameters()
+
+        if opt.optim == "adam":
+            self.optimizer = torch.optim.AdamW(
+                params,
+                lr=opt.lr,
+                betas=(opt.beta1, 0.999),
+                weight_decay=opt.weight_decay,
+            )
+        elif opt.optim == "sgd":
+            self.optimizer = torch.optim.SGD(
+                params, lr=opt.lr, momentum=0.0, weight_decay=opt.weight_decay
+            )
+        else:
+            raise ValueError("optim should be [adam, sgd]")
+
+        self.criterion = get_loss().to(self.device)
+        self.criterion1 = nn.CrossEntropyLoss()
+
+        self.model.to(opt.gpu_ids[0] if torch.cuda.is_available() else "cpu")
+
+    def adjust_learning_rate(self, min_lr=1e-8):
+        for param_group in self.optimizer.param_groups:
+            if param_group["lr"] < min_lr:
+                return False
+            param_group["lr"] /= 10.0
+        return True
+
+    def set_input(self, input):
+        self.input = input[0].to(self.device)
+        self.crops = [[t.to(self.device) for t in sublist] for sublist in input[1]]
+        self.label = input[2].to(self.device).float()
+
+    def forward(self):
+        self.get_features()
+        self.output, self.weights_max, self.weights_org = self.model.forward(
+            self.crops, self.features
+        )
+        self.output = self.output.view(-1)
+        self.loss = self.criterion(
+            self.weights_max, self.weights_org
+        ) + self.criterion1(self.output, self.label)
+
+    def get_loss(self):
+        loss = self.loss.data.tolist()
+        return loss[0] if isinstance(loss, type(list())) else loss
+
+    def optimize_parameters(self):
+        self.optimizer.zero_grad()
+        self.loss.backward()
+        self.optimizer.step()
+
+    def get_features(self):
+        self.features = self.model.get_features(self.input).to(
+            self.device
+        )  # shape: (batch_size
+
+    def eval(self):
+        self.model.eval()
+
+    def test(self):
+        with torch.no_grad():
+            self.forward()
+
+    def save_networks(self, save_filename):
+        save_path = os.path.join(self.save_dir, save_filename)
+
+        # serialize model and optimizer to dict
+        state_dict = {
+            "model": self.model.state_dict(),
+            "optimizer": self.optimizer.state_dict(),
+            "total_steps": self.total_steps,
+        }
+
+        torch.save(state_dict, save_path)

utils.py

@@ -0,0 +1,10 @@
+import os
+
+def get_list(path) -> list:
+    r"""Recursively read all files in root path"""
+    image_list = list()
+    for root, dirs, files in os.walk(path):
+        for f in files:
+            if f.split('.')[1] in ['png', 'jpg', 'jpeg']:
+                image_list.append(os.path.join(root, f))
+    return image_list

validate.py

@@ -0,0 +1,175 @@
+import argparse
+import torch
+import numpy as np
+import pandas as pd
+from data import AVLip
+import torch.utils.data
+from models import build_model
+from sklearn.metrics import average_precision_score, confusion_matrix, accuracy_score, roc_auc_score, roc_curve
+import os
+
+
+def custom_collate(batch):
+    """自定义 collate 函数，处理包含文件路径的批次数据"""
+    # batch 是一个列表，每个元素是 (img, crops, label, img_path)
+    imgs = torch.stack([item[0] for item in batch])
+    
+    # 处理 crops（列表的列表）：crops[scale_idx][sample_idx] 是一个 tensor
+    # 需要将其转换为：crops[scale_idx] 是一个 tensor，形状为 (batch_size, 3, 224, 224)
+    num_scales = len(batch[0][1])  # 尺度数（通常是3个：1.0x, 0.65x, 0.45x）
+    num_crops_per_scale = len(batch[0][1][0])  # 每个尺度的 crop 数量（通常是5）
+    
+    crops = []
+    for scale_idx in range(num_scales):
+        scale_crops = []
+        for crop_idx in range(num_crops_per_scale):
+            # 收集 batch 中所有样本在这个尺度和 crop 索引下的 tensor
+            crop_tensors = [batch[sample_idx][1][scale_idx][crop_idx] for sample_idx in range(len(batch))]
+            # 堆叠成一个 batch tensor
+            crop_batch = torch.stack(crop_tensors)
+            scale_crops.append(crop_batch)
+        crops.append(scale_crops)
+    
+    labels = torch.tensor([item[2] for item in batch])
+    img_paths = [item[3] for item in batch]
+    
+    return imgs, crops, labels, img_paths
+
+
+def compute_eer(y_true, y_pred_proba):
+    """计算 EER (Equal Error Rate) 和对应的阈值"""
+    # 获取 ROC 曲线上的点
+    fpr, tpr, thresholds = roc_curve(y_true, y_pred_proba)
+    fnr = 1 - tpr
+    
+    # 找到 FPR 和 FNR 差异最小的点，即为 EER
+    eer_threshold = thresholds[np.nanargmin(np.abs(fpr - fnr))]
+    eer = fpr[np.nanargmin(np.abs(fpr - fnr))]
+    
+    return eer, eer_threshold
+
+
+def compute_acc_at_eer(y_true, y_pred_proba, eer_threshold):
+    """计算在 EER 阈值下的准确率"""
+    y_pred_binary = (y_pred_proba >= eer_threshold).astype(int)
+    acc = accuracy_score(y_true, y_pred_binary)
+    return acc
+
+
+def validate(model, loader, gpu_id):
+    print("validating...")
+    device = torch.device(f"cuda:{gpu_id[0]}" if torch.cuda.is_available() else "cpu")
+    with torch.no_grad():
+        y_true, y_pred = [], []
+        img_paths = []  # 存储每个样本的文件路径
+        for batch_data in loader:
+            # 解包数据：现在使用 custom_collate，返回 (imgs, crops, labels, img_paths)
+            imgs, crops, labels, batch_paths = batch_data
+            
+            # 保存文件路径
+            img_paths.extend(batch_paths)
+            
+            img_tens = imgs.to(device)
+            # crops 现在是正确格式：crops[scale_idx][crop_idx] 是 (batch_size, 3, 224, 224)
+            # 只需要将每个 tensor 移动到 device
+            crops_tens = [[t.to(device) for t in scale_crops] for scale_crops in crops]
+            features = model.get_features(img_tens).to(device)
+
+            y_pred.extend(model(crops_tens, features)[0].sigmoid().flatten().tolist())
+            y_true.extend(labels.flatten().tolist())
+    y_true = np.array(y_true)
+    y_pred_proba = np.array(y_pred)  # 保留连续的概率值
+    y_pred_binary = np.where(y_pred_proba >= 0.5, 1, 0)  # 二值化用于 acc 计算
+
+    # Get AP (使用连续概率值)
+    ap = average_precision_score(y_true, y_pred_proba)
+    
+    # Get AUC (使用连续概率值)
+    auc = roc_auc_score(y_true, y_pred_proba)
+    
+    # 计算其他指标 (使用二值化结果)
+    cm = confusion_matrix(y_true, y_pred_binary)
+    tp, fn, fp, tn = cm.ravel()
+    fnr = fn / (fn + tp)
+    fpr = fp / (fp + tn)
+    acc = accuracy_score(y_true, y_pred_binary)
+    
+    # 计算 EER 和 ACC@EER
+    eer, eer_threshold = compute_eer(y_true, y_pred_proba)
+    acc_at_eer = compute_acc_at_eer(y_true, y_pred_proba, eer_threshold)
+    
+    return acc, ap, auc, fpr, fnr, eer, acc_at_eer, y_true, y_pred, img_paths
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument("--real_list_path", type=str, default="./datasets/val/0_real")
+    parser.add_argument("--fake_list_path", type=str, default="./datasets/val/1_fake")
+    parser.add_argument("--max_sample", type=int, default=1000, help="max number of validate samples")
+    parser.add_argument("--batch_size", type=int, default=10)
+    parser.add_argument("--data_label", type=str, default="val")
+    parser.add_argument("--arch", type=str, default="CLIP:ViT-L/14")
+    parser.add_argument("--ckpt", type=str, default="./checkpoints/ckpt.pth")
+    parser.add_argument("--gpu", type=int, default=0)
+    parser.add_argument("--output_csv", type=str, default=None, help="Path to save inference results as CSV")
+
+    opt = parser.parse_args()
+
+    device = torch.device(f"cuda:{opt.gpu}" if torch.cuda.is_available() else "cpu")
+    print(f"Using cuda {opt.gpu} for inference.")
+
+    model = build_model(opt.arch)
+    state_dict = torch.load(opt.ckpt, map_location="cpu")
+    model.load_state_dict(state_dict["model"])
+    print("Model loaded.")
+    model.eval()
+    model.to(device)
+
+    dataset = AVLip(opt)
+    loader = data_loader = torch.utils.data.DataLoader(
+        dataset, batch_size=opt.batch_size, shuffle=False,  # 改为 False 以保持顺序
+        collate_fn=custom_collate  # 使用自定义 collate 函数
+    )
+    acc, ap, auc, fpr, fnr, eer, acc_at_eer, y_true, y_pred, img_paths = validate(model, loader, gpu_id=[opt.gpu])
+    print(f"acc: {acc} ap: {ap} auc: {auc} fpr: {fpr} fnr: {fnr} eer: {eer} acc@eer: {acc_at_eer}")
+    
+    # 保存结果到 CSV
+    if opt.output_csv is not None:
+        print(f"Saving inference results to {opt.output_csv}...")
+        
+        # 计算 EER 和对应的阈值
+        eer, eer_threshold = compute_eer(np.array(y_true), np.array(y_pred))
+        acc_at_eer = compute_acc_at_eer(np.array(y_true), np.array(y_pred), eer_threshold)
+        
+        print(f"EER: {eer}, EER threshold: {eer_threshold}, ACC@EER: {acc_at_eer}")
+        
+        # 准备数据
+        results = []
+        y_pred_proba = np.array(y_pred)
+        y_pred_binary = np.where(y_pred_proba >= 0.5, 1, 0)
+        y_pred_at_eer = (y_pred_proba >= eer_threshold).astype(int)
+        
+        for i in range(len(y_true)):
+            result_dict = {
+                'img_path': img_paths[i] if i < len(img_paths) else f'sample_{i}',
+                'true_label': int(y_true[i]),
+                'pred_prob': float(y_pred_proba[i]),
+                'pred_label_05': int(y_pred_binary[i]),
+                'pred_label_eer': int(y_pred_at_eer[i])
+            }
+            results.append(result_dict)
+        
+        # 保存到 CSV
+        df = pd.DataFrame(results)
+        df.to_csv(opt.output_csv, index=False)
+        print(f"Results saved to {opt.output_csv}")
+        
+        # 保存汇总统计到另一个文件
+        summary_path = opt.output_csv.replace('.csv', '_summary.csv')
+        summary = {
+            'metric': ['acc', 'ap', 'auc', 'fpr', 'fnr', 'eer', 'acc_at_eer', 'eer_threshold'],
+            'value': [acc, ap, auc, fpr, fnr, eer, acc_at_eer, eer_threshold]
+        }
+        df_summary = pd.DataFrame(summary)
+        df_summary.to_csv(summary_path, index=False)
+        print(f"Summary saved to {summary_path}")