import os import numpy as np import torch import torch.nn as nn import torch.optim as optim from torch.optim import lr_scheduler from torch.utils.data import Dataset, DataLoader, RandomSampler, SequentialSampler import pickle import json import matplotlib.pyplot as plt from glob import glob import time import copy from tqdm import tqdm from transformers import BertLMHeadModel, BartTokenizer, BartForConditionalGeneration, BartConfig, BartForSequenceClassification, BertTokenizer, BertConfig, BertForSequenceClassification, RobertaTokenizer, RobertaForSequenceClassification, PegasusForConditionalGeneration, PegasusTokenizer, T5Tokenizer, T5ForConditionalGeneration, BertGenerationEncoder, BertGenerationDecoder, EncoderDecoderConfig, EncoderDecoderModel from data import ZuCo_dataset from model_decoding import BrainTranslator, BrainTranslatorNaive, T5Translator from config import get_config def train_model(dataloaders, device, model, criterion, optimizer, scheduler, num_epochs=25, checkpoint_path_best = './checkpoints/decoding/best/temp_decoding.pt', checkpoint_path_last = './checkpoints/decoding/last/temp_decoding.pt'): # modified from: https://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html since = time.time() best_model_wts = copy.deepcopy(model.state_dict()) best_loss = 100000000000 for epoch in range(num_epochs): print('Epoch {}/{}'.format(epoch, num_epochs - 1)) print('-' * 10) # Each epoch has a training and validation phase for phase in ['train', 'dev']: if phase == 'train': model.train() # Set model to training mode else: model.eval() # Set model to evaluate mode running_loss = 0.0 # Iterate over data. for input_embeddings, seq_len, input_masks, input_mask_invert, target_ids, target_mask, sentiment_labels in tqdm(dataloaders[phase]): # load in batch input_embeddings_batch = input_embeddings.to(device).float() input_masks_batch = input_masks.to(device) input_mask_invert_batch = input_mask_invert.to(device) target_ids_batch = target_ids.to(device) """replace padding ids in target_ids with -100""" target_ids_batch[target_ids_batch == tokenizer.pad_token_id] = -100 # zero the parameter gradients optimizer.zero_grad() # forward # track history if only in train with torch.set_grad_enabled(phase == 'train'): seq2seqLMoutput = model(input_embeddings_batch, input_masks_batch, input_mask_invert_batch, target_ids_batch) """calculate loss""" # logits = seq2seqLMoutput.logits # 8*48*50265 # logits = logits.permute(0,2,1) # 8*50265*48 # loss = criterion(logits, target_ids_batch_label) # calculate cross entropy loss only on encoded target parts # NOTE: my criterion not used loss = seq2seqLMoutput.loss # use the BART language modeling loss # """check prediction, instance 0 of each batch""" # print('target size:', target_ids_batch.size(), ',original logits size:', logits.size(), ',target_mask size', target_mask_batch.size()) # logits = logits.permute(0,2,1) # for idx in [0]: # print(f'-- instance {idx} --') # # print('permuted logits size:', logits.size()) # probs = logits[idx].softmax(dim = 1) # # print('probs size:', probs.size()) # values, predictions = probs.topk(1) # # print('predictions before squeeze:',predictions.size()) # predictions = torch.squeeze(predictions) # # print('predictions:',predictions) # # print('target mask:', target_mask_batch[idx]) # # print('[DEBUG]target tokens:',tokenizer.decode(target_ids_batch_copy[idx])) # print('[DEBUG]predicted tokens:',tokenizer.decode(predictions)) # backward + optimize only if in training phase if phase == 'train': # with torch.autograd.detect_anomaly(): loss.sum().backward() optimizer.step() # statistics running_loss += loss.sum().item() * input_embeddings_batch.size()[0] # batch loss # print('[DEBUG]loss:',loss.item()) # print('#################################') if phase == 'train': scheduler.step() epoch_loss = running_loss / dataset_sizes[phase] print('{} Loss: {:.4f}'.format(phase, epoch_loss)) # deep copy the model if phase == 'dev' and epoch_loss < best_loss: best_loss = epoch_loss best_model_wts = copy.deepcopy(model.state_dict()) '''save checkpoint''' torch.save(model.state_dict(), checkpoint_path_best) print(f'update best on dev checkpoint: {checkpoint_path_best}') # with torch.set_grad_enabled(False): # traced_model_1 = torch.jit.trace(model, (torch.rand(1, 56, 840).to(device), torch.randint(1, 56).to(device), torch.rand(1, 56).to(device), torch.rand(1, 56).to(device))) # traced_model_32 = torch.jit.trace(model, (torch.rand(32, 56, 840).to(device), torch.randint(32, 56).to(device), torch.rand(32, 56).to(device), torch.rand(32, 56).to(device))) # torch.jit.save(traced_model_1, checkpoint_path_best[:-3]+'_1_jit.pt') # torch.jit.save(traced_model_32, checkpoint_path_best[:-3]+'_32_jit.pt') print() time_elapsed = time.time() - since print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60)) print('Best val loss: {:4f}'.format(best_loss)) torch.save(model.state_dict(), checkpoint_path_last) print(f'update last checkpoint: {checkpoint_path_last}') # load best model weights model.load_state_dict(best_model_wts) return model def show_require_grad_layers(model): print() print(' require_grad layers:') # sanity check for name, param in model.named_parameters(): if param.requires_grad: print(' ', name) if __name__ == '__main__': args = get_config('train_decoding') ''' config param''' dataset_setting = 'unique_sent' num_epochs_step1 = args['num_epoch_step1'] num_epochs_step2 = args['num_epoch_step2'] step1_lr = args['learning_rate_step1'] step2_lr = args['learning_rate_step2'] batch_size = args['batch_size'] model_name = args['model_name'] # model_name = 'BrainTranslatorNaive' # with no additional transformers # model_name = 'BrainTranslator' # task_name = 'task1' # task_name = 'task1_task2' # task_name = 'task1_task2_task3' # task_name = 'task1_task2_taskNRv2' task_name = args['task_name'] train_input = args['train_input'] print("train_input is:", train_input) save_path = args['save_path'] if not os.path.exists(save_path): os.makedirs(save_path) skip_step_one = args['skip_step_one'] load_step1_checkpoint = args['load_step1_checkpoint'] use_random_init = args['use_random_init'] device_ids = [0] # device setting if use_random_init and skip_step_one: step2_lr = 5*1e-4 print(f'[INFO]using model: {model_name}') if skip_step_one: save_name = f'{task_name}_finetune_{model_name}_skipstep1_b{batch_size}_{num_epochs_step1}_{num_epochs_step2}_{step1_lr}_{step2_lr}_{dataset_setting}_{train_input}' else: save_name = f'{task_name}_finetune_{model_name}_2steptraining_b{batch_size}_{num_epochs_step1}_{num_epochs_step2}_{step1_lr}_{step2_lr}_{dataset_setting}_{train_input}' if use_random_init: save_name = 'randinit_' + save_name save_path_best = os.path.join(save_path, 'best') if not os.path.exists(save_path_best): os.makedirs(save_path_best) output_checkpoint_name_best = os.path.join(save_path_best, f'{save_name}.pt') save_path_last = os.path.join(save_path, 'last') if not os.path.exists(save_path_last): os.makedirs(save_path_last) output_checkpoint_name_last = os.path.join(save_path_last, f'{save_name}.pt') # subject_choice = 'ALL subject_choice = args['subjects'] print(f'![Debug]using {subject_choice}') # eeg_type_choice = 'GD eeg_type_choice = args['eeg_type'] print(f'[INFO]eeg type {eeg_type_choice}') # bands_choice = ['_t1'] # bands_choice = ['_t1','_t2','_a1','_a2','_b1','_b2','_g1','_g2'] bands_choice = args['eeg_bands'] print(f'[INFO]using bands {bands_choice}') ''' set random seeds ''' seed_val = 312 np.random.seed(seed_val) torch.manual_seed(seed_val) torch.cuda.manual_seed_all(seed_val) ''' set up device ''' # use cuda if torch.cuda.is_available(): # dev = "cuda:3" dev = args['cuda'] else: dev = "cpu" # CUDA_VISIBLE_DEVICES=0,1,2,3 device = torch.device(dev) print(f'[INFO]using device {dev}') print() ''' set up dataloader ''' whole_dataset_dicts = [] if 'task1' in task_name: dataset_path_task1 = '/datasets/pickle/task1-SR-datasets.pickle' with open(dataset_path_task1, 'rb') as handle: whole_dataset_dicts.append(pickle.load(handle)) if 'task2' in task_name: dataset_path_task2 = '/datasets/pickle/task2-NR-datasets.pickle' with open(dataset_path_task2, 'rb') as handle: whole_dataset_dicts.append(pickle.load(handle)) if 'task3' in task_name: dataset_path_task3 = '/datasets/pickle/task3-TSR-datasets.pickle' with open(dataset_path_task3, 'rb') as handle: whole_dataset_dicts.append(pickle.load(handle)) if 'taskNRv2' in task_name: dataset_path_taskNRv2 = '/datasets/pickle/task2-NR-2.0-datasets.pickle' with open(dataset_path_taskNRv2, 'rb') as handle: whole_dataset_dicts.append(pickle.load(handle)) print() """save config""" cfg_dir = './config/decoding/' if not os.path.exists(cfg_dir): os.makedirs(cfg_dir) with open(os.path.join(cfg_dir,f'{save_name}.json'), 'w') as out_config: json.dump(args, out_config, indent = 4) if model_name in ['BrainTranslator','BrainTranslatorNaive']: tokenizer = BartTokenizer.from_pretrained('facebook/bart-large') elif model_name == 'PegasusTranslator': tokenizer = PegasusTokenizer.from_pretrained('google/pegasus-xsum') elif model_name == 'T5Translator': tokenizer = T5Tokenizer.from_pretrained("t5-large") #tokenizer.set_prefix_tokens(language='english') # train dataset train_set = ZuCo_dataset(whole_dataset_dicts, 'train', tokenizer, subject = subject_choice, eeg_type = eeg_type_choice, bands = bands_choice, setting = dataset_setting, test_input=train_input) # dev dataset dev_set = ZuCo_dataset(whole_dataset_dicts, 'dev', tokenizer, subject = subject_choice, eeg_type = eeg_type_choice, bands = bands_choice, setting = dataset_setting, test_input=train_input) # test dataset # test_set = ZuCo_dataset(whole_dataset_dicts, 'test', tokenizer, subject = subject_choice, eeg_type = eeg_type_choice, bands = bands_choice, setting = dataset_setting) dataset_sizes = {'train': len(train_set), 'dev': len(dev_set)} print('[INFO]train_set size: ', len(train_set)) print('[INFO]dev_set size: ', len(dev_set)) # print('[INFO]test_set size: ', len(test_set)) # train dataloader train_dataloader = DataLoader(train_set, batch_size = batch_size, shuffle=True, num_workers=4) # dev dataloader val_dataloader = DataLoader(dev_set, batch_size = 1, shuffle=False, num_workers=4) # dataloaders dataloaders = {'train':train_dataloader, 'dev':val_dataloader} ''' set up model ''' if model_name == 'BrainTranslator': if use_random_init: config = BartConfig.from_pretrained('facebook/bart-large') pretrained = BartForConditionalGeneration(config) else: pretrained = BartForConditionalGeneration.from_pretrained('facebook/bart-large') model = BrainTranslator(pretrained, in_feature = 105*len(bands_choice), decoder_embedding_size = 1024, additional_encoder_nhead=8, additional_encoder_dim_feedforward = 2048) elif model_name == 'BrainTranslatorNaive': pretrained = BartForConditionalGeneration.from_pretrained('facebook/bart-large') model = BrainTranslatorNaive(pretrained, in_feature = 105*len(bands_choice), decoder_embedding_size = 1024, additional_encoder_nhead=8, additional_encoder_dim_feedforward = 2048) elif model_name == 'PegasusTranslator': pretrained = PegasusForConditionalGeneration.from_pretrained('google/pegasus-xsum') model = BrainTranslator(pretrained, in_feature = 105*len(bands_choice), decoder_embedding_size = 1024, additional_encoder_nhead=8, additional_encoder_dim_feedforward = 2048) elif model_name == 'T5Translator': pretrained = T5ForConditionalGeneration.from_pretrained("t5-large") model = T5Translator(pretrained, in_feature = 105*len(bands_choice), decoder_embedding_size = 1024, additional_encoder_nhead=8, additional_encoder_dim_feedforward = 2048) model.to(device) model = torch.nn.DataParallel(model, device_ids=device_ids) ''' training loop ''' ###################################################### '''step one trainig: freeze most of BART params''' ###################################################### # closely follow BART paper if model_name in ['BrainTranslator','BrainTranslatorNaive', 'PegasusTranslator', 'T5Translator']: for name, param in model.named_parameters(): if param.requires_grad and 'pretrained' in name: if ('shared' in name) or ('embed_positions' in name) or ('encoder.layers.0' in name): continue else: param.requires_grad = False elif model_name == 'BertGeneration': for name, param in model.named_parameters(): if param.requires_grad and 'pretrained' in name: if ('embeddings' in name) or ('encoder.layer.0' in name): continue else: param.requires_grad = False if skip_step_one: if load_step1_checkpoint: stepone_checkpoint = 'path_to_step_1_checkpoint.pt' print(f'skip step one, load checkpoint: {stepone_checkpoint}') model.load_state_dict(torch.load(stepone_checkpoint)) else: print('skip step one, start from scratch at step two') else: ''' set up optimizer and scheduler''' optimizer_step1 = optim.SGD(filter(lambda p: p.requires_grad, model.parameters()), lr=step1_lr, momentum=0.9) exp_lr_scheduler_step1 = lr_scheduler.StepLR(optimizer_step1, step_size=20, gamma=0.1) ''' set up loss function ''' criterion = nn.CrossEntropyLoss() print('=== start Step1 training ... ===') # print training layers show_require_grad_layers(model) # return best loss model from step1 training model = train_model(dataloaders, device, model, criterion, optimizer_step1, exp_lr_scheduler_step1, num_epochs=num_epochs_step1, checkpoint_path_best = output_checkpoint_name_best, checkpoint_path_last = output_checkpoint_name_last) ###################################################### '''step two trainig: update whole model for a few iterations''' ###################################################### for name, param in model.named_parameters(): param.requires_grad = True ''' set up optimizer and scheduler''' optimizer_step2 = optim.SGD(model.parameters(), lr=step2_lr, momentum=0.9) exp_lr_scheduler_step2 = lr_scheduler.StepLR(optimizer_step2, step_size=30, gamma=0.1) ''' set up loss function ''' criterion = nn.CrossEntropyLoss() print() print('=== start Step2 training ... ===') # print training layers show_require_grad_layers(model) '''main loop''' trained_model = train_model(dataloaders, device, model, criterion, optimizer_step2, exp_lr_scheduler_step2, num_epochs=num_epochs_step2, checkpoint_path_best = output_checkpoint_name_best, checkpoint_path_last = output_checkpoint_name_last) # '''save checkpoint''' # torch.save(trained_model.state_dict(), os.path.join(save_path,output_checkpoint_name))