finetune/finetune.py

# Standard
import os
import sys
import shutil
import argparse

# PIP
from tqdm import tqdm
import random
import pandas as pd
from sklearn.metrics import accuracy_score, precision_recall_fscore_support

import torch
from torch import nn
from torch.utils.data import DataLoader

from datasets import Dataset
from transformers import AutoModelForSequenceClassification, AutoTokenizer, T5Tokenizer,T5ForConditionalGeneration 
from transformers import AdamW, get_linear_schedule_with_warmup

# Custom
from config import Config
from dataset import CSV2Dataset, batch_sampling

parser = argparse.ArgumentParser()
parser.add_argument('--config_file', type=str, help='Config file name')
parser.add_argument('--model', type=str, default=None, help='Model name')
parser.add_argument('--checkpoint_filename', type=str, default=None)
parser.add_argument('--best_filename', type=str, default=None)

parser.add_argument('--train_data', type=str, default=None)
parser.add_argument('--val_data', type=str, default=None,
                    help='Train Label column name')
parser.add_argument('--test_data', type=str, default=None,
                    help='Train Label column name')
parser.add_argument('--test_res', type=str, default=None,
                    help='Train Label column name')

parser.add_argument('--sent_col', type=str, )
parser.add_argument('--label_col', type=str, default=None,
                    help='Train Label column name')
parser.add_argument('--num_labels', type=str, default=None)

parser.add_argument('--test_res_col', type=str, default=None,
                    help='Test result column name')
parser.add_argument('--test_col', type=str,)

parser.add_argument('--train', type=str, default=None,
                    help='Train Label column name')
parser.add_argument('--evaluate', type=str, default=None,
                    help='Train Label column name')
parser.add_argument('--test', type=str, default=None,
                    help='Train Label column name')

parser.add_argument('--resume', type=str, default=None,
                    help='Train Label column name')
parser.add_argument('--resume_model', type=str, default=None,
                    help='Train Label column name')

args = parser.parse_args()


def save_checkpoint(state, is_best, filename, best_filename):
    if is_best:
        print('Best F1 Updated -- Saving Best Checkpoint')
        torch.save(state, best_filename)

def train(train_loader, model, optimizer, scheduler, epoch, epochs):
    model.train()
    
    total_loss, total_accuracy = 0, 0
    print("-"*30)

    loop = tqdm(train_loader, leave=True)
    for (input_ids,attention_mask),labels in loop:
        optimizer.zero_grad()

        input_ids = input_ids.to(device)
        attention_mask = attention_mask.to(device)

        
        if 't5' in cfg.model:
            lm_label = labels[0].to(device)
            label_mask = labels[1].to(device)
            outputs = model(input_ids, attention_mask=attention_mask,
                            labels=lm_label, decoder_attention_mask = label_mask)
        else: 
            labels = labels.to(device)

            outputs = model(input_ids, attention_mask=attention_mask,
                            labels=labels)
        
        loss = outputs.loss.mean()
        total_loss += loss.item()

        outputs.loss.mean().backward()
        


        loop.set_description(f'Epoch {epoch}')
        loop.set_postfix(loss=loss.item())
        
        optimizer.step()
        scheduler.step()
        
    avg_loss = total_loss / len(train_loader)
    print(f" {epoch+1} Epoch Average train loss :  {avg_loss}")

def validate(valid_loader, model, tokenizer):
    model.eval()

    total_true = []
    total_pred = []
    real_total_true = []
    real_total_pred = []

    loop = tqdm(valid_loader, leave=True)
    for (input_ids,attention_mask),labels in loop:
        input_ids = input_ids.to(device)
        attention_mask = attention_mask.to(device)


        with torch.no_grad():
            if 't5' in cfg.model:
                lm_label = labels[0].to(device)
                label_mask = labels[1].to(device)
                outputs = model.module.generate(input_ids, attention_mask=attention_mask,max_length=3)
                pred = [tokenizer.decode(label) for label in outputs]
                pred = [l.replace('<pad>','').replace(' ','')[0] for l in pred]
                try:
                    _pred = [int(l) for l in pred]
                    pred = _pred
                except:
                    _pred = []
                    for l in pred:
                        if l == '0' or l == '1':
                            _pred.append(int(l))
                        else:
                            _pred.append(l)
                    pred = _pred
                

                lm_label[lm_label[:, :] == -100] = tokenizer.pad_token_id
                true = [tokenizer.decode(label) for label in lm_label]
                true = [int(l[0]) for l in true]

                _pred = []
                _true = []

                for i in range(len(true)):
                    if type(pred[i]) is int:
                        _pred.append(pred[i])
                        _true.append(true[i])

                
            else: 
                labels = labels.to(device)

                outputs = model(input_ids, attention_mask=attention_mask,
                                labels=labels)

                pred = [torch.argmax(logit).cpu().detach().item() for logit in outputs.logits]
                
    
                true = [label for label in labels.cpu().numpy()]
                
            
        total_true += true
        total_pred += pred

        if 't5' in cfg.model:
            real_total_true += _true
            real_total_pred += _pred
        
    try:
        precision, recall, f1, _ = precision_recall_fscore_support(total_true, total_pred, average='macro')
        accuracy = accuracy_score(total_true, total_pred)

        print(f"validation accuracy : {accuracy: .4f}")
        print(f"validation Precision : {precision: .4f}")
        print(f"validation Recall : {recall: .4f}")
        print(f"validation F1 : {f1: .4f}")
    except:
        precision, recall, f1, _ = precision_recall_fscore_support(real_total_true, real_total_pred, average='macro')
        accuracy = accuracy_score(real_total_true, real_total_pred)

        print(f"No. of int type output: {len(real_total_true)}/{len(total_true)}")
        print(f"validation accuracy : {accuracy: .4f}")
        print(f"validation Precision : {precision: .4f}")
        print(f"validation Recall : {recall: .4f}")
        print(f"validation F1 : {f1: .4f}") 
    
    return f1

def test(test_loader,model,tokenizer):
    model.eval()

    final_preds = []
    idss = []

    loop = tqdm(test_loader, leave=True)
    for input_ids,attention_mask in loop:

        input_ids = input_ids.to(device)
        attention_mask = attention_mask.to(device)
        with torch.no_grad():
            outputs = model(input_ids, attention_mask=attention_mask)

        argmax = [torch.argmax(logit).cpu().detach().item() for logit in outputs.logits]
        print(argmax)
        final_preds += argmax
        idss += input_ids.cpu()

    print(len(idss))
    sents = [tokenizer.decode(ids) for ids in idss]
    print(len(sents))
    
    print(len(final_preds))
    
    return (sents,final_preds)


device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
cfg = Config(args.config_file)

for key, value in vars(args).items():
    if value != None:
        exec("cfg.%s = '%s'" % (key,value))


print(cfg.model, cfg.sent_col, cfg.label_col)

cfg.num_workers = torch.cuda.device_count()
print(cfg.test_res_col)

print(cfg.checkpoint_filename)

if not os.path.exists('./checkpoints'):
    os.mkdir('./checkpoints')

print('Train:',cfg.train)
print('Evaluate:',cfg.evaluate)
print('Test:',cfg.test)

if 't5' in cfg.model:
    model = T5ForConditionalGeneration.from_pretrained(cfg.model,resume_download=True)
else:
    model = AutoModelForSequenceClassification.from_pretrained(cfg.model,resume_download=True)


optimizer = AdamW(model.parameters(), lr=2e-5, eps=1e-8)

if cfg.train:
    train_dataset = CSV2Dataset(cfg,cfg.train_data,'train')
    valid_dataset = CSV2Dataset(cfg,cfg.val_data,'valid')
    train_dataloader = DataLoader(train_dataset,batch_sampler=batch_sampling(cfg.batch_size,len(train_dataset)))
    valid_dataloader = DataLoader(valid_dataset,batch_sampler=batch_sampling(cfg.batch_size,len(valid_dataset)))
    if cfg.evaluate:
        test_dataset = CSV2Dataset(cfg,cfg.test_data,'valid') 
        test_dataloader = DataLoader(test_dataset,batch_sampler=batch_sampling(cfg.batch_size,len(test_dataset)))
    scheduler = get_linear_schedule_with_warmup(optimizer,num_warmup_steps=0, 
                                                num_training_steps=len(train_dataloader)*cfg.epochs)
    tokenizer = valid_dataset.get_tokenizer()

elif cfg.test:
    test_dataset = CSV2Dataset(cfg,cfg.test_data,'test')
    test_dataloader = DataLoader(test_dataset,batch_sampler=batch_sampling(cfg.batch_size,len(test_dataset),is_test=True))
    tokenizer = test_dataset.get_tokenizer()

if cfg.evaluate and not cfg.train:
    valid_dataset = CSV2Dataset(cfg,cfg.val_data,'valid') 
    valid_dataloader = DataLoader(valid_dataset,batch_sampler=batch_sampling(cfg.batch_size,len(valid_dataset)))
    tokenizer = valid_dataset.get_tokenizer()




model.resize_token_embeddings(len(tokenizer))
best_prec1 = 0

if cfg.evaluate or cfg.test or cfg.resume:
    torch.cuda.empty_cache()
    model = model.to(device)
    def resume():
        if os.path.isfile(cfg.resume_model):
            print("=> loading checkpoint '{}'".format(cfg.resume_model))
            checkpoint = torch.load(cfg.resume_model)
            cfg.start_epoch = checkpoint['epoch']+1
            global best_prec1
            if 'TL' in cfg.best_filename:
                best_prec1=0
                cfg.epochs = cfg.start_epoch + cfg.epochs
            else:
                best_prec1 = checkpoint['best_prec1']
            model.load_state_dict(checkpoint['state_dict'])
            optimizer.load_state_dict(checkpoint['optimizer'])
            print("=> loaded checkpoint '{}' (epoch {})"
                    .format(cfg.resume_model, checkpoint['epoch']))
        else:
            print("=> no checkpoint found at '{}'".format(cfg.resume_model))
    resume()

if cfg.train:
    model = nn.DataParallel(model, device_ids = list(range(torch.cuda.device_count()))).to(device)
    for epoch in range(cfg.start_epoch, cfg.epochs):
        # train for one epoch
        train(train_dataloader, model, optimizer, scheduler, epoch, cfg.epochs)

        # evaluate on validation set
        prec1 = validate(valid_dataloader, model, tokenizer)

        # remember best prec@1 and save checkpoint
        is_best = prec1 > best_prec1
        best_prec1 = max(prec1, best_prec1)
        best_model = model
        print(f"Best F1 :{best_prec1}")
        
    save_checkpoint({
        'epoch': epoch,
        'state_dict': best_model.module.state_dict(),
        'best_prec1': best_prec1,
        'optimizer' : optimizer.state_dict(),
    }, is_best,filename=cfg.checkpoint_filename,best_filename=cfg.best_filename)



if cfg.evaluate:
    if cfg.train:
        print(f'***On Test Set-{cfg.label_col}***')
        validate(test_dataloader,model,tokenizer)
    else:
        model = nn.DataParallel(model, device_ids = list(range(torch.cuda.device_count()))).to(device)
        validate(valid_dataloader, model, tokenizer)
    # exit()

if cfg.test:
    if cfg.train:
        model = best_model
    if cfg.evaluate:
        test_dataset = CSV2Dataset(cfg,cfg.test_data,'test')
        test_dataloader = DataLoader(test_dataset,batch_sampler=batch_sampling(cfg.batch_size,len(test_dataset),is_test=True))

    tokenizer = test_dataset.get_tokenizer()
    sents, preds = test(test_dataloader,model,tokenizer)


    df = pd.read_csv(cfg.test_data)
    if len(df) != len(preds):
        preds += [''] * (len(df)-len(preds))
    df['decoded_text'] = sents
    df[cfg.test_res_col] = preds
    df.to_csv(cfg.test_res,encoding='utf-8',index=False)