src/train_image_model.py

'''Finetune a vision transformer model on the dataset'''

from transformers import (AutoModelForImageClassification,
                          AutoFeatureExtractor, AutoConfig, TrainingArguments)
from datasets import Dataset, load_metric
from typing import Dict
import numpy as np
from mumin import MuminDataset
import os
from dotenv import load_dotenv
import gc

from trainer_with_class_weights import TrainerWithClassWeights


load_dotenv()


def train_image_model(model_id: str,
                      size: str,
                      random_split: bool = False,
                      num_epochs: int = 300,
                      **_) -> Dict[str, Dict[str, float]]:
    '''Train a vision transformer model on the dataset.

    Args:
        model_id (str):
            The model id to use.
        size (str):
            The size of the dataset.
        random_split (bool, optional):
            Whether to use a random split. Defaults to False.
        num_epochs (int, optional):
            The number of epochs to train for. Defaults to 300.

    Returns:
        dict:
            The results of the training, with keys 'train', 'val' and 'split',
            with dictionaries with the split scores as values.
    '''
    # Load the dataset
    mumin_dataset = MuminDataset(os.environ['TWITTER_API_KEY'], size=size)
    mumin_dataset.compile()
    image_df = mumin_dataset.nodes['image']
    tweet2image_df = mumin_dataset.rels[('tweet', 'has_image', 'image')]
    tweet2claim_df = mumin_dataset.rels[('tweet', 'discusses', 'claim')]
    claim_df = mumin_dataset.nodes['claim']
    df = (image_df.merge(tweet2image_df.rename(columns=dict(src='tweet_idx',
                                                            tgt='image_idx')),
                         left_index=True,
                         right_on='image_idx')
                  .merge(tweet2claim_df.rename(columns=dict(src='tweet_idx',
                                                            tgt='claim_idx')),
                         on='tweet_idx')
                  .merge(claim_df, left_on='claim_idx', right_index=True))
    image_df = df[['pixels', 'label', 'train_mask', 'val_mask', 'test_mask']]

    # If we are performing a random split then split the dataset into a
    # 80/10/10 train/val/test split, with a fixed random seed
    if random_split:
        train_df = image_df.sample(frac=0.8, random_state=42)
        val_test_df = image_df.drop(train_df.index)
        val_df = val_test_df.sample(frac=0.5, random_state=42)
        test_df  = val_test_df.drop(val_df.index)

    # Otherwise, use the train/val/test split that is already in the dataset
    else:
        train_df = image_df.query('train_mask == True')
        val_df = image_df.query('val_mask == True')
        test_df = image_df.query('test_mask == True')

    # Convert dataset to dictionaries
    train_dict = dict(pixels=train_df.pixels.map(lambda x: x.tobytes()),
                      width=train_df.pixels.map(lambda x: x.shape[0]),
                      height=train_df.pixels.map(lambda x: x.shape[1]),
                      orig_label=train_df.label)
    val_dict = dict(pixels=val_df.pixels.map(lambda x: x.tobytes()),
                    width=val_df.pixels.map(lambda x: x.shape[0]),
                    height=val_df.pixels.map(lambda x: x.shape[1]),
                    orig_label=val_df.label)
    test_dict = dict(pixels=test_df.pixels.map(lambda x: x.tobytes()),
                     width=test_df.pixels.map(lambda x: x.shape[0]),
                     height=test_df.pixels.map(lambda x: x.shape[1]),
                     orig_label=test_df.label)

    # Convert the dataset to the HuggingFace format
    train = Dataset.from_dict(train_dict)
    val = Dataset.from_dict(val_dict)
    test = Dataset.from_dict(test_dict)

    # Garbage collection
    del df, image_df, claim_df, train_df, val_df, test_df, mumin_dataset
    gc.collect()

    # Load the feature extractor and model
    config_dict = dict(num_labels=2,
                       id2label={0: 'misinformation', 1: 'factual'},
                       label2id=dict(misinformation=0, factual=1),
                       hidden_dropout_prob=0.2,
                       attention_probs_dropout_prob=0.2,
                       classifier_dropout_prob=0.2)
    config = AutoConfig.from_pretrained(model_id, **config_dict)
    model = AutoModelForImageClassification.from_pretrained(model_id,
                                                            config=config)
    feat_extractor = AutoFeatureExtractor.from_pretrained(model_id)

    # Preprocess the datasets
    def preprocess(examples: dict) -> dict:

        # Set up the labels
        labels = ['misinformation', 'factual']
        examples['labels'] = [labels.index(lbl)
                              for lbl in examples['orig_label']]

        # Extract the features
        images = [
            np.moveaxis(np.frombuffer(buf, dtype='uint8')
                          .reshape(width, height, 3),
                        source=-1,
                        destination=0)
            for buf, width, height in zip(examples['pixels'],
                                          examples['width'],
                                          examples['height'])
        ]
        inputs = feat_extractor(images=images)
        examples['pixel_values'] = inputs['pixel_values']

        return examples

    train = train.map(preprocess, batched=True, batch_size=32)
    val = val.map(preprocess, batched=True, batch_size=32)
    test = test.map(preprocess, batched=True, batch_size=32)

    # Set up compute_metrics function
    def compute_metrics(preds_and_labels: tuple) -> Dict[str, float]:
        metric = load_metric('f1')
        predictions, labels = preds_and_labels
        predictions = predictions.argmax(axis=-1)
        factual_results = metric.compute(predictions=predictions,
                                 references=labels)
        misinfo_results = metric.compute(predictions=1-predictions,
                                 references=1-labels)
        return dict(factual_f1=factual_results['f1'],
                    misinfo_f1=misinfo_results['f1'])

    # Set up the training arguments
    training_args = TrainingArguments(
        output_dir='models',
        per_device_train_batch_size=32,
        per_device_eval_batch_size=32,
        num_train_epochs=num_epochs,
        evaluation_strategy='steps',
        logging_strategy='steps',
        save_strategy='steps',
        eval_steps=100,
        logging_steps=100,
        save_steps=100,
        report_to='none',
        save_total_limit=1,
        learning_rate=2e-5,
        warmup_ratio=0.01,  # 10 epochs
        gradient_accumulation_steps=1,
        metric_for_best_model='factual_f1',
    )

    # Initialise the Trainer
    trainer = TrainerWithClassWeights(model=model,
                                      args=training_args,
                                      train_dataset=train,
                                      eval_dataset=val,
                                      compute_metrics=compute_metrics,
                                      class_weights=[1., 20.])

    # Train the model
    trainer.train()

    # Evaluate the model
    results = dict(train=trainer.evaluate(train),
                   val=trainer.evaluate(val),
                   test=trainer.evaluate(test))

    return results