init

experiments/model_finetuning_topic.py

@@ -0,0 +1,194 @@
+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
+from datasets import load_dataset, load_metric
+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")
+
+LABEL2ID = {
+    "arts_&_culture": 0,
+    "business_&_entrepreneurs": 1,
+    "celebrity_&_pop_culture": 2,
+    "diaries_&_daily_life": 3,
+    "family": 4,
+    "fashion_&_style": 5,
+    "film_tv_&_video": 6,
+    "fitness_&_health": 7,
+    "food_&_dining": 8,
+    "gaming": 9,
+    "learning_&_educational": 10,
+    "music": 11,
+    "news_&_social_concern": 12,
+    "other_hobbies": 13,
+    "relationships": 14,
+    "science_&_technology": 15,
+    "sports": 16,
+    "travel_&_adventure": 17,
+    "youth_&_student_life": 18
+}
+ID2LABEL = {v: k for k, v in LABEL2ID.items()}
+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 = "topic_temporal",
+        model: str = "roberta-base",
+        skip_train: bool = False,
+        skip_test: bool = False,
+        skip_upload: bool = False):
+
+    tokenizer = AutoTokenizer.from_pretrained(model)
+    model = AutoModelForSequenceClassification.from_pretrained(
+        model, id2label=ID2LABEL, label2id=LABEL2ID, num_labels=len(LABEL2ID), problem_type="multi_label_classification"
+    )
+    dataset = load_dataset(dataset, dataset_type)
+    tokenized_datasets = dataset.map(
+        lambda x: tokenizer(x["text"], padding="max_length", truncation=True, max_length=256), batched=True
+    )
+    metric_accuracy = load_metric("accuracy", "multilabel")
+    metric_f1 = load_metric("f1", "multilabel")
+
+    def compute_metric_search(eval_pred):
+        logits, labels = eval_pred
+        predictions = np.array([[int(sigmoid(j) > 0.5) for j in i] for i in logits])
+        return metric_f1.compute(predictions=predictions, references=labels, average="micro")
+
+    def compute_metric_all(eval_pred):
+        logits, labels = eval_pred
+        predictions = np.array([[int(sigmoid(j) > 0.5) for j in i] for i in logits])
+        return {
+            "f1": metric_f1.compute(predictions=predictions, references=labels, average="micro")["f1"],
+            "f1_macro": metric_f1.compute(predictions=predictions, references=labels, average="macro")["f1"],
+            "accuracy": metric_accuracy.compute(predictions=predictions, references=labels)["accuracy"]
+        }
+
+    model_alias = f"topic_{dataset_type}_{os.path.basename(model)}"
+    output_dir = f"ckpt/{model_alias}"
+    best_model_path = pj(output_dir, "best_model")
+
+    if not skip_train:
+        logging.info("training model")
+        trainer = Trainer(
+            model=model,
+            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=len(LABEL2ID),
+                id2label=ID2LABEL,
+                label2id=LABEL2ID
+            )
+        )
+
+        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]
+                ),
+            },
+            local_dir="./hyperparameter_search_cache",
+            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:
+            model = AutoModelForSequenceClassification.from_pretrained(
+                best_model_path,
+                num_labels=len(LABEL2ID),
+                problem_type="multi_label_classification",
+                id2label=ID2LABEL,
+                label2id=LABEL2ID
+            )
+            trainer = Trainer(
+                model=model,
+                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 = AutoModelForSequenceClassification.from_pretrained(
+            best_model_path,
+            num_labels=len(LABEL2ID),
+            problem_type="multi_label_classification",
+            id2label=ID2LABEL,
+            label2id=LABEL2ID
+        )
+        tokenizer = AutoTokenizer.from_pretrained(best_model_path)
+        model.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='', default="topic_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,
+    )
+

experiments/requirements.txt

@@ -0,0 +1,4 @@
+numpy
+datasets
+transformers
+huggingface_hub