""" Fine-tune T5 on topic classification (multi-label multi-class classification) ``` python finetune_t5.py --dataset-name ja --model-alias mt5-small-tweet-topic-ja --model-organization cardiffnlp --low-cpu-mem-usage ``` """ import json import logging import os import argparse import gc from glob import glob from typing import List, Set, Dict from shutil import copyfile from statistics import mean from itertools import product from distutils.dir_util import copy_tree import torch import transformers from datasets import load_dataset from transformers import Seq2SeqTrainer, Seq2SeqTrainingArguments, pipeline from huggingface_hub import Repository os.environ['TOKENIZERS_PARALLELISM'] = 'false' # turn-off the warning message os.environ['WANDB_DISABLED'] = 'true' # disable wandb _LR = [1e-6, 1e-5, 1e-4] _BATCH = 32 _EPOCH = 5 def load_model( model_name: str, use_auth_token: bool = False, low_cpu_mem_usage: bool = False) -> transformers.PreTrainedModel: """Load language model from huggingface model hub.""" # config & tokenizer config = transformers.AutoConfig.from_pretrained(model_name, use_auth_token=use_auth_token) if config.model_type == 't5': # T5 model requires T5ForConditionalGeneration class model_class = transformers.T5ForConditionalGeneration.from_pretrained elif config.model_type == 'mt5': model_class = transformers.MT5ForConditionalGeneration.from_pretrained elif config.model_type == 'bart': model_class = transformers.BartForConditionalGeneration.from_pretrained elif config.model_type == 'mbart': model_class = transformers.MBartForConditionalGeneration.from_pretrained else: raise ValueError(f'unsupported model type: {config.model_type}') param = {'config': config, 'use_auth_token': use_auth_token, 'low_cpu_mem_usage': low_cpu_mem_usage} return model_class(model_name, **param) def train( model_name: str, model_low_cpu_mem_usage: bool, dataset: str, dataset_name: str, dataset_column_label: str, dataset_column_text: str, random_seed: int, use_auth_token: bool): """Fine-tune seq2seq model.""" logging.info(f'[CONFIG]\n\t *LM: {model_name}, \n\t *Data: {dataset} ({dataset_name})') output_dir = f'ckpt/{os.path.basename(model_name)}.{os.path.basename(dataset)}.{dataset_name}' tokenizer = transformers.AutoTokenizer.from_pretrained(model_name, use_auth_token=use_auth_token) dataset_instance = load_dataset(dataset, dataset_name, split="train", use_auth_token=use_auth_token) tokenized_dataset = [] for d in dataset_instance: model_inputs = tokenizer(d[dataset_column_text], truncation=True) model_inputs['labels'] = tokenizer(text_target=d[dataset_column_label], truncation=True)['input_ids'] tokenized_dataset.append(model_inputs) for n, lr_tmp in enumerate(_LR): logging.info(f"[TRAIN {n}/{len(_LR)}] lr: {lr_tmp}") output_dir_tmp = f"{output_dir}/model_lr_{lr_tmp}" if os.path.exists(f"{output_dir_tmp}/eval_results.json"): continue model = load_model( model_name=model_name, use_auth_token=use_auth_token, low_cpu_mem_usage=model_low_cpu_mem_usage ) trainer = Seq2SeqTrainer( model=model, args=Seq2SeqTrainingArguments( num_train_epochs=_EPOCH, learning_rate=lr_tmp, output_dir=output_dir_tmp, save_strategy="epoch", evaluation_strategy="no", seed=random_seed, per_device_train_batch_size=_BATCH, ), data_collator=transformers.DataCollatorForSeq2Seq(tokenizer, model=model), train_dataset=tokenized_dataset, ) # train result = trainer.train() trainer.log_metrics("train", result.metrics) trainer.save_metrics("train", result.metrics) # clean up memory trainer.save_model() trainer.save_state() del trainer del model gc.collect() torch.cuda.empty_cache() # # # def get_f1_score(references: List[Set[str]], predictions: List[Set[str]]) -> float: # scores = [] # for g, r in zip(references, predictions): # tp = len(set(g).intersection(set(r))) # fp = len([_g for _g in g if _g not in r]) # fn = len([_r for _r in r if _r not in g]) # if tp == 0: # f1 = 0 # else: # f1 = 2 * tp / (2 * tp + fp + fn) # scores.append(f1) # return mean(scores) # # # # # def evaluate( # model_path: str, # batch_eval: int, # dataset_column_text: str, # dataset_instance, # dataset_split_test: str, # dataset_column_label: str, # ): # prediction_file = f'{model_path}/prediction.{dataset_name}.{}.txt' # input_data = [i[dataset_column_text] for i in dataset_instance[dataset_split_test]] # if not os.path.exists(): # pipe = pipeline( # 'text2text-generation', # model=model_path, # device='cuda:0' if torch.cuda.is_available() else 'cpu', # ) # output = pipe(input_data, batch_size=batch_eval) # output = [i['generated_text'] for i in output] # with open(f'{model_path}/prediction_test.txt', 'w') as f: # f.write('\n'.join(output)) # with open(f'{model_path}/prediction_test.txt') as f: # output = [set(i.split(',')) for i in f.read().split('\n')] # dataset_tmp = dataset_instance[dataset_split_test] # label_list = dataset_tmp[dataset_column_label] # _references = [ # set([_l for __i, _l in zip(_i[dataset_column_label], label_list) if __i == 1]) for _i in dataset_tmp # ] # eval_metric = get_f1_score(_references, output) # eval_metric[f'f1/{dataset}/{dataset_name}'] = eval_metric.pop('f1') # logging.info(json.dumps(eval_metric, indent=4)) # with open(f'{model_path}/evaluation_metrics.json', 'w') as f: # json.dump(eval_metric, f) # # # def train( # model_name: str, # model_low_cpu_mem_usage: bool, # dataset: str, # dataset_name: str, # dataset_column_label: str, # dataset_column_text: str, # dataset_split_train: str, # dataset_split_validation: str, # dataset_split_test: str, # lr: List, # epoch: List, # batch: List, # down_sample_train: int, # down_sample_validation: int, # random_seed: int, # use_auth_token: bool, # output_dir: str, # model_alias: str, # model_organization: str, # skip_train: bool = False, # skip_test: bool = False, # skip_upload: bool = False, # batch_eval: int = None): # """Fine-tune seq2seq model.""" # logging.info(f'[CONFIG]\n\t *LM: {model_name}, \n\t *Data: {dataset} ({dataset_name})') # if not output_dir: # output_dir = f'ckpt/{os.path.basename(model_name)}.{os.path.basename(dataset)}.{dataset_name}' # # dataset process # tokenizer = transformers.AutoTokenizer.from_pretrained(model_name, use_auth_token=use_auth_token) # dataset_split = { # 'train': dataset_split_train, # 'validation': dataset_split_validation # } # dataset_instance = load_dataset(dataset, dataset_name, use_auth_token=use_auth_token) # tokenized_dataset = {} # for s, s_dataset in zip(['train', 'validation'], [dataset_split_train, dataset_split_validation): # tokenized_dataset[s] = [] # for i in dataset_instance[s_dataset]: # model_inputs = tokenizer(i[dataset_column_text], truncation=True) # model_inputs['labels'] = tokenizer(text_target=i[dataset_column_label], truncation=True)['input_ids'] # tokenized_dataset[s].append(model_inputs) # # if not skip_train: # lr = [1e-6, 1e-5, 1e-4] if lr is None else lr # batch = [32] if not batch else batch # epoch = [3, 5] if not epoch else epoch # batch_eval = min(batch) if not batch_eval else batch_eval # for n, (lr_tmp, batch_tmp, epoch_tmp) in enumerate(product(lr, batch, epoch)): # logging.info(f"[TRAIN {n}/{len(lr) * len(batch) * len(epoch)}] lr: {lr_tmp}, batch: {batch_tmp}") # output_dir_tmp = f"{output_dir}/model_lr_{lr_tmp}_batch_{batch_tmp}_epoch_{epoch_tmp}" # if os.path.exists(f"{output_dir_tmp}/eval_results.json"): # continue # model = load_model( # model_name=model_name, use_auth_token=use_auth_token, low_cpu_mem_usage=model_low_cpu_mem_usage # ) # trainer = Seq2SeqTrainer( # model=model, # args=Seq2SeqTrainingArguments( # num_train_epochs=epoch_tmp, # learning_rate=lr_tmp, # output_dir=output_dir_tmp, # evaluation_strategy="no", # seed=random_seed, # per_device_train_batch_size=batch_tmp, # ), # data_collator=transformers.DataCollatorForSeq2Seq(tokenizer, model=model), # train_dataset=tokenized_dataset['train_ds'], # ) # # train # result = trainer.train() # trainer.log_metrics("train", result.metrics) # trainer.save_metrics("train", result.metrics) # # clean up memory # trainer.save_model() # trainer.save_state() # del trainer # del model # gc.collect() # torch.cuda.empty_cache() # # model_score = [] # for eval_file in glob(f"{output_dir}/model_*/eval_results.json"): # with open(eval_file) as f: # results = json.load(f) # model_score.append([os.path.dirname(eval_file), results['eval_loss'], results['eval_f1']]) # logging.info("Search Result") # for i in model_score: # logging.info(i) # max_metric = max(model_score, key=lambda x: x[2]) # if len([i for i in model_score if i[2] == max_metric]) > 1: # best_model = sorted(model_score, key=lambda x: x[1])[0][0] # else: # best_model = sorted(model_score, key=lambda x: x[2])[-1][0] # copy_tree(best_model, f'{output_dir}/best_model') # tokenizer.save_pretrained(f'{output_dir}/best_model') # else: # logging.info('skip hyperparameter search & model training (already done)') # # # get metric on the test set # if not skip_test: # logging.info('run evaluation on test set') # 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}/best_model') # model.push_to_hub(model_alias, **args) # tokenizer.push_to_hub(model_alias, **args) # repo = Repository(model_alias, f'{model_organization}/{model_alias}') # if os.path.exists(f'{output_dir}/best_model/prediction_test.txt'): # copyfile(f'{output_dir}/best_model/prediction_test.txt', f'{model_alias}/prediction_test.txt') # if os.path.exists(f'{output_dir}/best_model/evaluation_metrics.json'): # copyfile(f'{output_dir}/best_model/evaluation_metrics.json', f'{model_alias}/evaluation_metrics.json') # sample = [i[dataset_column_text] for i in dataset_instance[dataset_split_train]] # sample = [i for i in sample if ''' not in i and ''' not in i][:3] # widget = '\n'.join([f"- text: '{t}'\n example_title: example {_n + 1}" for _n, t in enumerate(sample)]) # with open(f'{model_alias}/README.md', 'w') as f: # f.write(f""" # --- # widget: # {widget} # --- # # # {model_organization}/{model_alias} # # This is [{model_name}](https://huggingface.co/{model_name}) fine-tuned on [{dataset} ({dataset_name})](https://huggingface.co/datasets/{dataset}). # # ### Usage # # ```python # from transformers import pipeline # # pipe = pipeline('text2text-generation', model='{model_organization}/{model_alias}') # output = pipe('{sample[0]}') # ``` # """) # repo.push_to_hub() # if __name__ == '__main__': # arguments logging.basicConfig(format='%(asctime)s %(levelname)-8s %(message)s', level=logging.INFO, datefmt='%Y-%m-%d %H:%M:%S') parser = argparse.ArgumentParser(description='Seq2Seq LM Fine-tuning on topic classification.') parser.add_argument('-m', '--model-name', default='google/mt5-small', type=str) parser.add_argument('--low-cpu-mem-usage', action='store_true') parser.add_argument('-d', '--dataset', default='cardiffnlp/tweet_topic_multilingual', type=str) parser.add_argument('--dataset-name', default='ja', type=str) parser.add_argument('--dataset-column-label', default='label_name_flatten', type=str) parser.add_argument('--dataset-column-text', default='text', type=str) 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('--lr', nargs='+', default=None, type=float) parser.add_argument('--epoch', nargs='+', default=None, type=int) parser.add_argument('--batch', nargs='+', default=None, type=int) parser.add_argument('--batch-eval', type=int, default=None) parser.add_argument('--down-sample-train', default=None, type=int) parser.add_argument('--down-sample-validation', default=200, type=int) parser.add_argument('--random-seed', default=42, type=int) parser.add_argument('--use-auth-token', action='store_true') parser.add_argument('--eval-steps', default=100, type=int) parser.add_argument('--output-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, random_seed=opt.random_seed, use_auth_token=opt.use_auth_token, )