init

experiments/model_predict_ner.py

@@ -2,7 +2,7 @@ import re
 import os
 import torch
 import json
-from typing import Dict, List
+
 from transformers import AutoTokenizer, AutoModelForTokenClassification, AutoConfig
 from datasets import load_dataset
 
@@ -33,13 +33,30 @@ def preprocess(model_name, text):
 
 class NER:
 
-    def __init__(self, model_name: str, max_length: int, id_to_label: Dict[str, str]):
+    id_to_label = {
+        '0': 'B-corporation',
+        '1': 'B-creative_work',
+        '2': 'B-event',
+        '3': 'B-group',
+        '4': 'B-location',
+        '5': 'B-person',
+        '6': 'B-product',
+        '7': 'I-corporation',
+        '8': 'I-creative_work',
+        '9': 'I-event',
+        '10': 'I-group',
+        '11': 'I-location',
+        '12': 'I-person',
+        '13': 'I-product',
+        '14': 'O'
+    }
+
+    def __init__(self, model_name: str):
         self.model_name = model_name
         self.config = AutoConfig.from_pretrained(self.model_name)
         self.model = AutoModelForTokenClassification.from_pretrained(self.model_name, config=self.config)
         self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
-        self.max_length = max_length
-        self.id_to_label = id_to_label
+        self.max_length = 128
         # GPU setup (https://github.com/cardiffnlp/tweetnlp/issues/15)
         if torch.cuda.is_available() and torch.cuda.device_count() > 0:
             self.device = torch.device('cuda')
@@ -53,39 +70,59 @@ class NER:
         self.model.to(self.device)
         self.model.eval()
         self.dataset = load_dataset("tweettemposhift/tweet_temporal_shift", "ner_temporal")
+        self.tokenized_datasets = self.dataset.map(lambda x: self.tokenize_and_align_labels(x), batched=True)
 
     def get_prediction(self, export_dir: str, batch_size: int):
         os.makedirs(export_dir, exist_ok=True)
         for test_split in ["test_1", "test_2", "test_3", "test_4"]:
+            data = self.tokenized_datasets[test_split]
+
+            # TODO: check the data format and fix the predict function accordingly
             data = self.dataset[test_split]
             predictions = self.predict(data["text"], batch_size)
             with open(f"{export_dir}/{test_split}.jsonl", "w") as f:
                 f.write("\n".join([json.dumps(i) for i in predictions]))
 
-        with open(export_dir, "w") as f:
-            predictions = self.predict(self.dataset[], batch_size)
-            for i in :
-                f.write(json.dumps(i) + "\n")
-
-    def predict(self, text: List[str], batch_size: int):
-        text = [[preprocess(self.model_name, t) for t in i] for i in text]
-        indices = list(range(0, len(text), batch_size)) + [len(text) + 1]
-        inputs = []
+    def predict(self, example, batch_size: int):
+        indices = list(range(0, len(example), batch_size)) + [len(example) + 1]
         preds = []
+        labels = []
         with torch.no_grad():
             for i in range(len(indices) - 1):
-                encoded_input = self.tokenizer.batch_encode_plus(
-                    text[indices[i]: indices[i + 1]],
-                    max_length=self.max_length,
-                    return_tensors='pt',
-                    padding=True,
-                    truncation=True)
-                inputs += encoded_input['input_ids'].cpu().detach().int().tolist()
+                encoded_input = example[indices[i]: indices[i + 1]]
+                labels += [
+                    [self.id_to_label[y] if y in self.id_to_label else y for y in x]
+                    for x in encoded_input['labels']
+                ]
                 output = self.model(**{k: v.to(self.device) for k, v in encoded_input.items()})
                 prob = torch.softmax(output['logits'], dim=-1).cpu().detach().float().tolist()
                 pred = torch.max(prob, dim=-1)[1].cpu().detach().int().tolist()
                 preds += [[self.id_to_label[_p] for _p in p] for p in pred]
-        return [{"label": p, "input_id": i} for p, i in zip(preds, inputs)]
+        return [{"prediction": p, "label": i} for p, i in zip(preds, labels)]
+
+    def tokenize_and_align_labels(self, examples):
+        tokens = [[preprocess(self.model_name, w) for w in t] for t in examples["text_tokenized"]]
+        tokenized_inputs = self.tokenizer(
+            tokens,
+            truncation=True,
+            is_split_into_words=True,
+            padding="max_length",
+            max_length=128
+        )
+        all_labels = examples["gold_label_sequence"]
+        new_labels = []
+        for token, label in zip(tokens, all_labels):
+            tmp_labels = [-100]
+            for to, la in zip(token, label):
+                to_tokenized = self.tokenizer.tokenize(to)
+                tmp_labels += [la] * len(to_tokenized)
+            if len(tmp_labels) > 128:
+                tmp_labels = tmp_labels[:128]
+            else:
+                tmp_labels = tmp_labels + [-100] * (128 - len(tmp_labels))
+            new_labels.append(tmp_labels)
+        tokenized_inputs["labels"] = new_labels
+        return tokenized_inputs
 
 
 if __name__ == '__main__':
@@ -107,4 +144,4 @@ if __name__ == '__main__':
         for random_r in range(4):
             for seed_s in range(3):
                 alias = f"tweettemposhift/ner-ner_random{random_r}_seed{seed_s}-{model_m}"
-                TopicClassification(alias).get_prediction(export_dir=f"prediction_files/{os.path.basename(alias)}", batch_size=32)
+                NER(alias).get_prediction(export_dir=f"prediction_files/{os.path.basename(alias)}", batch_size=32)