| import torch |
| import logging |
| from transformers import BertModel, BertTokenizerFast |
| import os |
| from pathlib import Path |
| import pandas as pd |
| from datasets import load_dataset |
| from torch.utils.data import DataLoader |
| from tqdm import tqdm |
|
|
| CURRENT_PATH = Path(__file__).parent |
|
|
|
|
| def tokenize(dataset): |
| BERT_MAX_LEN = 512 |
|
|
| tokenizer = BertTokenizerFast.from_pretrained( |
| "neuralmind/bert-base-portuguese-cased", max_length=BERT_MAX_LEN) |
|
|
| dataset = dataset.map(lambda example: tokenizer( |
| example["text"], truncation=True, padding="max_length", max_length=BERT_MAX_LEN)) |
|
|
| return dataset |
|
|
|
|
| def create_dataloader(dataset, shuffle=True): |
| return DataLoader(dataset, batch_size=8, shuffle=shuffle, num_workers=8, drop_last=True) |
|
|
|
|
| class AutoEncoder(torch.nn.Module): |
| def __init__(self): |
| super().__init__() |
|
|
| self.device = torch.device( |
| 'cuda' if torch.cuda.is_available() else 'cpu') |
|
|
| self.bert = BertModel.from_pretrained( |
| 'neuralmind/bert-base-portuguese-cased').to(self.device) |
|
|
| |
| for param in self.bert.parameters(): |
| param.requires_grad = False |
|
|
| self.encoder = torch.nn.Sequential( |
| torch.nn.Linear(self.bert.config.hidden_size, |
| self.bert.config.hidden_size // 5), |
| torch.nn.ReLU(), |
| torch.nn.Linear(self.bert.config.hidden_size // 5, |
| self.bert.config.hidden_size // 10), |
| torch.nn.ReLU(), |
| torch.nn.Linear(self.bert.config.hidden_size // 10, |
| self.bert.config.hidden_size // 30), |
| torch.nn.ReLU(), |
| ).to(self.device) |
|
|
| self.decoder = torch.nn.Sequential( |
| torch.nn.Linear(self.bert.config.hidden_size // 30, |
| self.bert.config.hidden_size // 10), |
| torch.nn.ReLU(), |
| torch.nn.Linear(self.bert.config.hidden_size // 10, |
| self.bert.config.hidden_size // 5), |
| torch.nn.ReLU(), |
| torch.nn.Linear(self.bert.config.hidden_size // |
| 5, self.bert.config.hidden_size), |
| torch.nn.Sigmoid() |
| ).to(self.device) |
|
|
| def forward(self, input_ids, attention_mask): |
| bert_output = self.bert(input_ids=input_ids, |
| attention_mask=attention_mask).last_hidden_state[:, 0, :] |
|
|
| encoded = self.encoder(bert_output) |
|
|
| decoded = self.decoder(encoded) |
|
|
| return bert_output, decoded |
|
|
|
|
| def load_models(): |
| models = [] |
|
|
| for domain in ['politics', 'news', 'law', 'social_media', 'literature', 'web']: |
| logging.info(f"Loading {domain} model...") |
|
|
| accumulator = [] |
|
|
| for lang in ['brazilian', 'european']: |
| model = AutoEncoder() |
| model.load_state_dict(torch.load(os.path.join( |
| CURRENT_PATH, 'models', 'autoencoder', f'{domain}_{lang}_model.pt'))) |
| accumulator.append(model) |
|
|
| models.append({ |
| 'models': accumulator, |
| 'train_domain': domain, |
| }) |
|
|
| return models |
|
|
|
|
| def benchmark(model, debug=False): |
|
|
| device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') |
|
|
| df_results = pd.DataFrame( |
| columns=['train_domain', 'test_domain', 'accuracy', 'f1', 'precision', 'recall']) |
|
|
| train_domain = model['train_domain'] |
|
|
| brazilian_model = model['models'][0] |
|
|
| european_model = model['models'][1] |
|
|
| brazilian_model.eval() |
| european_model.eval() |
|
|
| brazilian_model.to(device) |
| european_model.to(device) |
|
|
| for test_domain in ['politics', 'news', 'law', 'social_media', 'literature', 'web']: |
| dataset = load_dataset( |
| 'arubenruben/Portuguese_Language_Identification', test_domain, split='test') |
|
|
| if debug: |
| logging.info(f"Debugging {test_domain} dataset...") |
| dataset = dataset.select(range(100)) |
| else: |
| dataset = dataset.shuffle().select(range(min(50_000, len(dataset)))) |
|
|
| dataset = tokenize(dataset) |
|
|
| dataset.set_format(type='torch', columns=[ |
| 'input_ids', 'attention_mask', 'label']) |
|
|
| dataset = create_dataloader(dataset) |
|
|
| predictions = [] |
| labels = [] |
|
|
| reconstruction_loss = torch.nn.MSELoss(reduction='none') |
|
|
| with torch.no_grad(): |
| for batch in tqdm(dataset): |
| input_ids = batch['input_ids'].to(device) |
|
|
| attention_mask = batch['attention_mask'].to(device) |
|
|
| label = batch['label'].to(device) |
|
|
| bert_european, reconstruction_european = european_model( |
| input_ids=input_ids, attention_mask=attention_mask) |
| |
| bert_brazilian, reconstruction_brazilian = brazilian_model( |
| input_ids=input_ids, attention_mask=attention_mask) |
|
|
| test_loss_european = reconstruction_loss( |
| reconstruction_european, bert_european) |
|
|
| test_loss_brazilian = reconstruction_loss( |
| reconstruction_brazilian, bert_brazilian) |
|
|
| for loss_european, loss_brazilian in zip(test_loss_european, test_loss_brazilian): |
|
|
| if loss_european.mean().item() < loss_brazilian.mean().item(): |
| predictions.append(0) |
| total_loss += loss_european.mean().item() / len(test_loss_european) |
|
|
| else: |
| predictions.append(1) |
| total_loss += loss_brazilian.mean().item() / len(test_loss_brazilian) |
|
|
| labels.extend(label.tolist()) |
|
|
| accuracy = accuracy.compute( |
| predictions=predictions, references=labels)['accuracy'] |
| f1 = f1.compute(predictions=predictions, references=labels)['f1'] |
| precision = precision.compute( |
| predictions=predictions, references=labels)['precision'] |
| recall = recall.compute(predictions=predictions, |
| references=labels)['recall'] |
|
|
| df_results = pd.concat([df_results, pd.DataFrame( |
| [[train_domain, test_domain, accuracy, f1, precision, recall]], columns=df_results.columns)], ignore_index=True) |
|
|
| return df_results |
|
|
|
|
| def test(): |
| DEBUG = True |
|
|
| models = load_models() |
|
|
| df_results = pd.DataFrame( |
| columns=['train_domain', 'test_domain', 'accuracy', 'f1', 'precision', 'recall']) |
|
|
| for model in models: |
| logging.info(f"Train Domain {model['train_domain']}...") |
|
|
| df_results = pd.concat([df_results, benchmark( |
| model, debug=DEBUG)], ignore_index=True) |
|
|
| logging.info(f"Saving results...") |
|
|
| df_results.to_json(os.path.join(CURRENT_PATH, 'results', |
| 'autoencoder.json'), orient='records', indent=4, force_ascii=False) |
|
|
|
|
| if __name__ == '__main__': |
| test() |
|
|
