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)