init

training_scripts/finetune_t5.py

@@ -6,18 +6,17 @@ python finetune_t5.py --dataset-name ja --model-alias mt5-small-tweet-topic-ja -
 import json
 import logging
 import os
-import multiprocessing
 import argparse
 import gc
 from typing import List, Set
 from shutil import copyfile
 from statistics import mean
+from itertools import product
 
 import torch
 import transformers
 from datasets import load_dataset
 from transformers import Seq2SeqTrainer, Seq2SeqTrainingArguments, pipeline
-from ray import tune, init
 from huggingface_hub import Repository
 
 
@@ -60,6 +59,7 @@ def get_f1_score(references: List[Set[str]], predictions: List[Set[str]]):
         scores.append(f1)
     return {'f1': mean(scores)}
 
+
 def train(
         model_name: str,
         model_low_cpu_mem_usage: bool,
@@ -70,47 +70,26 @@ def train(
         dataset_split_train: str,
         dataset_split_validation: str,
         dataset_split_test: str,
-        search_range_lr: List,
-        search_range_epoch: List,
-        search_list_batch: List,
+        lr: List,
+        epoch: int,
+        batch: List,
         down_sample_train: int,
         down_sample_validation: int,
         random_seed: int,
         use_auth_token: bool,
-        n_trials: int,
-        eval_step: int,
-        parallel_cpu: bool,
         output_dir: str,
-        ray_result_dir: str,
         model_alias: str,
         model_organization: str,
+        skip_train: bool = False,
+        skip_test: bool = False,
+        skip_upload: bool = False,
+        eval_steps: float = 0.25,
         eval_batch_size: int = 16):
     """Fine-tune seq2seq model."""
-    logging.info(
-        f'[CONFIG]\n\t *LM: {model_name}, \n\t *Data: {dataset} ({dataset_name}), \n\t *Num of Trial: {n_trials}'
-    )
+    logging.info(f'[CONFIG]\n\t *LM: {model_name}, \n\t *Data: {dataset} ({dataset_name})')
     # set up the output directory
     if output_dir is None:
         output_dir = f'ckpt/{os.path.basename(model_name)}.{os.path.basename(dataset)}.{dataset_name}'
-    ray_result_dir = ray_result_dir
-    if ray_result_dir is None:
-        ray_result_dir = f'ray/{os.path.basename(model_name)}.{os.path.basename(dataset)}.{dataset_name}'
-
-    # define search space
-    search_range_lr = [1e-6, 1e-4] if search_range_lr is None else search_range_lr
-    assert len(search_range_lr) == 2, f'`search_range_lr` should contain [min_lr, max_lr]: {search_range_lr}'
-    search_range_epoch = [2, 6] if search_range_epoch is None else search_range_epoch
-    assert len(search_range_epoch) == 2, f'`search_range_epoch` should contain [min_epoch, max_epoch]: {search_range_epoch}'
-    search_list_batch = [64, 128] if search_list_batch is None else search_list_batch
-    search_space = {
-        'learning_rate': tune.loguniform(search_range_lr[0], search_range_lr[1]),
-        'num_train_epochs': tune.choice(list(range(search_range_epoch[0], search_range_epoch[1]))),
-        'per_device_train_batch_size': tune.choice(search_list_batch)
-    }
-    resources_per_trial = {'cpu': multiprocessing.cpu_count() if parallel_cpu else 1, 'gpu': torch.cuda.device_count()}
-    init(ignore_reinit_error=True, num_cpus=resources_per_trial['cpu'])
-    logging.info(f'[RESOURCE]\n{json.dumps(resources_per_trial, indent=4)}')
-
     # dataset process
     tokenizer = transformers.AutoTokenizer.from_pretrained(model_name, use_auth_token=use_auth_token)
     dataset_split = {
@@ -156,69 +135,52 @@ def train(
         generation_decode = decode_tokens(generation_token_id)
         return get_f1_score(references_decode, generation_decode)
 
-    if not os.path.exists(f'{output_dir}/model/pytorch_model.bin'):
-        trainer = Seq2SeqTrainer(
-            # model=model,
-            args=Seq2SeqTrainingArguments(
-                output_dir=f'{output_dir}/runs',
-                evaluation_strategy='steps',
-                eval_steps=eval_step,
-                seed=random_seed
-            ),
-            data_collator=transformers.DataCollatorForSeq2Seq(tokenizer, model=load_model(
-                model_name=model_name,
-                use_auth_token=use_auth_token,
-                low_cpu_mem_usage=model_low_cpu_mem_usage)),
-            train_dataset=tokenized_dataset['train_ds'],
-            eval_dataset=tokenized_dataset['validation_ds'],
-            compute_metrics=compute_metric,
-            model_init=lambda x: load_model(
-                model_name=model_name,
-                use_auth_token=use_auth_token,
-                low_cpu_mem_usage=model_low_cpu_mem_usage)
-        )
-        os.makedirs(f'{output_dir}/model', exist_ok=True)
-        if not os.path.exists(f'{output_dir}/model/hyperparameters.json'):
-            # grid search
-            best_run = trainer.hyperparameter_search(
-                hp_space=lambda x: search_space,
-                local_dir=ray_result_dir,
-                direction='maximize',
-                backend='ray',
-                n_trials=n_trials,
-                resources_per_trial=resources_per_trial
+    if not skip_train:
+        lr = [1e-6, 1e-4] if lr is None else lr
+        batch = [64] if batch is None else batch
+        for n, (lr_tmp, batch_tmp) in enumerate(product(lr, batch)):
+            logging.info(f"[TRAIN {n}/{len(lr) * len(batch)}] lr: {lr_tmp}, batch: {batch_tmp}")
+            trainer = Seq2SeqTrainer(
+                args=Seq2SeqTrainingArguments(
+                    num_train_epochs=epoch,
+                    learning_rate=lr_tmp,
+                    output_dir=f'{output_dir}/runs',
+                    evaluation_strategy='steps',
+                    eval_steps=eval_steps,
+                    per_device_eval_batch_size=eval_batch_size,
+                    seed=random_seed,
+                    per_device_train_batch_size=batch_tmp,
+                ),
+                data_collator=transformers.DataCollatorForSeq2Seq(tokenizer, model=load_model(
+                    model_name=model_name,
+                    use_auth_token=use_auth_token,
+                    low_cpu_mem_usage=model_low_cpu_mem_usage)),
+                train_dataset=tokenized_dataset['train_ds'],
+                eval_dataset=tokenized_dataset['validation_ds'],
+                compute_metrics=compute_metric,
             )
-            with open(f'{output_dir}/model/hyperparameters.json', 'w') as f:
+            os.makedirs(f'{output_dir}/model_{n}', exist_ok=True)
+            best_run = trainer.train()
+            trainer.save_model(f'{output_dir}/model_{n}')
+            tokenizer.save_pretrained(f'{output_dir}/model_{n}')
+            # grid search
+            with open(f'{output_dir}/model_{n}/hyperparameters.json', 'w') as f:
                 json.dump(best_run.hyperparameters, f)
-        else:
-            logging.info('skip hyperparameter search (already done)')
-
-        # fine-tuning with the best config
-        logging.info(f'fine-tuning with the best config')
-        with open(f'{output_dir}/model/hyperparameters.json') as f:
-            best_hyperparameters = json.load(f)
-        for n, v in best_hyperparameters.items():
-            setattr(trainer.args, n, v)
-        setattr(trainer, 'train_dataset', tokenized_dataset['train'])
-        setattr(trainer.args, 'evaluation_strategy', 'no')
-        trainer.train()
-        trainer.save_model(f'{output_dir}/model')
-        tokenizer.save_pretrained(f'{output_dir}/model')
-        logging.info(f'model saved at {output_dir}/model')
-        del trainer
-        gc.collect()
-        torch.cuda.empty_cache()
+            del trainer
+            gc.collect()
+            torch.cuda.empty_cache()
+            logging.info(f'model saved at {output_dir}/model_{n}')
     else:
         logging.info('skip hyperparameter search & model training (already done)')
 
     # get metric on the test set
-    if dataset_split_test is not None and not os.path.exists(f'{output_dir}/model/evaluation_metrics.json'):
+    if not skip_test:
         logging.info('run evaluation on test set')
         if not os.path.exists(f'{output_dir}/model/prediction_test.txt'):
             pipe = pipeline(
                 'text2text-generation',
                 model=f'{output_dir}/model',
-                device='cuda:0' if resources_per_trial['gpu'] > 0 else 'cpu'
+                device='cuda:0' if torch.cuda.is_available() else 'cpu',
             )
             input_data = [i[dataset_column_text] for i in dataset_instance[dataset_split_test]]
             output = pipe(input_data, batch_size=eval_batch_size)
@@ -237,8 +199,9 @@ def train(
         with open(f'{output_dir}/model/evaluation_metrics.json', 'w') as f:
             json.dump(eval_metric, f)
 
-    if model_alias is not None:
-        assert model_organization is not None, 'model_organization must be specified when model_alias is specified'
+    if not skip_upload:
+        assert model_alias is not None and model_organization is not None,\
+            'model_organization must be specified when model_alias is specified'
         logging.info('uploading to huggingface')
         args = {'use_auth_token': use_auth_token, 'organization': model_organization}
         model = load_model(model_name=f'{output_dir}/model')
@@ -289,42 +252,45 @@ if __name__ == '__main__':
     parser.add_argument('--dataset-split-train', default='train', type=str)
     parser.add_argument('--dataset-split-validation', default='validation', type=str)
     parser.add_argument('--dataset-split-test', default='test', type=str)
-    parser.add_argument('--search-range-lr', nargs='+', default=None, type=float)
-    parser.add_argument('--search-range-epoch', nargs='+', default=None, type=int)
-    parser.add_argument('--search-list-batch', nargs='+', default=None, type=int)
+    parser.add_argument('--lr', nargs='+', default=None, type=float)
+    parser.add_argument('--epoch', default=5, type=int)
+    parser.add_argument('--batch', nargs='+', default=None, type=int)
     parser.add_argument('--down-sample-train', default=None, type=int)
     parser.add_argument('--down-sample-validation', default=2000, type=int)
     parser.add_argument('--random-seed', default=42, type=int)
     parser.add_argument('--use-auth-token', action='store_true')
-    parser.add_argument('--n-trials', default=20, type=int)
-    parser.add_argument('--eval-step', default=100, type=int)
-    parser.add_argument('--parallel-cpu', action='store_true')
+    parser.add_argument('--eval-steps', default=100, type=int)
     parser.add_argument('--output-dir', default=None, type=str)
-    parser.add_argument('--ray-result-dir', default=None, type=str)
     parser.add_argument('--model-alias', default=None, type=str)
     parser.add_argument('--model-organization', default=None, 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()
 
-    train(model_name=opt.model_name,
-          model_low_cpu_mem_usage=opt.low_cpu_mem_usage,
-          dataset=opt.dataset,
-          dataset_name=opt.dataset_name,
-          dataset_column_label=opt.dataset_column_label,
-          dataset_column_text=opt.dataset_column_text,
-          dataset_split_train=opt.dataset_split_train,
-          dataset_split_validation=opt.dataset_split_validation,
-          dataset_split_test=opt.dataset_split_test,
-          search_range_lr=opt.search_range_lr,
-          search_range_epoch=opt.search_range_epoch,
-          search_list_batch=opt.search_list_batch,
-          down_sample_train=opt.down_sample_train,
-          down_sample_validation=opt.down_sample_validation,
-          random_seed=opt.random_seed,
-          use_auth_token=opt.use_auth_token,
-          n_trials=opt.n_trials,
-          eval_step=opt.eval_step,
-          parallel_cpu=opt.parallel_cpu,
-          output_dir=opt.output_dir,
-          ray_result_dir=opt.ray_result_dir,
-          model_alias=opt.model_alias,
-          model_organization=opt.model_organization)
+    train(
+        model_name=opt.model_name,
+        model_low_cpu_mem_usage=opt.low_cpu_mem_usage,
+        dataset=opt.dataset,
+        dataset_name=opt.dataset_name,
+        dataset_column_label=opt.dataset_column_label,
+        dataset_column_text=opt.dataset_column_text,
+        dataset_split_train=opt.dataset_split_train,
+        dataset_split_validation=opt.dataset_split_validation,
+        dataset_split_test=opt.dataset_split_test,
+        lr=opt.lr,
+        epoch=opt.epoch,
+        batch=opt.batch,
+        down_sample_train=opt.down_sample_train,
+        down_sample_validation=opt.down_sample_validation,
+        random_seed=opt.random_seed,
+        use_auth_token=opt.use_auth_token,
+        n_trials=opt.n_trials,
+        eval_steps=opt.eval_steps,
+        output_dir=opt.output_dir,
+        model_alias=opt.model_alias,
+        model_organization=opt.model_organization,
+        skip_train=opt.skip_train,
+        skip_test=opt.skip_test,
+        skip_upload=opt.skip_upload
+    )

training_scripts/requirements.txt

@@ -0,0 +1,6 @@
+ray
+ray[tune]
+torch
+datasets
+transformers
+huggingface_hub

training_scripts/script.sh

@@ -0,0 +1,6 @@
+python finetune_t5.py --dataset-name ja --model-alias mt5-small-tweet-topic-ja --model-organization cardiffnlp
+python finetune_t5.py --dataset-name gr --model-alias mt5-small-tweet-topic-gr --model-organization cardiffnlp
+python finetune_t5.py --dataset-name es --model-alias mt5-small-tweet-topic-es --model-organization cardiffnlp
+python finetune_t5.py --dataset-name en --model-alias mt5-small-tweet-topic-en --model-organization cardiffnlp
+
+