Autoencoder not tested

autoencoder.py

@@ -1,5 +1,209 @@
+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)
+
+        # Freeze BERT
+        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():
-    logging.info("Autoencoder Not Implemented")
+    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()

n_grams.py

@@ -40,11 +40,6 @@ def load_pipelines():
 
 def benchmark(pipeline, debug=False):
 
-    accuracy_evaluator = evaluate.load('accuracy')
-    f1_evaluator = evaluate.load('f1')
-    precision_evaluator = evaluate.load('precision')
-    recall_evaluator = evaluate.load('recall')
-
     df_results = pd.DataFrame(
         columns=['train_domain', 'test_domain', 'accuracy', 'f1', 'precision', 'recall'])
 
@@ -67,13 +62,16 @@ def benchmark(pipeline, debug=False):
 
         y = pipeline.predict(dataset['text'])
 
-        accuracy = accuracy_evaluator.compute(
+        accuracy = evaluate.load('accuracy').compute(
             predictions=y, references=dataset['label'])['accuracy']
-        f1 = f1_evaluator.compute(
+        
+        f1 = evaluate.load('f1').compute(
             predictions=y, references=dataset['label'])['f1']
-        precision = precision_evaluator.compute(
+        
+        precision = evaluate.load('precision').compute(
             predictions=y, references=dataset['label'])['precision']
-        recall = recall_evaluator.compute(
+        
+        recall = evaluate.load('recall').compute(
             predictions=y, references=dataset['label'])['recall']
 
         logging.info(

script.sh

@@ -0,0 +1,7 @@
+pip install -U -r requirements.txt
+
+python n_grams.py
+
+python embeddings.py
+
+python autoencoder.py