Upload 78 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+test3.png filter=lfs diff=lfs merge=lfs -text
+test5.png filter=lfs diff=lfs merge=lfs -text

configs/.ipynb_checkpoints/__init__-checkpoint.py

@@ -0,0 +1,7 @@
+import os
+import sys
+current_file_path = os.path.abspath(__file__)
+parent_dir = os.path.dirname(os.path.dirname(current_file_path))
+project_root_dir = os.path.dirname(parent_dir)
+sys.path.append(parent_dir)
+sys.path.append(project_root_dir)

configs/__init__.py

@@ -0,0 +1,7 @@
+import os
+import sys
+current_file_path = os.path.abspath(__file__)
+parent_dir = os.path.dirname(os.path.dirname(current_file_path))
+project_root_dir = os.path.dirname(parent_dir)
+sys.path.append(parent_dir)
+sys.path.append(project_root_dir)

configs/detector/.ipynb_checkpoints/detector-checkpoint.yaml

@@ -0,0 +1,86 @@
+# log dir 
+log_dir: ./logs_debug/clip_wavelet
+
+# model setting
+pretrained: ./training/weights/clip_wavelet_best.pth # path to a pre-trained model, if using one
+model_name: clip_wavelet   # model name
+backbone_name: vit  # backbone name
+
+#backbone setting
+backbone_config:
+  mode: original
+  num_classes: 2
+  inc: 3
+  dropout: false
+
+# dataset
+all_dataset: [FaceShifter, Celeb-DF-v1, Celeb-DF-v2]
+train_dataset: [iFakeFaceDB]
+test_dataset: [Celeb-DF-v1, Celeb-DF-v2, FaceShifter]
+
+compression: c23  # compression-level for videos
+train_batchSize: 64   # training batch size
+test_batchSize: 64   # test batch size
+workers: 8   # number of data loading workers
+frame_num: {'train': 300, 'test': 300}   # number of frames to use per video in training and testing
+resolution: 224   # resolution of output image to network
+with_mask: false   # whether to include mask information in the input
+with_landmark: false   # whether to include facial landmark information in the input
+
+
+# data augmentation
+use_data_augmentation: true  # Add this flag to enable/disable data augmentation
+data_aug:
+  flip_prob: 0.5
+  rotate_prob: 0.5
+  rotate_limit: [-10, 10]
+  blur_prob: 0.5
+  blur_limit: [3, 7]
+  brightness_prob: 0.5
+  brightness_limit: [-0.1, 0.1]
+  contrast_limit: [-0.1, 0.1]
+  quality_lower: 40
+  quality_upper: 100
+
+# mean and std for normalization
+mean: [0.5, 0.5, 0.5]
+std: [0.5, 0.5, 0.5]
+
+# optimizer config
+optimizer:
+  # choose between 'adam' and 'sgd'
+  type: adam
+  adam:
+    lr: 0.00001  # learning rate
+    beta1: 0.9  # beta1 for Adam optimizer
+    beta2: 0.999 # beta2 for Adam optimizer
+    eps: 0.00000001  # epsilon for Adam optimizer
+    weight_decay: 0.0005  # weight decay for regularization
+    amsgrad: false
+  sgd:
+    lr: 0.0002  # learning rate
+    momentum: 0.9  # momentum for SGD optimizer
+    weight_decay: 0.0005  # weight decay for regularization
+
+# training config
+lr_scheduler: null   # learning rate scheduler
+nEpochs: 50   # number of epochs to train for
+start_epoch: 0   # manual epoch number (useful for restarts)
+save_epoch: 1   # interval epochs for saving models
+rec_iter: 100   # interval iterations for recording
+logdir: ./logs   # folder to output images and logs
+manualSeed: 1024   # manual seed for random number generation
+save_ckpt: true   # whether to save checkpoint
+save_feat: true   # whether to save features
+
+# loss function
+loss_func: cross_entropy   # loss function to use
+losstype: null
+
+# metric
+metric_scoring: auc   # metric for evaluation (auc, acc, eer, ap)
+
+# cuda
+
+cuda: true   # whether to use CUDA acceleration
+cudnn: true   # whether to use CuDNN for convolution operations

configs/detector/.ipynb_checkpoints/detector2-checkpoint.yaml

@@ -0,0 +1,140 @@
+TASK: custom_laanet
+PRECISION: float64
+METRICS_BASE: binary
+SEED: 317
+DATA_RELOAD: False
+
+MODEL:
+  # PRETRAINED_PATH: '' 
+  type: PoseEfficientNet
+  model_name: efficientnet-b4
+  num_layers: B4
+  include_top: False
+  include_hm_decoder: True
+  head_conv: 64
+  use_c2: False
+  use_c3: True
+  use_c4: True
+  use_c51: True
+  efpn: True
+  tfpn: False
+  se_layer: False
+  heads:
+    hm: 1
+    cls: 1
+    cstency: 256
+  INIT_WEIGHTS:
+    pretrained: True
+    advprop: True
+
+DATASET:
+  type: BinaryFaceForensic
+  FROM_FILE: False
+  PIN_MEMORY: True
+  NUM_WORKERS: 7
+  COLOR_NORM: 'simple'  
+  mean: [0.485, 0.456, 0.406]
+  std: [0.229, 0.224, 0.225]
+  IMAGE_SUFFIX: png
+  COMPRESSION: c0
+  IMAGE_SUFFIX: png
+  IMAGE_SIZE: [384, 384]
+  HEATMAP_SIZE: [96, 96] #[IMAGE_SIZE//4, IMAGE_SIZE//4]
+  SIGMA: 2
+  ADAPTIVE_SIGMA: True
+  HEATMAP_TYPE: gaussian
+  SPLIT_IMAGE: False
+  DATA:
+    TYPE: frames
+    SAMPLES_PER_VIDEO: 
+      ACTIVE: True
+      TRAIN: 8
+      VAL: 8
+      TEST: 32
+    TRAIN:
+      NAME: custom_dataset
+      ROOT: ./datasets/train/
+      FROM_FILE: False
+      FAKETYPE: [fake]
+      LABEL_FOLDER: [real, fake]
+      
+    VAL:
+      NAME: custom_dataset
+      ROOT: ./datasets/test/
+      FROM_FILE: False
+      FAKETYPE: [fake]
+      LABEL_FOLDER: [real, fake]
+    TEST:
+      NAME: custom_dataset
+      ROOT: ./datasets/test/
+      FROM_FILE: False
+      FAKETYPE: [fake]
+      LABEL_FOLDER: [real, fake]
+  TRANSFORM:
+    geometry:
+      type: GeometryTransform
+      resize: [384, 384, 0] #h, w, p=probability. If no affine transform, set p=1
+      normalize: 0
+      horizontal_flip: 0.5
+      cropping: [0.15, 0.5] #Format: [crop_limit, prob]
+      scale: [0.15, 0.5] #Format: [scale_limit, prob]
+      rand_erasing: [0.5, 1] #Format: [p, max_count]
+    color:
+      type: ColorJitterTransform
+      clahe: 0.0
+      colorjitter: 0.3
+      gaussianblur: 0.3
+      gaussnoise: 0.3
+      jpegcompression: [0.5, 40, 100] # prob, lower and upper quality respectively
+      rgbshift: 0.3
+      randomcontrast: 0.0
+      randomgamma: 0.5
+      randombrightness: 1
+      huesat: 1
+    normalize:
+      mean: [0.5, 0.5, 0.5]
+      std: [0.5, 0.5, 0.5]
+
+TRAIN:
+  resume: True
+  gpus: [0]
+  pretrained_model: './training/weights/final_model.pth'
+  batch_size: 8
+  lr: 0.00005
+  epochs: 100
+  begin_epoch: 48
+  warm_up: 6
+  every_val_epochs: 1
+  loss:
+    type: CombinedFocalLoss
+    use_target_weight: False
+    cls_lmda: 1
+    dst_hm_cls_lmda: 0
+    offset_lmda: 0
+    hm_lmda: 100
+    cstency_lmda: 100
+    mse_reduction: sum
+    ce_reduction: mean
+  optimizer: SAM
+  distributed: False
+  tensorboard: False
+  resume: True
+  lr_scheduler:
+    # type: MultiStepLR
+    milestones: [5, 15, 20, 25]
+    gamma: 0.5
+  freeze_backbone: True
+  debug:
+    active: False
+    save_hm_gt: True
+    save_hm_pred: True
+
+TEST:
+  gpus: [0]
+  subtask: 'eval'
+  test_file: ''
+  vis_hm: True
+  threshold: 0.5
+  flip_test: True
+  video_level: True
+  pretrained: './training/weights/final_model.pth'

configs/detector/.ipynb_checkpoints/efn4_fpn_hm_adv-checkpoint.yaml

@@ -0,0 +1,159 @@
+TASK: EFN_hm10_EFPN_NoBasedCLS_Focal_C2_256Cst100_32FXRayv2_SAM(Adam)_ADV_Era3_OutSoftMax_5e5_div4_FZ
+PRECISION: float64
+METRICS_BASE: binary
+SEED: 317
+DATA_RELOAD: True
+DATASET:
+  type: HeatmapFaceForensic
+  TRAIN: True #Switch to True for training mode, False for testing mode
+  COMPRESSION: c0
+  IMAGE_SUFFIX: png
+  NUM_WORKERS: 7
+  PIN_MEMORY: True
+  IMAGE_SIZE: [384, 384]
+  HEATMAP_SIZE: [96, 96] #[IMAGE_SIZE//4, IMAGE_SIZE//4]
+  SIGMA: 2
+  ADAPTIVE_SIGMA: True
+  HEATMAP_TYPE: gaussian
+  SPLIT_IMAGE: False
+  DATA:
+    TYPE: frames
+    SAMPLES_PER_VIDEO: 
+      ACTIVE: True
+      TRAIN: 32 # Dynamically random number of frames in each epoch
+      VAL: 32
+      TEST: 32
+    TRAIN:
+      NAME: FF++ # This field to define datasets that can be used to train/in-dataset/cross-dataset evaluation
+      ROOT: /home/users/<user>/data/FaceForensics++/c0/
+      # ROOT: /data/deepfake_cluster/datasets_df/FaceForensics++/c0/
+      FROM_FILE: True
+      FAKETYPE: [Deepfakes, Face2Face, FaceSwap, NeuralTextures]
+      # ANNO_FILE: train/frames/FaceXRay/train_FF_FaceXRay.json
+      ANNO_FILE: processed_data/c0/dynamic_trainBI_FFv2.json
+      LABEL_FOLDER: [real, fake]
+    VAL:
+      NAME: FF++ # This field to define datasets that can be used to train/in-dataset/cross-dataset evaluation
+      ROOT: /Deep/datasets/
+      FROM_FILE: True
+      FAKETYPE: [Deepfakes, Face2Face, FaceSwap, NeuralTextures] # Choosing Deepfake techniques to be loaded for dataloader
+      # ANNO_FILE: val/frames/FaceXRay/val_FF_FaceXRay.json
+      ANNO_FILE: processed_data/c0/dynamic_valBI_FFv2.json
+      LABEL_FOLDER: [real, fake]
+    TEST:
+      NAME: DFW
+      # ROOT: /home/users/<user>/data/FaceForensics++/c0/
+      # ROOT: /home/users/<user>/data/Celeb-DFv1/
+      # ROOT: /data/deepfake_cluster/datasets_df/Celeb-DFv1/
+      # ROOT: /home/users/<user>/data/Celeb-DFv2/
+      # ROOT: /home/users/<user>/data/DFDCP/
+      # ROOT: /home/users/<user>/data/DFDC/
+      # ROOT: /home/users/<user>/data/DFD/
+      ROOT: /home/users/<user>/data/DFW/
+      FROM_FILE: False
+      # FAKETYPE: [original, Deepfakes]
+      # FAKETYPE: [original, Deepfakes, Face2Face, FaceSwap, NeuralTextures]
+      # FAKETYPE: [Celeb-real, Celeb-synthesis, YouTube-real]
+      # FAKETYPE: [method_A, method_B, original_videos]
+      # FAKETYPE: [fake, real]
+      # FAKETYPE: [DeepFakeDetection_original, DeepFakeDetection]
+      FAKETYPE: [real_test, fake_test]
+      ANNO_FILE: FaceXRay/test/test_FF_Xray.json
+      LABEL_FOLDER: [real, fake]
+  TRANSFORM:
+    geometry:
+      type: GeometryTransform
+      resize: [384, 384, 0] #h, w, p=probability. If no affine transform, set p=1
+      normalize: 0
+      horizontal_flip: 0.5
+      cropping: [0.15, 0.5] #Format: [crop_limit, prob]
+      scale: [0.15, 0.5] #Format: [scale_limit, prob]
+      rand_erasing: [0.5, 1] #Format: [p, max_count]
+    color:
+      type: ColorJitterTransform
+      clahe: 0.0
+      colorjitter: 0.3
+      gaussianblur: 0.3
+      gaussnoise: 0.3
+      jpegcompression: [0.5, 40, 100] # prob, lower and upper quality respectively
+      rgbshift: 0.3
+      randomcontrast: 0.0
+      randomgamma: 0.5
+      randombrightness: 1
+      huesat: 1
+    normalize:
+      mean: [0.5, 0.5, 0.5]
+      std: [0.5, 0.5, 0.5]
+  DEBUG: False
+  DYNAMIC_FXRAY: True
+MODEL:
+  type: PoseEfficientNet
+  model_name: efficientnet-b4
+  num_layers: B4
+  include_top: False
+  include_hm_decoder: True
+  head_conv: 64
+  use_c2: False
+  use_c3: True
+  use_c4: True
+  use_c51: True
+  efpn: True
+  tfpn: False
+  se_layer: False
+  heads:
+    hm: 1
+    cls: 1
+    cstency: 256
+  INIT_WEIGHTS:
+    pretrained: True
+    advprop: True
+TRAIN:
+  gpus: [0]
+  batch_size: 16
+  lr: 0.00005
+  epochs: 100
+  begin_epoch: -1
+  warm_up: 6
+  every_val_epochs: 1
+  loss:
+    type: CombinedFocalLoss
+    use_target_weight: False
+    cls_lmda: 1
+    dst_hm_cls_lmda: 0
+    offset_lmda: 0
+    hm_lmda: 10
+    cstency_lmda: 100
+    mse_reduction: sum
+    ce_reduction: mean
+  optimizer: SAM
+  distributed: False
+  pretrained: '~/Deep/training/weights/LALALAND1.pth'
+  tensorboard: True
+  resume: True
+  lr_scheduler:
+    # type: MultiStepLR
+    milestones: [5, 15, 20, 25]
+    gamma: 0.5
+  freeze_backbone: True
+  debug:
+    active: False
+    save_hm_gt: True
+    save_hm_pred: True
+TEST:
+  gpus: [0]
+  subtask: 'eval'
+  test_file: ''
+  vis_hm: True
+  threshold: 0.5
+  flip_test: True
+  video_level: True
+  pretrained: '~/Deep/training/weights/LALALAND1.pth'
+PREPROCESSING:
+  DATASET: FaceForensics
+  SPLIT: train
+  ROOT: ~/Deep/datasets/
+  FAKETYPE: [Deepfakes, Face2Face, FaceSwap, NeuralTextures]
+  IMAGE_SUFFIX: jpg
+  DATA_TYPE: images
+  LABEL: [real, fake]
+  DEBUG: False

configs/detector/detector.yaml

@@ -0,0 +1,86 @@
+# log dir 
+log_dir: ./logs_debug/clip_wavelet
+
+# model setting
+pretrained: ./training/weights/clip_wavelet_best.pth # path to a pre-trained model, if using one
+model_name: clip_wavelet   # model name
+backbone_name: vit  # backbone name
+
+#backbone setting
+backbone_config:
+  mode: original
+  num_classes: 2
+  inc: 3
+  dropout: false
+
+# dataset
+all_dataset: [FaceShifter, Celeb-DF-v1, Celeb-DF-v2]
+train_dataset: [iFakeFaceDB]
+test_dataset: [Celeb-DF-v1, Celeb-DF-v2, FaceShifter]
+
+compression: c23  # compression-level for videos
+train_batchSize: 64   # training batch size
+test_batchSize: 64   # test batch size
+workers: 8   # number of data loading workers
+frame_num: {'train': 300, 'test': 300}   # number of frames to use per video in training and testing
+resolution: 224   # resolution of output image to network
+with_mask: false   # whether to include mask information in the input
+with_landmark: false   # whether to include facial landmark information in the input
+
+
+# data augmentation
+use_data_augmentation: true  # Add this flag to enable/disable data augmentation
+data_aug:
+  flip_prob: 0.5
+  rotate_prob: 0.5
+  rotate_limit: [-10, 10]
+  blur_prob: 0.5
+  blur_limit: [3, 7]
+  brightness_prob: 0.5
+  brightness_limit: [-0.1, 0.1]
+  contrast_limit: [-0.1, 0.1]
+  quality_lower: 40
+  quality_upper: 100
+
+# mean and std for normalization
+mean: [0.5, 0.5, 0.5]
+std: [0.5, 0.5, 0.5]
+
+# optimizer config
+optimizer:
+  # choose between 'adam' and 'sgd'
+  type: adam
+  adam:
+    lr: 0.00001  # learning rate
+    beta1: 0.9  # beta1 for Adam optimizer
+    beta2: 0.999 # beta2 for Adam optimizer
+    eps: 0.00000001  # epsilon for Adam optimizer
+    weight_decay: 0.0005  # weight decay for regularization
+    amsgrad: false
+  sgd:
+    lr: 0.0002  # learning rate
+    momentum: 0.9  # momentum for SGD optimizer
+    weight_decay: 0.0005  # weight decay for regularization
+
+# training config
+lr_scheduler: null   # learning rate scheduler
+nEpochs: 50   # number of epochs to train for
+start_epoch: 0   # manual epoch number (useful for restarts)
+save_epoch: 1   # interval epochs for saving models
+rec_iter: 100   # interval iterations for recording
+logdir: ./logs   # folder to output images and logs
+manualSeed: 1024   # manual seed for random number generation
+save_ckpt: true   # whether to save checkpoint
+save_feat: true   # whether to save features
+
+# loss function
+loss_func: cross_entropy   # loss function to use
+losstype: null
+
+# metric
+metric_scoring: auc   # metric for evaluation (auc, acc, eer, ap)
+
+# cuda
+
+cuda: true   # whether to use CUDA acceleration
+cudnn: true   # whether to use CuDNN for convolution operations

configs/detector/detector2 copie.yaml

@@ -0,0 +1,142 @@
+TASK: custom_laanet
+PRECISION: float32
+METRICS_BASE: binary
+SEED: 317
+DATA_RELOAD: False
+Resume: True
+begin_epoch: 100
+
+MODEL:
+  # PRETRAINED_PATH: '' 
+  type: PoseEfficientNet
+  model_name: efficientnet-b4
+  num_layers: B4
+  include_top: False
+  include_hm_decoder: True
+  head_conv: 64
+  use_c2: False
+  use_c3: True
+  use_c4: True
+  use_c51: True
+  efpn: True
+  tfpn: False
+  se_layer: False
+  heads:
+    hm: 1
+    cls: 1
+    cstency: 256
+  INIT_WEIGHTS:
+    pretrained: True
+    advprop: True
+
+DATASET:
+  type: BinaryFaceForensic
+  FROM_FILE: False
+  PIN_MEMORY: True
+  NUM_WORKERS: 7
+  COLOR_NORM: 'simple'  
+  mean: [0.485, 0.456, 0.406]
+  std: [0.229, 0.224, 0.225]
+  IMAGE_SUFFIX: png
+  COMPRESSION: c0
+  IMAGE_SUFFIX: png
+  IMAGE_SIZE: [384, 384]
+  HEATMAP_SIZE: [96, 96] #[IMAGE_SIZE//4, IMAGE_SIZE//4]
+  SIGMA: 2
+  ADAPTIVE_SIGMA: True
+  HEATMAP_TYPE: gaussian
+  SPLIT_IMAGE: False
+  DATA:
+    TYPE: frames
+    SAMPLES_PER_VIDEO: 
+      ACTIVE: True
+      TRAIN: 8
+      VAL: 8
+      TEST: 32
+    TRAIN:
+      NAME: custom_dataset
+      ROOT: ./datasets/train/
+      FROM_FILE: False
+      FAKETYPE: [fake]
+      LABEL_FOLDER: [real, fake]
+      
+    VAL:
+      NAME: custom_dataset
+      ROOT: ./datasets/test/
+      FROM_FILE: False
+      FAKETYPE: [fake]
+      LABEL_FOLDER: [real, fake]
+    TEST:
+      NAME: custom_dataset
+      ROOT: ./datasets/test/
+      FROM_FILE: False
+      FAKETYPE: [fake]
+      LABEL_FOLDER: [real, fake]
+  TRANSFORM:
+    geometry:
+      type: GeometryTransform
+      resize: [384, 384, 0] #h, w, p=probability. If no affine transform, set p=1
+      normalize: 0
+      horizontal_flip: 0.5
+      cropping: [0.15, 0.5] #Format: [crop_limit, prob]
+      scale: [0.15, 0.5] #Format: [scale_limit, prob]
+      rand_erasing: [0.5, 1] #Format: [p, max_count]
+    color:
+      type: ColorJitterTransform
+      clahe: 0.0
+      colorjitter: 0.3
+      gaussianblur: 0.3
+      gaussnoise: 0.3
+      jpegcompression: [0.5, 40, 100] # prob, lower and upper quality respectively
+      rgbshift: 0.3
+      randomcontrast: 0.0
+      randomgamma: 0.5
+      randombrightness: 1
+      huesat: 1
+    normalize:
+      mean: [0.5, 0.5, 0.5]
+      std: [0.5, 0.5, 0.5]
+
+TRAIN:
+  resume: True
+  gpus: [0]
+  pretrained_model: './logs/27-03-2025/PoseEfficientNet_custom_laanet_model_final.pth'
+  batch_size: 32
+  lr: 0.00005
+  epochs: 150
+  begin_epoch: 100
+  warm_up: 6
+  every_val_epochs: 1
+  loss:
+    type: CombinedFocalLoss
+    use_target_weight: False
+    cls_lmda: 1
+    dst_hm_cls_lmda: 0
+    offset_lmda: 0
+    hm_lmda: 100
+    cstency_lmda: 100
+    mse_reduction: sum
+    ce_reduction: mean
+  optimizer: SAM
+  distributed: False
+  tensorboard: False
+  resume: True
+  lr_scheduler:
+    # type: MultiStepLR
+    milestones: [5, 15, 20, 25]
+    gamma: 0.5
+  freeze_backbone: True
+  debug:
+    active: False
+    save_hm_gt: True
+    save_hm_pred: True
+
+TEST:
+  gpus: [0]
+  subtask: 'eval'
+  test_file: ''
+  vis_hm: True
+  threshold: 0.5
+  flip_test: True
+  video_level: True
+  pretrained: './training/weights/final_model.pth'

configs/detector/detector2.yaml

@@ -0,0 +1,142 @@
+TASK: custom_laanet
+PRECISION: float32
+METRICS_BASE: binary
+SEED: 317
+DATA_RELOAD: False
+Resume: True
+begin_epoch: 100
+
+MODEL:
+  # PRETRAINED_PATH: '' 
+  type: PoseEfficientNet
+  model_name: efficientnet-b4
+  num_layers: B4
+  include_top: False
+  include_hm_decoder: True
+  head_conv: 64
+  use_c2: False
+  use_c3: True
+  use_c4: True
+  use_c51: True
+  efpn: True
+  tfpn: False
+  se_layer: False
+  heads:
+    hm: 1
+    cls: 1
+    cstency: 256
+  INIT_WEIGHTS:
+    pretrained: True
+    advprop: True
+
+DATASET:
+  type: BinaryFaceForensic
+  FROM_FILE: False
+  PIN_MEMORY: True
+  NUM_WORKERS: 7
+  COLOR_NORM: 'simple'  
+  mean: [0.485, 0.456, 0.406]
+  std: [0.229, 0.224, 0.225]
+  IMAGE_SUFFIX: png
+  COMPRESSION: c0
+  IMAGE_SUFFIX: png
+  IMAGE_SIZE: [384, 384]
+  HEATMAP_SIZE: [96, 96] #[IMAGE_SIZE//4, IMAGE_SIZE//4]
+  SIGMA: 2
+  ADAPTIVE_SIGMA: True
+  HEATMAP_TYPE: gaussian
+  SPLIT_IMAGE: False
+  DATA:
+    TYPE: frames
+    SAMPLES_PER_VIDEO: 
+      ACTIVE: True
+      TRAIN: 8
+      VAL: 8
+      TEST: 32
+    TRAIN:
+      NAME: custom_dataset
+      ROOT: ./datasets/train/
+      FROM_FILE: False
+      FAKETYPE: [fake]
+      LABEL_FOLDER: [real, fake]
+      
+    VAL:
+      NAME: custom_dataset
+      ROOT: ./datasets/test/
+      FROM_FILE: False
+      FAKETYPE: [fake]
+      LABEL_FOLDER: [real, fake]
+    TEST:
+      NAME: custom_dataset
+      ROOT: ./datasets/test/
+      FROM_FILE: False
+      FAKETYPE: [fake]
+      LABEL_FOLDER: [real, fake]
+  TRANSFORM:
+    geometry:
+      type: GeometryTransform
+      resize: [384, 384, 0] #h, w, p=probability. If no affine transform, set p=1
+      normalize: 0
+      horizontal_flip: 0.5
+      cropping: [0.15, 0.5] #Format: [crop_limit, prob]
+      scale: [0.15, 0.5] #Format: [scale_limit, prob]
+      rand_erasing: [0.5, 1] #Format: [p, max_count]
+    color:
+      type: ColorJitterTransform
+      clahe: 0.0
+      colorjitter: 0.3
+      gaussianblur: 0.3
+      gaussnoise: 0.3
+      jpegcompression: [0.5, 40, 100] # prob, lower and upper quality respectively
+      rgbshift: 0.3
+      randomcontrast: 0.0
+      randomgamma: 0.5
+      randombrightness: 1
+      huesat: 1
+    normalize:
+      mean: [0.5, 0.5, 0.5]
+      std: [0.5, 0.5, 0.5]
+
+TRAIN:
+  resume: True
+  gpus: [0]
+  pretrained_model: './logs/27-03-2025/PoseEfficientNet_custom_laanet_model_final.pth'
+  batch_size: 32
+  lr: 0.00005
+  epochs: 150
+  begin_epoch: 100
+  warm_up: 6
+  every_val_epochs: 1
+  loss:
+    type: CombinedFocalLoss
+    use_target_weight: False
+    cls_lmda: 1
+    dst_hm_cls_lmda: 0
+    offset_lmda: 0
+    hm_lmda: 100
+    cstency_lmda: 100
+    mse_reduction: sum
+    ce_reduction: mean
+  optimizer: SAM
+  distributed: False
+  tensorboard: False
+  resume: True
+  lr_scheduler:
+    # type: MultiStepLR
+    milestones: [5, 15, 20, 25]
+    gamma: 0.5
+  freeze_backbone: True
+  debug:
+    active: False
+    save_hm_gt: True
+    save_hm_pred: True
+
+TEST:
+  gpus: [0]
+  subtask: 'eval'
+  test_file: ''
+  vis_hm: True
+  threshold: 0.5
+  flip_test: True
+  video_level: True
+  pretrained: './training/weights/final_model.pth'

configs/detector/efn4_fpn_hm_adv.yaml

@@ -0,0 +1,159 @@
+TASK: EFN_hm10_EFPN_NoBasedCLS_Focal_C2_256Cst100_32FXRayv2_SAM(Adam)_ADV_Era3_OutSoftMax_5e5_div4_FZ
+PRECISION: float64
+METRICS_BASE: binary
+SEED: 317
+DATA_RELOAD: True
+DATASET:
+  type: HeatmapFaceForensic
+  TRAIN: True #Switch to True for training mode, False for testing mode
+  COMPRESSION: c0
+  IMAGE_SUFFIX: png
+  NUM_WORKERS: 7
+  PIN_MEMORY: True
+  IMAGE_SIZE: [384, 384]
+  HEATMAP_SIZE: [96, 96] #[IMAGE_SIZE//4, IMAGE_SIZE//4]
+  SIGMA: 2
+  ADAPTIVE_SIGMA: True
+  HEATMAP_TYPE: gaussian
+  SPLIT_IMAGE: False
+  DATA:
+    TYPE: frames
+    SAMPLES_PER_VIDEO: 
+      ACTIVE: True
+      TRAIN: 32 # Dynamically random number of frames in each epoch
+      VAL: 32
+      TEST: 32
+    TRAIN:
+      NAME: FF++ # This field to define datasets that can be used to train/in-dataset/cross-dataset evaluation
+      ROOT: /home/users/<user>/data/FaceForensics++/c0/
+      # ROOT: /data/deepfake_cluster/datasets_df/FaceForensics++/c0/
+      FROM_FILE: True
+      FAKETYPE: [Deepfakes, Face2Face, FaceSwap, NeuralTextures]
+      # ANNO_FILE: train/frames/FaceXRay/train_FF_FaceXRay.json
+      ANNO_FILE: processed_data/c0/dynamic_trainBI_FFv2.json
+      LABEL_FOLDER: [real, fake]
+    VAL:
+      NAME: FF++ # This field to define datasets that can be used to train/in-dataset/cross-dataset evaluation
+      ROOT: /Deep/datasets/
+      FROM_FILE: True
+      FAKETYPE: [Deepfakes, Face2Face, FaceSwap, NeuralTextures] # Choosing Deepfake techniques to be loaded for dataloader
+      # ANNO_FILE: val/frames/FaceXRay/val_FF_FaceXRay.json
+      ANNO_FILE: processed_data/c0/dynamic_valBI_FFv2.json
+      LABEL_FOLDER: [real, fake]
+    TEST:
+      NAME: DFW
+      # ROOT: /home/users/<user>/data/FaceForensics++/c0/
+      # ROOT: /home/users/<user>/data/Celeb-DFv1/
+      # ROOT: /data/deepfake_cluster/datasets_df/Celeb-DFv1/
+      # ROOT: /home/users/<user>/data/Celeb-DFv2/
+      # ROOT: /home/users/<user>/data/DFDCP/
+      # ROOT: /home/users/<user>/data/DFDC/
+      # ROOT: /home/users/<user>/data/DFD/
+      ROOT: /home/users/<user>/data/DFW/
+      FROM_FILE: False
+      # FAKETYPE: [original, Deepfakes]
+      # FAKETYPE: [original, Deepfakes, Face2Face, FaceSwap, NeuralTextures]
+      # FAKETYPE: [Celeb-real, Celeb-synthesis, YouTube-real]
+      # FAKETYPE: [method_A, method_B, original_videos]
+      # FAKETYPE: [fake, real]
+      # FAKETYPE: [DeepFakeDetection_original, DeepFakeDetection]
+      FAKETYPE: [real_test, fake_test]
+      ANNO_FILE: FaceXRay/test/test_FF_Xray.json
+      LABEL_FOLDER: [real, fake]
+  TRANSFORM:
+    geometry:
+      type: GeometryTransform
+      resize: [384, 384, 0] #h, w, p=probability. If no affine transform, set p=1
+      normalize: 0
+      horizontal_flip: 0.5
+      cropping: [0.15, 0.5] #Format: [crop_limit, prob]
+      scale: [0.15, 0.5] #Format: [scale_limit, prob]
+      rand_erasing: [0.5, 1] #Format: [p, max_count]
+    color:
+      type: ColorJitterTransform
+      clahe: 0.0
+      colorjitter: 0.3
+      gaussianblur: 0.3
+      gaussnoise: 0.3
+      jpegcompression: [0.5, 40, 100] # prob, lower and upper quality respectively
+      rgbshift: 0.3
+      randomcontrast: 0.0
+      randomgamma: 0.5
+      randombrightness: 1
+      huesat: 1
+    normalize:
+      mean: [0.5, 0.5, 0.5]
+      std: [0.5, 0.5, 0.5]
+  DEBUG: False
+  DYNAMIC_FXRAY: True
+MODEL:
+  type: PoseEfficientNet
+  model_name: efficientnet-b4
+  num_layers: B4
+  include_top: False
+  include_hm_decoder: True
+  head_conv: 64
+  use_c2: False
+  use_c3: True
+  use_c4: True
+  use_c51: True
+  efpn: True
+  tfpn: False
+  se_layer: False
+  heads:
+    hm: 1
+    cls: 1
+    cstency: 256
+  INIT_WEIGHTS:
+    pretrained: True
+    advprop: True
+TRAIN:
+  gpus: [0]
+  batch_size: 16
+  lr: 0.00005
+  epochs: 100
+  begin_epoch: -1
+  warm_up: 6
+  every_val_epochs: 1
+  loss:
+    type: CombinedFocalLoss
+    use_target_weight: False
+    cls_lmda: 1
+    dst_hm_cls_lmda: 0
+    offset_lmda: 0
+    hm_lmda: 10
+    cstency_lmda: 100
+    mse_reduction: sum
+    ce_reduction: mean
+  optimizer: SAM
+  distributed: False
+  pretrained: '~/Deep/training/weights/LALALAND1.pth'
+  tensorboard: True
+  resume: True
+  lr_scheduler:
+    # type: MultiStepLR
+    milestones: [5, 15, 20, 25]
+    gamma: 0.5
+  freeze_backbone: True
+  debug:
+    active: False
+    save_hm_gt: True
+    save_hm_pred: True
+TEST:
+  gpus: [0]
+  subtask: 'eval'
+  test_file: ''
+  vis_hm: True
+  threshold: 0.5
+  flip_test: True
+  video_level: True
+  pretrained: '~/Deep/training/weights/LALALAND1.pth'
+PREPROCESSING:
+  DATASET: FaceForensics
+  SPLIT: train
+  ROOT: ~/Deep/datasets/
+  FAKETYPE: [Deepfakes, Face2Face, FaceSwap, NeuralTextures]
+  IMAGE_SUFFIX: jpg
+  DATA_TYPE: images
+  LABEL: [real, fake]
+  DEBUG: False

configs/get_config.py

@@ -0,0 +1,16 @@
+#-*- coding: utf-8 -*-
+import os
+
+from yaml import load, dump
+try:
+    from yaml import CLoader as Loader, CDumper as Dumper
+except ImportError:
+    from yaml import Loader, Dumper    
+from box import Box as edict
+
+
+def load_config(cfg):
+    with open(cfg) as f:
+        config = load(f, Loader=Loader)
+
+    return edict(config)

configs/test_config.yaml

@@ -0,0 +1,38 @@
+mode: test
+lmdb: False
+rgb_dir: '/ssd_scratch/deep_fake_dataset/'
+lmdb_dir: '/ssd_scratch/deep_fake_dataset/datasets_lmdbs/'
+dataset_json_folder: './preprocessing/dataset_json_v6/'
+label_dict:
+  # DFD
+  DFD_fake: 1
+  DFD_real: 0
+  # FF++ + FaceShifter(FF-real+FF-FH)
+  FF-SH: 1
+  FF-F2F: 1
+  FF-DF: 1
+  FF-FS: 1
+  FF-NT: 1
+  FF-FH: 1
+  FF-real: 0
+  # CelebDF
+  CelebDFv1_real: 0
+  CelebDFv1_fake: 1
+  CelebDFv2_real: 0
+  CelebDFv2_fake: 1
+  # DFDCP
+  DFDCP_Real: 0
+  DFDCP_FakeA: 1
+  DFDCP_FakeB: 1
+  # DFDC
+  DFDC_Fake: 1
+  DFDC_Real: 0
+  # DeeperForensics-1.0
+  DF_fake: 1
+  DF_real: 0
+  # UADFV
+  UADFV_Fake: 1
+  UADFV_Real: 0
+  # Roop
+  roop_Real: 0
+  roop_Fake: 1

configs/train_config copie.yaml

@@ -0,0 +1,43 @@
+mode: train
+lmdb: False
+dry_run: False
+rgb_dir: '/ssd_scratch/deep_fake_dataset/'
+lmdb_dir: '/ssd_scratch/deep_fake_dataset/datasets_lmdbs/'
+dataset_json_folder: './preprocessing/dataset_json_v6/'
+SWA: False
+save_avg: True
+log_dir: ./logs/training/
+# label settings
+label_dict:
+  # DFD
+  DFD_fake: 1
+  DFD_real: 0
+  # FF++ + FaceShifter(FF-real+FF-FH)
+  FF-SH: 1
+  FF-F2F: 1
+  FF-DF: 1
+  FF-FS: 1
+  FF-NT: 1
+  FF-FH: 1
+  FF-real: 0
+  # CelebDF
+  CelebDFv1_real: 0
+  CelebDFv1_fake: 1
+  CelebDFv2_real: 0
+  CelebDFv2_fake: 1
+  # DFDCP
+  DFDCP_Real: 0
+  DFDCP_FakeA: 1
+  DFDCP_FakeB: 1
+  # DFDC
+  DFDC_Fake: 1
+  DFDC_Real: 0
+  # DeeperForensics-1.0
+  DF_fake: 1
+  DF_real: 0
+  # UADFV
+  UADFV_Fake: 1
+  UADFV_Real: 0
+  # Roop
+  roop_Real: 0
+  roop_Fake: 1

configs/train_config.yaml

@@ -0,0 +1,46 @@
+mode: train
+lmdb: False
+dry_run: False
+rgb_dir: '/ssd_scratch/deep_fake_dataset/'
+lmdb_dir: '/ssd_scratch/deep_fake_dataset/datasets_lmdbs/'
+dataset_json_folder: './preprocessing/dataset_json_v6/'
+SWA: False
+save_avg: True
+log_dir: ./logs/training/
+# label settings
+label_dict:
+  # iFakeFaceDB labels
+  real: 0
+  fake: 1
+  # DFD
+  DFD_fake: 1
+  DFD_real: 0
+  # FF++ + FaceShifter(FF-real+FF-FH)
+  FF-SH: 1
+  FF-F2F: 1
+  FF-DF: 1
+  FF-FS: 1
+  FF-NT: 1
+  FF-FH: 1
+  FF-real: 0
+  # CelebDF
+  CelebDFv1_real: 0
+  CelebDFv1_fake: 1
+  CelebDFv2_real: 0
+  CelebDFv2_fake: 1
+  # DFDCP
+  DFDCP_Real: 0
+  DFDCP_FakeA: 1
+  DFDCP_FakeB: 1
+  # DFDC
+  DFDC_Fake: 1
+  DFDC_Real: 0
+  # DeeperForensics-1.0
+  DF_fake: 1
+  DF_real: 0
+  # UADFV
+  UADFV_Fake: 1
+  UADFV_Real: 0
+  # Roop
+  roop_Real: 0
+  roop_Fake: 1

loss/__init__.py

@@ -0,0 +1,11 @@
+import os
+import sys
+current_file_path = os.path.abspath(__file__)
+parent_dir = os.path.dirname(os.path.dirname(current_file_path))
+project_root_dir = os.path.dirname(parent_dir)
+sys.path.append(parent_dir)
+sys.path.append(project_root_dir)
+
+from metrics.registry import LOSSFUNC
+
+from .cross_entropy_loss import CrossEntropyLoss

loss/abstract_loss_func.py

@@ -0,0 +1,17 @@
+import torch.nn as nn
+
+class AbstractLossClass(nn.Module):
+    """Abstract class for loss functions."""
+    def __init__(self):
+        super(AbstractLossClass, self).__init__()
+
+    def forward(self, pred, label):
+        """
+        Args:
+            pred: prediction of the model
+            label: ground truth label
+            
+        Return:
+            loss: loss value
+        """
+        raise NotImplementedError('Each subclass should implement the forward method.')

loss/cross_entropy_loss.py

@@ -0,0 +1,26 @@
+import torch.nn as nn
+from .abstract_loss_func import AbstractLossClass
+from metrics.registry import LOSSFUNC
+
+
+@LOSSFUNC.register_module(module_name="cross_entropy")
+class CrossEntropyLoss(AbstractLossClass):
+    def __init__(self):
+        super().__init__()
+        self.loss_fn = nn.CrossEntropyLoss()
+
+    def forward(self, inputs, targets):
+        """
+        Computes the cross-entropy loss.
+
+        Args:
+            inputs: A PyTorch tensor of size (batch_size, num_classes) containing the predicted scores.
+            targets: A PyTorch tensor of size (batch_size) containing the ground-truth class indices.
+
+        Returns:
+            A scalar tensor representing the cross-entropy loss.
+        """
+        # Compute the cross-entropy loss
+        loss = self.loss_fn(inputs, targets)
+
+        return loss

metrics/__init__.py

@@ -0,0 +1,7 @@
+import os
+import sys
+current_file_path = os.path.abspath(__file__)
+parent_dir = os.path.dirname(os.path.dirname(current_file_path))
+project_root_dir = os.path.dirname(parent_dir)
+sys.path.append(parent_dir)
+sys.path.append(project_root_dir)

metrics/base_metrics_class.py

@@ -0,0 +1,204 @@
+import numpy as np
+from sklearn import metrics
+import torch
+import torch.nn as nn
+
+
+def get_accracy(output, label):
+    _, prediction = torch.max(output, 1)    # argmax
+    correct = (prediction == label).sum().item()
+    accuracy = correct / prediction.size(0)
+    return accuracy
+
+
+def get_prediction(output, label):
+    prob = nn.functional.softmax(output, dim=1)[:, 1]
+    prob = prob.view(prob.size(0), 1)
+    label = label.view(label.size(0), 1)
+    #print(prob.size(), label.size())
+    datas = torch.cat((prob, label.float()), dim=1)
+    return datas
+
+
+def calculate_metrics_for_train(label, output):
+    if output.size(1) == 2:
+        prob = torch.softmax(output, dim=1)[:, 1]
+    else:
+        prob = output
+
+    # Accuracy
+    _, prediction = torch.max(output, 1)
+    correct = (prediction == label).sum().item()
+    accuracy = correct / prediction.size(0)
+
+    # Average Precision
+    y_true = label.cpu().detach().numpy()
+    y_pred = prob.cpu().detach().numpy()
+    ap = metrics.average_precision_score(y_true, y_pred)
+
+    # AUC and EER
+    try:
+        fpr, tpr, thresholds = metrics.roc_curve(label.squeeze().cpu().numpy(),
+                                                 prob.squeeze().cpu().numpy(),
+                                                 pos_label=1)
+    except:
+        # for the case when we only have one sample
+        return None, None, accuracy, ap
+
+    if np.isnan(fpr[0]) or np.isnan(tpr[0]):
+        # for the case when all the samples within a batch is fake/real
+        auc, eer = None, None
+    else:
+        auc = metrics.auc(fpr, tpr)
+        fnr = 1 - tpr
+        eer = fpr[np.nanargmin(np.absolute((fnr - fpr)))]
+
+    return auc, eer, accuracy, ap
+
+
+# ------------ compute average metrics of batches---------------------
+class Metrics_batch():
+    def __init__(self):
+        self.tprs = []
+        self.mean_fpr = np.linspace(0, 1, 100)
+        self.aucs = []
+        self.eers = []
+        self.aps = []
+
+        self.correct = 0
+        self.total = 0
+        self.losses = []
+
+    def update(self, label, output):
+        acc = self._update_acc(label, output)
+        if output.size(1) == 2:
+            prob = torch.softmax(output, dim=1)[:, 1]
+        else:
+            prob = output
+        #label = 1-label
+        #prob = torch.softmax(output, dim=1)[:, 1]
+        auc, eer = self._update_auc(label, prob)
+        ap = self._update_ap(label, prob)
+
+        return acc, auc, eer, ap
+
+    def _update_auc(self, lab, prob):
+        fpr, tpr, thresholds = metrics.roc_curve(lab.squeeze().cpu().numpy(),
+                                                 prob.squeeze().cpu().numpy(),
+                                                 pos_label=1)
+        if np.isnan(fpr[0]) or np.isnan(tpr[0]):
+            return -1, -1
+
+        auc = metrics.auc(fpr, tpr)
+        interp_tpr = np.interp(self.mean_fpr, fpr, tpr)
+        interp_tpr[0] = 0.0
+        self.tprs.append(interp_tpr)
+        self.aucs.append(auc)
+
+        # return auc
+
+        # EER
+        fnr = 1 - tpr
+        eer = fpr[np.nanargmin(np.absolute((fnr - fpr)))]
+        self.eers.append(eer)
+
+        return auc, eer
+
+    def _update_acc(self, lab, output):
+        _, prediction = torch.max(output, 1)    # argmax
+        correct = (prediction == lab).sum().item()
+        accuracy = correct / prediction.size(0)
+        # self.accs.append(accuracy)
+        self.correct = self.correct+correct
+        self.total = self.total+lab.size(0)
+        return accuracy
+
+    def _update_ap(self, label, prob):
+        y_true = label.cpu().detach().numpy()
+        y_pred = prob.cpu().detach().numpy()
+        ap = metrics.average_precision_score(y_true,y_pred)
+        self.aps.append(ap)
+
+        return np.mean(ap)
+
+    def get_mean_metrics(self):
+        mean_acc, std_acc = self.correct/self.total, 0
+        mean_auc, std_auc = self._mean_auc()
+        mean_err, std_err = np.mean(self.eers), np.std(self.eers)
+        mean_ap, std_ap = np.mean(self.aps), np.std(self.aps)
+        
+        return {'acc':mean_acc, 'auc':mean_auc, 'eer':mean_err, 'ap':mean_ap}
+
+    def _mean_auc(self):
+        mean_tpr = np.mean(self.tprs, axis=0)
+        mean_tpr[-1] = 1.0
+        mean_auc = metrics.auc(self.mean_fpr, mean_tpr)
+        std_auc = np.std(self.aucs)
+        return mean_auc, std_auc
+
+    def clear(self):
+        self.tprs.clear()
+        self.aucs.clear()
+        # self.accs.clear()
+        self.correct=0
+        self.total=0
+        self.eers.clear()
+        self.aps.clear()
+        self.losses.clear()
+
+
+# ------------ compute average metrics of all data ---------------------
+class Metrics_all():
+    def __init__(self):
+        self.probs = []
+        self.labels = []
+        self.correct = 0
+        self.total = 0
+
+    def store(self, label, output):
+        prob = torch.softmax(output, dim=1)[:, 1]
+        _, prediction = torch.max(output, 1)    # argmax
+        correct = (prediction == label).sum().item()
+        self.correct += correct
+        self.total += label.size(0)
+        self.labels.append(label.squeeze().cpu().numpy())
+        self.probs.append(prob.squeeze().cpu().numpy())
+
+    def get_metrics(self):
+        y_pred = np.concatenate(self.probs)
+        y_true = np.concatenate(self.labels)
+        # auc
+        fpr, tpr, thresholds = metrics.roc_curve(y_true,y_pred,pos_label=1)
+        auc = metrics.auc(fpr, tpr)
+        # eer
+        fnr = 1 - tpr
+        eer = fpr[np.nanargmin(np.absolute((fnr - fpr)))]
+        # ap
+        ap = metrics.average_precision_score(y_true,y_pred)
+        # acc
+        acc = self.correct / self.total
+        return {'acc':acc, 'auc':auc, 'eer':eer, 'ap':ap}
+
+    def clear(self):
+        self.probs.clear()
+        self.labels.clear()
+        self.correct = 0
+        self.total = 0
+
+
+# only used to record a series of scalar value
+class Recorder:
+    def __init__(self):
+        self.sum = 0
+        self.num = 0
+    def update(self, item, num=1):
+        if item is not None:
+            self.sum += item * num
+            self.num += num
+    def average(self):
+        if self.num == 0:
+            return None
+        return self.sum/self.num
+    def clear(self):
+        self.sum = 0
+        self.num = 0

metrics/registry.py

@@ -0,0 +1,19 @@
+class Registry(object):
+    def __init__(self):
+        self.data = {}
+
+    def register_module(self, module_name=None):
+        def _register(cls):
+            name = module_name
+            if module_name is None:
+                name = cls.__name__
+            self.data[name] = cls
+            return cls
+        return _register
+
+    def __getitem__(self, key):
+        return self.data[key]
+
+DETECTOR = Registry()
+TRAINER  = Registry()
+LOSSFUNC = Registry()

metrics/utils.py

@@ -0,0 +1,92 @@
+from sklearn import metrics
+import numpy as np
+
+def parse_metric_for_print(metric_dict):
+    if metric_dict is None:
+        return "\n"
+    str = "\n"
+    str += "================================ Each dataset best metric ================================ \n"
+    for key, value in metric_dict.items():
+        if key != 'avg':
+            str= str+ f"| {key}: "
+            for k,v in value.items():
+                str = str + f" {k}={v} "
+            str= str+ "| \n"
+        else:
+            str += "============================================================================================= \n"
+            str += "================================== Average best metric ====================================== \n"
+            avg_dict = value
+            for avg_key, avg_value in avg_dict.items():
+                if avg_key == 'dataset_dict':
+                    for key,value in avg_value.items():
+                        str = str + f"| {key}: {value} | \n"
+                else:
+                    str = str + f"| avg {avg_key}: {avg_value} | \n"
+    str += "============================================================================================="
+    return str
+
+
+def get_test_metrics(y_pred, y_true, img_names):
+    def get_video_metrics(image, pred, label):
+        result_dict = {}
+        new_label = []
+        new_pred = []
+        # print(image[0])
+        # print(pred.shape)
+        # print(label.shape)
+        for item in np.transpose(np.stack((image, pred, label)), (1, 0)):
+
+            s = item[0]
+            if '\\' in s:
+                parts = s.split('\\')
+            else:
+                parts = s.split('/')
+            a = parts[-2]
+            b = parts[-1]
+
+            if a not in result_dict:
+                result_dict[a] = []
+
+            result_dict[a].append(item)
+        image_arr = list(result_dict.values())
+
+        for video in image_arr:
+            pred_sum = 0
+            label_sum = 0
+            leng = 0
+            for frame in video:
+                pred_sum += float(frame[1])
+                label_sum += int(frame[2])
+                leng += 1
+            new_pred.append(pred_sum / leng)
+            new_label.append(int(label_sum / leng))
+        fpr, tpr, thresholds = metrics.roc_curve(new_label, new_pred)
+        v_auc = metrics.auc(fpr, tpr)
+        fnr = 1 - tpr
+        v_eer = fpr[np.nanargmin(np.absolute((fnr - fpr)))]
+        return v_auc, v_eer
+
+
+    y_pred = y_pred.squeeze()
+    # For UCF, where labels for different manipulations are not consistent.
+    y_true[y_true >= 1] = 1
+    # auc
+    fpr, tpr, thresholds = metrics.roc_curve(y_true, y_pred, pos_label=1)
+    auc = metrics.auc(fpr, tpr)
+    # eer
+    fnr = 1 - tpr
+    eer = fpr[np.nanargmin(np.absolute((fnr - fpr)))]
+    # ap
+    ap = metrics.average_precision_score(y_true, y_pred)
+    # acc
+    prediction_class = (y_pred > 0.5).astype(int)
+    correct = (prediction_class == np.clip(y_true, a_min=0, a_max=1)).sum().item()
+    acc = correct / len(prediction_class)
+    if type(img_names[0]) is not list:
+        # calculate video-level auc for the frame-level methods.
+        v_auc, _ = get_video_metrics(img_names, y_pred, y_true)
+    else:
+        # video-level methods
+        v_auc=auc
+
+    return {'acc': acc, 'auc': auc, 'eer': eer, 'ap': ap, 'pred': y_pred, 'video_auc': v_auc, 'label': y_true}

models/__init__.py

@@ -0,0 +1,29 @@
+#-*- coding: utf-8 -*-
+from .builder import MODELS, build_model
+from .networks.arcface import (
+    SimpleClassificationDF,
+)
+from .networks.mrsa_resnet import (
+    PoseResNet, resnet_spec, Bottleneck
+)
+from .networks.pose_hrnet import (
+    PoseHighResolutionNet
+)
+from .networks.xception import (
+    Xception
+)
+from.networks.pose_efficientNet import (
+    PoseEfficientNet
+)
+from .networks.common import *
+from .utils import (
+    load_pretrained, freeze_backbone,
+    load_model, save_model, unfreeze_backbone,
+    preset_model,
+)
+
+
+__all__=['SimpleClassificationDF', 'PoseResNet', 'MODELS', 'build_model', 
+         'load_pretrained', 'freeze_backbone', 'resnet_spec',
+         'load_model', 'save_model', 'unfreeze_backbone', 'Bottleneck',
+         'preset_model', 'PoseHighResolutionNet', 'Xception', 'PoseEfficientNet']

models/builder.py

@@ -0,0 +1,45 @@
+#-*- coding: utf-8 -*-
+from typing import Dict, Any, Optional
+
+import os
+import sys
+if not os.getcwd() in sys.path:
+    sys.path.append(os.getcwd())
+
+from torch.nn import Sequential
+
+from register.register import Registry, build_from_cfg
+
+
+def build_model_from_cfg(cfg, registry, default_args=None):
+    """Build a PyTorch model from config dict(s). Different from
+    ``build_from_cfg``, if cfg is a list, a ``nn.Sequential`` will be built.
+    Args:
+        cfg (dict, list[dict]): The config of modules, is is either a config
+            dict or a list of config dicts. If cfg is a list, a
+            the built modules will be wrapped with ``nn.Sequential``.
+        registry (:obj:`Registry`): A registry the module belongs to.
+        default_args (dict, optional): Default arguments to build the module.
+            Defaults to None.
+    Returns:
+        nn.Module: A built nn module.
+    """
+    if isinstance(cfg, list):
+        modules = [
+            build_from_cfg(cfg_, registry, default_args) for cfg_ in cfg
+        ]
+        return Sequential(*modules)
+    else:
+        return build_from_cfg(cfg, registry, default_args)
+
+
+MODELS = Registry('model', build_func=build_model_from_cfg)
+HEADS = MODELS
+BACKBONES = MODELS
+
+
+def build_model(cfg: Dict,
+                model: Registry,
+                build_func=build_model_from_cfg,
+                default_args: Optional[Dict] = None) -> Any:
+    return build_func(cfg, model, default_args)