def hypermodel_tunning_parameters(data, y, args): import numpy as np from kerastuner.tuners import (RandomSearch, BayesianOptimization, Hyperband) from sklearn.model_selection import StratifiedShuffleSplit SEED = args.samples[0] EXECUTION_PER_TRIAL = args.hypermodel['execution_per_trial'] HYPERBAND_MAX_EPOCHS = args.hypermodel['hyperband_max_epochs'] N_EPOCH_SEARCH = 30 MODEL_TYPE = args.model_type PROJECT_NAME = args.experiment_name NUM_CLASSES = 1 # One sigmoid neuron for binary classification DATA = data.data X = [x for x in data.X] np.random.seed(SEED) # Get dynamic model class dynamic_model = get_model(model_type=MODEL_TYPE) # Instantiate object from dynamic model class hypermodel = dynamic_model(DATA, NUM_CLASSES) tuner = Hyperband( hypermodel, max_epochs=HYPERBAND_MAX_EPOCHS, objective='val_loss', loss='binary_crossentropy', seed=SEED, executions_per_trial=EXECUTION_PER_TRIAL, directory='hyperband', project_name=PROJECT_NAME, metrics=['accuracy'] ) tuner.search_space_summary() kf = StratifiedShuffleSplit(n_splits=1, random_state=SEED, test_size=0.3) kf.get_n_splits(X, y) print('\t>{} HYPERMODEL START {}'.format('>' * 30, '<' * 30)) for i, partition in enumerate(kf.split(X[0], y)): print('>>> Testing PARTITION {}'.format(i)) train_index, test_index = partition (x_train, y_train), (x_test, y_test) = data.load_partition(train_index, test_index) print('Number of samples for:\n\tTrain:\t{}\n\tTest:\t{}'.format(x_train[0].shape[0], x_test[0].shape[0])) tuner.search(x_train, y_train, epochs=N_EPOCH_SEARCH, validation_split=0.1, verbose=0) # # Show a summary of the search # tuner.results_summary() # # Retrieve the best model. # best_model = tuner.get_best_models(num_models=1)[0] # # Evaluate the best model. # loss, accuracy = best_model.evaluate(x_test, y_test) # print(' =' * 30) # print('\tBest Model') # print('\tLoss: {}'.format(loss)) # print('\tAcc: {}'.format(accuracy)) # print(' =' * 30) print('\t>{} HYPERMODEL END {}'.format('>' * 30, '<' * 30)) return tuner
def hyperband(self): tuner = Hyperband( self.build_model, objective='mean_squared_error', max_epochs=self.hyper_maxepochs, factor=self.hyper_factor, hyperband_iterations=self.hyper_iters, # The number of times to iterate over the full Hyperband algorithm. It is recommended to set this to as high a value as is within your resource budget. # directory=dir, seed=self.seed, overwrite=True, directory=self.kt_dir ) tuner.search( x=self.data, y=self.train_labels, epochs=self.epochs, # batch_size=self.batch_size, validation_data=(self.test_data, self.test_labels), ) return tuner
def main(cube_dir, hyperband_iterations, max_epochs): device_name = tf.test.gpu_device_name() if device_name != '/device:GPU:0': raise SystemError('GPU device not found') logging.info('Found GPU at: {}'.format(device_name)) x, y, val_x, val_y = deep_emulator.data(cube_dir, rescale=True) tuner = Hyperband( build_model, objective='val_mean_absolute_error', hyperband_iterations=hyperband_iterations, max_epochs=max_epochs, directory='results/hyperband', project_name='agnfinder_5layer_dropout' ) early_stopping = keras.callbacks.EarlyStopping(restore_best_weights=True) tuner.search( x, y, callbacks=[early_stopping], validation_data=(val_x, val_y), batch_size=1024 ) tuner.results_summary() models = tuner.get_best_models(num_models=5) for n, model in enumerate(models): logging.info(f'Model {n}') logging.info(model.summary())
def find_best_NN(x_train_main, y_train_main): tuner = Hyperband(build_model, objective="loss", max_epochs=10, hyperband_iterations=10) tuner.search(x_train, y_train, batch_size=1, epochs=10, validation_split=0.3) tuner.results_summary() print("\n\n\n") print("\n\n\nHERE IS THE BEST MODEL\n\n\n") best_params = tuner.get_best_hyperparameters()[0] best_model = tuner.hypermodel.build(best_params) best_model.summary() return best_model
def TuneNetwork(): #Function to tune hyperparameters for the neural network tuner = Hyperband(CreateNNmodel, max_epochs=50, objective='val_accuracy', executions_per_trial=7, directory=os.path.normpath('C:/')) tuner.search(x=TrainingInput, y=TrainingOutput, validation_data=(TestingInput, TestingOutput), epochs=50, batch_size=Features) best_model = tuner.get_best_models(num_models=1)[0] loss, accuracy = best_model.evaluate(TestingInput, TestingOutput) print(accuracy)
def hypermodel_exec(x_train, x_test, y_train, y_test): SEED = 17 MAX_TRIALS = 40 EXECUTION_PER_TRIAL = 3 HYPERBAND_MAX_EPOCHS = 20 NUM_CLASSES = 1 # One sigmoid neuron for binary classification INPUT_SHAPE = (32, 32, 3 ) # Depends on embedding type and bp lenght of dataset N_EPOCH_SEARCH = 40 np.random.seed(SEED) hypermodel = HotCNNHyperModel(input_shape=INPUT_SHAPE, num_classes=NUM_CLASSES) # tuner = RandomSearch( # hypermodel, # objective='val_loss', # seed=SEED, # max_trials=MAX_TRIALS, # executions_per_trial=EXECUTION_PER_TRIAL, # directory='random_search', # project_name='hot_cnn_promoter_01' # ) tuner = Hyperband(hypermodel, max_epochs=HYPERBAND_MAX_EPOCHS, objective='val_accuracy', seed=SEED, executions_per_trial=EXECUTION_PER_TRIAL, directory='hyperband', project_name='hot_cnn_promoter_01') tuner.search_space_summary() tuner.search(x_train, y_train, epochs=N_EPOCH_SEARCH, validation_split=0.1) # Show a summary of the search tuner.results_summary() # Retrieve the best model. best_model = tuner.get_best_models(num_models=1)[0] # Evaluate the best model. loss, accuracy = best_model.evaluate(x_test, y_test)
def find_best(x_train, y_train): # создаю тюнер, который сможет подобрать оптимальную архитектуру модели tuner = Hyperband(build_model, objective="loss", max_epochs=10, hyperband_iterations=3) print("\n\n\n") # начинается автоматический подбор гиперпараметров print('[INFO] start searching') tuner.search(x_train, y_train, batch_size=128, epochs=10, validation_split=0.2) # выбираем лучшую модель print("\n\n\nRESULTS SUMMARY") tuner.results_summary() print("\n\n\n") # получаем лучшую модель print("\n\n\nHERE IS THE BEST MODEL\n\n\n") best_params = tuner.get_best_hyperparameters()[0] best_model = tuner.hypermodel.build(best_params) best_model.summary() return best_model
def nn_tune_train(data: pd.DataFrame, model_names: list)->dict: num_classes = len(data.label.unique()) with tqdm(total=num_classes) as bar: for X_train, X_test, y_train, y_test, label in ut.data_split_classwise(data): bar.set_description(f'Tuning on model {label}') for name in model_names: tuner = Hyperband( _build_model, objective='val_loss', max_epochs=50, factor=3, directory='hyperband', project_name=f'slp{label}' ) tuner.search(X_train, y_train, epochs=50, validation_data=(X_test, y_test)) best_hps = tuner.get_best_hyperparameters(num_trials=1)[0] print(f"{name} optimal params: {best_hps}") bar.update(1)
def __train_neural_networks(self, estimator): if estimator.get_metric() == "mse": tuner = Hyperband(estimator, max_epochs=20, objective="val_mse", executions_per_trial=1, directory="regression_nn" + str(random.randint(0, 1000))) else: tuner = Hyperband(estimator, max_epochs=20, objective="val_accuracy", executions_per_trial=1, directory="classification_nn" + str(random.randint(0, 1000))) tuner.search(self.X_train, self.y_train, epochs=1, validation_split=0.1, verbose=0) return tuner.get_best_models(num_models=1)[0]
def train(): bert_xtrain, bert_xval = bert_transform_for_train() tuner = Hyperband( bert_model.build_model, objective="val_accuracy", max_epochs=3, project_name="../hyperparameter/hyperband", ) # Keras Callbacks model_path = os.path.join("..", "models", "keras_hyperband_disaster_prediction.h5") tensorboard_logs_path = os.path.join("..", "tensorboard_logs") checkpoint_cb = keras.callbacks.ModelCheckpoint(filepath=model_path, save_best_only=True) early_stopping_cb = keras.callbacks.EarlyStopping( patience=10, restore_best_weights=True) tensorboard_cb = keras.callbacks.TensorBoard( os.path.join(tensorboard_logs_path, time.strftime("run_%Y_%m_%d_at_%H_%M_%S"))) tuner.search( { "input_word_ids": bert_xtrain[0], "input_mask": bert_xtrain[1], "segment_ids": bert_xtrain[2], }, y_train, epochs=3, batch_size=32, validation_data=( { "input_word_ids": bert_xval[0], "input_mask": bert_xval[1], "segment_ids": bert_xval[2], }, y_val, ), callbacks=[checkpoint_cb, early_stopping_cb, tensorboard_cb], )
def tuneHyperband(X, y, max_trials=3): """ Perform Hyperband Tuning to search for the best model and Hyperparameters Arguments: X: Input dataset y: Label or output dataset max_trials: Trials required to perform tuning """ hypermodel = HyperResNet(input_shape=(128, 128, 3), num_classes=10) tuner = Hyperband( hypermodel, max_epochs=max_trials, objective='val_accuracy', seed=42, ) X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=49) # searches the tuner space defined by hyperparameters (hp) and returns the # best model tuner.search(X_train, y_train, epochs=5, validation_data=(X_test, y_test)) hyp = tuner.get_best_hyperparameters(num_trials=1)[0] #hyp = tuner.oracle.get_best_trials(num_trials=1)[0].hyperparameters.values #best_hps = np.stack(hyp).astype(None) history = tuner_hist(X, y, tuner, hyp) """ Return: models[0] : best model obtained after tuning best_hps : best Hyperprameters obtained after tuning, stored as array history : history of the data executed from the given model """ return tuner.get_best_models(1)[0], hyp, history
class AutoQKeras: """Performs autoquantization in Keras model. Arguments: model: Model to be quantized. metrics: List of metrics to be used. custom_objects: Custom objects used by Keras during quantization. goal: Metric to compute secondary goal of search (bits or energy) output_dir: name of output directory to store results. mode: random, hyperband or bayesian used by kerastuner. transfer_weights: if true, transfer weights from unquantized model. frozen_layers: if true, these layers will not be quantized but weights transferred from original model. activation_bits: parameter to be used by 'model_quantize'. limit: limit the number of bits in quantizers specified as a dictionary. tune_filters: one of "block", "layer", "none" for tuning entire network, each layer separately, or no tuning. tune_filters_exceptions: name of layers that will not be tuned. layer_indexes: indexes of layers we will quantize. learning_rate_optimizer: if true, user will provide lr scheduler callback. quantization_config: file name of dictionary containing configuration of quantizers for kernel, bias and activation. tuner_kwargs: parameters for kerastuner depending on whether mode is random, hyperband or baeysian. Please refer to the documentation of kerstuner Tuners. """ def __init__(self, model, metrics=None, custom_objects=None, goal=None, output_dir="result", mode="random", transfer_weights=False, frozen_layers=None, activation_bits=4, limit=None, tune_filters="none", tune_filters_exceptions=None, learning_rate_optimizer=False, layer_indexes=None, quantization_config=None, overwrite=True, **tuner_kwargs): if not metrics: metrics = [] if not custom_objects: custom_objects = {} # goal: { "type": ["bits", "energy"], "params": {...} } or ForgivingFactor # type # For type == "bits": # delta_p: increment (in %) of the accuracy if trial is smaller. # delta_n: decrement (in %) of the accuracy if trial is bigger. # rate: rate of decrease/increase in model size in terms of bits. # input_bits; size of input tensors. # output_bits; size of output tensors. # stress: parameter to reduce reference size to force tuner to # choose smaller models. # config: configuration on what to compute for each layer # minimum configuration is { "default": ["parameters", "activations"] } # use simplest one - number of bits if not goal: goal = { "type": "bits", "params": { "delta_p": 8.0, "delta_n": 8.0, "rate": 2.0, "stress": 1.0, "input_bits": 8, "output_bits": 8, "ref_bits": 8, "config": { "default": ["parameters", "activations"] } } } self.overwrite = overwrite # if we have not created it already, create new one. if not isinstance(goal, ForgivingFactor): target = forgiving_factor[goal["type"]](**goal["params"]) else: target = goal # if no metrics were specified, we want to make sure we monitor at least # accuracy. if not metrics: metrics = ["acc"] self.hypermodel = AutoQKHyperModel( model, metrics, custom_objects, target, transfer_weights=transfer_weights, frozen_layers=frozen_layers, activation_bits=activation_bits, limit=limit, tune_filters=tune_filters, tune_filters_exceptions=tune_filters_exceptions, layer_indexes=layer_indexes, learning_rate_optimizer=learning_rate_optimizer, quantization_config=quantization_config) # right now we create unique results directory idx = 0 name = output_dir if self.overwrite: while os.path.exists(name): idx += 1 name = output_dir + "_" + str(idx) output_dir = name self.output_dir = output_dir # let's ignore mode for now assert mode in ["random", "bayesian", "hyperband"] if mode == "random": self.tuner = RandomSearch(self.hypermodel, objective=kt.Objective( "val_score", "max"), project_name=output_dir, **tuner_kwargs) elif mode == "bayesian": self.tuner = BayesianOptimization(self.hypermodel, objective=kt.Objective( "val_score", "max"), project_name=output_dir, **tuner_kwargs) elif mode == "hyperband": self.tuner = Hyperband(self.hypermodel, objective=kt.Objective("val_score", "max"), project_name=output_dir, **tuner_kwargs) else: pass self.tuner.search_space_summary() def _has_earlystopping(self, callbacks): """Check if EarlyStopping has been defined or not.""" if callbacks is None: return False for callback in callbacks: if isinstance(callback, tf.keras.callbacks.EarlyStopping): return True return False def history(self, number_of_trials=-1): """Returns the history of the model search.""" trials = self.tuner.oracle.get_best_trials(number_of_trials) state = [trial.get_state() for trial in trials] result = {} result["score"] = [ state[i]["score"] for i in range(len(state)) if trials[i].score is not None ] for i in range(len(state)): if trials[i].score is not None: keys = state[i]["metrics"]["metrics"].keys() for key in keys: if key != "score" and not key.startswith( "val_") and key != "loss" and key != "trial": cur_accuracy = state[i]["metrics"]["metrics"][key][ "observations"][0]["value"][0] if "val_" + key in state[i]["metrics"]["metrics"].keys( ): cur_val_accuracy = state[i]["metrics"]["metrics"][ "val_" + key]["observations"][0]["value"][0] else: cur_val_accuracy = None # only update result if both key and val_key exist if cur_val_accuracy: if key not in result.keys(): result[key] = [cur_accuracy] result["val_" + key] = [cur_val_accuracy] else: result[key].append(cur_accuracy) result["val_" + key].append(cur_val_accuracy) result["trial_size"] = [ state[i]["metrics"]["metrics"]["trial"]["observations"][0]["value"] [0] for i in range(len(state)) if trials[i].score is not None ] return result def fit(self, *fit_args, **fit_kwargs): """Invokes tuner fit algorithm.""" callbacks = fit_kwargs.get("callbacks", None) if callbacks is None: callbacks = [] epochs = fit_kwargs.get("epochs", None) if epochs is None: epochs = 10 if not self._has_earlystopping(callbacks): callbacks = callbacks + [ tf.keras.callbacks.EarlyStopping("val_loss", patience=min(20, epochs // 5)) ] fit_kwargs["callbacks"] = callbacks self.tuner.search(*fit_args, **fit_kwargs) @staticmethod def get_best_lr(qmodel): """Extracts best lr of model.""" return qmodel.optimizer.lr.numpy() def get_best_model(self): params = self.tuner.get_best_hyperparameters()[0] q_model = self.tuner.hypermodel.build(params) self.learning_rate = q_model.optimizer.lr.numpy() return q_model def get_learning_rate(self): return self.learning_rate
return lrate lrate = LearningRateScheduler(step_decay) my_callbacks = [ lrate, # learning rate scheduler # save the weights of the model with the best f1-score after each epoch tf.keras.callbacks.ModelCheckpoint( filepath='pretrained_modelss\\checkpoint\\model.{epoch:02d}.h5', save_weights_only=True, save_best_only=False), LRTensorBoard( log_dir="/tmp/tb_log"), # report learning rate after each epoch PredictionCallback() ] # ====================================================================================================================== # Tuner search # ====================================================================================================================== tuner.search(x=training_batch_generator, steps_per_epoch=steps_per_epoch, validation_data=validation_batch_generator, validation_steps=validation_steps - 1, epochs=3, callbacks=my_callbacks) # Show a summary of the search tuner.results_summary()
directory='models', project_name='lab1', ) tuner.search_space_summary() """**Очистка результатов в конце каждого шага обучения и поиск оптимальных гиперпараметров**""" class ClearTrainingOutput(Callback): def on_train_end(*args, **kwargs): IPython.display.clear_output(wait = True) tuner.search( x_train, y_train, validation_split=0.2, verbose=2, callbacks = [ClearTrainingOutput()], ) """**Создание модели**""" best_hps = tuner.get_best_hyperparameters()[0] model = tuner.hypermodel.build(best_hps) model.summary() """**Обучаем модель**""" history = model.fit(x_train, y_train, epochs=25, batch_size=30, validation_split=0.2, verbose=2) """**Сохраняем модель**"""
def run_model_fitting(PROJECT_NAME): """ """ SENTENCE_DECODER = pd.read_pickle( f'results\\objects\\{PROJECT_NAME}\\sentence_decoder.pkl') TARGET_DECODER = pd.read_pickle( f'results\\objects\\{PROJECT_NAME}\\target_decoder.pkl') TUNING_FRACTION = 0.1 BTCH_LIST = os.listdir(f'data\\preprocessed\\{PROJECT_NAME}\\inputs') BTCH = [i for i in range(len(BTCH_LIST))] BTCH = np.random.choice(BTCH, int(len(BTCH) * TUNING_FRACTION), replace=False) TR_BTCH = BTCH[:int(len(BTCH) * 0.8)] TS_BTCH = BTCH[int(len(BTCH) * 0.8):] tr_generator = DataGenerator(list_batches=TR_BTCH, project_name=PROJECT_NAME, shuffle=True, multi_target=True) ts_generator = DataGenerator(list_batches=TS_BTCH, project_name=PROJECT_NAME, shuffle=True, multi_target=True) model = LanguageModel(max_vocab=len(SENTENCE_DECODER) + 1, multi_target=True, max_target_1=len(SENTENCE_DECODER) + 1, max_target_2=len(TARGET_DECODER)) ES = EarlyStopping(monitor='val_loss', min_delta=0.0001, patience=5, verbose=1, mode='auto', restore_best_weights=True) tuner_obj = Hyperband(hypermodel=model, max_epochs=30, hyperband_iterations=1, objective='val_loss', directory='o', project_name=f'{PROJECT_NAME}') tuner_obj.search(tr_generator, epochs=30, callbacks=[ES], verbose=2, validation_data=ts_generator) BTCH = [i for i in range(len(BTCH_LIST))] BTCH = np.random.choice(BTCH, int(len(BTCH)), replace=False) TR_BTCH = BTCH[:int(len(BTCH) * 0.8)] TS_BTCH = BTCH[int(len(BTCH) * 0.8):] tr_generator = DataGenerator(list_batches=TR_BTCH, project_name=PROJECT_NAME, shuffle=True, multi_target=True) ts_generator = DataGenerator(list_batches=TS_BTCH, project_name=PROJECT_NAME, shuffle=True, multi_target=True) model = tuner_obj.get_best_models(1)[0] ES = EarlyStopping(monitor='val_loss', min_delta=0.0001, patience=5, verbose=1, mode='auto', restore_best_weights=True) model.fit(tr_generator, epochs=50, verbose=2, callbacks=[ES], validation_data=ts_generator) model.save(f'results\\models\\{PROJECT_NAME}')
from kerastuner.tuners import Hyperband #HYPERBAND_MAX_EPOCHS = 10 MAX_TRIALS = 5 tuner = Hyperband( build_model, max_epochs=4, objective='val_accuracy', directory='hyperband', project_name='cifar10' ) # starts building model tuner.search(train_images, train_labels, epochs = 3, validation_split = 0.12) model_2 = tuner.get_best_models(1)[0] model_2.summary() #predicting test accuracy model_2.fit(train_images, train_labels, epochs = 10, initial_epoch=3, validation_split = 0.15) score = model_2.evaluate(test_images, test_labels) print('Test loss:', score[0]) print('Test accuracy:', score[1])
tuner = Hyperband( build_model, objective=kt.Objective('val_IndVal_Final_layer_mape', direction='min'), max_epochs=400, hyperband_iterations=5, directory='HyperBandTrials', project_name='SN!Mult-valInd-Adam-KR-HPT' ) # Defining the Early Stopping Function early_stopping_callback = EarlyStopping(monitor='val_IndVal_Final_layer_mape', patience=500, min_delta= 1e-3, restore_best_weights=True, mode='auto', verbose=True) tuner.search_space_summary() print(model.summary()) tuner.search(X_train, (y_train_comb[:,0], y_train_comb[:,1]), epochs=5000, validation_data=(X_test, (y_test_comb[:,0], y_test_comb[:,1])), callbacks=[early_stopping_callback]) models = tuner.get_best_models(num_models=2) models[0].save('/mnt/IMP/Work/Thesis/NeuralNetwork/DeepLearning-RarefiedFlows/SavedModels/HyperBand/Adam/Best_Model_1/') models[1].save('/mnt/IMP/Work/Thesis/NeuralNetwork/DeepLearning-RarefiedFlows/SavedModels/HyperBand/Adam/Best_Model_2/') tuner.results_summary()
model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["categorical_accuracy"]) return model X,Y = next(imagenet_gen) trainX, testX, trainY, testY = train_test_split(X, Y, test_size=0.25) tuner = Hyperband( tuner_model, objective='val_categorical_accuracy', max_epochs=40, project_name='tuning_categorical' ) tuner.search_space_summary() tuner.search(trainX, trainY,epochs=25,validation_data=(testX, testY),verbose=0) tuner.results_summary() best_model = tuner.get_best_models(num_models=1)[0] # Evaluate the best model. loss, accuracy = best_model.evaluate(testX, testY) tuner.get_best_hyperparameters()[0].values """Pretty good results : 0.898 vs 0.7551 categorical accuracy ## Testing different applications (ResNet, Inception) """ from keras.applications import VGG16
# print(f'train_labels: \n{train_labels}') # ''' # model = build_model() # Build tuner tuner = Hyperband(build_model, objective='mse', max_epochs=100, executions_per_trial=5, directory='tuning', project_name='tuning') print(tuner.search_space_summary()) # Build tensorflow dataset dataset = tf.data.Dataset.from_tensor_slices( (train_data, train_labels)).batch(128) # Train Model tuner.search( dataset, shuffle=True, epochs=500, # war 10000 verbose=0) model = tuner.get_best_models(num_models=1) print(tuner.results_summary()) # Save model # model.save('model.h5') validate_model(model, test_data, test_labels) # validate_model(model, train_data, train_labels) # '''
for obj in metr: start = time.time() if obj == 'accuracy': goal = obj else: goal = kt.Objective('val_' + obj, direction="max") tuner = Hyperband(build_model, objective=goal, max_epochs=MAX_EPOCHS, factor=FACTOR, directory='my_dir', project_name='val_' + obj + '_' + time.ctime()) tuner.search(X_res, pd.get_dummies(y_res).values, epochs=MAX_EPOCHS, batch_size=2048, verbose=0, callbacks=[early_stops(obj)], validation_data=(X_val, pd.get_dummies(y_val).values)) end = time.time() print('Tuning time is %.2f' % (end - start)) print(tuner.oracle.get_best_trials(num_trials=1)[0].hyperparameters.values) bp = pd.Series( tuner.oracle.get_best_trials(num_trials=1)[0].hyperparameters.values, name=obj) #bp = bp.append(pd.Series(end-start,index=['Tuning_time'])) bps = pd.concat((bps, bp), axis=1) models = tuner.get_best_models(num_models=FACTOR) for i in range(FACTOR): Y_pred = models[i].predict(X_test)
hyperband_iterations=2, directory='HyperBandTrials', project_name='PressureOpti_hl') # Defining the Early Stopping Function early_stopping_callback = EarlyStopping(monitor='val_mape', patience=500, min_delta=1e-4, restore_best_weights=True, mode='auto', verbose=True) tuner.search_space_summary() print(model.summary()) tuner.search(X_train, y_train, epochs=2000, validation_data=(X_test, y_test), callbacks=[early_stopping_callback]) models = tuner.get_best_models(num_models=2) models[0].save( '/mnt/IMP/Work/Thesis/NeuralNetwork/DeepLearning-RarefiedFlows/SavedModels/Pressure/HyperBand_hl/Best_Model_1' ) models[1].save( '/mnt/IMP/Work/Thesis/NeuralNetwork/DeepLearning-RarefiedFlows/SavedModels/Pressure/HyperBand_hl/Best_Model_2' ) tuner.results_summary()
tuner = Hyperband(hypermodel, max_epochs=HYPERBAND_MAX_EPOCHS, objective='val_accuracy', seed=SEED, executions_per_trial=EXECUTION_PER_TRIAL, directory='hyperband', project_name='MNIST') # Search space summary of tuner tuner.search_space_summary() # Start the tuning N_EPOCH_SEARCH = 40 tuner.search(X_train_reshaped, y_train_reshaped, epochs=N_EPOCH_SEARCH, validation_split=0.1) # Summary of the results tuner.results_summary() # Retrieve best model best_model = tuner.get_best_models(num_models=1)[0] # Evaluate best model loss, accuracy = best_model.evaluate(X_test_reshaped, y_test_reshaped) print(f""" The hyperparameter search is complete. The optimal number of filters in the first convoluted layer is {best_model.get('num_filters_1')},
factor=0.5, patience=10, verbose=1, min_lr=1e-5) hypermodel = InceptionHyperModel(INPUT_SHAPE, NUM_CLASSES) tuner = Hyperband(hypermodel, objective='val_accuracy', max_epochs=20, directory=os.path.normpath('C:/'), project_name='birds225') tuner.search(x=train_gen, steps_per_epoch=TRAIN_STEP_SIZE, epochs=20, validation_data=valid_gen, validation_steps=VALID_STEP_SIZE) tuner.results_summary() best_hps = tuner.get_best_hyperparameters()[0] print('Optimal hyperparameters:') print('learning rate: ', best_hps.get('learning_rate')) print('filters 1: ', best_hps.get('filters1')) print('filters 2: ', best_hps.get('filters2')) print('filters 3: ', best_hps.get('filters3')) print('dense units: ', best_hps.get('dense_units')) print('dropout rate: ', best_hps.get('dropout_rate'))
for obj in metr: start = time.time() if obj in ['loss', 'accuracy']: goal = obj else: goal = kt.Objective('val_' + obj, direction="max") tuner = Hyperband(build_model, objective=goal, max_epochs=MAX_EPOCHS, factor=FACTOR, directory='my_dir', project_name='val_' + obj + '_' + time.ctime()) tuner.search(X_res, y_res, epochs=MAX_EPOCHS, batch_size=2048, verbose=0, callbacks=[early_stops(obj)], validation_data=(X_val, y_val)) end = time.time() print('Tuning time is %.2f' % (end - start)) print(tuner.oracle.get_best_trials(num_trials=1)[0].hyperparameters.values) bp = pd.Series( tuner.oracle.get_best_trials(num_trials=1)[0].hyperparameters.values, name=obj) #bp = bp.append(pd.Series(end-start,index=['Tuning_time'])) bps = pd.concat((bps, bp), axis=1) models = tuner.get_best_models(num_models=FACTOR) for i in range(FACTOR): Y_pred = models[i].predict(X_test)
loss='binary_crossentropy', metrics=['accuracy']) return model hypermodel = MyHyperModel(num_classes=1) tuner = Hyperband(hypermodel, objective='accuracy', max_epochs=10, seed=10, project_name='divorce test') tuner.search(X_train.values, y_train.values.flatten(), epochs=10, validation_data=(X_test.values, y_test.values.flatten())) params = tuner.get_best_hyperparameters()[0] model = tuner.hypermodel.build(params) model.fit(X.values, y.values.flatten(), epochs=20) hyperband_accuracy_df = pd.DataFrame(model.history.history) hyperband_accuracy_df[['loss', 'accuracy']].plot() plt.title('Loss & Accuracy Per EPOCH') plt.xlabel('EPOCH') plt.ylabel('Accruacy') plt.show()
#set up hyperband search strategy #parameters set due to memory constraints tuner_hb = Hyperband(hypermodel, max_epochs=200, objective='val_loss', metrics=[iou, iou_thresholded, 'mse'], distribution_strategy=tf.distribute.MirroredStrategy(), seed=42, hyperband_iterations=3) #print total search space tuner_hb.search_space_summary() #search through the total search space tuner_hb.search(train_generator, epochs=500, verbose=1, validation_data=(img_test, mask_test)) #save best model and hyperparameters best_model = tuner_hb.get_best_models(1)[0] best_hyperparameters = tuner_hb.get_best_hyperparameters(1)[0] print(tuner_hb.get_best_hyperparameters(1)) # model_json = best_model.to_json() with open("hp_bce_all_basicUNet_model.json", "w") as json_file: json_file.write(model_json) # serialize weights to HDF5 best_model.save_weights("hp_bce_all_tune_basicUNet_tuner_model.h5")
simpnet = SimpNet(config=Slim()) # simpnet = SimpNet(config=Full()) mode = 'test' if mode == 'tune': tuner = Hyperband( simpnet, objective='val_sparse_categorical_accuracy', max_epochs=15, hyperband_iterations=1, ) tuner.search( train, epochs=20, validation_data=test, callbacks=SimpNet.get_callbacks(), ) best_hps = tuner.get_best_hyperparameters(num_trials=1) # Build the model with the optimal hyperparameters and train it on the data for 50 epochs model = tuner.hypermodel.build(best_hps) history = model.fit( train, epochs=50, validation_data=test, callbacks=SimpNet.get_callbacks(), verbose=2, )
optimizer = hp.Choice('optimizer', ['adam', 'sgd', 'rmsprop']) model.compile( loss='categorical_crossentropy', optimizer = optimizer, metrics=['accuracy']) return model hyper_model = HyperResNet(input_shape=(IMG_WIDTH, IMG_WIDTH, 3), classes=28) # Hyperband serach, could use Random Search instead tuner = Hyperband( hypermodel=hyper_model, objective="val_accuracy", max_epochs=5, directory=DIR_NAME, project_name=PROJECT_NAME ) tuner.search_space_summary() tuner.search(img_gen_train, validation_data =(test, test_labels)) tuner.results_summary() best_model = tuner.get_best_models(num_models=1)[0] best_model.summary() with open("tuner"+PROJECT_NAME+".pkl", "wb") as f: pickle.dump(tuner, f)
def main(): metadata = load_metadata() # train_metadata2, test_metadata2 = load_metadata2() ''' Fraction of positive samples wanted in both test and validation set, the same as it is in the test set of the Kaggle Chest X-Ray Images (Pneumonia) dataset''' train_metadata, val_metadata, test_metadata = split_dataset(metadata, augmentation + 1) # train_metadata = train_metadata.head(8) # val_metadata = val_metadata.head(256) if augmentation > 0: pos_train_metadata = train_metadata[train_metadata['Pneumonia'] == 1] neg_train_metadata = train_metadata[train_metadata['Pneumonia'] == 0] pos_train_metadata_augmented = augment(metadata=pos_train_metadata, rate=augmentation, batch_size=16, seed=seed) train_metadata = pd.concat([pos_train_metadata, pos_train_metadata_augmented, neg_train_metadata], ignore_index=True) # train_metadata = pd.concat(([train_metadata, train_metadata2]), ignore_index=True) train_metadata = shuffle_DataFrame(train_metadata, seed) """val_metadata2, test_metadata2 = split_dataset2(test_metadata2) val_metadata = pd.concat(([val_metadata, val_metadata2]), ignore_index=True) test_metadata = pd.concat(([test_metadata, test_metadata2]), ignore_index=True)""" print('Train:') print(Counter(train_metadata['Pneumonia'])) print('Validation:') print(Counter(val_metadata['Pneumonia'])) print('Test:') print(Counter(test_metadata['Pneumonia'])) train_ds = make_pipeline(file_paths=train_metadata['File Path'].to_numpy(), y=train_metadata['Pneumonia'].to_numpy(), shuffle=True, batch_size=batch_size, seed=seed) val_ds = make_pipeline(file_paths=val_metadata['File Path'].to_numpy(), y=val_metadata['Pneumonia'].to_numpy(), shuffle=False, batch_size=val_batch_size) samples_ds = make_pipeline(file_paths=train_metadata['File Path'].to_numpy(), y=train_metadata['Pneumonia'].to_numpy(), shuffle=True, batch_size=16, seed=seed) show_samples(samples_ds) del samples_ds # Not needed anymore """str_time = datetime.datetime.now().strftime("%m%d-%H%M%S") log_dir = f'{logs_root}/{str_time}' logs_cb = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1, profile_batch=0) history = model.fit(x=train_ds, validation_data=val_ds, epochs=300, shuffle=False, callbacks=[logs_cb])""" # TODO what if I use val_loss instead? tuner = Hyperband(make_model_DenseNet121, objective=kt.Objective("val_auc", direction="max"), # Careful to keep the direction updated max_epochs=epochs_base, hyperband_iterations=2, directory='computations', project_name='base-1dataset-densenet121-auc-auc') early_stopping_cb = tf.keras.callbacks.EarlyStopping(monitor='val_auc', patience=patience) tuner.search(x=train_ds, validation_data=val_ds, epochs=epochs_base, shuffle=False, callbacks=[early_stopping_cb]) model_maker = ModelMaker(tuner) tuner_ft = Hyperband(model_maker.make_model_DenseNet121, objective=kt.Objective("val_auc", direction="max"), # Careful to keep the direction updated max_epochs=epochs_ft, hyperband_iterations=2, directory='computations', project_name='fine-1dataset-densenet121-auc-auc') early_stopping_cb = tf.keras.callbacks.EarlyStopping(monitor='val_auc', patience=patience) tuner_ft.search(x=train_ds, validation_data=val_ds, epochs=epochs_ft, shuffle=False, callbacks=[early_stopping_cb]) best_ft_model = tuner_ft.get_best_models()[0] test_ds = make_pipeline(file_paths=test_metadata['File Path'].to_numpy(), y=test_metadata['Pneumonia'].to_numpy(), shuffle=False, batch_size=val_batch_size) test_results = best_ft_model.evaluate(x=test_ds, return_dict=True, verbose=1) print('\nHyper-parameters for the fine-tuned model:') print(tuner_ft.get_best_hyperparameters()[0].values) print('\nTest results on the fine-tuned model:') print(test_results) hps = tuner_ft.get_best_hyperparameters()[0].values dev_metadata = pd.concat([train_metadata, val_metadata], ignore_index=True) dev_metadata = shuffle_DataFrame(dev_metadata, seed=seed) dev_metadata.reset_index(inplace=True, drop=True) fold_size = int(np.ceil(len(dev_metadata) / n_folds)) train_datasets, val_datasets = [], [] for fold in range(n_folds): fold_val_metadata = dev_metadata.iloc[fold * fold_size:fold * fold_size + fold_size, :] val_datasets.append(make_pipeline(file_paths=fold_val_metadata['File Path'].to_numpy(), y=fold_val_metadata['Pneumonia'].to_numpy(), batch_size=val_batch_size, shuffle=False)) fold_train_metadata1 = dev_metadata.iloc[:fold * fold_size, :] fold_train_metadata2 = dev_metadata.iloc[fold * fold_size + fold_size:, :] fold_train_metadata = pd.concat([fold_train_metadata1, fold_train_metadata2], ignore_index=False) train_datasets.append(make_pipeline(file_paths=fold_train_metadata['File Path'].to_numpy(), y=fold_train_metadata['Pneumonia'].to_numpy(), batch_size=batch_size, shuffle=True, seed=seed)) histories, means = k_fold_resumable_fit(model_maker=model_maker.make_model_DenseNet121, hp=hps, comp_dir='computations', project='xval', train_datasets=train_datasets, val_datasets=val_datasets, log_dir='computations/xval/logs', epochs=epochs_ft) print(histories) print(means) pass
val_generator = train_datagen.flow(img_test, mask_test) INPUT_SHAPE = images[0].shape NUM_CLASSES = 1 HYPERBAND_MAX_EPOCHS = 22 SEED = 2 hypermodel = HyperUNet(input_shape=INPUT_SHAPE, classes=NUM_CLASSES) tuner = Hyperband(hypermodel, max_epochs=HYPERBAND_MAX_EPOCHS, objective='val_accuracy', seed=SEED, executions_per_trial=22) tuner.search(train_generator, epochs=20, validation_data=val_generator) best_model = tuner.get_best_models(1)[0] best_hyperparameters = tuner.get_best_hyperparameters(1)[0] # model_json = best_model.to_json() with open("LGG_basicUNet_model.json", "w") as json_file: json_file.write(model_json) # serialize weights to HDF5 best_model.save_weights("LGG_basicUNet_tuner_model.h5") with open('best_LGG_basicUNet_Param.txt', 'w') as f: print(best_hyperparameters, file=f)