def build_sherpa_parameter_space():
params = [
sherpa.Ordinal(name='depth', range=[2,3]),
sherpa.Discrete(name='dense_neurons', range=[100, 164]),
sherpa.Discrete(name='init_filters', range=[8,32]),
sherpa.Choice(name='use_batchnorm', range=[False, True]),
sherpa.Continuous(name='dropout', range=[0.35, 0.55]),
sherpa.Ordinal(name='batch_size', range=[512, 1024]),
sherpa.Continuous(name='learning_rate', range=[0.005, 0.01]),
sherpa.Continuous(name='beta1', range=[0.45, 0.55]),
sherpa.Continuous(name='beta2', range=[0.95, 1.0])
]
return params
def run_example(FLAGS):
"""
Run parallel Sherpa optimization over a set of discrete hp combinations.
"""
parameters = [sherpa.Continuous('learning_rate', [1e-5, 5e-1], 'log'),
sherpa.Continuous('decay', [1e-8, 1e-2], 'log'),
sherpa.Continuous('momentum', [0., 0.99]),
sherpa.Continuous('dropout', [0.0001, 0.7]),
sherpa.Ordinal('batch_size', [32, 64, 128, 256])]
algorithm = bayesian_optimization.GPyOpt(max_concurrent=FLAGS.concurrent,
model_type='GP',
acquisition_type='EI',
max_num_trials=100)
# Run on local machine.
scheduler = LocalScheduler()
rval = sherpa.optimize(parameters=parameters,
algorithm=algorithm,
dashboard_port=FLAGS.port,
lower_is_better=False,
command='python fashion_mlp.py',
scheduler=scheduler,
verbose=0,
max_concurrent=FLAGS.concurrent,
output_dir='./output_gpyopt_{}'.format(
time.strftime("%Y-%m-%d--%H-%M-%S")))
def run_example(FLAGS):
"""
Run parallel Sherpa optimization over a set of discrete hp combinations.
"""
parameters = [
sherpa.Continuous('learning_rate', [1e-5, 5e-1], 'log'),
sherpa.Continuous('decay', [1e-8, 1e-2], 'log'),
sherpa.Continuous('momentum', [0., 0.99]),
sherpa.Continuous('dropout', [0.0001, 0.7]),
sherpa.Ordinal('batch_size', [32, 64, 128, 256])
]
algorithm = alg = sherpa.algorithms.PopulationBasedTraining(
num_generations=26,
population_size=100,
parameter_range={
'learning_rate': [1e-10, 9e-1],
'decay': [1e-10, 9e-1]
},
perturbation_factors=(0.8, 1.2))
# Run on local machine.
scheduler = LocalScheduler()
rval = sherpa.optimize(parameters=parameters,
algorithm=algorithm,
dashboard_port=FLAGS.port,
lower_is_better=False,
command='python fashion_mlp.py',
scheduler=scheduler,
verbose=0,
max_concurrent=FLAGS.concurrent,
output_dir='./output_pbt_{}'.format(
time.strftime("%Y-%m-%d--%H-%M-%S")))
def test_local_search():
parameters = [
sherpa.Continuous('cont', [0, 1]),
sherpa.Ordinal('ord', [1, 2, 3])
]
seed = {'cont': 0.5, 'ord': 2}
alg = sherpa.algorithms.LocalSearch(seed_configuration=seed)
study = sherpa.Study(parameters=parameters,
algorithm=alg,
lower_is_better=True,
disable_dashboard=True)
def mock_objective(p):
return p['cont'] / p['ord']
# Initial suggestion.
t = study.get_suggestion()
tlist = [t]
tbest = t
assert t.parameters == seed
study.add_observation(t,
objective=mock_objective(t.parameters),
iteration=1)
study.finalize(t)
# Perform a suggestion.
t = study.get_suggestion()
tlist.append(t)
if mock_objective(t.parameters) < mock_objective(tbest.parameters):
tbest = t
study.add_observation(t,
objective=mock_objective(t.parameters),
iteration=1)
study.finalize(t)
if t.parameters['ord'] == 2:
assert t.parameters['cont'] != 0.5
assert abs(t.parameters['cont'] - 0.5) < 0.2
else:
assert t.parameters['cont'] == 0.5
t.parameters['ord'] in [1, 3]
# Do more iterations.
for i in range(50):
t = study.get_suggestion()
#print(t.parameters)
assert t.parameters['ord'] in [1, 2, 3]
assert t.parameters['cont'] >= 0.0
assert t.parameters['cont'] <= 1.0
# All new suggestions should be based on tbest.
assert t.parameters['ord'] == tbest.parameters['ord'] \
or t.parameters['cont'] == tbest.parameters['cont']
tlist.append(t)
if mock_objective(t.parameters) < mock_objective(tbest.parameters):
tbest = t
study.add_observation(t,
objective=mock_objective(t.parameters),
iteration=1)
study.finalize(t)
def test_pbt_ordinal():
parameters = [sherpa.Ordinal(name='param_a', range=[-1, 0, 1])]
algorithm = sherpa.algorithms.PopulationBasedTraining(num_generations=2,
population_size=10)
study = sherpa.Study(parameters=parameters,
algorithm=algorithm,
lower_is_better=True,
disable_dashboard=True)
for _ in range(10):
trial = study.get_suggestion()
print("Trial-ID={}".format(trial.id))
print(trial.parameters)
print()
study.add_observation(trial=trial, iteration=1, objective=trial.parameters['param_a']*0.1)
study.finalize(trial=trial,
status='COMPLETED')
for _ in range(10):
trial = study.get_suggestion()
print("Trial-ID={}".format(trial.id))
print(trial.parameters)
print()
assert trial.parameters['param_a'] in (-1, 0, 1)
study.add_observation(trial=trial, iteration=1, objective=trial.parameters['param_a']*0.1)
study.finalize(trial=trial,
status='COMPLETED')
def get_study():
parameters = [
sherpa.Ordinal("conv3d_num_filters", [16, 32, 64, 128]),
sherpa.Ordinal("conv3d_kernel_size", [(3, 5, 5), (5, 5, 5), (5, 7, 7)]),
sherpa.Discrete("encoder_rnn_num_layers", [1, 3]),
sherpa.Continuous("encoder_rnn_dropout", [0.0, 0.3]),
sherpa.Continuous("lr", [2e-4, 4e-3], scale="log"),
]
algorithm = sherpa.algorithms.RandomSearch(max_num_trials=16)
stopping_rule = sherpa.algorithms.MedianStoppingRule(min_iterations=8, min_trials=4)
return sherpa.Study(
parameters=parameters,
algorithm=algorithm,
lower_is_better=True,
stopping_rule=stopping_rule,
)
class TestLocalSearch:
@pytest.mark.parametrize("parameter,seed,expected",
[(sherpa.Ordinal('p', [0, 1, 2, 3, 4]), {'p': 2}, [1, 3]),
(sherpa.Continuous('p', [0, 1]), {'p': 0.5}, [0.5*0.8, 0.5*1.2]),
(sherpa.Discrete('p', [0, 10]), {'p': 5}, [4, 6]),
(sherpa.Choice('p', [0, 1, 2, 3, 4]), {'p': 2}, [0, 1, 3, 4])])
def test_seed_and_first_suggestion(self, parameter, seed, expected):
study = get_local_search_study_lower_is_better([parameter],
seed)
trial = study.get_suggestion()
assert trial.parameters['p'] == seed['p']
study.add_observation(trial, objective=trial.parameters['p'], iteration=1)
study.finalize(trial)
trial = study.get_suggestion()
assert trial.parameters['p'] in expected
@pytest.mark.parametrize("parameter,seed,expected",
[(sherpa.Ordinal('p', [0, 1, 2, 3, 4]), {'p': 2}, [0, 1]),
(sherpa.Continuous('p', [0, 1]), {'p': 0.5}, [0.5*(0.8), 0.5*(0.8)**2]),
(sherpa.Discrete('p', [0, 10]), {'p': 5}, [int(5*(0.8)), int(5*(0.8)**2)]),
(sherpa.Choice('p', [0, 1, 2]), {'p': 2}, [0])])
def test_expected_value_after_three_iterations(self, parameter, seed, expected):
study = get_local_search_study_lower_is_better([parameter],
seed)
for trial in study:
study.add_observation(trial, objective=trial.parameters['p'], iteration=1)
study.finalize(trial)
if trial.id == 3:
break
assert study.get_best_result()['Objective'] in expected
@pytest.mark.parametrize("param1,seed1,param2,seed2", [(sherpa.Ordinal('p1', [0, 1, 2, 3, 4]), {'p1': 2},
sherpa.Continuous('p2', [0, 1]), {'p2': 0.5})])
def test_only_one_parameter_is_perturbed_at_a_time(self, param1, seed1, param2, seed2):
seed = dict(seed1, **seed2)
study = get_local_search_study_lower_is_better([param1, param2],
seed=seed)
trial = study.get_suggestion()
study.add_observation(trial, objective=1, iteration=1)
study.finalize(trial)
trial = study.get_suggestion()
assert not all(
param_value != seed[param_name] for param_name, param_value in
trial.parameters.items())
def test_genetic():
"""
Since genetic algorithms are stochastic we will check for average improvements while testing new configurations
"""
parameters = [
sherpa.Ordinal(name='param_a',
range=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
sherpa.Ordinal(
name='param_b',
range=['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']),
sherpa.Ordinal(name='param_c',
range=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
]
algorithm = sherpa.algorithms.Genetic()
study = sherpa.Study(parameters=parameters,
algorithm=algorithm,
lower_is_better=False,
disable_dashboard=True)
mean_values = []
for _ in range(500):
results = study.results
if results.shape[0] > 0:
results = results[results['Status'] == 'COMPLETED']
mean_values.append(results['Objective'].mean())
trial = study.get_suggestion()
print("Trial-ID={}".format(trial.id))
print(trial.parameters)
print()
study.add_observation(trial=trial,
iteration=1,
objective=trial.parameters['param_a'] * 0.1 +
trial.parameters['param_c'] * 0.1)
study.finalize(trial=trial, status='COMPLETED')
ascending = 0
for pos in range(len(mean_values) - 1):
if mean_values[pos + 1] > mean_values[pos]:
ascending += 1
print(ascending / len(mean_values))
assert ascending / len(
mean_values
) > 0.7, "At least 70% of times we add a new result we must improve the average Objective"
results = results[results['Status'] == 'COMPLETED']
def runner():
parameters = [
sherpa.Discrete('num_units', [64, 512]),
sherpa.Discrete('num_layers', [2, 15]),
sherpa.Ordinal('batch_size', [4096]),
sherpa.Ordinal('learning_rate',
[0.0001, 0.0003162278, 0.001, 0.003162278, 0.001]),
sherpa.Continuous('dropout_rate', [0, 0.6]),
sherpa.Continuous('leaky_relu_alpha', [0, 1]),
sherpa.Ordinal('batch_norm', [0, 1]),
]
#alg = sherpa.algorithms.BayesianOptimization(max_num_trials=50)
#alg = sherpa.algorithms.GPyOpt(max_num_trials=50)
alg = sherpa.algorithms.RandomSearch(max_num_trials=40)
#resources = ['/device:GPU:0', '/device:GPU:1', '/device:GPU:2', '/device:GPU:3']
resources = [0, 1, 2, 3]
scheduler = sherpa.schedulers.LocalScheduler(resources=resources)
#study = sherpa.Study(parameters=parameters,
# algorithm=alg,
# lower_is_better=True)
script = '/work/00157/walling/projects/cloud_emulator/walling-CBRAIN-CAM/notebooks/tbeucler_devlog/sherpa/sherpa-trial-phase2-study1-pos.py'
tempdir = '/work/00157/walling/projects/cloud_emulator/walling-CBRAIN-CAM/notebooks/tbeucler_devlog/sherpa/sherpa-temp-phase2-study1-pos'
#import time
#time.sleep(1000)
results = sherpa.optimize(parameters=parameters,
algorithm=alg,
lower_is_better=True,
filename=script,
output_dir=tempdir,
scheduler=scheduler,
max_concurrent=4,
verbose=1,
mongodb_args={'bind_ip':
'0.0.0.0'}) #, 'port':47001})
def setup_sherpa(max_num_trials):
parameters = [
sherpa.Continuous("learning_rate", [1e-4, 1e-2], "log"),
sherpa.Continuous("dropout_1", [0, 0.5]),
sherpa.Continuous("dropout_2", [0, 0.5]),
sherpa.Ordinal(name='batch_size', range=[32, 64, 128]),
sherpa.Discrete("filter_1", [20, 200]),
sherpa.Discrete("filter_2", [20, 200]),
sherpa.Discrete("filter_3", [20, 200]),
sherpa.Discrete("kernel_1", [2,4]),
sherpa.Discrete("kernel_2", [2,4]),
sherpa.Discrete("kernel_3", [2,4]),
sherpa.Discrete("dense_units_1", [32, 400]),
sherpa.Discrete("dense_units_2", [32, 400]),
sherpa.Discrete("dense_units_3", [32, 400]),
sherpa.Discrete("pool_1", [2,3]),
sherpa.Discrete("pool_2", [2,3]),
]
algorithm = sherpa.algorithms.bayesian_optimization.GPyOpt(max_num_trials=max_num_trials)
return parameters, algorithm
def run_example(FLAGS):
"""
Run parallel Sherpa optimization over a set of discrete hp combinations.
"""
parameters = [
sherpa.Continuous('learning_rate', [1e-5, 5e-1], 'log'),
sherpa.Continuous('decay', [1e-8, 1e-2], 'log'),
sherpa.Continuous('momentum', [0., 0.99]),
sherpa.Continuous('dropout', [0.0001, 0.7]),
sherpa.Ordinal('batch_size', [32, 64, 128, 256])
]
# 27 epochs to produce one finished 13 epoch model
# => 54 epochs to produce one finished 26 epoch model (resource unit = 2epochs)
# RS uses 100 models x 26 epochs = 2600 epochs.models
# ASHA can produce 2600epochs.models//54epochs = 48 models
algorithm = sherpa.algorithms.SuccessiveHalving(r=1,
R=9,
eta=3,
s=0,
max_finished_configs=48)
# Run on local machine.
scheduler = LocalScheduler()
rval = sherpa.optimize(parameters=parameters,
algorithm=algorithm,
dashboard_port=FLAGS.port,
lower_is_better=False,
command='python fashion_mlp.py',
scheduler=scheduler,
verbose=0,
max_concurrent=FLAGS.concurrent,
output_dir='./output_successive_halving_{}'.format(
time.strftime("%Y-%m-%d--%H-%M-%S")))
mkdir(results_directory)
except FileExistsError:
pass
### Optimize hyperparameters
param_names = RES_OPT_PRMS
parameters = [
sherpa.Continuous(name='gamma', range=[0.1, 25]),
sherpa.Continuous(name='sigma', range=[0.01, 5.0]),
sherpa.Continuous(name='spect_rad', range=[0.1, 25]),
sherpa.Continuous(name='ridge_alpha', range=[1e-8, 2], scale='log'),
sherpa.Continuous(name='mean_degree', range=[0.1, 5]),
]
augmentedprms = [
sherpa.Continuous(name='window', range=[10*DT[SYSTEM], 1000*DT[SYSTEM]]),
sherpa.Ordinal(name='overlap', range=[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.95])
#Alternative:
#sherpa.Continuous(name='overlap', range=[0.0, 0.95])
]
roboprms = [
sherpa.Continuous(name='delta', range=[0.01, 5.0]),
]
if METHOD == "augmented":
parameters += augmentedprms
param_names += METHOD_PRMS
if SYSTEM == "softrobot":
parameters += roboprms
param_names += ROBO_OPT_PRMS
#Load robot data
BIG_ROBO_DATA_LOADED = load_robo(BIG_ROBO_DATA)
SMALL_ROBO_DATA_LOADED = load_robo(SMALL_ROBO_DATA)
rois = dom.documentElement
xmin = int(rois.getElementsByTagName("xmin")[0].firstChild.data)
xmax = int(rois.getElementsByTagName("xmax")[0].firstChild.data)
ymin = int(rois.getElementsByTagName("ymin")[0].firstChild.data)
ymax = int(rois.getElementsByTagName("ymax")[0].firstChild.data)
label = np.zeros((2047, 1520))
for i in range(xmin, xmax):
for j in range(ymin, ymax):
label[j][i] = 1
labelList.append(label)
return np.array(imgList), np.array(labelList)
if __name__ == '__main__':
parameters = [
sherpa.Ordinal(name='batch_size', range=[16, 32, 64, 128, 256]),
sherpa.Ordinal(name='steps', range=[16, 32, 64, 128, 256]),
sherpa.Ordinal(name='epoch', range=[4096])
]
alg = sherpa.algorithms.BayesianOptimization(max_num_trials=500)
study = sherpa.core.Study(parameters=parameters,
algorithm=alg,
lower_is_better=False,
disable_dashboard=True)
for trial in study:
model = Sequential()
model.add(
Convolution2D(filters=32,
kernel_size=(3, 3),
border_mode='same',
bkg_test_x = bkg_test.drop(columns=['target', 'sampleName', 'nJets30Clean'])
test_x = test.drop(columns=['target', 'sampleName', 'nJets30Clean'])
train_x_ttdilep_nJet = train_x_ttdilep['nJets30Clean']
train_x_ttdilep = train_x_ttdilep.drop(
columns=['target', 'sampleName', 'nJets30Clean'])
### Hyperparameter search ###
parameters = [
sherpa.Continuous('DRf_learning_rate', [0.001, 0.1], scale='log'),
sherpa.Continuous('DfR_learning_rate', [0.001, 0.1], scale='log'),
sherpa.Continuous('DRf_momentum', [0.5, 0.9]),
sherpa.Continuous('DfR_momentum', [0.5, 0.9]),
sherpa.Discrete('additional_hidden_layers_classifier', [0, 3]),
sherpa.Discrete('additional_hidden_layers_adversarial', [0, 3]),
sherpa.Ordinal('num_hidden_units_classifier', [50, 100, 150]),
sherpa.Ordinal('num_hidden_units_adversarial', [50, 100, 150]),
sherpa.Choice('first_layer_activation', ['tanh', 'no_tanh']),
sherpa.Continuous('dropout_rate', [0.2, 0.5]),
sherpa.Ordinal('adversarial_batch_size', [128, 256, 512, 1024]),
sherpa.Continuous('lambda', [2, 12])
]
random_search = sherpa.algorithms.RandomSearch(max_num_trials=num_of_trials)
study = sherpa.Study(parameters=parameters,
algorithm=random_search,
lower_is_better=True,
disable_dashboard=True)
trial_num = 0
for trial in study:
def run_sherpa(rinv):
results_path = path / "sherpa_results" / rinv
if not results_path.exists():
os.mkdir(results_path)
results_csv = results_path / "results.csv"
if results_csv.exists():
return
parameters = [
sherpa.Continuous("learning_rate", [1e-4, 1e-2], "log"),
sherpa.Continuous("dropout_0", [0, 0.5]),
sherpa.Continuous("dropout_1", [0, 0.5]),
sherpa.Continuous("dropout_2", [0, 0.5]),
sherpa.Ordinal("batch_size", [128, 256, 512]),
sherpa.Discrete("filter_1", [16, 400]),
sherpa.Discrete("filter_2", [16, 400]),
sherpa.Discrete("filter_3", [16, 400]),
sherpa.Discrete("dense_units_1", [20, 400]),
sherpa.Discrete("dense_units_2", [20, 400]),
sherpa.Discrete("dense_units_3", [20, 400]),
]
algorithm = sherpa.algorithms.bayesian_optimization.GPyOpt(
max_num_trials=max_num_trials)
study = sherpa.Study(parameters=parameters,
algorithm=algorithm,
lower_is_better=False,
disable_dashboard=True,
output_dir=results_path)
X, y = get_data(rinv, N)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.75,
random_state=42)
t = tqdm.tqdm(study, total=max_num_trials)
for tix, trial in enumerate(t):
# Sherpa settings in trials
tp = trial.parameters
model = get_model(tp)
for i in range(trial_epochs):
training_error = model.fit(X_train,
y_train,
batch_size=int(tp["batch_size"]),
verbose=0)
loss, accuracy, auc = model.evaluate(X_test, y_test, verbose=0)
study.add_observation(
trial=trial,
iteration=i,
objective=auc,
context={
"loss": loss,
"auc": auc,
"accuracy": accuracy
},
)
if study.should_trial_stop(trial):
study.finalize(trial=trial, status="STOPPED")
break
study.finalize(trial=trial, status="COMPLETED")
np.save(results_path / "best_results.npy", study.get_best_result())
study.save()
t.set_description(
f"Trial {trial.id}; rinv={rinv.replace('p','.')} -> AUC = {auc:.4}"
)
print("---------------- Model Compilation -----------------")
model.compile(optimizer='adam', loss='mean_squared_error', metrics=['mean_squared_error',
'mean_absolute_error',
'mean_absolute_percentage_error',
'cosine_proximity', 'accuracy'])
# parameters = [sherpa.Discrete('num_units', [50, 200])]
batches = numpy.arange(25, 1001, 25).tolist()
dropouts = numpy.arange(0.001, 1.001, 0.002).tolist()
learning_rates = numpy.arange(0.0001, 1.0001, 0.0001).tolist()
activations = ['relu', 'elu', 'prelu', 'Adadelta', 'Adagrad', 'Adam', 'Adamax', 'Ftrl', 'Nadam', 'RMSprop', 'SGD']
parameters = [sherpa.Continuous(name='lr', range=learning_rates, scale='log'),
sherpa.Ordinal(name='batch_size', range=batches),
sherpa.Choice(name='activation', range=activations)]
# alg = sherpa.algorithms.RandomSearch(max_num_trials=50)
alg = sherpa.algorithms.GPyOpt(max_num_trials=150)
study = sherpa.Study(parameters=parameters,
algorithm=alg,
lower_is_better=True)
for trial in study:
model1 = Sequential()
model1.add(LSTM(units=50, activation='relu', return_sequences=True, input_shape=(1, 4)))
model1.add(Activation(custom_activation, name="Swish"))
model1.add(Dropout(0.2))
model1.add(LSTM(units=50, return_sequences=True))
model1.add(Activation(custom_activation))
'-l',
help='the given resource list.',
default=
"hostname=\'(arcus-1|arcus-2|arcus-3|arcus-4|arcus-5|arcus-6|arcus-7|arcus-8|arcus-9)\'"
)
parser.add_argument('--env',
help='Your environment path.',
default='/home/lhertel/profiles/python3env.profile',
type=str)
FLAGS = parser.parse_args()
# Define Hyperparameter ranges
parameters = [
sherpa.Continuous(name='lr', range=[0.005, 0.1], scale='log'),
sherpa.Continuous(name='dropout', range=[0., 0.4]),
sherpa.Ordinal(name='batch_size', range=[16, 32, 64])
]
if FLAGS.algorithm == 'PBT':
algorithm = sherpa.algorithms.PopulationBasedTraining(
population_size=50,
parameter_range={
'lr': [0.0000001, 1.],
'batch_size': [16, 32, 64, 128, 256, 512]
})
parameters.append(sherpa.Choice(name='epochs', range=[3]))
stoppingrule = None
else:
parameters.append(
sherpa.Continuous(name='lr_decay', range=[1e-4, 1e-7], scale='log'))
parameters.append(sherpa.Choice(name='epochs', range=[25]))
os.makedirs(
os.path.join(output_dir, 'Models'),
exist_ok=True
)
parameters = [
# LEARNING RATE
sherpa.Continuous('lr', [0.00001, 0.1]),
sherpa.Continuous('lr_decay', [0.5, 1.0]),
# REGULARIZATION
sherpa.Continuous('leaky_relu', [0., 0.9]),
sherpa.Continuous('dropout', [0., 0.9]),
sherpa.Continuous('noise', [0., 1.]),
sherpa.Ordinal('batch_norm', [1, 0]),
# ARCHITECTURE
sherpa.Discrete('num_layers', [3,FLAGS.max_dense_layers]),
sherpa.Discrete('num_dense_nodes', [128, 1024]),
sherpa.Choice('optimizer', ['adam', 'sgd', 'rmsprop']),
# SETTINGS
sherpa.Choice('epochs', [30]),
sherpa.Choice('batch_size', [16384]),
sherpa.Choice('patience', [10]),
sherpa.Choice('data', [FLAGS.data]),
sherpa.Choice('data_dir', ['/oasis/projects/nsf/sio134/jott1/']),
sherpa.Choice('model_dir', [output_dir + 'Models/']),
]
def gen_test(num_start_sample, sample_len, test_samples):
end_of_sample = sample_len + 1
test_x = test_samples[num_start_sample:num_start_sample + sample_len, :]
test_y = test_samples[num_start_sample+sample_len:num_start_sample+end_of_sample, :]
test_x = test_x.reshape(1,sample_len,69)
return test_x, test_y
#samples, time steps, features
#sample_lens = list(range(6,510,6))
parameters = [sherpa.Discrete('layer_one_dep', [69, 138, 207, 276]),
sherpa.Ordinal('sample_len', range=[6,12,18,24,30,36,42,48,54,60,66,72,78,84]),
sherpa.Continuous('learn_rate', range=[.00001, 0.5], scale = 'log'),
sherpa.Discrete('epoch_num', range=[1,1000], scale='log'),
sherpa.Discrete('batch_num', range=[2,4,8,16,32,64,128])]
alg = sherpa.algorithms.RandomSearch(max_num_trials=30)
study = sherpa.Study(parameters=parameters, algorithm=alg, lower_is_better=False, disable_dashboard=True, output_dir=r'C:\Users\Michael\Desktop\Python\pwrball_rand\output')
#layer_one_dep, layer_two_dep, sample_len, learn_rate, epoch_num, batch_num
df = pd.read_csv(r'C:\Users\Michael\Desktop\Python\pwrball_rand\pwrball_9_15.csv')
sequence = df.values.reshape(-1,1).tolist()
ohe = OneHotEncoder().fit(sequence)
encoded_sequence = ohe.transform(sequence).toarray()
train, test = train_test_split(encoded_sequence, test_size = 0.05)
