|
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') |
|
|
