init

experiments/main.sh

@@ -1,4 +1,6 @@
-MODEL=""
+MODEL="cardiffnlp/twitter-roberta-base"
+MODEL="jhu-clsp/bernice"
+MODEL="vinai/bertweet-base"
 MODEL="roberta-base"
 
 

experiments/model_finetuning_ner.py

@@ -0,0 +1,194 @@
+"""Experiment.
+
+```
+python model_finetuning_ner.py -m "roberta-base" -d "ner_temporal"
+```
+"""
+import argparse
+import json
+import logging
+import math
+import os
+from os.path import join as pj
+from shutil import copyfile
+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")
+EVAL_STEP = 500
+RANDOM_SEED = 42
+N_TRIALS = 10
+
+
+def sigmoid(x):
+    return 1 / (1 + math.exp(-x))
+
+
+def main(
+        dataset: str = "tweettemposhift/tweet_temporal_shift",
+        dataset_type: str = "ner_temporal",
+        model: str = "roberta-base",
+        skip_train: bool = False,
+        skip_test: bool = False,
+        skip_upload: bool = False):
+
+    model_alias = f"ner-{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, add_prefix_space=True)
+
+    def align_labels_with_tokens(labels, word_ids):
+        new_labels = []
+        current_word = None
+        for word_id in word_ids:
+            if word_id != current_word:
+                # Start of a new word!
+                current_word = word_id
+                label = -100 if word_id is None else labels[word_id]
+                new_labels.append(label)
+            elif word_id is None:
+                # Special token
+                new_labels.append(-100)
+            else:
+                # Same word as previous token
+                label = labels[word_id]
+                # If the label is B-XXX we change it to I-XXX
+                if label % 2 == 1:
+                    label += 1
+                new_labels.append(label)
+
+        return new_labels
+
+    def tokenize_and_align_labels(examples):
+        tokenized_inputs = tokenizer(
+            examples["tokens"], truncation=True, is_split_into_words=True, padding="max_length", max_length=256
+        )
+        all_labels = examples["ner_tags"]
+        new_labels = []
+        for ind, labels in enumerate(all_labels):
+            word_ids = tokenized_inputs.word_ids(ind)
+            new_labels.append(align_labels_with_tokens(labels, word_ids))
+
+        tokenized_inputs["labels"] = new_labels
+        return tokenized_inputs
+
+    dataset = load_dataset(dataset, dataset_type)
+    tokenized_datasets = dataset.map(
+        lambda x: tokenize_and_align_labels(x),
+        batched=True
+    )
+
+    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(output_dir, "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)
+        tokenizer = AutoTokenizer.from_pretrained(best_model_path)
+        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()
+
+
+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="ner_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,
+    )
+