def manipulate(TAG_NAME,BATCH_SIZE,FILEPATH,LABEL,NUM_CLASSES,MODEL,LAYERS,EPOCHS): print("Parameters: Timestamp:{} Batch size:{} Model:{} Epochs:{}".format(TAG_NAME,BATCH_SIZE,MODEL,EPOCHS)) data = pd.read_csv(FILEPATH) rows = np.asarray(data.iloc[:, :]) print("Shuffling brands.") np.random.shuffle(rows) print("Shuffle finished.") layers_list = LAYERS train_data = rows[:int(0.8*(len(rows)))] val_data = rows[int(0.8*(len(rows))):] train_generator = DataGenerator(datas=train_data,batch_size=BATCH_SIZE,label=LABEL,num_classes=NUM_CLASSES) val_generator = DataGenerator(datas=val_data,batch_size=BATCH_SIZE,label=LABEL,num_classes=NUM_CLASSES) model = config.model(MODEL).create_model_with_layers(layers_list,NUM_CLASSES) steps_per_epoch = math.ceil(len(data) / BATCH_SIZE) checkpoint = ModelCheckpoint("saved_models/{}_best_model.hdf5".format(TAG_NAME), monitor='val_loss', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', period=1) callback_lists = [checkpoint] history = model.fit_generator(train_generator, steps_per_epoch=steps_per_epoch,epochs=EPOCHS,validation_data=val_generator,callbacks=callback_lists) model.save("model_{}.h5".format(TAG_NAME)) post_process(history,TAG_NAME)
def __init__(self, pre_path=''): self.all_data = ABSAData() self.train_iter = self.all_data.train_iter self.val_iter = self.all_data.val_iter self.test_iter = self.all_data.test_iter self.text_vocab = self.all_data.text_vocab self.aspect_vocab = self.all_data.aspect_vocab self.label_vocab = self.all_data.label_vocab self.device_dict = { -1: 'cpu', 0: 'cuda:0', 1: 'cuda:1', 2: 'cuda:2', } self.model = config.model().to(self.device_dict[config.device]) if config.pretrain: self.load_model(config.pretrain_path) self.criterion = config.criterion() # TODO: Set momentum for optimizer, momentum=0.9 self.optimizer = config.optimizer(filter(lambda p: p.requires_grad, self.model.parameters()), lr=config.learning_rate, lr_decay=config.lr_decay, weight_decay=0.001) if config.if_log: self.writer = SummaryWriter(log_dir=config.log_dir) # Create pretrained model folder if not config.pretrain: if pre_path != '': self.pre_dir = pre_path
def model(): body = b_class planet = p_class initialcondition = ic_class aerodynamics = a_class engine = e_class m = cnf.model(body, planet, initialcondition, aerodynamics, engine) return m
def vqa(): st = time.time() img = utl.get_img_tensor(cfg.img_path) img_features = cfg.vgg16_extractor(img) img_features = tf.reshape(img_features, (1, -1, 512)) out, att = cfg.model(cfg.question_seq, trg=None, image_info=img_features) cfg.answer = utl.convert_text(cfg.tokenizer_ans, out[0]).replace(' ', '') cfg.att = att end = time.time() return end - st
def run_past_model(weights_path, model=None): X_test = load_data(test_only=True) # recreate the model if model is None: m = config.model() else: m = model() m.load_weights(weights_path) test_model(X_test, m, weights_path)
def set_up_models(self, embeddings): print("..Seting up the models") classifier_params = config.lstm_classifier_params if config.model is LSTMClassifier else config.hierarchical_lstm_classifier_params vocabulary, n_embeddings, embedding_layer = embeddings for i in range(0, self.size): model = config.model(embedding_layer, n_embeddings, **classifier_params).cpu() model_restore_callback = BestModelRestore( monitor=config.restore_monitor, mode=config.restore_mode, verbose=True) early_stopping_callback = EarlyStopping( monitor=config.early_stop_monitor, min_delta=config.early_stop_min_delta, patience=config.early_stop_patience, mode=config.early_stop_mode, verbose=True) grad_clip_callback = ClipNorm(model.parameters(), config.max_grad_norm) lr_callback_2 = MultiStepLR(milestones=[3]) model_pt = Model(model, config.optimizer, self.loss_fn, metrics=['acc', microF1]).cpu() self.constituents.append(model) self.constituents_pt.append(model_pt) self.constituents_callbacks.append( (model_restore_callback, early_stopping_callback, grad_clip_callback, lr_callback_2)) if self.type == "stack": self.stack_model = StackedClassifier(self.size, config.classes) model_restore_callback = BestModelRestore( monitor=config.restore_monitor, mode=config.restore_mode, verbose=True) early_stopping_callback = EarlyStopping( monitor=config.early_stop_monitor, min_delta=config.early_stop_min_delta, patience=config.early_stop_patience, mode=config.early_stop_mode, verbose=True) grad_clip_callback = ClipNorm(self.stack_model.parameters(), config.max_grad_norm) self.stack_model_pt = Model( self.stack_model, config.optimizer, torch.nn.NLLLoss(torch.Tensor(config.label_weights).cuda()), metrics=['acc', microF1]).cpu() self.stack_callbacks = [ model_restore_callback, early_stopping_callback, grad_clip_callback ]
def train(data, scene, mdl_path, vgg_weights_path): ### hyper-params lr = config.lr val_split = config.val_split max_epoch = config.max_epoch batch_size = config.batch_size ### img_shape = np.shape(data[0][0]) #(height, width, channel) model = config.model(lr, img_shape, scene, vgg_weights_path) model = model.initModel('SBI') # make sure that training input shape equals to model output input_shape = (img_shape[0], img_shape[1]) output_shape = (model.output._keras_shape[1], model.output._keras_shape[2]) assert input_shape == output_shape, 'Given input shape:' + str( input_shape) + ', but your model outputs shape:' + str(output_shape) early = keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=1e-4, patience=10, verbose=0, mode='auto') mc = keras.callbacks.ModelCheckpoint('weights{epoch:08d}.h5', save_weights_only=False, period=1) redu = keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=5, verbose=0, mode='auto') model.fit(data[0], data[1], validation_split=val_split, epochs=max_epoch, batch_size=batch_size, callbacks=[redu, early, mc], verbose=1, class_weight=data[2], shuffle=True) #model.summary() model.save(mdl_path) del model, data, early, redu
def set_up_model(vectors, **kwargs): print("..Setting up the model") classifier_params = config.lstm_classifier_params if config.model is lstm_classifier.LSTMClassifier else config.hierarchical_lstm_classifier_params model = config.model(vectors[2], vectors[1], **classifier_params).cuda() model_restore_callback = BestModelRestore(monitor=config.restore_monitor, mode=config.restore_mode, verbose=True) early_stopping_callback = EarlyStopping( monitor=config.early_stop_monitor, min_delta=config.early_stop_min_delta, patience=config.early_stop_patience, mode=config.early_stop_mode, verbose=True) grad_clip_callback = ClipNorm(model.parameters(), config.max_grad_norm) # lr_callback_1 = ReduceLROnPlateau(mode="max", patience=1, monitor="val_microF1", threshold=0.002, min_lr=1e-6, verbose=True, threshold_mode='abs') lr_callback_2 = MultiStepLR(milestones=[2]) loss_fn = torch.nn.CrossEntropyLoss( torch.Tensor(config.label_weights).cuda()) pt_fw = Model(model, config.optimizer, loss_fn, metrics=['acc', microF1]) return pt_fw, [ model_restore_callback, early_stopping_callback, grad_clip_callback ], model
def train(X_train, y_train, X_val, y_val, weights_path=None): """ Trains our CNN """ # create base model # model = ResNet50() model = config.model() # restart from middle if weights_path: model.load_weights(weights_path) # optimizers: adam, rmsprop, sgd, etc. model.compile(optimizer=config.optimizer, loss='categorical_crossentropy', metrics=['accuracy', 'top_k_categorical_accuracy']) # callbacks for training cb_early_stop = EarlyStopping(monitor="val_loss", patience=config.patience) cb_checkpoint = ModelCheckpoint("weights.{epoch:02d}-{val_loss:.2f}.hdf5") cb_csv = CSVLogger("training.log") # preprocessed data niceness inputs_train, inputs_val = preprocess_data(X_train, y_train, X_val, y_val) print("# Data loaded. Beginning training.") history = model.fit_generator( inputs_train, epochs=config.epochs, steps_per_epoch=X_train.shape[0] / config.batch_size, validation_steps=X_val.shape[0] / config.batch_size, verbose=1, validation_data=inputs_val, callbacks=[cb_early_stop, cb_checkpoint, cb_csv]) return model, history
dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'test']} class_names = image_datasets['train'].classes trainloader = dataloaders['train'] testloader = dataloaders['test'] # compute class weights class_weights = compute_class_weights(image_datasets['train'].imgs, len(image_datasets['train'].classes)) class_weights = torch.FloatTensor(class_weights).to(device) print("Found {} training images".format(len(image_datasets['train']))) print("Found {} evaluating images".format(len(image_datasets['test']))) print("Classes: {}".format(class_names)) # model net = model(args) net = net.to(device) # print(net) # net parameters # count_parameters(net) summary(net, (3, args.img_size, args.img_size)) if device == 'cuda': net = torch.nn.DataParallel(net) cudnn.benchmark = True if args.resume: # load checkpoint. print('Resuming from checkpoint {}'.format(args.checkpoint)) assert os.path.isfile( args.checkpoint), 'Error: no checkpoint directory found!'
if __name__ == '__main__': import argparse parser = argparse.ArgumentParser() parser.add_argument('--gpu', '-g', type=str, default='0') parser.add_argument('--bsize', '-b', type=int, default=32) parser.add_argument('--model', '-m', type=str, default='VGG16') parser.add_argument('--epochs','-e', type=int, default=5) args = parser.parse_args() print("Parameters: ",args) BATCH_SIZE = args.bsize os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu chosed_model = config.model(args.model) EPOCHS = args.epochs data = pd.read_csv("Reinforced_mixed_benefits.csv") rows = np.asarray(data.iloc[:, :]) print("Start shuffling.") np.random.shuffle(rows) print("Shuffling finished.") train_data = rows[:int(0.8*(len(rows)))] val_data = rows[int(0.8*(len(rows))):] pd.DataFrame(val_data).to_csv("test_data.csv",header=0,index=False) train_generator = DataGenerator(datas=train_data,batch_size=BATCH_SIZE) val_generator = DataGenerator(datas=val_data,batch_size=BATCH_SIZE)
def main(): model_name = config.model() Model = import_model.import_model(model_name) # DATABASE DATABASE = config.data_name() DATABASE_PATH = config.data_root() + "/" + DATABASE # RESULTS result_folder = config.result_root() + '/' + DATABASE + '/' + Model.name() if not os.path.isdir(result_folder): os.makedirs(result_folder) # Parameters parameters = config.parameters(result_folder) if os.path.isfile(DATABASE_PATH + '/binary_piano'): parameters["binarize_piano"] = True else: parameters["binarize_piano"] = False if os.path.isfile(DATABASE_PATH + '/binary_orch'): parameters["binarize_orch"] = True else: parameters["binarize_orch"] = False parameters["model_name"] = model_name # Load the database metadata and add them to the script parameters to keep a record of the data processing pipeline parameters.update(pkl.load(open(DATABASE_PATH + '/metadata.pkl', 'rb'))) ############################################################ # Logging ############################################################ # log file log_file_path = 'log' # set up logging to file - see previous section for more details logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M', filename=log_file_path, filemode='w') # define a Handler which writes INFO messages or higher to the sys.stderr console = logging.StreamHandler() console.setLevel(logging.INFO) # set a format which is simpler for console use formatter = logging.Formatter('%(levelname)-8s %(message)s') # tell the handler to use this format console.setFormatter(formatter) # add the handler to the root logger logging.getLogger('').addHandler(console) # Now, we can log to the root logger, or any other logger. First the root... logging.info('#' * 60) logging.info('#' * 60) logging.info('#' * 60) logging.info('* L * O * P *') logging.info('** Model : ' + Model.name()) for k, v in parameters.items(): logging.info('** ' + k + ' : ' + str(v)) logging.info('#' * 60) logging.info('#' * 60) ############################################################ # Hyper parameter space ############################################################ # Two cases : # 1/ Random search model_parameters_space = Model.get_hp_space() # 2/ Defined configurations configs = config.import_configs() ############################################################ # Grid search loop ############################################################ # Organisation : # Each config is a folder with a random ID (integer) # In eahc of this folder there is : # - a config.pkl file with the hyper-parameter space # - a result.txt file with the result # The result.csv file containing id;result is created from the directory, rebuilt from time to time if DEFINED_CONFIG: for config_id, model_parameters in configs.items(): config_folder = parameters['result_folder'] + '/' + config_id if os.path.isdir(config_folder): shutil.rmtree(config_folder) os.mkdir(config_folder) config_loop(Model, config_folder, model_parameters, parameters, DATABASE_PATH) else: # Already tested configs list_config_folders = glob.glob(result_folder + '/*') number_hp_config = max( 0, parameters["max_hyperparam_configs"] - len(list_config_folders)) for hp_config in range(number_hp_config): # Give a random ID and create folder ID_SET = False while not ID_SET: ID_config = str(random.randint(0, 2**25)) config_folder = parameters['result_folder'] + '/' + ID_config if config_folder not in list_config_folders: ID_SET = True os.mkdir(config_folder) # Sample model parameters from hyperparam space model_parameters = hyperopt.pyll.stochastic.sample( model_parameters_space) config_loop(Model, config_folder, model_parameters, parameters, DATABASE_PATH) # Update folder list list_config_folders.append(config_folder) return
def main(): # check cuda available assert torch.cuda.is_available() == True # when the input dimension doesnot change, add this flag to speed up cudnn.benchmark = True num_classes = config.num_classes[config.problem_type] # input are RGB images in size 3 * h * w # output are binary model = config.model(3, num_classes) # data parallel model = nn.DataParallel(model, device_ids=config.device_ids).cuda() # loss function if num_classes == 2: loss = LossBinary(jaccard_weight=config.jaccard_weight) valid_metric = validation_binary else: loss = LossMulti(num_classes=num_classes, jaccard_weight=config.jaccard_weight) valid_metric = validation_multi # train/valid filenmaes train_filenames, valid_filenames = trainval_split(config.fold) print('num of train / validation files = {} / {}'.format( len(train_filenames), len(valid_filenames))) # trainset transform train_transform = Compose([ Resize(height=config.train_height, width=config.train_width, p=1), Normalize(p=1) ], p=1) # validset transform valid_transform = Compose([ Resize(height=config.train_height, width=config.train_width, p=1), Normalize(p=1) ], p=1) # train dataloader train_loader = DataLoader(dataset=RobotSegDataset( train_filenames, transform=train_transform), shuffle=True, num_workers=config.num_workers, batch_size=config.batch_size, pin_memory=True) # valid dataloader valid_loader = DataLoader( dataset=RobotSegDataset(valid_filenames, transform=valid_transform), shuffle=True, num_workers=config.num_workers, batch_size=len( config.device_ids), # in valid time use one img for each dataset pin_memory=True) train(model=model, loss_func=loss, train_loader=train_loader, valid_loader=valid_loader, valid_metric=valid_metric, fold=config.fold, num_classes=num_classes)