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