0.1.10

Using Ax for Human-in-the-loop Experimentation¶

While Ax can be used in as a fully automated service, generating and deploying candidates Ax can be also used in a trial-by-trial fashion, allowing for human oversight.

Typically, human intervention in Ax is necessary when there are clear tradeoffs between multiple metrics of interest. Condensing multiple outcomes of interest into a single scalar quantity can be really challenging. Instead, it can be useful to specify an objective and constraints, and tweak these based on the information from the experiment.

To facilitate this, Ax provides the following key features:

  1. Constrained optimization
  2. Interfaces for easily modifying optimization goals
  3. Utilities for visualizing and deploying new trials composed of multiple optimizations.

In this tutorial, we'll demonstrate how Ax enables users to explore these tradeoffs. With an understanding of the tradeoffs present in our data, we'll then make use of the constrained optimization utilities to generate candidates from multiple different optimization objectives, and create a conglomerate batch, with all of these candidates in together in one trial.

Experiment Setup

For this tutorial, we will assume our experiment has already been created.

In [1]:
from ax import Data, Metric, OptimizationConfig, Objective, OutcomeConstraint, ComparisonOp, load
from ax.modelbridge.cross_validation import cross_validate
from ax.modelbridge.factory import get_GPEI
from ax.plot.diagnostic import tile_cross_validation
from ax.plot.scatter import plot_multiple_metrics, tile_fitted
from ax.utils.notebook.plotting import render, init_notebook_plotting

import pandas as pd

init_notebook_plotting()

[INFO 03-20 17:45:42] ipy_plotting: Injecting Plotly library into cell. Do not overwrite or delete cell.
In [2]:
experiment = load('hitl_exp.json')

Initial Sobol Trial

Bayesian Optimization experiments almost always begin with a set of random points. In this experiment, these points were chosen via a Sobol sequence, accessible via the ModelBridge factory.

A collection of points run and analyzed together form a BatchTrial. A Trial object provides metadata pertaining to the deployment of these points, including details such as when they were deployed, and the current status of their experiment.

Here, we see an initial experiment has finished running (COMPLETED status).

In [3]:
experiment.trials[0]
Out[3]:
BatchTrial(experiment_name='human_in_the_loop_tutorial', index=0, status=TrialStatus.COMPLETED)
In [4]:
experiment.trials[0].time_created
Out[4]:
datetime.datetime(2019, 3, 29, 18, 10, 6)
In [5]:
# Number of arms in first experiment, including status_quo
len(experiment.trials[0].arms)
Out[5]:
65
In [6]:
# Sample arm configuration
experiment.trials[0].arms[0]
Out[6]:
Arm(name='0_0', parameters={'x_excellent': 0.9715802669525146, 'x_good': 0.8615524768829346, 'x_moderate': 0.7668091654777527, 'x_poor': 0.34871453046798706, 'x_unknown': 0.7675797343254089, 'y_excellent': 2.900710028409958, 'y_good': 1.5137152910232545, 'y_moderate': 0.6775947093963622, 'y_poor': 0.4974367544054985, 'y_unknown': 1.0852564811706542, 'z_excellent': 517803.49761247635, 'z_good': 607874.5171427727, 'z_moderate': 1151881.2023103237, 'z_poor': 2927449.2621421814, 'z_unknown': 2068407.6935052872})

Experiment Analysis

Optimization Config

An important construct for analyzing an experiment is an OptimizationConfig. An OptimizationConfig contains an objective, and outcome constraints. Experiment's can have a default OptimizationConfig, but models can also take an OptimizationConfig as input independent of the default.

Objective: A metric to optimize, along with a direction to optimize (default: maximize)

Outcome Constraint: A metric to constrain, along with a constraint direction (<= or >=), as well as a bound.

Let's start with a simple OptimizationConfig. By default, our objective metric will be maximized, but can be minimized by setting the minimize flag. Our outcome constraint will, by default, be evaluated as a relative percentage change. This percentage change is computed relative to the experiment's status quo arm.

In [7]:
experiment.status_quo
Out[7]:
Arm(name='status_quo', parameters={'x_excellent': 0, 'x_good': 0, 'x_moderate': 0, 'x_poor': 0, 'x_unknown': 0, 'y_excellent': 1, 'y_good': 1, 'y_moderate': 1, 'y_poor': 1, 'y_unknown': 1, 'z_excellent': 1000000, 'z_good': 1000000, 'z_moderate': 1000000, 'z_poor': 1000000, 'z_unknown': 1000000})
In [8]:
objective_metric = Metric(name="metric_1")
constraint_metric = Metric(name="metric_2")

experiment.optimization_config = OptimizationConfig(
    objective=Objective(objective_metric),
    outcome_constraints=[
        OutcomeConstraint(metric=constraint_metric, op=ComparisonOp.LEQ, bound=5),
    ]
)

Data

Another critical piece of analysis is data itself! Ax data follows a standard format, shown below. This format is imposed upon the underlying data structure, which is a Pandas DataFrame.

A key set of fields are required for all data, for use with Ax models.

It's a good idea to double check our data before fitting models -- let's make sure all of our expected metrics and arms are present.

In [9]:
data = Data(pd.read_json('hitl_data.json'))
data.df.head()
Out[9]:
arm_name metric_name mean sem trial_index start_time end_time n
0 0_1 metric_1 495.763048 2.621641 0 2019-03-30 2019-04-03 1599994
1 0_23 metric_1 524.367712 2.731647 0 2019-03-30 2019-04-03 1596356
2 0_14 metric_2 21.460244 0.069457 0 2019-03-30 2019-04-03 1600182
3 0_53 metric_2 21.437433 0.069941 0 2019-03-30 2019-04-03 1601081
4 0_53 metric_1 548.387691 2.893486 0 2019-03-30 2019-04-03 1601081
In [10]:
data.df['arm_name'].unique()
Out[10]:
array(['0_1', '0_23', '0_14', '0_53', '0_0', '0_54', '0_55', '0_56',
       '0_27', '0_57', '0_58', '0_13', '0_59', '0_6', '0_60', '0_61',
       '0_62', '0_63', '0_7', '0_28', '0_15', '0_16', '0_17', '0_18',
       '0_19', '0_29', '0_2', '0_20', '0_21', '0_22', '0_3', '0_30',
       '0_8', '0_10', '0_31', '0_24', '0_32', '0_33', '0_34', '0_35',
       '0_36', '0_37', '0_38', '0_9', '0_39', '0_4', '0_25', '0_11',
       '0_40', '0_41', '0_42', '0_43', '0_44', '0_45', 'status_quo',
       '0_46', '0_47', '0_48', '0_26', '0_49', '0_12', '0_5', '0_50',
       '0_51', '0_52'], dtype=object)
In [11]:
data.df['metric_name'].unique()
Out[11]:
array(['metric_1', 'metric_2'], dtype=object)

Search Space

The final component necessary for human-in-the-loop optimization is a SearchSpace. A SearchSpace defines the feasible region for our parameters, as well as their types.

Here, we have both parameters and a set of constraints on those parameters.

Without a SearchSpace, our models are unable to generate new candidates. By default, the models will read the search space off of the experiment, when they are told to generate candidates. SearchSpaces can also be specified by the user at this time. Sometimes, the first round of an experiment is too restrictive--perhaps the experimenter was too cautious when defining their initial ranges for exploration! In this case, it can be useful to generate candidates from new, expanded search spaces, beyond that specified in the experiment.

In [12]:
experiment.search_space.parameters
Out[12]:
{'x_excellent': RangeParameter(name='x_excellent', parameter_type=FLOAT, range=[0.0, 1.0]),
 'x_good': RangeParameter(name='x_good', parameter_type=FLOAT, range=[0.0, 1.0]),
 'x_moderate': RangeParameter(name='x_moderate', parameter_type=FLOAT, range=[0.0, 1.0]),
 'x_poor': RangeParameter(name='x_poor', parameter_type=FLOAT, range=[0.0, 1.0]),
 'x_unknown': RangeParameter(name='x_unknown', parameter_type=FLOAT, range=[0.0, 1.0]),
 'y_excellent': RangeParameter(name='y_excellent', parameter_type=FLOAT, range=[0.1, 3.0]),
 'y_good': RangeParameter(name='y_good', parameter_type=FLOAT, range=[0.1, 3.0]),
 'y_moderate': RangeParameter(name='y_moderate', parameter_type=FLOAT, range=[0.1, 3.0]),
 'y_poor': RangeParameter(name='y_poor', parameter_type=FLOAT, range=[0.1, 3.0]),
 'y_unknown': RangeParameter(name='y_unknown', parameter_type=FLOAT, range=[0.1, 3.0]),
 'z_excellent': RangeParameter(name='z_excellent', parameter_type=FLOAT, range=[50000.0, 5000000.0]),
 'z_good': RangeParameter(name='z_good', parameter_type=FLOAT, range=[50000.0, 5000000.0]),
 'z_moderate': RangeParameter(name='z_moderate', parameter_type=FLOAT, range=[50000.0, 5000000.0]),
 'z_poor': RangeParameter(name='z_poor', parameter_type=FLOAT, range=[50000.0, 5000000.0]),
 'z_unknown': RangeParameter(name='z_unknown', parameter_type=FLOAT, range=[50000.0, 5000000.0])}
In [13]:
experiment.search_space.parameter_constraints
Out[13]:
[OrderConstraint(x_poor <= x_moderate),
 OrderConstraint(x_moderate <= x_good),
 OrderConstraint(x_good <= x_excellent),
 OrderConstraint(y_poor <= y_moderate),
 OrderConstraint(y_moderate <= y_good),
 OrderConstraint(y_good <= y_excellent)]

Model Fit

Fitting BoTorch's GPEI will allow us to predict new candidates based on our first Sobol batch. Here, we make use of the default settings for GP-EI defined in the ModelBridge factory.

In [14]:
gp = get_GPEI(
    experiment=experiment,
    data=data,
)

We can validate the model fits using cross validation, shown below for each metric of interest. Here, our model fits leave something to be desired--the tail ends of each metric are hard to model. In this situation, there are three potential actions to take:

  1. Increase the amount of traffic in this experiment, to reduce the measurement noise.
  2. Increase the number of points run in the random batch, to assist the GP in covering the space.
  3. Reduce the number of parameters tuned at one time.

However, away from the tail effects, the fits do show a strong correlations, so we will proceed with candidate generation.

In [15]:
cv_result = cross_validate(gp)
render(tile_cross_validation(cv_result))

The parameters from the initial batch have a wide range of effects on the metrics of interest, as shown from the outcomes from our fitted GP model.

In [16]:
render(tile_fitted(gp, rel=True))
In [17]:
METRIC_X_AXIS = 'metric_1'
METRIC_Y_AXIS = 'metric_2'

render(plot_multiple_metrics(
    gp,
    metric_x=METRIC_X_AXIS,
    metric_y=METRIC_Y_AXIS,
))

Candidate Generation

With our fitted GPEI model, we can optimize EI (Expected Improvement) based on any optimization config. We can start with our initial optimization config, and aim to simply maximize the playback smoothness, without worrying about the constraint on quality.

In [18]:
unconstrained = gp.gen(
    n=3,
    optimization_config=OptimizationConfig(
        objective=Objective(objective_metric),
    )
)

Let's plot the tradeoffs again, but with our new arms.

In [19]:
render(plot_multiple_metrics(
    gp,
    metric_x=METRIC_X_AXIS,
    metric_y=METRIC_Y_AXIS,
    generator_runs_dict={
        'unconstrained': unconstrained,
    }
))

Change Objectives

With our unconstrained optimization, we generate some candidates which are pretty promising with respect to our objective! However, there is a clear regression in our constraint metric, above our initial 5% desired constraint. Let's add that constraint back in.

In [20]:
constraint_5 = OutcomeConstraint(metric=constraint_metric, op=ComparisonOp.LEQ, bound=5)
constraint_5_results = gp.gen(
    n=3, 
    optimization_config=OptimizationConfig(
        objective=Objective(objective_metric),
        outcome_constraints=[constraint_5]
    )
)

This yields a GeneratorRun, which contains points according to our specified optimization config, along with metadata about how the points were generated. Let's plot the tradeoffs in these new points.

In [21]:
from ax.plot.scatter import plot_multiple_metrics
render(plot_multiple_metrics(
    gp,
    metric_x=METRIC_X_AXIS,
    metric_y=METRIC_Y_AXIS,
    generator_runs_dict={
        'constraint_5': constraint_5_results
    }
))

It is important to note that the treatment of constraints in GP EI is probabilistic. The acquisition function weights our objective by the probability that each constraint is feasible. Thus, we may allow points with a very small probability of violating the constraint to be generated, as long as the chance of the points increasing our objective is high enough.

You can see above that the point estimate for each point is significantly below a 5% increase in the constraint metric, but that there is uncertainty in our prediction, and the tail probabilities do include probabilities of small regressions beyond 5%.

In [22]:
constraint_1 = OutcomeConstraint(metric=constraint_metric, op=ComparisonOp.LEQ, bound=1)
constraint_1_results = gp.gen(
    n=3, 
    optimization_config=OptimizationConfig(
        objective=Objective(objective_metric),
        outcome_constraints=[constraint_1],
    )
)
In [23]:
render(plot_multiple_metrics(
    gp,
    metric_x=METRIC_X_AXIS,
    metric_y=METRIC_Y_AXIS,
    generator_runs_dict={
        "constraint_1": constraint_1_results,
    }
))

Finally, let's view all three sets of candidates together.

In [24]:
render(plot_multiple_metrics(
    gp,
    metric_x=METRIC_X_AXIS,
    metric_y=METRIC_Y_AXIS,
    generator_runs_dict={
        'unconstrained': unconstrained,
        'loose_constraint': constraint_5_results,
        'tight_constraint': constraint_1_results,
    }
))

Creating a New Trial

Having done the analysis and candidate generation for three different optimization configs, we can easily create a new BatchTrial which combines the candidates from these three different optimizations. Each set of candidates looks promising -- the point estimates are higher along both metric values than in the previous batch. However, there is still a good bit of uncertainty in our predictions. It is hard to choose between the different constraint settings without reducing this noise, so we choose to run a new trial with all three constraint settings. However, we're generally convinced that the tight constraint is too conservative. We'd still like to reduce our uncertainty in that region, but we'll only take one arm from that set.

In [25]:
# We can add entire generator runs, when constructing a new trial. 
trial = experiment.new_batch_trial().add_generator_run(unconstrained).add_generator_run(constraint_5_results)

# Or, we can hand-pick arms. 
trial.add_arm(constraint_1_results.arms[0])
Out[25]:
BatchTrial(experiment_name='human_in_the_loop_tutorial', index=1, status=TrialStatus.CANDIDATE)

The arms are combined into a single trial, along with the status_quo arm. Their generator can be accessed from the trial as well.

In [26]:
experiment.trials[1].arms
Out[26]:
[Arm(name='1_0', parameters={'x_excellent': 0.6810277966264183, 'x_good': 0.31206451784238975, 'x_moderate': 0.23337619190647763, 'x_poor': 0.10219343844057818, 'x_unknown': 0.760433568566807, 'y_excellent': 2.566844680721129, 'y_good': 1.7566408092163726, 'y_moderate': 0.8194488783827847, 'y_poor': 0.2744912887464769, 'y_unknown': 1.912906243418841, 'z_excellent': 4793642.261519941, 'z_good': 3656645.711089254, 'z_moderate': 2507592.827862918, 'z_poor': 1437654.7562104636, 'z_unknown': 2426175.0626716013}),
 Arm(name='1_1', parameters={'x_excellent': 0.7223005431535086, 'x_good': 0.3700673777828665, 'x_moderate': 0.319589387939645, 'x_poor': 0.12652861270894686, 'x_unknown': 0.5640907891393588, 'y_excellent': 2.587245410528788, 'y_good': 1.9682624448015527, 'y_moderate': 1.0434197129183445, 'y_poor': 0.3285292065632337, 'y_unknown': 1.1442501564474263, 'z_excellent': 4905830.067147889, 'z_good': 2964260.343288982, 'z_moderate': 3043644.1721064146, 'z_poor': 2538599.0484043844, 'z_unknown': 1676360.9948316503}),
 Arm(name='1_2', parameters={'x_excellent': 0.7067728497337189, 'x_good': 0.26005001534291533, 'x_moderate': 0.1665819165918935, 'x_poor': 0.1065857096077233, 'x_unknown': 0.9082050874150543, 'y_excellent': 2.4383556447677615, 'y_good': 1.6818905283845738, 'y_moderate': 0.5712522722943407, 'y_poor': 0.3243454386942638, 'y_unknown': 2.179187572905732, 'z_excellent': 4512171.2722107405, 'z_good': 4122691.3431410627, 'z_moderate': 2081445.933290975, 'z_poor': 766762.978070889, 'z_unknown': 3111191.21902966}),
 Arm(name='1_3', parameters={'x_excellent': 0.7902386537970847, 'x_good': 0.5279845186752136, 'x_moderate': 0.3378718639095799, 'x_poor': 0.1139488254962186, 'x_unknown': 0.684105605003766, 'y_excellent': 2.613002460108169, 'y_good': 1.8092873823365074, 'y_moderate': 0.8606752562982023, 'y_poor': 0.3115787600712633, 'y_unknown': 1.7130296338449216, 'z_excellent': 4869250.33561693, 'z_good': 3527255.773934231, 'z_moderate': 3088228.031995592, 'z_poor': 1875818.7098433068, 'z_unknown': 2512277.4065714953}),
 Arm(name='1_4', parameters={'x_excellent': 0.664051029468801, 'x_good': 0.5139017370193185, 'x_moderate': 0.402143349608106, 'x_poor': 0.05307737512808195, 'x_unknown': 0.5911952363345104, 'y_excellent': 2.485831215428807, 'y_good': 1.8984425774083993, 'y_moderate': 1.0116415660499194, 'y_poor': 0.2418005243157498, 'y_unknown': 1.2156169885935124, 'z_excellent': 4530064.764548857, 'z_good': 2736233.0744596333, 'z_moderate': 2473928.4809331005, 'z_poor': 2953365.54562382, 'z_unknown': 1130259.716179118}),
 Arm(name='1_5', parameters={'x_excellent': 0.8262332047534766, 'x_good': 0.4518750878394794, 'x_moderate': 0.3900459659773735, 'x_poor': 0.2643721426069692, 'x_unknown': 0.7149924377526723, 'y_excellent': 2.648118427090796, 'y_good': 2.253810872912625, 'y_moderate': 0.9646742423945431, 'y_poor': 0.626726636640154, 'y_unknown': 1.8025667770942089, 'z_excellent': 4369909.972807657, 'z_good': 4269548.422907823, 'z_moderate': 4236994.683996065, 'z_poor': 2226815.2995190606, 'z_unknown': 3463881.911588156}),
 Arm(name='1_6', parameters={'x_excellent': 0.7590459416009847, 'x_good': 0.7036519829718367, 'x_moderate': 0.44921820209334806, 'x_poor': 0.035434323469166515, 'x_unknown': 0.7626099734469179, 'y_excellent': 2.646448394021947, 'y_good': 1.8642810278935855, 'y_moderate': 0.8452868385739735, 'y_poor': 0.18052355904039244, 'y_unknown': 1.3741867518753115, 'z_excellent': 4561802.585365397, 'z_good': 2733851.179805342, 'z_moderate': 2004005.5603148805, 'z_poor': 2887792.9015876395, 'z_unknown': 1660703.4350797534})]

The original GeneratorRuns can be accessed from within the trial as well. This is useful for later analyses, allowing introspection of the OptimizationConfig used for generation (as well as other information, e.g. SearchSpace used for generation).

In [27]:
experiment.trials[1]._generator_run_structs
Out[27]:
[GeneratorRunStruct(generator_run=GeneratorRun(3 arms, total weight 3.0), weight=1.0),
 GeneratorRunStruct(generator_run=GeneratorRun(3 arms, total weight 3.0), weight=1.0),
 GeneratorRunStruct(generator_run=GeneratorRun(1 arms, total weight 1.0), weight=1.0)]

Here, we can see the unconstrained set-up used for our first set of candidates.

In [28]:
experiment.trials[1]._generator_run_structs[0].generator_run.optimization_config
Out[28]:
OptimizationConfig(objective=Objective(metric_name="metric_1", minimize=False), outcome_constraints=[])
Download Tutorial Archive (.tar.gz): Notebook, Source and Data
Download Tutorial Jupyter Notebook
Download Tutorial Source Code

Total runtime of script: 2 minutes, 39.16 seconds.