finetune/multi_label.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 MultiLabelDataset(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.float)
        }

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 = torch.nn.Linear(config.hidden_size, 5)

    def forward(self, input_ids, attention_mask, token_type_ids):
        output_1 = self.l1(input_ids=input_ids, attention_mask=attention_mask)
        hidden_state = output_1[0]
        pooler = hidden_state[:, 0]
        pooler = self.pre_classifier(pooler)
        pooler = torch.nn.Tanh()(pooler)
        pooler = self.dropout(pooler)
        output = self.classifier(pooler)
        return output
    

def loss_fn(outputs, targets):
    return torch.nn.BCEWithLogitsLoss()(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.float)

        outputs = model(input_ids=ids, attention_mask=mask, labels=targets)

        optimizer.zero_grad()
        loss = outputs.loss
        loop.set_postfix(loss=loss.mean().item())
        
        loss.mean().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)
            outputs = model(input_ids=ids, attention_mask=mask, ).logits
            fin_targets.extend(targets.cpu().detach().numpy().tolist())
            fin_outputs.extend(torch.sigmoid(outputs).cpu().detach().numpy().tolist())
    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[1:],model_names[1:]):
    
    
    tokenizer = AutoTokenizer.from_pretrained(model_path, truncation=True)
    tokenizer.add_tokens(special_tokens)
    
    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 = MultiLabelDataset(train_df, tokenizer, MAX_LEN)
        valid_set = MultiLabelDataset(valid_df, tokenizer, MAX_LEN) 
        testing_set = MultiLabelDataset(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 = AutoModelForSequenceClassification.from_pretrained(model_path, 
                                                            problem_type="multi_label_classification", 
                                                            num_labels=5, ignore_mismatched_sizes=True)
        model.resize_token_embeddings(len(tokenizer))
        print(list(range(torch.cuda.device_count())))
        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(outputs) >=0.5
            
            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(outputs) >=0.5
            
            tst_hamming_loss = metrics.hamming_loss(targets, final_outputs)
            tst_hamming_score = hamming_score(np.array(targets), np.array(final_outputs))
            final_outputs = 1*final_outputs
            cols = [f'{model_name}-ML-{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}-ML-ALL-P-{idx}-res.csv',index=False) 
            test_data  = pd.concat([test_data,outputs_df],axis=1)
            test_data.to_csv(test_file,index=False)
            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}-ML-{code}'])
                f1 = metrics.f1_score(test_data[hate_col], outputs_df[f'{model_name}-ML-{code}'],average='macro')
                n,h = metrics.f1_score(test_data[hate_col], outputs_df[f'{model_name}-ML-{code}'],average=None)
                r = metrics.recall_score(test_data[hate_col], outputs_df[f'{model_name}-ML-{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}-ML-ALL-P-res-scores.csv')