function will set them to proper values and warn them
"""
if not isinstance(self.n_envs, int) or self.n_envs < 1:
- logger.warning("Config: n_envs=%s invalid, set to 1", self.n_envs)
+ logger.warning("Config: n_envs=%r invalid, set to 1", self.n_envs)
self.n_envs = 1
if not isinstance(self.n_eval_envs, int) or self.n_eval_envs < 1:
logger.warning(
- "Config: n_eval_envs=%s invalid, set to 1",
+ "Config: n_eval_envs=%r invalid, set to 1",
self.n_eval_envs,
)
self.n_eval_envs = 1
if self.multiprocessing and self.n_envs <= 1:
logger.warning(
- "Config: multiprocessing requires n_envs>1, set to False",
+ "Config: multiprocessing=True requires n_envs=%d>1, set to False",
+ self.n_envs,
)
self.multiprocessing = False
if self.eval_multiprocessing and self.n_eval_envs <= 1:
logger.warning(
- "Config: eval_multiprocessing requires n_eval_envs>1, set to False",
+ "Config: eval_multiprocessing=True requires n_eval_envs=%d>1, set to False",
+ self.n_eval_envs,
)
self.eval_multiprocessing = False
if self.multiprocessing and self.plot_new_best:
logger.warning(
- "Config: plot_new_best incompatible with multiprocessing, set to False",
+ "Config: plot_new_best=True incompatible with multiprocessing=True, set to False",
)
self.plot_new_best = False
if not isinstance(self.frame_stacking, int) or self.frame_stacking < 0:
logger.warning(
- "Config: frame_stacking=%s invalid, set to 0",
+ "Config: frame_stacking=%r invalid, set to 0",
self.frame_stacking,
)
self.frame_stacking = 0
self.frame_stacking = 0
if not isinstance(self.n_eval_steps, int) or self.n_eval_steps <= 0:
logger.warning(
- "Config: n_eval_steps=%s invalid, set to 10000",
+ "Config: n_eval_steps=%r invalid, set to 10000",
self.n_eval_steps,
)
self.n_eval_steps = 10_000
if not isinstance(self.n_eval_episodes, int) or self.n_eval_episodes <= 0:
logger.warning(
- "Config: n_eval_episodes=%s invalid, set to 5",
+ "Config: n_eval_episodes=%r invalid, set to 5",
self.n_eval_episodes,
)
self.n_eval_episodes = 5
or self.optuna_purge_period < 0
):
logger.warning(
- "Config: purge_period=%s invalid, set to 0",
+ "Config: purge_period=%r invalid, set to 0",
self.optuna_purge_period,
)
self.optuna_purge_period = 0
tensorboard_throttle = self.rl_config.get("tensorboard_throttle", 1)
if not isinstance(tensorboard_throttle, int) or tensorboard_throttle < 1:
logger.warning(
- "Config: tensorboard_throttle=%s invalid, set to 1",
+ "Config: tensorboard_throttle=%r invalid, set to 1",
tensorboard_throttle,
)
self.rl_config["tensorboard_throttle"] = 1
if self.continual_learning and bool(self.frame_stacking):
logger.warning(
- "Config: continual_learning incompatible with frame_stacking, set to False",
+ "Config: continual_learning=True incompatible with frame_stacking=%d, set to False",
+ self.frame_stacking,
)
self.continual_learning = False
if gamma is not None:
model_reward_parameters["potential_gamma"] = gamma
else:
- logger.warning("PBRS: no valid discount gamma resolved for environment")
+ logger.warning(
+ "PBRS [%s]: no valid discount gamma resolved for environment", pair
+ )
return env_info
Set training and evaluation environments
"""
if self.train_env is not None or self.eval_env is not None:
- logger.info("Env: closing environments")
+ logger.info("Env [%s]: closing environments", dk.pair)
self.close_envs()
train_df = data_dictionary.get("train_features")
seed = self.get_model_params().get("seed", 42)
if self.check_envs:
- logger.info("Env: checking environments")
+ logger.info("Env [%s]: checking environments", dk.pair)
_train_env_check = MyRLEnv(
df=train_df,
prices=prices_train,
_eval_env_check.close()
logger.info(
- "Env: populating %s train and %s eval environments",
+ "Env [%s]: populating %s train and %s eval environments",
+ dk.pair,
self.n_envs,
self.n_eval_envs,
)
eval_days = steps_to_days(eval_timesteps, self.config.get("timeframe"))
total_days = steps_to_days(total_timesteps, self.config.get("timeframe"))
- logger.info("Model: type=%s", self.model_type)
+ logger.info("Model [%s]: type=%s", dk.pair, self.model_type)
logger.info(
- "Training: %s steps (%s days), %s cycles, %s env(s) -> total %s steps (%s days)",
+ "Training [%s]: %s steps (%s days), %s cycles, %s env(s) -> total %s steps (%s days)",
+ dk.pair,
train_timesteps,
train_days,
train_cycles,
total_days,
)
logger.info(
- "Training: eval %s steps (%s days), %s episodes, %s env(s)",
+ "Training [%s]: eval %s steps (%s days), %s episodes, %s env(s)",
+ dk.pair,
eval_timesteps,
eval_days,
self.n_eval_episodes,
self.n_eval_envs,
)
- logger.info("Config: multiprocessing=%s", self.multiprocessing)
- logger.info("Config: eval_multiprocessing=%s", self.eval_multiprocessing)
- logger.info("Config: frame_stacking=%s", self.frame_stacking)
- logger.info("Config: action_masking=%s", self.action_masking)
- logger.info("Config: recurrent=%s", self.recurrent)
- logger.info("Config: hyperopt=%s", self.hyperopt)
+ logger.info(
+ "Config: multiprocessing=%s, eval_multiprocessing=%s, "
+ "frame_stacking=%s, action_masking=%s, recurrent=%s, hyperopt=%s",
+ self.multiprocessing,
+ self.eval_multiprocessing,
+ self.frame_stacking,
+ self.action_masking,
+ self.recurrent,
+ self.hyperopt,
+ )
start_time = time.time()
if self.hyperopt:
best_params = self.optimize(dk, total_timesteps)
if best_params is None:
logger.error(
- "Hyperopt %s: optimization failed, using default model params",
+ "Hyperopt [%s]: optimization failed, using default model params",
dk.pair,
)
best_params = self.get_model_params()
model_params = best_params
else:
model_params = self.get_model_params()
- logger.info("Model: %s params: %s", self.model_type, model_params)
+ logger.info("Model [%s]: %s params: %s", dk.pair, self.model_type, model_params)
# "PPO"
if ReforceXY._MODEL_TYPES[0] in self.model_type:
min_timesteps = 2 * n_steps * self.n_envs
if total_timesteps <= min_timesteps:
logger.warning(
- "Training: total_timesteps=%s is less than or equal to 2*n_steps*n_envs=%s. This may lead to suboptimal training results for model %s",
+ "Training [%s]: total_timesteps=%s is less than or equal to 2*n_steps*n_envs=%s. This may lead to suboptimal training results for model %s",
+ dk.pair,
total_timesteps,
min_timesteps,
self.model_type,
if aligned_total_timesteps != total_timesteps:
total_timesteps = aligned_total_timesteps
logger.info(
- "Training: aligned total %s steps (%s days) for model %s",
+ "Training [%s]: aligned total %s steps (%s days) for model %s",
+ dk.pair,
total_timesteps,
steps_to_days(total_timesteps, self.config.get("timeframe")),
self.model_type,
model = self.get_init_model(dk.pair)
if model is not None:
logger.info(
- "Training: continual training activated, starting from previously trained model state"
+ "Training [%s]: continual training activated, starting from previously trained model state",
+ dk.pair,
)
model.set_env(self.train_env)
else:
model_filename = dk.model_filename if dk.model_filename else "best"
model_filepath = Path(dk.data_path / f"{model_filename}_model.zip")
if model_filepath.is_file():
- logger.info("Model: found best model at %s", model_filepath)
+ logger.info("Model [%s]: found best model at %s", dk.pair, model_filepath)
try:
best_model = self.MODELCLASS.load(
dk.data_path / f"{model_filename}_model"
)
return best_model
except Exception as e:
- logger.error("Model: failed to load best model: %r", e, exc_info=True)
+ logger.error(
+ "Model [%s]: failed to load best model: %r",
+ dk.pair,
+ e,
+ exc_info=True,
+ )
logger.info(
- "Model: best model not found at %s, using final model", model_filepath
+ "Model [%s]: best model not found at %s, using final model",
+ dk.pair,
+ model_filepath,
)
return model
try:
delete_study(study_name=study_name, storage=storage)
except Exception as e:
- logger.warning("Hyperopt %s: failed to delete study: %r", study_name, e)
+ logger.warning("Hyperopt [%s]: failed to delete study: %r", study_name, e)
@staticmethod
def _sanitize_pair(pair: str) -> str:
return result
except Exception as e:
logger.warning(
- "Hyperopt %s: failed to load retrain counters from %s: %r",
+ "Hyperopt [%s]: failed to load retrain counters from %s: %r",
pair,
counters_path,
e,
json.dump(counters, write_file, indent=4, sort_keys=True)
except Exception as e:
logger.warning(
- "Hyperopt %s: failed to save retrain counters to %s: %r",
+ "Hyperopt [%s]: failed to save retrain counters to %s: %r",
pair,
counters_path,
e,
)
else:
raise ValueError(
- f"Hyperopt {pair}: unsupported storage backend '{storage_backend}'. "
+ f"Hyperopt [{pair}]: unsupported storage backend '{storage_backend}'. "
f"Expected one of: {list(ReforceXY._STORAGE_BACKENDS)}"
)
return storage
logger.info(
"Hyperopt: using AutoSampler (seed=%d)",
seed,
- )
+ ) # No identifier needed for global sampler config
return optunahub.load_module("samplers/auto_sampler").AutoSampler(seed=seed)
# "tpe"
elif sampler == ReforceXY._SAMPLER_TYPES[0]:
"Hyperopt: using TPESampler (n_startup_trials=%d, multivariate=True, group=True, seed=%d)",
self.optuna_n_startup_trials,
seed,
- )
+ ) # No identifier needed for global sampler config
return TPESampler(
n_startup_trials=self.optuna_n_startup_trials,
multivariate=True,
min_resource,
max_resource,
reduction_factor,
- )
+ ) # No identifier needed for global pruner config
return HyperbandPruner(
min_resource=min_resource,
max_resource=max_resource,
ReforceXY.delete_study(study_name, storage)
if continuous and not pair_purge_triggered:
logger.info(
- "Hyperopt %s: study deleted (continuous mode)",
+ "Hyperopt [%s]: study deleted (continuous mode)",
study_name,
)
if pair_purge_triggered:
logger.info(
- "Hyperopt %s: study purged on retrain %s (purge_period=%s)",
+ "Hyperopt [%s]: study purged on retrain %s (purge_period=%s)",
study_name,
pair_purge_count,
self.optuna_purge_period,
load_if_exists=load_if_exists,
)
logger.info(
- "Hyperopt %s: study created (direction=%s, n_trials=%s, timeout=%s, continuous=%s, load_if_exists=%s)",
+ "Hyperopt [%s]: study created (direction=%s, n_trials=%s, timeout=%s, continuous=%s, load_if_exists=%s)",
study_name,
direction.name,
self.optuna_n_trials,
if best_trial_params:
study.enqueue_trial(best_trial_params)
logger.info(
- "Hyperopt %s: warm start enqueued previous best params",
+ "Hyperopt [%s]: warm start enqueued previous best params",
study_name,
)
else:
logger.info(
- "Hyperopt %s: warm start found no previous best params",
+ "Hyperopt [%s]: warm start found no previous best params",
study_name,
)
hyperopt_failed = False
except KeyboardInterrupt:
time_spent = time.time() - start_time
logger.info(
- "Hyperopt %s: interrupted by user after %.2f secs",
+ "Hyperopt [%s]: interrupted by user after %.2f secs",
study_name,
time_spent,
)
except Exception as e:
time_spent = time.time() - start_time
logger.error(
- "Hyperopt %s: optimization failed after %.2f secs: %r",
+ "Hyperopt [%s]: optimization failed after %.2f secs: %r",
study_name,
time_spent,
e,
n_pruned = len([t for t in study.trials if t.state == TrialState.PRUNED])
n_failed = len([t for t in study.trials if t.state == TrialState.FAIL])
logger.info(
- "Hyperopt %s: %s completed, %s pruned, %s failed trials",
+ "Hyperopt [%s]: %s completed, %s pruned, %s failed trials",
study_name,
n_completed,
n_pruned,
study_has_best_trial = ReforceXY.study_has_best_trial(study)
if not study_has_best_trial:
logger.error(
- "Hyperopt %s: no best trial found after %.2f secs",
+ "Hyperopt [%s]: no best trial found after %.2f secs",
study_name,
time_spent,
)
best_trial_params = self.load_best_trial_params(dk.pair)
if best_trial_params is None:
logger.error(
- "Hyperopt %s: no previously saved best params found",
+ "Hyperopt [%s]: no previously saved best params found",
study_name,
)
return None
best_trial_params = study.best_trial.params
logger.info(
- "Hyperopt %s: completed in %.2f secs",
+ "Hyperopt [%s]: completed in %.2f secs",
study_name,
time_spent,
)
if study_has_best_trial:
logger.info(
- "Hyperopt %s: best trial #%d with score %s",
+ "Hyperopt [%s]: best trial #%d with score %s",
study_name,
study.best_trial.number,
study.best_trial.value,
)
- logger.info("Hyperopt %s: best params %s", study_name, best_trial_params)
+ logger.info("Hyperopt [%s]: best params: %s", study_name, best_trial_params)
self.save_best_trial_params(best_trial_params, dk.pair)
self.full_path / f"{best_trial_params_filename}.json"
)
logger.info(
- "Hyperopt %s: saving best params to %s", pair, best_trial_params_path
+ "Hyperopt [%s]: saving best params to %s", pair, best_trial_params_path
)
try:
with best_trial_params_path.open("w", encoding="utf-8") as write_file:
json.dump(best_trial_params, write_file, indent=4)
except Exception as e:
logger.error(
- "Hyperopt %s: failed to save best params to %s: %r",
+ "Hyperopt [%s]: failed to save best params to %s: %r",
pair,
best_trial_params_path,
e,
)
if best_trial_params_path.is_file():
logger.info(
- "Hyperopt %s: loading best params from %s", pair, best_trial_params_path
+ "Hyperopt [%s]: loading best params from %s",
+ pair,
+ best_trial_params_path,
)
with best_trial_params_path.open("r", encoding="utf-8") as read_file:
best_trial_params = json.load(read_file)
return sample_params_dqn(trial)
else:
raise NotImplementedError(
- f"Hyperopt {trial.study.study_name}: model type '{self.model_type}' not supported"
+ f"Hyperopt [{trial.study.study_name}]: model type '{self.model_type}' not supported"
)
def objective(
Objective function for Optuna trials hyperparameter optimization
"""
study_name = trial.study.study_name
- logger.info("Hyperopt %s: starting trial #%d", study_name, trial.number)
+ logger.info("Hyperopt [%s]: starting trial #%d", study_name, trial.number)
params = self.get_optuna_params(trial)
params = deepmerge(self.get_model_params(), params)
params["seed"] = params.get("seed", 42) + trial.number
logger.info(
- "Hyperopt %s: trial #%d params %s", study_name, trial.number, params
+ "Hyperopt [%s]: trial #%d params: %s", study_name, trial.number, params
)
# "PPO"
model.learn(total_timesteps=total_timesteps, callback=callbacks)
except AssertionError:
logger.warning(
- "Hyperopt %s: trial #%d encountered NaN (AssertionError)",
+ "Hyperopt [%s]: trial #%d encountered NaN (AssertionError)",
study_name,
trial.number,
)
except ValueError as e:
if any(x in str(e).lower() for x in ("nan", "inf")):
logger.warning(
- "Hyperopt %s: trial #%d encountered NaN/Inf (ValueError): %r",
+ "Hyperopt [%s]: trial #%d encountered NaN/Inf (ValueError): %r",
study_name,
trial.number,
e,
raise
except FloatingPointError as e:
logger.warning(
- "Hyperopt %s: trial #%d encountered NaN/Inf (FloatingPointError): %r",
+ "Hyperopt [%s]: trial #%d encountered NaN/Inf (FloatingPointError): %r",
study_name,
trial.number,
e,
except RuntimeError as e:
if any(x in str(e).lower() for x in ("nan", "inf")):
logger.warning(
- "Hyperopt %s: trial #%d encountered NaN/Inf (RuntimeError): %r",
+ "Hyperopt [%s]: trial #%d encountered NaN/Inf (RuntimeError): %r",
study_name,
trial.number,
e,
)
if self._exit_potential_mode not in set(ReforceXY._EXIT_POTENTIAL_MODES):
logger.warning(
- "PBRS: exit_potential_mode=%r invalid, set to %r. Valid: %s",
+ "PBRS [%s]: exit_potential_mode=%r invalid, set to %r. Valid: %s",
+ self.id,
self._exit_potential_mode,
ReforceXY._EXIT_POTENTIAL_MODES[0],
", ".join(ReforceXY._EXIT_POTENTIAL_MODES),
if self._exit_potential_mode == ReforceXY._EXIT_POTENTIAL_MODES[0]:
if self._entry_additive_enabled or self._exit_additive_enabled:
logger.info(
- "PBRS: canonical mode, additive disabled (use exit_potential_mode=%s to enable)",
+ "PBRS [%s]: canonical mode, additive disabled (use exit_potential_mode=%s to enable)",
+ self.id,
ReforceXY._EXIT_POTENTIAL_MODES[1],
)
self._entry_additive_enabled = False
# "non_canonical"
elif self._exit_potential_mode == ReforceXY._EXIT_POTENTIAL_MODES[1]:
if self._entry_additive_enabled or self._exit_additive_enabled:
- logger.info("PBRS: non-canonical mode, additive enabled")
+ logger.info("PBRS [%s]: non-canonical mode, additive enabled", self.id)
if MyRLEnv.is_unsupported_pbrs_config(
self._hold_potential_enabled, getattr(self, "add_state_info", False)
):
logger.warning(
- "PBRS: hold_potential_enabled=True requires add_state_info=True, enabling"
+ "PBRS [%s]: hold_potential_enabled=True requires add_state_info=True, enabling",
+ self.id,
)
self.add_state_info = True
self._set_observation_space()
return min(max(-1.0, x), 1.0)
logger.warning(
- "PBRS: potential_transform=%r invalid, set to 'tanh'. Valid: %s",
+ "PBRS [%s]: potential_transform=%r invalid, set to 'tanh'. Valid: %s",
+ self.id,
name,
", ".join(ReforceXY._TRANSFORM_FUNCTIONS),
)
)
if exit_plateau_grace < 0.0:
logger.warning(
- "PBRS: exit_plateau_grace=%.2f invalid, set to 0.0", exit_plateau_grace
+ "PBRS [%s]: exit_plateau_grace=%.2f invalid, set to 0.0",
+ self.id,
+ exit_plateau_grace,
)
exit_plateau_grace = 0.0
)
if slope < 0.0:
logger.warning(
- "PBRS: exit_linear_slope=%.2f invalid, set to 1.0", slope
+ "PBRS [%s]: exit_linear_slope=%.2f invalid, set to 1.0",
+ self.id,
+ slope,
)
slope = 1.0
return 1.0 / (1.0 + slope * dr)
strategy_fn = strategies.get(exit_attenuation_mode, None)
if strategy_fn is None:
logger.warning(
- "PBRS: exit_attenuation_mode=%r invalid, set to %r. Valid: %s",
+ "PBRS [%s]: exit_attenuation_mode=%r invalid, set to %r. Valid: %s",
+ self.id,
exit_attenuation_mode,
ReforceXY._EXIT_ATTENUATION_MODES[2], # "linear"
", ".join(ReforceXY._EXIT_ATTENUATION_MODES),
)
except Exception as e:
logger.warning(
- "PBRS: exit_attenuation_mode=%r failed (%r), set to %r (effective_dr=%.5f)",
+ "PBRS [%s]: exit_attenuation_mode=%r failed (%r), set to %r (effective_dr=%.5f)",
+ self.id,
exit_attenuation_mode,
e,
ReforceXY._EXIT_ATTENUATION_MODES[2], # "linear"
if check_invariants:
if not np.isfinite(exit_factor):
logger.debug(
- "PBRS: exit_factor=%.5f non-finite, set to 0.0", exit_factor
+ "PBRS [%s]: exit_factor=%.5f non-finite, set to 0.0",
+ self.id,
+ exit_factor,
)
return 0.0
if efficiency_coefficient < 0.0:
logger.debug(
- "PBRS: efficiency_coefficient=%.5f negative", efficiency_coefficient
+ "PBRS [%s]: efficiency_coefficient=%.5f negative",
+ self.id,
+ efficiency_coefficient,
)
if exit_factor < 0.0 and pnl >= 0.0:
logger.debug(
- "PBRS: exit_factor=%.5f negative with pnl=%.5f positive, clamped to 0.0",
+ "PBRS [%s]: exit_factor=%.5f negative with pnl=%.5f positive, clamped to 0.0",
+ self.id,
exit_factor,
pnl,
)
)
if exit_factor_threshold > 0 and abs(exit_factor) > exit_factor_threshold:
logger.warning(
- "PBRS: |exit_factor|=%.5f exceeds exit_factor_threshold=%.5f",
+ "PBRS [%s]: |exit_factor|=%.5f exceeds exit_factor_threshold=%.5f",
+ self.id,
abs(exit_factor),
exit_factor_threshold,
)
Get environment data aligned on ticks, including optional trade events
"""
if not self.history:
- logger.warning("Env: history is empty")
+ logger.debug("Env [%s]: history is empty", self.id)
return DataFrame()
_history_df = DataFrame(self.history)
if "tick" not in _history_df.columns:
- logger.warning("Env: 'tick' column missing from history")
+ logger.error("Env [%s]: 'tick' column missing from history", self.id)
return DataFrame()
_rollout_history = _history_df.copy()
)
except Exception as e:
logger.error(
- "Env: failed to merge history with prices: %r", e, exc_info=True
+ "Env [%s]: failed to merge history with prices: %r",
+ self.id,
+ e,
+ exc_info=True,
)
return DataFrame()
return history
last_mean_reward = float(getattr(self, "last_mean_reward", np.nan))
except Exception as e:
logger.warning(
- "Hyperopt %s: trial #%d invalid last_mean_reward (eval_idx=%s, timesteps=%s): %r",
+ "Hyperopt [%s]: trial #%d invalid last_mean_reward (eval_idx=%s, timesteps=%s): %r",
self.trial.study.study_name,
self.trial.number,
self.eval_idx,
if not np.isfinite(last_mean_reward):
logger.warning(
- "Hyperopt %s: trial #%d non-finite last_mean_reward (eval_idx=%s, timesteps=%s)",
+ "Hyperopt [%s]: trial #%d non-finite last_mean_reward (eval_idx=%s, timesteps=%s)",
self.trial.study.study_name,
self.trial.number,
self.eval_idx,
self.trial.report(last_mean_reward, self.num_timesteps)
except Exception as e:
logger.warning(
- "Hyperopt %s: trial #%d trial.report failed (eval_idx=%s, timesteps=%s): %r",
+ "Hyperopt [%s]: trial #%d trial.report failed (eval_idx=%s, timesteps=%s): %r",
self.trial.study.study_name,
self.trial.number,
self.eval_idx,
best_mean_reward = float(getattr(self, "best_mean_reward", np.nan))
except Exception as e:
logger.warning(
- "Hyperopt %s: trial #%d invalid best_mean_reward (eval_idx=%s, timesteps=%s): %r",
+ "Hyperopt [%s]: trial #%d invalid best_mean_reward (eval_idx=%s, timesteps=%s): %r",
self.trial.study.study_name,
self.trial.number,
self.eval_idx,
)
else:
logger.warning(
- "Hyperopt %s: trial #%d non-finite best_mean_reward (eval_idx=%s, timesteps=%s)",
+ "Hyperopt [%s]: trial #%d non-finite best_mean_reward (eval_idx=%s, timesteps=%s)",
self.trial.study.study_name,
self.trial.number,
self.eval_idx,
)
except Exception as e:
logger.error(
- "Hyperopt %s: trial #%d logger.record failed (eval_idx=%s, timesteps=%s): %r",
+ "Hyperopt [%s]: trial #%d logger.record failed (eval_idx=%s, timesteps=%s): %r",
self.trial.study.study_name,
self.trial.number,
self.eval_idx,
try:
if self.trial.should_prune():
logger.info(
- "Hyperopt %s: trial #%d pruned (eval_idx=%s, timesteps=%s, score=%.5f)",
+ "Hyperopt [%s]: trial #%d pruned (eval_idx=%s, timesteps=%s, score=%.5f)",
self.trial.study.study_name,
self.trial.number,
self.eval_idx,
return False
except Exception as e:
logger.warning(
- "Hyperopt %s: trial #%d should_prune failed (eval_idx=%s, timesteps=%s): %r",
+ "Hyperopt [%s]: trial #%d should_prune failed (eval_idx=%s, timesteps=%s): %r",
self.trial.study.study_name,
self.trial.number,
self.eval_idx,
repositories / freqai-strategies.git / commitdiff
