ax.modelbridge¶

Generation Strategy, Registry, and Factory¶

Generation Strategy¶

class ax.modelbridge.generation_strategy.GenerationStep[source]¶

Bases: tuple

One step in the generation strategy, corresponds to a single model. Describes the model, how many trials will be generated with this model, what minimum number of observations is required to proceed to the next model, etc.

Model can be specified either from the model registry (ax.modelbridge.registry.Models or using a callable model constructor. Only models from the registry can be saved, and thus optimization can only be resumed if interrupted when using models from the registry.

property enforce_num_trials¶: Alias for field number 4

property index¶: Alias for field number 7

property max_parallelism¶: Alias for field number 3

property min_trials_observed¶: Alias for field number 2

property model¶: Alias for field number 0

property model_gen_kwargs¶: Alias for field number 6

property model_kwargs¶: Alias for field number 5

property model_name¶

Return type: str

property num_trials¶: Alias for field number 1

class ax.modelbridge.generation_strategy.GenerationStrategy(steps, name=None)[source]¶

Bases: ax.core.base.Base

GenerationStrategy describes which model should be used to generate new points for which trials, enabling and automating use of different models throughout the optimization process. For instance, it allows to use one model for the initialization trials, and another one for all subsequent trials. In the general case, this allows to automate use of an arbitrary number of models to generate an arbitrary numbers of trials described in the trials_per_model argument.

clone_reset()[source]¶

Copy this generation strategy without it’s state.

Return type: GenerationStrategy

property experiment¶

Experiment, currently set on this generation strategy.

Return type: Experiment

gen(experiment, data=None, n=1, **kwargs)[source]¶

Produce the next points in the experiment.

Return type: GeneratorRun

property last_generator_run¶

Latest generator run produced by this generation strategy. Returns None if no generator runs have been produced yet.

Return type: Optional[GeneratorRun]

property model¶

Current model in this strategy. Returns None if no model has been set yet (i.e., if no generator runs have been produced from this GS).

Return type: Optional[ModelBridge]

property model_transitions¶

List of trial indices where a transition happened from one model to another.

Return type: List[int]

property name¶

Name of this generation strategy. Defaults to a combination of model names provided in generation steps.

Return type: str

property num_running_trials_for_current_step¶

Number of trials in status RUNNING for the current generation step of this strategy.

Return type: int

property trial_indices_by_step¶

Find trials in experiment that are not mapped to a generation step yet and add them to the mapping of trials by generation step.

Return type: Dict[int, List[int]]

property trials_as_df¶

Puts information on individual trials into a data frame for easy viewing. For example: Gen. Step | Model | Trial Index | Trial Status | Arm Parameterizations 0 | Sobol | 0 | RUNNING | {“0_0”:{“x”:9.17…}}

Return type: Optional[DataFrame]

property uses_non_registered_models¶

Whether this generation strategy involves models that are not registered and therefore cannot be stored.

Return type: bool

exception ax.modelbridge.generation_strategy.MaxParallelismReachedException(step, num_running)[source]¶

Bases: Exception

Special exception indicating that maximum number of trials running in parallel set on a given step (as GenerationStep.max_parallelism) has been reached. Upon getting this exception, users should wait until more trials are completed with data, to generate new trials.

Registry¶

class ax.modelbridge.registry.ModelSetup[source]¶

Bases: tuple

A model setup defines a coupled combination of a model, a model bridge, standard set of transforms, and standard model bridge keyword arguments. This coupled combination yields a given standard modeling strategy in Ax, such as BoTorch GP+EI, a Thompson sampler, or a Sobol quasirandom generator.

property bridge_class¶: Alias for field number 0

property model_class¶: Alias for field number 1

property standard_bridge_kwargs¶: Alias for field number 3

property transforms¶: Alias for field number 2

class ax.modelbridge.registry.Models[source]¶

Bases: enum.Enum

Registry of available models.

Uses MODEL_KEY_TO_MODEL_SETUP to retrieve settings for model and model bridge, by the key stored in the enum value.

To instantiate a model in this enum, simply call an enum member like so: Models.SOBOL(search_space=search_space) or Models.GPEI(experiment=experiment, data=data). Keyword arguments specified to the call will be passed into the model or the model bridge constructors according to their keyword.

For instance, Models.SOBOL(search_space=search_space, scramble=False) will instantiate a RandomModelBridge(search_space=search_space) with a SobolGenerator(scramble=False) underlying model.

BOTORCH = 'BO'¶

EMPIRICAL_BAYES_THOMPSON = 'EB'¶

FACTORIAL = 'Factorial'¶

GPEI = 'GPEI'¶

GPKG = 'GPKG'¶

GPMES = 'GPMES'¶

SOBOL = 'Sobol'¶

THOMPSON = 'Thompson'¶

UNIFORM = 'Uniform'¶

view_defaults()[source]¶

Obtains the default keyword arguments for the model and the modelbridge specified through the Models enum, for ease of use in notebook environment, since models and bridges cannot be inspected directly through the enum.

Return type: Tuple[Dict[str, Any], Dict[str, Any]]
Returns: A tuple of default keyword arguments for the model and the model bridge.

view_kwargs()[source]¶

Obtains annotated keyword arguments that the model and the modelbridge (corresponding to a given member of the Models enum) constructors expect.

Return type: Tuple[Dict[str, Any], Dict[str, Any]]
Returns: A tuple of annotated keyword arguments for the model and the model bridge.

ax.modelbridge.registry.get_model_from_generator_run(generator_run, experiment, data, models_enum=None, after_gen=False)[source]¶

Reinstantiate a model from model key and kwargs stored on a given generator run, with the given experiment and the data to initialize the model with.

Note: requires that the model that was used to get the generator run, is part of the Models registry enum.

Parameters

generator_run (GeneratorRun) – A GeneratorRun created by the model we are looking to reinstantiate.
experiment (Experiment) – The experiment for which the model is reinstantiated.
data (Data) – Data, with which to reinstantiate the model.
models_enum (Optional[Type[Models]]) – Optional subclass of Models registry, from which to obtain the settings of the model. Useful only if the generator run was created via a model that could not be included into the main registry, but can still be represented as a ModelSetup and was added to a registry that extends Models.
after_gen (bool) – Whether to reinstantiate the model in the state, in which it was after it created this generator run, as opposed to before. Defaults to False, useful when reinstantiating the model to resume optimization, rather than to recreate its state at the time of generation.

Return type

ModelBridge

ax.modelbridge.registry.logger = <Logger ax.modelbridge.registry (INFO)>¶

Module containing a registry of standard models (and generators, samplers etc.) such as Sobol generator, GP+EI, Thompson sampler, etc.

Use of Models enum allows for serialization and reinstantiation of models and generation strategies from generator runs they produced. To reinstantiate a model from generator run, use get_model_from_generator_run utility from this module.

Factory¶

ax.modelbridge.factory.DEFAULT_TORCH_DEVICE = device(type='cpu')¶

Module containing functions that generate standard models, such as Sobol, GP+EI, etc.

Note: a special case here is a composite generator, which requires an additional GenerationStrategy and is able to delegate work to multiple models (for instance, to a random model to generate the first trial, and to an optimization model for subsequent trials).

ax.modelbridge.factory.get_GPEI(experiment, data, search_space=None, dtype=torch.float64, device=device(type='cpu'))[source]¶

Instantiates a GP model that generates points with EI.

Return type: TorchModelBridge

ax.modelbridge.factory.get_GPKG(experiment, data, search_space=None, cost_intercept=0.01, dtype=torch.float64, device=device(type='cpu'), transforms=[<class 'ax.modelbridge.transforms.remove_fixed.RemoveFixed'>, <class 'ax.modelbridge.transforms.ordered_choice_encode.OrderedChoiceEncode'>, <class 'ax.modelbridge.transforms.one_hot.OneHot'>, <class 'ax.modelbridge.transforms.int_to_float.IntToFloat'>, <class 'ax.modelbridge.transforms.log.Log'>, <class 'ax.modelbridge.transforms.unit_x.UnitX'>, <class 'ax.modelbridge.transforms.ivw.IVW'>, <class 'ax.modelbridge.transforms.derelativize.Derelativize'>, <class 'ax.modelbridge.transforms.standardize_y.StandardizeY'>], transform_configs=None, **kwargs)[source]¶

Instantiates a GP model that generates points with KG.

Return type: TorchModelBridge

ax.modelbridge.factory.get_GPMES(experiment, data, search_space=None, cost_intercept=0.01, dtype=torch.float64, device=device(type='cpu'), transforms=[<class 'ax.modelbridge.transforms.remove_fixed.RemoveFixed'>, <class 'ax.modelbridge.transforms.ordered_choice_encode.OrderedChoiceEncode'>, <class 'ax.modelbridge.transforms.one_hot.OneHot'>, <class 'ax.modelbridge.transforms.int_to_float.IntToFloat'>, <class 'ax.modelbridge.transforms.log.Log'>, <class 'ax.modelbridge.transforms.unit_x.UnitX'>, <class 'ax.modelbridge.transforms.ivw.IVW'>, <class 'ax.modelbridge.transforms.derelativize.Derelativize'>, <class 'ax.modelbridge.transforms.standardize_y.StandardizeY'>], transform_configs=None, **kwargs)[source]¶

Instantiates a GP model that generates points with MES.

Return type: TorchModelBridge

ax.modelbridge.factory.get_MTGP(experiment, data, search_space=None, trial_index=None)[source]¶

Instantiates a Multi-task Gaussian Process (MTGP) model that generates points with EI.

If the input experiment is a MultiTypeExperiment then a Multi-type Multi-task GP model will be instantiated. Otherwise, the model will be a Single-type Multi-task GP.

Return type: TorchModelBridge

ax.modelbridge.factory.get_botorch(experiment, data, search_space=None, dtype=torch.float64, device=device(type='cpu'), transforms=[<class 'ax.modelbridge.transforms.remove_fixed.RemoveFixed'>, <class 'ax.modelbridge.transforms.ordered_choice_encode.OrderedChoiceEncode'>, <class 'ax.modelbridge.transforms.one_hot.OneHot'>, <class 'ax.modelbridge.transforms.int_to_float.IntToFloat'>, <class 'ax.modelbridge.transforms.log.Log'>, <class 'ax.modelbridge.transforms.unit_x.UnitX'>, <class 'ax.modelbridge.transforms.ivw.IVW'>, <class 'ax.modelbridge.transforms.derelativize.Derelativize'>, <class 'ax.modelbridge.transforms.standardize_y.StandardizeY'>], transform_configs=None, model_constructor=<function get_and_fit_model>, model_predictor=<function predict_from_model>, acqf_constructor=<function get_NEI>, acqf_optimizer=<function scipy_optimizer>, refit_on_cv=False, refit_on_update=True, optimization_config=None)[source]¶

Instantiates a BotorchModel.

Return type: TorchModelBridge

ax.modelbridge.factory.get_empirical_bayes_thompson(experiment, data, search_space=None, num_samples=10000, min_weight=None, uniform_weights=False)[source]¶

Instantiates an empirical Bayes / Thompson sampling model.

Return type: DiscreteModelBridge

ax.modelbridge.factory.get_factorial(search_space)[source]¶

Instantiates a factorial generator.

Return type: DiscreteModelBridge

ax.modelbridge.factory.get_sobol(search_space, seed=None, deduplicate=False, init_position=0, scramble=True)[source]¶

Instantiates a Sobol sequence quasi-random generator.

Parameters

search_space (SearchSpace) – Sobol generator search space.
kwargs – Custom args for sobol generator.

Return type

RandomModelBridge

Returns

RandomModelBridge, with SobolGenerator as model.

ax.modelbridge.factory.get_thompson(experiment, data, search_space=None, num_samples=10000, min_weight=None, uniform_weights=False)[source]¶

Instantiates a Thompson sampling model.

Return type: DiscreteModelBridge

ax.modelbridge.factory.get_uniform(search_space, deduplicate=False, seed=None)[source]¶

Instantiate uniform generator.

Parameters

search_space (SearchSpace) – Uniform generator search space.
kwargs – Custom args for uniform generator.

Return type

RandomModelBridge

Returns

RandomModelBridge, with UniformGenerator as model.

Model Bridges¶

Base Model Bridge¶

class ax.modelbridge.base.ModelBridge(search_space, model, transforms=None, experiment=None, data=None, transform_configs=None, status_quo_name=None, status_quo_features=None, optimization_config=None, fit_out_of_design=False)[source]¶

Bases: abc.ABC

The main object for using models in Ax.

ModelBridge specifies 3 methods for using models:

predict: Make model predictions. This method is not optimized for speed and so should be used primarily for plotting or similar tasks and not inside an optimization loop.
gen: Use the model to generate new candidates.
cross_validate: Do cross validation to assess model predictions.

ModelBridge converts Ax types like Data and Arm to types that are meant to be consumed by the models. The data sent to the model will depend on the implementation of the subclass, which will specify the actual API for external model.

This class also applies a sequence of transforms to the input data and problem specification which can be used to ensure that the external model receives appropriate inputs.

Subclasses will implement what is here referred to as the “terminal transform,” which is a transform that changes types of the data and problem specification.

cross_validate(cv_training_data, cv_test_points)[source]¶

Make a set of cross-validation predictions.

Parameters

cv_training_data (List[Observation]) – The training data to use for cross validation.
cv_test_points (List[ObservationFeatures]) – The test points at which predictions will be made.

Return type

List[ObservationData]

Returns

A list of predictions at the test points.

feature_importances(metric_name)[source]¶

Return type: Dict[str, float]

gen(n, search_space=None, optimization_config=None, pending_observations=None, fixed_features=None, model_gen_options=None)[source]¶

Parameters

n (int) – Number of points to generate
search_space (Optional[SearchSpace]) – Search space
optimization_config (Optional[OptimizationConfig]) – Optimization config
pending_observations (Optional[Dict[str, List[ObservationFeatures]]]) – A map from metric name to pending observations for that metric.
fixed_features (Optional[ObservationFeatures]) – An ObservationFeatures object containing any features that should be fixed at specified values during generation.
model_gen_options (Optional[Dict[str, Union[int, float, str, AcquisitionFunction]]]) – A config dictionary that is passed along to the model.

Return type

GeneratorRun

get_training_data()[source]¶

A copy of the (untransformed) data with which the model was fit.

Return type: List[Observation]

property metric_names¶

Metric names present in training data.

Return type: Set[str]

property model_space¶

SearchSpace used to fit model.

Return type: SearchSpace

predict(observation_features)[source]¶

Make model predictions (mean and covariance) for the given observation features.

Predictions are made for all outcomes. If an out-of-design observation can successfully be transformed, the predicted value will be returned. Othwerise, we will attempt to find that observation in the training data and return the raw value.

Parameters

observation_features (List[ObservationFeatures]) – observation features

Return type

Tuple[Dict[str, List[float]], Dict[str, Dict[str, List[float]]]]

Returns

2-element tuple containing

Dictionary from metric name to list of mean estimates, in same order as observation_features.
Nested dictionary with cov[‘metric1’][‘metric2’] a list of cov(metric1@x, metric2@x) for x in observation_features.

property status_quo¶

Observation corresponding to status quo, if any.

Return type: Optional[Observation]

property training_in_design¶

For each observation in the training data, a bool indicating if it is in-design for the model.

Return type: List[bool]

update(data, experiment)[source]¶

Update the model bridge and the underlying model with new data. This method should be used instead of fit, in cases where the underlying model does not need to be re-fit from scratch, but rather updated.

Note: update expects only new data (obtained since the model initialization or last update) to be passed in, not all data in the experiment.

Parameters

data (Data) – data from the experiment obtained since the last update
experiment (Experiment) – experiment, in which this data was obtained

Return type

None

ax.modelbridge.base.gen_arms(observation_features, arms_by_signature=None)[source]¶

Converts observation features to arms.

Return type: List[Arm]

ax.modelbridge.base.unwrap_observation_data(observation_data)[source]¶

Converts observation data to the format for model prediction outputs. That format assumes each observation data has the same set of metrics.

Return type: Tuple[Dict[str, List[float]], Dict[str, Dict[str, List[float]]]]

Array Model Bridge¶

class ax.modelbridge.array.ArrayModelBridge(search_space, model, transforms=None, experiment=None, data=None, transform_configs=None, status_quo_name=None, status_quo_features=None, optimization_config=None, fit_out_of_design=False)[source]¶

Bases: ax.modelbridge.base.ModelBridge

A model bridge for using array-based models.

Requires that all non-task parameters have been transformed to RangeParameters with float type and no log scale. Task parameters must be transformed to RangeParameters with int type.

This will convert all parameter types to float and put data into arrays.

feature_importances(metric_name)[source]¶

Return type: Dict[str, float]

model: Any = None¶

outcomes: List[str] = None¶

parameters: List[str] = None¶

ax.modelbridge.array.array_to_observation_data(f, cov, outcomes)[source]¶

Convert arrays of model predictions to a list of ObservationData.

Parameters

f (ndarray) – An (n x d) array
cov (ndarray) – An (n x d x d) array
outcomes (List[str]) – A list of d outcome names

Returns: A list of n ObservationData

Return type: List[ObservationData]

ax.modelbridge.array.extract_objective_weights(objective, outcomes)[source]¶

Extract a weights for objectives.

Weights are for a maximization problem.

Give an objective weight to each modeled outcome. Outcomes that are modeled but not part of the objective get weight 0.

In the single metric case, the objective is given either +/- 1, depending on the minimize flag.

In the multiple metric case, each objective is given the input weight, multiplied by the minimize flag.

Parameters

objective (Objective) – Objective to extract weights from.
outcomes (List[str]) – n-length list of names of metrics.

Return type

ndarray

Returns

(n,) array of weights.

ax.modelbridge.array.extract_outcome_constraints(outcome_constraints, outcomes)[source]¶

Return type: Optional[Tuple[ndarray, ndarray]]

ax.modelbridge.array.validate_optimization_config(optimization_config, outcomes)[source]¶

Validate optimization config against model fitted outcomes.

Parameters

optimization_config (OptimizationConfig) – Config to validate.
outcomes (List[str]) – List of metric names w/ valid model fits.

Raises

ValueError if –

Relative constraints are found 2. Optimization metrics are not present in model fitted outcomes.

Return type

None

Discrete Model Bridge¶

class ax.modelbridge.discrete.DiscreteModelBridge(search_space, model, transforms=None, experiment=None, data=None, transform_configs=None, status_quo_name=None, status_quo_features=None, optimization_config=None, fit_out_of_design=False)[source]¶

Bases: ax.modelbridge.base.ModelBridge

A model bridge for using models based on discrete parameters.

Requires that all parameters have been transformed to ChoiceParameters.

model: DiscreteModel = None¶

outcomes: List[str] = None¶

parameters: List[str] = None¶

search_space: Optional[SearchSpace] = None¶

NumPy Model Bridge¶

class ax.modelbridge.numpy.NumpyModelBridge(search_space, model, transforms=None, experiment=None, data=None, transform_configs=None, status_quo_name=None, status_quo_features=None, optimization_config=None, fit_out_of_design=False)[source]¶

Bases: ax.modelbridge.array.ArrayModelBridge

A model bridge for using numpy array-based models.

This model bridge interfaces with NumpyModel.

Requires that all parameters have been transformed to RangeParameters or FixedParameters with float type and no log scale.

model: NumpyModel = None¶

outcomes: List[str] = None¶

parameters: List[str] = None¶

Random Model Bridge¶

class ax.modelbridge.random.RandomModelBridge(search_space, model, transforms=None, experiment=None, data=None, transform_configs=None, status_quo_name=None, status_quo_features=None, optimization_config=None, fit_out_of_design=False)[source]¶

Bases: ax.modelbridge.base.ModelBridge

A model bridge for using purely random ‘models’. Data and optimization configs are not required.

This model bridge interfaces with RandomModel.

model¶: A RandomModel used to generate candidates (note: this an awkward use of the word ‘model’).

parameters¶: Params found in search space on modelbridge init.

model: RandomModel = None

parameters: List[str] = None

update(data, experiment)[source]¶

Update the model bridge and the underlying model with new data. This method should be used instead of fit, in cases where the underlying model does not need to be re-fit from scratch, but rather updated.

Note: update expects only new data (obtained since the model initialization or last update) to be passed in, not all data in the experiment.

Parameters

data (Data) – data from the experiment obtained since the last update
experiment (Experiment) – experiment, in which this data was obtained

Return type

None

Torch Model Bridge¶

class ax.modelbridge.torch.TorchModelBridge(experiment, search_space, data, model, transforms, transform_configs=None, torch_dtype=None, torch_device=None, status_quo_name=None, status_quo_features=None, optimization_config=None)[source]¶

Bases: ax.modelbridge.array.ArrayModelBridge

A model bridge for using torch-based models.

Specifies an interface that is implemented by TorchModel. In particular, model should have methods fit, predict, and gen. See TorchModel for the API for each of these methods.

Requires that all parameters have been transformed to RangeParameters or FixedParameters with float type and no log scale.

This class converts Ax parameter types to torch tensors before passing them to the model.

model: Optional[TorchModel] = None¶

outcomes: Optional[List[str]] = None¶

parameters: Optional[List[str]] = None¶

Utilities¶

General Utilities¶

ax.modelbridge.modelbridge_utils.extract_parameter_constraints(parameter_constraints, param_names)[source]¶

Extract parameter constraints.

Return type: Optional[Tuple[ndarray, ndarray]]

ax.modelbridge.modelbridge_utils.get_bounds_and_task(search_space, param_names)[source]¶

Extract box bounds from a search space in the usual Scipy format. Identify integer parameters as task features.

Return type: Tuple[List[Tuple[float, float]], List[int], Dict[int, Union[str, bool, float, int, None]]]

ax.modelbridge.modelbridge_utils.get_fixed_features(fixed_features, param_names)[source]¶

Reformat a set of fixed_features.

Return type: Optional[Dict[int, float]]

ax.modelbridge.modelbridge_utils.get_pending_observation_features(experiment, include_failed_as_pending=False)[source]¶

Computes a list of pending observation features (corresponding to arms that have been generated and deployed in the course of the experiment, but have not been completed with data).

Parameters

experiment (Experiment) – Experiment, pending features on which we seek to compute.
include_failed_as_pending (bool) – Whether to include failed trials as pending (for example, to avoid the model suggesting them again).

Return type

Optional[Dict[str, List[ObservationFeatures]]]

Returns

An optional mapping from metric names to a list of observation features, pending for that metric (i.e. do not have evaluation data for that metric). If there are no pending features for any of the metrics, return is None.

ax.modelbridge.modelbridge_utils.parse_observation_features(X, param_names)[source]¶

Re-format raw model-generated candidates into ObservationFeatures.

Parameters

param_names (List[str]) – List of param names.
X (ndarray) – Raw np.ndarray of candidate values.

Return type

List[ObservationFeatures]

Returns

List of candidates, represented as ObservationFeatures.

ax.modelbridge.modelbridge_utils.pending_observations_as_array(pending_observations, outcome_names, param_names)[source]¶

Re-format pending observations.

Parameters

pending_observations (Dict[str, List[ObservationFeatures]]) – List of raw numpy pending observations.
outcome_names (List[str]) – List of outcome names.
param_names (List[str]) – List fitted param names.

Return type

Optional[List[ndarray]]

Returns

Filtered pending observations data, by outcome and param names.

ax.modelbridge.modelbridge_utils.transform_callback(param_names, transforms)[source]¶

A closure for performing the round trip transformations.

The function round points by de-transforming points back into the original space (done by applying transforms in reverse), and then re-transforming them. This function is specifically for points which are formatted as numpy arrays. This function is passed to _model_gen.

Parameters

param_names (List[str]) – Names of parameters to transform.
transforms (MutableMapping[str, Transform]) – Ordered set of transforms which were applied to the points.

Return type

Callable[[ndarray], ndarray]

Returns

a function with for performing the roundtrip transform.

Cross Validation¶

class ax.modelbridge.cross_validation.CVResult[source]¶

Bases: tuple

Container for cross validation results.

property observed¶: Alias for field number 0

property predicted¶: Alias for field number 1

ax.modelbridge.cross_validation.assess_model_fit(diagnostics, significance_level=0.1)[source]¶

Assess model fit for given diagnostics results.

It determines if a model fit is good or bad based on Fisher exact test p

Parameters: diagnostics (Dict[str, Dict[str, float]]) – Output of compute_diagnostics
Return type: Tuple[Dict[str, float], Dict[str, float]]
Returns: Two dictionaries, one for good metrics, one for bad metrics, each mapping metric name to p-value

ax.modelbridge.cross_validation.compute_diagnostics(result)[source]¶

Computes diagnostics for given cross validation results.

It provides a dictionary with values for the following diagnostics, for each metric:

‘Mean prediction CI’: the average width of the CIs at each of the CV predictions, relative to the observed mean.
‘MAPE’: mean absolute percentage error of the estimated mean relative to the observed mean.
‘Total raw effect’: the percent change from the smallest observed mean to the largest observed mean.
‘Correlation coefficient’: the Pearson correlation of the estimated and observed means.
‘Rank correlation’: the Spearman correlation of the estimated and observed means.
‘Fisher exact test p’: we test if the model is able to distinguish the bottom half of the observations from the top half, using Fisher’s exact test and the observed/estimated means. A low p value indicates that the model has some ability to identify good arms. A high p value indicates that the model cannot identify arms better than chance, or that the observations are too noisy to be able to tell.

Each of these is returned as a dictionary from metric name to value for that metric.

Parameters: result (List[CVResult]) – Output of cross_validate
Return type: Dict[str, Dict[str, float]]
Returns: A dictionary keyed by diagnostic name with results as described above.

ax.modelbridge.cross_validation.cross_validate(model, folds=-1, test_selector=None)[source]¶

Cross validation for model predictions.

Splits the model’s training data into train/test folds and makes out-of-sample predictions on the test folds.

Train/test splits are made based on arm names, so that repeated observations of a arm will always be in the train or test set together.

The test set can be limited to a specific set of observations by passing in a test_selector callable. This function should take in an Observation and return a boolean indiciating if it should be used in the test set or not. For example, we can limit the test set to arms with trial 0 with test_selector = lambda obs: obs.features.trial_index == 0 If not provided, all observations will be available for the test set.

Parameters

model (ModelBridge) – Fitted model (ModelBridge) to cross validate.
folds (int) – Number of folds. Use -1 for leave-one-out, otherwise will be k-fold.
test_select – Function for selecting observations for the test set.

Return type

List[CVResult]

Returns

A CVResult for each observation in the training data.

ax.modelbridge.cross_validation.cross_validate_by_trial(model, trial=-1)[source]¶

Cross validation for model predictions on a particular trial.

Uses all of the data up until the specified trial to predict each of the arms that was launched in that trial. Defaults to the last trial.

Parameters

model (ModelBridge) – Fitted model (ModelBridge) to cross validate.
trial (int) – Trial for which predictions are evaluated.

Return type

List[CVResult]

Returns

A CVResult for each observation in the training data.

Dispatch Utilities¶

ax.modelbridge.dispatch_utils.choose_generation_strategy(search_space, use_batch_trials=False, enforce_sequential_optimization=True, random_seed=None, winsorize_botorch_model=False, winsorization_limits=None, no_bayesian_optimization=False, num_trials=None, num_initialization_trials=None, no_max_parallelism=False, max_parallelism_cap=None)[source]¶

Select an appropriate generation strategy based on the properties of the search space and expected settings of the experiment, such as number of arms per trial, optimization algorithm settings, expected number of trials in the experiment, etc.

Parameters

search_space (SearchSpace) – SearchSpace, based on the properties of which to select the generation strategy.
use_batch_trials (bool) – Whether this generation strategy will be used to generate batched trials instead of 1-arm trials.
enforce_sequential_optimization (bool) – Whether to enforce that the generation strategy needs to be updated with min_trials_observed observations for a given generation step before proceeding to the next one.
random_seed (Optional[int]) – Fixed random seed for the Sobol generator.
winsorize_botorch_model (bool) – Whether to apply the winsorization transform prior to applying other transforms for fitting the BoTorch model.
winsorization_limits (Optional[Tuple[Optional[float], Optional[float]]]) – Bounds for winsorization, if winsorizing, expressed as percentile. Usually only the upper winsorization trim is used when minimizing, and only the lower when maximizing.
no_bayesian_optimization (bool) – If True, Bayesian optimization generation strategy will not be suggested and quasi-random strategy will be used.
num_trials (Optional[int]) – Total number of trials in the optimization, if known in advance.
num_initialization_trials (Optional[int]) – Specific number of initialization trials, if wanted. Typically, initialization trials are generated quasi-randomly.
no_max_parallelism (bool) – If True, no limit on parallelism will be imposed. Be aware that parallelism is limited to improve performance of Bayesian optimization, so only disable its limiting if there is a good reason to do so.
max_parallelism_cap (Optional[int]) – Integer representing a cap on parallelism in this gen. strategy; if specified, generation strategy will not generate trials if more than max_parallelism_cap trials for current generation step are running. Note that less than max_parallelism_cap may be scheduled in parallel if beneficial for Bayesian optimization performance; max_parallelism_cap is meant to just be a hard limit on parallelism (e.g., to avoid overloading machine(s) that evaluate the experiment trials).

Return type

GenerationStrategy

Transforms¶

ax.modelbridge.transforms.base¶

class ax.modelbridge.transforms.base.Transform(search_space, observation_features, observation_data, config=None)[source]¶

Bases: object

Defines the API for a transform that is applied to search_space, observation_features, observation_data, and optimization_config.

Transforms are used to adapt the search space and data into the types and structures expected by the model. When Transforms are used (for instance, in ModelBridge), it is always assumed that they may potentially mutate the transformed object in-place.

Forward transforms are defined for all four of those quantities. Reverse transforms are defined for observation_data and observation.

The forward transform for observation features must accept a partial observation with not all features recorded.

Forward and reverse transforms for observation data accept a list of observation features as an input, but they will not be mutated.

The forward transform for optimization config accepts the modelbridge and fixed features as inputs, but they will not be mutated.

This class provides an identify transform.

config: TConfig = None¶

transform_observation_data(observation_data, observation_features)[source]¶

Transform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

This takes in observation_features, so that data transforms can be conditional on features, but observation_features are notmutated.

Parameters

observation_data (List[ObservationData]) – Observation data
observation_features (List[ObservationFeatures]) – Corresponding observation features

Returns: transformed observation data

Return type: List[ObservationData]

transform_observation_features(observation_features)[source]¶

Transform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features

Returns: transformed observation features

Return type: List[ObservationFeatures]

transform_optimization_config(optimization_config, modelbridge, fixed_features)[source]¶

Transform optimization config.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: optimization_config (OptimizationConfig) – The optimization config

Returns: transformed optimization config.

Return type: OptimizationConfig

transform_search_space(search_space)[source]¶

Transform search space.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: search_space (SearchSpace) – The search space

Returns: transformed search space.

Return type: SearchSpace

untransform_observation_data(observation_data, observation_features)[source]¶

Untransform observation data.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters

observation_data (List[ObservationData]) – Observation data, in transformed space
observation_features (List[ObservationFeatures]) – Corresponding observation features, in same space.

Returns: observation data in original space.

Return type: List[ObservationData]

untransform_observation_features(observation_features)[source]¶

Untransform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features in the transformed space

Returns: observation features in the original space

Return type: List[ObservationFeatures]

ax.modelbridge.transforms.cap_parameter¶

class ax.modelbridge.transforms.cap_parameter.CapParameter(search_space, observation_features, observation_data, config=None)[source]¶

Bases: ax.modelbridge.transforms.base.Transform

Cap parameter range(s) to given values. Expects a configuration of form { parameter_name -> new_upper_range_value }.

This transform only transforms the search space.

config = None¶

transform_search_space(search_space)[source]¶

Transform search space.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: search_space (SearchSpace) – The search space

Returns: transformed search space.

Return type: SearchSpace

ax.modelbridge.transforms.centered_unit_x¶

class ax.modelbridge.transforms.centered_unit_x.CenteredUnitX(search_space, observation_features, observation_data, config=None)[source]¶

Bases: ax.modelbridge.transforms.base.Transform

Map X to [-1, 1]^d for RangeParameter of type float and not log scale.

Currently does not support linear constraints, but could in the future be adjusted to transform them too, since this is a linear operation.

Transform is done in-place.

config = None¶

transform_observation_features(observation_features)[source]¶

Transform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features

Returns: transformed observation features

Return type: List[ObservationFeatures]

transform_search_space(search_space)[source]¶

Transform search space.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: search_space (SearchSpace) – The search space

Returns: transformed search space.

Return type: SearchSpace

untransform_observation_features(observation_features)[source]¶

Untransform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features in the transformed space

Returns: observation features in the original space

Return type: List[ObservationFeatures]

ax.modelbridge.transforms.convert_metric_names¶

class ax.modelbridge.transforms.convert_metric_names.ConvertMetricNames(search_space, observation_features, observation_data, config=None)[source]¶

Bases: ax.modelbridge.transforms.base.Transform

Convert all metric names to canonical name as specified on a multi_type_experiment.

For example, a multi-type experiment may have an offline simulator which attempts to approximate observations from some online system. We want to map the offline metric names to the corresponding online ones so the model can associate them.

This is done by replacing metric names in the data with the corresponding online metric names.

In the inverse transform, data will be mapped back onto the original metric names. By default, this transform is turned off. It can be enabled by passing the “perform_untransform” flag to the config.

config = None¶

transform_observation_data(observation_data, observation_features)[source]¶

Transform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

This takes in observation_features, so that data transforms can be conditional on features, but observation_features are notmutated.

Parameters

observation_data (List[ObservationData]) – Observation data
observation_features (List[ObservationFeatures]) – Corresponding observation features

Returns: transformed observation data

Return type: List[ObservationData]

untransform_observation_data(observation_data, observation_features)[source]¶

Untransform observation data.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters

observation_data (List[ObservationData]) – Observation data, in transformed space
observation_features (List[ObservationFeatures]) – Corresponding observation features, in same space.

Returns: observation data in original space.

Return type: List[ObservationData]

ax.modelbridge.transforms.convert_metric_names.convert_mt_observations(observations, experiment)[source]¶

Apply ConvertMetricNames transform to observations for a MT experiment.

Return type: List[Observation]

ax.modelbridge.transforms.convert_metric_names.tconfig_from_mt_experiment(experiment)[source]¶

Generate the TConfig for this transform given a multi_type_experiment.

Parameters: experiment (MultiTypeExperiment) – The experiment from which to generate the config.
Return type: Dict[str, Union[int, float, str, AcquisitionFunction]]
Returns: The transform config to pass into the ConvertMetricNames constructor.

ax.modelbridge.transforms.derelativize¶

class ax.modelbridge.transforms.derelativize.Derelativize(search_space, observation_features, observation_data, config=None)[source]¶

Bases: ax.modelbridge.transforms.base.Transform

Changes relative constraints to not-relative constraints using a plug-in estimate of the status quo value.

If status quo is in-design, uses model estimate at status quo. If not, uses raw observation at status quo.

Transform is done in-place.

config = None¶

transform_optimization_config(optimization_config, modelbridge, fixed_features)[source]¶

Transform optimization config.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: optimization_config (OptimizationConfig) – The optimization config

Returns: transformed optimization config.

Return type: OptimizationConfig

ax.modelbridge.transforms.int_range_to_choice¶

class ax.modelbridge.transforms.int_range_to_choice.IntRangeToChoice(search_space, observation_features, observation_data, config=None)[source]¶

Bases: ax.modelbridge.transforms.base.Transform

Convert a RangeParameter of type int to a ordered ChoiceParameter.

Transform is done in-place.

config = None¶

transform_search_space(search_space)[source]¶

Transform search space.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: search_space (SearchSpace) – The search space

Returns: transformed search space.

Return type: SearchSpace

ax.modelbridge.transforms.int_to_float¶

class ax.modelbridge.transforms.int_to_float.IntToFloat(search_space, observation_features, observation_data, config=None)[source]¶

Bases: ax.modelbridge.transforms.base.Transform

Convert a RangeParameter of type int to type float.

Uses either randomized_rounding or default python rounding, depending on ‘rounding’ flag.

Transform is done in-place.

config = None¶

transform_observation_features(observation_features)[source]¶

Transform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features

Returns: transformed observation features

Return type: List[ObservationFeatures]

transform_search_space(search_space)[source]¶

Transform search space.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: search_space (SearchSpace) – The search space

Returns: transformed search space.

Return type: SearchSpace

untransform_observation_features(observation_features)[source]¶

Untransform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features in the transformed space

Returns: observation features in the original space

Return type: List[ObservationFeatures]

ax.modelbridge.transforms.ivw¶

class ax.modelbridge.transforms.ivw.IVW(search_space, observation_features, observation_data, config=None)[source]¶

Bases: ax.modelbridge.transforms.base.Transform

If an observation data contains multiple observations of a metric, they are combined using inverse variance weighting.

config = None¶

transform_observation_data(observation_data, observation_features)[source]¶

Transform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

This takes in observation_features, so that data transforms can be conditional on features, but observation_features are notmutated.

Parameters

observation_data (List[ObservationData]) – Observation data
observation_features (List[ObservationFeatures]) – Corresponding observation features

Returns: transformed observation data

Return type: List[ObservationData]

ax.modelbridge.transforms.ivw.ivw_metric_merge(obsd, conflicting_noiseless='warn')[source]¶

Merge multiple observations of a metric with inverse variance weighting.

Correctly updates the covariance of the new merged estimates: ybar1 = Sum_i w_i * y_i ybar2 = Sum_j w_j * y_j cov[ybar1, ybar2] = Sum_i Sum_j w_i * w_j * cov[y_i, y_j]

w_i will be infinity if any variance is 0. If one variance is 0., then the IVW estimate is the corresponding mean. If there are multiple measurements with 0 variance but means are all the same, then IVW estimate is that mean. If there are multiple measurements and means differ, behavior depends on argument conflicting_noiseless. “ignore” and “warn” will use the first of the measurements as the IVW estimate. “warn” will additionally log a warning. “raise” will raise an exception.

Parameters

obsd (ObservationData) – An ObservationData object
conflicting_noiseless (str) – “warn”, “ignore”, or “raise”

Return type

ObservationData

ax.modelbridge.transforms.log¶

class ax.modelbridge.transforms.log.Log(search_space, observation_features, observation_data, config=None)[source]¶

Bases: ax.modelbridge.transforms.base.Transform

Apply log base 10 to a float RangeParameter domain.

Transform is done in-place.

config = None¶

transform_observation_features(observation_features)[source]¶

Transform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features

Returns: transformed observation features

Return type: List[ObservationFeatures]

transform_search_space(search_space)[source]¶

Transform search space.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: search_space (SearchSpace) – The search space

Returns: transformed search space.

Return type: SearchSpace

untransform_observation_features(observation_features)[source]¶

Untransform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features in the transformed space

Returns: observation features in the original space

Return type: List[ObservationFeatures]

ax.modelbridge.transforms.one_hot¶

class ax.modelbridge.transforms.one_hot.OneHot(search_space, observation_features, observation_data, config=None)[source]¶

Bases: ax.modelbridge.transforms.base.Transform

Convert categorical parameters (unordered ChoiceParameters) to one-hot-encoded parameters.

Does not convert task parameters.

Parameters will be one-hot-encoded, yielding a set of RangeParameters, of type float, on [0, 1]. If there are two values, one single RangeParameter will be yielded, otherwise there will be a new RangeParameter for each ChoiceParameter value.

In the reverse transform, floats can be converted to a one-hot encoded vector using one of two methods:

Strict rounding: Choose the maximum value. With levels [‘a’, ‘b’, ‘c’] and: float values [0.2, 0.4, 0.3], the restored parameter would be set to ‘b’. Ties are broken randomly, so values [0.2, 0.4, 0.4] is randomly set to ‘b’ or ‘c’.
Randomized rounding: Sample from the distribution. Float values: [0.2, 0.4, 0.3] are transformed to ‘a’ w.p. 0.2/0.9, ‘b’ w.p. 0.4/0.9, or ‘c’ w.p. 0.3/0.9.

Type of rounding can be set using transform_config[‘rounding’] to either ‘strict’ or ‘randomized’. Defaults to strict.

Transform is done in-place.

config = None¶

transform_observation_features(observation_features)[source]¶

Transform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features

Returns: transformed observation features

Return type: List[ObservationFeatures]

transform_search_space(search_space)[source]¶

Transform search space.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: search_space (SearchSpace) – The search space

Returns: transformed search space.

Return type: SearchSpace

untransform_observation_features(observation_features)[source]¶

Untransform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features in the transformed space

Returns: observation features in the original space

Return type: List[ObservationFeatures]

class ax.modelbridge.transforms.one_hot.OneHotEncoder(values)[source]¶

Bases: object

Joins the two encoders needed for OneHot transform.

property classes¶

Return number of classes discovered while fitting transform.

Return type: ndarray

int_encoder: LabelEncoder = None¶

inverse_transform(encoded_labels)[source]¶

Inverse transorm a list of one hot encoded labels.

Return type: List[~T]

label_binarizer: LabelBinarizer = None¶

transform(labels)[source]¶

One hot encode a list of labels.

Return type: ndarray

ax.modelbridge.transforms.ordered_choice_encode¶

class ax.modelbridge.transforms.ordered_choice_encode.OrderedChoiceEncode(search_space, observation_features, observation_data, config=None)[source]¶

Bases: ax.modelbridge.transforms.base.Transform

Convert ordered ChoiceParameters to unit length RangeParameters.

Parameters will be transformed to an integer RangeParameter, mapped from the original choice domain to a contiguous range from [0, n_choices]. Does not transform task parameters.

In the inverse transform, parameters will be mapped back onto the original domain.

Transform is done in-place.

config = None¶

transform_observation_features(observation_features)[source]¶

Transform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features

Returns: transformed observation features

Return type: List[ObservationFeatures]

transform_search_space(search_space)[source]¶

Transform search space.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: search_space (SearchSpace) – The search space

Returns: transformed search space.

Return type: SearchSpace

untransform_observation_features(observation_features)[source]¶

Untransform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features in the transformed space

Returns: observation features in the original space

Return type: List[ObservationFeatures]

ax.modelbridge.transforms.remove_fixed¶

class ax.modelbridge.transforms.remove_fixed.RemoveFixed(search_space, observation_features, observation_data, config=None)[source]¶

Bases: ax.modelbridge.transforms.base.Transform

Remove fixed parameters.

Fixed parameters should not be included in the SearchSpace. This transform removes these parameters, leaving only tunable parameters.

Transform is done in-place.

config = None¶

transform_observation_features(observation_features)[source]¶

Transform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features

Returns: transformed observation features

Return type: List[ObservationFeatures]

transform_search_space(search_space)[source]¶

Transform search space.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: search_space (SearchSpace) – The search space

Returns: transformed search space.

Return type: SearchSpace

untransform_observation_features(observation_features)[source]¶

Untransform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features in the transformed space

Returns: observation features in the original space

Return type: List[ObservationFeatures]

ax.modelbridge.transforms.rounding¶

ax.modelbridge.transforms.rounding.contains_constrained_integer(search_space, transform_parameters)[source]¶

Check if any integer parameters are present in parameter_constraints.

Order constraints are ignored since strict rounding preserves ordering.

Return type: bool

ax.modelbridge.transforms.rounding.randomized_onehot_round(x)[source]¶

Randomized rounding of x to a one-hot vector. x should be 0 <= x <= 1.

Return type: ndarray

ax.modelbridge.transforms.rounding.randomized_round(x)[source]¶

Randomized round of x

Return type: int

ax.modelbridge.transforms.rounding.randomized_round_parameters(parameters, transform_parameters)[source]¶

Return type: Dict[str, Union[str, bool, float, int, None]]

ax.modelbridge.transforms.rounding.strict_onehot_round(x)[source]¶

Round x to a one-hot vector by selecting the max element. Ties broken randomly.

Return type: ndarray

ax.modelbridge.transforms.search_space_to_choice¶

class ax.modelbridge.transforms.search_space_to_choice.SearchSpaceToChoice(search_space, observation_features, observation_data, config=None)[source]¶

Bases: ax.modelbridge.transforms.base.Transform

Replaces the search space with a single choice parameter, whose values are the signatures of the arms observed in the data.

This transform is meant to be used with ThompsonSampler.

Transform is done in-place.

config = None¶

transform_observation_features(observation_features)[source]¶

Transform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features

Returns: transformed observation features

Return type: List[ObservationFeatures]

transform_search_space(search_space)[source]¶

Transform search space.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: search_space (SearchSpace) – The search space

Returns: transformed search space.

Return type: SearchSpace

untransform_observation_features(observation_features)[source]¶

Untransform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features in the transformed space

Returns: observation features in the original space

Return type: List[ObservationFeatures]

ax.modelbridge.transforms.standardize_y¶

class ax.modelbridge.transforms.standardize_y.StandardizeY(search_space, observation_features, observation_data, config=None)[source]¶

Bases: ax.modelbridge.transforms.base.Transform

Standardize Y, separately for each metric.

Transform is done in-place.

config = None¶

transform_observation_data(observation_data, observation_features)[source]¶

Transform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

This takes in observation_features, so that data transforms can be conditional on features, but observation_features are notmutated.

Parameters

observation_data (List[ObservationData]) – Observation data
observation_features (List[ObservationFeatures]) – Corresponding observation features

Returns: transformed observation data

Return type: List[ObservationData]

transform_optimization_config(optimization_config, modelbridge, fixed_features)[source]¶

Transform optimization config.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: optimization_config (OptimizationConfig) – The optimization config

Returns: transformed optimization config.

Return type: OptimizationConfig

untransform_observation_data(observation_data, observation_features)[source]¶

Untransform observation data.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters

observation_data (List[ObservationData]) – Observation data, in transformed space
observation_features (List[ObservationFeatures]) – Corresponding observation features, in same space.

Returns: observation data in original space.

Return type: List[ObservationData]

ax.modelbridge.transforms.standardize_y.compute_standardization_parameters(Ys)[source]¶

Compute mean and std. dev of Ys.

Return type: Tuple[Dict[Union[str, Tuple[str, str]], float], Dict[Union[str, Tuple[str, str]], float]]

ax.modelbridge.transforms.stratified_standardize_y¶

class ax.modelbridge.transforms.stratified_standardize_y.StratifiedStandardizeY(search_space, observation_features, observation_data, config=None)[source]¶

Bases: ax.modelbridge.transforms.base.Transform

Standardize Y, separately for each metric and for each value of a ChoiceParameter.

The name of the parameter by which to stratify the standardization can be specified in config[“parameter_name”]. If not specified, will use a task parameter if search space contains exactly 1 task parameter, and will raise an exception otherwise.

The stratification parameter must be fixed during generation if there are outcome constraints, in order to apply the standardization to the constraints.

Transform is done in-place.

config = None¶

transform_observation_data(observation_data, observation_features)[source]¶

Transform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

This takes in observation_features, so that data transforms can be conditional on features, but observation_features are notmutated.

Parameters

observation_data (List[ObservationData]) – Observation data
observation_features (List[ObservationFeatures]) – Corresponding observation features

Returns: transformed observation data

Return type: List[ObservationData]

transform_optimization_config(optimization_config, modelbridge, fixed_features)[source]¶

Transform optimization config.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: optimization_config (OptimizationConfig) – The optimization config

Returns: transformed optimization config.

Return type: OptimizationConfig

untransform_observation_data(observation_data, observation_features)[source]¶

Untransform observation data.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters

observation_data (List[ObservationData]) – Observation data, in transformed space
observation_features (List[ObservationFeatures]) – Corresponding observation features, in same space.

Returns: observation data in original space.

Return type: List[ObservationData]

ax.modelbridge.transforms.task_encode¶

class ax.modelbridge.transforms.task_encode.TaskEncode(search_space, observation_features, observation_data, config=None)[source]¶

Bases: ax.modelbridge.transforms.ordered_choice_encode.OrderedChoiceEncode

Convert task ChoiceParameters to unit length RangeParameters.

Parameters will be transformed to an integer RangeParameter, mapped from the original choice domain to a contiguous range from [0, n_choices].

In the inverse transform, parameters will be mapped back onto the original domain.

Transform is done in-place.

config = None¶

ax.modelbridge.transforms.trial_as_task¶

class ax.modelbridge.transforms.trial_as_task.TrialAsTask(search_space, observation_features, observation_data, config=None)[source]¶

Bases: ax.modelbridge.transforms.base.Transform

Convert trial to one or more task parameters.

How trial is mapped to parameter is specified with a map like {parameter_name: {trial_index: level name}}. For example, {“trial_param1”: {0: “level1”, 1: “level1”, 2: “level2”},} will create choice parameters “trial_param1” with is_task=True. Observations with trial 0 or 1 will have “trial_param1” set to “level1”, and those with trial 2 will have “trial_param1” set to “level2”. Multiple parameter names and mappings can be specified in this dict.

The trial level mapping can be specified in config[“trial_level_map”]. If not specified, defaults to a parameter with a level for every trial index.

For the reverse transform, if there are multiple mappings in the transform the trial will not be set.

Will raise if trial not specified for every point in the training data.

Transform is done in-place.

config = None¶

transform_observation_features(observation_features)[source]¶

Transform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features

Returns: transformed observation features

Return type: List[ObservationFeatures]

transform_search_space(search_space)[source]¶

Transform search space.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: search_space (SearchSpace) – The search space

Returns: transformed search space.

Return type: SearchSpace

untransform_observation_features(observation_features)[source]¶

Untransform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features in the transformed space

Returns: observation features in the original space

Return type: List[ObservationFeatures]

ax.modelbridge.transforms.unit_x¶

class ax.modelbridge.transforms.unit_x.UnitX(search_space, observation_features, observation_data, config=None)[source]¶

Bases: ax.modelbridge.transforms.base.Transform

Map X to [0, 1]^d for RangeParameter of type float and not log scale.

Uses bounds l <= x <= u, sets x_tilde_i = (x_i - l_i) / (u_i - l_i). Constraints wTx <= b are converted to gTx_tilde <= h, where g_i = w_i (u_i - l_i) and h = b - wTl.

Transform is done in-place.

config = None¶

transform_observation_features(observation_features)[source]¶

Transform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features

Returns: transformed observation features

Return type: List[ObservationFeatures]

transform_search_space(search_space)[source]¶

Transform search space.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: search_space (SearchSpace) – The search space

Returns: transformed search space.

Return type: SearchSpace

untransform_observation_features(observation_features)[source]¶

Untransform observation features.

This is typically done in-place. This class implements the identity transform (does nothing).

Parameters: observation_features (List[ObservationFeatures]) – Observation features in the transformed space

Returns: observation features in the original space

Return type: List[ObservationFeatures]

ax.modelbridge.winsorize¶

class ax.modelbridge.transforms.winsorize.Winsorize(search_space, observation_features, observation_data, config=None)[source]¶

Bases: ax.modelbridge.transforms.base.Transform

Clip the mean values for each metric to lay within the limits provided in the config as a tuple of (lower bound percentile, upper bound percentile). Config should include those bounds under key “winsorization_limits”.

config = None¶

transform_observation_data(observation_data, observation_features)[source]¶

Winsorize observation data in place.

Return type: List[ObservationData]