init

lm_finetuning.py

@@ -0,0 +1,170 @@
+import argparse
+import json
+import logging
+import os
+import shutil
+import urllib.request
+import multiprocessing
+from os.path import join as pj
+
+import torch
+import numpy as np
+from huggingface_hub import create_repo
+from datasets import load_dataset, load_metric
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, TrainingArguments, Trainer
+from ray import tune
+
+logging.basicConfig(format='%(asctime)s %(levelname)-8s %(message)s', level=logging.INFO, datefmt='%Y-%m-%d %H:%M:%S')
+
+PARALLEL = bool(int(os.getenv("PARALLEL", 1)))
+RAY_RESULTS = os.getenv("RAY_RESULTS", "ray_results")
+
+
+def internet_connection(host='http://google.com'):
+    try:
+        urllib.request.urlopen(host)
+        return True
+    except:
+        return False
+
+
+def get_metrics():
+    metric_accuracy = load_metric("accuracy")
+    metric_f1 = load_metric("f1")
+
+    def compute_metric_search(eval_pred):
+        logits, labels = eval_pred
+        predictions = np.argmax(logits, axis=-1)
+        return metric_f1.compute(predictions=predictions, references=labels, average='micro')
+
+    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, average='micro')['f1'],
+            'f1_macro': metric_f1.compute(predictions=predictions, references=labels, average='macro')['f1'],
+            'accuracy': metric_accuracy.compute(predictions=predictions, references=labels)['accuracy']
+        }
+    return compute_metric_search, compute_metric_all
+
+
+def 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', help='', default='cardiffnlp/tweet_topic_single', type=str)
+    parser.add_argument('--dataset-name', help='huggingface dataset name', default='citation_intent', type=str)
+    parser.add_argument('-l', '--seq-length', help='', default=128, type=int)
+    parser.add_argument('--random-seed', help='', default=42, type=int)
+    parser.add_argument('--eval-step', help='', default=50, type=int)
+    parser.add_argument('-o', '--output-dir', help='Directory to output', default='ckpt_tmp', type=str)
+    parser.add_argument('-t', '--n-trials', default=10, type=int)
+    parser.add_argument('--push-to-hub', action='store_true')
+    parser.add_argument('--use-auth-token', action='store_true')
+    parser.add_argument('--hf-organization', default=None, type=str)
+    parser.add_argument('-a', '--model-alias', help='', default=None, type=str)
+    parser.add_argument('--summary-file', default='metric_summary.json', type=str)
+    parser.add_argument('--skip-train', action='store_true')
+    parser.add_argument('--skip-eval', action='store_true')
+    opt = parser.parse_args()
+    assert opt.summary_file.endswith('.json'), f'`--summary-file` should be a json file {opt.summary_file}'
+    # setup data
+    dataset = load_dataset(opt.dataset, opt.dataset_name)
+    network = internet_connection()
+    # setup model
+    tokenizer = AutoTokenizer.from_pretrained(opt.model, local_files_only=not network)
+    model = AutoModelForSequenceClassification.from_pretrained(
+        opt.model, num_labels=dataset['train'].features['label'].num_classes, local_files_only=not network)
+    tokenized_datasets = dataset.map(
+        lambda x: tokenizer(x["text"], padding="max_length", truncation=True, max_length=opt.seq_length),
+        batched=True)
+    # setup metrics
+    compute_metric_search, compute_metric_all = get_metrics()
+
+    if not opt.skip_train:
+        # setup trainer
+        trainer = Trainer(
+            model=model,
+            args=TrainingArguments(
+                output_dir=opt.output_dir,
+                evaluation_strategy="steps",
+                eval_steps=opt.eval_step,
+                seed=opt.random_seed
+            ),
+            train_dataset=tokenized_datasets["train"],
+            eval_dataset=tokenized_datasets["validation"],
+            compute_metrics=compute_metric_search,
+            model_init=lambda x: AutoModelForSequenceClassification.from_pretrained(
+                opt.model, return_dict=True, num_labels=dataset['train'].features['label'].num_classes)
+        )
+        # parameter search
+        if PARALLEL:
+            best_run = trainer.hyperparameter_search(
+                hp_space=lambda x: {
+                    "learning_rate": tune.loguniform(1e-6, 1e-4),
+                    "num_train_epochs": tune.choice(list(range(1, 6))),
+                    "per_device_train_batch_size": tune.choice([4, 8, 16, 32, 64]),
+                },
+                local_dir=RAY_RESULTS, direction="maximize", backend="ray", n_trials=opt.n_trials,
+                resources_per_trial={'cpu': multiprocessing.cpu_count(), "gpu": torch.cuda.device_count()},
+
+            )
+        else:
+            best_run = trainer.hyperparameter_search(
+                hp_space=lambda x: {
+                    "learning_rate": tune.loguniform(1e-6, 1e-4),
+                    "num_train_epochs": tune.choice(list(range(1, 6))),
+                    "per_device_train_batch_size": tune.choice([4, 8, 16, 32, 64]),
+                },
+                local_dir=RAY_RESULTS, direction="maximize", backend="ray", n_trials=opt.n_trials
+            )
+        # finetuning
+        for n, v in best_run.hyperparameters.items():
+            setattr(trainer.args, n, v)
+        trainer.train()
+        trainer.save_model(pj(opt.output_dir, 'best_model'))
+        best_model_path = pj(opt.output_dir, 'best_model')
+    else:
+        best_model_path = opt.output_dir
+
+    # evaluation
+    model = AutoModelForSequenceClassification.from_pretrained(
+        best_model_path,
+        num_labels=dataset['train'].features['label'].num_classes,
+        local_files_only=not network)
+    trainer = Trainer(
+        model=model,
+        args=TrainingArguments(
+            output_dir=opt.output_dir,
+            evaluation_strategy="no",
+            seed=opt.random_seed
+        ),
+        train_dataset=tokenized_datasets["train"],
+        eval_dataset=tokenized_datasets["test"],
+        compute_metrics=compute_metric_all,
+        model_init=lambda x: AutoModelForSequenceClassification.from_pretrained(
+            opt.model, return_dict=True, num_labels=dataset['train'].features['label'].num_classes)
+    )
+    summary_file = pj(opt.output_dir, opt.summary_file)
+    if not opt.skip_eval:
+        result = {f'test/{k}': v for k, v in trainer.evaluate().items()}
+        logging.info(json.dumps(result, indent=4))
+        with open(summary_file, 'w') as f:
+            json.dump(result, f)
+
+    if opt.push_to_hub:
+        assert opt.hf_organization is not None, f'specify hf organization `--hf-organization`'
+        assert opt.model_alias is not None, f'specify hf organization `--model-alias`'
+        url = create_repo(opt.model_alias, organization=opt.hf_organization, exist_ok=True)
+        # if not opt.skip_train:
+        args = {"use_auth_token": opt.use_auth_token, "repo_url": url, "organization": opt.hf_organization}
+        trainer.model.push_to_hub(opt.model_alias, **args)
+        tokenizer.push_to_hub(opt.model_alias, **args)
+        if os.path.exists(summary_file):
+            shutil.copy2(summary_file, opt.model_alias)
+        os.system(
+            f"cd {opt.model_alias} && git lfs install && git add . && git commit -m 'model update' && git push && cd ../")
+        shutil.rmtree(f"{opt.model_alias}")  # clean up the cloned repo
+
+
+if __name__ == '__main__':
+    main()