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)
