def load_and_fit(refit, plot_egs, cv_scores):
train_inst = Load_Data('train', repickle=False)
data_X, data_y = train_inst.data_X, train_inst.data_y
train_X, cv_X, train_y, cv_y = train_test_split(data_X,
data_y,
test_size=0.33,
random_state=42)
train_X = train_X / 255
cv_X = cv_X / 255
del data_X, data_y
mod_fpath = os.path.join(MODEL_DIR, '.mdl_wts.hdf5')
model = modelling(train_X[0].shape)
if refit or not os.path.exists(mod_fpath):
earlyStopping = EarlyStopping(monitor='val_loss',
patience=6,
verbose=0,
mode='min')
mcp_save = ModelCheckpoint(mod_fpath,
save_best_only=True,
monitor='val_loss',
mode='min')
reduce_lr_loss = ReduceLROnPlateau(monitor='val_loss',
factor=0.2,
patience=2,
verbose=1,
epsilon=1e-4,
mode='min')
model.fit(train_X[:, :, :, :],
train_y[:, :],
epochs=100,
verbose=1,
batch_size=32,
callbacks=[earlyStopping, mcp_save, reduce_lr_loss],
validation_data=(cv_X, cv_y))
model.load_weights(filepath=mod_fpath)
if plot_egs:
for i in range(10):
show_example_prediction(model, cv_X, cv_y)
if cv_scores:
pred_log_loss, pred_accuracy = cv_score(model, cv_X, cv_y)
print(
f"CV log loss: {pred_log_loss:.3f}\nCV accuracy: {pred_accuracy:.3f}"
)
test_inst = Load_Data('test', repickle=False)
test_data = test_inst.data
test_data = test_data / 255
preds = model.predict(test_data)
prepare_submission(preds)
def main(directory):
dir_list = os.listdir(directory)
for e in dir_list:
file_name = directory + os.path.basename(e)
metalearning = ml.main(os.path.basename(e))
load = Load_Data(file_name)
train, valid, test = load.split_train_test_valid()
for i in range(1):
try:
output_file1 = sys.argv[1]
output_file2 = sys.argv[1]
if not output_file1.endswith('.pkl'):
output_file1 += '.pkl'
output_file2 += '.pkl'
except IndexError:
output_file1 = 'results_ab_' + os.path.basename(e) + '_' + str(
i) + '.pkl'
output_file2 = 'results_ab_test_' + os.path.basename(
e) + '_' + str(i) + '.pkl'
print("Will save results to", output_file1, output_file2)
# data = load(file_name)
hb = Hyperband(get_params, try_params, train, valid, test,
metalearning)
results = hb.run(skip_last=1)
# print(results)
test_results = hb.tests(results)
print("{} total, best in validation:\n".format(len(results)))
for r in sorted(results, key=lambda x: x['loss']):
print("loss: {:.2} | {} seconds | {:.1f} instances | run {} ".
format(r['loss'], r['seconds'], r['instances'],
r['counter']))
pprint(r['params'])
print
print("test results")
for r in range(len(test_results)):
t = test_results[r]
print(
"loss: {:.2%} | auc: {:.2%} | {} seconds | {} run ".format(
t['loss'], t['auc'], t['seconds'], t['counter']))
pprint(t['params'])
print
print("results: ", results)
print("test results: ", test_results)
print("saving...")
with open(output_file1, 'wb') as f:
pickle.dump(results, f)
with open(output_file2, 'wb') as f:
pickle.dump(test_results, f)
return 'finished'
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
from load_data import Load_Data
from suplinrel import SupLinRel
from utils import dose_to_category, mean_confidence_interval
delta = 0.75
num_run = 20
X, y = Load_Data().extract()
y = dose_to_category(y)
K = 3
reward = np.array([[0, -1, -1], \
[-1, 0, -1], \
[-1, -1, 0]])
regrets = np.zeros(num_run)
accuracy_scores = np.zeros(num_run)
for i in range(num_run):
print("Processing Trial # %d out of %d." % (i+1, num_run))
SLR = SupLinRel(K, reward, delta=delta)
SLR.data_load(X, y)
SLR.run()
regrets[i] = SLR.total_regret()
accuracy_scores[i] = SLR.accuracy_score()
regrets_mean, regrets_width = mean_confidence_interval(regrets)
import numpy as np
import pandas as pd
import baseline
from load_data import Load_Data
from utils import dose_to_category
X, y = Load_Data().extract(genotype=True)
model1 = baseline.Fixed_Dose()
model1.fit(X, y)
ypred = model1.predict(X)
print("The accuracy score of fixed dose is: %f." %
np.round(np.mean(dose_to_category(ypred) == dose_to_category(y)), 6))
model2 = baseline.Clinical_Dosing_Alg()
model2.fit(X, y)
ypred = model2.predict(X)
print("The accuracy score of clinical dosing algorithm is: %f." %
np.round(np.mean(dose_to_category(ypred) == dose_to_category(y)), 6))
model3 = baseline.Pharma_Dosing_Alg()
model3.fit(X, y)
ypred = model3.predict(X)
print("The accuracy score of Pharmacogenetic dosing algorithm is: %f." %
np.round(np.mean(dose_to_category(ypred) == dose_to_category(y)), 6))
variance_dict = {}
#creates a datelist which increments in 12 or 24 hour chunks
dates = mt.make_datetimelist(start_date, end_date, incr)
for date in dates:
hour = date.strftime('%H')
#create dict for variable type
for ob_type in ob_types:
ob_dict[ob_type] = ob_dict.get(ob_type, {})
data_dict[ob_type] = data_dict.get(ob_type, {})
SE_dict[ob_type] = SE_dict.get(ob_type, {})
variance_dict[ob_type] = variance_dict.get(ob_type, {})
#Load in the ensemble data for a given initilization
efa = Load_Data(date, ensemble_type, variables, ob_type, [ob_type])
statecls, lats, lons, elevs = efa.load_netcdfs(post,
lr=loc_rad,
inf=inflation)
#Want to interpolate ALL observations valid during a given ensemble forecast.
#Or not, to minimize runtime of script. 1 ens, var, and forecast hour takes
#about 1 minute to run.
hour_step = 6
j = start_index
fh = hour_step * j
sfh = str(fh)
while fh <= end_hour:
#print(fh)
obs = efa.load_obs(fh)
from load_data import Load_Data
from data_process import Data_Processing
from model import Model
from evaluation import Evaluation
if __name__ == '__main__':
# load data
load_data_module = Load_Data()
credit_dataframe, target_dataframe, categories_feature = load_data_module.forward()
# data processing
data_processing_module = Data_Processing(credit_dataframe, target_dataframe, categories_feature)
train_credit_dataframe, train_target_dataframe, test_credit_dataframe, test_target_dataframe = \
data_processing_module.forward(used_model = 'xgboost')
# modeling
model_module = Model(train_credit_dataframe, train_target_dataframe, categories_feature, used_model = 'xgboost')
model = model_module.forward()
# evaluating
evaluation_module = Evaluation(model, test_credit_dataframe, test_target_dataframe, categories_feature, used_model = 'xgboost')
evaluation_module.forward()