def main(opt): # Check you can write to output path directory if not os.access(os.path.split(opt.model_path)[0], os.W_OK): raise OSError("--model_path is not a writeable path: %s" % opt.model_path) # Import dataset dataset = import_ham_dataset(dataset_root=opt.dataroot, training=opt.training, model_path=os.path.split(opt.model_path)[0]) dataloader = torch.utils.data.DataLoader(dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.workers) n_class = dataset.NUM_CLASS # Load InceptionV3 network model = models.inception_v3(pretrained=True) # Freeze all layers for params in model.parameters(): params.requires_grad = False # Stage-2 , Freeze all the layers till "Conv2d_4a_3*3" ct = [] for name, child in model.named_children(): if "Conv2d_4a_3x3" in ct: for params in child.parameters(): params.requires_grad = True ct.append(name) # Replace final layer num_ftrs = model.fc.in_features model.fc = nn.Linear(num_ftrs, n_class) # Print network layer architecture for name, child in model.named_children(): for name2, params in child.named_parameters(): print(name, name2, 'trainable=%r' % params.requires_grad) if opt.cuda and torch.cuda.is_available(): device = torch.device("cuda:0") else: device = torch.device("cpu") print("Using", device) model.to(device) # Move model to device # Model training parameters criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(list(filter(lambda p: p.requires_grad, model.parameters())), lr=0.001, momentum=0.9) scheduler = lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1) # Initiate TensorBoard logger logger_tensorboard = TensorboardLogger(log_dir=os.path.split(opt.model_path)[0]) # # Training if opt.training: train_model(model, dataloader, len(dataset), criterion, optimizer, scheduler, device, opt.model_path, logger_tensorboard, num_epochs=opt.epochs) # # Testing else: model.load_state_dict(torch.load(opt.model_path)) test_model(model, dataloader, len(dataset), criterion, device)
def main(args): set_seeds(322) args = get_args(args) dataset = Dataset(args) layers = [200, 600, dataset.n_items] args.z_dim = layers[0] args.l2_coeff = 0. if args.model == 'MultiVAE': model = MultiVAE(layers, args=args).to(args.device) metric_values = train_model(model, dataset, args) elif args.model == 'MultiDAE': args.l2_coeff = 0.01 / args.train_batch_size model = MultiDAE([200, dataset.n_items], args=args).to(args.device) metric_values = train_model(model, dataset, args) elif args.model == 'Multi_our_VAE': model = Multi_our_VAE(layers, args=args).to(args.device) metric_values = train_met_model(model, dataset, args) elif args.model == 'MultiHoffmanVAE': model = MultiHoffmanVAE(layers, args=args).to(args.device) metric_values = train_hoffman_model(model, dataset, args) elif args.model == 'Multi_ourHoffman_VAE': model = Multi_ourHoffman_VAE(layers, args=args).to(args.device) metric_values = train_methoffman_model(model, dataset, args) np.savetxt( "../logs/metrics_{}_{}_K_{}_N_{}_learnreverse_{}_anneal_{}_lrdec_{}_lrenc_{}.txt" .format(args.data, args.model, args.K, args.N, args.learnable_reverse, args.annealing, args.lrdec, args.lrenc), np.array(metric_values)) with open("../logs/log.txt", "a") as myfile: myfile.write("!!Success!! \n \n \n \n".format(args)) print('Success!')
def main(overwrite=False): # convert input images into an hdf5 file if overwrite or not os.path.exists(config["data_file"]): training_files, subject_ids = fetch_training_data_files( return_subject_ids=True) write_data_to_file(training_files, config["data_file"], image_shape=config["image_shape"], subject_ids=subject_ids) data_file_opened = open_data_file(config["data_file"]) if not overwrite and os.path.exists(config["model_file"]): model = load_old_model(config["model_file"]) else: # instantiate new model model = is_model(input_shape=config["input_shape"], n_labels=config["n_labels"], initial_learning_rate=config["initial_learning_rate"], n_base_filters=config["n_base_filters"]) # get training and testing generators train_generator, validation_generator, n_train_steps, n_validation_steps = get_training_and_validation_generators( data_file_opened, batch_size=config["batch_size"], data_split=config["validation_split"], overwrite=overwrite, validation_keys_file=config["validation_file"], training_keys_file=config["training_file"], n_labels=config["n_labels"], labels=config["labels"], patch_shape=config["patch_shape"], validation_batch_size=config["validation_batch_size"], validation_patch_overlap=config["validation_patch_overlap"], training_patch_start_offset=config["training_patch_start_offset"], permute=config["permute"], augment=config["augment"], skip_blank=config["skip_blank"], augment_flip=config["flip"], augment_distortion_factor=config["distort"]) # run training train_model(model=model, model_file=config["model_file"], training_generator=train_generator, validation_generator=validation_generator, steps_per_epoch=n_train_steps, validation_steps=n_validation_steps, initial_learning_rate=config["initial_learning_rate"], learning_rate_drop=config["learning_rate_drop"], learning_rate_patience=config["patience"], early_stopping_patience=config["early_stop"], n_epochs=config["n_epochs"]) data_file_opened.close()
def main(_): print("Start preprocessing data...") if FLAGS.actions == "random": data = data_preprocessing.data_prep(FLAGS.dataset, FLAGS.num_actions, FLAGS.total_num_actions) else: actions = FLAGS.actions.split(",") data = data_preprocessing.data_prep(FLAGS.dataset, FLAGS.num_actions, FLAGS.total_num_actions, actions) video_dir = os.path.normpath( os.path.join(FLAGS.video_dir, FLAGS.dataset, "{0}_actions".format(FLAGS.num_actions), '_'.join(data.actions))) tf.reset_default_graph() print("Create model...") model = seq2seq_model.Seq2SeqModel(len(data.dim_use), FLAGS.source_seq_len, FLAGS.target_seq_len, FLAGS.rnn_size, FLAGS.batch_size, FLAGS.learning_rate) sess = training.get_session() #perform segmentations with pre-trained model if FLAGS.load > 0: model = training.load_model(sess, model, train_dir, FLAGS.load) else: #train new model if FLAGS.load <= 0: current_step = 0 print("Creating model with fresh parameters.") sess.run(tf.global_variables_initializer()) #continue training given a checkpoint else: current_step = FLAGS.load + 1 model = training.load_model(sess, model, train_dir, FLAGS.load) print("Training is in process...") training.train_model(sess, model, train_dir, data, model.batch_size, current_step, FLAGS.iterations) print("Finding temporal segments...") test_states, all_states, cuts = segmentation.find_cuts( sess, model, data.norm_complete_train) print("Doing clustering...") pred_labels, reduced_states, labels_true, all_labels = segmentation.clustering( model, cuts, test_states, all_states, data.trainData, FLAGS.num_actions) labels_true, labels_pred = segmentation.order_labels( labels_true, all_labels) colors = viz.get_color(labels_true) xyz_gt = get_gt(data.complete_train) print("Generate results...") print("length of gt:{0}, pred:{1},reduced:{2}:".format( len(labels_true), len(labels_pred), len(reduced_states))) generate_video(video_dir, labels_true, labels_pred, xyz_gt, reduced_states, colors, FLAGS.gen_video)
def main(argv=None): print("begin:") model = unet_2d.unet_model_2d_attention([256, 256, 3], 21, batch_normalization=True) voc = voc_reader.voc_reader(256, 256, 8, 8) batch_size = 8 steps_per_epoch = 1464 // batch_size validation_steps = 1449 // batch_size training.train_model(model, "model_File", training.train_generator_data(voc), training.val_generator_data(voc), steps_per_epoch, validation_steps)
def run_autoencoder_model_experiment(model, dataset_dir, exp_name, batch_size=32, epochs=200, steps_per_epoch=100, validation_steps=20, early_stop_patience=15, evaluation_steps=500, experiments_dir="experiments", tensorboard_logs_dir="tensorboard_logs", earlystop_metric="loss", checkpoint_metric="val_binary_accuracy"): outfiles_dir = os.path.join(experiments_dir, exp_name) tensorboard_logdir = os.path.join(tensorboard_logs_dir, exp_name) metrics_cols = [' '.join([word.capitalize() for word in metric.split('_')]) for metric in model.metrics_names] metrics_df = pd.DataFrame(columns=["Fold", "Set"] + metrics_cols) n_folds = len(os.listdir(dataset_dir)) with tempfile.TemporaryDirectory() as temp_dir: init_weights_file = os.path.join(temp_dir, "init_weights.h5") temp_weights_file = os.path.join(temp_dir, "temp_weights.h5") model.save_weights(init_weights_file) for i in range(n_folds): fold_name = "fold_{}".format(i) folds_files = glob(os.path.join(dataset_dir, fold_name, "fold_*.txt")) model.load_weights(init_weights_file) cur_outfiles_dir = os.path.join(outfiles_dir, fold_name) if not os.path.exists(cur_outfiles_dir): os.makedirs(cur_outfiles_dir) cur_tensorboard_logdir = os.path.join(tensorboard_logdir, fold_name) if not os.path.exists(cur_tensorboard_logdir): os.makedirs(cur_tensorboard_logdir) train_datagen = FacePairGenerator([folds_files[j] for j in range(len(folds_files)) if j != i], batch_size=batch_size) test_datagen = FacePairGenerator([folds_files[i]], batch_size=batch_size) train_model(model, train_datagen, test_datagen, epochs=epochs, steps_per_epoch=steps_per_epoch, validation_steps=validation_steps, early_stop_patience=early_stop_patience, tensorboard_logdir=cur_tensorboard_logdir, best_model_filepath=temp_weights_file, earlystop_metric=earlystop_metric, checkpoint_metric=checkpoint_metric) model.load_weights(temp_weights_file) train_metrics, val_metrics = evaluate_model(model, train_datagen, test_datagen, evaluation_steps=evaluation_steps) model.save(os.path.join(cur_outfiles_dir, "best_model.h5"), overwrite=True, include_optimizer=False, save_format='h5') cur_metrics_df = pd.DataFrame([train_metrics, val_metrics], columns=metrics_cols) cur_metrics_df.insert(0, "Set", ["Train", "Val"]) cur_metrics_df.to_csv(os.path.join(cur_outfiles_dir, "metrics.csv"), index=False) cur_metrics_df.insert(0, "Fold", [i, i]) metrics_df = pd.concat([metrics_df, cur_metrics_df], ignore_index=True) metrics_df.to_csv(os.path.join(outfiles_dir, "metrics.csv"), index=False)
def optuna_objective(trial): # args.lr = trial.suggest_loguniform('lr', 1e-4, 1e-2) # args.optimizer = trial.suggest_categorical('optimizer', ['Adam', 'SDG', 'RMSprop', 'Nadam']) args.batch_size = trial.suggest_categorical( 'batch_size', [4, 8, 16]) args.layers = trial.suggest_categorical('layers', [1, 2, 3]) args.units = trial.suggest_categorical('units', [25, 50, 100]) args.dropout = trial.suggest_categorical( 'dropout', [0.1, 0.2, 0.5]) # args.dropout_only_last = trial.suggest_categorical('dropout_only_last', [True, False]) args.attention_first = trial.suggest_categorical( 'attention_first', [True, False]) # args.attention_middle = trial.suggest_categorical('attention_middle', [True, False]) test_results, val_results = train_model( args, x, y, args.file_desc, args.patience, args.folds, units=args.units, undersample=args.no_undersample is False, augment_train=args.no_augment is False, optimizing=True) return np.mean(val_results[:, 3])
def main(): print('loading training data.....') data_file_opened, train_list, train_name = get_data(config['data_fpath']) config_file = open(config['training_config_file'], 'a') config_file.writelines('train_nii: ' + ' / '.join(train_name)) del train_name config_file.close() if config["model_file"]: print('load pre_train_model....') model = load_old_model(config["model_file"]) else: print('build the new mode.....') model = Unet(input_size=config['input_size'], first_filter_num=config['initial_filter_num'], weight_decay=config['l2_regular'], batch_norm=config['bn'], deconv=config['deconv'], dropout_rate=config['drop'], deeper=config['deeper_4'], nb_classes=config['nb_classes'], initial_learning_rate=config['initial_lr'], activate_fun=config['activation_fun'], multi_gpu=multi_gpu_num, use_Adam=config["use_Adam"]) # get training and testing generators print('get training and testing generators....') train_generator, validation_generator, n_train_steps, n_validation_steps = get_training_and_validation_generators( data_file_opened, patch_shape=config["patch_shape"], batch_size=config["batch_size"], n_labels=config['nb_classes'], training_list=train_list, validation_list=None, val_split=config["validation_split"], binary_num_rate=config["binary_num_rate"], min_point=config["min_point"], pos_num_rate=config["pos_num_rate"], nag_num_rate=config["nag_num_rate"], validation_batch_size=config["validation_batch_size"], augment=config["augment"], augment_flip=config["flip"], augment_distortion_factor=config["distort"]) # run training print('training is going on...') model = train_model(model=model, save_path=config['save_fpath'], training_generator=train_generator, validation_generator=validation_generator, steps_per_epoch=n_train_steps, validation_steps=n_validation_steps, initial_learning_rate=config["initial_lr"], learning_rate_drop=config["learning_rate_drop"], learning_rate_epochs=config['learning_rate_epochs'], n_epochs=config["n_epochs"], early_stopping_patience=config["early_stop"])
def train(directory): """ Creates features dataset from raw data and trains a model the transformed data Parameters directory: string with absolute directory path of training data files """ #load training data and aggregate from "time" series to regular data train = prep.create_featureframe(raw_path=filespath + "\\data\\features", label_path=filespath + "\\data\\labels", labels=True) #export created file to csv train.to_csv('fframe.csv') train = pd.DataFrame.from_csv('fframe.csv') #create and save model file(s) training.train_model(train)
def main(overwrite=False): # convert input images into an hdf5 file data_file_opened = open_data_file(config["data_file"]) model = model_3d_1(input_shape=config["input_shape"], initial_learning_rate=config["initial_learning_rate"], opt=args.opt ) if not overwrite and os.path.exists(config["model_file"]): print('load model !!') load_old_model(config["model_file"], model) # get training and testing generators train_generator, validation_generator, n_train_steps, n_validation_steps = get_training_and_validation_generators( data_file_opened, batch_size=config["batch_size"], data_split=config["validation_split"], overwrite=overwrite, validation_keys_file=config["validation_file"], training_keys_file=config["training_file"], patch_shape=config["patch_shape"], validation_batch_size=config["validation_batch_size"], validation_patch_overlap=config["validation_patch_overlap"], training_patch_start_offset=config["training_patch_start_offset"], ) # run training train_model(model=model, model_file=config["model_file"], training_generator=train_generator, validation_generator=validation_generator, steps_per_epoch=n_train_steps, validation_steps=n_validation_steps, initial_learning_rate=config["initial_learning_rate"], learning_rate_drop=config["learning_rate_drop"], learning_rate_patience=config["patience"], early_stopping_patience=config["early_stop"], n_epochs=config["n_epochs"]) data_file_opened.close()
def run_experiment(parser, use_gpu): # parse experiment specific command line arguments parser.add_argument('--learning-rate', dest='learning_rate', type=float, default=0.001, help='Learning rate to use during training.') args, _unknown = parser.parse_known_args() # pre-process data process_raw_data(use_gpu, force_pre_processing_overwrite=False) start_compute_grad = time.time() for path in data_paths: # run experiment training_file = "data/preprocessed/training_" + path + ".hdf5" validation_file = "data/preprocessed/validation.hdf5" if args.skenario is 1: model = RGN(embedding_size=42, use_gpu=use_gpu, minibatch_size=args.minibatch_size, pretraining=-1) elif args.skenario is 2: model = UTGN(embedding_size=42, use_gpu=use_gpu, batch_size=args.minibatch_size, pretraining=-1) elif args.skenario is 3: model = RGN(embedding_size=768 + 21, use_gpu=use_gpu, minibatch_size=args.minibatch_size, use_pssm=False, use_token=True) elif args.skenario is 4: model = UTGN(embedding_size=768 + 21, use_gpu=use_gpu, batch_size=args.minibatch_size, use_pssm=False, use_token=True) elif args.skenario is 5: model = RGN(embedding_size=21, use_gpu=use_gpu, minibatch_size=args.minibatch_size, pretraining=-1, use_pssm=False) elif args.skenario is 6: model = UTGN(embedding_size=21, use_gpu=use_gpu, batch_size=args.minibatch_size, pretraining=-1, use_pssm=False) elif args.skenario is 7: model = RGN(embedding_size=768, use_gpu=use_gpu, minibatch_size=args.minibatch_size, use_aa=False, use_pssm=False, use_token=True) elif args.skenario is 8: model = UTGN(embedding_size=768, use_gpu=use_gpu, batch_size=args.minibatch_size, use_aa=False, use_pssm=False, use_token=True) train_loader = contruct_dataloader_from_disk(training_file, args.minibatch_size) validation_loader = contruct_dataloader_from_disk(validation_file, args.minibatch_size) identifier = "skenario{0}".format(args.skenario) train_model_path = train_model( data_set_identifier=identifier, model=model, train_loader=train_loader, validation_loader=validation_loader, learning_rate=args.learning_rate, minibatch_size=args.minibatch_size, eval_interval=args.eval_interval, hide_ui=args.hide_ui, use_gpu=use_gpu, optimizer_type=args.optimizer_type, restart=args.restart, minimum_updates=args.minimum_updates) print(train_model_path) end = time.time() print("Training time:", end - start_compute_grad)
def train(self, data): es = keras.callbacks.EarlyStopping(monitor="val_loss", mode='min', patience=self.config["PATIENCE"]) self.loss, self.acc, self.history = train_model(self.model, data, self.config, has_acc=self.predictModel, cb_list=[es]) best_epoch(self.history, has_acc=self.predictModel) if self.predictModel: print('{} test accuracy: {:.3f}'.format(self.model.name, self.acc))
def training_stage(action, args): try: dataset = DATASETS[args.dataset] except KeyError: if not os.path.exists(args.dataset): raise Exception("Please specify a valid dataset id or path.") filename = os.path.split(args.dataset)[-1] dataset = Dataset( filename=filename, filepath=args.dataset, lang=args.language ) if action == "preprocess": if args.out: dataset = dataset._replace(preprocessed_filepath=args.out) get_training_file( dataset=dataset, use_cache=False, lemmatize=False, remove_stopwords=True, progressbar=False if args.no_pb else True, tokenizer=args.tokenizer, workers=args.workers, chunk_size=args.chunk_size ) elif action == "train": train_model( dataset=dataset, model_type=args.model, use_cache=True, dims=args.dims, window=args.window, workers=args.workers, model_filepath=args.out )
def job(): students_image_count_obj = {} try: for username in os.listdir(constants.DATASET_PATH): concatenated_dir = constants.DATASET_PATH + "/" + username if os.path.isdir(concatenated_dir): students_image_count_obj[username] = len([ file for file in os.listdir(concatenated_dir) if (os.path.isfile(concatenated_dir + "/" + file) and os.path.splitext(file) [1].lower() == constants.SUPPORTED_FILE_TYPE) ]) start_training = True for username in students_image_count_obj.keys(): if (students_image_count_obj[username] != constants.USER_TRAINING_IMAGE_COUNT): start_training = False break # check if any new user is added, i.e. is there really any need of training again. if start_training: students_count = len(students_image_count_obj.keys()) if students_count > constants.ALREADY_TRAINED_STUDENTS_COUNT: constants.ALREADY_TRAINED_STUDENTS_COUNT = students_count else: log.info("Training terminated to avoid redundant trainings.") start_training = False else: log.info( "Training didn't start because of insufficient number of images." ) log.info("Metadata: " + str(students_image_count_obj)) if start_training: log.info("Initialising model's training.") extract_embeddings() train_model() except KeyboardInterrupt: log.error("Training process' polling job interrupted.")
def main(): raw_lst = processing.get_raw_data() names_lst = processing.get_raw_names() for idx in range(len(raw_lst)): dataset_name = names_lst[idx] X, y, target_names = processing.process_data(raw_lst[idx]) model_dict = training.train_model(X, y, target_names, dataset_name) training.print_elapsed_time(model_dict) reporting.produce_report(model_dict)
def execute(): model = create_model() base_dir: str = '/Users/Jan/Developer/ML/dogs/dataset' train_generator, val_generator = create_generators(f'{base_dir}/train', f'{base_dir}/val', f'{base_dir}/test') history = train_model(train_generator, val_generator, model) display_progress(history) print(history)
def run_experiment(parser, use_gpu): # parse experiment specific command line arguments parser.add_argument('--learning-rate', dest='learning_rate', type=float, default=0.01, help='Learning rate to use during training.') parser.add_argument('--min-updates', dest='minimum_updates', type=int, default=1000, help='Minimum number of minibatch iterations.') parser.add_argument('--minibatch-size', dest='minibatch_size', type=int, default=1, help='Size of each minibatch.') args, _unknown = parser.parse_known_args() # pre-process data process_raw_data(use_gpu, force_pre_processing_overwrite=False) # run experiment training_file = "data/preprocessed/single_protein.txt.hdf5" validation_file = "data/preprocessed/single_protein.txt.hdf5" model = ExampleModel(21, args.minibatch_size, use_gpu=use_gpu) # embed size = 21 train_loader = contruct_dataloader_from_disk(training_file, args.minibatch_size) validation_loader = contruct_dataloader_from_disk(validation_file, args.minibatch_size) train_model_path = train_model(data_set_identifier="TRAIN", model=model, train_loader=train_loader, validation_loader=validation_loader, learning_rate=args.learning_rate, minibatch_size=args.minibatch_size, eval_interval=args.eval_interval, hide_ui=args.hide_ui, use_gpu=use_gpu, minimum_updates=args.minimum_updates) print("Completed training, trained model stored at:") print(train_model_path)
def train_in_batch(server_name, suff, kbase_id1, lang_code, org_id, token): training_id_fname = "training_ids.txt" print("---------------------TRAINING KBASE----------------------") training_id = training.train_model(server_name, suff, kbase_id1, lang_code, org_id, token) print(training_id) out_string = training_id + "\n" if not os.path.exists(training_id_fname): print("Case 1") with open(training_id_fname, 'w') as file: file.write(out_string) else: with open(training_id_fname, 'a') as file: file.write(out_string) status_code = "" while status_code.lower() != "succeeded": print("---------------------VIEW TRAINING STATUS-------------------") resp_json = training.view_trained_model(server_name, suff, kbase_id1, lang_code, training_id, org_id, token) status_code = resp_json["status"].lower() if status_code == 'failed': print("resp_json: ", resp_json) print("status_code: ", status_code) print("errorMessage: ", resp_json["errorMessage"]) error_message = resp_json["errorMessage"] index_words = error_message.index("-words") index_start = index_words + len("-words") substr_doc_id = error_message[index_start:] resp_doc = documents.view_doc(server_name, suff, kbase_id1, lang_code, substr_doc_id, org_id, token) print("Document failed question: ", resp_doc["faq"]["question"]) print("Document failed answer: ", resp_doc["faq"]["answer"]) return else: print("status_code: ", status_code) time.sleep(10)
def run_experiment(parser, use_gpu): # parse experiment specific command line arguments parser.add_argument('--learning-rate', dest='learning_rate', type=float, default=0.01, help='Learning rate to use during training.') parser.add_argument( '--input-file', dest='input_file', type=str, default='data/preprocessed/protein_net_testfile.txt.hdf5') args, _unknown = parser.parse_known_args() # pre-process data process_raw_data(use_gpu, force_pre_processing_overwrite=False) # run experiment training_file = args.input_file validation_file = args.input_file model = MyModel(21, use_gpu=use_gpu) # embed size = 21 train_loader = contruct_dataloader_from_disk(training_file, args.minibatch_size) validation_loader = contruct_dataloader_from_disk(validation_file, args.minibatch_size) train_model_path = train_model(data_set_identifier="TRAIN", model=model, train_loader=train_loader, validation_loader=validation_loader, learning_rate=args.learning_rate, minibatch_size=args.minibatch_size, eval_interval=args.eval_interval, hide_ui=args.hide_ui, use_gpu=use_gpu, minimum_updates=args.minimum_updates) print("Completed training, trained model stored at:") print(train_model_path)
def run_experiment(parser, use_gpu): # parse experiment specific command line arguments parser.add_argument('--learning-rate', dest='learning_rate', type=float, default=0.01, help='Learning rate to use during training.') args, _unknown = parser.parse_known_args() # pre-process data process_raw_data(use_gpu, raw_data_root="data/raw/*", force_pre_processing_overwrite=False) # run experiment training_file = "data/preprocessed/train_sample.txt.hdf5" validation_file = "data/preprocessed/test_sample.txt.hdf5" model = ExampleModel(21, args.minibatch_size, use_gpu=use_gpu) # embed size = 21 train_loader = contruct_dataloader_from_disk(training_file, args.minibatch_size) validation_loader = contruct_dataloader_from_disk(validation_file, args.minibatch_size) train_model_path = train_model(data_set_identifier="TRAIN", model=model, train_loader=train_loader, validation_loader=validation_loader, learning_rate=args.learning_rate, minibatch_size=args.minibatch_size, eval_interval=args.eval_interval, hide_ui=args.hide_ui, use_gpu=use_gpu, minimum_updates=args.minimum_updates) print(train_model_path)
EPOCHS=20 LIM=1000 X_train, y_train = preprocess(train['price'], categories=CATEGORIES,units=UNITS, lookahead=LOOKAHEAD, vol_adjust=VOL_ADJUST ) X_dev, y_dev = preprocess(dev['price'], categories=CATEGORIES,units=UNITS, lookahead=LOOKAHEAD, vol_adjust=VOL_ADJUST) if LIM: X_train = X_train[:LIM] y_train = y_train[:LIM] X_dev = X_dev[:LIM] y_dev = y_dev[:LIM] model = build_model(X_train.shape[1], n_categories=CATEGORIES, loss='categorical_crossentropy') train_model(RUN_ID, model, X_train, y_train, epochs=EPOCHS) from keras.utils import np_utils from sklearn.metrics import confusion_matrix, accuracy_score, f1_score def report_performance(): y_pred = model.predict(X_dev.as_matrix(), batch_size=2000, verbose=2) pred_classes = np_utils.categorical_probas_to_classes(y_pred) conf_matrix = confusion_matrix(y_dev, pred_classes) print conf_matrix print "accuracy", accuracy_score(y_dev, pred_classes) print "f1", f1_score(y_dev, pred_classes, average='weighted') #sns.heatmap(conf_matrix) #plt.show()
if torch.cuda.is_available(): write_out("CUDA is available, using GPU") use_gpu = True # start web server start_dashboard_server() process_raw_data(use_gpu, force_pre_processing_overwrite=False) training_file = "data/preprocessed/sample.txt.hdf5" validation_file = "data/preprocessed/sample.txt.hdf5" testing_file = "data/preprocessed/testing.hdf5" model = ExampleModel(21, args.minibatch_size, use_gpu=use_gpu) # embed size = 21 train_loader = contruct_dataloader_from_disk(training_file, args.minibatch_size) validation_loader = contruct_dataloader_from_disk(validation_file, args.minibatch_size) train_model_path = train_model(data_set_identifier="TRAIN", model=model, train_loader=train_loader, validation_loader=validation_loader, learning_rate=args.learning_rate, minibatch_size=args.minibatch_size, eval_interval=args.eval_interval, hide_ui=args.hide_ui, use_gpu=use_gpu, minimum_updates=args.minimum_updates) print(train_model_path)
def run_experiment(parser, use_gpu): parser.add_argument('--minibatch-size-validation', dest='minibatch_size_validation', type=int, default=8, help='Size of each minibatch during evaluation.') parser.add_argument('--hidden-size', dest='hidden_size', type=int, default=64, help='Hidden size.') parser.add_argument('--learning-rate', dest='learning_rate', type=float, default=0.0002, help='Learning rate to use during training.') parser.add_argument('--cv-partition', dest='cv_partition', type=int, default=0, help='Run a particular cross validation rotation.') parser.add_argument('--model-mode', dest='model_mode', type=int, default=2, help='Which model to use.') parser.add_argument('--input-data', dest='input_data', type=str, default='data/raw/TMHMM3.train.3line.latest', help='Path of input data file.') parser.add_argument('--pre-trained-model-paths', dest='pre_trained_model_paths', type=str, default=None, help='Paths of pre-trained models.') parser.add_argument('--profile-path', dest='profile_path', type=str, default="", help='Profiles to use for embedding.') args, _unknown = parser.parse_known_args() result_matrices = np.zeros((5, 5), dtype=np.int64) if args.model_mode == 0: model_mode = TMHMM3Mode.LSTM elif args.model_mode == 1: model_mode = TMHMM3Mode.LSTM_CRF elif args.model_mode == 2: model_mode = TMHMM3Mode.LSTM_CRF_HMM elif args.model_mode == 3: model_mode = TMHMM3Mode.LSTM_CRF_MARG else: print("ERROR: No model defined") print("Using model:", model_mode) if args.profile_path != "": embedding = "PROFILE" else: embedding = "BLOSUM62" use_marg_prob = False all_prediction_data = [] for cv_partition in [0, 1, 2, 3, 4]: # prepare data sets train_set, val_set, test_set = load_data_from_disk(filename=args.input_data, partition_rotation=cv_partition) # topology data set train_set_topology = list(filter(lambda x: x[3] == 0 or x[3] == 1, train_set)) val_set_topology = list(filter(lambda x: x[3] == 0 or x[3] == 1, val_set)) test_set_topology = list(filter(lambda x: x[3] == 0 or x[3] == 1, test_set)) if not args.silent: print("Loaded ", len(train_set), "training,", len(val_set), "validation and", len(test_set), "test samples") print("Processing data...") pre_processed_path = "data/preprocessed/preprocessed_data_" + str( hashlib.sha256(args.input_data.encode()).hexdigest())[:8] + "_cv" \ + str(cv_partition) + ".pickle" if not os.path.isfile(pre_processed_path): input_data_processed = list([TMDataset.from_disk(set, use_gpu) for set in [train_set, val_set, test_set, train_set_topology, val_set_topology, test_set_topology]]) pickle.dump(input_data_processed, open(pre_processed_path, "wb")) input_data_processed = pickle.load(open(pre_processed_path, "rb")) train_preprocessed_set = input_data_processed[0] validation_preprocessed_set = input_data_processed[1] test_preprocessed_set = input_data_processed[2] train_preprocessed_set_topology = input_data_processed[3] validation_preprocessed_set_topology = input_data_processed[4] _test_preprocessed_set_topology = input_data_processed[5] print("Completed preprocessing of data...") train_loader = tm_contruct_dataloader_from_disk(train_preprocessed_set, args.minibatch_size, balance_classes=True) validation_loader = tm_contruct_dataloader_from_disk(validation_preprocessed_set, args.minibatch_size_validation, balance_classes=True) test_loader = tm_contruct_dataloader_from_disk( test_preprocessed_set if args.evaluate_on_test else validation_preprocessed_set, args.minibatch_size_validation) train_loader_topology = \ tm_contruct_dataloader_from_disk(train_preprocessed_set_topology, args.minibatch_size) validation_loader_topology = \ tm_contruct_dataloader_from_disk(validation_preprocessed_set_topology, args .minibatch_size_validation) type_predictor_model_path = None if args.pre_trained_model_paths is None: for (experiment_id, train_data, validation_data) in [ ("TRAIN_TYPE_CV" + str(cv_partition) + "-" + str(model_mode) + "-HS" + str(args.hidden_size) + "-F" + str(args.input_data.split(".")[-2]) + "-P" + str(args.profile_path.split("_")[-1]), train_loader, validation_loader), ("TRAIN_TOPOLOGY_CV" + str(cv_partition) + "-" + str(model_mode) + "-HS" + str(args.hidden_size) + "-F" + str(args.input_data.split(".")[-2]) + "-P" + str(args.profile_path.split("_")[-1]), train_loader_topology, validation_loader_topology)]: type_predictor = None if type_predictor_model_path is not None: type_predictor = load_model_from_disk(type_predictor_model_path, force_cpu=False) model = load_model_from_disk(type_predictor_model_path, force_cpu=False) model.type_classifier = type_predictor model.type_01loss_values = [] model.topology_01loss_values = [] else: model = TMHMM3( embedding, args.hidden_size, use_gpu, model_mode, use_marg_prob, type_predictor, args.profile_path) model_path = train_model(data_set_identifier=experiment_id, model=model, train_loader=train_data, validation_loader=validation_data, learning_rate=args.learning_rate, minibatch_size=args.minibatch_size, eval_interval=args.eval_interval, hide_ui=args.hide_ui, use_gpu=use_gpu, minimum_updates=args.minimum_updates) # let the GC collect the model del model write_out(model_path) # if we just trained a type predictor, save it for later if "TRAIN_TYPE" in experiment_id: type_predictor_model_path = model_path else: # use the pre-trained model model_path = args.pre_trained_model_paths.split(",")[cv_partition] # test model write_out("Testing model...") model = load_model_from_disk(model_path, force_cpu=False) _loss, json_data, prediction_data = model.evaluate_model(test_loader) all_prediction_data.append(post_process_prediction_data(prediction_data)) result_matrix = np.array(json_data['confusion_matrix']) result_matrices += result_matrix write_out(result_matrix) set_experiment_id( "TEST-" + str(model_mode) + "-HS" + str(args.hidden_size) + "-F" + str(args.input_data.split(".")[-2]), args.learning_rate, args.minibatch_size) write_out(result_matrices) write_prediction_data_to_disk("\n".join(all_prediction_data))
def run_experiment(parser, use_gpu): # parse experiment specific command line arguments parser.add_argument('--learning-rate', dest='learning_rate', type=float, default=0.001, help='Learning rate to use during training.') parser.add_argument('--embed-size', dest='embed_size', type=int, default=21, help='Embedding size.') args, _unknown = parser.parse_known_args() all_prediction_data = [] result_matrices = [] # pre-process data preprocessed_training_file = process_single_raw_data( training_file, use_gpu=use_gpu, force_pre_processing_overwrite=False) preprocessed_validation_file = process_single_raw_data( validation_file, use_gpu=use_gpu, force_pre_processing_overwrite=False) preprocessed_test_file = process_single_raw_data( test_file, use_gpu=use_gpu, force_pre_processing_overwrite=False) # run experiment # model = ExampleModel(args.embed_size, args.minibatch_size, use_gpu=use_gpu) # embed size = 21 # model = SimpleRCNN(args.embed_size, args.minibatch_size, use_gpu=use_gpu) # embed size = 21 model = DeepResRCNN_100(args.embed_size, args.minibatch_size, use_gpu=use_gpu) # embed size = 21 train_loader = contruct_dataloader_from_disk(preprocessed_training_file, args.minibatch_size) validation_loader = contruct_dataloader_from_disk( preprocessed_validation_file, args.minibatch_size) train_model_path = train_model(data_set_identifier="TRAIN", model=model, train_loader=train_loader, validation_loader=validation_loader, learning_rate=args.learning_rate, minibatch_size=args.minibatch_size, eval_interval=args.eval_interval, hide_ui=args.hide_ui, use_gpu=use_gpu, minimum_updates=args.minimum_updates) print(train_model_path) # test model test_loader = contruct_dataloader_from_disk(preprocessed_test_file, args.minibatch_size) write_out("Testing model...") model = load_model_from_disk(train_model_path, force_cpu=False) _loss, json_data, _ = model.evaluate_model(test_loader) all_prediction_data.append(json_data) # all_prediction_data.append(model.post_process_prediction_data(prediction_data)) result_matrix = np.array(json_data['confusion_matrix']) result_matrices += result_matrix write_out(result_matrix) set_experiment_id( "TEST-" + str(args.hidden_size) + "-F" + str(args.input_data.split(".")[-2]), args.learning_rate, args.minibatch_size) write_out(result_matrices) write_prediction_data_to_disk("\n".join(all_prediction_data))
from argparse import ArgumentParser from training import train_model if __name__ == '__main__': parser = ArgumentParser() parser.add_argument('--use_gpu', type=int, choices=[0, 1], default=0) parser.add_argument('--pre_trained', type=str, default=None) parser.add_argument('--label_dict', type=str, default='./data/y2_id_dic.txt') # parser.add_argument('--train_dataset', type=str, default='data/train.json') # parser.add_argument('--dev_dataset', type=str, default='data/dev.json') parser.add_argument('--embedding_size', type=int, default=300) parser.add_argument('--hidden_size', type=int, default=25) parser.add_argument('--dict_number', type=int, default=21128) parser.add_argument('--num_labels', type=int, default=53) parser.add_argument('--batch_size', type=int, default=128) parser.add_argument('--lr', type=float, default=1e-4) parser.add_argument('--epochs', type=int, default=50) #parser.add_argument('--save_model', type=str, default='models/bert.pt') option = parser.parse_args() train_model(option)
import os import torch.optim from data_loader import LabelledTextDS from models import FastText from plotting import * from training import train_model import pandas as pd num_epochs = 50 num_hidden = 40 # Number of hidden neurons in model dev = 'cuda' if torch.cuda.is_available( ) else 'cpu' # If you have a GPU installed, use that, otherwise CPU dataset = LabelledTextDS(os.path.join('data', 'labelled_movie_reviews.csv'), dev=dev) imdb_data = pd.read_csv('data/labelled_movie_reviews.csv') model = FastText( len(dataset.token_to_id) + 2, num_hidden, len(dataset.class_to_id)).to(dev) optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9) losses, accuracies = train_model(dataset, model, optimizer, num_epochs) torch.save(model, os.path.join('saved_models', 'classifier.pth')) print('') print_accuracies(accuracies) plot_losses(losses)
elif model == 'BasicLSTM': lstm = BasicLSTM(input_dim, 5, goal_dim, output_length=goal_length) lstm.to(device) lstm_optim = torch.optim.SGD(lstm.parameters(), lr=0.001, momentum=0.9) setup_kwargs['model'] = lstm setup_kwargs['optim'] = lstm_optim elif model == 'NTM_LSTM': memory_banks = 10 memory_dim = 20 ntm = NTM_LSTM(input_dim, 5, goal_dim, memory_banks, memory_dim, output_length=goal_length) ntm_optim = torch.optim.SGD(ntm.parameters(), lr=0.001) setup_kwargs['model'] = ntm setup_kwargs['optim'] = ntm_optim setup_kwargs['print_interval'] = 1e2 else: print("MODEL IS NOT RECOGNIZED! ERROR!") # Begin Training the Model! train_model(**setup_kwargs)
**kwargs) manualSeed = 9302 #random.randint(1, 10000) # fix seed print("Random Seed: ", manualSeed) random.seed(manualSeed) torch.manual_seed(manualSeed) g_config = get_config() model_dir = args.model_dir setupLogger(os.path.join(model_dir, 'log.txt')) g_config.model_dir = model_dir criterion = nn.HingeEmbeddingLoss() model = Siamese() # load model snapshot load_path = args.load_path if load_path is not '': snapshot = torch.load(load_path) # loadModelState(model, snapshot) model.load_state_dict(snapshot['state_dict']) logging('Model loaded from {}'.format(load_path)) train_model(model, criterion, train_loader, test_loader, g_config, use_cuda=False)
optimizer = torch.optim.SGD(model.parameters(), lr=lr,weight_decay=weightDecay,momentum=0.9) # lr should be set to 0.1 scheduler = torch.optim.lr_scheduler.StepLR(optimizer,step_size=20,gamma=0.1,verbose=True) else: weightDecay = 5e-5 optimizer = torch.optim.Adam(model.parameters(), lr=lr,weight_decay=weightDecay) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,'min',patience=1,factor=0.1,verbose=True) if resume_from_ckp: ckp_path = checkpoint_path ckp = torch.load(ckp_path, map_location=device) model.load_state_dict(ckp['state_dict']) optimizer.load_state_dict(ckp['optimizer']) scheduler.load_state_dict(ckp['scheduler']) start_epoch = ckp['epoch'] print("Resuming from checkpoint...") del ckp else: start_epoch = 0 if args.model == 'VDSR': model = train_model(model, optimizer, scheduler, num_epochs=num_epochs, start_epoch=start_epoch,checkpoint_dir=checkpoint_path,dataloaders=dataloaders,clip_norm=0.4,scheduler_no_arg=True) else: model = train_model(model, optimizer, scheduler, num_epochs=num_epochs, start_epoch=start_epoch,checkpoint_dir=checkpoint_path,dataloaders=dataloaders) filename = "./model/"+"trial"+str(trialNumber)+".pth" torch.save(model.state_dict(), filename) # %%
def fit(self, *args, **kwargs): ''' Train the model. See training.train_model for more details. ''' from training import train_model return train_model(self, *args, **kwargs)