# -*- coding: utf-8 -*-
"""Evaluating models for BibleBERT
Copyright 2021 © Javier de la Rosa
"""

# Dependencies
# !pip install -qU transformers sacrebleu scikit-learn datasets seqeval conllu pyarrow nltk

# Dependencies and helper functions
import argparse
import logging
import os
import random
import sys
from dataclasses import dataclass
from dataclasses import field
from pathlib import Path
from typing import Optional

import datasets
import numpy as np
import pandas as pd
# from datasets import ClassLabel
from datasets import load_dataset
from nltk.tokenize import word_tokenize
from nltk.tokenize.treebank import TreebankWordDetokenizer
from seqeval.metrics.sequence_labeling import accuracy_score as seq_accuracy_score
from seqeval.metrics.sequence_labeling import f1_score as seq_f1_score
from seqeval.metrics.sequence_labeling import precision_score as seq_precision_score
from seqeval.metrics.sequence_labeling import recall_score as seq_recall_score
from seqeval.metrics.sequence_labeling import classification_report as seq_classification_report
from sklearn.metrics import accuracy_score as sk_accuracy_score
from sklearn.metrics import f1_score as sk_f1_score
from sklearn.metrics import precision_score as sk_precision_score
from sklearn.metrics import recall_score as sk_recall_score
from sklearn.metrics import classification_report as sk_classification_report
# from sklearn.preprocessing import MultiLabelBinarizer
from tqdm import tqdm
from transformers import (
    AutoConfig,
    AutoModelForTokenClassification,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    RobertaTokenizer,
    RobertaTokenizerFast,
    DataCollatorForTokenClassification,
    DataCollatorWithPadding,
    PreTrainedTokenizerFast,
    Trainer,
    TrainingArguments,
    pipeline,
    set_seed,
)
# from transformers.training_args import TrainingArguments
import wandb

BIBLES_BASE_URI = "https://huggingface.co/datasets/linhd-postdata/stanzas/resolve/main"
BIBLES = {
    "validation": f"{BIBLES_BASE_URI}/eval.csv",
    "test": f"{BIBLES_BASE_URI}/test.csv",
    "train": f"{BIBLES_BASE_URI}/train.csv"
}


# Helper Funtions
def printm(string):
    print(str(string))


# Tokenize all texts and align the labels with them.
def tokenize_and_align_labels(
    tokenizer, examples, text_column_name, max_length, padding,
    label_column_name, label_to_id, label_all_tokens
):
    tokenized_inputs = tokenizer(
        examples[text_column_name],
        max_length=max_length,
        padding=padding,
        truncation=True,
        # We use this argument because the texts in our dataset are lists of words (with a label for each word).
        is_split_into_words=True,
    )
    labels = []
    for i, label in enumerate(examples[label_column_name]):
        word_ids = tokenized_inputs.word_ids(batch_index=i)
        previous_word_idx = None
        label_ids = []
        for word_idx in word_ids:
            # Special tokens have a word id that is None. We set the label to -100 so they are automatically
            # ignored in the loss function.
            if word_idx is None:
                label_ids.append(-100)
            # We set the label for the first token of each word.
            elif word_idx != previous_word_idx:
                label_ids.append(label_to_id[label[word_idx]])
            # For the other tokens in a word, we set the label to either the current label or -100, depending on
            # the label_all_tokens flag.
            else:
                label_ids.append(label_to_id[label[word_idx]] if label_all_tokens else -100)
            previous_word_idx = word_idx

        labels.append(label_ids)
    tokenized_inputs["labels"] = labels
    return tokenized_inputs


# Metrics
def token_compute_metrics(pairs, label_list):
    """Token metrics based on seqeval"""
    raw_predictions, labels = pairs
    predictions = np.argmax(raw_predictions, axis=2)

    # Remove ignored index (special tokens)
    true_predictions = [
        [label_list[p] for (p, l) in zip(prediction, label) if l != -100]
        for prediction, label in zip(predictions, labels)
    ]
    true_probas = [
        [label_list[p] for (p, l) in zip(prediction, label) if l != -100]
        for prediction, label in zip(predictions, labels)
    ]
    true_labels = [
        [label_list[l] for (p, l) in zip(prediction, label) if l != -100]
        for prediction, label in zip(predictions, labels)
    ]
    raw_scores = (
        np.exp(raw_predictions) / np.exp(raw_predictions).sum(-1, keepdims=True)
    )
    scores = raw_scores.max(axis=2)
    true_scores = [
        [(s, l) for (s, l) in zip(score, label) if l != -100]
        for score, label in zip(scores, labels)
    ]

    # mlb = MultiLabelBinarizer()  # sparse_output=True
    # true_predictions = mlb.fit_transform(true_predictions)
    # mlb = MultiLabelBinarizer()  # sparse_output=True
    # true_labels = mlb.fit_transform(true_labels)
    # wandb.log({
    #     "roc" : wandb.plot.roc_curve(
    #         labels,
    #         predictions,
    #         labels=label_list
    # )})
    metrics = {
        "accuracy": seq_accuracy_score(true_labels, true_predictions),
        "precision_micro": seq_precision_score(true_labels, true_predictions, average="micro"),
        "recall_micro": seq_recall_score(true_labels, true_predictions, average="micro"),
        "f1_micro": seq_f1_score(true_labels, true_predictions, average="micro"),
        "precision_macro": seq_precision_score(true_labels, true_predictions, average="macro"),
        "recall_macro": seq_recall_score(true_labels, true_predictions, average="macro"),
        "f1_macro": seq_f1_score(true_labels, true_predictions, average="macro"),
        # "report": seq_classification_report(true_labels, true_predictions, digits=4)
    }
    reports = seq_classification_report(
        true_labels, true_predictions, output_dict=True, zero_division=0,
    )
    for label, report in reports.items():
        for metric_key, metric_value in report.items():
            metric_title = metric_key.replace(" avg", "_avg", 1)
            metrics.update({
                f"label_{label}_{metric_title}": metric_value,
            })
    # labels_to_plot = label_list.copy()
    # if "O" in labels_to_plot:
    #     labels_to_plot.remove("O")
    flat_true_labels = sum(true_labels, [])
    flat_true_predictions = sum(true_predictions, [])
    wandb.log({
        # "roc": wandb.plot.roc_curve(
        #     labels.reshape(-1),
        #     raw_scores.reshape(-1, raw_predictions.shape[-1]),
        #     labels=label_list,
        #     classes_to_plot=labels_to_plot,
        # ),
        "matrix": wandb.sklearn.plot_confusion_matrix(
            flat_true_labels, flat_true_predictions, label_list
        )
    })
    return metrics


def sequence_compute_metrics(pairs, label_list):
    """Sequence metrics based on sklearn"""
    raw_predictions, labels = pairs
    predictions = np.argmax(raw_predictions, axis=1)
    metrics = {
        "accuracy": sk_accuracy_score(labels, predictions),
        "precision_micro": sk_precision_score(labels, predictions, average="micro"),
        "recall_micro": sk_recall_score(labels, predictions, average="micro"),
        "f1_micro": sk_f1_score(labels, predictions, average="micro"),
        "precision_macro": sk_precision_score(labels, predictions, average="macro"),
        "recall_macro": sk_recall_score(labels, predictions, average="macro"),
        "f1_macro": sk_f1_score(labels, predictions, average="macro"),
        # "report": sk_classification_report(labels, predictions, digits=4)
    }
    reports = sk_classification_report(
        labels, predictions, target_names=label_list, output_dict=True,
    )
    for label, report in reports.items():
        if not isinstance(report, dict):
            report = {"": report}
        for metric_key, metric_value in report.items():
            metric_title = metric_key.replace(" avg", "_avg", 1)
            metrics.update({
                f"label_{label}_{metric_title}": metric_value,
            })
    wandb.log({
        "roc": wandb.plot.roc_curve(
            labels, raw_predictions, labels=label_list
        ),
        "matrix": wandb.sklearn.plot_confusion_matrix(
            labels, predictions, label_list
        )
    })
    return metrics


def write_file(kind, metrics, output_dir, save_artifact=False):
    output_file = output_dir / f"{kind}_results.txt"
    headers = []
    label_headers = []
    data = []
    label_data = []
    with open(output_file, "w") as writer:
        printm(f"**{kind.capitalize()} results**")
        for key, value in metrics.items():
            printm(f"\t{key} = {value}")
            writer.write(f"{key} = {value}\n")
            title = key.replace("eval_", "", 1)
            if title.startswith("label_"):
                label_headers.append(title.replace("label_", "", 1))
                label_data.append(value)
            else:
                headers.append(title)
                data.append(value)
            wandb.log({f"{kind}:{title}": value})
    wandb.log({kind: wandb.Table(data=[data], columns=headers)})
    if label_headers:
        wandb.log({
            f"{kind}:labels": wandb.Table(
                data=[label_data], columns=label_headers
            )
        })
    if save_artifact:
        artifact = wandb.Artifact(kind, type="result")
        artifact.add_file(str(output_file))
        wandb.log_artifact(artifact)


def dataset_select(dataset, size):
    dataset_len = len(dataset)
    if size < 0 or size > dataset_len:
        return dataset
    elif size <= 1:  # it's a percentage
        return dataset.select(range(int(size * dataset_len)))
    else:  # it's a number
        return dataset.select(range(int(size)))


def main(args):
    # Set seed
    if args.run:
        seed = random.randrange(10**3)
    else:
        seed = args.seed
    set_seed(seed)
    # Run name
    model_name = args.model_name
    model_name = model_name[2:] if model_name.startswith("./") else model_name
    model_name = model_name[1:] if model_name.startswith("/") else model_name
    run_name = f"{model_name}_{args.task_name}"
    run_name = f"{run_name}_{args.dataset_config or args.dataset_name}"
    run_name = run_name.replace("/", "-")
    run_name = f"{run_name}_l{str(args.dataset_language)}"
    run_name = f"{run_name}_c{str(args.dataset_century)}"
    run_name = f"{run_name}_e{str(args.num_train_epochs)}"
    run_name = f"{run_name}_lr{str(args.learning_rate)}"
    run_name = f"{run_name}_ws{str(args.warmup_steps)}"
    run_name = f"{run_name}_wd{str(args.weight_decay)}"
    run_name = f"{run_name}_s{str(seed)}"
    run_name = f"{run_name}_eas{str(args.eval_accumulation_steps)}"
    if args.max_length != 512:
        run_name = f"{run_name}_seq{str(args.max_length)}"
    if args.label_all_tokens:
        run_name = f"{run_name}_labelall"
    if args.run:
        run_name = f"{run_name}_r{str(args.run)}"
    output_dir = Path(args.output_dir) / run_name
    # Tokenizer settings
    padding = "longest"  # args.task_name not in ("ner", "pos")  # default: False @param ["False", "'max_length'"] {type: 'raw'}
    max_length = args.max_length #@param {type: "number"}
    # Training settings
    weight_decay = args.weight_decay  #@param {type: "number"}
    adam_beta1 = 0.9  #@param {type: "number"}
    adam_beta2 = 0.999  #@param {type: "number"}
    adam_epsilon = 1e-08  #@param {type: "number"}
    max_grad_norm = 1.0  #@param {type: "number"}
    save_total_limit = 1  #@param {type: "integer"}
    load_best_model_at_end = False  #@param {type: "boolean"}
    # wandb
    wandb.init(name=run_name, project="postdata")
    wandb.log({
        "seed": int(seed),
    })
    # Loading Dataset
    print("\n\n#####################################")
    print(args.model_name)
    print(args.task_name)
    print(args.dataset_config)
    print(args.dataset_language)
    print(args.dataset_century)
    train_split = args.dataset_split_train
    test_split = args.dataset_split_test
    validation_split = args.dataset_split_validation
    if ":" in args.dataset_name:
        dataset_name, dataset_config = args.dataset_name.split(":")
    else:
        dataset_name = args.dataset_name
        dataset_config = args.dataset_config
    use_auth_token = os.environ.get("AUTH_TOKEN", None)
    if dataset_config is None or len(dataset_config) == 0:
        dataset = load_dataset(dataset_name, use_auth_token=use_auth_token)
    elif dataset_name == "csv" and dataset_config:
        dataset = load_dataset(
            dataset_name,
            data_files={
                "train": BIBLES["train"](dataset_config),
                "validation": BIBLES["validation"](dataset_config),
                "test": BIBLES["test"](dataset_config),
            },
            use_auth_token=use_auth_token)
    else:
        dataset = load_dataset(dataset_name, dataset_config, use_auth_token=use_auth_token)
    if args.dataset_language and args.dataset_language.lower() not in ("all", "balanced"):
        dataset = dataset.filter(lambda x: x["language"] == args.dataset_language)
    if args.dataset_century and args.dataset_century.lower() != "all":
        dataset = dataset.filter(lambda x: x["century"] in args.dataset_century)
    if dataset["train"].shape[0] == 0 or dataset["test"].shape[0] == 0 or dataset["validation"].shape[0] == 0:
        print(f"Not enough data for {str(args.dataset_language)} on {str(args.dataset_century)}: {str(dataset.shape)}")
        return
    column_names = dataset[train_split].column_names
    features = dataset[train_split].features
    if "tokens" in column_names:
        text_column_name = "tokens"
    elif "text" in column_names:
        text_column_name = "text"
    else:
        text_column_name = column_names[0]
    if f"{args.task_name}_tags" in column_names:
        label_column_name = f"{args.task_name}_tags"
    elif "label" in column_names:
        label_column_name = "label"
    else:
        label_column_name = column_names[1]
    if dataset_name == "csv":
        label_list = list(set(dataset[train_split][label_column_name]))
    elif isinstance(features[label_column_name], datasets.features.Sequence):
        label_list = features[label_column_name].feature.names
    else:
        label_list = features[label_column_name].names
    label_to_id = {i: i for i in range(len(label_list))}
    num_labels = len(label_list)
    print(f"Number of labels: {num_labels}")
    print({label.split("-")[-1] for label in label_list})

    # Training
    config = AutoConfig.from_pretrained(
        args.model_name,
        num_labels=num_labels,
        finetuning_task=args.task_name,
        cache_dir=args.cache_dir,
        force_download=args.force_download,
    )
    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name,
        cache_dir=args.cache_dir,
        use_fast=True,
        force_download=args.force_download,
    )
    if isinstance(tokenizer, (RobertaTokenizer, RobertaTokenizerFast)):
        tokenizer = AutoTokenizer.from_pretrained(
            args.model_name,
            cache_dir=args.cache_dir,
            use_fast=True,
            force_download=args.force_download,
            add_prefix_space=True,
        )

    tokenizer_test_sentence = """
    Ya que el Ángel del Señor tiene nombre propio, y su nombre es Yahveh.
    """.strip()
    printm("""Tokenizer test""")
    printm(f"> {tokenizer_test_sentence}")
    printm(tokenizer.tokenize(tokenizer_test_sentence))
    printm(tokenizer(tokenizer_test_sentence).input_ids)
    # STILTs
    is_stilt = args.model_name in args.stilt.split(",") or args.stilt == "all"
    model_config = dict(
        from_tf=bool(".ckpt" in args.model_name),
        config=config,
        cache_dir=args.cache_dir,
        force_download=args.force_download,
    )
    # Token tasks
    if args.task_name in ("pos", "ner"):
        if is_stilt:
            # model = AutoModelForTokenClassification.from_config(
            #     config=config
            # )
            model_config.pop("config")
            model = AutoModelForTokenClassification.from_pretrained(
                args.model_name, num_labels=num_labels, ignore_mismatched_sizes=True, **model_config,
            )
        else:
            model = AutoModelForTokenClassification.from_pretrained(
                args.model_name, **model_config,
            )
        # Preprocessing the dataset
        tokenized_datasets = dataset.map(
            lambda examples: tokenize_and_align_labels(
                tokenizer, examples, text_column_name, max_length, padding,
                label_column_name, label_to_id, args.label_all_tokens),
            batched=True,
            load_from_cache_file=not args.overwrite_cache,
            num_proc=os.cpu_count(),
        )
        # Data collator
        data_collator = DataCollatorForTokenClassification(tokenizer)
        compute_metrics = token_compute_metrics
    # Sequence tasks
    else:
        if is_stilt:
            # model = AutoModelForSequenceClassification.from_config(
            #     config=config
            # )
            model_config.pop("config")
            model = AutoModelForSequenceClassification.from_pretrained(
                args.model_name, num_labels=num_labels, ignore_mismatched_sizes=True, **model_config,
            )
        else:
            model = AutoModelForSequenceClassification.from_pretrained(
                args.model_name, **model_config,
            )
        # Preprocessing the dataset
        tokenized_datasets = dataset.map(
            lambda examples: tokenizer(
                examples[text_column_name],
                max_length=max_length,
                padding=padding,
                truncation=True,
                is_split_into_words=False,
            ),
            batched=True,
            load_from_cache_file=not args.overwrite_cache,
            num_proc=os.cpu_count(),
        )
        # Data collator
        data_collator = DataCollatorWithPadding(
            tokenizer,
            max_length=max_length,
            padding=padding,
        )
        compute_metrics = sequence_compute_metrics
    train_dataset = dataset_select(
        tokenized_datasets[train_split], args.max_train_size
    )
    test_dataset = dataset_select(
        tokenized_datasets[test_split], args.max_test_size
    )
    validation_dataset = dataset_select(
        tokenized_datasets[validation_split], args.max_validation_size
    )
    wandb.log({
        "train_size": len(train_dataset),
        "test_size": len(test_dataset),
        "validation_size": len(validation_dataset),
    })
    samples_per_batch = (
        train_dataset.shape[0] / args.train_batch_size
    )
    total_steps = args.num_train_epochs * samples_per_batch
    warmup_steps = int(args.warmup_steps * total_steps)
    wandb.log({
        "total_steps": int(total_steps),
        "total_warmup_steps": warmup_steps
    })
    do_eval = args.do_eval and (validation_split in tokenized_datasets)
    do_test = args.do_test and (test_split in tokenized_datasets)
    do_predict = args.do_predict and (test_split in tokenized_datasets)
    training_args = TrainingArguments(
        output_dir=output_dir.as_posix(),
        overwrite_output_dir=args.overwrite_output_dir,
        do_train=args.do_train,
        do_eval=do_eval,
        do_predict=do_test or do_predict,
        per_device_train_batch_size=int(args.train_batch_size),
        per_device_eval_batch_size=int(args.eval_batch_size or args.train_batch_size),
        learning_rate=float(args.learning_rate),
        weight_decay=weight_decay,
        adam_beta1=adam_beta1,
        adam_beta2=adam_beta2,
        adam_epsilon=adam_epsilon,
        max_grad_norm=max_grad_norm,
        num_train_epochs=args.num_train_epochs,
        warmup_steps=warmup_steps,
        load_best_model_at_end=load_best_model_at_end,
        seed=seed,
        save_total_limit=save_total_limit,
        run_name=run_name,
        disable_tqdm=False,
        eval_steps=1000,
        eval_accumulation_steps=args.eval_accumulation_steps or None,  # it was not set
        dataloader_num_workers=64,  # it was not set
    )
    # Initialize our Trainer
    trainer = Trainer(
        model=model,
        args=training_args,
        train_dataset=train_dataset,
        eval_dataset=validation_dataset if do_eval else None,
        tokenizer=tokenizer,
        data_collator=data_collator,
        compute_metrics=lambda pairs: compute_metrics(pairs, label_list),
    )
    if args.do_train:
        train_result = trainer.train()
        trainer.save_model()  # Saves the tokenizer too for easy upload
        write_file("train", train_result.metrics, output_dir, save_artifact=args.save_artifacts)
        # Need to save the state, since Trainer.save_model saves only the tokenizer with the model
        trainer.state.save_to_json(output_dir / "trainer_state.json")
    # Evaluation
    if do_eval:
        printm(f"**Evaluate**")
        results = trainer.evaluate()
        write_file("eval", results, output_dir, save_artifact=args.save_artifacts)
    # Tesing and predicting
    if do_test or do_predict:
        printm("**Test**")
        predictions, labels, metrics = trainer.predict(test_dataset)
        if not do_predict:
            write_file("test", metrics, output_dir, save_artifact=args.save_artifacts)
        if args.task_name in ("ner", "pos"):
            predictions = np.argmax(predictions, axis=2)
            # Remove ignored index (special tokens)
            true_predictions = [
                [label_list[p] for (p, l) in zip(prediction, label) if l != -100]
                for prediction, label in zip(predictions, labels)
            ]
        else:
            predictions = np.argmax(predictions, axis=1)
            true_predictions = [
                label_list[p] for (p, l) in zip(predictions, labels) if l != -100
            ]
        # Save predictions
        output_test_predictions_file = os.path.join(output_dir, "test_predictions.txt")
        output_test_predictions = "\n".join(" ".join(map(str, p)) for p in true_predictions)
        with open(output_test_predictions_file, "a+") as writer:
            writer.write(output_test_predictions)
        if args.save_artifacts:
            artifact = wandb.Artifact("predictions", type="result")
            artifact.add_file(output_test_predictions_file)
            wandb.log_artifact(artifact)
    # # Log the results
    # logfile = output_dir / "evaluation.csv"
    # # Check if logfile exist
    # try:
    #     f = open(logfile)
    #     f.close()
    # except FileNotFoundError:
    #     with open(logfile, 'a+') as f:
    #         f.write("model_name" + "\t" + "data_language" + "\t" + "task_name" + "\t" "learning_rate"+ "\t" + "num_epochs"+ "\t" + "warmup_steps"+ "\t" + "validation_f1" +"\t"+"test_f1"+"\n")
    # with open(logfile, 'a') as f:
    #     print(results)
    #     f.write(args.model_name + "\t" + (args.dataset_config or args.dataset_name) + "\t" + args.task_name + "\t" + str(args.learning_rate) + "\t" + str(args.num_train_epochs)+ "\t" + str(warmup_steps)+ "\t" + str(results['eval_f1']) + "\t" + str(metrics['eval_f1']) + "\n")


if __name__ == "__main__":
    # yesno = lambda x: str(x).lower() in {'true', 't', '1', 'yes', 'y'}
    parser = argparse.ArgumentParser(description=f""
    f"Evaluating BERT models for sequence classification on Bibles"""
    f"", epilog=f"""Example usage:
    {__file__} --task_name sequence --model_name "bert-base-multilingual-cased"
    """, formatter_class=argparse.RawTextHelpFormatter)
    parser.add_argument('--model_name',
        metavar='model_name', help='Model name or path')
    parser.add_argument('--dataset_name', default="csv",
        metavar='dataset_name', help='Dataset name. It might enforce a config if added after a semicolon: "conll2002:es". This will ignore dataset_config, useful when run in grid search')
    parser.add_argument('--dataset_config',
        metavar='dataset_config', help='Dataset config name')
    parser.add_argument('--dataset_language', default="all",
        metavar='dataset_language', help='Dataset language name')
    parser.add_argument('--dataset_century', default="all",
        metavar='dataset_century', help='Dataset century')

    parser.add_argument('--dataset_split_train', default="train",
        metavar='dataset_split_train', help='Dataset train split name')
    parser.add_argument('--dataset_split_test', default="test",
        metavar='dataset_split_test', help='Dataset test split name')
    parser.add_argument('--dataset_split_validation', default="validation",
        metavar='dataset_split_validation', help='Dataset validation split name')

    parser.add_argument('--max_train_size', type=float, default=-1.0,
        metavar='max_train_size', help='Percentage of train dataset or number of rows to use')
    parser.add_argument('--max_test_size', type=float, default=-1.0,
        metavar='max_test_size', help='Percentage of test dataset or number of rows to use')
    parser.add_argument('--max_validation_size', type=float, default=-1.0,
        metavar='max_validation_size', help='Percentage of validation dataset or number of rows to use')

    parser.add_argument('--do_train',
        metavar='do_train', default=True, type=bool,
        help='Run training',
    )
    parser.add_argument('--do_eval',
        metavar='do_eval', default=True, type=bool,
        help='Run evaluation on validation test',
    )
    parser.add_argument('--do_test',
        metavar='do_test', default=True, type=bool,
        help='Run evaluation on test set',
    )
    parser.add_argument('--do_predict',
        metavar='do_predict', default=False, type=bool,
        help='Run prediction only on test set',
    )
    parser.add_argument('--task_name',
        metavar='task_name', default="ner",
        help='Task name (supported in the dataset), either ner or pos',
    )
    parser.add_argument('--num_train_epochs',
        metavar='num_train_epochs', default=4, type=float,
        help='Number of training epochs',
    )
    parser.add_argument('--eval_accumulation_steps',
        metavar='eval_accumulation_steps', default=0, type=int,
        help='Number of predictions steps to accumulate the output tensors for, before moving the results to the CPU.',
    )
    parser.add_argument('--cache_dir',
        metavar='cache_dir', default="/var/ml/cache/",
        help='Cache dir for the transformer library',
    )
    parser.add_argument('--overwrite_cache',
        metavar='overwrite_cache', default=False, type=bool,
        help='Overwrite cache dir if present',
    )
    parser.add_argument('--output_dir',
        metavar='output_dir', default="/var/ml/output/",
        help='Output dir for models and logs',
    )
    parser.add_argument('--overwrite_output_dir',
        metavar='overwrite_output_dir', default=True, type=bool,
        help='Overwrite output dir if present',
    )
    parser.add_argument('--seed',
        metavar='seed', type=int, default=2021,
        help='Seed for the experiments',
    )
    parser.add_argument('--run',
        metavar='run', type=int,
        help='Control variable for doing several runs of the same experiment. It will force random seeds even across the same set of parameters fo a grid search',
    )
    parser.add_argument('--train_batch_size',
        metavar='train_batch_size', type=int, default=8,
        help='Batch size for training',
    )
    parser.add_argument('--eval_batch_size',
        metavar='eval_batch_size', type=int,
        help='Batch size for evaluation. Defaults to train_batch_size',
    )
    parser.add_argument('--max_length',
        metavar='max_length', type=int, default=512,
        help='Maximum sequence length',
    )
    parser.add_argument('--learning_rate',
        metavar='learning_rate', type=str, default="3e-05",
        help='Learning rate',
    )
    parser.add_argument('--warmup_steps',
        metavar='warmup_steps', type=float, default=0.0,
        help='Warmup steps as percentage of the total number of steps',
    )
    parser.add_argument('--weight_decay',
        metavar='weight_decay', type=float, default=0.0,
        help='Weight decay',
    )
    parser.add_argument('--label_all_tokens',
        metavar='label_all_tokens', type=bool, default=False,
        help=('Whether to put the label for one word on all tokens of '
              'generated by that word or just on the one (in which case the '
              'other tokens will have a padding index).'),
    )
    parser.add_argument('--force_download',
        metavar='force_download', type=bool, default=False,
        help='Force the download of model, tokenizer, and config',
    )
    parser.add_argument('--save_artifacts',
        metavar='save_artifacts', type=bool, default=False,
        help='Save train, eval, and test files in Weight & Biases',
    )
    parser.add_argument('--stilt',
        metavar='stilt', type=str, default="",
        help='Specify models already fine-tuned for other tasks',
    )

    args = parser.parse_args()
    main(args)