def main(): haplotypes = True size = 100 info = DataGenerator(size) if haplotypes: print "\nOriginal Haplotypes:" print info min_size = 10 max_size = 20 min_distance = 0 max_distance = 5 error = 0 # currently working on easy algorithm overlap_chance = 0.5 # 50/50 chance info.create_string(min_size=min_size, max_size=max_size, min_distance=min_distance, max_distance=max_distance, error=error, overlap_chance=overlap_chance) def print_hap(haplotype, flipped): result = "" if not flipped: for H in haplotype: result += str(H) else: for H in haplotype: if H == 0: result += "1" else: result += "0" print result print "\n- Easy Algorithm -\n" assembled = EasyAssembly.assemble(info.reads, size) if haplotypes: print "Assembled haplotypes:" print_hap(assembled, flipped=False) print_hap(assembled, flipped=True) print "\n- Accuracy: 100% -"
elif alpha == 0.01: ## FOR 99% PIS n_std_devs = 2.575 else: raise Exception('ERROR unusual alpha') results_runs = [] run = 0 # X_train = [] # y_train = [] # X_val = [] # y_val = [] for run in range(0, n_runs): # generate data Gen = DataGenerator(type_in="boston") X_train, y_train, X_val, y_val = Gen.CreateData(n_samples=n_samples, seed_in=run, train_prop=train_prop, bound_limit=bound_limit, n_std_devs=n_std_devs) print('\n--- view data ---') Gen.ViewData(n_rows=5, hist=False, plot=False) X_boundary = [] y_boundary = [] y_pred_all = [] X_train_orig, y_train_orig = X_train, y_train
is_sk_run = 0 is_deep_NN = False # whether to make a 2 layer NN gp_results = [] ens_results = [] single_results = [] mc_results = [] hmc_results = [] sk_results = [] unc_ens_results = [] run_kls = [] for run_ in range(n_runs): print('\n\n ====== run:', run_, '======\n') # -- create data -- Gen = DataGenerator(type_in=data_set) X_train, y_train, X_val, y_val = Gen.CreateData(n_samples=n_samples, seed_in=run_ + 1000, train_prop=0.9) # X_train = X_train[0:2] # y_train = y_train[0:2] n_samples = X_train.shape[0] X_dim = X_train.shape[1] y_dim = 1 # this lets us test how gp changes when data duplicated # the effect is the same as over optimising a NN # which suggests there is a need to do early stopping # X_train_orig = X_train.copy() # y_train_orig = y_train.copy() # for i in range(50):
import torch from pytorch_pretrained_bert.modeling import * from DataGen import DataGenerator from model import BertBiLSTMCRF os.environ["CUDA_VISIBLE_DEVICES"] = "1" if __name__ == "__main__": BERT_PRETRAINED_PATH = "./multi_cased_L-12_H-768_A-12/" TRAIN_PATH = "/data/loclh2/QABot/data/train_analysis.txt" batch_size = 32 shuffle = False data_gen = DataGenerator(model=BertModel, model_name=BERT_PRETRAINED_PATH) train_gen = data_gen.get_generator(TRAIN_PATH, batch_size, shuffle=shuffle) for batch in train_gen: pass
is_bound_ideal = True is_y_rescale = True save_graphs = False in_ddof = 1 perc_or_norm = 'norm' lube_perc = 90. n_std_devs = 1.96 is_bound_val = False is_bound_train = True is_bound_indiv = False is_title = False var_plot = 0 bound_limit = 2. # generate data Gen = DataGenerator(type_in=type_in) X_train, y_train, X_val, y_val = Gen.CreateData(n_samples=n_samples, bound_limit=bound_limit) print('\n--- view data ---') Gen.ViewData(n_rows=5, hist=False, plot=False) for i in range(0, len(params_in)): # start session tf.reset_default_graph() sess = tf.Session() # sess.run(tf.global_variables_initializer()) # sess = tf.InteractiveSession() # tf.global_variables_initializer().run() # init variables print('--- loop:', i, '---\nparams: ', params_in[i])
padding='same', name='final_3x3_conv_blk', activation='softmax')(PPM) return output #Print the current working directory for a quick sanity check cwd = os.getcwd() #Use when running on local runtime cwd = os.path.join(cwd, 'Data') print(cwd) #Get the variables train_pairs = get_image_pair_fnames(cwd, 'train') val_pairs = get_image_pair_fnames(cwd, 'val') params = {'dims': (256, 256, 3), 'batch_size': 32, 'shuffle': True} train_datagen = DataGenerator(train_pairs, **params) val_datagen = DataGenerator(val_pairs, **params) print('ho') #Now we build the model #We begin by defining the ResNet101 to be used in the netowrk pre_trained_model = ResNet50(input_shape=(256, 256, 3), include_top=False, weights=None) output = Model_PSP(pre_trained_model, num_classes=35) #We plot the model for better clarity #Compile the model and check summary/plot it model = models.Model(pre_trained_model.input, output) model.compile(optimizer='adam', loss="categorical_crossentropy", metrics=['acc', iou_coef, dice_coef])
# pre calcs if alpha == 0.05: n_std_devs = 1.96 elif alpha == 0.10: n_std_devs = 1.645 elif alpha == 0.01: n_std_devs = 2.575 else: raise Exception('ERROR unusual alpha') results_runs = [] run = 0 for run in range(0, n_runs): # generate data Gen = DataGenerator(type_in=type_in) X_train, y_train, X_val, y_val = Gen.CreateData(n_samples=n_samples, seed_in=run, train_prop=train_prop, bound_limit=bound_limit, n_std_devs=n_std_devs) # print('\n--- view data ---') # Gen.ViewData(n_rows=5, hist=False, plot=False) X_boundary = [] y_boundary = [] y_pred_all = [] X_train_orig, y_train_orig = X_train, y_train for b in range(0, n_bootstraps):
def load_model(save_path): with open(save_path, 'rb') as f: data = pickle.load(f) return data["model"] if __name__ == "__main__": PRETRAINED_MODEL = "models/" BERT_PRETRAINED_PATH = "./multi_cased_L-12_H-768_A-12/" #VALID_PATH = "/data/loclh2/QABot/data/test_analysis.txt" batch_size = 32 shuffle = True use_cuda = True data_gen = DataGenerator(model=BertModel, model_name=BERT_PRETRAINED_PATH) #model = BertBiLSTMCRF.create(16, # len(data_gen.rel_list), # BERT_PRETRAINED_PATH, # freeze=True, # rnn_layers=2, # input_dropout=0.1, # use_cuda=use_cuda, # hidden_size=64, # label_embedding_size=64, # enc_hidden_dim=64, # activation="tanh") # model.load_state_dict(torch.load(PRETRAINED_MODEL))
def train(dataset, alpha_values, params): runs = params['n_runs'] # number of runs h_size = params['h_size'] # number of hidden units n_epoch = params['epochs'] # number epochs to train for l_rate = params['lr'] # learning rate of optimizer decay_rate = params['decay_rate'] # learning rate decay lambda_in = params['lambda_in'] # lambda_in param in the loss sigma_in = params['sigma_in'] # initialize std dev of NN weights soften = params['soften'] # soften param in the loss patience = params['patience'] # patience is_early_stop = patience != -1 n_ensemble = 5 if dataset == 'YearPredictionMSD': n_batch = 1000 # batch size out_biases = [5., -5.] else: n_batch = 100 # batch size out_biases = [3., -3.] qd_metrics_per_alpha = [] piven_metrics_per_alpha = [] print(f"Dataset = {dataset}, runs = {runs}, epochs = {n_epoch}\n") print("Started...") for alpha in alpha_values: qd_metrics_per_run = [] piven_metrics_per_run = [] for run in range(1, runs + 1): # fix seed seed = run np.random.seed(seed) tf.random.set_random_seed(seed) # ensemble results qd_y_pred_all = [] piven_y_pred_all = [] # create data gen_data = DataGenerator(dataset_name=dataset) X_train, y_train, X_val, y_val = gen_data.create_data(seed_in=seed) for i in range(n_ensemble): tf.reset_default_graph() with tf.Session() as qd_sess: # create qd network qd_model = TfNetwork(x_size=X_train.shape[1], y_size=2, h_size=h_size, alpha=alpha, soften=soften, lambda_in=lambda_in, sigma_in=sigma_in, out_biases=out_biases, method='qd', patience=patience, dataset=dataset) # train qd print( f"\nalpha = {alpha}, run = {run}, ensemble = {i + 1}, QD training..." ) qd_model.train(qd_sess, X_train, y_train, X_val, y_val, n_epoch=n_epoch, l_rate=l_rate, decay_rate=decay_rate, is_early_stop=is_early_stop, n_batch=n_batch) # predict on X_val _, y_pred_qd = qd_model.predict(qd_sess, X_test=X_val, y_test=y_val) qd_y_pred_all.append(y_pred_qd) y_u_qd, y_l_qd, y_qd = ensemble_to_prediction(qd_y_pred_all, alpha, method='qd') # calc metrics y_val_0 = y_val[:, 0] qd_picp, qd_mpiw = picp_mpiw(y_l_qd, y_u_qd, y_val_0) mse_qd = round( mean_squared_error(gen_data.scale_c * y_val_0, gen_data.scale_c * y_qd), 3) qd_metrics_per_run.append([qd_picp, qd_mpiw, mse_qd**0.5]) for i in range(n_ensemble): tf.reset_default_graph() with tf.Session() as piven_sess: # create piven network piven_model = TfNetwork(x_size=X_train.shape[1], y_size=2, h_size=h_size, alpha=alpha, soften=soften, lambda_in=lambda_in, sigma_in=sigma_in, out_biases=out_biases, method='piven', patience=patience, dataset=dataset) # train piven print( f"\nalpha = {alpha}, run = {run}, ensemble = {i + 1}, PIVEN training..." ) piven_model.train(piven_sess, X_train, y_train, X_val, y_val, n_epoch=n_epoch, l_rate=l_rate, decay_rate=decay_rate, is_early_stop=is_early_stop, n_batch=n_batch) # predict on X_val _, y_pred_piven = piven_model.predict(piven_sess, X_test=X_val, y_test=y_val) piven_y_pred_all.append(y_pred_piven) y_u_piven, y_l_piven, y_piven = ensemble_to_prediction( piven_y_pred_all, alpha, method='piven') # calc metrics y_val_0 = y_val[:, 0] piven_picp, piven_mpiw = picp_mpiw(y_l_piven, y_u_piven, y_val_0) mse_piven = round( mean_squared_error(gen_data.scale_c * y_val_0, gen_data.scale_c * y_piven), 3) piven_metrics_per_run.append( [piven_picp, piven_mpiw, mse_piven**0.5]) # save metrics qd_metrics_per_alpha.append(qd_metrics_per_run) piven_metrics_per_alpha.append(piven_metrics_per_run) return qd_metrics_per_alpha, piven_metrics_per_alpha
start_epoch = 0 num_epoches = 50 learning_rate = 0.001 decay_rate = 0.1 update_lr_epoches = [ 35, ] momentum = 0.9 if use_cuda: device = "cuda" else: device = "cpu" data_gen = DataGenerator(model=BertModel, model_name=PRETRAINED_PATH, device=device) ner_size = len(data_gen.ner_list) rel_size = len(data_gen.rel_list) model = BertBiLSTMCRF.create(ner_size, rel_size, PRETRAINED_PATH, freeze=freeze, rnn_layers=2, input_dropout=0.1, use_cuda=use_cuda, use_extra=use_extra, hidden_size=64, label_embedding_size=32,