def objective(trial: optuna.Trial):
negative_rate = trial.suggest_categorical("negative_rate",
[10, 20, 30, 40, 50, 60])
in_dim = trial.suggest_categorical('input dim', [100, 200, 500, 1000])
out_dim = in_dim
alpha = trial.suggest_loguniform('alpha', 2e-6, 2e-1)
return run_experiment(negative_rate, in_dim, out_dim, alpha)
def objective(trial: Trial) -> float:
trial.set_user_attr('method', 'sdne')
classifier = classifier_type
if classifier is None:
classifier = trial.suggest_categorical('classifier',
['SVM', 'EN', 'RF', 'LR'])
else:
trial.set_user_attr('classifier', classifier)
alpha = trial.suggest_uniform('alpha', 0, 0.4)
beta = trial.suggest_int('beta', 0, 30)
epochs = trial.suggest_categorical('epochs', [5, 10, 15, 20, 25, 30])
# Set the inner trial seed
_set_trial_seed(trial)
model = embed_train.train_embed_sdne(
train_graph_filename=train_graph_filename,
alpha=alpha,
beta=beta,
epochs=epochs,
weighted=weighted,
)
return predict_and_evaluate(
prediction_task=prediction_task,
model=model,
graph=graph,
graph_train=graph_train,
testing_pos_edges=testing_pos_edges,
seed=study_seed,
trial=trial,
labels=labels,
node_list=node_list,
classifier_type=classifier,
)
def sample_a2c_params(trial: optuna.Trial) -> Dict[str, Any]:
"""
Sampler for A2C hyperparams.
:param trial:
:return:
"""
gamma = trial.suggest_categorical("gamma", [0.9, 0.95, 0.98, 0.99, 0.995, 0.999, 0.9999])
normalize_advantage = trial.suggest_categorical("normalize_advantage", [False, True])
max_grad_norm = trial.suggest_categorical("max_grad_norm", [0.3, 0.5, 0.6, 0.7, 0.8, 0.9, 1, 2, 5])
use_rms_prop = trial.suggest_categorical("use_rms_prop", [False, True])
gae_lambda = trial.suggest_categorical("gae_lambda", [0.8, 0.9, 0.92, 0.95, 0.98, 0.99, 1.0])
n_steps = trial.suggest_categorical("n_steps", [8, 16, 32, 64, 128, 256, 512, 1024, 2048])
lr_schedule = trial.suggest_categorical("lr_schedule", ["linear", "constant"])
learning_rate = trial.suggest_loguniform("lr", 1e-5, 1)
ent_coef = trial.suggest_loguniform("ent_coef", 0.00000001, 0.1)
vf_coef = trial.suggest_uniform("vf_coef", 0, 1)
log_std_init = trial.suggest_uniform("log_std_init", -4, 1)
ortho_init = trial.suggest_categorical("ortho_init", [False, True])
net_arch = trial.suggest_categorical("net_arch", ["small", "medium"])
# sde_net_arch = trial.suggest_categorical("sde_net_arch", [None, "tiny", "small"])
# full_std = trial.suggest_categorical("full_std", [False, True])
# activation_fn = trial.suggest_categorical('activation_fn', ['tanh', 'relu', 'elu', 'leaky_relu'])
activation_fn = trial.suggest_categorical("activation_fn", ["tanh", "relu"])
if lr_schedule == "linear":
learning_rate = linear_schedule(learning_rate)
net_arch = {
"small": [dict(pi=[64, 64], vf=[64, 64])],
"medium": [dict(pi=[256, 256], vf=[256, 256])],
}[net_arch]
# sde_net_arch = {
# None: None,
# "tiny": [64],
# "small": [64, 64],
# }[sde_net_arch]
activation_fn = {"tanh": nn.Tanh, "relu": nn.ReLU, "elu": nn.ELU, "leaky_relu": nn.LeakyReLU}[activation_fn]
return {
"n_steps": n_steps,
"gamma": gamma,
"gae_lambda": gae_lambda,
"learning_rate": learning_rate,
"ent_coef": ent_coef,
"normalize_advantage": normalize_advantage,
"max_grad_norm": max_grad_norm,
"use_rms_prop": use_rms_prop,
"vf_coef": vf_coef,
"policy_kwargs": dict(
log_std_init=log_std_init,
net_arch=net_arch,
# full_std=full_std,
activation_fn=activation_fn,
# sde_net_arch=sde_net_arch,
ortho_init=ortho_init,
),
}
def sample_ppo_params(trial: optuna.Trial) -> Dict[str, Any]:
"""
Sampler for PPO2 hyperparams.
:param trial:
:return:
"""
batch_size = trial.suggest_categorical("batch_size", [8, 16, 32, 64, 128, 256, 512])
n_steps = trial.suggest_categorical("n_steps", [8, 16, 32, 64, 128, 256, 512, 1024, 2048])
gamma = trial.suggest_categorical("gamma", [0.9, 0.95, 0.98, 0.99, 0.995, 0.999, 0.9999])
learning_rate = trial.suggest_loguniform("lr", 1e-5, 1)
lr_schedule = "constant"
# lr_schedule = trial.suggest_categorical('lr_schedule', ['linear', 'constant'])
ent_coef = trial.suggest_loguniform("ent_coef", 0.00000001, 0.1)
clip_range = trial.suggest_categorical("clip_range", [0.1, 0.2, 0.3, 0.4])
n_epochs = trial.suggest_categorical("n_epochs", [1, 5, 10, 20])
gae_lambda = trial.suggest_categorical("gae_lambda", [0.8, 0.9, 0.92, 0.95, 0.98, 0.99, 1.0])
max_grad_norm = trial.suggest_categorical("max_grad_norm", [0.3, 0.5, 0.6, 0.7, 0.8, 0.9, 1, 2, 5])
vf_coef = trial.suggest_uniform("vf_coef", 0, 1)
net_arch = trial.suggest_categorical("net_arch", ["small", "medium"])
log_std_init = trial.suggest_uniform("log_std_init", -4, 1)
sde_sample_freq = trial.suggest_categorical("sde_sample_freq", [-1, 8, 16, 32, 64, 128, 256])
ortho_init = False
# ortho_init = trial.suggest_categorical('ortho_init', [False, True])
# activation_fn = trial.suggest_categorical('activation_fn', ['tanh', 'relu', 'elu', 'leaky_relu'])
activation_fn = trial.suggest_categorical("activation_fn", ["tanh", "relu"])
# TODO: account when using multiple envs
if batch_size > n_steps:
batch_size = n_steps
if lr_schedule == "linear":
learning_rate = linear_schedule(learning_rate)
net_arch = {
"small": [dict(pi=[64, 64], vf=[64, 64])],
"medium": [dict(pi=[256, 256], vf=[256, 256])],
}[net_arch]
activation_fn = {"tanh": nn.Tanh, "relu": nn.ReLU, "elu": nn.ELU, "leaky_relu": nn.LeakyReLU}[activation_fn]
return {
"n_steps": n_steps,
"batch_size": batch_size,
"gamma": gamma,
"learning_rate": learning_rate,
"ent_coef": ent_coef,
"clip_range": clip_range,
"n_epochs": n_epochs,
"gae_lambda": gae_lambda,
"max_grad_norm": max_grad_norm,
"vf_coef": vf_coef,
"sde_sample_freq": sde_sample_freq,
"policy_kwargs": dict(
log_std_init=log_std_init,
net_arch=net_arch,
activation_fn=activation_fn,
ortho_init=ortho_init,
),
}
def rf_from_trial(trial: optuna.Trial):
max_leaf_nodes = trial.suggest_categorical('max_leaf_nodes_type',
['unlimited', 'limited'])
if max_leaf_nodes == 'unlimited':
max_leaf_nodes = None
else:
max_leaf_nodes = trial.suggest_int('max_leaf_nodes', 1, 1000)
params = {
'n_estimators':
trial.suggest_int('n_estimators', 10, 300),
'criterion':
trial.suggest_categorical('criterion', ['mse', 'mae']),
'min_samples_split':
trial.suggest_uniform('min_samples_split', 0., 1.),
'min_samples_leaf':
trial.suggest_uniform('min_samples_leaf', 0., .5),
'max_features':
trial.suggest_categorical('max_features',
['auto', 'log2', 'sqrt', None]),
'max_leaf_nodes':
max_leaf_nodes,
'random_state':
trial.suggest_int('random_state', 0, 999999),
'n_jobs':
-1,
'verbose':
1
}
return RandomForestRegressor(**params)
def objective(self, trial: Trial) -> float:
suggest: Dict[str, Union[bool, float, int, str]] = {
"n_estimators":
trial.suggest_int("n_estimators", self.params["n_estimators"][0],
self.params["n_estimators"][1]),
"max_depth":
trial.suggest_int("max_depth", self.params["max_depth"][0],
self.params["max_depth"][1]),
"max_features":
trial.suggest_categorical("max_features",
self.params["max_features"]),
"min_samples_leaf":
trial.suggest_loguniform(
"min_samples_leaf",
self.params["min_samples_leaf"][0],
self.params["min_samples_leaf"][1],
),
"min_samples_split":
trial.suggest_loguniform(
"min_samples_split",
self.params["min_samples_split"][0],
self.params["min_samples_split"][1],
),
"bootstrap":
trial.suggest_categorical("bootstrap", (True, False)),
}
est: BaseEstimator = self.model.__class__(**suggest)
return -cross_val_score(estimator=est,
X=self.X,
y=self.y,
cv=self.cv,
scoring="neg_mean_squared_error").mean()
def objective(trial:Trial, data, target):
train_x, valid_x, train_y, valid_y = train_test_split(data, target, test_size=0.25)
dtrain = xgb.DMatrix(train_x, label=train_y)
dvalid = xgb.DMatrix(valid_x, label=valid_y)
param = {
"verbosity": 0,
"objective": "binary:logistic",
"booster": trial.suggest_categorical("booster", ["gbtree", "gblinear", "dart"]),
"lambda": trial.suggest_float("lambda", 1e-8, 1.0, log=True),
"alpha": trial.suggest_float("alpha", 1e-8, 1.0, log=True),
}
if param["booster"] == "gbtree" or param["booster"] == "dart":
param["max_depth"] = trial.suggest_int("max_depth", 1, 9)
param["eta"] = trial.suggest_float("eta", 1e-8, 1.0, log=True)
param["gamma"] = trial.suggest_float("gamma", 1e-8, 1.0, log=True)
param["grow_policy"] = trial.suggest_categorical("grow_policy", ["depthwise", "lossguide"])
if param["booster"] == "dart":
param["sample_type"] = trial.suggest_categorical("sample_type", ["uniform", "weighted"])
param["normalize_type"] = trial.suggest_categorical("normalize_type", ["tree", "forest"])
param["rate_drop"] = trial.suggest_float("rate_drop", 1e-8, 1.0, log=True)
param["skip_drop"] = trial.suggest_float("skip_drop", 1e-8, 1.0, log=True)
bst = xgb.train(param, dtrain)
preds = bst.predict(dvalid)
pred_labels = np.rint(preds)
precision = sklearn.metrics.f1_score(valid_y, pred_labels)
return precision
def objective(trial: optuna.Trial, hparams: Namespace):
"""Return the objective loss for an optuna trial.
Args:
trial (optuna.Trial): The optuna trial.
hparams (Namespace): The argparse `Namespace` that will be passed to
the `LightningModule`.
"""
hparams.loss = trial.suggest_categorical(
'loss', ['CrossEntropy', 'TripletMargin', 'ArcFace'])
if hparams.loss == 'ArcFace':
hparams.loss_margin = trial.suggest_uniform('loss_margin', 0.3, 0.9)
hparams.sampler = None
elif hparams.loss == 'TripletMargin':
hparams.loss_margin = trial.suggest_uniform('loss_margin', 0, 0.2)
hparams.sampler = 'MPerClass'
hparams.m_per_class = 5
hparams.miner = trial.suggest_categorical('miner', ['BatchHard', None])
hparams.optim = 'SGD'
hparams.lr = trial.suggest_loguniform('lr', 1e-8, 1e0)
max_steps = 1e4
hparams.lr_sched = trial.suggest_categorical('lr_sched',
[None, 'OneCycleLr'])
if hparams.lr_sched == 'OneCycleLR':
hparams.lr_sched_total_steps = max_steps
hparams.lr_sched_max_lr = 10 * hparams.lr
hparams.use_sample_data = True
def get_parameters(self, trial: optuna.Trial):
kwargs = {
'stop_loss':
trial.suggest_int("stop_loss", 1, 200, step=10),
'slope_average':
trial.suggest_categorical('slope_average', ['ema', 'sma']),
'slope_ma_length':
trial.suggest_int('slope_ma_length', 5, 610),
'slope_fast_length':
trial.suggest_int('slope_fast_length', 5, 610),
'slope_slow_length':
trial.suggest_int('slope_slow_length', 5, 610),
'slope_trend_filter_enable':
trial.suggest_categorical('slope_trend_filter_enable',
[True, False]),
}
if kwargs['slope_fast_length'] >= kwargs['slope_slow_length']:
raise optuna.exceptions.TrialPruned(
"slope_fast_length >= slope_slow_length")
if kwargs['slope_trend_filter_enable']:
kwargs['slope_trend_filter_length'] = trial.suggest_int(
'slope_trend_filter_length', 5, 610)
return kwargs
def optimal_params(trial: optuna.Trial):
params = {}
penalty = trial.suggest_categorical("penalty", ["l1", "l2"])
params["penalty"] = penalty
tol = trial.suggest_uniform("tol", 1e-5, 1e-3)
params["tol"] = tol
C = trial.suggest_uniform("C", 1e-4, 10)
params["C"] = C
params["random_state"] = 42
if penalty == "l2":
solver = trial.suggest_categorical(
"solver", ["newton-cg", "lbfgs", "sag", "saga"])
params["solver"] = solver
else:
params["solver"] = "saga"
params["max_iter"] = 10000
params["multi_class"] = "auto"
oof_preds = np.zeros((X.shape[0], ))
fold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
for (trn_index, val_index) in fold.split(X, y):
X_train, X_val = X[trn_index], X[val_index]
y_train = y[trn_index]
model = LogisticRegression(**params)
model.fit(X_train, y_train)
y_pred = model.predict(X_val)
oof_preds[val_index] = y_pred
f1 = f1_score(y, oof_preds, average="macro")
return 1.0 - f1
def suggest_kwargs(
trial: Trial,
prefix: str,
kwargs_ranges: Mapping[str, Any],
kwargs: Optional[Mapping[str, Any]] = None,
):
_kwargs = {}
if kwargs:
_kwargs.update(kwargs)
for name, info in kwargs_ranges.items():
if name in _kwargs:
continue # has been set by default, won't be suggested
prefixed_name = f'{prefix}.{name}'
dtype, low, high = info['type'], info.get('low'), info.get('high')
if dtype in {int, 'int'}:
q, scale = info.get('q'), info.get('scale')
if scale == 'power_two':
_kwargs[name] = suggest_discrete_power_two_int(
trial=trial,
name=prefixed_name,
low=low,
high=high,
)
elif q is not None:
_kwargs[name] = suggest_discrete_uniform_int(
trial=trial,
name=prefixed_name,
low=low,
high=high,
q=q,
)
else:
_kwargs[name] = trial.suggest_int(name=prefixed_name,
low=low,
high=high)
elif dtype in {float, 'float'}:
if info.get('scale') == 'log':
_kwargs[name] = trial.suggest_loguniform(name=prefixed_name,
low=low,
high=high)
else:
_kwargs[name] = trial.suggest_uniform(name=prefixed_name,
low=low,
high=high)
elif dtype == 'categorical':
choices = info['choices']
_kwargs[name] = trial.suggest_categorical(name=prefixed_name,
choices=choices)
elif dtype in {bool, 'bool'}:
_kwargs[name] = trial.suggest_categorical(name=prefixed_name,
choices=[True, False])
else:
logger.warning(
f'Unhandled data type ({dtype}) for parameter {name}')
return _kwargs
def get_trial_hyperparameters(self, trial: optuna.Trial) -> dict:
if self.model_class == models.LinearColaborativeFilteringModel:
learning_rate = trial.suggest_uniform('learning_rate', 1e-5, 1e-1)
number_of_epochs = int(
trial.suggest_int('number_of_epochs', 10, 15))
batch_size = int(
trial.suggest_categorical('batch_size',
[2**power
for power in range(6, 12)]))
gradient_clip_val = trial.suggest_uniform('gradient_clip_val', 1.0,
1.0)
embedding_size = int(trial.suggest_int('embedding_size', 100, 500))
regularization_factor = trial.suggest_uniform(
'regularization_factor', 1, 100)
dropout_probability = trial.suggest_uniform(
'dropout_probability', 0.0, 1.0)
hyperparameters = {
'learning_rate': learning_rate,
'number_of_epochs': number_of_epochs,
'batch_size': batch_size,
'gradient_clip_val': gradient_clip_val,
'embedding_size': embedding_size,
'regularization_factor': regularization_factor,
'dropout_probability': dropout_probability,
}
elif self.model_class == models.DeepConcatenationColaborativeFilteringModel:
learning_rate = trial.suggest_uniform('learning_rate', 1e-4, 1e-3)
number_of_epochs = int(
trial.suggest_int('number_of_epochs', 10, 15))
batch_size = int(
trial.suggest_categorical('batch_size',
[2**power
for power in range(6, 12)]))
gradient_clip_val = trial.suggest_uniform('gradient_clip_val', 1.0,
1.0)
embedding_size = int(trial.suggest_int('embedding_size', 100, 500))
dense_layer_count = int(
trial.suggest_int('dense_layer_count', 1, 4))
regularization_factor = trial.suggest_uniform(
'regularization_factor', 1, 100)
dropout_probability = trial.suggest_uniform(
'dropout_probability', 0.0, 0.75)
hyperparameters = {
'learning_rate': learning_rate,
'number_of_epochs': number_of_epochs,
'batch_size': batch_size,
'gradient_clip_val': gradient_clip_val,
'embedding_size': embedding_size,
'dense_layer_count': dense_layer_count,
'regularization_factor': regularization_factor,
'dropout_probability': dropout_probability,
}
else:
raise ValueError(f'Unrecognized model {model_class}')
return hyperparameters
def knn(trial: optuna.Trial):
n_neighbors = trial.suggest_int("n_neighbors", 1, 10)
weights = trial.suggest_categorical("weights", ['uniform', 'distance'])
algorithm = trial.suggest_categorical("algorithm",
['ball_tree', 'kd_tree'])
leaf_size = trial.suggest_int('leaf_size', 1, 50)
classifier = sklearn.neighbors.KNeighborsClassifier(
n_neighbors=n_neighbors,
weights=weights,
algorithm=algorithm,
leaf_size=leaf_size)
return evaluate_classifier(classifier)
def objective(self, trial: optuna.Trial) -> float:
trial.suggest_float('lr', 1e-6, 1e-4)
trial.suggest_categorical('batch_size', [4, 8, 14])
trial.suggest_float('weight_decay', 0.0, 0.1)
trial.suggest_float('dropout', 0.0, 0.8)
executor = optuna.integration.allennlp.AllenNLPExecutor(
trial=trial,
config_file=self.config_file,
serialization_dir=self.MODEL_PATH + f'/trial_{trial.number}',
metrics='best_validation_f1-measure-overall')
return executor.run()
def suggest_kwargs(
trial: Trial,
prefix: str,
kwargs_ranges: Mapping[str, Any],
kwargs: Optional[Mapping[str, Any]] = None,
) -> Mapping[str, Any]:
_kwargs: Dict[str, Any] = {}
if kwargs:
_kwargs.update(kwargs)
for name, info in kwargs_ranges.items():
if name in _kwargs:
continue # has been set by default, won't be suggested
prefixed_name = f'{prefix}.{name}'
dtype, low, high = info['type'], info.get('low'), info.get('high')
if dtype in {int, 'int'}:
scale = info.get('scale')
if scale in {'power_two', 'power'}:
_kwargs[name] = suggest_discrete_power_int(
trial=trial,
name=prefixed_name,
low=low,
high=high,
base=info.get('q') or info.get('base') or 2,
)
elif scale is None or scale == 'linear':
# get log from info - could either be a boolean or string
log = info.get('log') in {True, 'TRUE', 'True', 'true', 't', 'YES', 'Yes', 'yes', 'y'}
_kwargs[name] = trial.suggest_int(
name=prefixed_name,
low=low,
high=high,
step=info.get('q') or info.get('step') or 1,
log=log,
)
else:
logger.warning(f'Unhandled scale {scale} for parameter {name} of data type {dtype}')
elif dtype in {float, 'float'}:
if info.get('scale') == 'log':
_kwargs[name] = trial.suggest_loguniform(name=prefixed_name, low=low, high=high)
else:
_kwargs[name] = trial.suggest_uniform(name=prefixed_name, low=low, high=high)
elif dtype == 'categorical':
choices = info['choices']
_kwargs[name] = trial.suggest_categorical(name=prefixed_name, choices=choices)
elif dtype in {bool, 'bool'}:
_kwargs[name] = trial.suggest_categorical(name=prefixed_name, choices=[True, False])
else:
logger.warning(f'Unhandled data type ({dtype}) for parameter {name}')
return _kwargs
def sample_clustering_config_with_optuna(trial: Trial) -> Dict:
"""
Uses optuna to sample a config dictionary with clustering parameters.
:param trial: optuna trial
:return: config dictionary
"""
cluster_criterion = trial.suggest_categorical("cluster_criterion", ['inconsistent', 'distance', 'maxclust'])
cluster_depth = 0 if not cluster_criterion == 'inconsistent' else trial.suggest_int("cluster_depth", low=1, high=10)
clustering_config = {"threshold": trial.suggest_uniform("threshold", 0, 1),
"linkage_method": trial.suggest_categorical("linkage_method", ['single', 'complete', 'average', 'weighted', 'centroid', 'median', 'ward']),
"cluster_criterion": cluster_criterion,
"cluster_depth": cluster_depth}
return clustering_config
def mlp(trial: optuna.Trial):
hidden_layer_size = trial.suggest_int("hidden_layer_size", 10, 1000, 10)
hidden_layer_count = trial.suggest_int("hidden_layer_count", 1, 10)
hidden_layer = (hidden_layer_size, ) * hidden_layer_count
activation_fun = trial.suggest_categorical("activation_fun",
['identity', 'tanh', 'relu'])
alpha = trial.suggest_float("alpha", 0.000001, 0.0001)
learning_rate = trial.suggest_categorical(
'learning_rate', ['constant', 'invscaling', 'adaptive'])
classifier = MLPClassifier(hidden_layer_sizes=hidden_layer,
activation=activation_fun,
alpha=alpha,
learning_rate=learning_rate)
return evaluate_classifier(classifier)
def evaluate_params(self, trial: optuna.Trial):
params = dict()
params['model_type'] = trial.suggest_categorical(
'model_type', ['dnn', 'cnn'])
if params['model_type'] == 'dnn':
params['l1_units'] = trial.suggest_categorical(
'l1_units', [8, 16, 32, 64])
params['l1_activation'] = trial.suggest_categorical(
'l1_activation', ['relu', 'sigmoid', 'linear'])
params['l2_units'] = trial.suggest_categorical(
'l2_units', [8, 16, 32, 64])
params['l2_activation'] = trial.suggest_categorical(
'l2_activation', ['relu', 'sigmoid', 'linear'])
elif params['model_type'] == 'cnn':
params['cnn_l1_filters'] = trial.suggest_categorical(
'cnn_l1_filters', [8, 16, 32, 64])
params['cnn_dense_l1_units'] = trial.suggest_categorical(
'cnn_dense_l1_units', [8, 16, 32, 64])
params['cnn_dense_l2_units'] = trial.suggest_categorical(
'cnn_dense_l2_units', [8, 16, 32, 64])
if trial.should_prune():
raise optuna.structs.TrialPruned()
return self.run_model(params, trial.number)
def sample_ddpg_params(trial: optuna.Trial) -> Dict[str, Any]:
"""
Sampler for DDPG hyperparams.
:param trial:
:return:
"""
gamma = trial.suggest_categorical("gamma", [0.9, 0.95, 0.98, 0.99, 0.995, 0.999, 0.9999])
learning_rate = trial.suggest_loguniform("lr", 1e-5, 1)
batch_size = trial.suggest_categorical("batch_size", [16, 32, 64, 100, 128, 256, 512, 1024, 2048])
buffer_size = trial.suggest_categorical("buffer_size", [int(1e4), int(1e5), int(1e6)])
# Polyak coeff
tau = trial.suggest_categorical("tau", [0.001, 0.005, 0.01, 0.02])
episodic = trial.suggest_categorical("episodic", [True, False])
if episodic:
n_episodes_rollout = 1
train_freq, gradient_steps = -1, -1
else:
train_freq = trial.suggest_categorical("train_freq", [1, 16, 128, 256, 1000, 2000])
gradient_steps = train_freq
n_episodes_rollout = -1
noise_type = trial.suggest_categorical("noise_type", ["ornstein-uhlenbeck", "normal", None])
noise_std = trial.suggest_uniform("noise_std", 0, 1)
# NOTE: Add "verybig" to net_arch when tuning HER (see TD3)
net_arch = trial.suggest_categorical("net_arch", ["small", "medium", "big"])
# activation_fn = trial.suggest_categorical('activation_fn', [nn.Tanh, nn.ReLU, nn.ELU, nn.LeakyReLU])
net_arch = {
"small": [64, 64],
"medium": [256, 256],
"big": [400, 300],
}[net_arch]
hyperparams = {
"gamma": gamma,
"tau": tau,
"learning_rate": learning_rate,
"batch_size": batch_size,
"buffer_size": buffer_size,
"train_freq": train_freq,
"gradient_steps": gradient_steps,
"n_episodes_rollout": n_episodes_rollout,
"policy_kwargs": dict(net_arch=net_arch),
}
if noise_type == "normal":
hyperparams["action_noise"] = NormalActionNoise(
mean=np.zeros(trial.n_actions), sigma=noise_std * np.ones(trial.n_actions)
)
elif noise_type == "ornstein-uhlenbeck":
hyperparams["action_noise"] = OrnsteinUhlenbeckActionNoise(
mean=np.zeros(trial.n_actions), sigma=noise_std * np.ones(trial.n_actions)
)
return hyperparams
def objective(trial: optuna.Trial):
model_cfg = {
"input_size": [32, 32],
"input_channel": 3,
"depth_multiple": 1.0,
"width_multiple": 1.0,
}
conv_type = trial.suggest_categorical("conv_type", ["Conv", "DWConv"])
kernel_size = trial.suggest_int("kernel_size", 3, 7, step=2)
n_channel_01 = trial.suggest_int("n_channel_01", 8, 64, step=8)
n_channel_02 = trial.suggest_int("n_channel_02", 8, 128, step=8)
linear_activation = trial.suggest_categorical("linear_activation",
["ReLU", "SiLU"])
n_channel_03 = trial.suggest_int("n_channel_03", 64, 256, step=8)
n_channel_04 = trial.suggest_int("n_channel_04", 32, 128, step=8)
n_repeat = trial.suggest_int("n_repeat", 1, 3)
backbone = [
[-1, n_repeat, conv_type, [n_channel_01, kernel_size, 1]],
[-1, 1, "MaxPool", [2]],
[-1, n_repeat, conv_type, [int(n_channel_02), kernel_size, 1]],
[-1, 1, "MaxPool", [2]],
[-1, 1, "Flatten", []],
[-1, 1, "Linear", [n_channel_03, linear_activation]],
[-1, 1, "Linear", [n_channel_04, linear_activation]],
[-1, 1, "Linear", [10]],
]
model_cfg.update({"backbone": backbone})
model = Model(model_cfg, verbose=True).to(device)
batch_size = trial.suggest_int("batch_size", 8, 256)
epochs = trial.suggest_int("epochs", 5, 20)
train_loader = DataLoader(train_dataset,
batch_size=batch_size,
sampler=subset_sampler)
test_loader = DataLoader(test_dataset, batch_size=batch_size)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())
trainer = TorchTrainer(model, criterion, optimizer, device=device)
trainer.train(train_loader,
n_epoch=epochs,
test_dataloader=test_loader)
test_loss, test_accuracy = trainer.test(test_loader)
return test_loss
def func(trial: Trial, x_max: float = 1.0) -> float:
x = trial.suggest_uniform("x", -x_max, x_max)
y = trial.suggest_loguniform("y", 20, 30)
z = trial.suggest_categorical("z", (-1.0, 1.0))
assert isinstance(z, float)
return (x - 2)**2 + (y - 25)**2 + z
def multi_objective_function(trial: Trial) -> Tuple[float, float]:
x1: float = trial.suggest_float("x1", 0.1, 3)
x2: float = trial.suggest_float("x2", 0.1, 3, log=True)
x3: int = trial.suggest_int("x3", 2, 4, log=True)
x4 = trial.suggest_categorical("x4", [0.1, 1.0, 10.0])
assert isinstance(x4, float)
return (x1 + x2 * x3 + x4, x1 * x4)
def objective(trial: Trial) -> float:
x1: float = trial.suggest_float("x1", 0.1, 3)
x2: float = trial.suggest_float("x2", 0.1, 3, log=True)
x3: int = trial.suggest_int("x3", 2, 4, log=True)
x4 = trial.suggest_categorical("x4", [0.1, 1.0, 10.0])
assert isinstance(x4, float)
return x1 + x2 * x3 + x4
def suggest_discrete_power_two_int(trial: Trial, name, low, high) -> int:
"""Suggest an integer in the given range [2^low, 2^high]."""
if high <= low:
raise Exception(
f"Upper bound {high} is not greater than lower bound {low}.")
choices = [2**i for i in range(low, high + 1)]
return trial.suggest_categorical(name=name, choices=choices)
def suggest_discrete_uniform_int(trial: Trial, name, low, high, q) -> int:
"""Suggest an integer in the given range [low, high] inclusive with step size q."""
if (high - low) % q:
logger.warning(
f'bad range given: range({low}, {high}, {q}) - not divisible by q')
choices = list(range(low, high + 1, q))
return trial.suggest_categorical(name=name, choices=choices)
def _suggest(self, trial: optuna.Trial, v: problem.Var) -> float:
if v.name in trial.params:
if isinstance(trial.params[v.name], str):
assert isinstance(v.range, problem.CategoricalRange)
return v.range.choices.index(trial.params[v.name])
else:
return trial.params[v.name]
if isinstance(v.range, problem.ContinuousRange):
if v.distribution == problem.Distribution.UNIFORM:
return trial.suggest_uniform(v.name, v.range.low, v.range.high)
elif v.distribution == problem.Distribution.LOG_UNIFORM:
return trial.suggest_loguniform(v.name, v.range.low,
v.range.high)
elif isinstance(v.range, problem.DiscreteRange):
if self._use_discrete_uniform:
return trial.suggest_discrete_uniform(v.name,
v.range.low,
v.range.high - 1,
q=1)
elif v.distribution == problem.Distribution.LOG_UNIFORM:
return trial.suggest_int(v.name,
v.range.low,
v.range.high - 1,
log=True)
else:
return trial.suggest_int(v.name, v.range.low, v.range.high - 1)
elif isinstance(v.range, problem.CategoricalRange):
category = trial.suggest_categorical(v.name, v.range.choices)
return v.range.choices.index(category)
raise ValueError("Unsupported parameter: {}".format(v))
def run_model(trial: optuna.Trial) -> float:
print(study, ' with ', len(study.trials))
print(trial)
l1Units = trial.suggest_categorical('l1Units', [2, 4, 8, 16, 32])
l2Units = trial.suggest_categorical('l2Units', [2, 4, 8, 16, 32])
print("Training model with: ")
print("Layer 1 units: ", l1Units)
print("Layer 2 units: ", l2Units)
if trial.should_prune():
raise optuna.structs.TrialPruned()
model = keras.Sequential([
keras.layers.Dense(l1Units,
activation='relu',
input_shape=(WINDOW_SIZE, )),
keras.layers.Dense(l2Units, activation='relu'),
keras.layers.Dense(1)
])
model.compile(optimizer='adam',
loss='mean_squared_error',
metrics=['mse', 'mae'])
model.fit(x_train, y_train, epochs=20, verbose=0)
_, mse, _ = model.evaluate(x_test, y_test)
print("Test mse: ", mse)
return mse
def sample_her_params(trial: optuna.Trial, hyperparams: Dict[str, Any]) -> Dict[str, Any]:
"""
Sampler for HerReplayBuffer hyperparams.
:param trial:
:parma hyperparams:
:return:
"""
her_kwargs = trial.her_kwargs.copy()
her_kwargs["n_sampled_goal"] = trial.suggest_int("n_sampled_goal", 1, 5)
her_kwargs["goal_selection_strategy"] = trial.suggest_categorical(
"goal_selection_strategy", ["final", "episode", "future"]
)
her_kwargs["online_sampling"] = trial.suggest_categorical("online_sampling", [True, False])
hyperparams["replay_buffer_kwargs"] = her_kwargs
return hyperparams
def objective(trial: Trial) -> float:
trial.set_user_attr('method', 'hope')
classifier = classifier_type
if classifier is None:
classifier = trial.suggest_categorical('classifier',
['SVM', 'EN', 'RF', 'LR'])
else:
trial.set_user_attr('classifier', classifier)
dimensions = trial.suggest_int('dimensions', dimensions_range[0],
dimensions_range[1])
# Set the inner trial seed
_set_trial_seed(trial)
model = embed_train.train_embed_hope(
train_graph_filename=train_graph_filename,
dimensions=dimensions,
weighted=weighted,
)
return predict_and_evaluate(
model=model,
graph=graph,
graph_train=graph_train,
testing_pos_edges=testing_pos_edges,
seed=seed,
trial=trial,
labels=labels,
node_list=node_list,
classifier_type=classifier,
prediction_task=prediction_task,
)
def f(trial: Trial) -> float:
x = trial.suggest_int("x", 1, 1)
y = trial.suggest_categorical("y", (2.5, ))
trial.set_user_attr("train_loss", 3)
raise ValueError()
return x + y # 3.5
