init

experiments/huggingface_ops.py

@@ -0,0 +1,9 @@
+from huggingface_hub import HfApi, ModelFilter
+from pprint import pprint
+
+api = HfApi()
+models = api.list_models(filter=ModelFilter(author='tweettemposhift'))
+models_filtered = [i.modelId for i in models if 'topic-' in i.modelId]
+
+pprint(sorted([i for i in models_filtered if i.endswith('twitter-roberta-base-2019-90m')]))
+pprint(sorted([i for i in models_filtered if i.endswith('twitter-roberta-base-dec2020')]))

experiments/main.sh

@@ -1,22 +1,21 @@
 # MAIN EXPERIMENT
 MODEL="roberta-base"
 MODEL="vinai/bertweet-base"
-MODEL="cardiffnlp/twitter-roberta-base-2022-154m"
 MODEL="jhu-clsp/bernice"
-MODEL="cardiffnlp/twitter-roberta-base-2021-124m"
 MODEL="roberta-large"
-
-# topic, ner, nerd[hk], sentiment[ukri]
 MODEL="vinai/bertweet-large"
-# topic, ner, nerd[hk], sentiment[ukri]
+MODEL="cardiffnlp/twitter-roberta-base-2019-90m"
+MODEL="cardiffnlp/twitter-roberta-base-dec2020"
+MODEL="cardiffnlp/twitter-roberta-base-2021-124m"
+MODEL="cardiffnlp/twitter-roberta-base-2022-154m"
 MODEL="cardiffnlp/twitter-roberta-large-2022-154m"
 
 # ABLATION (TimeLMs)
 ## Topic & NER
-MODEL="twitter-roberta-base-jun2020"
-MODEL="twitter-roberta-base-sep2021"
+MODEL="cardiffnlp/twitter-roberta-base-jun2020"
+MODEL="cardiffnlp/twitter-roberta-base-sep2021"
 ## NERD
-MODEL="twitter-roberta-base-jun2021"
+MODEL="cardiffnlp/twitter-roberta-base-jun2021"
 
 # SENTIMENT
 python model_finetuning_sentiment.py -m "${MODEL}" -d "sentiment_small_temporal"

experiments/model_predict_classifier.py

@@ -0,0 +1,201 @@
+""" Simple interface for CardiffNLP twitter models. """
+import os
+import torch
+import re
+import json
+from typing import List, Dict
+
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, 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 Classifier:
+
+    def __init__(self,
+                 model_name: str,
+                 max_length: int,
+                 multi_label: bool,
+                 id_to_label: Dict[str, str]):
+
+        self.model_name = model_name
+        self.config = AutoConfig.from_pretrained(self.model_name)
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+        self.model = AutoModelForSequenceClassification.from_pretrained(self.model_name, config=self.config)
+        self.max_length = max_length
+        self.multi_label = multi_label
+        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()
+
+    def predict(self, text: List[str], batch_size: int):
+        text = [preprocess(self.model_name, t) for t in text]
+        indices = list(range(0, len(text), batch_size)) + [len(text) + 1]
+        probs = []
+        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)
+                output = self.model(**{k: v.to(self.device) for k, v in encoded_input.items()})
+                if self.multi_label:
+                    probs += torch.sigmoid(output.logits).cpu().tolist()
+                else:
+                    probs += torch.softmax(output.logits, -1).cpu().tolist()
+        if self.multi_label:
+            return [{"label": [self.id_to_label[str(n)] for n, p in enumerate(_pr) if p > 0.5]} for _pr in probs]
+        return [{"label": self.id_to_label[str(p.index(max(p)))]} for p in probs]
+
+
+class TopicClassification(Classifier):
+
+    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'
+    }
+
+    def __init__(self, model_name: str):
+        super().__init__(model_name, max_length=128, multi_label=True, id_to_label=self.id_to_label)
+        self.dataset = load_dataset("tweettemposhift/tweet_temporal_shift", "topic_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]))
+
+
+class SentimentClassification(Classifier):
+
+    id_to_label = {'0': '0', '1': '1'}
+
+    def __init__(self, model_name: str):
+        super().__init__(model_name, max_length=128, multi_label=False, id_to_label=self.id_to_label)
+        self.dataset = load_dataset("tweettemposhift/tweet_temporal_shift", "sentiment_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]))
+
+
+class NERDClassification(Classifier):
+
+    id_to_label = {'0': '0', '1': '1'}
+
+    def __init__(self, model_name: str):
+        super().__init__(model_name, max_length=128, multi_label=False, id_to_label=self.id_to_label)
+        self.dataset = load_dataset("tweettemposhift/tweet_temporal_shift", "nerd_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]
+            text = [
+                f"{d['target']} {self.tokenizer.sep_token} {d['definition']} {self.tokenizer.sep_token} {d['text']}"
+                for d in data
+            ]
+            predictions = self.predict(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]))
+
+
+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/topic-topic_temporal-{model_m}"
+        TopicClassification(alias).get_prediction(export_dir=f"prediction_files/{os.path.basename(alias)}", batch_size=512)
+        torch.cuda.empty_cache()
+        for random_r in range(4):
+            for seed_s in range(3):
+                alias = f"tweettemposhift/topic-topic_random{random_r}_seed{seed_s}-{model_m}"
+                TopicClassification(alias).get_prediction(export_dir=f"prediction_files/{os.path.basename(alias)}", batch_size=512)
+                torch.cuda.empty_cache()
+
+    for model_m in model_list:
+        alias = f"tweettemposhift/sentiment-sentiment_small_temporal-{model_m}"
+        SentimentClassification(alias).get_prediction(export_dir=f"prediction_files/{os.path.basename(alias)}", batch_size=512)
+        torch.cuda.empty_cache()
+        for random_r in range(4):
+            for seed_s in range(3):
+                alias = f"tweettemposhift/sentiment-sentiment_small_random{random_r}_seed{seed_s}-{model_m}"
+                SentimentClassification(alias).get_prediction(export_dir=f"prediction_files/{os.path.basename(alias)}", batch_size=512)
+                torch.cuda.empty_cache()
+
+    for model_m in model_list:
+        alias = f"tweettemposhift/nerd-nerd_temporal-{model_m}"
+        NERDClassification(alias).get_prediction(export_dir=f"prediction_files/{os.path.basename(alias)}", batch_size=512)
+        torch.cuda.empty_cache()
+        for random_r in range(4):
+            for seed_s in range(3):
+                alias = f"tweettemposhift/nerd-nerd_random{random_r}_seed{seed_s}-{model_m}"
+                NERDClassification(alias).get_prediction(export_dir=f"prediction_files/{os.path.basename(alias)}", batch_size=512)
+                torch.cuda.empty_cache()

experiments/model_predict_ner.py

@@ -0,0 +1,109 @@
+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

@@ -0,0 +1,13 @@
+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")