Add Benchmarks and Models

benchmark/ensemble/autoencoder.py

@@ -0,0 +1,233 @@
+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
+import numpy as np
+
+ROOT_PATH = Path(__file__).parent.parent.parent
+
+PATH_AUTOENCODER = os.path.join(
+    ROOT_PATH, "results", "autoencoder", "isolated")
+
+
+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)
+
+
+def process_results(results):
+    predictions = []
+
+    # Perform Majority Voting
+    for row in results:
+        number_of_ones = np.array(row).sum()
+
+        number_of_zeros = len(row) - number_of_ones
+
+        if number_of_ones > number_of_zeros:
+            predictions.append(1)
+        else:
+            predictions.append(0)
+
+    return predictions
+
+
+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
+
+
+class EnsembleModel(torch.nn.Module):
+    def __init__(self, domains=['law', 'literature', 'news', 'politics', 'social_media', 'web']):
+        super().__init__()
+        self.models = []
+        self.domains = domains
+        self.device = torch.device(
+            'cuda' if torch.cuda.is_available() else 'cpu')
+
+        for domain in domains:
+            dict_model = {}
+
+            for language in ['brazilian', 'european']:
+                model_state_dict = torch.load(os.path.join(
+                    PATH_AUTOENCODER, 'isolated', 'models', f"{domain}_{language}_model.pt"), map_location=self.device)
+
+                model = AutoEncoder()
+                model.load_state_dict(model_state_dict)
+                model.to(self.device)
+                model.eval()
+
+                dict_model[language] = model
+
+            self.models.append(dict_model)
+
+    def forward(self, input_ids, attention_mask):
+        results = []
+
+        loss_fn = torch.nn.MSELoss(reduction='none')
+
+        for dict_model in self.models:
+            brazilian_bert_output, brazilian_decoded = dict_model['brazilian'](
+                input_ids=input_ids, attention_mask=attention_mask)
+            european_bert_output, european_decoded = dict_model['european'](
+                input_ids=input_ids, attention_mask=attention_mask)
+
+            brazilian_loss = loss_fn(brazilian_decoded, brazilian_bert_output)
+            european_loss = loss_fn(european_decoded, european_bert_output)
+
+            brazilian_loss = torch.mean(brazilian_loss, dim=1)
+
+            european_loss = torch.mean(european_loss, dim=1)
+
+            aux_labels = []
+
+            aux_labels = torch.where(
+                european_loss < brazilian_loss, 0, 1).tolist()
+
+            results.append(aux_labels)
+
+        return np.array(results).transpose().tolist()
+
+
+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(
+            'Random-Mary-Smith/port_data_random', test_domain, split='test')
+
+        if debug:
+            logging.info(f"Debugging {test_domain} dataset...")
+            dataset = dataset.select(range(100))
+
+        dataset = tokenize(dataset)
+
+        dataset.set_format(type='torch', columns=[
+                           'input_ids', 'attention_mask', 'label'])
+
+        dataset = create_dataloader(dataset)
+
+        all_labels = []
+
+        predictions = []
+
+        with torch.no_grad():
+            for batch in tqdm(dataset, ascii=True, miniters=10):
+                input_ids = batch['input_ids'].to(model.device)
+                attention_mask = batch['attention_mask'].to(model.device)
+                labels = batch['label'].to(model.device)
+
+                results = model(input_ids, attention_mask)
+
+                all_labels.extend(labels.flatten().int().cpu().tolist())
+                predictions.extend(process_results(results))
+
+        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
+
+    df_results = pd.DataFrame(
+        columns=['train_domain', 'test_domain', 'accuracy', 'f1', 'precision', 'recall'])
+
+    model = EnsembleModel()
+
+    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(PATH_AUTOENCODER, 'out',
+                       'autoencoder.json'), orient='records', indent=4, force_ascii=False)
+
+
+if __name__ == '__main__':
+    test()

benchmark/ensemble/bert.py

@@ -0,0 +1,263 @@
+import torch
+import logging
+from pathlib import Path
+import os
+from transformers import BertModel, BertForTokenClassification
+import pandas as pd
+import evaluate
+from datasets import load_dataset
+from transformers import BertTokenizerFast
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+
+ROOT_PATH = Path(__file__).parent.parent.parent
+
+BERT_PATH = os.path.join(ROOT_PATH, 'results', 'bert', 'isolated')
+
+logging.basicConfig(level=logging.INFO,
+                    format='%(asctime)s %(levelname)s %(message)s', datefmt='%H:%M:%S', filename=os.path.join(BERT_PATH, 'out', 'debug_embeddings.txt'), filemode='w')
+
+
+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)
+
+
+def process_output(predictions, reduction):
+    final_predictions = []
+
+    for tensor in predictions:
+        if reduction == 'mean':
+            raw_label = torch.mean(tensor).item()
+        elif reduction == 'median':
+            raw_label = torch.median(tensor).item()
+        elif reduction == 'max':
+            max_value = torch.max(tensor)
+            min_value = torch.min(tensor)
+
+            raw_label = min_value.item() if abs(min_value) > max_value else max_value.item()
+        elif reduction == 'majority_vote':
+            number_of_positive = torch.sum(tensor > 0).item()
+            number_of_negative = len(tensor) - number_of_positive
+
+            raw_label = 1 if number_of_positive > number_of_negative else -1
+        else:
+            raise ValueError("Invalid reduction type")
+
+        final_predictions.append(raw_label)
+
+    final_predictions = torch.tensor(
+        final_predictions, dtype=torch.float32, device=predictions.device)
+
+    return (final_predictions > 0).flatten().int().cpu().tolist()
+
+
+def benchmark(model, debug=False):
+
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+    df_result = pd.DataFrame(
+        columns=['train_domain', 'test_domain', 'accuracy', 'f1', 'precision', 'recall'])
+
+    train_domain = model['train_domain']
+
+    model = model['model']
+
+    model.to(device)
+
+    model.eval()
+
+    for test_domain in ['politics', 'news', 'law', 'social_media', 'literature', 'web']:
+        dataset = load_dataset(
+            'Random-Mary-Smith/port_data_random', test_domain, split='test')
+
+        if debug:
+            logging.info("Debug mode: using only 100 samples")
+            dataset = dataset.shuffle().select(range(100))
+
+        dataset = tokenize(dataset)
+
+        dataset.set_format(type='torch', columns=[
+                           'input_ids', 'attention_mask', 'label'])
+
+        dataset = create_dataloader(dataset)
+
+        y = []
+
+        all_labels = []
+
+        with torch.no_grad():
+            for batch in tqdm(dataset):
+                input_ids = batch['input_ids'].to(device)
+                attention_mask = batch['attention_mask'].to(device)
+
+                # Convert Labels from 1D to 2D. Example [4] -> [4x1]
+                labels = batch['label'].unsqueeze(1).float().to(model.device)
+
+                all_labels.extend(labels.flatten().int().cpu().tolist())
+
+                outputs = model(input_ids=input_ids,
+                                attention_mask=attention_mask)
+
+                y.extend(process_output(outputs, reduction='mean'))
+
+        accuracy = evaluate.load('accuracy').compute(
+            predictions=y, references=dataset['label'])['accuracy']
+        f1 = evaluate.load('f1').compute(
+            predictions=y, references=dataset['label'])['f1']
+        precision = evaluate.load('precision').compute(
+            predictions=y, references=dataset['label'])['precision']
+        recall = evaluate.load('recall').compute(
+            predictions=y, references=dataset['label'])['recall']
+
+        df_result = pd.concat([df_result, pd.DataFrame({
+            'train_domain': [train_domain],
+            'test_domain': [test_domain],
+            'accuracy': [accuracy],
+            'f1': [f1],
+            'precision': [precision],
+            'recall': [recall],
+        })], ignore_index=True)
+
+    return df_result
+
+
+class LanguageIdentifer(torch.nn.Module):
+    def __init__(self, mode='horizontal_stacking', pos_layers_to_freeze=0, bertimbau_layers_to_freeze=0):
+        super().__init__()
+
+        self.labels = ['pt-PT', 'pt-BR']
+
+        self.portuguese_model = BertModel.from_pretrained(
+            "neuralmind/bert-base-portuguese-cased")
+
+        self.portuguese_pos_tagging_model = BertForTokenClassification.from_pretrained(
+            "lisaterumi/postagger-portuguese")
+
+        for layer in range(bertimbau_layers_to_freeze):
+            for name, param in self.portuguese_model.named_parameters():
+                if f".{layer}" in name:
+                    print(f"Freezing Layer {name} of Bertimbau")
+                    param.requires_grad = False
+
+        for layer in range(pos_layers_to_freeze):
+            for name, param in self.portuguese_pos_tagging_model.named_parameters():
+                if f".{layer}" in name:
+                    print(f"Freezing Layer {name} of POS")
+                    param.requires_grad = False
+
+        self.portuguese_pos_tagging_model.classifier = torch.nn.Identity()
+        self.mode = mode
+
+        if self.mode == 'horizontal_stacking':
+            self.linear = self.common_network(torch.nn.Linear(
+                self.portuguese_pos_tagging_model.config.hidden_size + self.portuguese_model.config.hidden_size, 512))
+        elif self.mode == 'bertimbau_only' or self.mode == 'pos_only' or self.mode == 'vertical_sum':
+            self.linear = self.common_network(torch.nn.Linear(
+                self.portuguese_model.config.hidden_size, 512))
+        else:
+            raise NotImplementedError
+
+    def common_network(self, custom_linear):
+        return torch.nn.Sequential(
+            custom_linear,
+            torch.nn.ReLU(),
+            torch.nn.Dropout(0.2),
+            torch.nn.Linear(512, 1),
+        )
+
+    def forward(self, input_ids, attention_mask):
+
+        #(Batch_Size,Sequence Length, Hidden_Size)
+        outputs_bert = self.portuguese_model(
+            input_ids=input_ids, attention_mask=attention_mask).last_hidden_state[:, 0, :]
+
+        #(Batch_Size,Sequence Length, Hidden_Size)
+        outputs_pos = self.portuguese_pos_tagging_model(
+            input_ids=input_ids, attention_mask=attention_mask).logits[:, 0, :]
+
+        if self.mode == 'horizontal_stacking':
+            outputs = torch.cat((outputs_bert, outputs_pos), dim=1)
+        elif self.mode == 'bertimbau_only':
+            outputs = outputs_bert
+        elif self.mode == 'pos_only':
+            outputs = outputs_pos
+        elif self.mode == 'vertical_sum':
+            outputs = outputs_bert + outputs_pos
+            outputs = torch.nn.functional.normalize(outputs, p=2, dim=1)
+
+        return self.linear(outputs)
+
+
+class EnsembleModel(torch.nn.Module):
+    def __init__(self, domain=['law', 'literature', 'news', 'politics', 'social_media', 'web']):
+        super().__init__()
+
+        self.domain = domain
+
+        self.models = []
+
+        self.device = torch.device(
+            'cuda' if torch.cuda.is_available() else 'cpu')
+
+        print(f'Ensemble Model running on {self.device}')
+
+        for domain in self.domain:
+            model_state_dict = torch.load(os.path.join(
+                BERT_PATH, 'isolated', 'models', f'{domain}.pt'), map_location=self.device)
+
+            new_model = LanguageIdentifer(mode='pos_only')
+
+            new_model.load_state_dict(model_state_dict)
+
+            new_model = new_model.to(self.device)
+
+            self.models.append({
+                'model': new_model,
+                'domain': domain,
+            })
+
+    def forward(self, input_ids, attention_mask):
+        results = []
+
+        for model in self.models:
+
+            model = model['model']
+
+            output = model(input_ids=input_ids, attention_mask=attention_mask)
+
+            results.append(output)
+
+        return torch.stack(results, dim=1)
+
+
+def test():
+    DEBUG = False
+
+    df_results = pd.DataFrame(
+        columns=['train_domain', 'test_domain', 'accuracy', 'f1', 'precision', 'recall'])
+
+    ensemble = EnsembleModel()
+
+    df_results = pd.concat(
+        [df_results, benchmark(ensemble, debug=DEBUG)], ignore_index=True)
+
+    logging.info("Saving Results...")
+
+    df_results.to_json(os.path.join(BERT_PATH, 'out', 'bert_ensemble.json'),
+                       orient='records', indent=4, force_ascii=False)
+
+
+if __name__ == '__main__':
+    test()

benchmark/ensemble/n_grams.py

@@ -0,0 +1,156 @@
+
+from datasets import load_dataset
+from pathlib import Path
+import pandas as pd
+import os
+import pickle
+import logging
+import evaluate
+import nltk
+import numpy as np
+from tqdm import tqdm
+
+ROOT_PATH = Path(__file__).parent.parent.parant
+
+N_GRAMS_PATH = os.path.join(ROOT_PATH, 'results', 'n_grams', 'isolated')
+
+logging.basicConfig(level=logging.INFO,
+                    format='%(asctime)s %(levelname)s %(message)s', datefmt='%H:%M:%S', filename=os.path.join(N_GRAMS_PATH, 'out', 'debug_ngrams.txt'), filemode='w')
+
+nltk.download("stopwords")
+nltk.download("punkt")
+
+
+def tokenizer(text):
+    return nltk.tokenize.word_tokenize(text, language="portuguese")
+
+
+def load_pipelines():
+    in_path = os.path.join(N_GRAMS_PATH, 'models')
+
+    pipeline = []
+
+    for domain in ['politics', 'news', 'law', 'social_media', 'literature', 'web']:
+        with open(os.path.join(in_path, f'{domain}.pickle'), 'rb') as f:
+            logging.info(f"Loading {domain} pipeline...")
+            pipeline.append({
+                'pipeline': pickle.load(f),
+                'train_domain': domain,
+            })
+
+    return pipeline
+
+
+def process_strategy(strategy, raw_predictions):
+    raw_predictions = np.array(raw_predictions)
+
+    if strategy == 'mean':
+        predictions = np.mean(raw_predictions, axis=0)
+
+    elif strategy == 'median':
+        predictions = np.median(raw_predictions, axis=0)
+
+    elif strategy == 'majority_voting':
+        raw_predictions = raw_predictions.transpose()
+
+        predictions = [1 if np.sum(row > 0) > np.sum(
+            row < 0) else -1 for row in raw_predictions]
+
+    else:
+        raise Exception(f"Strategy {strategy} not implemented")
+
+    predictions = np.array(predictions)
+
+    # Convert predictions to 1 or 0 based on a threshold
+    return np.where(predictions > 0.5, 1, 0)
+
+
+def process_batch(batch, models, strategy):
+    predictions = []
+
+    for model in models:
+        predictions.append(model.predict(batch).tolist())
+
+    return process_strategy(strategy, predictions)
+
+
+def benchmark(pipelines, debug=False):
+
+    df_results = pd.DataFrame(
+        columns=['test_domain', 'accuracy', 'f1', 'precision', 'recall'])
+
+    accuracy_evaluate = evaluate.load('accuracy')
+    f1_evaluate = evaluate.load('f1')
+    precision_evaluate = evaluate.load('precision')
+    recall_evaluate = evaluate.load('recall')
+
+    for test_domain in ['politics', 'news', 'law', 'social_media', 'literature', 'web']:
+
+        logging.info(f"Test Domain {test_domain}...")
+
+        dataset = load_dataset(
+            'Random-Mary-Smith/port_data_random', test_domain, split='test')
+
+        if debug:
+            logging.info("Debug mode: using only 100 samples")
+            dataset = dataset.shuffle().select(range(100))
+
+        batch = []
+        predictions = []
+
+        for row in tqdm(dataset):
+            batch.append(row['text'])
+
+            if len(batch) == 100:
+                predictions.extend(process_batch(
+                    batch, pipelines, 'majority_voting'))
+                batch = []
+
+        if len(batch) > 0:
+            predictions.extend(process_batch(
+                batch, pipelines, 'majority_voting'))
+
+        accuracy = accuracy_evaluate.compute(
+            predictions=predictions, references=dataset['label'])['accuracy']
+        f1 = f1_evaluate.compute(
+            predictions=predictions, references=dataset['label'])['f1']
+        precision = precision_evaluate.compute(
+            predictions=predictions, references=dataset['label'])['precision']
+        recall = recall_evaluate.compute(
+            predictions=predictions, references=dataset['label'])['recall']
+
+        logging.info(
+            f"Accuracy: {accuracy} | F1: {f1} | Precision: {precision} | Recall: {recall}")
+
+        df_results = pd.concat([df_results, pd.DataFrame(
+            [[test_domain, accuracy, f1, precision, recall]], columns=df_results.columns)], ignore_index=True)
+
+    return df_results
+
+
+def test():
+
+    DEBUG = False
+
+    pipelines = []
+
+    for domain in ['politics', 'news', 'law', 'social_media', 'literature', 'web']:
+        with open(os.path.join(N_GRAMS_PATH, "models", f"{domain}.pickle"), "rb") as f:
+            pipelines.append(pickle.load(f))
+
+    logging.info(f"Debug mode: {DEBUG}")
+
+    df_results = pd.DataFrame(
+        columns=['train_domain', 'test_domain', 'accuracy', 'f1', 'precision', 'recall'])
+
+    df_results = pd.concat(
+        [df_results, benchmark(pipelines, debug=True)], ignore_index=True)
+
+    logging.info("Saving results...")
+
+    df_results.to_json(os.path.join(N_GRAMS_PATH, 'out', 'n_grams.json'),
+                       orient='records', indent=4, force_ascii=False)
+
+
+if __name__ == "__main__":
+    test()

benchmark/isolated/autoencoder.py

@@ -0,0 +1,210 @@
+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
+
+ROOT_PATH = Path(__file__).parent.parent.parent
+
+PATH_AUTOENCODER = os.path.join(
+    ROOT_PATH, "results", "autoencoder", "isolated")
+
+
+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(
+                PATH_AUTOENCODER, 'models', 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(
+            'Random-Mary-Smith/port_data_random', test_domain, split='test')
+
+        if debug:
+            logging.info(f"Debugging {test_domain} dataset...")
+            dataset = dataset.select(range(100))
+
+        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(PATH_AUTOENCODER, 'out',
+                           'autoencoder.json'), orient='records', indent=4, force_ascii=False)
+
+
+if __name__ == '__main__':
+    test()

benchmark/isolated/bert.py

@@ -0,0 +1,205 @@
+import torch
+import logging
+from pathlib import Path
+import os
+from transformers import BertModel, BertForTokenClassification
+import pandas as pd
+import evaluate
+from datasets import load_dataset
+from transformers import BertTokenizerFast
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+
+ROOT_PATH = Path(__file__).parent.parent.parent
+
+BERT_PATH = os.path.join(ROOT_PATH, 'results', 'bert', 'isolated')
+
+logging.basicConfig(level=logging.INFO,
+                    format='%(asctime)s %(levelname)s %(message)s', datefmt='%H:%M:%S', filename=os.path.join(BERT_PATH, 'out', 'debug_embeddings.txt'), filemode='w')
+
+
+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 LanguageIdentifer(torch.nn.Module):
+    def __init__(self, mode='horizontal_stacking', pos_layers_to_freeze=0, bertimbau_layers_to_freeze=0):
+        super().__init__()
+
+        self.labels = ['pt-PT', 'pt-BR']
+
+        self.portuguese_model = BertModel.from_pretrained(
+            "neuralmind/bert-base-portuguese-cased")
+
+        self.portuguese_pos_tagging_model = BertForTokenClassification.from_pretrained(
+            "lisaterumi/postagger-portuguese")
+
+        for layer in range(bertimbau_layers_to_freeze):
+            for name, param in self.portuguese_model.named_parameters():
+                if f".{layer}" in name:
+                    print(f"Freezing Layer {name} of Bertimbau")
+                    param.requires_grad = False
+
+        for layer in range(pos_layers_to_freeze):
+            for name, param in self.portuguese_pos_tagging_model.named_parameters():
+                if f".{layer}" in name:
+                    print(f"Freezing Layer {name} of POS")
+                    param.requires_grad = False
+
+        self.portuguese_pos_tagging_model.classifier = torch.nn.Identity()
+        self.mode = mode
+
+        if self.mode == 'horizontal_stacking':
+            self.linear = self.common_network(torch.nn.Linear(
+                self.portuguese_pos_tagging_model.config.hidden_size + self.portuguese_model.config.hidden_size, 512))
+        elif self.mode == 'bertimbau_only' or self.mode == 'pos_only' or self.mode == 'vertical_sum':
+            self.linear = self.common_network(torch.nn.Linear(
+                self.portuguese_model.config.hidden_size, 512))
+        else:
+            raise NotImplementedError
+
+    def common_network(self, custom_linear):
+        return torch.nn.Sequential(
+            custom_linear,
+            torch.nn.ReLU(),
+            torch.nn.Dropout(0.2),
+            torch.nn.Linear(512, 1),
+        )
+
+    def forward(self, input_ids, attention_mask):
+
+        #(Batch_Size,Sequence Length, Hidden_Size)
+        outputs_bert = self.portuguese_model(
+            input_ids=input_ids, attention_mask=attention_mask).last_hidden_state[:, 0, :]
+
+        #(Batch_Size,Sequence Length, Hidden_Size)
+        outputs_pos = self.portuguese_pos_tagging_model(
+            input_ids=input_ids, attention_mask=attention_mask).logits[:, 0, :]
+
+        if self.mode == 'horizontal_stacking':
+            outputs = torch.cat((outputs_bert, outputs_pos), dim=1)
+        elif self.mode == 'bertimbau_only':
+            outputs = outputs_bert
+        elif self.mode == 'pos_only':
+            outputs = outputs_pos
+        elif self.mode == 'vertical_sum':
+            outputs = outputs_bert + outputs_pos
+            outputs = torch.nn.functional.normalize(outputs, p=2, dim=1)
+
+        return self.linear(outputs)
+
+
+def load_models():
+    models = []
+
+    for domain in ['politics', 'news', 'law', 'social_media', 'literature', 'web']:
+        logging.info(f"Loading {domain} model...")
+
+        model = LanguageIdentifer(mode='pos_only')
+        model.load_state_dict(torch.load(os.path.join(
+            BERT_PATH, 'models', f'{domain}.pt')))
+
+        models.append({
+            'model': model,
+            'train_domain': domain,
+        })
+
+    return models
+
+
+def benchmark(model, debug=False):
+
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+    df_result = pd.DataFrame(
+        columns=['train_domain', 'test_domain', 'accuracy', 'f1', 'precision', 'recall'])
+
+    train_domain = model['train_domain']
+
+    model = model['model']
+
+    model.to(device)
+
+    model.eval()
+
+    for test_domain in ['politics', 'news', 'law', 'social_media', 'literature', 'web']:
+        dataset = load_dataset(
+            'Random-Mary-Smith/port_data_random', test_domain, split='test')
+
+        if debug:
+            logging.info("Debug mode: using only 100 samples")
+            dataset = dataset.shuffle().select(range(100))
+
+        dataset = tokenize(dataset)
+
+        dataset.set_format(type='torch', columns=[
+                           'input_ids', 'attention_mask', 'label'])
+
+        dataset = create_dataloader(dataset)
+
+        y = []
+
+        with torch.no_grad():
+            for batch in tqdm(dataset):
+                input_ids = batch['input_ids'].to(device)
+                attention_mask = batch['attention_mask'].to(device)
+
+                y.extend(model(input_ids, attention_mask).cpu().detach().numpy())
+
+        y = [1 if y_ > 0.5 else 0 for y_ in y]
+
+        accuracy = evaluate.load('accuracy').compute(
+            predictions=y, references=dataset['label'])['accuracy']
+        f1 = evaluate.load('f1').compute(
+            predictions=y, references=dataset['label'])['f1']
+        precision = evaluate.load('precision').compute(
+            predictions=y, references=dataset['label'])['precision']
+        recall = evaluate.load('recall').compute(
+            predictions=y, references=dataset['label'])['recall']
+
+        df_result = pd.concat([df_result, pd.DataFrame({
+            'train_domain': [train_domain],
+            'test_domain': [test_domain],
+            'accuracy': [accuracy],
+            'f1': [f1],
+            'precision': [precision],
+            'recall': [recall],
+        })], ignore_index=True)
+
+    return df_result
+
+
+def test():
+    DEBUG = False
+
+    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("Saving Results...")
+
+        df_results.to_json(os.path.join(BERT_PATH, 'out', 'embeddings.json'),
+                           orient='records', indent=4, force_ascii=False)
+
+
+if __name__ == '__main__':
+    test()

benchmark/isolated/n_grams.py

@@ -0,0 +1,108 @@
+
+from datasets import load_dataset
+from pathlib import Path
+import pandas as pd
+import os
+import pickle
+import logging
+import evaluate
+import nltk
+
+ROOT_PATH = Path(__file__).parent.parent.parant
+
+N_GRAMS_PATH = os.path.join(ROOT_PATH, 'results', 'n_grams', 'isolated')
+
+logging.basicConfig(level=logging.INFO,
+                    format='%(asctime)s %(levelname)s %(message)s', datefmt='%H:%M:%S', filename=os.path.join(N_GRAMS_PATH, 'out', 'debug_ngrams.txt'), filemode='w')
+
+nltk.download("stopwords")
+nltk.download("punkt")
+
+
+def tokenizer(text):
+    return nltk.tokenize.word_tokenize(text, language="portuguese")
+
+
+def load_pipelines():
+    in_path = os.path.join(N_GRAMS_PATH, 'models')
+
+    pipeline = []
+
+    for domain in ['politics', 'news', 'law', 'social_media', 'literature', 'web']:
+        with open(os.path.join(in_path, f'{domain}.pickle'), 'rb') as f:
+            logging.info(f"Loading {domain} pipeline...")
+            pipeline.append({
+                'pipeline': pickle.load(f),
+                'train_domain': domain,
+            })
+
+    return pipeline
+
+
+def benchmark(pipeline, debug=False):
+
+    df_results = pd.DataFrame(
+        columns=['train_domain', 'test_domain', 'accuracy', 'f1', 'precision', 'recall'])
+
+    train_domain = pipeline['train_domain']
+
+    pipeline = pipeline['pipeline']
+
+    for test_domain in ['politics', 'news', 'law', 'social_media', 'literature', 'web']:
+
+        logging.info(f"Test Domain {test_domain}...")
+
+        dataset = load_dataset(
+            'Random-Mary-Smith/port_data_random', test_domain, split='test')
+
+        if debug:
+            logging.info("Debug mode: using only 100 samples")
+            dataset = dataset.shuffle().select(range(100))
+
+        y = pipeline.predict(dataset['text'])
+
+        accuracy = evaluate.load('accuracy').compute(
+            predictions=y, references=dataset['label'])['accuracy']
+
+        f1 = evaluate.load('f1').compute(
+            predictions=y, references=dataset['label'])['f1']
+
+        precision = evaluate.load('precision').compute(
+            predictions=y, references=dataset['label'])['precision']
+
+        recall = evaluate.load('recall').compute(
+            predictions=y, references=dataset['label'])['recall']
+
+        logging.info(
+            f"Accuracy: {accuracy} | F1: {f1} | Precision: {precision} | Recall: {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 = False
+
+    logging.info(f"Debug mode: {DEBUG}")
+
+    pipelines = load_pipelines()
+    df_results = pd.DataFrame(
+        columns=['train_domain', 'test_domain', 'accuracy', 'f1', 'precision', 'recall'])
+
+    for pipeline in pipelines:
+        logging.info(f"Train Domain {pipeline['train_domain']}...")
+
+        df_results = pd.concat(
+            [df_results, benchmark(pipeline, debug=True)], ignore_index=True)
+
+        logging.info("Saving results...")
+
+        df_results.to_json(os.path.join(N_GRAMS_PATH, 'out', 'n_grams.json'),
+                           orient='records', indent=4, force_ascii=False)
+
+
+if __name__ == "__main__":
+    test()

benchmark/requirements.txt

@@ -0,0 +1,9 @@
+evaluate
+datasets
+transformers
+torch
+sklearn
+python-dotenv
+pandas
+nltk
+numpy

benchmark/run.sh

@@ -0,0 +1,19 @@
+pip install -U -r requirements.txt
+
+echo "N-Grams Isolated"
+python isolated/n_grams.py
+
+echo "Embeddings Isolated"
+python isolated/embeddings.py
+
+echo "Autoencoder Isolated"
+python isolated/autoencoder.py
+
+echo "N-Grams Ensemble"
+python ensemble/n_grams.py
+
+echo "Embeddings Ensemble"
+python ensemble/embeddings.py
+
+echo "Autoencoder Ensemble"
+python ensemble/autoencoder.py

results/autoencoder/ensemble/autoencoder_two_models_bert_ensemble.json

@@ -0,0 +1,51 @@
+[
+    {
+        "domain": "literature",
+        "accuracy": 0.811065051,
+        "precision": 0.2609853529,
+        "recall": 0.2372881356,
+        "f1": 0.2485732403
+    },
+    {
+        "domain": "web",
+        "accuracy": 0.9622961957,
+        "precision": 0.9545522056,
+        "recall": 0.9958165479,
+        "f1": 0.9747478577
+    },
+    {
+        "domain": "politics",
+        "accuracy": 0.9711538462,
+        "precision": 0.9904552129,
+        "recall": 0.9420391061,
+        "f1": 0.9656406586
+    },
+    {
+        "domain": "social_media",
+        "accuracy": 0.869140625,
+        "precision": 0.884,
+        "recall": 0.8532818533,
+        "f1": 0.8683693517
+    },
+    {
+        "domain": "law",
+        "accuracy": 0.9862580128,
+        "precision": 0.5836298932,
+        "recall": 0.2237380628,
+        "f1": 0.3234714004
+    },
+    {
+        "domain": "news",
+        "accuracy": 0.9621394231,
+        "precision": 0.8615737204,
+        "recall": 0.9611385717,
+        "f1": 0.9086368031
+    },
+    {
+        "domain": "dslcc",
+        "accuracy": 0.7217741935,
+        "precision": 0.9311023622,
+        "recall": 0.4777777778,
+        "f1": 0.6315086782
+    }
+]

results/autoencoder/isolated/models/law_brazilian_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:444001532ac9842ae633037e1d747b3143f1ee0dcf4c83a4651cc4bede9dd02d
+size 436832599

results/autoencoder/isolated/models/law_european_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c7b88d69e3514c292d715a86e7d431e7e38de66945e8e37c4822ee9b2076eec
+size 436832386

results/autoencoder/isolated/models/literature_brazilian_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:52654c651543949e087d9fad18b5d05a2fc7b32ee87f3e5caf54fba039bd4a40
+size 436834538

results/autoencoder/isolated/models/literature_european_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d9ea3c1082c7736371a91df53986132e45e4ce498632f5f2030e96c6035bd2b8
+size 436834325

results/autoencoder/isolated/models/news_brazilian_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad68858f7adbf2716f2625f3ac23616e7be798ad825765de9a2d215ba716770a
+size 436832812

results/autoencoder/isolated/models/news_european_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab068cf0430b89fb2a7d0f5328eaee6b3d8eff5a45861eac1cfb86e674a5c426
+size 436832599

results/autoencoder/isolated/models/politics_brazilian_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7269e21cda82de1812f3d04dc780e51b423ecd21406ff688c3c13a9f475c2880
+size 436834112

results/autoencoder/isolated/models/politics_european_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab8fc3cdf5dcd2f68767a85d99a51aa4670c875299a33c39988d7dc0d9d7ba54
+size 436833899

results/autoencoder/isolated/models/social_media_brazilian_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:24eb156db710d19443aefbd0f99ab62434ae2c7fa4cc02220048b2be7fd3d945
+size 436834964

results/autoencoder/isolated/models/social_media_european_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8b00fa7475744c1f0ce3da688ef96615c40e62777329954d3220a281647fb782
+size 436834751

results/autoencoder/isolated/models/web_brazilian_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:18d4403dbe50ce55ee68db624dfa96b48caa75d913317b7e403197a2518471b7
+size 436832599

results/autoencoder/isolated/models/web_european_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:96d788e6a7ffbcae6537abab2318ee948276d095dcd8efe0211cb3b24bedf76f
+size 436832386

results/autoencoder/isolated/out/autoencoder_two_models_bert.json

@@ -0,0 +1,298 @@
+[
+    {
+        "train_domain":"politics",
+        "test_domain":"politics",
+        "accuracy":0.9964871194,
+        "f1":0.995898838,
+        "precision":0.9986291981,
+        "recall":0.9931833674
+    },
+    {
+        "train_domain":"politics",
+        "test_domain":"news",
+        "accuracy":0.9326,
+        "f1":0.8001897308,
+        "precision":0.9323017408,
+        "recall":0.7008724553
+    },
+    {
+        "train_domain":"politics",
+        "test_domain":"law",
+        "accuracy":0.733,
+        "f1":0.6927502877,
+        "precision":0.8157181572,
+        "recall":0.602
+    },
+    {
+        "train_domain":"politics",
+        "test_domain":"social_media",
+        "accuracy":0.7583333333,
+        "f1":0.7826086957,
+        "precision":0.7111716621,
+        "recall":0.87
+    },
+    {
+        "train_domain":"politics",
+        "test_domain":"literature",
+        "accuracy":0.7081749049,
+        "f1":0.2194915254,
+        "precision":0.1695026178,
+        "recall":0.3112980769
+    },
+    {
+        "train_domain":"politics",
+        "test_domain":"web",
+        "accuracy":0.8920351986,
+        "f1":0.9221761405,
+        "precision":0.97405944,
+        "recall":0.8755404571
+    },
+    {
+        "train_domain":"news",
+        "test_domain":"politics",
+        "accuracy":0.9411592506,
+        "f1":0.9358851675,
+        "precision":0.8800239952,
+        "recall":0.9993188011
+    },
+    {
+        "train_domain":"news",
+        "test_domain":"news",
+        "accuracy":0.96158,
+        "f1":0.9057640422,
+        "precision":0.857275513,
+        "recall":0.9600665557
+    },
+    {
+        "train_domain":"news",
+        "test_domain":"law",
+        "accuracy":0.783,
+        "f1":0.8181056161,
+        "precision":0.7041847042,
+        "recall":0.976
+    },
+    {
+        "train_domain":"news",
+        "test_domain":"social_media",
+        "accuracy":0.6283333333,
+        "f1":0.7283800244,
+        "precision":0.5738963532,
+        "recall":0.9966666667
+    },
+    {
+        "train_domain":"news",
+        "test_domain":"literature",
+        "accuracy":0.6192965779,
+        "f1":0.2373849572,
+        "precision":0.1612068966,
+        "recall":0.4500601685
+    },
+    {
+        "train_domain":"news",
+        "test_domain":"web",
+        "accuracy":0.9623194946,
+        "f1":0.974758162,
+        "precision":0.9545589106,
+        "recall":0.9958307597
+    },
+    {
+        "train_domain":"law",
+        "test_domain":"politics",
+        "accuracy":0.5825526932,
+        "f1":0.0606060606,
+        "precision":0.92,
+        "recall":0.0313351499
+    },
+    {
+        "train_domain":"law",
+        "test_domain":"news",
+        "accuracy":0.80902,
+        "f1":0.0072772637,
+        "precision":0.9459459459,
+        "recall":0.0036526821
+    },
+    {
+        "train_domain":"law",
+        "test_domain":"law",
+        "accuracy":0.627,
+        "f1":0.4069952305,
+        "precision":0.992248062,
+        "recall":0.256
+    },
+    {
+        "train_domain":"law",
+        "test_domain":"social_media",
+        "accuracy":0.5,
+        "f1":0.0,
+        "precision":0.0,
+        "recall":0.0
+    },
+    {
+        "train_domain":"law",
+        "test_domain":"literature",
+        "accuracy":0.8681875792,
+        "f1":0.0,
+        "precision":0.0,
+        "recall":0.0
+    },
+    {
+        "train_domain":"law",
+        "test_domain":"web",
+        "accuracy":0.272450361,
+        "f1":0.0086087625,
+        "precision":1.0,
+        "recall":0.004322989
+    },
+    {
+        "train_domain":"social_media",
+        "test_domain":"politics",
+        "accuracy":0.9464285714,
+        "f1":0.9376065462,
+        "precision":0.9385665529,
+        "recall":0.9366485014
+    },
+    {
+        "train_domain":"social_media",
+        "test_domain":"news",
+        "accuracy":0.8606,
+        "f1":0.4624402283,
+        "precision":0.9065618385,
+        "recall":0.3103840977
+    },
+    {
+        "train_domain":"social_media",
+        "test_domain":"law",
+        "accuracy":0.735,
+        "f1":0.6856465006,
+        "precision":0.8425655977,
+        "recall":0.578
+    },
+    {
+        "train_domain":"social_media",
+        "test_domain":"social_media",
+        "accuracy":0.9133333333,
+        "f1":0.9155844156,
+        "precision":0.8924050633,
+        "recall":0.94
+    },
+    {
+        "train_domain":"social_media",
+        "test_domain":"literature",
+        "accuracy":0.7621989861,
+        "f1":0.2337927514,
+        "precision":0.2030141844,
+        "recall":0.2755716005
+    },
+    {
+        "train_domain":"social_media",
+        "test_domain":"web",
+        "accuracy":0.3959837545,
+        "f1":0.3026829904,
+        "precision":0.9675270608,
+        "recall":0.1794040451
+    },
+    {
+        "train_domain":"literature",
+        "test_domain":"politics",
+        "accuracy":0.5714285714,
+        "f1":0.0040816327,
+        "precision":1.0,
+        "recall":0.0020449898
+    },
+    {
+        "train_domain":"literature",
+        "test_domain":"news",
+        "accuracy":0.81004,
+        "f1":0.007523511,
+        "precision":0.4090909091,
+        "recall":0.0037966674
+    },
+    {
+        "train_domain":"literature",
+        "test_domain":"law",
+        "accuracy":0.5,
+        "f1":0.0,
+        "precision":0.0,
+        "recall":0.0
+    },
+    {
+        "train_domain":"literature",
+        "test_domain":"social_media",
+        "accuracy":0.5,
+        "f1":0.0,
+        "precision":0.0,
+        "recall":0.0
+    },
+    {
+        "train_domain":"literature",
+        "test_domain":"literature",
+        "accuracy":0.9085868188,
+        "f1":0.6526189043,
+        "precision":0.6537997587,
+        "recall":0.6514423077
+    },
+    {
+        "train_domain":"literature",
+        "test_domain":"web",
+        "accuracy":0.2691787004,
+        "f1":0.000308642,
+        "precision":0.3333333333,
+        "recall":0.0001543925
+    },
+    {
+        "train_domain":"web",
+        "test_domain":"politics",
+        "accuracy":0.4294496487,
+        "f1":0.600860127,
+        "precision":0.4294496487,
+        "recall":1.0
+    },
+    {
+        "train_domain":"web",
+        "test_domain":"news",
+        "accuracy":0.19406,
+        "f1":0.3250422927,
+        "precision":0.19406,
+        "recall":1.0
+    },
+    {
+        "train_domain":"web",
+        "test_domain":"law",
+        "accuracy":0.5,
+        "f1":0.6666666667,
+        "precision":0.5,
+        "recall":1.0
+    },
+    {
+        "train_domain":"web",
+        "test_domain":"social_media",
+        "accuracy":0.5,
+        "f1":0.6666666667,
+        "precision":0.5,
+        "recall":1.0
+    },
+    {
+        "train_domain":"web",
+        "test_domain":"literature",
+        "accuracy":0.1316539924,
+        "f1":0.2326753465,
+        "precision":0.1316539924,
+        "recall":1.0
+    },
+    {
+        "train_domain":"web",
+        "test_domain":"web",
+        "accuracy":0.7305956679,
+        "f1":0.8443285528,
+        "precision":0.7305956679,
+        "recall":1.0
+    },
+    {
+        "train_domain": "dslcc",
+        "test_domain": "dslcc",
+        "accuracy": 0.8385,
+        "f1": 0.8532485234,
+        "precision": 0.7818484596,
+        "recall": 0.939
+    }
+]

results/bert/all_mixed/models/all_mixed.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:beaadaa18288ba670f5462b6d64608141636430a8b8eab8d4a74bfbac0a3ff9c
+size 870781645

results/bert/all_mixed/out/results.json

@@ -0,0 +1,20 @@
+[
+    {
+        "epoch":0,
+        "train_loss":0.0914312218,
+        "validation_loss":0.0514053669,
+        "validation_accuracy":0.9849954874,
+        "validation_f1":0.9897747367,
+        "validation_precision":0.9857580398,
+        "validation_recall":0.9938243014
+    },
+    {
+        "epoch":1,
+        "train_loss":0.0308213484,
+        "validation_loss":0.0557541026,
+        "validation_accuracy":0.9862364621,
+        "validation_f1":0.9906067139,
+        "validation_precision":0.988172043,
+        "validation_recall":0.9930534115
+    }
+]

results/bert/ensemble/bert_ensemble.json

@@ -0,0 +1,58 @@
+[
+    {
+        "domain": "law",
+        "accuracy": 0.9174107143,
+        "f1": 0.9160997732,
+        "precision": 0.9099099099,
+        "recall": 0.9223744292,
+        "reduction": "mean"
+    },
+    {
+        "domain": "literature",
+        "accuracy": 0.8989158163,
+        "f1": 0.5914948454,
+        "precision": 0.6296296296,
+        "recall": 0.5577156744,
+        "reduction": "mean"
+    },
+    {
+        "domain": "news",
+        "accuracy": 0.9659455128,
+        "f1": 0.9082816293,
+        "precision": 0.9614505997,
+        "recall": 0.8606850716,
+        "reduction": "mean"
+    },
+    {
+        "domain": "politics",
+        "accuracy": 0.9930889423,
+        "f1": 0.9918928446,
+        "precision": 0.9964589235,
+        "recall": 0.9873684211,
+        "reduction": "mean"
+    },
+    {
+        "domain": "social_media",
+        "accuracy": 0.87109375,
+        "f1": 0.875,
+        "precision": 0.8555555556,
+        "recall": 0.8953488372,
+        "reduction": "mean"
+    },
+    {
+        "domain": "web",
+        "accuracy": 0.9461050725,
+        "f1": 0.9621200064,
+        "precision": 0.9895236536,
+        "recall": 0.9361932786,
+        "reduction": "mean"
+    },
+    {
+        "domain": "dslcc",
+        "accuracy": 0.9417842742,
+        "precision": 0.927734375,
+        "recall": 0.9581442259,
+        "f1": 0.9426941206,
+        "reduction": "mean"
+    }
+]

results/bert/isolated/models/law.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1eea49d09c473d5e5f48cd13684f7ef8a2169b8cdef8c3f1b416098a6d2906af
+size 870778721

results/bert/isolated/models/literature.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ed0b9eea2b8e952dc7de0b336df9ea9b7c711e2493335ad2e84f9cf6558160a
+size 870781645

results/bert/isolated/models/news.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:43919c77fb5b3c0b0c4f655db7aafe411e50288c7bcab0f6a2ca57b736669c8c
+size 870781645

results/bert/isolated/models/politics.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eb16dbe006cacded46926019d19444f594bd6837db5e4bf9b689c2cc121e3b31
+size 870781645

results/bert/isolated/models/social_media.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea2013fd41113421e0bbc7c194c748b2938a5d87424e3b19180b696b7b5b9e1d
+size 870781645

results/bert/isolated/models/web.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eb13539ce7edba148aaee8689bf2ba64b57f52b9ddae5c3daf95b7bd9b1eb02f
+size 870781645

results/bert/isolated/out/bert_isolated.json

@@ -0,0 +1,298 @@
+[
+    {
+        "train_domain":"politics",
+        "test_domain":"politics",
+        "accuracy":1.0,
+        "f1":1.0,
+        "precision":1.0,
+        "recall":1.0
+    },
+    {
+        "train_domain":"politics",
+        "test_domain":"news",
+        "accuracy":0.79322,
+        "f1":0.6391148033,
+        "precision":0.4800985893,
+        "recall":0.9556367432
+    },
+    {
+        "train_domain":"politics",
+        "test_domain":"law",
+        "accuracy":0.537,
+        "f1":0.6537023186,
+        "precision":0.5221027479,
+        "recall":0.874
+    },
+    {
+        "train_domain":"politics",
+        "test_domain":"social_media",
+        "accuracy":0.745,
+        "f1":0.7779390421,
+        "precision":0.6889460154,
+        "recall":0.8933333333
+    },
+    {
+        "train_domain":"politics",
+        "test_domain":"literature",
+        "accuracy":0.2461977186,
+        "f1":0.2225490196,
+        "precision":0.1287821483,
+        "recall":0.8185096154
+    },
+    {
+        "train_domain":"politics",
+        "test_domain":"web",
+        "accuracy":0.7766245487,
+        "f1":0.8349449817,
+        "precision":0.9074107628,
+        "recall":0.773197468
+    },
+    {
+        "train_domain":"news",
+        "test_domain":"politics",
+        "accuracy":0.8711943794,
+        "f1":0.8433048433,
+        "precision":0.8829231916,
+        "recall":0.8070892979
+    },
+    {
+        "train_domain":"news",
+        "test_domain":"news",
+        "accuracy":0.9904,
+        "f1":0.9748348537,
+        "precision":0.9714733542,
+        "recall":0.978219697
+    },
+    {
+        "train_domain":"news",
+        "test_domain":"law",
+        "accuracy":0.867,
+        "f1":0.8618899273,
+        "precision":0.8963282937,
+        "recall":0.83
+    },
+    {
+        "train_domain":"news",
+        "test_domain":"social_media",
+        "accuracy":0.6516666667,
+        "f1":0.7052186178,
+        "precision":0.6112469438,
+        "recall":0.8333333333
+    },
+    {
+        "train_domain":"news",
+        "test_domain":"literature",
+        "accuracy":0.8113117871,
+        "f1":0.3252124646,
+        "precision":0.3076098607,
+        "recall":0.3449519231
+    },
+    {
+        "train_domain":"news",
+        "test_domain":"web",
+        "accuracy":0.9653655235,
+        "f1":0.9760735718,
+        "precision":0.9853658537,
+        "recall":0.9669549104
+    },
+    {
+        "train_domain":"law",
+        "test_domain":"politics",
+        "accuracy":0.7570257611,
+        "f1":0.759837963,
+        "precision":0.659798995,
+        "recall":0.8956343793
+    },
+    {
+        "train_domain":"law",
+        "test_domain":"news",
+        "accuracy":0.93408,
+        "f1":0.8249415764,
+        "precision":0.8448651001,
+        "recall":0.8059360731
+    },
+    {
+        "train_domain":"law",
+        "test_domain":"law",
+        "accuracy":0.991,
+        "f1":0.9909547739,
+        "precision":0.995959596,
+        "recall":0.986
+    },
+    {
+        "train_domain":"law",
+        "test_domain":"social_media",
+        "accuracy":0.5866666667,
+        "f1":0.6467236467,
+        "precision":0.5646766169,
+        "recall":0.7566666667
+    },
+    {
+        "train_domain":"law",
+        "test_domain":"literature",
+        "accuracy":0.8241444867,
+        "f1":0.2570281124,
+        "precision":0.2900302115,
+        "recall":0.2307692308
+    },
+    {
+        "train_domain":"law",
+        "test_domain":"web",
+        "accuracy":0.8910198556,
+        "f1":0.9210139002,
+        "precision":0.9787973584,
+        "recall":0.8696726374
+    },
+    {
+        "train_domain":"social_media",
+        "test_domain":"politics",
+        "accuracy":0.9871194379,
+        "f1":0.9851551957,
+        "precision":0.9759358289,
+        "recall":0.9945504087
+    },
+    {
+        "train_domain":"social_media",
+        "test_domain":"news",
+        "accuracy":0.92494,
+        "f1":0.7731366741,
+        "precision":0.9403028966,
+        "recall":0.6564360501
+    },
+    {
+        "train_domain":"social_media",
+        "test_domain":"law",
+        "accuracy":0.831,
+        "f1":0.8234064786,
+        "precision":0.8621444201,
+        "recall":0.788
+    },
+    {
+        "train_domain":"social_media",
+        "test_domain":"social_media",
+        "accuracy":0.9716666667,
+        "f1":0.9713322091,
+        "precision":0.9829351536,
+        "recall":0.96
+    },
+    {
+        "train_domain":"social_media",
+        "test_domain":"literature",
+        "accuracy":0.806400507,
+        "f1":0.285380117,
+        "precision":0.2775881684,
+        "recall":0.293622142
+    },
+    {
+        "train_domain":"social_media",
+        "test_domain":"web",
+        "accuracy":0.9073781588,
+        "f1":0.9333766128,
+        "precision":0.9837495724,
+        "recall":0.8879110699
+    },
+    {
+        "train_domain":"literature",
+        "test_domain":"politics",
+        "accuracy":0.6053864169,
+        "f1":0.1543287327,
+        "precision":0.9761904762,
+        "recall":0.0837874659
+    },
+    {
+        "train_domain":"literature",
+        "test_domain":"news",
+        "accuracy":0.82226,
+        "f1":0.1939229025,
+        "precision":0.7267165194,
+        "recall":0.1118903077
+    },
+    {
+        "train_domain":"literature",
+        "test_domain":"law",
+        "accuracy":0.534,
+        "f1":0.1527272727,
+        "precision":0.84,
+        "recall":0.084
+    },
+    {
+        "train_domain":"literature",
+        "test_domain":"social_media",
+        "accuracy":0.5566666667,
+        "f1":0.3813953488,
+        "precision":0.6307692308,
+        "recall":0.2733333333
+    },
+    {
+        "train_domain":"literature",
+        "test_domain":"literature",
+        "accuracy":0.9632446134,
+        "f1":0.8730853392,
+        "precision":0.8012048193,
+        "recall":0.9591346154
+    },
+    {
+        "train_domain":"literature",
+        "test_domain":"web",
+        "accuracy":0.3385604693,
+        "f1":0.1805730259,
+        "precision":0.9513991163,
+        "recall":0.0997529339
+    },
+    {
+        "train_domain":"web",
+        "test_domain":"politics",
+        "accuracy":0.9464285714,
+        "f1":0.9397431676,
+        "precision":0.9094964946,
+        "recall":0.9720708447
+    },
+    {
+        "train_domain":"web",
+        "test_domain":"news",
+        "accuracy":0.93934,
+        "f1":0.8187197418,
+        "precision":0.9561636186,
+        "recall":0.7158235786
+    },
+    {
+        "train_domain":"web",
+        "test_domain":"law",
+        "accuracy":0.848,
+        "f1":0.8512720157,
+        "precision":0.8333333333,
+        "recall":0.87
+    },
+    {
+        "train_domain":"web",
+        "test_domain":"social_media",
+        "accuracy":0.635,
+        "f1":0.5628742515,
+        "precision":0.7014925373,
+        "recall":0.47
+    },
+    {
+        "train_domain":"web",
+        "test_domain":"literature",
+        "accuracy":0.8678707224,
+        "f1":0.1146496815,
+        "precision":0.4821428571,
+        "recall":0.065060241
+    },
+    {
+        "train_domain":"web",
+        "test_domain":"web",
+        "accuracy":0.9877030686,
+        "f1":0.9915862601,
+        "precision":0.9913566908,
+        "recall":0.9918159358
+    },
+    {
+        "train_domain": "dslcc",
+        "test_domain": "dslcc",
+        "accuracy": 0.962,
+        "f1": 0.962962962962963,
+        "precision": 0.9391634980988594,
+        "recall": 0.988
+    }
+]

results/n_grams/ensemble/n_gram_ensemble.json

@@ -0,0 +1,58 @@
+[
+    {
+        "domain": "politics",
+        "strategy": "majority_voting",
+        "f1": 0.7564366632,
+        "precision": 0.6082815735,
+        "recall": 1.0,
+        "accuracy": 0.7233109096
+    },
+    {
+        "domain": "news",
+        "strategy": "majority_voting",
+        "f1": 0.356506143,
+        "precision": 0.2170128905,
+        "recall": 0.9980236038,
+        "accuracy": 0.3097422841
+    },
+    {
+        "domain": "law",
+        "strategy": "majority_voting",
+        "f1": 0.6983002833,
+        "precision": 0.5405701754,
+        "recall": 0.986,
+        "accuracy": 0.574
+    },
+    {
+        "domain": "social_media",
+        "strategy": "majority_voting",
+        "f1": 0.6674082314,
+        "precision": 0.5008347245,
+        "recall": 1.0,
+        "accuracy": 0.5016666667
+    },
+    {
+        "domain": "literature",
+        "strategy": "majority_voting",
+        "f1": 0.2360283688,
+        "precision": 0.133805082,
+        "recall": 1.0,
+        "accuracy": 0.1473800855
+    },
+    {
+        "domain": "web",
+        "strategy": "majority_voting",
+        "f1": 0.8529256721,
+        "precision": 0.7440790986,
+        "recall": 0.9990737882,
+        "accuracy": 0.7482517483
+    },
+    {
+        "domain": "dslcc",
+        "strategy": "majority_voting",
+        "accuracy": 0.5605,
+        "f1": 0.6936214708957825,
+        "precision": 0.5323702514713751,
+        "recall": 0.995
+    }
+]

results/n_grams/isolated/models/law.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd1926e566a8840d9656aadf955343fdf8a8841c3bc251058e37baf3e726b986
+size 3870287

results/n_grams/isolated/models/literature.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7fa782a2211bbbb110fa891014747cbcc1d08347562d12538a57eefef353942e
+size 3643250

results/n_grams/isolated/models/news.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f9f1276713546b4ad7e866caf06ff6f8139f273b10353a6daf234197786e28c
+size 11673593

results/n_grams/isolated/models/politics.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:92d473047d3737c5670d96c1c54cd7bff379fb25b827bd122cc7b454450df3a0
+size 6181398

results/n_grams/isolated/models/social_media.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3db018d5788a331601603653bbbf660a36849033d73f2db133f26695db5fe772
+size 4416756

results/n_grams/isolated/models/web.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ee28487012dbe05c85bf7ec19cf406f2cef194b654c8057207e08bca2af26f38
+size 8580899

results/n_grams/isolated/out/n_gram_isolated.json

@@ -0,0 +1,299 @@
+[
+    {
+        "train_domain": "politics",
+        "test_domain": "politics",
+        "accuracy": 0.9874232232,
+        "f1": 0.985565626,
+        "precision": 0.9721854305,
+        "recall": 0.9993192648
+    },
+    {
+        "train_domain": "politics",
+        "test_domain": "news",
+        "accuracy": 0.3608,
+        "f1": 0.3550730487,
+        "precision": 0.2192156276,
+        "recall": 0.9337720229
+    },
+    {
+        "train_domain": "politics",
+        "test_domain": "law",
+        "accuracy": 0.519,
+        "f1": 0.5842696629,
+        "precision": 0.5144596651,
+        "recall": 0.676
+    },
+    {
+        "train_domain": "politics",
+        "test_domain": "social_media",
+        "accuracy": 0.53,
+        "f1": 0.6766055046,
+        "precision": 0.5157342657,
+        "recall": 0.9833333333
+    },
+    {
+        "train_domain": "politics",
+        "test_domain": "literature",
+        "accuracy": 0.175716321,
+        "f1": 0.2392987582,
+        "precision": 0.1362048894,
+        "recall": 0.984375
+    },
+    {
+        "train_domain": "politics",
+        "test_domain": "web",
+        "accuracy": 0.6861042184,
+        "f1": 0.7966683714,
+        "precision": 0.7562768761,
+        "recall": 0.8416177833
+    },
+    {
+        "train_domain": "news",
+        "test_domain": "politics",
+        "accuracy": 0.831529687,
+        "f1": 0.8360842345,
+        "precision": 0.7183374083,
+        "recall": 1.0
+    },
+    {
+        "train_domain": "news",
+        "test_domain": "news",
+        "accuracy": 0.98862,
+        "f1": 0.9705196622,
+        "precision": 0.9575708005,
+        "recall": 0.9838235294
+    },
+    {
+        "train_domain": "news",
+        "test_domain": "law",
+        "accuracy": 0.325,
+        "f1": 0.2734122713,
+        "precision": 0.296037296,
+        "recall": 0.254
+    },
+    {
+        "train_domain": "news",
+        "test_domain": "social_media",
+        "accuracy": 0.5566666667,
+        "f1": 0.6366120219,
+        "precision": 0.5393518519,
+        "recall": 0.7766666667
+    },
+    {
+        "train_domain": "news",
+        "test_domain": "literature",
+        "accuracy": 0.3902168751,
+        "f1": 0.2372277228,
+        "precision": 0.1420104315,
+        "recall": 0.7199519231
+    },
+    {
+        "train_domain": "news",
+        "test_domain": "web",
+        "accuracy": 0.7957365215,
+        "f1": 0.8756437547,
+        "precision": 0.7886209029,
+        "recall": 0.9842543995
+    },
+    {
+        "train_domain": "law",
+        "test_domain": "politics",
+        "accuracy": 0.4474992688,
+        "f1": 0.077186126,
+        "precision": 0.1366782007,
+        "recall": 0.0537780803
+    },
+    {
+        "train_domain": "law",
+        "test_domain": "news",
+        "accuracy": 0.66152,
+        "f1": 0.2485569665,
+        "precision": 0.2167583056,
+        "recall": 0.2912894162
+    },
+    {
+        "train_domain": "law",
+        "test_domain": "law",
+        "accuracy": 0.944,
+        "f1": 0.94092827,
+        "precision": 0.9955357143,
+        "recall": 0.892
+    },
+    {
+        "train_domain": "law",
+        "test_domain": "social_media",
+        "accuracy": 0.5366666667,
+        "f1": 0.3015075377,
+        "precision": 0.612244898,
+        "recall": 0.2
+    },
+    {
+        "train_domain": "law",
+        "test_domain": "literature",
+        "accuracy": 0.8163685294,
+        "f1": 0.161849711,
+        "precision": 0.2028985507,
+        "recall": 0.1346153846
+    },
+    {
+        "train_domain": "law",
+        "test_domain": "web",
+        "accuracy": 0.466839612,
+        "f1": 0.4695320391,
+        "precision": 0.8598438142,
+        "recall": 0.3229391788
+    },
+    {
+        "train_domain": "social_media",
+        "test_domain": "politics",
+        "accuracy": 0.9128400117,
+        "f1": 0.8960223308,
+        "precision": 0.9191123837,
+        "recall": 0.8740639891
+    },
+    {
+        "train_domain": "social_media",
+        "test_domain": "news",
+        "accuracy": 0.79194,
+        "f1": 0.3744813902,
+        "precision": 0.4545985401,
+        "recall": 0.3183723546
+    },
+    {
+        "train_domain": "social_media",
+        "test_domain": "law",
+        "accuracy": 0.657,
+        "f1": 0.5619412516,
+        "precision": 0.777385159,
+        "recall": 0.44
+    },
+    {
+        "train_domain": "social_media",
+        "test_domain": "social_media",
+        "accuracy": 0.95,
+        "f1": 0.9503311258,
+        "precision": 0.9440789474,
+        "recall": 0.9566666667
+    },
+    {
+        "train_domain": "social_media",
+        "test_domain": "literature",
+        "accuracy": 0.7101472218,
+        "f1": 0.249897583,
+        "precision": 0.1895587321,
+        "recall": 0.3665865385
+    },
+    {
+        "train_domain": "social_media",
+        "test_domain": "web",
+        "accuracy": 0.3842770133,
+        "f1": 0.2850032744,
+        "precision": 0.9403630078,
+        "recall": 0.1679530719
+    },
+    {
+        "train_domain": "literature",
+        "test_domain": "politics",
+        "accuracy": 0.5691722726,
+        "f1": 0.0133958473,
+        "precision": 0.4166666667,
+        "recall": 0.0068073519
+    },
+    {
+        "train_domain": "literature",
+        "test_domain": "news",
+        "accuracy": 0.80216,
+        "f1": 0.1064137308,
+        "precision": 0.4006802721,
+        "recall": 0.0613541667
+    },
+    {
+        "train_domain": "literature",
+        "test_domain": "law",
+        "accuracy": 0.542,
+        "f1": 0.1821428571,
+        "precision": 0.85,
+        "recall": 0.102
+    },
+    {
+        "train_domain": "literature",
+        "test_domain": "social_media",
+        "accuracy": 0.465,
+        "f1": 0.3977485929,
+        "precision": 0.4549356223,
+        "recall": 0.3533333333
+    },
+    {
+        "train_domain": "literature",
+        "test_domain": "literature",
+        "accuracy": 0.9086591737,
+        "f1": 0.7235265932,
+        "precision": 0.6015936255,
+        "recall": 0.9074519231
+    },
+    {
+        "train_domain": "literature",
+        "test_domain": "web",
+        "accuracy": 0.2752086623,
+        "f1": 0.0365817091,
+        "precision": 0.6354166667,
+        "recall": 0.0188329731
+    },
+    {
+        "train_domain": "web",
+        "test_domain": "politics",
+        "accuracy": 0.6715413864,
+        "f1": 0.5491770373,
+        "precision": 0.6692759295,
+        "recall": 0.4656228727
+    },
+    {
+        "train_domain": "web",
+        "test_domain": "news",
+        "accuracy": 0.89038,
+        "f1": 0.653605511,
+        "precision": 0.8251156853,
+        "recall": 0.5411259941
+    },
+    {
+        "train_domain": "web",
+        "test_domain": "law",
+        "accuracy": 0.694,
+        "f1": 0.6408450704,
+        "precision": 0.7755681818,
+        "recall": 0.546
+    },
+    {
+        "train_domain": "web",
+        "test_domain": "social_media",
+        "accuracy": 0.525,
+        "f1": 0.2784810127,
+        "precision": 0.5789473684,
+        "recall": 0.1833333333
+    },
+    {
+        "train_domain": "web",
+        "test_domain": "literature",
+        "accuracy": 0.8576856103,
+        "f1": 0.0343716434,
+        "precision": 0.1616161616,
+        "recall": 0.0192307692
+    },
+    {
+        "train_domain": "web",
+        "test_domain": "web",
+        "accuracy": 0.8958944282,
+        "f1": 0.9253417455,
+        "precision": 0.9719626168,
+        "recall": 0.8829885767
+    },
+    {
+        "train_domain": "dslcc",
+        "test_domain": "dslcc",
+        "accuracy": 0.9225,
+        "f1": 0.9233811171527434,
+        "precision": 0.9130009775171065,
+        "recall": 0.934,
+        "analyzer": "word"
+    }
+]