update xception evaluation code

Author: ControlNet

.gitignore

@@ -440,3 +440,5 @@ docs/_build/
 
 # Pyenv
 .python-version
+
+lightning_logs

Cargo.lock

@@ -131,7 +131,7 @@ Evaluate the predictions. Firstly prepare the predictions as described in the [d
 ```python
 from avdeepfake1m.evaluation import ap_ar_1d, auc
 print(ap_ar_1d("<PREDICTION_JSON>", "<METADATA_JSON>", "file", "fake_segments", 1, [0.5, 0.75, 0.9, 0.95], [50, 30, 20, 10, 5], [0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95]))
-print(auc("<PREDICTION_TXT>", "<METADATA_JSON>"))
+print(auc("<PREDICTION_TXT>", "<METADATA_JSON>", "file", "fake_segments"))
 ```
 
 ## License

README.md

@@ -16,8 +16,32 @@ This example trains a Xception model on the AVDeepfake1M/AVDeepfake1M++ dataset
 ```bash
 python train.py --data_root /path/to/avdeepfake1m --model xception
 ```
+### Output
 
-## Output
-
-*   **Checkpoints:** Model checkpoints are saved under `./ckpt1/xception/`. The last checkpoint is saved as `last.ckpt`.
+*   **Checkpoints:** Model checkpoints are saved under `./ckpt/xception/`. The last checkpoint is saved as `last.ckpt`.
 *   **Logs:** Training logs (including metrics like `train_loss`, `val_loss`, and learning rates) are saved by PyTorch Lightning, typically in a directory named `./lightning_logs/`. You can view these logs using TensorBoard (`tensorboard --logdir ./lightning_logs`). 
+
+
+## Inference
+
+After training, you can generate predictions on a dataset subset (train, val, or test) using `infer.py`. This script will save the predictions to a text file, following the format from the [challenge](https://deepfakes1m.github.io/2025/details).
+
+```bash
+python infer.py --data_root /path/to/avdeepfake1m --checkpoint /path/to/your/checkpoint.ckpt --model xception --subset val
+```
+
+The output prediction file will be saved to `output/<model_name>_<subset>.txt` (e.g., `output/xception_val.txt`).
+
+## Evaluation
+
+```bash
+python evaluate.py <path_to_prediction_file> <path_to_metadata_json>
+```
+
+For example:
+
+```bash
+python evaluate.py ./output/xception_val.txt /path/to/avdeepfake1m/val_metadata.json
+```
+
+This will print the AUC score based on your model's predictions. 

examples/xception/README.md

@@ -0,0 +1,16 @@
+import argparse
+
+from avdeepfake1m.evaluation import auc
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Evaluation script for AV-Deepfake1M")
+    parser.add_argument("prediction_file_path", type=str, help="Path to the prediction file (e.g., output/results/xception_val.txt)")
+    parser.add_argument("metadata_file_path", type=str, help="Path to the metadata JSON file (e.g., /path/to/val_metadata.json)")
+    args = parser.parse_args()
+
+    print(auc(
+        args.prediction_file_path,
+        args.metadata_file_path,
+        "file",  # As per README, this is usually "file"
+        "fake_segments"  # As per README, this is usually "fake_segments" for AUC
+    ))

examples/xception/evaluate.py

@@ -0,0 +1,49 @@
+import argparse
+
+import torch
+from tqdm.auto import tqdm
+from pathlib import Path
+
+from avdeepfake1m.loader import AVDeepfake1mPlusPlusVideo
+from xception import Xception
+
+parser = argparse.ArgumentParser(description="Xception inference")
+parser.add_argument("--data_root", type=str)
+parser.add_argument("--checkpoint", type=str)
+parser.add_argument("--model", type=str)
+parser.add_argument("--batch_size", type=int, default=128)
+parser.add_argument("--subset", type=str, choices=["train", "val", "test"])
+parser.add_argument("--gpus", type=int, default=1)
+parser.add_argument("--take_num", type=int, default=None)
+
+if __name__ == '__main__':
+    args = parser.parse_args()
+    use_gpu = args.gpus > 0
+    device = "cuda" if use_gpu else "cpu"
+
+    if args.model == "xception":
+        model = Xception.load_from_checkpoint(args.checkpoint, lr=None, distributed=False).eval()
+    else:
+        raise ValueError(f"Unknown model: {args.model}")
+
+    model.to(device)
+    model.train()
+    test_dataset = AVDeepfake1mPlusPlusVideo(args.subset, args.data_root, take_num=args.take_num)
+
+    save_path = f"output/{args.model}_{args.subset}.txt"
+    Path(save_path).parent.mkdir(parents=True, exist_ok=True)
+    with open(save_path, "w") as f:
+        with torch.inference_mode():
+            for i, (video, _, label) in enumerate(tqdm(test_dataset)):
+                # batch video as frames use batch_size
+                preds_video = []
+                for j in range(0, len(video), args.batch_size):
+                    batch = video[j:j + args.batch_size].to(device)
+                    preds_video.append(model(batch))
+
+                preds_video = torch.cat(preds_video, dim=0).flatten()
+                # choose the max prediction
+                pred = preds_video.max().item()
+
+                file_name = test_dataset.metadata[i].file
+                f.write(f"{file_name};{pred}\n")