finetune/multi_task.py

import warnings
warnings.simplefilter('ignore')
import numpy as np
import pandas as pd
from tqdm import tqdm
from sklearn import metrics
import transformers
import torch
from torch import nn
from torch.utils.data import Dataset, DataLoader, RandomSampler, SequentialSampler
from transformers import DistilBertTokenizer, DistilBertModel,AutoModel,AutoTokenizer,AutoConfig,AutoModelForSequenceClassification
import logging
logging.basicConfig(level=logging.ERROR)
import os
from itertools import permutations


from torch import cuda
device = 'cuda' if cuda.is_available() else 'cpu'
print(device)

models = ['vinai/bertweet-base',
          './hate_bert',
          'Twitter/TwHIN-BERT-base',
          'cardiffnlp/twitter-roberta-base',
          'Xuhui/ToxDect-roberta-large',
          'bert-base-cased',
          'roberta-base']
model_names = [
    'BERTweet',
    'HateBERT',
    'TwHIN-BERT',
    'Twitter-RoBERTa',
    'ToxDect-RoBERTa',
    'BERT',
    'RoBERTa'
]
countries = ['United States','Australia','United Kingdom','South Africa','Singapore']
codes = ['US', 'AU', 'GB', 'ZA', 'SG']
_hate_cols = [f'{country.replace(" ","_")}_Hate' for country in countries]

def hamming_score(y_true, y_pred, normalize=True, sample_weight=None):
    acc_list = []
    for i in range(y_true.shape[0]):
        set_true = set( np.where(y_true[i])[0] )
        set_pred = set( np.where(y_pred[i])[0] )
        tmp_a = None
        if len(set_true) == 0 and len(set_pred) == 0:
            tmp_a = 1
        else:
            tmp_a = len(set_true.intersection(set_pred))/\
                    float( len(set_true.union(set_pred)) )
        acc_list.append(tmp_a)
    return np.mean(acc_list)

class MultiTaskDataset(Dataset):

    def __init__(self, dataframe, tokenizer, max_len):
        self.tokenizer = tokenizer
        self.data = dataframe
        self.text = dataframe.text
        self.targets = self.data.labels
        self.max_len = max_len

    def __len__(self):
        return len(self.text)

    def __getitem__(self, index):
        text = str(self.text[index])

        inputs = self.tokenizer.encode_plus(
            text,
            None,
            truncation=True,
            add_special_tokens=True,
            max_length=self.max_len,
            pad_to_max_length=True,
            return_token_type_ids=True
        )
        ids = inputs['input_ids']
        mask = inputs['attention_mask']
        token_type_ids = inputs["token_type_ids"]


        return {
            'ids': torch.tensor(ids, dtype=torch.long),
            'mask': torch.tensor(mask, dtype=torch.long),
            'token_type_ids': torch.tensor(token_type_ids, dtype=torch.long),
            'targets': torch.tensor(self.targets[index], dtype=torch.long)
        }

class Classifier(torch.nn.Module):
    def __init__(self,model_name,tokenizer):
        super(Classifier, self).__init__()
        self.l1 = AutoModel.from_pretrained(model_name)
        self.l1.resize_token_embeddings(len(tokenizer))
        config = AutoConfig.from_pretrained(model_name)
        self.pre_classifier = torch.nn.Linear(config.hidden_size, config.hidden_size)
        self.dropout = torch.nn.Dropout(0.1)
        
        self.classifier_1 = torch.nn.Linear(config.hidden_size, 2)
        self.classifier_2 = torch.nn.Linear(config.hidden_size, 2)
        self.classifier_3 = torch.nn.Linear(config.hidden_size, 2)
        self.classifier_4 = torch.nn.Linear(config.hidden_size, 2)
        self.classifier_5 = torch.nn.Linear(config.hidden_size, 2)

    def forward(self, input_ids, attention_mask, token_type_ids):
        outputs = self.l1(input_ids=input_ids, attention_mask=attention_mask)
        pooler = outputs[1]
        pooler = self.pre_classifier(pooler)
        pooler = self.dropout(pooler)
        output_1 = self.classifier_1(pooler)
        output_2 = self.classifier_2(pooler)
        output_3 = self.classifier_3(pooler)
        output_4 = self.classifier_4(pooler)
        output_5 = self.classifier_5(pooler)
        return output_1,output_2,output_3,output_4,output_5
    

def loss_fn(outputs, targets):
    return torch.nn.CrossEntropyLoss()(outputs, targets)

def train(epoch,model,training_loader):
    model.train()
    loop = tqdm(enumerate(training_loader, 0),total=len(training_loader))
    loop.set_description(f"Epoch {epoch}")
    for _,data in loop:
        ids = data['ids'].to(device, dtype = torch.long)
        mask = data['mask'].to(device, dtype = torch.long)
        token_type_ids = data['token_type_ids'].to(device, dtype = torch.long)
        targets = data['targets'].to(device, dtype = torch.long)

        output_1,output_2,output_3,output_4,output_5 = model(ids, mask, token_type_ids)
        optimizer.zero_grad()
        loss_1 = loss_fn(output_1, targets[:,0])
        loss_2 = loss_fn(output_2, targets[:,1])
        loss_3 = loss_fn(output_3, targets[:,2])
        loss_4 = loss_fn(output_4, targets[:,3])
        loss_5 = loss_fn(output_5, targets[:,4])
        loss = (loss_1 + loss_2 + loss_3 + loss_4 + loss_5)
        
        loop.set_postfix(loss=loss.item())
        
        loss.backward()
        optimizer.step()

def validation(testing_loader,model):
    model.eval()
    fin_targets=[]
    fin_outputs=[]
    with torch.no_grad():
        for _, data in tqdm(enumerate(testing_loader, 0),total=len(testing_loader)):
            ids = data['ids'].to(device, dtype = torch.long)
            mask = data['mask'].to(device, dtype = torch.long)
            token_type_ids = data['token_type_ids'].to(device, dtype = torch.long)
            targets = data['targets'].to(device, dtype = torch.float)
            
            output_1,output_2,output_3,output_4,output_5 = model(ids, mask, token_type_ids)
            prob_1 = nn.Softmax(dim=1)(output_1)
            prob_2 = nn.Softmax(dim=1)(output_2)
            prob_3 = nn.Softmax(dim=1)(output_3)
            prob_4 = nn.Softmax(dim=1)(output_4)
            prob_5 = nn.Softmax(dim=1)(output_5)
                        
            fin_targets.extend(targets.cpu().detach().numpy().tolist())
            fin_outputs+=[[p1.cpu().detach().numpy().tolist(),p2.cpu().detach().numpy().tolist(),
                                 p3.cpu().detach().numpy().tolist(),p4.cpu().detach().numpy().tolist(),
                                 p5.cpu().detach().numpy().tolist()] for p1,p2,p3,p4,p5 in zip(prob_1, prob_2, prob_3, prob_4, prob_5)]

    return fin_outputs, fin_targets


MAX_LEN = 128
TRAIN_BATCH_SIZE = 32
VALID_BATCH_SIZE = 32
EPOCHS = 6
LEARNING_RATE = 2e-5
special_tokens = ["[US]","[AU]","[GB]","[ZA]","[SG]","@USER","URL"]

col_idx_permutation = list(permutations(range(5)))

for model_path,model_name in zip(models,model_names):
    
    tokenizer = AutoTokenizer.from_pretrained(model_path, truncation=True)
    tokenizer.add_tokens(special_tokens)
    
    res_row_list = []
    res_df = pd.DataFrame()
    
    train_file = './data_splits/CREHate_train.csv'
    valid_file = './data_splits/CREHate_valid.csv'
    test_file = './data_splits/CREHate_test.csv'
    
    train_data = pd.read_csv(train_file)
    valid_data = pd.read_csv(valid_file)
    test_data = pd.read_csv(test_file)
    
    for idx,idx_permute in enumerate(col_idx_permutation):
        hate_cols = [_hate_cols[i] for i in idx_permute]
        
        train_df = pd.DataFrame()
        train_df['text'] = train_data['Text'] 
        train_df['labels'] = train_data[hate_cols].values.tolist()
        
        valid_df = pd.DataFrame()
        valid_df['text'] = valid_data['Text'] 
        valid_df['labels'] = valid_data[hate_cols].values.tolist()
        
        test_df = pd.DataFrame()
        test_df['text'] = test_data['Text'] 
        test_df['labels'] = test_data[hate_cols].values.tolist()
        
        
        training_set = MultiTaskDataset(train_df, tokenizer, MAX_LEN)
        valid_set = MultiTaskDataset(valid_df, tokenizer, MAX_LEN) 
        testing_set = MultiTaskDataset(test_df, tokenizer, MAX_LEN)
        
        train_params = {'batch_size': TRAIN_BATCH_SIZE,
                        'shuffle': True,
                        'num_workers': torch.cuda.device_count()
                        }
        valid_params = {'batch_size': VALID_BATCH_SIZE,
                        'shuffle': True,
                        'num_workers': torch.cuda.device_count()
                        }

        test_params = {'batch_size': VALID_BATCH_SIZE,
                        'shuffle': False,
                        'num_workers': torch.cuda.device_count()
                        }

        training_loader = DataLoader(training_set, **train_params)
        valid_loader = DataLoader(valid_set, **valid_params)
        testing_loader = DataLoader(testing_set, **test_params)
        
        model = Classifier(model_path,tokenizer)

        
        
        model = nn.DataParallel(model, device_ids =list(range(torch.cuda.device_count()))).to(device)
        
        optimizer = torch.optim.AdamW(params =  model.parameters(), lr=LEARNING_RATE, eps=1e-8)
        min_hamming_loss = 1
        best_model = None
        
        for epoch in range(EPOCHS):
            train(epoch,model,training_loader)
            outputs, targets = validation(valid_loader,model)

            final_outputs = np.array([[0 if output[0]>output[1] else 1 for output in row] for row in outputs])
            val_hamming_loss = metrics.hamming_loss(targets, final_outputs)
            val_hamming_score = hamming_score(np.array(targets), np.array(final_outputs))
            print(f"Hamming Score = {val_hamming_score}")
            print(f"Hamming Loss = {val_hamming_loss}")
            
            if val_hamming_loss < min_hamming_loss:
                min_hamming_loss = val_hamming_loss
                best_model = model
                
        
        if best_model is not None:
            
            outputs, targets = validation(testing_loader,best_model)
            
            final_outputs = np.array([[0 if output[0]>output[1] else 1 for output in row] for row in outputs])
            
            tst_hamming_loss = metrics.hamming_loss(targets, final_outputs)
            tst_hamming_score = hamming_score(np.array(targets), np.array(final_outputs))
            cols = [f'{model_name}-MT-{country}' for country in [codes[i] for i in idx_permute]]
            outputs_df = pd.DataFrame(final_outputs,columns=cols)
            total = pd.concat([test_data[hate_cols],outputs_df],axis=1)
            total.to_csv(f'./res/{model_name}-MT-ALL-P-{idx}-res.csv',index=False) 
            test_data  = pd.concat([test_data,outputs_df],axis=1)
            print(test_data)
            print(total)
            print('\tAcc\tF1\tH-F1\tN-F1')
            
            row = []
            for hate_col,code in zip(hate_cols,[codes[i] for i in idx_permute]):
                acc = metrics.accuracy_score(test_data[hate_col],outputs_df[f'{model_name}-MT-{code}'])
                f1 = metrics.f1_score(test_data[hate_col], outputs_df[f'{model_name}-MT-{code}'],average='macro')
                n,h = metrics.f1_score(test_data[hate_col], outputs_df[f'{model_name}-MT-{code}'],average=None)
                r = metrics.recall_score(test_data[hate_col], outputs_df[f'{model_name}-MT-{code}']) 
                print(f'{code}:\t{acc:.4f}\t{f1:.4f}\t{n:.4f}\t{h:.4f}\t{r:.4f}')
                row += [acc,f1,n,h,r]
            res_cols = []
            for code in [codes[i] for i in idx_permute]:
                res_cols += [f'{code}-{score}' for score in ['acc','f1','h','n','r']]
            res_df_row = pd.DataFrame([row],index=[idx],columns=res_cols)
            res_df = pd.concat([res_df,res_df_row])
            if 'avg' in res_df.index:
                res_df.drop('avg',inplace=True)
            res_df.loc['avg'] = res_df.mean(axis=0)
            print(res_df)
            res_df.to_csv(f'./res/{model_name}-MT-ALL-P-res-scores.csv')