trim redundant training/doc files from deepfake-whisper-features

deepfake-whisper-features/README

@@ -1,6 +0,0 @@
-1. Prepare metadata.csv file in the same way we prepare one for df_arena toolkit
-2. Go inside src/datasets/generic_deep_faket_dataset.py 
-3. Change filepath in line 31 to path of desired metadata file.
-            self.samples=pd.read_csv('/data/code/df_arena_stuff/df_arena_metadata/asvspoof_2024_eval.csv', names=['file', 'label' ], header=0)        
-4. Change name of output score file inside evaluate_models_2019.py on line 162 and 165 to desired name
-5. Do inference using python evaluate_models_2019.py --config /mesonet_whisper_mfcc_finetuned/config.yaml

deepfake-whisper-features/configs/finetuning/whisper_frontend_mesonet.yaml

@@ -1,16 +0,0 @@
-data:
-  seed: 42
-
-checkpoint:
-  path: "trained_models/whisper_frontend_mesonet/ckpt.pth"
-
-model:
-  name: "whisper_frontend_mesonet"
-  parameters:
-    freeze_encoder: false
-    input_channels: 2
-    fc1_dim: 1024
-    frontend_algorithm: ["lfcc"]
-  optimizer:
-    lr: 1.0e-06
-    weight_decay: 0.0001

deepfake-whisper-features/configs/training/lcnn.yaml

@@ -1,14 +0,0 @@
-data:
-  seed: 42
-
-checkpoint:
-  path: ""
-
-model:
-  name: "lcnn"
-  parameters:
-    input_channels: 1
-    frontend_algorithm: ["mfcc"]
-  optimizer:
-    lr: 0.0001
-    weight_decay: 0.0001

deepfake-whisper-features/configs/training/mesonet.yaml

@@ -1,15 +0,0 @@
-data:
-  seed: 42
-
-checkpoint:
-  path: ""
-
-model:
-  name: "mesonet"
-  parameters:
-    input_channels: 1
-    fc1_dim: 1024
-    frontend_algorithm: ["lfcc"]
-  optimizer:
-    lr: 0.0001
-    weight_decay: 0.0001

deepfake-whisper-features/configs/training/rawnet3.yaml

@@ -1,13 +0,0 @@
-data:
-  seed: 42
-
-checkpoint:
-  path: ""
-
-model:
-  name: "rawnet3"
-  parameters: {}
-  optimizer:
-    lr: 0.001
-    weight_decay: 0.00005  # 5e-5
-

deepfake-whisper-features/configs/training/specrnet.yaml

@@ -1,14 +0,0 @@
-data:
-  seed: 42
-
-checkpoint:
-  path: ""
-
-model:
-  name: "specrnet"
-  parameters:
-    input_channels: 1
-    frontend_algorithm: ["lfcc"]
-  optimizer:
-    lr: 0.0001
-    weight_decay: 0.0001

deepfake-whisper-features/configs/training/whisper_frontend_lcnn.yaml

@@ -1,16 +0,0 @@
-data:
-  seed: 42
-
-checkpoint:
-  path: ""
-
-model:
-  name: "whisper_frontend_lcnn"
-  parameters:
-    freeze_encoder: True
-    input_channels: 2
-    frontend_algorithm: ["lfcc"]
-  optimizer:
-    lr: 0.0001
-    weight_decay: 0.0001
-

deepfake-whisper-features/configs/training/whisper_frontend_lcnn_mfcc.yaml

@@ -1,15 +0,0 @@
-data:
-  seed: 42
-
-checkpoint:
-  path: ""
-
-model:
-  name: "whisper_frontend_lcnn"
-  parameters:
-    freeze_encoder: True
-    input_channels: 2
-    frontend_algorithm: ["mfcc"]
-  optimizer:
-    lr: 0.0001
-    weight_decay: 0.0001

deepfake-whisper-features/configs/training/whisper_frontend_mesonet.yaml

@@ -1,16 +0,0 @@
-data:
-  seed: 42
-
-checkpoint:
-  path: ""
-
-model:
-  name: "whisper_frontend_mesonet"
-  parameters:
-    freeze_encoder: True
-    input_channels: 2
-    fc1_dim: 1024
-    frontend_algorithm: ["lfcc"]
-  optimizer:
-    lr: 0.0001
-    weight_decay: 0.0001

deepfake-whisper-features/configs/training/whisper_frontend_mesonet_mfcc.yaml

@@ -1,17 +0,0 @@
-data:
-  seed: 42
-
-checkpoint:
-  path: ""
-
-model:
-  name: "whisper_frontend_mesonet"
-  parameters:
-    freeze_encoder: True
-    input_channels: 2
-    fc1_dim: 1024
-    frontend_algorithm: ["mfcc"]
-  optimizer:
-    lr: 0.0001
-    weight_decay: 0.0001
-

deepfake-whisper-features/configs/training/whisper_frontend_specrnet.yaml

@@ -1,15 +0,0 @@
-data:
-  seed: 42
-
-checkpoint:
-  path: ""
-
-model:
-  name: "whisper_frontend_specrnet"
-  parameters:
-    freeze_encoder: True
-    input_channels: 2
-    frontend_algorithm: ["lfcc"]
-  optimizer:
-    lr: 0.0001
-    weight_decay: 0.0001

deepfake-whisper-features/configs/training/whisper_frontend_specrnet_mfcc.yaml

@@ -1,16 +0,0 @@
-data:
-  seed: 42
-
-checkpoint:
-  path: ""
-
-model:
-  name: "whisper_frontend_specrnet"
-  parameters:
-    freeze_encoder: True
-    input_channels: 2
-    frontend_algorithm: ["mfcc"]
-  optimizer:
-    lr: 0.0001
-    weight_decay: 0.0001
-

deepfake-whisper-features/configs/training/whisper_lcnn.yaml

@@ -1,15 +0,0 @@
-data:
-  seed: 42
-
-checkpoint:
-  path: ""
-
-model:
-  name: "whisper_lcnn"
-  parameters:
-    freeze_encoder: True
-    input_channels: 1
-    frontend_algorithm: ["lfcc"]
-  optimizer:
-    lr: 0.0001
-    weight_decay: 0.0001

deepfake-whisper-features/configs/training/whisper_mesonet.yaml

@@ -1,16 +0,0 @@
-data:
-  seed: 42
-
-checkpoint:
-  path: ""
-
-model:
-  name: "whisper_mesonet"
-  parameters:
-    freeze_encoder: True
-    input_channels: 1
-    fc1_dim: 1024
-    frontend_algorithm: []
-  optimizer:
-    lr: 0.0001
-    weight_decay: 0.0001

deepfake-whisper-features/configs/training/whisper_specrnet.yaml

@@ -1,15 +0,0 @@
-data:
-  seed: 42
-
-checkpoint:
-  path: ""
-
-model:
-  name: "whisper_specrnet"
-  parameters:
-    freeze_encoder: True
-    input_channels: 1
-    frontend_algorithm: ["lfcc"]
-  optimizer:
-    lr: 0.0001
-    weight_decay: 0.0001

deepfake-whisper-features/download_whisper.py

@@ -1,29 +0,0 @@
-# pip install git+https://github.com/openai/whisper.git
-from collections import OrderedDict
-import whisper
-import torch
-
-from src.commons import WHISPER_MODEL_WEIGHTS_PATH
-
-def download_whisper():
-    model = whisper.load_model("tiny.en")
-    return model
-
-
-def extract_and_save_encoder(model):
-    model_ckpt = OrderedDict()
-
-    model_ckpt['model_state_dict'] = OrderedDict()
-
-    for key, value in model.encoder.state_dict().items():
-        model_ckpt['model_state_dict'][f'encoder.{key}'] = value
-
-    model_ckpt['dims'] = model.dims
-    torch.save(model_ckpt, WHISPER_MODEL_WEIGHTS_PATH)
-
-
-if __name__ == "__main__":
-    model = download_whisper()
-    print("Downloaded Whisper model!")
-    extract_and_save_encoder(model)
-    print(f"Saved encoder at '{WHISPER_MODEL_WEIGHTS_PATH}'")

deepfake-whisper-features/evaluate_models_2019.py

@@ -1,232 +0,0 @@
-import argparse
-import logging
-from pathlib import Path
-from typing import Dict, List, Optional, Union
-import sys
-
-import torch
-import torchaudio
-import yaml
-from sklearn.metrics import precision_recall_fscore_support, roc_auc_score
-from torch.utils.data import DataLoader, Dataset
-
-from src import metrics, commons
-from src.models import models
-from src.datasets.base_dataset import SimpleAudioFakeDataset
-from src.datasets.generic_deep_fake_dataset import GenericDeepFakeDataset
-
-
-def get_dataset(
-    datasets_paths: List[Union[Path, str]],
-    amount_to_use: Optional[int],
-) -> SimpleAudioFakeDataset:
-    data_val = GenericDeepFakeDataset(
-        subset="test",
-        path=datasets_paths[0],
-    )
-    # data_val = ASVspoof2019Dataset(
-    #     subset="foo",
-    #     path=datasets_paths[0],
-    # )
-    return data_val
-
-def genSpoof_list(dir_meta, is_train=False, is_eval=False):
-    d_meta = {}
-    file_list = []
-
-    with open(dir_meta, "r") as f:
-        for line in f:
-            if is_eval:
-                key = line.strip()
-                file_list.append(key)
-            else:
-                _, key, _, _, label = line.strip().split()
-                file_list.append(key)
-                d_meta[key] = 1 if label == "bonafide" else 0
-
-    return (d_meta, file_list) if not is_eval else file_list
-
-class Dataset_ASVspoof2019_eval(Dataset):
-    def __init__(self, list_IDs, base_dir):
-        self.list_IDs = list_IDs
-        self.base_dir = base_dir
-
-    def __len__(self):
-        return len(self.list_IDs)
-
-    def __getitem__(self, index):
-        utt_id = self.list_IDs[index]
-        X, _ = torchaudio.load(self.base_dir + "/" + utt_id + ".flac")
-        return X, utt_id
-
-def collate_fn_eval(batch):
-        x, utt_id = zip(*batch)
-        x = torch.nn.utils.rnn.pad_sequence(
-            [tensor.squeeze() for tensor in x], batch_first=True, padding_value=0.0
-        )
-        return x, utt_id
-
-def evaluate_nn(
-    model_paths: List[Path],
-    datasets_paths: List[Union[Path, str]],
-    model_config: Dict,
-    device: str,
-    amount_to_use: Optional[int] = None,
-    batch_size: int = 32,
-):
-    logging.info("Loading data...")
-    model_name, model_parameters = model_config["name"], model_config["parameters"]
-
-    # Load model architecture
-    model = models.get_model(
-        model_name=model_name,
-        config=model_parameters,
-        device=device,
-    )
-    # If provided weights, apply corresponding ones (from an appropriate fold)
-    if len(model_paths):
-        model.load_state_dict(torch.load(model_paths))
-    model = model.to(device)
-
-    data_val = get_dataset(
-        datasets_paths=datasets_paths,
-        amount_to_use=amount_to_use,
-    )
-
-    logging.info(
-        f"Testing '{model_name}' model, weights path: '{model_paths}', on {len(data_val)} audio files."
-    )
-    test_loader = DataLoader(
-        data_val,
-        batch_size=batch_size,
-        shuffle=False,
-        drop_last=False,
-        num_workers=3,
-    )
-
-    # d_label_eval, file_eval = genSpoof_list(
-    #         dir_meta="/home/tran/dev/dataset/LA/ASVspoof2019_LA_cm_protocols/ASVspoof2019.LA.cm.eval.trl.txt",
-    #         is_eval=False, # TODO problem in implementing
-    # )
-    # eval = Dataset_ASVspoof2019_eval(
-    #         list_IDs=file_eval,
-    #         base_dir="/home/tran/dev/dataset/LA/ASVspoof2019_LA_eval/flac",
-    # )
-
-    # test_loader = DataLoader(
-    #         dataset=eval,
-    #         batch_size=batch_size,
-    #         shuffle=False,
-    #         collate_fn=collate_fn_eval,
-    # )
-
-    # logging.info(
-    #     f"Testing '{model_name}' model, weights path: '{model_paths}', on {len(data_val)} audio files."
-    # )
-    # test_loader = DataLoader(
-    #     data_val,
-    #     batch_size=batch_size,
-    #     shuffle=True,
-    #     drop_last=True,
-    #     num_workers=3,
-    # )
-
-    batches_number = len(data_val) // batch_size
-    num_correct = 0.0
-    num_total = 0.0
-
-    y_pred = torch.Tensor([]).to(device)
-    y = torch.Tensor([]).to(device)
-    y_pred_label = torch.Tensor([]).to(device)
-    fname_list = []
-    score_list = []
-
-    for i, (batch_x, sr, sample_name, batch_y) in enumerate(test_loader):
-
-        model.eval()
-        if i % 10 == 0:
-            print(f"Batch [{i}/{batches_number}]")
-
-        with torch.no_grad():
-            batch_x = batch_x.to(device)
-            batch_y = batch_y.to(device)
-            num_total += batch_x.size(0)
-
-            batch_pred = model(batch_x).squeeze(1)
-            batch_score = batch_pred.data.cpu().numpy().ravel()
-            batch_pred = torch.sigmoid(batch_pred)
-            batch_pred_label = (batch_pred + 0.5).int()
-            fname_list.extend(sample_name)
-            score_list.extend(batch_score.tolist())
-            
-    with open("./in_the_wild.txt", 'w') as fh:
-        for f, cm in zip(fname_list, score_list):
-            fh.write('{} {}\n'.format(f, cm))
-    print('Result saved to {}'.format("./in_the_wild.txt"))
-
-def main(args):
-    LOGGER = logging.getLogger()
-    LOGGER.setLevel(logging.INFO)
-
-    ch = logging.StreamHandler()
-    formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
-    ch.setFormatter(formatter)
-    LOGGER.addHandler(ch)
-    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
-
-    if not args.cpu and torch.cuda.is_available():
-        device = "cuda"
-    else:
-        device = "cpu"
-
-    with open(args.config, "r") as f:
-        config = yaml.safe_load(f)
-
-    seed = config["data"].get("seed", 42)
-    # fix all seeds - this should not actually change anything
-    commons.set_seed(seed)
-    evaluate_nn(
-        model_paths=config["checkpoint"].get("path", []),
-        datasets_paths=[
-            "/data/code/SSL_antispoof_work/asvspoof5/flac_D/",
-        ],
-        model_config=config["model"],
-        amount_to_use=args.amount,
-        device=device,
-    )
-
-
-def parse_args():
-    parser = argparse.ArgumentParser()
-
-    # If assigned as None, then it won't be taken into account
-    IN_THE_WILD_DATASET_PATH = "/data/code/SSL_antispoof_work/asvspoof5/flac_D/"
-
-    parser.add_argument(
-        "--in_the_wild_path", type=str, default=IN_THE_WILD_DATASET_PATH
-    )
-
-    default_model_config = "config.yaml"
-    parser.add_argument(
-        "--config",
-        help="Model config file path (default: config.yaml)",
-        type=str,
-        default=default_model_config,
-    )
-
-    default_amount = None
-    parser.add_argument(
-        "--amount",
-        "-a",
-        help=f"Amount of files to load from each directory (default: {default_amount} - use all).",
-        type=int,
-        default=default_amount,
-    )
-
-    parser.add_argument("--cpu", "-c", help="Force using cpu", action="store_true")
-
-    return parser.parse_args()
-
-
-if __name__ == "__main__":
-    main(parse_args())

deepfake-whisper-features/install.sh

@@ -1,6 +0,0 @@
-conda install pytorch==1.11.0 torchvision==0.12.0 torchaudio==0.11.0 cudatoolkit=11.3 -c pytorch -y
-
-pip install asteroid-filterbanks==0.4.0
-pip install librosa==0.9.2
-pip install git+https://github.com/openai/whisper.git@7858aa9c08d98f75575035ecd6481f462d66ca27
-pip install pandas==2.0.2

deepfake-whisper-features/train_and_test.py

@@ -1,147 +0,0 @@
-import argparse
-import logging
-from pathlib import Path
-
-import torch
-import yaml
-
-import train_models
-import evaluate_models
-from src.commons import set_seed
-
-
-LOGGER = logging.getLogger()
-LOGGER.setLevel(logging.INFO)
-
-ch = logging.StreamHandler()
-formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
-ch.setFormatter(formatter)
-LOGGER.addHandler(ch)
-
-
-def parse_args():
-    parser = argparse.ArgumentParser()
-
-    ASVSPOOF_DATASET_PATH = "../datasets/ASVspoof2021/DF"
-    IN_THE_WILD_DATASET_PATH = "../datasets/release_in_the_wild"
-
-    parser.add_argument(
-        "--asv_path",
-        type=str,
-        default=ASVSPOOF_DATASET_PATH,
-        help="Path to ASVspoof2021 dataset directory",
-    )
-    parser.add_argument(
-        "--in_the_wild_path",
-        type=str,
-        default=IN_THE_WILD_DATASET_PATH,
-        help="Path to In The Wild dataset directory",
-    )
-    default_model_config = "config.yaml"
-    parser.add_argument(
-        "--config",
-        help="Model config file path (default: config.yaml)",
-        type=str,
-        default=default_model_config,
-    )
-
-    default_train_amount = None
-    parser.add_argument(
-        "--train_amount",
-        "-a",
-        help=f"Amount of files to load for training.",
-        type=int,
-        default=default_train_amount,
-    )
-
-    default_valid_amount = None
-    parser.add_argument(
-        "--valid_amount",
-        "-va",
-        help=f"Amount of files to load for testing.",
-        type=int,
-        default=default_valid_amount,
-    )
-
-    default_test_amount = None
-    parser.add_argument(
-        "--test_amount",
-        "-ta",
-        help=f"Amount of files to load for testing.",
-        type=int,
-        default=default_test_amount,
-    )
-
-    default_batch_size = 8
-    parser.add_argument(
-        "--batch_size",
-        "-b",
-        help=f"Batch size (default: {default_batch_size}).",
-        type=int,
-        default=default_batch_size,
-    )
-
-    default_epochs = 10  # it was 5 originally
-    parser.add_argument(
-        "--epochs",
-        "-e",
-        help=f"Epochs (default: {default_epochs}).",
-        type=int,
-        default=default_epochs,
-    )
-
-    default_model_dir = "trained_models"
-    parser.add_argument(
-        "--ckpt",
-        help=f"Checkpoint directory (default: {default_model_dir}).",
-        type=str,
-        default=default_model_dir,
-    )
-
-    parser.add_argument("--cpu", "-c", help="Force using cpu?", action="store_true")
-
-    return parser.parse_args()
-
-
-if __name__ == "__main__":
-    args = parse_args()
-    # TRAIN MODEL
-
-    with open(args.config, "r") as f:
-        config = yaml.safe_load(f)
-
-    seed = config["data"].get("seed", 42)
-    # fix all seeds
-    set_seed(seed)
-
-    if not args.cpu and torch.cuda.is_available():
-        device = "cuda"
-    else:
-        device = "cpu"
-
-    model_dir = Path(args.ckpt)
-    model_dir.mkdir(parents=True, exist_ok=True)
-
-    # evaluation_config_path, model_path = train_models.train_nn(
-    #     datasets_paths=[
-    #         args.asv_path,
-    #     ],
-    #     device=device,
-    #     amount_to_use=(args.train_amount, args.valid_amount),
-    #     batch_size=args.batch_size,
-    #     epochs=args.epochs,
-    #     model_dir=model_dir,
-    #     config=config,
-    # )
-
-    with open(evaluation_config_path, "r") as f:
-        config = yaml.safe_load(f)
-
-    evaluate_models.evaluate_nn(
-        model_paths=config["checkpoint"].get("path", []),
-        batch_size=args.batch_size,
-        datasets_paths=[args.in_the_wild_path],
-        model_config=config["model"],
-        amount_to_use=args.test_amount,
-        device=device,
-    )

deepfake-whisper-features/train_models.py

@@ -1,235 +0,0 @@
-import argparse
-import logging
-import sys
-import time
-from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Union
-
-import torch
-import yaml
-
-from src.datasets.detection_dataset import DetectionDataset
-from src.models import models
-from src.trainer import GDTrainer
-from src.commons import set_seed
-
-
-def save_model(
-    model: torch.nn.Module,
-    model_dir: Union[Path, str],
-    name: str,
-) -> None:
-    full_model_dir = Path(f"{model_dir}/{name}")
-    full_model_dir.mkdir(parents=True, exist_ok=True)
-    torch.save(model.state_dict(), f"{full_model_dir}/ckpt.pth")
-
-
-def get_datasets(
-    datasets_paths: List[Union[Path, str]],
-    amount_to_use: Tuple[Optional[int], Optional[int]],
-) -> Tuple[DetectionDataset, DetectionDataset]:
-    data_train = DetectionDataset(
-        asvspoof_path=datasets_paths[0],
-        subset="train",
-        reduced_number=amount_to_use[0],
-        oversample=True,
-    )
-    data_test = DetectionDataset(
-        asvspoof_path=datasets_paths[0],
-        subset="test",
-        reduced_number=amount_to_use[1],
-        oversample=True,
-    )
-
-    return data_train, data_test
-
-
-def train_nn(
-    datasets_paths: List[Union[Path, str]],
-    batch_size: int,
-    epochs: int,
-    device: str,
-    config: Dict,
-    model_dir: Optional[Path] = None,
-    amount_to_use: Tuple[Optional[int], Optional[int]] = (None, None),
-    config_save_path: str = "configs",
-) -> Tuple[str, str]:
-    logging.info("Loading data...")
-    model_config = config["model"]
-    model_name, model_parameters = model_config["name"], model_config["parameters"]
-    optimizer_config = model_config["optimizer"]
-
-    timestamp = time.time()
-    checkpoint_path = ""
-
-    data_train, data_test = get_datasets(
-        datasets_paths=datasets_paths,
-        amount_to_use=amount_to_use,
-    )
-
-    current_model = models.get_model(
-        model_name=model_name,
-        config=model_parameters,
-        device=device,
-    )
-
-    # If provided weights, apply corresponding ones (from an appropriate fold)
-    model_path = config["checkpoint"]["path"]
-    if model_path:
-        current_model.load_state_dict(torch.load(model_path))
-        logging.info(
-            f"Finetuning '{model_name}' model, weights path: '{model_path}', on {len(data_train)} audio files."
-        )
-        if config["model"]["parameters"].get("freeze_encoder"):
-            for param in current_model.whisper_model.parameters():
-                param.requires_grad = False
-    else:
-        logging.info(f"Training '{model_name}' model on {len(data_train)} audio files.")
-    current_model = current_model.to(device)
-
-    use_scheduler = "rawnet3" in model_name.lower()
-
-    current_model = GDTrainer(
-        device=device,
-        batch_size=batch_size,
-        epochs=epochs,
-        optimizer_kwargs=optimizer_config,
-        use_scheduler=use_scheduler,
-    ).train(
-        dataset=data_train,
-        model=current_model,
-        test_dataset=data_test,
-    )
-
-    if model_dir is not None:
-        save_name = f"model__{model_name}__{timestamp}"
-        save_model(
-            model=current_model,
-            model_dir=model_dir,
-            name=save_name,
-        )
-        checkpoint_path = str(model_dir.resolve() / save_name / "ckpt.pth")
-
-    # Save config for testing
-    if model_dir is not None:
-        config["checkpoint"] = {"path": checkpoint_path}
-        config_name = f"model__{model_name}__{timestamp}.yaml"
-        config_save_path = str(Path(config_save_path) / config_name)
-        with open(config_save_path, "w") as f:
-            yaml.dump(config, f)
-        logging.info("Test config saved at location '{}'!".format(config_save_path))
-    return config_save_path, checkpoint_path
-
-
-def main(args):
-    LOGGER = logging.getLogger()
-    LOGGER.setLevel(logging.INFO)
-
-    ch = logging.StreamHandler()
-    formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
-    ch.setFormatter(formatter)
-    LOGGER.addHandler(ch)
-    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
-
-    with open(args.config, "r") as f:
-        config = yaml.safe_load(f)
-
-    seed = config["data"].get("seed", 42)
-    # fix all seeds
-    set_seed(seed)
-
-    if not args.cpu and torch.cuda.is_available():
-        device = "cuda"
-    else:
-        device = "cpu"
-
-    model_dir = Path(args.ckpt)
-    model_dir.mkdir(parents=True, exist_ok=True)
-
-    train_nn(
-        datasets_paths=[
-            args.asv_path,
-            args.wavefake_path,
-            args.celeb_path,
-            args.asv19_path,
-        ],
-        device=device,
-        amount_to_use=(args.train_amount, args.test_amount),
-        batch_size=args.batch_size,
-        epochs=args.epochs,
-        model_dir=model_dir,
-        config=config,
-    )
-
-
-def parse_args():
-    parser = argparse.ArgumentParser()
-
-    ASVSPOOF_DATASET_PATH = "../datasets/ASVspoof2021/DF"
-
-    parser.add_argument(
-        "--asv_path",
-        type=str,
-        default=ASVSPOOF_DATASET_PATH,
-        help="Path to ASVspoof2021 dataset directory",
-    )
-
-    default_model_config = "config.yaml"
-    parser.add_argument(
-        "--config",
-        help="Model config file path (default: config.yaml)",
-        type=str,
-        default=default_model_config,
-    )
-
-    default_train_amount = None
-    parser.add_argument(
-        "--train_amount",
-        "-a",
-        help=f"Amount of files to load for training.",
-        type=int,
-        default=default_train_amount,
-    )
-
-    default_test_amount = None
-    parser.add_argument(
-        "--test_amount",
-        "-ta",
-        help=f"Amount of files to load for testing.",
-        type=int,
-        default=default_test_amount,
-    )
-
-    default_batch_size = 8
-    parser.add_argument(
-        "--batch_size",
-        "-b",
-        help=f"Batch size (default: {default_batch_size}).",
-        type=int,
-        default=default_batch_size,
-    )
-
-    default_epochs = 10
-    parser.add_argument(
-        "--epochs",
-        "-e",
-        help=f"Epochs (default: {default_epochs}).",
-        type=int,
-        default=default_epochs,
-    )
-
-    default_model_dir = "trained_models"
-    parser.add_argument(
-        "--ckpt",
-        help=f"Checkpoint directory (default: {default_model_dir}).",
-        type=str,
-        default=default_model_dir,
-    )
-
-    parser.add_argument("--cpu", "-c", help="Force using cpu?", action="store_true")
-
-    return parser.parse_args()
-
-
-if __name__ == "__main__":
-    main(parse_args())