init

experiments/model_finetuning_hate.py

@@ -0,0 +1,187 @@
+"""Experiment.
+
+```
+python model_finetuning_hate.py -m "roberta-base" -d "hate_temporal"
+```
+"""
+import argparse
+import json
+import logging
+import math
+import os
+import re
+from os.path import join as pj
+from shutil import copyfile, rmtree
+from glob import glob
+
+import numpy as np
+import evaluate
+from datasets import load_dataset
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, TrainingArguments, Trainer
+from huggingface_hub import Repository
+
+logging.basicConfig(format="%(asctime)s %(levelname)-8s %(message)s", level=logging.INFO, datefmt="%Y-%m-%d %H:%M:%S")
+os.environ["WANDB_DISABLED"] = "true"
+
+EVAL_STEP = 500
+RANDOM_SEED = 42
+N_TRIALS = 10
+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
+
+
+def sigmoid(x):
+    return 1 / (1 + math.exp(-x))
+
+
+def main(
+        dataset: str = "tweettemposhift/tweet_temporal_shift",
+        dataset_type: str = "hate_temporal",
+        model: str = "roberta-base",
+        skip_train: bool = False,
+        skip_test: bool = False,
+        skip_upload: bool = False):
+
+    model_alias = f"hate-{dataset_type}-{os.path.basename(model)}"
+    output_dir = f"ckpt/{model_alias}"
+    best_model_path = pj(output_dir, "best_model")
+
+    tokenizer = AutoTokenizer.from_pretrained(model)
+    dataset = load_dataset(dataset, dataset_type)
+    tokenized_datasets = dataset.map(
+        lambda x: tokenizer(
+            [preprocess(model, t) for t in x["text"]],
+            padding="max_length",
+            truncation=True,
+            max_length=64),
+        batched=True
+    )
+    tokenized_datasets = tokenized_datasets.rename_column("gold_label_binary", "label")
+    metric_accuracy = evaluate.load("accuracy")
+    metric_f1 = evaluate.load("f1")
+
+    def compute_metric_search(eval_pred):
+        logits, labels = eval_pred
+        predictions = np.argmax(logits, axis=-1)
+        return metric_accuracy.compute(predictions=predictions, references=labels)
+
+    def compute_metric_all(eval_pred):
+        logits, labels = eval_pred
+        predictions = np.argmax(logits, axis=-1)
+        return {
+            "f1": metric_f1.compute(predictions=predictions, references=labels)["f1"],
+            "accuracy": metric_accuracy.compute(predictions=predictions, references=labels)["accuracy"]
+        }
+
+    if not skip_train:
+        logging.info("training model")
+        trainer = Trainer(
+            model=AutoModelForSequenceClassification.from_pretrained(model, num_labels=2),
+            args=TrainingArguments(
+                output_dir=output_dir,
+                evaluation_strategy="steps",
+                eval_steps=EVAL_STEP,
+                seed=RANDOM_SEED
+            ),
+            train_dataset=tokenized_datasets["train"],
+            eval_dataset=tokenized_datasets["validation"],
+            compute_metrics=compute_metric_search,
+            model_init=lambda x: AutoModelForSequenceClassification.from_pretrained(
+                model, return_dict=True, num_labels=2,
+            )
+        )
+
+        best_run = trainer.hyperparameter_search(
+            hp_space=lambda trial: {
+                "learning_rate": trial.suggest_float("learning_rate", 1e-6, 1e-4, log=True),
+                "per_device_train_batch_size": trial.suggest_categorical(
+                    "per_device_train_batch_size", [8, 16, 32]
+                ),
+            },
+            direction="maximize",
+            backend="optuna",
+            n_trials=N_TRIALS
+        )
+        for n, v in best_run.hyperparameters.items():
+            setattr(trainer.args, n, v)
+        trainer.train()
+        trainer.save_model(best_model_path)
+
+    if not skip_test:
+        logging.info("testing model")
+        test_split = ["test"]
+        if dataset_type.endswith("temporal"):
+            test_split += ["test_1", "test_2", "test_3", "test_4"]
+        summary_file = pj(best_model_path, "summary.json")
+        if os.path.exists(summary_file):
+            with open(summary_file) as f:
+                metric = json.load(f)
+        else:
+            metric = {}
+        for single_test in test_split:
+            trainer = Trainer(
+                model=AutoModelForSequenceClassification.from_pretrained(best_model_path, num_labels=2),
+                args=TrainingArguments(
+                    output_dir=output_dir,
+                    evaluation_strategy="no",
+                    seed=RANDOM_SEED
+                ),
+                train_dataset=tokenized_datasets["train"],
+                eval_dataset=tokenized_datasets[single_test],
+                compute_metrics=compute_metric_all
+            )
+            metric.update({f"{single_test}/{k}": v for k, v in trainer.evaluate().items()})
+        logging.info(json.dumps(metric, indent=4))
+        with open(summary_file, "w") as f:
+            json.dump(metric, f)
+
+    if not skip_upload:
+        logging.info("uploading to huggingface")
+        model_organization = "tweettemposhift"
+        model_instance = AutoModelForSequenceClassification.from_pretrained(best_model_path, num_labels=2)
+        model_instance.push_to_hub(f"{model_organization}/{model_alias}", use_auth_token=True)
+        tokenizer.push_to_hub(f"{model_organization}/{model_alias}", use_auth_token=True)
+        repo = Repository(model_alias, f"{model_organization}/{model_alias}")
+        for i in glob(f"{best_model_path}/*"):
+            if not os.path.exists(f"{model_alias}/{os.path.basename(i)}"):
+                copyfile(i, f"{model_alias}/{os.path.basename(i)}")
+        repo.push_to_hub()
+        rmtree(model_alias)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Fine-tuning language model.")
+    parser.add_argument("-m", "--model", help="transformer LM", default="roberta-base", type=str)
+    parser.add_argument("-d", "--dataset-type", help='dataset type', default="hate_temporal", type=str)
+    parser.add_argument("--skip-train", action="store_true")
+    parser.add_argument("--skip-test", action="store_true")
+    parser.add_argument("--skip-upload", action="store_true")
+    opt = parser.parse_args()
+    main(
+        dataset_type=opt.dataset_type,
+        model=opt.model,
+        skip_train=opt.skip_train,
+        skip_test=opt.skip_test,
+        skip_upload=opt.skip_upload,
+    )
+

statistics.py

@@ -5,7 +5,7 @@ from transformers import AutoTokenizer
 
 tokenizer = AutoTokenizer.from_pretrained("roberta-base")
 stats = []
-for i in ["hate_temporal", "nerd_temporal", "ner_temporal", "topic_temporal", "sentiment_small_temporal"]:
+for i in ["emoji_temporal", "hate_temporal", "nerd_temporal", "ner_temporal", "topic_temporal", "sentiment_small_temporal"]:
     for s in ["train", "validation", "test"]:
         dataset = load_dataset("tweettemposhift/tweet_temporal_shift", i, split=s)
         df = dataset.to_pandas()
@@ -26,6 +26,7 @@ for i in ["hate_temporal", "nerd_temporal", "ner_temporal", "topic_temporal", "s
 df = pd.DataFrame(stats)
 print(df)
 pretty_name = {
+    "emoji_temporal": "Emoji",
     "hate_temporal": "Hate",
     "nerd_temporal": "NERD",
     "ner_temporal": "NER",