src/agatston/tasks/base_task.py

"""
 Copyright (c) 2022, salesforce.com, inc.
 All rights reserved.
 SPDX-License-Identifier: BSD-3-Clause
 For full license text, see the LICENSE_Lavis file in the repo root or https://opensource.org/licenses/BSD-3-Clause
"""

import logging
import os
import wandb 

import torch
import torch.distributed as dist
from common.dist_utils import get_rank, get_world_size, is_main_process, is_dist_avail_and_initialized
from common.logger import MetricLogger, SmoothedValue
from common.registry import registry
from datasets.data_utils import prepare_sample
from typing import Optional, Dict, List, Union, Tuple
import torch.nn.functional as F
import ipdb
from sklearn.metrics import cohen_kappa_score, accuracy_score, confusion_matrix
import numpy as np

class BaseTask:
    def __init__(self, **kwargs):
        super().__init__()

        self.inst_id_key = "instance_id"
        self.wandb_initialized = False

    def init_wandb(self, cfg):
        if is_main_process():
            self.wandb_initialized = True

    @classmethod
    def setup_task(cls, **kwargs):
        return cls()

    def build_model(self, cfg):
        model_config = cfg.model_cfg
        model_cls = registry.get_model_class(model_config.arch)
        return model_cls.from_config(model_config)

    def build_datasets(self, cfg):
        """
        Build a dictionary of datasets, keyed by split 'train', 'valid', 'test'.
        Download dataset and annotations automatically if not exist.

        Args:
            cfg (common.config.Config): _description_

        Returns:
            dict: Dictionary of torch.utils.data.Dataset objects by split.
        """

        datasets = dict()

        datasets_config = cfg.datasets_cfg
        # print('datasets_config',datasets_config)
        assert len(datasets_config) > 0, "At least one dataset has to be specified."

        for name in datasets_config:
            dataset_config = datasets_config[name]
            builder = registry.get_builder_class(name)(dataset_config)
            dataset = builder.build_datasets()

            dataset['train'].name = name #?
            if 'sample_ratio' in dataset_config:
                dataset['train'].sample_ratio = dataset_config.sample_ratio
            print(f"Loaded dataset: {name} with {len(dataset['train'])} samples.")
            datasets[name] = dataset

        return datasets

    def train_step(self, model, samples):
        outputs = model(samples)
        loss, modal, task  = outputs['loss'], outputs['modal'], outputs['task_type']
        return loss, modal, task 

    def valid_step(self, model, samples):
        """
        Validation step function to compute predictions and prepare for QWK calculation.
        """
        model.eval()
        
        with torch.no_grad():
            outputs = model(samples)
            loss = outputs['loss']
            logits = outputs.get('logits', None)
            if logits is None:
                # Handle case where model outputs probabilities directly
                probs = outputs.get('probs', None)
                if probs is not None:
                    preds = torch.argmax(probs, dim=1)
            else:
                preds = torch.argmax(logits, dim=1)
                
            labels = samples['labels']
            score_labels = samples.get('score_labels', None)
            
            # print("logits", logits.shape)

            return [{
                'loss': loss.item(),
                'pred': pred.item(),
                'logits': logits,
                'label': label.item(),
                'score_label': score_label.item() if score_label is not None else None,
                'modal': outputs['modal'],
                'task_type': outputs['task_type']
            } for pred, label, score_label in zip(preds, labels, score_labels)]
        # print('NOT YET')
        # raise NotImplementedError
    

    def before_evaluation(self, model, dataset, **kwargs):
        model.before_evaluation(dataset=dataset, task_type=type(self))

    def after_evaluation(self, val_result, **kwargs):
        loss = val_result['loss']
        qwk = val_result['qwk']
        val_log = {
            'agg_metrics': qwk
        }
        return val_log

    def inference_step(self):
        raise NotImplementedError

    def evaluation(self, model, data_loader, cuda_enabled=True):
        metric_logger = MetricLogger(delimiter="  ")
        header = "Evaluation"
        # TODO make it configurable
        print_freq = 10

        results = []

        for samples in metric_logger.log_every(data_loader, print_freq, header):
            samples = prepare_sample(samples, cuda_enabled=cuda_enabled)

            eval_output = self.valid_step(model=model, samples=samples)
            results.extend(eval_output)

        if is_dist_avail_and_initialized():
            dist.barrier()

        return results
    
    

    def train_epoch(
        self,
        epoch,
        model,
        data_loader,
        optimizer,
        lr_scheduler,
        scaler=None,
        cuda_enabled=False,
        log_freq=50,
        accum_grad_iters=1,
    ):  
        return_dict, metric_logger = self._train_inner_loop(
            epoch=epoch,
            iters_per_epoch=lr_scheduler.iters_per_epoch,
            model=model,
            data_loader=data_loader,
            optimizer=optimizer,
            scaler=scaler,
            lr_scheduler=lr_scheduler,
            log_freq=log_freq,
            cuda_enabled=cuda_enabled,
            accum_grad_iters=accum_grad_iters,
        )

        # Log metrics to wandb
        if is_main_process() and self.wandb_initialized:
            wandb.log({
                "epoch": epoch,
                "train/loss": float(return_dict["loss"]),
                "train/lr": float(return_dict["lr"]),
                "train/modal": return_dict["modal"],
                "train/task": return_dict["task"],
            })

        return return_dict, metric_logger

    def train_iters(
        self,
        epoch,
        start_iters,
        iters_per_inner_epoch,
        model,
        data_loader,
        optimizer,
        lr_scheduler,
        scaler=None,
        cuda_enabled=False,
        log_freq=50,
        accum_grad_iters=1,
    ):
        return self._train_inner_loop(
            epoch=epoch,
            start_iters=start_iters,
            iters_per_epoch=iters_per_inner_epoch,
            model=model,
            data_loader=data_loader,
            optimizer=optimizer,
            scaler=scaler,
            lr_scheduler=lr_scheduler,
            log_freq=log_freq,
            cuda_enabled=cuda_enabled,
            accum_grad_iters=accum_grad_iters,
        )

    def _train_inner_loop(
        self,
        epoch,
        iters_per_epoch,
        model,
        data_loader,
        optimizer,
        lr_scheduler,
        scaler=None,
        start_iters=None,
        log_freq=50,
        cuda_enabled=False,
        accum_grad_iters=1,
    ):
        """
        An inner training loop compatible with both epoch-based and iter-based training.

        When using epoch-based, training stops after one epoch; when using iter-based,
        training stops after #iters_per_epoch iterations.
        """
        use_amp = scaler is not None

        if not hasattr(data_loader, "__next__"):
            # convert to iterator if not already
            data_loader = iter(data_loader)

        metric_logger = MetricLogger(delimiter="  ")
        metric_logger.add_meter("lr", SmoothedValue(window_size=1, fmt="{global_avg:.8e}"))
        metric_logger.add_meter("loss", SmoothedValue(window_size=1, fmt="{global_avg:.3f}"))

        # if iter-based runner, schedule lr based on inner epoch.
        logging.info(
            "Start training epoch {}, {} iters per inner epoch.".format(
                epoch, iters_per_epoch
            )
        )
        header = "Epoch: [{}]".format(epoch)
        if start_iters is None:
            # epoch-based runner
            inner_epoch = epoch
        else:
            # In iter-based runner, we schedule the learning rate based on iterations.
            inner_epoch = start_iters // iters_per_epoch
            header = header + "; inner epoch [{}]".format(inner_epoch)

        for i in metric_logger.log_every(range(iters_per_epoch), log_freq, header):
            # if using iter-based runner, we stop after iters_per_epoch iterations.
            if i >= iters_per_epoch:
                break

            samples = next(data_loader)

            samples = prepare_sample(samples, cuda_enabled=cuda_enabled)
            samples.update(
                {
                    "epoch": inner_epoch,
                    "num_iters_per_epoch": iters_per_epoch,
                    "iters": i,
                }
            )


            lr_scheduler.step(cur_epoch=inner_epoch, cur_step=i)
            torch.autograd.set_detect_anomaly(True)
            
            with torch.cuda.amp.autocast(enabled=use_amp):
                loss, modal, task = self.train_step(model=model, samples=samples)
            
            with torch.autograd.detect_anomaly():
                if use_amp:
                    scaler.scale(loss).backward()
                else:
                    loss.backward()

            # scaler.unscale_(optimizer)
            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
            
            # update gradients every accum_grad_iters iterations
            if (i + 1) % accum_grad_iters == 0:
                if use_amp:
                    scaler.unscale_(optimizer)  
                    scaler.step(optimizer)
                    scaler.update()                     
                else:    
                    optimizer.step()
                optimizer.zero_grad()


            metric_logger.update(loss=loss.item())
            metric_logger.update(lr=optimizer.param_groups[0]["lr"])
            metric_logger.update(modal=modal)
            metric_logger.update(task=task)
            
            if is_main_process() and self.wandb_initialized:
                wandb.log({
                    "train/step": i + epoch * iters_per_epoch,
                    "train/loss_step": loss.item(),
                    "train/lr_step": optimizer.param_groups[0]["lr"],
                    "train/modal_step": modal,
                    "train/task_step": task,
                })

        # after train_epoch()
        # gather the stats from all processes
        metric_logger.synchronize_between_processes()
        logging.info("Averaged stats: " + str(metric_logger.global_avg()))
        return_dict = {}
        for k, meter in metric_logger.meters.items():
            if not isinstance(meter, str):
                return_dict.update({k: "{:.3f}".format(meter.global_avg)})
        # return_dict = {k: "{:.3f}".format(meter.global_avg) for k, meter in metric_logger.meters.items()}
        return_dict.update({'modal': modal, 'task': task})
        return return_dict, metric_logger

    @staticmethod
    def save_result(result, result_dir, filename, remove_duplicate=""):
        import json

        result_file = os.path.join(
            result_dir, "%s_rank%d.json" % (filename, get_rank())
        )
        final_result_file = os.path.join(result_dir, "%s.json" % filename)

        json.dump(result, open(result_file, "w"))

        if is_dist_avail_and_initialized():
            dist.barrier()

        if is_main_process():
            logging.warning("rank %d starts merging results." % get_rank())
            # combine results from all processes
            result = []

            for rank in range(get_world_size()):
                result_file = os.path.join(
                    result_dir, "%s_rank%d.json" % (filename, rank)
                )
                res = json.load(open(result_file, "r"))
                result += res

            if remove_duplicate:
                result_new = []
                id_list = []
                for res in result:
                    if res[remove_duplicate] not in id_list:
                        id_list.append(res[remove_duplicate])
                        result_new.append(res)
                result = result_new

            json.dump(result, open(final_result_file, "w"))
            print("result file saved to %s" % final_result_file)
            
            if wandb.run is not None:
                wandb.log({"final_results": result})

        return final_result_file