init

experiments/analysis_prediction.py

@@ -0,0 +1,129 @@
+import os
+import json
+
+import pandas as pd
+from datasets import load_dataset
+
+root_dir = "experiments/prediction_files"
+id_to_label = {
+    '0': 'arts_&_culture',
+    '1': 'business_&_entrepreneurs',
+    '2': 'celebrity_&_pop_culture',
+    '3': 'diaries_&_daily_life',
+    '4': 'family',
+    '5': 'fashion_&_style',
+    '6': 'film_tv_&_video',
+    '7': 'fitness_&_health',
+    '8': 'food_&_dining',
+    '9': 'gaming',
+    '10': 'learning_&_educational',
+    '11': 'music',
+    '12': 'news_&_social_concern',
+    '13': 'other_hobbies',
+    '14': 'relationships',
+    '15': 'science_&_technology',
+    '16': 'sports',
+    '17': 'travel_&_adventure',
+    '18': 'youth_&_student_life'
+}
+tasks = ["nerd", "sentiment", "topic"]
+splits = ["test_1", "test_2", "test_3", "test_4"]
+model_list = [
+    "roberta-base",
+    "bertweet-base",
+    "bernice",
+    "roberta-large",
+    "bertweet-large",
+    "twitter-roberta-base-2019-90m",
+    "twitter-roberta-base-dec2020",
+    "twitter-roberta-base-2021-124m",
+    "twitter-roberta-base-2022-154m",
+    "twitter-roberta-large-2022-154m"
+]
+references = {}
+
+for task in tasks:
+    references[task] = {}
+    for s in splits:
+        data = load_dataset("tweettemposhift/tweet_temporal_shift", f"{task}_temporal", split=s)
+        if task in ["nerd", "sentiment"]:
+            references[task][s] = [str(i) for i in data['gold_label_binary']]
+        else:
+            references[task][s] = [{id_to_label[str(n)] for n, k in enumerate(i) if k == 1} for i in data['gold_label_list']]
+
+os.makedirs("experiments/analysis", exist_ok=True)
+
+output = {}
+for model_m in model_list:
+    flags = []
+    for s in splits:
+        with open(f"{root_dir}/topic-topic_temporal-{model_m}/{s}.jsonl") as f:
+            pred = [set(json.loads(i)["label"]) for i in f.read().split('\n') if len(i)]
+            flags += [a == b for a, b in zip(references["topic"][s], pred)]
+    count = {}
+    for seed_s in range(3):
+        flags_rand = []
+        for random_r in range(4):
+            with open(f"{root_dir}/topic-topic_random{random_r}_seed{seed_s}-{model_m}/test_{random_r + 1}.jsonl") as f:
+                pred = [set(json.loads(i)["label"]) for i in f.read().split('\n') if len(i)]
+                flags_rand += [a == b for a, b in zip(references["topic"][f"test_{random_r + 1}"], pred)]
+        count[f"{model_m}_{seed_s}"] = [not x and y for x, y in zip(flags, flags_rand)]
+    output[model_m] = pd.DataFrame(count).sum(1)
+
+df_main = []
+for s in splits:
+    df_main.append(load_dataset("tweettemposhift/tweet_temporal_shift", "topic_temporal", split=s).to_pandas())
+df_main = pd.concat(df_main)
+df_main["error_count"] = pd.DataFrame(output).sum(1).values
+df_main["gold_label_list"] = [", ".join([id_to_label[str(n)] for n, k in enumerate(i) if k == 1]) for i in df_main['gold_label_list']]
+df_main.sort_values("error_count", ascending=False).to_csv("experiments/analysis/topic.csv")
+
+
+output = {}
+for model_m in model_list:
+    flags = []
+    for s in splits:
+        with open(f"{root_dir}/nerd-nerd_temporal-{model_m}/{s}.jsonl") as f:
+            pred = [json.loads(i)["label"] for i in f.read().split('\n') if len(i)]
+            flags += [a == b for a, b in zip(references["nerd"][s], pred)]
+    count = {}
+    for seed_s in range(3):
+        flags_rand = []
+        for random_r in range(4):
+            with open(f"{root_dir}/nerd-nerd_random{random_r}_seed{seed_s}-{model_m}/test_{random_r + 1}.jsonl") as f:
+                pred = [json.loads(i)["label"] for i in f.read().split('\n') if len(i)]
+                flags_rand += [a == b for a, b in zip(references["nerd"][f"test_{random_r + 1}"], pred)]
+        count[f"{model_m}_{seed_s}"] = [not x and y for x, y in zip(flags, flags_rand)]
+    output[model_m] = pd.DataFrame(count).sum(1)
+
+df_main = []
+for s in splits:
+    df_main.append(load_dataset("tweettemposhift/tweet_temporal_shift", "nerd_temporal", split=s).to_pandas())
+df_main = pd.concat(df_main)
+df_main["error_count"] = pd.DataFrame(output).sum(1).values
+df_main.sort_values("error_count", ascending=False).to_csv("experiments/analysis/nerd.csv")
+
+
+output = {}
+for model_m in model_list:
+    flags = []
+    for s in splits:
+        with open(f"{root_dir}/sentiment-sentiment_small_temporal-{model_m}/{s}.jsonl") as f:
+            pred = [json.loads(i)["label"] for i in f.read().split('\n') if len(i)]
+            flags += [a == b for a, b in zip(references["sentiment"][s], pred)]
+    count = {}
+    for seed_s in range(3):
+        flags_rand = []
+        for random_r in range(4):
+            with open(f"{root_dir}/sentiment-sentiment_small_random{random_r}_seed{seed_s}-{model_m}/test_{random_r + 1}.jsonl") as f:
+                pred = [json.loads(i)["label"] for i in f.read().split('\n') if len(i)]
+                flags_rand += [a == b for a, b in zip(references["sentiment"][f"test_{random_r + 1}"], pred)]
+        count[f"{model_m}_{seed_s}"] = [not x and y for x, y in zip(flags, flags_rand)]
+    output[model_m] = pd.DataFrame(count).sum(1)
+
+df_main = []
+for s in splits:
+    df_main.append(load_dataset("tweettemposhift/tweet_temporal_shift", "sentiment_small_temporal", split=s).to_pandas())
+df_main = pd.concat(df_main)
+df_main["error_count"] = pd.DataFrame(output).sum(1).values
+df_main.sort_values("error_count", ascending=False).to_csv("experiments/analysis/sentiment.csv")

experiments/model_predict_classifier.py

@@ -113,6 +113,8 @@ class TopicClassification(Classifier):
     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"]:
+            if os.path.exists(f"{export_dir}/{test_split}.jsonl"):
+                continue
             data = self.dataset[test_split]
             predictions = self.predict(data["text"], batch_size)
             with open(f"{export_dir}/{test_split}.jsonl", "w") as f:
@@ -130,6 +132,8 @@ class SentimentClassification(Classifier):
     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"]:
+            if os.path.exists(f"{export_dir}/{test_split}.jsonl"):
+                continue
             data = self.dataset[test_split]
             predictions = self.predict(data["text"], batch_size)
             with open(f"{export_dir}/{test_split}.jsonl", "w") as f:
@@ -147,6 +151,8 @@ class NERDClassification(Classifier):
     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"]:
+            if os.path.exists(f"{export_dir}/{test_split}.jsonl"):
+                continue
             data = self.dataset[test_split]
             text = [
                 f"{d['target']} {self.tokenizer.sep_token} {d['definition']} {self.tokenizer.sep_token} {d['text']}"

experiments/model_predict_ner.py

@@ -1,109 +1,110 @@
-import re
-import os
-import torch
-import json
-from typing import Dict, List
-from transformers import AutoTokenizer, AutoModelForTokenClassification, AutoConfig
-from datasets import load_dataset
-
-URL_RE = re.compile(r"https?:\/\/[\w\.\/\?\=\d&#%_:/-]+")
-HANDLE_RE = re.compile(r"@\w+")
-
-
-def preprocess_bernice(text):
-    text = HANDLE_RE.sub("@USER", text)
-    text = URL_RE.sub("HTTPURL", text)
-    return text
-
-
-def preprocess_timelm(text):
-    text = HANDLE_RE.sub("@user", text)
-    text = URL_RE.sub("http", text)
-    return text
-
-
-def preprocess(model_name, text):
-    if model_name == "jhu-clsp/bernice":
-        return preprocess_bernice(text)
-    if "twitter-roberta-base" in model_name:
-        return preprocess_timelm(text)
-    return text
-
-
-class NER:
-
-    def __init__(self, model_name: str, max_length: int, id_to_label: Dict[str, 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
-        # 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')
-        elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available() and torch.backends.mps.is_built():
-            self.device = torch.device("mps")
-        else:
-            self.device = torch.device('cpu')
-        self.parallel = torch.cuda.device_count() > 1
-        if self.parallel:
-            self.model = torch.nn.DataParallel(self.model)
-        self.model.to(self.device)
-        self.model.eval()
-        self.dataset = load_dataset("tweettemposhift/tweet_temporal_shift", "ner_temporal")
-
-    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.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 = []
-        preds = []
-        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()
-                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)]
-
-
-if __name__ == '__main__':
-    model_list = [
-        "roberta-base",
-        "bertweet-base",
-        "bernice",
-        "roberta-large",
-        "bertweet-large",
-        "twitter-roberta-base-2019-90m",
-        "twitter-roberta-base-dec2020",
-        "twitter-roberta-base-2021-124m",
-        "twitter-roberta-base-2022-154m",
-        "twitter-roberta-large-2022-154m"
-    ]
-    for model_m in model_list:
-        alias = f"tweettemposhift/ner-ner_temporal-{model_m}"
-        NER(alias).get_prediction(export_dir=f"prediction_files/{os.path.basename(alias)}", batch_size=32)
-        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)
+# #WIP
+# import re
+# import os
+# import torch
+# import json
+# from typing import Dict, List
+# from transformers import AutoTokenizer, AutoModelForTokenClassification, AutoConfig
+# from datasets import load_dataset
+#
+# URL_RE = re.compile(r"https?:\/\/[\w\.\/\?\=\d&#%_:/-]+")
+# HANDLE_RE = re.compile(r"@\w+")
+#
+#
+# def preprocess_bernice(text):
+#     text = HANDLE_RE.sub("@USER", text)
+#     text = URL_RE.sub("HTTPURL", text)
+#     return text
+#
+#
+# def preprocess_timelm(text):
+#     text = HANDLE_RE.sub("@user", text)
+#     text = URL_RE.sub("http", text)
+#     return text
+#
+#
+# def preprocess(model_name, text):
+#     if model_name == "jhu-clsp/bernice":
+#         return preprocess_bernice(text)
+#     if "twitter-roberta-base" in model_name:
+#         return preprocess_timelm(text)
+#     return text
+#
+#
+# class NER:
+#
+#     def __init__(self, model_name: str, max_length: int, id_to_label: Dict[str, 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
+#         # 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')
+#         elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available() and torch.backends.mps.is_built():
+#             self.device = torch.device("mps")
+#         else:
+#             self.device = torch.device('cpu')
+#         self.parallel = torch.cuda.device_count() > 1
+#         if self.parallel:
+#             self.model = torch.nn.DataParallel(self.model)
+#         self.model.to(self.device)
+#         self.model.eval()
+#         self.dataset = load_dataset("tweettemposhift/tweet_temporal_shift", "ner_temporal")
+#
+#     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.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 = []
+#         preds = []
+#         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()
+#                 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)]
+#
+#
+# if __name__ == '__main__':
+#     model_list = [
+#         "roberta-base",
+#         "bertweet-base",
+#         "bernice",
+#         "roberta-large",
+#         "bertweet-large",
+#         "twitter-roberta-base-2019-90m",
+#         "twitter-roberta-base-dec2020",
+#         "twitter-roberta-base-2021-124m",
+#         "twitter-roberta-base-2022-154m",
+#         "twitter-roberta-large-2022-154m"
+#     ]
+#     for model_m in model_list:
+#         alias = f"tweettemposhift/ner-ner_temporal-{model_m}"
+#         NER(alias).get_prediction(export_dir=f"prediction_files/{os.path.basename(alias)}", batch_size=32)
+#         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)

experiments/prediction.py

@@ -1,13 +0,0 @@
-from transformers import pipeline
-
-pipe = pipeline(model="tweettemposhift/nerd-nerd_random1_seed2-twitter-roberta-base-2019-90m")
-out = pipe("This restaurant is awesome")
-
-pipe = pipeline(model="tweettemposhift/sentiment-sentiment_small_random3_seed2-twitter-roberta-base-dec2020")
-pipe("This restaurant is awesome")
-
-pipe = pipeline(model="tweettemposhift/topic-topic_random3_seed2-twitter-roberta-base-dec2020")
-pipe("This restaurant is awesome")
-
-pipe = pipeline(model="tweettemposhift/ner-ner_random1_seed2-twitter-roberta-base-2019-90m")
-pipe("This restaurant is awesome")