def test_trainer_regressor_train_valid_with_multiple_ndarray_inputs():
from deephyper.benchmark.nas.linearRegMultiInputs.problem import Problem
config = Problem.space
config["hyperparameters"]["num_epochs"] = 2
# load functions
load_data = util.load_attr_from(config["load_data"]["func"])
config["load_data"]["func"] = load_data
config["create_search_space"]["func"] = util.load_attr_from(
config["create_search_space"]["func"])
# Loading data
kwargs = config["load_data"].get("kwargs")
(tX, ty), (vX, vy) = load_data() if kwargs is None else load_data(**kwargs)
print("[PARAM] Data loaded")
# Set data shape
# interested in shape of data not in length
input_shape = [np.shape(itX)[1:] for itX in tX]
output_shape = list(np.shape(ty))[1:]
config["data"] = {
"train_X": tX,
"train_Y": ty,
"valid_X": vX,
"valid_Y": vy
}
search_space = config["create_search_space"]["func"](
input_shape, output_shape, **config["create_search_space"]["kwargs"])
arch_seq = [random() for i in range(search_space.num_nodes)]
print("arch_seq: ", arch_seq)
search_space.set_ops(arch_seq)
search_space.draw_graphviz("trainer_keras_regressor_test.dot")
if config.get("preprocessing") is not None:
preprocessing = util.load_attr_from(config["preprocessing"]["func"])
config["preprocessing"]["func"] = preprocessing
else:
config["preprocessing"] = None
model = search_space.create_model()
plot_model(model,
to_file="trainer_keras_regressor_test.png",
show_shapes=True)
trainer = TrainerTrainValid(config=config, model=model)
res = trainer.train()
assert res != sys.float_info.max
def test_trainer_regressor_train_valid_with_multiple_generator_inputs():
from deephyper.nas.run.util import (
load_config,
setup_data,
)
from deephyper.benchmark.nas.linearRegMultiInputsGen.problem import Problem
config = Problem.space
load_config(config)
input_shape, output_shape = setup_data(config)
create_search_space = config["create_search_space"]["func"]
cs_kwargs = config["create_search_space"].get("kwargs")
if cs_kwargs is None:
search_space = create_search_space(input_shape, output_shape, seed=42)
else:
search_space = create_search_space(input_shape,
output_shape,
seed=42,
**cs_kwargs)
arch_seq = [random() for i in range(search_space.num_nodes)]
config["arch_seq"] = arch_seq
search_space.set_ops(arch_seq)
config["hyperparameters"]["num_epochs"] = 2
search_space.set_ops(arch_seq)
search_space.draw_graphviz("trainer_keras_regressor_test.dot")
model = search_space.create_model()
plot_model(model,
to_file="trainer_keras_regressor_test.png",
show_shapes=True)
trainer = TrainerTrainValid(config=config, model=model)
res = trainer.train()
assert res != sys.float_info.max
def train(config):
seed = config["seed"]
repeat = config["post_train"]["repeat"]
if seed is not None:
np.random.seed(seed)
# must be between (0, 2**32-1)
seeds = [np.random.randint(0, 2**32 - 1) for _ in range(repeat)]
for rep in range(repeat):
tf.keras.backend.clear_session()
default_callbacks_config = copy.deepcopy(CB_CONFIG)
if seed is not None:
np.random.seed(seeds[rep])
tf.random.set_seed(seeds[rep])
logger.info(f"Training replica {rep+1}")
# Pre-settings: particularly import for BeholderCB to work
sess = tf.Session()
K.set_session(sess)
# override hyperparameters with post_train hyperparameters
keys = filter(lambda k: k in config["hyperparameters"],
config["post_train"].keys())
for k in keys:
config["hyperparameters"][k] = config["post_train"][k]
load_config(config)
input_shape, output_shape = setup_data(config)
search_space = setup_search_space(config,
input_shape,
output_shape,
seed=seed)
search_space.draw_graphviz(f'model_{config["id"]}.dot')
logger.info("Model operations set.")
model_created = False
try:
model = search_space.create_model()
model_created = True
except:
model_created = False
logger.info("Error: Model creation failed...")
logger.info(traceback.format_exc())
if model_created:
# model.load_weights(default_cfg['model_checkpoint']['filepath'])
# Setup callbacks
callbacks = []
callbacks_config = config["post_train"].get("callbacks")
if callbacks_config is not None:
for cb_name, cb_conf in callbacks_config.items():
if cb_name in default_callbacks_config:
default_callbacks_config[cb_name].update(cb_conf)
if cb_name == "ModelCheckpoint":
default_callbacks_config[cb_name][
"filepath"] = f'best_model_id{config["id"]}_r{rep}.h5'
elif cb_name == "TensorBoard":
if default_callbacks_config[cb_name]["beholder"]:
callbacks.append(
BeholderCB(
logdir=default_callbacks_config[
cb_name]["log_dir"],
sess=sess,
))
default_callbacks_config[cb_name].pop("beholder")
Callback = getattr(keras.callbacks, cb_name)
callbacks.append(
Callback(**default_callbacks_config[cb_name]))
logger.info(
f"Adding new callback {type(Callback).__name__} with config: {default_callbacks_config[cb_name]}!"
)
else:
logger.error(
f"'{cb_name}' is not an accepted callback!")
trainer = TrainerTrainValid(config=config, model=model)
trainer.callbacks.extend(callbacks)
json_fname = f'post_training_hist_{config["id"]}.json'
# to log the number of trainable parameters before running training
trainer.init_history()
try:
with open(json_fname, "r") as f:
fhist = json.load(f)
except FileNotFoundError:
fhist = trainer.train_history
for k, v in fhist.items():
fhist[k] = [v]
with open(json_fname, "w") as f:
json.dump(fhist, f, cls=Encoder)
hist = trainer.train(with_pred=False, last_only=False)
# Timing of prediction for validation dataset
t = time() # ! TIMING - START
trainer.predict(dataset="valid")
hist["val_predict_time"] = time() - t # ! TIMING - END
for k, v in hist.items():
fhist[k] = fhist.get(k, [])
fhist[k].append(v)
with open(json_fname, "w") as f:
json.dump(fhist, f, cls=Encoder)
return model
def run(config):
physical_devices = tf.config.list_physical_devices("GPU")
try:
for i in range(len(physical_devices)):
tf.config.experimental.set_memory_growth(physical_devices[i], True)
except:
# Invalid device or cannot modify virtual devices once initialized.
pass
distributed_strategy = tf.distribute.MirroredStrategy()
n_replicas = distributed_strategy.num_replicas_in_sync
seed = config["seed"]
if seed is not None:
np.random.seed(seed)
tf.random.set_seed(seed)
load_config(config)
# Scale batch size and learning rate according to the number of ranks
if config[a.hyperparameters].get("lsr_batch_size"):
batch_size = config[a.hyperparameters][a.batch_size] * n_replicas
else:
batch_size = config[a.hyperparameters][a.batch_size]
if config[a.hyperparameters].get("lsr_learning_rate"):
learning_rate = config[a.hyperparameters][a.learning_rate] * n_replicas
else:
learning_rate = config[a.hyperparameters][a.learning_rate]
logger.info(
f"Scaled: 'batch_size' from {config[a.hyperparameters][a.batch_size]} to {batch_size} "
)
logger.info(
f"Scaled: 'learning_rate' from {config[a.hyperparameters][a.learning_rate]} to {learning_rate} "
)
config[a.hyperparameters][a.batch_size] = batch_size
config[a.hyperparameters][a.learning_rate] = learning_rate
input_shape, output_shape = setup_data(config)
search_space = setup_search_space(config,
input_shape,
output_shape,
seed=seed)
model_created = False
with distributed_strategy.scope():
try:
model = search_space.create_model()
model_created = True
except:
logger.info("Error: Model creation failed...")
logger.info(traceback.format_exc())
else:
# Setup callbacks
callbacks = []
cb_requires_valid = False # Callbacks requires validation data
callbacks_config = config["hyperparameters"].get("callbacks")
if callbacks_config is not None:
for cb_name, cb_conf in callbacks_config.items():
if cb_name in default_callbacks_config:
default_callbacks_config[cb_name].update(cb_conf)
# Special dynamic parameters for callbacks
if cb_name == "ModelCheckpoint":
default_callbacks_config[cb_name][
"filepath"] = f'best_model_{config["id"]}.h5'
# replace patience hyperparameter
if "patience" in default_callbacks_config[cb_name]:
patience = config["hyperparameters"].get(
f"patience_{cb_name}")
if patience is not None:
default_callbacks_config[cb_name][
"patience"] = patience
# Import and create corresponding callback
Callback = import_callback(cb_name)
callbacks.append(
Callback(**default_callbacks_config[cb_name]))
if cb_name in ["EarlyStopping"]:
cb_requires_valid = "val" in cb_conf[
"monitor"].split("_")
else:
logger.error(
f"'{cb_name}' is not an accepted callback!")
trainer = TrainerTrainValid(config=config, model=model)
trainer.callbacks.extend(callbacks)
last_only, with_pred = preproc_trainer(config)
last_only = last_only and not cb_requires_valid
if model_created:
history = trainer.train(with_pred=with_pred, last_only=last_only)
# save history
save_history(config.get("log_dir", None), history, config)
result = compute_objective(config["objective"], history)
else:
# penalising actions if model cannot be created
result = -1
if result < -10 or np.isnan(result):
result = -10
return result
def run(config: dict) -> float:
# Threading configuration
if os.environ.get("OMP_NUM_THREADS", None) is not None:
logger.debug(f"OMP_NUM_THREADS is {os.environ.get('OMP_NUM_THREADS')}")
num_intra = int(os.environ.get("OMP_NUM_THREADS"))
tf.config.threading.set_intra_op_parallelism_threads(num_intra)
tf.config.threading.set_inter_op_parallelism_threads(2)
seed = config["seed"]
if seed is not None:
np.random.seed(seed)
tf.random.set_seed(seed)
load_config(config)
input_shape, output_shape = setup_data(config)
search_space = setup_search_space(config,
input_shape,
output_shape,
seed=seed)
model_created = False
try:
model = search_space.create_model()
model_created = True
except:
logger.info("Error: Model creation failed...")
logger.info(traceback.format_exc())
if model_created:
# Setup callbacks
callbacks = []
cb_requires_valid = False # Callbacks requires validation data
callbacks_config = config["hyperparameters"].get("callbacks")
if callbacks_config is not None:
for cb_name, cb_conf in callbacks_config.items():
if cb_name in default_callbacks_config:
default_callbacks_config[cb_name].update(cb_conf)
# Special dynamic parameters for callbacks
if cb_name == "ModelCheckpoint":
default_callbacks_config[cb_name][
"filepath"] = f'best_model_{config["id"]}.h5'
# replace patience hyperparameter
if "patience" in default_callbacks_config[cb_name]:
patience = config["hyperparameters"].get(
f"patience_{cb_name}")
if patience is not None:
default_callbacks_config[cb_name][
"patience"] = patience
# Import and create corresponding callback
Callback = import_callback(cb_name)
callbacks.append(
Callback(**default_callbacks_config[cb_name]))
if cb_name in ["EarlyStopping"]:
cb_requires_valid = "val" in cb_conf["monitor"].split(
"_")
else:
logger.error(f"'{cb_name}' is not an accepted callback!")
trainer = TrainerTrainValid(config=config, model=model)
trainer.callbacks.extend(callbacks)
last_only, with_pred = preproc_trainer(config)
last_only = last_only and not cb_requires_valid
history = trainer.train(with_pred=with_pred, last_only=last_only)
# save history
save_history(config.get("log_dir", None), history, config)
result = compute_objective(config["objective"], history)
else:
# penalising actions if model cannot be created
result = -1
if result < -10 or np.isnan(result):
result = -10
return result