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,