diff --git a/docs/source/technical_details/ax_botorch/model_bridge_gen_guide.md b/docs/source/technical_details/ax_botorch/model_bridge_gen_guide.md new file mode 100644 index 00000000..880fbb6d --- /dev/null +++ b/docs/source/technical_details/ax_botorch/model_bridge_gen_guide.md @@ -0,0 +1,569 @@ +# Candidate Generation Flow: `ModelBridge.gen()` → `scipy.optimize.minimize` + +This document give an overview of the key concepts and flow when calling `ax.ModelBridge.gen()`. + +Related resources: +- `docs\source\technical_details\ax_botorch\options_routing_guide.md`: Deepdive on passing optimisation arguments. +- `tutorials\ax_botorch\botorch_minimal_example_custom_acq.ipynb`: Minimal code example of custom acquisition function integration. + +**Ax version**: 0.3.7 +**BoTorch version**: as pinned by ax 0.3.7 + +NOTE: largely generate with AI, mid-level human review. + +## Table of Contents +1. [Overview](#overview) +2. [Architecture Layers](#architecture-layers) +3. [Detailed Flow](#detailed-flow) +4. [Key Classes and Responsibilities](#key-classes-and-responsibilities) +5. [Optimization Parameter Pipeline](#optimization-parameter-pipeline) +6. [Code Examples](#code-examples) +7. [References](#references) + +--- + +## Overview +The Ax/Botorch/Scipy layers have the following high level concerns when `.gen()` is called: +- **Ax**: Formulate the different objects Ax supports (e.g. data formats, search space types, transforms multi-objective, multi-fidelity, constraints, etc.) into a botorch acqusition function, which is then optimised. +- **BoTorch**: `AcquisitionFunction` definition, and associated higher level optimisation routines (Multi restart, initial conditions etc.) +- **Scipy**: Optimisation engine, performs the optimisation from a given point. + +See `tutorials/ax_botorch/botorch_minimal_example_custom_acq.ipynb` for minimal code example of each of these steps. + +### Conceptual Architecture +**Ax level** — transforms Ax objects into tensors, then creates and runs an `Acquisition` (Ax's internal wrapper around BoTorch components): + +``` +ModelBridge.gen(n, model_gen_options) [ax.modelbridge.torch.TorchModelBridge] + ↓ + BoTorchModel.gen() [ax.models.torch.botorch_modular.model.BoTorchModel] + ├── Acquisition.__init__() [ax.models.torch.botorch_modular.acquisition.Acquisition] + │ └── botorch_acqf_class(...) [botorch.acquisition.AcquisitionFunction subclass] + └── Acquisition.optimize() + └── optimize_acqf(...) [botorch.optim.optimize] +``` + +- `Acquisition.__init__()`: exists to handle all Ax-specific logic around acquisition function construction (pending observations, multi-objective, constraints, multi-fidelity, etc.) before simply instantiating a `botorch.acquisition.AcquisitionFunction`. + - BoTorch integration: Acquisition function must **register an input constructor** (`@acqf_input_constructor`). This selects the the relevant kwargs to instantiate the botrch acquistion function from a large set Ax provided. + +- `Acquisition.optimize()` exists to handle Ax logic for different search space types (continuous, discrete, mixed) before simply calling `botorch.optim.optimize.optimize_acqf` (or its discrete equivalent). + - BoTorch integration: Acquisition function must **register optimizer defaults** (`@optimizer_argparse.register`). This provides sensible default optimization parameters (e.g. `num_restarts`, `method`, `with_grad`) that can be overridden by the user. + +**BoTorch level**: +- `botorch.acquisition.AcquisitionFunction`: has a `forward()` method returning the acquisition score for a candidate point +- `botorch.optim.optimize.optimize_acqf`: helper to optimise an `AcquisitionFunction` with multi-start and initial condition generation + + +### Code flow +``` +User Code + ↓ +ModelBridge.gen(n, model_gen_options) + ↓ +TorchModelBridge._gen() + ├── Transforms search space → SearchSpaceDigest + ├── Builds TorchOptConfig (embeds model_gen_options) + └── calls → BoTorchModel.gen() + ├── construct_acquisition_and_optimizer_options() + │ ├── acq_options ← model_gen_options["acquisition_function_kwargs"] + │ └── opt_options ← model_gen_options["optimizer_kwargs"] + ├── _instantiate_acquisition(acq_options) + │ └── Acquisition.__init__() + │ ├── get_acqf_input_constructor() → input_constructor + │ ├── input_constructor(**acq_options) → acqf_inputs + │ └── botorch_acqf_class(**acqf_inputs) → self.acqf + └── Acquisition.optimize(opt_options) + ├── optimizer_argparse(acqf, optimizer_options=opt_options) + └── optimize_acqf(**optimizer_options_with_defaults) + └── _optimize_acqf_batch() + ├── gen_batch_initial_conditions() + └── gen_candidates_scipy() + └── minimize_with_timeout() + └── scipy.optimize.minimize() +``` +--- +## Key workflow to integrate botorch acquisition function into Ax Generation: +To use a custom BoTorch acquisition function in Ax, the following integration points are relevant: +- **Acquisition Function Construction (Mandatory)**: Register an input constructor that extracts the relevant kwargs for acqusition function instantiation from a large set passed by Ax. +- **Optimizer Defaults (recommended)**: Register default optimization parameters for your acquisition function, which can be overridden by user-provided options. + +### Acquisition Function Construction +See `tutorials\ax_botorch\botorch_minimal_example_custom_acq.ipynb`, `construct_inputs_custom_acq` function for a minimal code example. + +### Optimizer Defaults +See `tutorials\ax_botorch\botorch_minimal_example_custom_acq.ipynb`, `_argparse_custom_acquisition` function for a minimal code example. + +--- +## Details: +### Architecture Layers + +#### 1. Entry Point: `ModelBridge.gen()` + +**Location**: `ax.modelbridge.base.ModelBridge` + +**Purpose**: User-facing entry point for generating new candidate points. Handles Ax-level transforms and validation before delegating to the model. + +**Key Parameters**: +- `n`: Number of candidates to generate +- `search_space`: Search space (defaults to model's search space) +- `optimization_config`: Objective and constraints +- `pending_observations`: Points currently being evaluated +- `fixed_features`: Features to fix during generation +- `model_gen_options`: Dictionary controlling acquisition and optimization behaviour + +**Key Behaviour**: +- Validates inputs +- Applies Ax transforms to search space and observations +- Calls `self._gen(...)` passing `model_gen_options` through unchanged +- Untransforms generated candidates back to problem space + +#### 2. Bridge Layer: `TorchModelBridge._gen()` + +**Location**: `ax.modelbridge.torch.TorchModelBridge` + +**Purpose**: Converts Ax-level objects into tensor-based representations suitable for BoTorch, and packages everything into a `TorchOptConfig`. + +**Key Behaviour**: +- Merges `self._default_model_gen_options` with user-provided `model_gen_options` +- Builds `SearchSpaceDigest` (bounds, feature types, etc.) +- Builds `TorchOptConfig` dataclass containing: + - `objective_weights`, `outcome_constraints`, `linear_constraints` + - `fixed_features`, `pending_observations` + - `model_gen_options` (passed through as-is) + - `rounding_func` +- Calls `self.model.gen(n, search_space_digest, torch_opt_config)` + +#### 3. Model Layer: `BoTorchModel.gen()` + +**Location**: `ax.models.torch.botorch_modular.model.BoTorchModel` + +**Purpose**: Orchestrates the two main steps: acquisition function instantiation and optimization. Splits the user's options into the two relevant streams. + +**Key Behaviour**: +- Calls `construct_acquisition_and_optimizer_options()` to split options +- Calls `_instantiate_acquisition()` with `acq_options` +- Calls `Acquisition.optimize()` with `opt_options` + +#### 4. Acquisition Wrapper: `Acquisition` + +**Location**: `ax.models.torch.botorch_modular.acquisition.Acquisition` + +**Purpose**: Ax's wrapper around a BoTorch `AcquisitionFunction`. Handles instantiation (via input constructors) and optimization (via `optimize_acqf`). + +**Key Attributes**: +- `acqf`: The actual BoTorch `AcquisitionFunction` instance +- `surrogates`: Dict of Surrogate model(s) +- `options`: The `acq_options` dict passed during construction +- `X_pending`: Pending points tensor +- `X_observed`: Observed points tensor + +**Key Methods**: +- `__init__()`: Instantiates the BoTorch acquisition function via input constructor +- `optimize()`: Runs multi-start optimization of the acquisition function +- `evaluate()`: Evaluates the acquisition function at given points + +#### 5. Optimizer Argument Parser: `optimizer_argparse` + +**Location**: `ax.models.torch.botorch_modular.optimizer_argparse` + +**Purpose**: A `Dispatcher` that resolves default optimization parameters based on the acquisition function type. Custom acquisition functions can register their own defaults. + +**Key Behaviour**: +- Dispatches based on the acquisition function class (uses class hierarchy) +- Returns a dict of kwargs for `optimize_acqf` +- User-provided `optimizer_options` override the defaults + +#### 6. BoTorch Optimization: `optimize_acqf()` + +**Location**: `botorch.optim.optimize` + +**Purpose**: Multi-start optimization of the acquisition function. Generates initial conditions, then runs local optimization from each start. + +**Key Parameters**: +- `acq_function`: The BoTorch acquisition function +- `bounds`: Parameter bounds tensor `(2, d)` +- `q`: Number of candidates per batch +- `num_restarts`: Number of random restarts for multi-start optimization +- `raw_samples`: Number of initial quasi-random samples for generating starting points +- `options`: Dict passed to `gen_candidates_scipy` (and eventually to scipy) +- `sequential`: Whether to optimize candidates one at a time +- `gen_candidates`: Callable for local optimization (default: `gen_candidates_scipy`) + +#### 7. Scipy Interface: `gen_candidates_scipy()` + +**Location**: `botorch.generation.gen` + +**Purpose**: Wraps the acquisition function for scipy consumption. Converts between torch tensors and numpy arrays, handles gradient computation. + +**Key Parameters (via `options` dict)**: +- `method`: Scipy optimizer method (default: `"L-BFGS-B"` or `"SLSQP"` with constraints) +- `with_grad`: Whether to compute gradients (default: `True`) +- `maxiter`: Maximum iterations (default: `2000`) +- `callback`: Optional callback function +- Any other key is passed as scipy `options` + +#### 8. Scipy: `minimize_with_timeout()` + +**Location**: `botorch.optim.utils.timeout` + +**Purpose**: Thin wrapper around `scipy.optimize.minimize` that adds timeout support via an injected callback. + +--- + +### Flow + +#### Step 1: User calls `ModelBridge.gen()` + +```python +model_bridge.gen(n=1, model_gen_options={...}) +``` + +#### Step 2: `TorchModelBridge._gen()` merges options and builds config + +```python +augmented_model_gen_options = { + **self._default_model_gen_options, + **(model_gen_options or {}), +} +# Builds TorchOptConfig with model_gen_options embedded +search_space_digest, torch_opt_config = self._get_transformed_model_gen_args(...) +# Delegates to the model +gen_results = self.model.gen(n, search_space_digest, torch_opt_config) +``` + +#### Step 3: `BoTorchModel.gen()` splits options + +```python +acq_options, opt_options = construct_acquisition_and_optimizer_options( + acqf_options=self.acquisition_options, + model_gen_options=torch_opt_config.model_gen_options, +) +``` + +**`construct_acquisition_and_optimizer_options`** (in `ax/models/torch/botorch_modular/utils.py`): +- `acq_options` = `self.acquisition_options` merged with `model_gen_options["acquisition_function_kwargs"]` +- `opt_options` = copy of `model_gen_options["optimizer_kwargs"]` + +Key constants: +- `Keys.ACQF_KWARGS = "acquisition_function_kwargs"` +- `Keys.OPTIMIZER_KWARGS = "optimizer_kwargs"` + +#### Step 4: `_instantiate_acquisition()` creates the Acquisition wrapper + +```python +acqf = self._instantiate_acquisition( + search_space_digest=search_space_digest, + torch_opt_config=torch_opt_config, + acq_options=acq_options, +) +``` + +This creates: +```python +return self.acquisition_class( + surrogates=self.surrogates, + botorch_acqf_class=self.botorch_acqf_class, # e.g. QoILookAhead + search_space_digest=..., + torch_opt_config=..., + options=acq_options, +) +``` + +#### Step 5: `Acquisition.__init__()` instantiates the BoTorch acquisition function + +Three key sub-steps: + +**5a. Look up the input constructor from BoTorch's registry:** +```python +input_constructor = get_acqf_input_constructor(botorch_acqf_class) +``` +This finds the function registered with `@acqf_input_constructor(MyAcqf)` in `ACQF_INPUT_CONSTRUCTOR_REGISTRY`. + +**5b. Call the input constructor with combined kwargs:** +```python +input_constructor_kwargs = { + "X_baseline": unique_Xs_observed, + "X_pending": unique_Xs_pending, + "objective_thresholds": objective_thresholds, + "constraints": ..., + "target_fidelities": ..., + "bounds": ..., + **acqf_model_kwarg, # {"model": model} + **model_deps, + **self.options, # ← acq_options passed through here +} + +acqf_inputs = input_constructor( + training_data=training_data, + objective=objective, + posterior_transform=posterior_transform, + **input_constructor_kwargs, +) +``` + +**5c. Instantiate the BoTorch acquisition function:** +```python +self.acqf = botorch_acqf_class(**acqf_inputs) +``` + +**Example — QoILookAhead:** + +The registered input constructor is `construct_inputs_qoi_look_ahead` in `axtreme/acquisition/qoi_look_ahead.py`: +```python +@acqf_input_constructor(QoILookAhead) +def construct_inputs_qoi_look_ahead(model, qoi_estimator, sampler, **_): + return {"model": model, "qoi_estimator": qoi_estimator, "sampler": sampler} +``` +The `qoi_estimator` and `sampler` arrive via `self.options` → `acq_options` → `model_gen_options["acquisition_function_kwargs"]`. + +#### Step 6: `Acquisition.optimize()` resolves optimizer defaults and calls `optimize_acqf` + +```python +optimizer_options_with_defaults = optimizer_argparse( + self.acqf, # dispatches based on acqf type + bounds=bounds, + q=n, + optimizer_options=optimizer_options, # ← opt_options from step 3 +) +``` + +**`optimizer_argparse`** is a `Dispatcher`. It dispatches based on the acquisition function class: + +**Default (`_argparse_base`, registered for `AcquisitionFunction`):** +```python +@optimizer_argparse.register(AcquisitionFunction) +def _argparse_base(acqf, sequential=True, num_restarts=20, raw_samples=1024, + init_batch_limit=32, batch_limit=5, optimizer_options=None, ...): + optimizer_options = optimizer_options or {} + return { + "sequential": sequential, + "num_restarts": num_restarts, + "raw_samples": raw_samples, + "options": { + "init_batch_limit": init_batch_limit, + "batch_limit": batch_limit, + **optimizer_options.get("options", {}), + }, + **{k: v for k, v in optimizer_options.items() if k != "options"}, + } +``` + +**Custom (`_argparse_qoi_look_ahead` in axtreme):** +```python +@optimizer_argparse.register(QoILookAhead) +def _argparse_qoi_look_ahead(acqf, **kwargs): + args = _argparse_base(acqf, **kwargs) + # Override defaults: raw_samples=100, with_grad=False, method="Nelder-Mead" + ... + return args +``` + +Then calls: +```python +optimize_acqf( + acq_function=self.acqf, + bounds=bounds, + q=n, + inequality_constraints=..., + fixed_features=..., + post_processing_func=..., + **optimizer_options_with_defaults, +) +``` + +#### Step 7: `optimize_acqf()` sets up multi-start optimization + +- Sets `gen_candidates = gen_candidates_scipy` (default) +- Wraps all inputs into an `OptimizeAcqfInputs` dataclass +- Calls `_optimize_acqf()` → `_optimize_acqf_batch()` + +#### Step 8: `_optimize_acqf_batch()` runs batched multi-start optimization + +- Generates initial conditions via `gen_batch_initial_conditions()` (uses `raw_samples` and `num_restarts`) +- Splits initial conditions into batches of size `batch_limit` +- For each batch, calls: + ```python + gen_candidates(batched_ics_, acq_function, + lower_bounds=..., upper_bounds=..., + options={k: v for k, v in options.items() if k not in INIT_OPTION_KEYS}, + fixed_features=..., timeout_sec=...) + ``` + +`INIT_OPTION_KEYS` are filtered out before passing to scipy: +```python +INIT_OPTION_KEYS = { + "alpha", "batch_limit", "eta", "init_batch_limit", "nonnegative", + "n_burnin", "sample_around_best", "sample_around_best_sigma", + "sample_around_best_prob_perturb", "seed", +} +``` + +#### Step 9: `gen_candidates_scipy()` interfaces with scipy + +- Reads from `options`: + - `method`: default `"L-BFGS-B"` (no constraints) or `"SLSQP"` (with constraints) + - `with_grad`: default `True` + - `maxiter`: default `2000` + - `callback`: optional +- If `with_grad=True`: wraps acqf in a numpy function that computes value + gradient via `torch.autograd.grad` +- If `with_grad=False`: wraps acqf computing value only (scipy uses finite differences) +- Calls: +```python +minimize_with_timeout( + fun=f_np_wrapper, + args=(f,), # f = lambda x: -acquisition_function(x) + x0=x0, + method=options.get("method", "SLSQP" if constraints else "L-BFGS-B"), + jac=with_grad, + bounds=bounds, + constraints=constraints, + callback=options.get("callback", None), + options={k: v for k, v in options.items() + if k not in ["method", "callback", "with_grad"]}, # e.g. maxiter, maxfev + timeout_sec=timeout_sec, +) +``` + +#### Step 10: `minimize_with_timeout()` calls scipy + +```python +scipy.optimize.minimize(fun, x0, args, method, jac, bounds, constraints, callback, options) +``` +with an injected timeout callback. + +--- + +### Code Examples + +#### Example 1: Basic Candidate Generation + +```python +from ax.modelbridge.registry import Models + +# Create model (see gp_model_creation_flow.md) +model_bridge = Models.BOTORCH_MODULAR( + experiment=experiment, + data=experiment.fetch_data(), +) + +# Generate a candidate with default settings +generator_run = model_bridge.gen(n=1) +``` + +#### Example 2: Custom Acquisition Function with QoILookAhead + +```python +from ax.modelbridge.registry import Models +from axtreme.acquisition.qoi_look_ahead import QoILookAhead +from axtreme.sampling import MeanSampler + +model_bridge = Models.BOTORCH_MODULAR( + experiment=experiment, + data=experiment.fetch_data(), + botorch_acqf_class=QoILookAhead, +) + +# Generate with custom acquisition and optimizer options +generator_run = model_bridge.gen( + n=1, + model_gen_options={ + "acquisition_function_kwargs": { + "qoi_estimator": my_qoi_estimator, + "sampler": MeanSampler(), + }, + "optimizer_kwargs": { + "num_restarts": 10, + "raw_samples": 100, + "options": { + "with_grad": False, + "method": "Nelder-Mead", + "maxfev": 50, + }, + }, + }, +) +``` + +#### Example 3: Registering a Custom Input Constructor + +```python +from botorch.acquisition.input_constructors import acqf_input_constructor + +@acqf_input_constructor(MyCustomAcqf) +def construct_inputs_my_acqf(model, my_param, **_): + """Registered input constructor for MyCustomAcqf. + + Args are received from Acquisition.__init__ kwargs: + - model: always provided by Ax + - my_param: provided via model_gen_options["acquisition_function_kwargs"]["my_param"] + """ + return {"model": model, "my_param": my_param} +``` + +#### Example 4: Registering Custom Optimizer Defaults + +```python +from ax.models.torch.botorch_modular.optimizer_argparse import ( + optimizer_argparse, + _argparse_base, +) + +@optimizer_argparse.register(MyCustomAcqf) +def _argparse_my_acqf(acqf, **kwargs): + """Custom optimizer defaults for MyCustomAcqf.""" + args = _argparse_base(acqf, **kwargs) + + optimizer_options = kwargs.get("optimizer_options", {}) + options = optimizer_options.get("options", {}) + + # Set defaults (only if user hasn't provided them) + if "raw_samples" not in optimizer_options: + args["raw_samples"] = 50 + if "with_grad" not in options: + args["options"]["with_grad"] = False + if "method" not in options: + args["options"]["method"] = "Nelder-Mead" + + return args +``` + +#### Example 5: Accessing the Acquisition Function Directly + +```python +# After model creation +model_bridge = Models.BOTORCH_MODULAR(experiment=experiment, data=data) + +# Access the underlying BoTorch model +botorch_model = model_bridge.model + +# Manually instantiate acquisition for inspection +from ax.models.torch.botorch_modular.acquisition import Acquisition +acqf_wrapper = Acquisition( + surrogates={"": botorch_model.surrogate}, + botorch_acqf_class=QoILookAhead, + search_space_digest=search_space_digest, + torch_opt_config=torch_opt_config, + options={"qoi_estimator": my_qoi, "sampler": MeanSampler()}, +) + +# The actual BoTorch acquisition function +print(type(acqf_wrapper.acqf)) # → QoILookAhead +``` + +--- + +## References + +- Ax Documentation: https://ax.dev/ +- BoTorch Documentation: https://botorch.org/ +- Code locations: + - `ax.modelbridge.base.ModelBridge.gen()`: Entry point + - `ax.modelbridge.torch.TorchModelBridge._gen()`: Bridge-level generation + - `ax.models.torch.botorch_modular.model.BoTorchModel.gen()`: Model-level orchestration + - `ax.models.torch.botorch_modular.utils.construct_acquisition_and_optimizer_options()`: Option splitting + - `ax.models.torch.botorch_modular.acquisition.Acquisition`: Instantiation and optimization wrapper + - `ax.models.torch.botorch_modular.optimizer_argparse`: Default optimizer arguments + - `botorch.optim.optimize.optimize_acqf()`: Multi-start optimization + - `botorch.generation.gen.gen_candidates_scipy()`: Scipy interface + - `botorch.optim.utils.timeout.minimize_with_timeout()`: Scipy wrapper + - `axtreme.acquisition.qoi_look_ahead`: Custom acquisition function example diff --git a/docs/source/technical_details/ax_botorch/options_routing_guide.md b/docs/source/technical_details/ax_botorch/options_routing_guide.md new file mode 100644 index 00000000..9348cf15 --- /dev/null +++ b/docs/source/technical_details/ax_botorch/options_routing_guide.md @@ -0,0 +1,397 @@ +# Options Routing Guide: `ModelBridge.gen()` → `scipy.optimize.minimize` + +This document explains how to get your options to the right place when calling `ModelBridge.gen()`. The options dict is split and transformed multiple times between the Ax entry point and the underlying scipy optimizer. + +Related resources: +- `model_bridge_gen_guide.md`: Overview of `ModelBridge.gen()`. +- `tutorials\ax_botorch\botorch_minimal_example_custom_acq.ipynb`: Creating a custom acquisition function in Botorch, optimising it, and intergrating it with Ax.Breakpoints can be set here to easily trace/play with the options flow. +- `tutorials\ax_botorch\optimisation.ipynb`: Deepdive on `optimize_acqf` settings. + +NOTE: largely generate with AI, with mid-level human review. + +## Table of Contents + +1. [TL;DR — Where to put your options](#tldr--where-to-put-your-options) +2. [Detailed Routing](#detailed-routing) + - [Level 1: ModelBridge.gen()](#level-1-modelbridgegenmodel_gen_options) + - [Level 2a: Acquisition Function Construction](#level-2a-acquisition-function-construction) + - [Level 2b: Optimization — optimizer_argparse](#level-2b-optimization--optimizer_argparse) + - [Level 3: optimize_acqf → _optimize_acqf_batch](#level-3-optimize_acqf--_optimize_acqf_batch) + - [Level 4: gen_candidates_scipy](#level-4-gen_candidates_scipyoptions) + - [Level 5: scipy.optimize.minimize](#level-5-scipyoptimizeminimizeoptions) +3. [Complete Routing Diagram](#complete-routing-diagram) +4. [Practical Examples](#practical-examples) +5. [Key Gotchas](#key-gotchas) + +## TL;DR — Where to put your options + +```python +model_bridge.gen( + n=1, + model_gen_options={ + # ─── Goes to AcquisitionFunction.__init__() ─── + "acquisition_function_kwargs": { + # Any kwarg your input_constructor expects + "my_param": value, + }, + # ─── Goes to optimize_acqf() (via optimizer_argparse) ─── + "optimizer_kwargs": { + # Top-level kwargs of optimize_acqf: + "num_restarts": 10, + "raw_samples": 100, + "sequential": True, + "timeout_sec": 60.0, + "retry_on_optimization_warning": False, + + # ─── Goes to gen_candidates_scipy() ─── + "options": { + # Init-phase options (consumed by gen_batch_initial_conditions): + "init_batch_limit": 32, + "batch_limit": 5, + "seed": 42, + "sample_around_best": True, + + # gen_candidates_scipy options (consumed before scipy): + "with_grad": False, + "method": "Nelder-Mead", + "callback": my_callback_fn, + + # ─── Goes to scipy.optimize.minimize(options={...}) ─── + "maxiter": 500, + "maxfev": 1000, + "xatol": 1e-8, + "fatol": 1e-8, + # ... any scipy method-specific option + }, + }, + }, +) +``` + +--- + +## Detailed Routing + +### Level 1: `ModelBridge.gen(model_gen_options={})` + +Code objects: `ax.modelbridge.base.ModelBridge` → `ax.modelbridge.torch.TorchModelBridge._gen()` → `ax.models.torch.botorch_modular.model.BoTorchModel.gen()` + +The `model_gen_options` dict is passed unchanged through `TorchModelBridge._gen()` into `BoTorchModel.gen()`, where it is split by `construct_acquisition_and_optimizer_options()`: + +```python +# ax.models.torch.botorch_modular.utils.construct_acquisition_and_optimizer_options +def construct_acquisition_and_optimizer_options(acqf_options, model_gen_options): + acq_options = acqf_options.copy() # from BoTorchModel.acquisition_options + acq_options.update(model_gen_options["acquisition_function_kwargs"]) # merged in + opt_options = model_gen_options["optimizer_kwargs"].copy() + return acq_options, opt_options +``` + +| Key in `model_gen_options` | Destination | +|----------------------------------|--------------------------------------| +| `"acquisition_function_kwargs"` | → `Acquisition.__init__()` (acqf construction) | +| `"optimizer_kwargs"` | → `Acquisition.optimize()` (optimization) | + +--- + +### Level 2a: Acquisition Function Construction + +code object: `ax.models.torch.botorch_modular.acquisition.Acquisition.__init__()` + +`acq_options` flows into `Acquisition.__init__()` where it is passed as `**self.options` to the registered **input constructor**: + +```python +input_constructor_kwargs = { + "model": model, + "X_baseline": ..., + "X_pending": ..., + **self.options, # ← your "acquisition_function_kwargs" end up here +} +acqf_inputs = input_constructor(**input_constructor_kwargs) +self.acqf = botorch_acqf_class(**acqf_inputs) +``` + +**Guidance**: Put anything your `@acqf_input_constructor` needs in `"acquisition_function_kwargs"`. + +--- + +### Level 2b: Optimization — `optimizer_argparse` + +Code object: `ax.models.torch.botorch_modular.acquisition.Acquisition.optimize()` → `ax.models.torch.botorch_modular.optimizer_argparse.optimizer_argparse` + +`opt_options` is passed as `optimizer_options` to `optimizer_argparse()`, which produces the final kwargs for `optimize_acqf`: + +```python +# ax.models.torch.botorch_modular.acquisition.Acquisition.optimize() +optimizer_options_with_defaults = optimizer_argparse( + self.acqf, + bounds=bounds, + q=n, + optimizer_options=opt_options, # ← your "optimizer_kwargs" +) +optimize_acqf(acq_function=self.acqf, bounds=bounds, q=n, **optimizer_options_with_defaults) +``` + +The default `_argparse_base` merges your options like this: + +```python +# ax.models.torch.botorch_modular.optimizer_argparse._argparse_base +def _argparse_base(acqf, sequential=True, num_restarts=20, raw_samples=1024, + init_batch_limit=32, batch_limit=5, optimizer_options=None, **ignore): + optimizer_options = optimizer_options or {} + return { + "sequential": sequential, + "num_restarts": num_restarts, + "raw_samples": raw_samples, + "options": { + "init_batch_limit": init_batch_limit, + "batch_limit": batch_limit, + **optimizer_options.get("options", {}), # ← your "optimizer_kwargs"]["options"] + }, + **{k: v for k, v in optimizer_options.items() if k != "options"}, # ← top-level overrides + } +``` + +**Result**: Anything you put at the top level of `"optimizer_kwargs"` (except `"options"`) overrides top-level `optimize_acqf` kwargs. Anything inside `"optimizer_kwargs"["options"]` goes into the `options` dict passed down the stack. + +--- + +### Level 3: `optimize_acqf()` → `_optimize_acqf_batch()` + +Code object:`botorch.optim.optimize.optimize_acqf()` → `botorch.optim.optimize._optimize_acqf_batch()` + +`optimize_acqf` accepts these relevant parameters (which come from `optimizer_options_with_defaults`). +#### Parameters +See docs [here](https://botorch.readthedocs.io/en/latest/optim.html#botorch.optim.optimize.optimize_acqf). Refer to related resource for a deepdive on `optimize_acqf` settings.: + +| Parameter | Source | Purpose | +|-----------|--------|---------| +| `num_restarts` | top-level `"optimizer_kwargs"` | Number of multi-start restarts | +| `raw_samples` | top-level `"optimizer_kwargs"` | Quasi-random samples for initial conditions | +| `sequential` | top-level `"optimizer_kwargs"` | Sequential vs joint q-batch optimization | +| `timeout_sec` | top-level `"optimizer_kwargs"` | Total optimization timeout | +| `retry_on_optimization_warning` | top-level `"optimizer_kwargs"` | Retry on failure | +| `options` | `"optimizer_kwargs"["options"]` | Passed to init + gen_candidates | + +#### Internal Functionality +Inside `_optimize_acqf_batch`, the `options` dict is split: + +```python +# Some keys are used for gen_batch_initial_conditions, then FILTERED OUT: +INIT_OPTION_KEYS = { + "alpha", + "batch_limit", + "eta", + "init_batch_limit", + "nonnegative", + "n_burnin", + "sample_around_best", + "sample_around_best_sigma", + "sample_around_best_prob_perturb", + "seed", + "thinning", +} + +# What gets passed to gen_candidates_scipy: +gen_kwargs = { + "options": {k: v for k, v in options.items() if k not in INIT_OPTION_KEYS}, + ... +} +``` + +--- + +### Level 4: `gen_candidates_scipy(options={})` + +Code object: `botorch.generation.gen.gen_candidates_scipy()` + +This function consumes three keys from its `options` dict and passes the rest to scipy: +#### Parameters consumed from 'options' argument: + +| Key | Consumed by | Purpose | +|-----|-------------|---------| +| `"with_grad"` | `gen_candidates_scipy` | If `True`: computes gradients, sets `jac=True`. If `False`: no gradients, scipy uses finite differences | +| `"method"` | `gen_candidates_scipy` | Passed as `method` arg to `scipy.optimize.minimize`. Default: `"L-BFGS-B"` (no constraints) or `"SLSQP"` (with constraints) | +| `"callback"` | `gen_candidates_scipy` | Passed as `callback` arg to `scipy.optimize.minimize` | + +Everything else becomes scipy's `options` dict: + +#### Internal functionality + +```python +# botorch.optim.utils.timeout.minimize_with_timeout → scipy.optimize.minimize +res = minimize_with_timeout( + fun=f_np_wrapper, + x0=x0, + method=options.get("method", "SLSQP" if constraints else "L-BFGS-B"), + jac=with_grad, + bounds=bounds, + constraints=constraints, + callback=options.get("callback", None), + options={k: v for k, v in options.items() if k not in ["method", "callback", "with_grad"]}, +) +``` + +--- + +### Level 5: `scipy.optimize.minimize(options={})` + +Code object: `scipy.optimize.minimize()` + +What arrives here depends on the method. Common options per method: + +| Method | Useful `options` keys | +|--------|----------------------| +| `L-BFGS-B` | `maxiter`, `maxfun`, `ftol`, `gtol`, `maxcor`, `maxls` | +| `Nelder-Mead` | `maxiter`, `maxfev`, `xatol`, `fatol`, `adaptive` | +| `SLSQP` | `maxiter`, `ftol`, `eps` | + +See [scipy.optimize.minimize docs](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html) for method-specific options. + +--- + +## Complete Routing Diagram + +``` +model_gen_options +├── "acquisition_function_kwargs" +│ └── → Acquisition.__init__() → input_constructor(**kwargs) → AcqFunction(**inputs) +│ +└── "optimizer_kwargs" + ├── "num_restarts" → optimize_acqf(num_restarts=...) + ├── "raw_samples" → optimize_acqf(raw_samples=...) + ├── "sequential" → optimize_acqf(sequential=...) + ├── "timeout_sec" → optimize_acqf(timeout_sec=...) + ├── "retry_on_..." → optimize_acqf(retry_on_optimization_warning=...) + │ + └── "options" + ├── "init_batch_limit" → gen_batch_initial_conditions (then filtered out) + ├── "batch_limit" → _optimize_acqf_batch (then filtered out) + ├── "seed" → gen_batch_initial_conditions (then filtered out) + ├── "sample_around_best" → gen_batch_initial_conditions (then filtered out) + │ ... (all INIT_OPTION_KEYS filtered before gen_candidates_scipy) + │ + ├── "with_grad" → gen_candidates_scipy (consumed, not passed to scipy) + ├── "method" → scipy.optimize.minimize(method=...) + ├── "callback" → scipy.optimize.minimize(callback=...) + │ + └── → scipy.optimize.minimize(options={...}) + ├── "maxiter" + ├── "maxfev" + ├── "ftol" + ├── "xatol" + └── ... +``` + +--- + +## Practical Examples + +### Example 1: Gradient-free optimization with Nelder-Mead + +Use this when your acquisition function doesn't support gradients (e.g. involves non-differentiable operations): + +```python +model_gen_options={ + "optimizer_kwargs": { + "num_restarts": 10, + "raw_samples": 100, + "options": { + "with_grad": False, + "method": "Nelder-Mead", + "maxfev": 200, # scipy option: max function evaluations + "xatol": 1e-6, # scipy option: absolute x tolerance + "fatol": 1e-6, # scipy option: absolute f tolerance + }, + }, +} +``` + +### Example 2: Faster optimization with fewer restarts + +```python +model_gen_options={ + "optimizer_kwargs": { + "num_restarts": 5, # fewer multi-start points + "raw_samples": 50, # fewer initial samples + "options": { + "batch_limit": 5, # how many restarts run in parallel + "maxiter": 100, # fewer scipy iterations per restart + }, + }, +} +``` + +### Example 3: L-BFGS-B with custom tolerances + +```python +model_gen_options={ + "optimizer_kwargs": { + "options": { + "with_grad": True, # default, uses autograd + "method": "L-BFGS-B", # default when no constraints + "maxiter": 500, + "ftol": 1e-9, # scipy L-BFGS-B: function tolerance + "gtol": 1e-6, # scipy L-BFGS-B: gradient tolerance + }, + }, +} +``` + +### Example 4: Using `acquisition_options` on BoTorchModel (static options) + +Options that don't change between `.gen()` calls can be set at model creation: + +```python +model_bridge = Models.BOTORCH_MODULAR( + experiment=exp, + data=data, + botorch_acqf_class=MyAcqf, + acquisition_options={"my_static_param": value}, # merged into acq_options +) +# At gen time, "acquisition_function_kwargs" is merged ON TOP of acquisition_options +model_bridge.gen(n=1, model_gen_options={ + "acquisition_function_kwargs": {"my_dynamic_param": other_value}, +}) +``` + +### Example 5: Custom optimizer defaults via `optimizer_argparse` + +Register defaults so users don't need to specify them every `.gen()` call: + +```python +from ax.models.torch.botorch_modular.optimizer_argparse import optimizer_argparse, _argparse_base + +@optimizer_argparse.register(MyCustomAcqf) +def _argparse_my_acqf(acqf, **kwargs): + args = _argparse_base(acqf, **kwargs) + + # Override defaults (respect user overrides via optimizer_options) + user_options = kwargs.get("optimizer_options", {}) + user_inner_options = user_options.get("options", {}) + + if "raw_samples" not in user_options: + args["raw_samples"] = 50 + if "with_grad" not in user_inner_options: + args["options"]["with_grad"] = False + if "method" not in user_inner_options: + args["options"]["method"] = "Nelder-Mead" + + return args +``` + +--- + +## Key Gotchas + +1. **`"options"` nesting**: Options inside `"optimizer_kwargs"["options"]` serve *three different consumers* (init, gen_candidates_scipy, scipy). The routing is determined by key name, not explicit targeting. + +2. **`optimizer_argparse` sets defaults**: If you don't provide `num_restarts` etc., they come from `_argparse_base` (or your registered override), not from `optimize_acqf` defaults. The argparse output *replaces* `optimize_acqf`'s defaults because it's splatted as `**kwargs`. + +3. **`acquisition_options` vs `"acquisition_function_kwargs"`**: Both end up in the same place. `acquisition_options` is set at model construction time; `"acquisition_function_kwargs"` is per-`.gen()` call and takes precedence (dict `.update()`). + +4. **INIT_OPTION_KEYS are silently consumed**: If you put `"batch_limit"` in options, it controls batch size during optimization but is NOT passed to scipy. This is by design but can be confusing. + +5. **Float64 matters**: When using gradient-based optimization with scipy, use `torch.float64`. Float32 causes scipy to recommend tiny steps that get truncated, leading to no progress. + +6. **`"method"` determines valid scipy options**: Each scipy method accepts different `options` keys. Passing an unsupported key is silently ignored by some methods and raises errors in others. Check [scipy docs](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html) for your chosen method. diff --git a/src/axtreme/acquisition/qoi_look_ahead.py b/src/axtreme/acquisition/qoi_look_ahead.py index 946ac2c2..88e9e7ae 100644 --- a/src/axtreme/acquisition/qoi_look_ahead.py +++ b/src/axtreme/acquisition/qoi_look_ahead.py @@ -553,62 +553,44 @@ def construct_inputs_qoi_look_ahead( # noqa: D417 @optimizer_argparse.register(QoILookAhead) def _argparse_qoi_look_ahead( - # NOTE: this is a bit of a non-standard implementation because we need to update params in a nested dict. Would - # prefer to set the key values directly here acqf: QoILookAhead, # needs to accept the variety of args it is handed, and then pick the relevant ones **kwargs: Any, # noqa: ANN401 ) -> dict[str, Any]: - """Controls the default optimization parameters used. - - The following provides an overview of how passing optimization argument to `ax.TorchModelBridge.gen()`. - Anything that is not passed here will used the default value defined by this function. - - ```python - TorchModelBridge.gen( - ... # Other parameters there that are not relevant - model_gen_options: { - optimise_kwargs: { # content of this key later used like `botorch.optim.optimize_acqf(**optimise_kwargs)` # noqa: E501 - options: { # This is a parameter of `botorch.optim.optimize_acqf` - with_grad: False # Example of some optimization params that can be passed - ... - method: "L-BFSG" - } - } - } - ``` - - Rough flow of this object through the stack: - - `ax.TorchModelBridge.gen(..., model_gen_options: dict)` - [internally end up calling `TorchModelBridge.model` giving the below object] - - `ax.BotorchModel.gen(..., torch_opt_config: TorchOptimConfig)` - - Same way TorchModelBridge convert x data from ax type to tensors, the config type is converted. - [Internally that leads to the following being called] - - `ax.Acquisition.optimise(..., opt_options)` - - where `opt_options = torch_opt_config.model_gen_options.optimize_kwargs` - [Internally this leads to the following being called] - - `botorch.optim.optimize_acqf(..., opt_options_with_defaults)` - - `opt_options_with_defaults` is `opt_options` with defaults added. - - This function helps add the defaults in the final step + """Contruct the default arguements to `optimize_acqf` when ModelBridge.gen(...) is called. - Note: - - This function is stored in a registry in Ax. This registery is searched (by acquisition class name) - when the acqf func is being optimized. - - Any variable passed from `.gen` must override the defaults specified here - - Existing default implementations can be found here: ax.models.torch.botorch_modular.optimizer_argparse + Create the default arguments, respecting relevant overrides from `kwargs`. + + Details: + - For details on expected inputs and outputs, and where this function is used, see: + `tutorials/ax_botorch/botorch_minimal_example_custom_acq.ipynb`: See "_argparse_custom_acquisition" + - For details on the flow of arguments for optimisation, see + `docs/source/technical_details/ax_botorch/options_routing_guide.md` Args: - acqf: Acqusiton that will be passed. - kwargs: - - everything passed in value of `optimizer_kwargs` in `model.gen(model_gen_options = {optimizer_kwargs ={}})` can be found with - `kwargs[optimizer_options]` + acqf: Acqusiton that will be passed. This is ignored. + kwargs: The important key is "optimizer_kwargs". The content corresponds with overrides the user provided in + `ModelBridge.gen(...)`. e.g. Connect corresponds to "" in + `ModelBridge.gen(model_gen_options = {optimizer_kwargs ={}})`. See Details for additional informations. Returns: - dict of args unpacked to `botorch.optim.optimize_acqf`. - - All args are set with this, excluding the following: - - `acq_function`,`bounds`,`q`,`inequality_constraints`,`fixed_features`,`post_processing_func` - """ # noqa: E501 + dict of args unpacked to create `botorch.optim.optimize_acqf`. See "Details" for additional infromation. + + Example output (defaults): + { + 'sequential': True, + 'num_restarts': 20, + 'raw_samples': 100, + 'options': { + 'init_batch_limit': 32, + 'batch_limit': 5, + 'with_grad': False, + 'method': 'Nelder-Mead', + 'maxfev': 5, + }, + 'retry_on_optimization_warning': False, + } + """ # Start by using the default arg constructure, then adding in any kwargs that were passed in. # NOTE: this is an internal method, using it is an anti pattern. @@ -630,7 +612,7 @@ def _argparse_qoi_look_ahead( args["options"]["method"] = "Nelder-Mead" # These options are specific to using Nelder-Mead if "maxfev" not in options: - args["options"]["maxfev"] = "5" + args["options"]["maxfev"] = 5 if "retry_on_optimization_warning" not in optimizer_options: args["retry_on_optimization_warning"] = False diff --git a/tests/acquisition/test_qoi_look_ahead.py b/tests/acquisition/test_qoi_look_ahead.py index 4ef1f08b..a348d6c3 100644 --- a/tests/acquisition/test_qoi_look_ahead.py +++ b/tests/acquisition/test_qoi_look_ahead.py @@ -3,17 +3,27 @@ # sourcery skip: no-conditionals-in-tests from collections.abc import Callable -from unittest.mock import patch +from unittest.mock import MagicMock, patch import matplotlib.pyplot as plt import pytest import torch +from ax.core.arm import Arm +from ax.core.experiment import Experiment +from ax.core.objective import Objective +from ax.core.optimization_config import OptimizationConfig +from ax.core.parameter import ParameterType, RangeParameter +from ax.core.search_space import SearchSpace +from ax.metrics.branin import BraninMetric +from ax.modelbridge.registry import Models +from ax.runners.synthetic import SyntheticRunner from botorch.models import SingleTaskGP from botorch.models.model import Model from botorch.optim import optimize_acqf from axtreme.acquisition.qoi_look_ahead import ( QoILookAhead, + _argparse_qoi_look_ahead, average_observational_noise, closest_observational_noise, conditional_update, @@ -430,7 +440,7 @@ def var(self, x: torch.Tensor) -> torch.Tensor: dummy_qoi = DummyQoI() acqf = QoILookAhead(model, qoi_estimator=dummy_qoi) - candidate, result = optimize_acqf( + candidate, _ = optimize_acqf( acqf, bounds=torch.tensor([[0.0], [1.0]]), q=1, @@ -443,3 +453,74 @@ def var(self, x: torch.Tensor) -> torch.Tensor: # Could run the optimisation longer if we require it to be more precise. This is considered approapriate for a test. torch.testing.assert_close(candidate, torch.tensor([[0.5]]), rtol=0, atol=1e-3) + + +class TestArgparseQoiLookAhead: + """Test that _argparse_qoi_look_ahead provides correct defaults and respects user overrides.""" + + def test_user_overrides_respected(self): + """Check that user-provided optimizer_options take precedence over defaults.""" + acqf = QoILookAhead(model=None, qoi_estimator=None) # type: ignore[arg-type] + + result = _argparse_qoi_look_ahead( + acqf, + optimizer_options={ + "raw_samples": 512, + "options": {"method": "L-BFGS-B"}, + }, + ) + + # User overrides should take effect + assert result["raw_samples"] == 512 + assert result["options"]["method"] == "L-BFGS-B" + # maxfev and retry_on_optimization_warning should NOT be set because they are + # only added when method defaults to Nelder-Mead + assert "maxfev" not in result["options"] + assert "retry_on_optimization_warning" not in result + # Value that were not overridden should still have default value + assert result["options"]["with_grad"] is False + + @pytest.mark.integration + @pytest.mark.filterwarnings( + "ignore : Input data is not standardized : botorch.exceptions.InputDataWarning : botorch.models" + ) + @patch("ax.models.torch.botorch_modular.acquisition.optimize_acqf") + def test_model_bridge_gen_passes_defaults_to_optimize_acqf(self, mock_optimize_acqf: MagicMock): + """Verify defaults from _argparse_qoi_look_ahead reach optimize_acqf via ModelBridge.gen().""" + + experiment = Experiment( + name="test_argparse", + search_space=SearchSpace( + parameters=[RangeParameter(name="x1", parameter_type=ParameterType.FLOAT, lower=0.0, upper=1.0)] + ), + optimization_config=OptimizationConfig( + objective=Objective(metric=BraninMetric(name="branin", param_names=["x1", "x1"]), minimize=True) + ), + runner=SyntheticRunner(), + ) + for val in [0.2, 0.5, 0.8]: + trial = experiment.new_trial() + trial.add_arm(Arm(parameters={"x1": val})) + _ = trial.run() + _ = trial.mark_completed() + + mock_optimize_acqf.return_value = (torch.tensor([[0.5]]), torch.tensor([1.0])) + + model_bridge = Models.BOTORCH_MODULAR( + experiment=experiment, + data=experiment.fetch_data(), + botorch_acqf_class=QoILookAhead, + fit_tracking_metrics=False, + acquisition_options={"qoi_estimator": MagicMock(), "sampler": None}, + ) + _ = model_bridge.gen(1, model_gen_options={"optimizer_kwargs": {"options": {"maxfev": 20}}}) + + # Extract kwargs passed to optimize_acqf + call_kwargs = mock_optimize_acqf.call_args.kwargs + + # Our defaults should be present + assert call_kwargs["raw_samples"] == 100 + assert call_kwargs["options"]["with_grad"] is False + assert call_kwargs["options"]["method"] == "Nelder-Mead" + # User override should take precedence + assert call_kwargs["options"]["maxfev"] == 20 diff --git a/tutorials/ax_botorch/botorch_minimal_example_custom_acq.ipynb b/tutorials/ax_botorch/botorch_minimal_example_custom_acq.ipynb new file mode 100644 index 00000000..b1862f85 --- /dev/null +++ b/tutorials/ax_botorch/botorch_minimal_example_custom_acq.ipynb @@ -0,0 +1,4156 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# A Minimal example of custom acquisiton function\n", + "This notebooks covers the consideration for setting up a Custom Acquisitions function, and optimising it with botorch and Ax.\n", + "\n", + "Problem description:\n", + "- TODO: flesh this out: why do we not just use the gp to model objective = pdf * underling function in this example (and in general)\n", + "\n", + "This notebook covers:\n", + "- Set up (through botorch):\n", + " - problem (true underling function and datapoint)\n", + " - Setup GP\n", + "- Basic Acquisition function:\n", + " - `__init__` and `forward` inputs and outputs\n", + " - Behaviour expected by the things that then optimise this.\n", + "- Optimisation of Acqusitions function (through Botorch):\n", + " - Brute force scoring of acquisiton function over the domain\n", + " - High level botorch automatic tool `optimise_acqf` (builds on the bellow)\n", + " - lower level botorch (`gen_batch_initial_conditions`, `gen_candidates_scipy`)\n", + " - Direct `scipy` optimisation\n", + "- Multiple rounds of DOE (gp + acquisition -> pick new point and train new gp)\n", + " - TODO: what is the true optimal of the problem\n", + " - refit hyperparams every step (and condition)\n", + " - don't refit hyperparms each step (just condition)\n", + "- Put into `Ax` framework.\n", + " - Set up the `acqf_input_constructor` required\n", + " - ax.BotorchModel using custom acquisition and acquisition args (all wraped in TorchModelBridge)\n", + " - Wrapping above into a `GenerationStratergy`\n", + "- Exploration\n", + " - WIP: Supporting q = 2 optimisation, using sequential q=1. This is similar to lookahead\n", + " - Differntiation through 2 levels of fantasy GPs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Any\n", + "\n", + "import gpytorch\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import scipy\n", + "import torch\n", + "from ax.core import (\n", + " Arm,\n", + " Data,\n", + " Experiment,\n", + " Metric,\n", + " Objective,\n", + " OptimizationConfig,\n", + " ParameterType,\n", + " RangeParameter,\n", + " Runner,\n", + " SearchSpace,\n", + ")\n", + "from ax.modelbridge.generation_strategy import GenerationStep, GenerationStrategy\n", + "from ax.modelbridge.registry import Models\n", + "from ax.plot.slice import plot_slice\n", + "from ax.utils.common.result import Ok\n", + "from ax.utils.notebook.plotting import render\n", + "from botorch.acquisition import input_constructors\n", + "from botorch.acquisition.acquisition import AcquisitionFunction\n", + "from botorch.acquisition.input_constructors import acqf_input_constructor\n", + "from botorch.fit import fit_gpytorch_model\n", + "from botorch.generation.gen import gen_candidates_scipy\n", + "from botorch.models import SingleTaskGP\n", + "from botorch.models.model import Model\n", + "from botorch.optim import optimize_acqf\n", + "from botorch.optim.initializers import gen_batch_initial_conditions\n", + "from botorch.posteriors.gpytorch import GPyTorchPosterior\n", + "from botorch.utils.transforms import t_batch_mode_transform\n", + "from matplotlib.axes import Axes\n", + "from torch.distributions.distribution import Distribution\n", + "from torch.distributions.normal import Normal" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device(\"cpu\") # \"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "# As explained here there are a lot of issues that come up when using dtype = float32 (This is the default for torch\n", + "# because its faster than float64) .Specifically this will cause issues with scipy optimise, because it will recommends\n", + "# a small step (.4 ->.40000000001), but in the conversion to float34 it will be truncated back to .4, and the model will\n", + "# produce the exact same output\n", + "# https://github.com/pytorch/botorch/discussions/1444\n", + "\n", + "torch.set_default_dtype(torch.float64)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set up" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set up the true underlying function\n", + "This is the find we model with our GP (e.g the simulator)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def underling_function(x: torch.Tensor) -> torch.Tensor:\n", + " return -3 * torch.sin(3 * x) - x**2 + 0.7 * x + 3\n", + "\n", + "\n", + "x = torch.linspace(0, 1, 100)\n", + "y_true = underling_function(x)\n", + "\n", + "_ = plt.plot(x.numpy(), y_true.numpy())\n", + "_ = plt.title(\"true function\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set up the training data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bounds = torch.tensor([[0.0], [1.0]]) # 1D search space [lower_bound, upper_bound]\n", + "random_initial_points = 2\n", + "\n", + "train_x = torch.tensor([[0.1], [0.85]])\n", + "train_y = underling_function(train_x)\n", + "\n", + "\n", + "_ = plt.plot(x.numpy(), y_true.numpy())\n", + "_ = plt.scatter(train_x.numpy(), train_y.numpy(), c=\"red\")\n", + "_ = plt.title(\"true function\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create the GP" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\SEBWIN\\Documents\\technical\\code\\axtreme\\.venv\\Lib\\site-packages\\botorch\\models\\utils\\assorted.py:202: InputDataWarning: Input data is not standardized (mean = tensor([1.6864]), std = tensor([0.6887])). Please consider scaling the input to zero mean and unit variance.\n", + " warnings.warn(msg, InputDataWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SingleTaskGP(\n", + " (likelihood): GaussianLikelihood(\n", + " (noise_covar): HomoskedasticNoise(\n", + " (noise_prior): GammaPrior()\n", + " (raw_noise_constraint): GreaterThan(1.000E-04)\n", + " )\n", + " )\n", + " (mean_module): ConstantMean()\n", + " (covar_module): ScaleKernel(\n", + " (base_kernel): MaternKernel(\n", + " (lengthscale_prior): GammaPrior()\n", + " (raw_lengthscale_constraint): Positive()\n", + " )\n", + " (outputscale_prior): GammaPrior()\n", + " (raw_outputscale_constraint): Positive()\n", + " )\n", + ")\n" + ] + } + ], + "source": [ + "# Single task GP: Single independant output, with homoskedastic noise (fit from data)\n", + "# Note: this model can be used as is, but the hyperparams have not yet been fit for this specific problem\n", + "gp = SingleTaskGP(train_X=train_x, train_Y=train_y)\n", + "\n", + "print(gp)\n", + "\n", + "# mll: marginal log likelihood. This can be thought of as the \"loss\" function which is thin optimised\n", + "# with `fit_gpytorch_model(mll)` to find the hyperparameters (e.g length_scale etc).\n", + "mll = gpytorch.mlls.ExactMarginalLogLikelihood(gp.likelihood, gp)\n", + "_ = fit_gpytorch_model(mll);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Show the result of the fitted Gp" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Like gypytorch, model should be set to eval prior to making predictions\n", + "_ = gp.eval()\n", + "# The Likelihood also needs to be set to eval if its not automatically within the model likelihood.eval()\n", + "\n", + "\n", + "# Helper\n", + "def plot_gp(model: Model, X: torch.Tensor | None = None, posterior_samples: int = 10, ax: None | Axes = None) -> Axes: # noqa: N803\n", + " \"\"\"Plots each of the model targets over the domain. Also plots the training data.\n", + "\n", + " Args:\n", + " model: assumed to be relevant to this demo problem (targets, domain etc).\n", + " # TODO(sw 2024-11-8): currently only testing with SingleTaskGP\n", + " X: (n,1): Linspace of [0,1] is used by default. Only 1d is currently supported.\n", + " posterior_samples: Number of posterior samples to draw and plot\n", + " ax: will plot to this axis if provied\n", + " \"\"\"\n", + " X = X if (X is not None) else torch.linspace(0, 1, 201).reshape(-1, 1) # noqa: N806\n", + "\n", + " if ax is None:\n", + " _, ax = plt.subplots()\n", + "\n", + " # Quick and dirty way to ensure consistent colours\n", + " colours = [\"b\", \"c\", \"m\", \"y\", \"k\", \"r\"]\n", + "\n", + " train_x_all = model.train_inputs[0].detach()\n", + " train_y_all = model.train_targets.detach()\n", + " train_var_all = model.likelihood.noise.detach()\n", + "\n", + " # t = 1 then:\n", + " # shape model.train_targets: (n)\n", + " # shape model.train_inputs: ((n,d),)\n", + " if len(model.train_targets.shape) == 1:\n", + " n_targets = 1\n", + " # need to add a t dimension to all of these so they can be treated the same way as the multicase\n", + " train_x_all = train_x_all.unsqueeze(0)\n", + " train_y_all = train_y_all.unsqueeze(0)\n", + " train_var_all = train_var_all.unsqueeze(0)\n", + "\n", + " # t > 1 then:\n", + " # shape model.train_targets: (t,n)\n", + " # shape model.train_inputs: ((t,n,d),)\n", + " else:\n", + " n_targets = model.train_targets.shape[-1]\n", + "\n", + " for target_idx in range(n_targets):\n", + " c = colours[target_idx % len(colours)]\n", + "\n", + " train_x = train_x_all[target_idx]\n", + " train_y = train_y_all[target_idx]\n", + " train_var = train_var_all[target_idx]\n", + "\n", + " with torch.no_grad():\n", + " posterior: GPyTorchPosterior = model.posterior(X) # type: ignore\n", + "\n", + " mean = posterior.mean[:, target_idx]\n", + " var = posterior.variance[:, target_idx]\n", + " _ = ax.fill_between(X.flatten(), mean - 1.95 * var**0.5, mean + 1.95 * var**0.5, alpha=0.3, color=c)\n", + " _ = ax.plot(X, mean, color=c)\n", + " _ = ax.scatter(train_x.flatten(), train_y, color=c)\n", + " _ = ax.errorbar(train_x.flatten(), train_y, 1.95 * train_var**0.5, fmt=\"o\", color=c)\n", + "\n", + " if posterior_samples > 0:\n", + " samples = posterior.rsample(torch.Size([posterior_samples]))[..., target_idx]\n", + " for sample in samples:\n", + " _ = ax.plot(X.cpu().numpy(), sample.cpu().numpy(), \"grey\", alpha=0.3)\n", + "\n", + " _ = ax.set_title(\"Gp prediction\")\n", + " return ax\n", + "\n", + "\n", + "# test model on 101 regular spaced points on the interval [0, 1]\n", + "_ = plot_gp(gp)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define mock optimisation problem\n", + "Typically, bayesian optimisation is about find the max of the true underling function.\n", + "\n", + "In axtreme, we need to integrated the GP over weather conditions, and we want to find areas of the GP that could reduce uncertainty in this calculation. This is not the same as standard ofptimisation of the GP, so a different approach is needed. This is discussed further in the axtreme package.\n", + "\n", + "Here we set up a more minimal example where:\n", + "- We have a GP surrogating some underlying funtion\n", + "- The next points that we want to chose if effected by a distribution as well as the GP\n", + "\n", + "While bayesian optimisation could be performed directly on the the objective function we define, the purpose of this is to use a GP and a simple distribution as a placeholder for more complex functionality, and show how CustomAcquisiton functions are integrated." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhYAAAGzCAYAAABzfl4TAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsXQd4k9X7PWnTvQe0BcregoAiKqi4994T98CJe29xDxT3RhH1597+XQiiIjJlzwKF0lLo3k2T/3Pum5ukbdKmbdom6Xee56OhzfjyjXvPfd/zntdks9lsMGDAgAEDBgwY8AFCfPEmBgwYMGDAgAEDBrEwYMCAAQMGDPgURsTCgAEDBgwYMOAzGMTCgAEDBgwYMOAzGMTCgAEDBgwYMOAzGMTCgAEDBgwYMOAzGMTCgAEDBgwYMOAzGMTCgAEDBgwYMOAzGMTCgAEDBgwYMOAzGMTCgAEDHYaLLroIffv2rfc7k8mEBx54wGefcfDBB6vNgAEDnQODWBgw0InIysrCtddei8GDByM6Olptw4cPxzXXXIP//vvPODcesGrVKkVGNm/ebBwjAwb8DObO3gEDBroqvv32W5x11lkwm80477zzMGrUKISEhGDNmjX4/PPP8corryji0adPHwQzKisr1TFoKbF48MEHVWSiYQTkp59+8vEeGjBgoCUwiIUBA52AjRs34uyzz1ak4ddff0VGRka9vz/xxBN4+eWXFdHwB5SXlyMmJqZd3jsyMtKn7xceHu7T9zNgwEDL4B+jlgEDXQxPPvmkmqzfeeedRqSC4Ar++uuvR2ZmZj19QmxsLDZt2oSjjjpKTfQ9evTAQw89BG+aFHNlf/zxx6sV/ejRo9WEzrQLoyOuePfdd5XuYc6cObj66qvRvXt39OrVy/H3H374AQceeKD6/Li4OBx33HFYuXJlo8/78ssvMWLECPU5/PnFF1+43S93Govt27fj0ksvVd8vIiIC/fr1w+TJk1FTU6P274wzzlDPO+SQQ9Truf3+++8eNRY7d+5U75eWlqb2h9GhGTNm1HsO0yp8n6effhqvv/46BgwYoD57n332wb///tvs8TVgwIDAiFgYMNBJaZCBAwdi3333bdHr6urqcPTRR2O//fZT5OTHH3/E/fffD4vFoghGc1i/fr1Kv1x11VW48MILFbHhJM33OeKII+o9l6SiW7duuO+++xQJIt5//331OhIbRlUqKipUyuaAAw7AkiVLHGkJkpfTTjtNEZfHHnsMu3fvxsUXX1yPoHhCTk4Oxo0bh6KiIlxxxRUYOnSoIhqffvqp+ryDDjpIka4XXngBd911F4YNG6Zep3+6S7WQaGzYsEHpWUhSPvnkE0XU+Bk33HBDvefPmjULpaWluPLKKxXR4HE+9dRTFaELCwtrdv8NGOjysBkwYKBDUVxczPCC7eSTT270t8LCQlt+fr5jq6iocPztwgsvVK+77rrrHL+zWq224447zhYeHq6e3xT69OmjXv/ZZ5/V25eMjAzbmDFjHL9755131PMOOOAAm8Vicfy+tLTUlpiYaLv88svrvW9ubq4tISGh3u9Hjx6t3reoqMjxu59++km9L/fDFfzd/fff7/j/pEmTbCEhIbZ///230Xfg9yU++eQT9brZs2c3es7EiRPVpjFt2jT13JkzZzp+V1NTY9t///1tsbGxtpKSEvW7rKws9byUlBRbQUGB47lfffWV+v0333zj8dgaMGDACSMVYsBAB6OkpET9ZFqjIbiyZpRAby+99FKj53DVrcEVNf/PFMEvv/zS7GcztXDKKac4/h8fH49JkyapaENubm69515++eUIDQ11/P/nn39WK/xzzjkHu3btcmx8DiMvs2fPVs/bsWMHli5dqiIbCQkJjtczIsIIRlOwWq0qhXLCCSdg7Nixjf7O79tSfP/990hPT1f7rcHIA6MeZWVlKuXjCkZ0kpKSHP9n2odgxMKAAQPNw0iFGDDQwaAugeCk1hCvvfaaCsPn5eXh/PPPb/R3ijn79+9f73csVSW8Kb1k+qXh5Oz6ek7AGkwZNEyjEIceeqjb9yZJIbZs2aJ+Dho0qNFzhgwZgsWLF3vcv/z8fEW8qMnwFbg/3JeGQlidOtH7q9G7d+96/9cko7Cw0Gf7ZMBAMMMgFgYMdDC4iqdgc8WKFY3+pjUX/uDPEBUV1SiaoHUWrgREo6Ulo/4K1yiNK7wRyBowYMAgFgYMdApYSfHmm29iwYIFSqjoLTi5MySvowzEunXr1M+Gfg7uQAEjJ0jXqIW3r2eVBMEqkcMPP9zj87Tvho5wuGLt2rVNfgbTP4x8uCNdrU2JcH9oNsZj5xq1oF+I6/4aMGDANzA0FgYMdAJuu+025bJ5ySWXqLRHS1bHL774Yr3n8f/UDBx22GFeVVy4ln0y7fDee++p8lN3UQhXsBKEk/6jjz6K2tpat2kMgtEYvh/LOYuLi+tpNGhs1RQ48Z988sn45ptvsHDhQo/HRXtqUPPRHI499lilH/n4448dv2MVzfTp05XOZeLEic2+hwEDBrxHcMQuDRgIMDDnz7JGCgqpO9DOm5w46bbJv3GSbVieSQ8GloZSGMm0CT0lvvvuO1V2ydV+c2Ckg34O9GWgp8Pbb7+tiA3LTpsDSQVLSy+44ALstddeyuCLn7l161a1DxMmTHCQHpaYMirDMlSSp4KCAjWR77HHHm61Ja4gcWG5Kid8lptSC0FBKEtE582bh8TEREVcmLJgySvJC/0mqP1gNKUh+B7UrrC8dNGiRSoyw9LVP//8E9OmTXNoXgwYMOAjuFSIGDBgoIOxYcMG2+TJk20DBw60RUZG2qKiomxDhw61XXXVVbalS5fWey7LTWNiYmwbN260HXnkkbbo6GhbWlqaKtWsq6tr9rNY5snS1P/7v/+z7bnnnraIiAj1WSzddIUuN3VX7kmwxPOoo45SJabc5wEDBtguuugi28KFC+s9j2Wtw4YNU58zfPhw2+eff66+Q3PlpsSWLVtU2Wm3bt3U6/v372+75pprbNXV1Y7nvPHGG+r3oaGh9UpPG5abEnl5ebaLL77YlpqaqkpzR44cqb6nK3S56VNPPdXoO7vbRwMGDLiHif/4iqQYMGCg/cAVN1faza34PYErdVZb0JzLgAEDBtoLhsbCgAEDBgwYMOAzGMTCgAEDBgwYMOAzGMTCgAEDBgwYMOAzGBoLAwYMGDBgwIDPYEQsDBgwYMCAAQM+g0EsDBgwYMCAAQOBa5BFW126/9GUpjWdCg0YMGDAgAEDHQ+6U7BJIrskN2zq16nEgqQiMzOzoz/WgAEDBgwYMOADZGdnN3IF7lRioe1zuWO6zbIBAwYMGDBgwL/B3kIMDDRng9/hxEKnP0gqDGJhwIABAwYMBBaakzEY4k0DBgwYMGDAgM9gEAsDBgwYMGDAgM9gEAsDBgwYMGDAgM/Q4RoLAwYMGAi2EjyLxYK6urrO3hUDBtqE0NBQmM3mNltBGMTCgAEDBlqJmpoa7NixAxUVFcYxNBAUiI6ORkZGBsLDw1v9HgaxMGDAgIFWmv1lZWWpVR4NgzgQG6Z/BgI58kainJ+fr67rQYMGNWmC1RQMYmHAgAEDrQAHYZIL1vVzlWfAQKAjKioKYWFh2LJli7q+IyMjW/U+hnjTgAEDBtqA1q7qDBgI1uvZuCMMGDBgwIABAz6DQSwMGDBgwIABAz6DQSwMGDBgwAAOPvhgTJkyxXEk+vbti2nTpnX6kdm8ebMSxS5dutTxuz///BMjR45UeoCTTz65U/fPQGMY4k0DBgwYMNAI//77L2JiYrw6MiQhJCWuxKQ9cdNNN2H06NH44YcfEBsb2yGfacB7GBELAwYMGDDQCN26dfPbapeNGzfi0EMPVa27ExMTO3t3DDSAQSwMGOhE1NayFTGQnw9s3w5kZQFr1wIrVwLLlgGLFwMLFwILFgDz5wN//y0/+X/+fskS4L//gFWrgPXrGTYGcnKA3buBsjLAYjFOb0d7AZTXlHf4xs9tCcrLyzFp0iS12qcZ0jPPPNPoOa6pEL7/Aw88gN69eyMiIkL5dlx//fWOFArLE2+88UaVsmjKy4N/e+WVV3DMMceo0sb+/fvj008/rfecBQsWYMyYMarUcezYsVjCi7xBWmT37t245JJL1ON33323Rd/dQPvDSIUYMNDOqKkBSktlotdbQQFQVARUVcnfSTC4Wa3u36PhWK3nEf5s+LfQUCAsTDaa5zGazUUdNz5m5JhbXJw8x4DvUFFbgdjHOj40X3ZnGWLCvUtbELfeeivmzJmDr776Ct27d8ddd92FxYsXq/SCO3z22Wd47rnn8NFHH2GPPfZAbm4ulpH5Avj8888xatQoXHHFFbj88sub/ex7770Xjz/+OJ5//nm8//77OPvss7F8+XIMGzYMZWVlOP7443HEEUdg5syZyqjphhtucLyWniF0Oh0yZAgeeughnHXWWUhISPD6exvoGBjEwoABH6K6WggDN5KHvDz5WVkpf9NEgBN+RIRM7PHx8tNsFlLQVjBKwU0TFn7+jh3ymODn0/cmKgpISgLS0uSnJh+t9MQxECDg5P3WW2+pifuwww5Tv5sxY4ZKK3jC1q1bkZ6ejsMPP1wJJhm5GDdunPpbcnKych+Ni4tTz2kOZ5xxBi677DL1+OGHH8bPP/+M6dOn4+WXX8asWbOU6Rj3jxELkpht27Zh8uTJ6vn8HH4GIxUkFN58noGOh0EsDBhoA0gYdu2S1ANTGSQS5eUyqXMC5+TNLTVVJuyO8FIiQeHmiSAwKsJICfedhGPTJiE8JDeMZHBfOcckJwMpKRLZMOAdosOiVfSgMz63JfoEuiruu+++jt+RHDAK0BQZYFqEqYujjz4axx57LE444QTVsKql2H///Rv9X1d8rF69GnvuuWc9x8eGzzfg/zCIhQEDLQAbWJJI7NwJZGfLxEyNBH/PsZATc0aGRCP8FSQ31OQ11OUxokJSxO+1bp08j9+nWzegTx/5yc2IaHgGV9ItSUkECpiCWLt2LX755RcVYbj66qvx1FNPqXQKIxgGDLjCIBYGDDQDRh9yc0UUydU9Uwtc8ZM8MI3Rt69ECAId/D7cGKkgSJaoB+F35/cm0WA6OzNTNhIoI70deBgwYIAiA//8849KaRCFhYVYt24dJk6c6PF1FFsySsHtmmuuwdChQ5U2Yq+99lIN2LxtGz9//nwlHHX9P8WaBHUW1F1UVVU5ohb8u4HAQhAMhwYM+B7UIzAawdX7xo1CJqhbIJHo3l3SG8EO6j1IHDR50BUsrFhhJYqOzgwYID+p02iiIMCAn4CVIJdeeqkScKakpCjx5t13391kjwhWXpA4MH3CElTqM0g0+jCUZa8gmTt3rhJismoklfk0D/jkk09UtccBBxyADz74QFWBUFNBnHvuuWpfKAK98847VRXI008/3Q5HwUB7wiAWBgy4aA90ioMln0x5cBFGQSMXdl094svvT80FNx4rRjO2bpW0CUkGdRkkGT17CgEz4L9gGoMiTkYfKLq8+eabUVxc7PH59IpgJQeNqUgw6Hr5zTffKGJCsELjyiuvVNGQ6urqJstfH3zwQVVdwnQKS10//PBDDB8+3EF6+L5XXXWVimLw90888QROO+20djgKBtoLJltLC6DbiJKSEqXm5UUcb4w+BvwA1BVwglyzRtIdFDVylc6UAKs3DDQNjiAsp2VUhzoNHrt+/YD+/YVsBOsxZLie5ZD9+vVrdXvprqhB+eKLLwwb7gC9rr2dv42IhYEuOxmygoNpDkYnOCnyHqI40U/NBv0WTH9wjOHGSAYXvsuXy8bjOXSo6FCaiI4bMGAgiGAQCwNdCtRJMDqxerW4VDI6wWjuwIG+8ZDo6mCanloLbtRksAx39mxJlTCCMXiwCD+DQexqwIAB9zBubwNdAqziYGXDihXAtm1CIijCNPoXta8mg/5F3Cj6JJmj9Tg1GHvsIekSIzrUtdDBmXcDnQSDWBgIalRUABs2SBUDyyY5kVHIHqx5f3+FTpWwdJcC2e+/F2JHgjFokFG2asBAMMEgFgaCVpDJagUSCjb4onukke7ofJDQUdCpjcZ++w2g6eKwYaLFsBcZGDBgIIBhEAsDQQVqJkgoOFlxZcxSUYNQ+B+YimKPEkYtKJz96y9JU5FgsPLQEHoaMBC4MIiFgaAAQ+xsG84OyzS2IqFgiN0QZPp/RYn2xigslHbw1GKQYIwY4XQBNWDAQODAIBYGAhosb6Qok4RiyxYRYxqEIjChq0lIMP75R3xFRo6UCIZhHW7AQODAIBYGAhY0s1q8WMSZLF9kOWNXd8cMBugW7kyR/PGHRDBGjZIohlFFYsCA/6MDmjgbMOBb0IBpzhzgyy8l/dGjh1R6GKQi+FIkFHSyQvHXX4HPPxeSQS8SAwaaAnub0Ia8rfj999+VW2hRUZFP3zfYYRALAwEDGi7RzfGLLyQXz/JFCjO7QkOwrkwwKPCksRZtw1mm+vXXYnJmWCK09piamtweeOABH5/F4MFZZ52lusAaaBpGKsRAQICNwf79V/QUzLdzommiGaOBIANFuCxTpUiX1wJNzuiBwW7bhsCzZdhBdbMdH3/8Me677z6spa+9HWwE5mpoxaZj5i5olVrLlUwDsKMrNwNNwxiaDfg12EFz7lznKpVujXRyNEhF8MNqrYPFUoGammJUVe1CRUUeLJYdSEvLQWzsNvz7bzY++mgbfvttO7Kzc7Fr1y4Vsq6srISVqt7OAMMoNFHp6K0F4Zv09HTHxoZSjFLo/69Zs0Z1O/3hhx+w9957qxbo8+bNw0UXXdSocdiUKVNw8MEHO/7PY/7YY4+p5lWcfEeNGoVPP/20yX3hZ3/JnKYLmGpgyoFg23Q+5/PPP8chhxyiWrbzff/+++96r+Hze/furf5+yimnYDe95Bvgq6++wl577aUaa/Xv3191WbW45NX4Oa+88gpOPPFExMTEYOrUqY3eo2EqhNGd0aNH4/3331et43k8zz77bJQyvGYHH5933nnqPdnN9bnnnlPHjccvWNH1aKiBgADnBYoymfLgAisjw6gMCHbU1dXAYimHxVKJujqSA89iCuppaA1OvQ2vEVYEsRqI/hdMnxCc3DiYc6IM7yirVVq9doZPPBl4TIzP3u6OO+7A008/rSbgJKppvQBJxcyZM/Hqq69i0KBBmDt3Ls4//3x069YNEydObNP+3H333Wp/+L58fM4552DDhg0qkvLPP//g0ksvVZ9P8vPjjz/i/vvvr/f6P/74A5MmTcILL7yAAw88EBs3bsQVV1yh/ub6XBIFtoefNm2aeu9NDJE2A74XydG3336LwsJCnHnmmeo9NDFhq/k///wTX3/9NdLS0lSEaPHixYqQBCsMYmHA78ByQ6Y9Vq6UjqNG2iN4UVdXjZqaElgsZYpYNERISBhCQ8NhMoUhJMSsVpUMtMpPk6oSqa21IienDgsX1mHAgBr061eNsDCLilxwYySDJIOrSbZ6ltcaaAoPPfQQjjjiCK8PUnV1NR599FH88ssv2H///dXvSEoY7XjttdfaTCxuueUWHHfcceoxIw177LGHIhZDhw7F888/j6OPPhq33Xab+vvgwYPx119/KYKhwdeQLF144YWOfXv44YfVa1yJxbnnnouLL77Y8X9viAUjNYxkkMASF1xwAX799VdFLBitmDFjBmbNmoXDDjtM/f2dd95BDyrOgxgGsTDgN6DNM1O9XIHS7pldMI3ywuCDzWZVZKKmpkgRCw1O+KGhUTCbo9UWGhoBk6n5bC2DEYxW6EZnjGKMHWtBWlo5KirKUF5e7iAZDJEnJyc7UgA+By9YRg86Gj6+UcaOHdui53OSr6ioaERGampqMIZCmDZizz33dDxmOoHYuXOnIharV69W6Q9XkNy4Eotly5apqIFreoPakaqqKrXfTKG05nsTTIFoUqH3bydtf+3EhFqNcePGOf7Oa2/IkCEIZhjEwoBfQJsisfslI7qMUhgLy+DTTNTUFKK6ulCRC4KTu9kci7CwOISFxXhFJDyBVUK8duhv8uOPZowYkYBx4xKQlmZBSUmJClNzkM/Ly1NajO7duzsmFJ+BF60PUxKdBaaQXBESEtKoM6mruLHMTqa+++479GSOygXUaXgCz39T76sR5lJLrglhS3Q03D9GLU499dRGf6PmwtP39gau+6b3z9pZGh8/gUEsDHQqeP+xemv+fIlS9O5tlI8GG0giqqsL6hEKpjfCwxMRHs7URKhPq0cY6aKekW6s27cD++1nxqBByUorUFxcrFIjDN1nZ2er1SMJBidOA55BncQKNnNxwdKlSx2T6vDhwxWB2Lp1a4vSHnxf1yqV9evXqwhCSzBs2DCls3DFfA4oLqBok5UvA1mf3oHo37+/Okb//vuvEpcSvAZZsnrQQQchWGEQCwOdBgqnOR7Qm4ILRyNKEVzgSrS2tkRVdGghZmhoJCIjU2A2x7Sr1kFHvRi9+OEHKU8dN86kFP0MWzMlwggGB3mmSBi+dl25GqiPQw89FE899RTee+89lWagSJNEQ6c5eEypg7jxxhvVav2AAw5Qx5bpB+patLbB3fu++OKL6j2Zmrj99tsbRQCaw/XXX48JEyYocedJJ52E//u//6uXBiEomDz++OPV5H766acrIsn0CL/DI4880m6nOy4uTn33W2+9VaXgSGKp6eDnB7PWx6DpBjocjHxSE/XVV7KqpI6JWxDfZ10OrOwoK9uKiopcRSoYoYiJ6Ym4uD4IC4vtkEGVQQh6X7A8mdbvvN543YWEhKoBPjMzUyn/qQNg9MK1RNBAfRx11FG49957ldhxn332UceKVRauoBiSz2F1BqMIFFQyNcLyU0945pln1HlgpQaFkyQnLU1P7bfffnjjjTeUiJOlqD/99BPuueeeRvvPqg3+jfvP17Dssw8te9sZzz77rCJOJDaHH364IkE8PsFMZE22hgmudgZznQw/ks2SyRroWqiqAhYtkk2bHhlR6ODSUVRV5SvvCYKaCUYowsOTOnWFxpQboxYUCO+1F0V6UnHEVTJD8RR4EqmpqUihl7gXoPAvKytLTZzBPEkY8C3Ky8uVDoWkimWy/oamrmtv528jFWKgw5CbC/z1F+u+DV+KYAQrPaqqdipyQVBDQVLBMtHOBskrU9ysGKG3Ul4eMGECoxmhapDPz89XqRHqLxjKZ+7fgAFfYMmSJcp4jJUhnJBZykswbROs6Pw73kDQg6tFelJQT0Xx+IABwdMwjGF+q7UGVmutXUdgU9oC6bvAPKrZxYvBdyJFfwL9Jyor6YopojuWiUZFpcFs9j/rY9rBM9JOQy12T91vP1qDm1RqhLl9lgkWFBSoc8jfGTDgCzz99NNKPEqjNjqa0rCL0bFghUEsDLQrSCRIKP77z9k0LDjcISvs7pCyOvcGJBf0aWBZpYgXA1vixMmXXhQUZ7Lag2QqIiIFERHJfi1MI6nldcioxc8/y096OrFqhPvNclRGLyiwC+bB30DHYMyYMVjE3G8XgkEsDLQb2Cxq3jzJbTMMHYhmV9KEqRK1taWorS1XkQlXcCJiRIIboxNCFjipWtVk64xoWBQp4Ub9gfg3xCAsLL7DxIy+BI8DhZk6SkFDK0YpSJ4CBWlpVO2LsJPRiwMOoIhY+kCQXLByJDQ01GtLawMGDAgMYmHA56BAjhEKRirodUNXRAo1A9FqmuWSrj0rtDskow786a07pBCLKjURM+JBglFbW6Y2VimEhSUgIiJRERR/R3U1oxT59igFxZndEB7eTk6W7Qxd5rx5M/DNN8D48UyNJCpRJ/UWTI2wcsTVWdGAAQNNwyAWBnwKVuxRHEdvCrazZtVHoPkucOIkCdCgNoJRBW5cmbcmhUEBY0iIvIcmLoyCMHpB0kEDKbpS0oGS6QR/XPkz7VNZmavIUKBGKdyBpJe6H6ZEfvkFYGPM/fZLUeSCKZHc3FylvzAqPwwY8A4GsTDgMzDl8ccf8pPl4VH+p91rondFkXKG1NEJnaqgMyQtp329GmekgxtJBCMY/GxpEc4eGiXqcyMjU/0mgsF9q6jYoY4Pj4VEKRIDMkrRVGqExlpsgMfUyIEHdkNMTI0qD9y+fbvyPGD0woABA00jaO4SunHMnQvQi8XunGqgA6s+dOqjpiZwUh8iPixGdfVuB6FgZIGeCwztM0XR3uDErKMhFkuV2hdGBCQNU6r2hSWbnSX05DHiPlVV7Vb/Z3QiOrqHIkXBCHY8Z/QiK4vRNxMmTMhAePhWZaKVk5OjzJyCiUwZMNAeCGxZeoO8PgcD2veuWdPZe9N1QF+h2bOBX3+VLpMkdoFAKpjqKC/fqsokSSoYGYiOTkdcXH9ERiZ3CKloCLM5UrlTxsZyZRxtn9QLUFqa5Ug/dCR4XMrLtzlIBckW9y1YSYVr1QjJMSua/u//QpGf31MRO92C3YABA12EWGiwdfJPP4nSu4s3mOsQw6vvv5djTS1FIHgK2WzUCexUdtOMEHDCiIrqjri4fn4jQCTBiI3NVCSDhEcm+O0qFcH97wjw2JSVbVEpEB6j6OgMRbwCvUTWW/AyYOSTqZF588KxaVO6EiLT40K7dHYVsC34tGnT2vyctuLdd99VvV7aG19++aVqVsaKoClTpqAzcfDBB3f6PrQGQTdKcHKjX8Lvv4vLo5sOvAZ8kHZavRr49lvRU9ATIBBKSbnqLy3dbO+yaVM6BhKKiIjOtZv2BKZH4uL6OnwhmB7h/usSz/YC00OM5ugeH4xS8Fh1RdDdm31s/vsvDitXJqkIHS3ALRZnpVCggv1RLrnkEvTo0UMZN1FDcsMNN6gy25aC3TuvuOIKn+2bO6Jy1llnqa6g7Y0rr7xSNSrj8WH/k47A77//ru7xoqKier///PPPO2wffImg0Vg0HAwYlmd1AjvwHnhg4AgJ/R3V1dKRlFEKkolAMLyiOJPlkaz2IDhZijOk/7Mhiah0UySDFRksUy0ry1a6Cwo/fUmISLbkOBWq//MzJUoRALmtdgSjFrzON27shrKySgwfXoXIyNyANs/atGmTaow1ePBgfPjhh6ovxMqVK1UXzh9++EG1HWc3Tm/RERboUVFRamtPlJWVqRJjNi0j4epsJLfgHPgTgi5iocGyc1YmLF3KPKn0CDDQNlApz27EFGnS7TgjIzC0FAzpa1LB6ERsbN+AIBWuoD22RA4S1P+pe6io2O6z1AhLSamn0KSCxIUiza5OKlx1F4MHm1BSko5Fi0xYv748oLuhXnPNNSpKwW6fEydOVO3EjznmGPzyyy+qAubuu++u93x+13POOQcxMTGqt8pLL73UZISBK+/LLrtMEQ42q2J7dLYpd8U333yjOo2yjJck7ZRTTnGE/7ds2aJasIs1vqlRKoSRC/6ePThcwY6lA6i+tYNt0fm9YmNjkZaWhgsuuMCjToZRA+1Xwv3l+/N3DzzwAEaPHl3vufyu/M4aF110EU4++WRl3Z2RkaEa2fEY17qEzKurq1VbeAqAIyIiVLrlrbfewubNm3HIIYeo52j3V76fu1QIy5/ZVZbPYxdYfrf169c7/q6PEVvHs4Mqvze7zDLK1pEIWmJBkNxypbFhg2gBqAkw0DqwcRgNhHgseUwDwS+IwkdqKbjKZ7VHTEwvpafwx7SHNxCtQ7rSO/AxnUD192sL6KnhqqegtoOlroF6nNqzkdnAgRSudsOSJWwutVtFeQIN1Ilw4rn66qsbRQDS09Nx3nnn4eOPP6733Z566inVkpwNte644w6VMvmZfugecMYZZ6iVP6MftLPea6+9cNhhh6nPJthOnUTi2GOPVe/566+/qiZdOvzfq1cv1ayLE6K7SZGRlrFjx+KDDz6o93v+n+3XNbkhQaCl9sKFC/Hjjz8qR9UzzzzT7T6PHz9e9fMgPvvsM/W5/J23mD17NjZu3Kh+zpgxQ03y3DRICBgdeuGFF7B69Wq89tprauIn0eDnEfx8fi5bwLsDCQe/y9dff42///5bnSMeQ1cCU1FRoQjO+++/j7lz52Lr1q2qHX1HIihTIe76AtBZj+SCxJCVCwa8A69Xpj1Y28+BlWp5f59vmPpg2qCmRlaUNJ1i6qMzKj3aA9Q7MJ1DQaekRrYqskE30JaCJa205uYxC/ZSUl+hd+9E5OSUYd26MqSk1MFqDSxywRUuJySuaN2Bv+fKmB1fdSO2CRMmKEKhJ/U///xTRQeOOOKIRq+fN28eFixYoIgFV+YEJzqKIj/99FOlxZg6dSrOPvtsPPjgg47Xkbjo8D+Fk4wekOh4AgnQiy++6NAgMIpBEjNz5kz1f/6NpOLRRx91vObtt99WEzmfy+/hCkZw9PflPjT12e7AKAI/MzQ0FEOHDsVxxx2nCNPll1+uPu9///ufImOHH364en7//v0bpTz4+Z4EqjxvJBQ89prwkEjx+/DYkswRJBmvvvqqI3Jz7bXXOjqqdhSCOmKhwfJHnsPKSgnl0xUyABcanVJhQydC9vugIDYz0/9JBXtYcKIlqeCKm4QiJqZH0JAKjdDQSHtZapRKhzAtotMY3uspdqG8PEeRCpKS2NjeBqnwAryuMjLSER9vQm2tDWVldarcPdDQkmgL9RgN/89Vtzsw5UGtAtMBXJHrLSsrS63oiaVLl6oIRltAYsI0AvUgepJlZISTut4PRg9c90H/Te+HL7HHHnsoUqHBlAjJlf6+/BvTTq0FjzcN2vbdd1/H73iMhwwZUu9cMEXimg5y3Y+OQtBHLBqWj+Xni+cCJ01G3oKlfbevsXWrEIqcHNGqREbC7yHukDlKL8DUB1ff/ti621eQ9E6m8uJgJQfLaEms6IrZVBqDRIKlq9obg7qT5l5joOGxD0NiIq3Xd6Cqqg4lJVbExYUgEIw5mdvnueZkpHUNruDvufpurSCTpIKTGfUJDaFX474QYTKiwFTHrFmzsN9++6mfkydPrrcfJ5xwAp544olGr+X+eQt2uW1IwlxTDxq0fXeFyWSC1e550N6i0+b2o6NTdl0iYuEK3ivcWDHy229i8GTACa68mD/+7jvpmcDURyCQCimR3KZIhazmewc1qXAdNKi7YOUIwaiF+F1Ym9RTkFQ4Xxu4upPOBFNs4pxKMW0tSkrYawZ+D65ymcJ4+eWXlemXK9gXhSt/lna6XhM6KuD6f0+pFEYN+D5cXZPEuG66kmbPPfdUaQJPYFqCvVqag9aDUG/AShdGMVz3g5UuFFk23A+KUL0FCRa/j+vkzAhESzBy5EhFMubMmePx+xJNfWceb5Y5/8OyPDtYGkxdxvDhw+FP6HLEgmBYn9ELipSZGjHM9AR0GuS9TsJFMkHRM3UV/g6ZTOXGp/6A5lL+0mOjo0CvCxF1Mjxf6iBZDclXfTFrpqPKxEDroKtmwsJoD1+nqs9oa+/voBaAVQosq6TAj54NFDeScLDqgxoIVzCv/+STTyqtACtCPvnkEyXgdAdqCJgqYZUEq06Yrvjrr79UpQmFh8T999+vhIz8yQjJ8uXL60UWSAa4X6xQacrt9NRTT1UVK4xUsLLCtUSUVRkUi7KahT4bTH9QtHrxxRd7RVo0WJlBvQm/P9+D35+i1Jagb9++uPDCC5VvCPUQTAsxokPdBUEPEd673377rfosRlsaYtCgQTjppJOUZoM6FqZ6zj//fHW++Htv8cUXXzhSQu2FAJg22geMTHE1vmWLrM5pB96VkZ0tVR8kW3TRDJQSfeoEmAKoP7l2zcuapIqVL5zsLJZKu8lVrSP1oUWaoqcQfYaBtoLlkKEq1RoWZkFdnU2RC/q9+DM4SXGSp4CQVRLMyVNUycmZq/+G/gk333yzej7FkI888gieffZZRUrcgRPk999/j4MOOkhN4hRJMpLAElKWfOrJmuSEYkSWcjKlQcGnBsWGJCTcr6ZSMhR4Mt3BSZbRC1eQZJAQkUQceeSRKmrA0k2mY5je8BaMFDC6Q0JBgSn3szVVFq+88ooy3mI1Did2EgTt4kpyQCErBbI8RhRcusM777yDvffeG8cff7wib1xM8Vg3TH80heLiYkf1S3vBZOvg5EtJSQkSEhLUl2N9s69AIzy7GFgZZHkLfntOqhwYqE+iMDkQVum+PG5sIMboGsO4jOQEQq8PXrYkFOxKSlAjwB4fBiTdwYoRTSooXOXx4oBPUy3t5GmgbTCbq9C9exYyM/siNJSDBo9xCCwWCWuzJLurGPNRs8DqDHpXGAhsVFVVqYgKTdPoMdKa+TsApEYdI+pktI0pgMJCYL/9AsOiuq3gyopakxUrhIwxUhEIEFLBctIS9X9WfkREtH8PgUABy0WZ5igqWqWMtHR1TGxsPyNK0S4w2Xu61NgjQnWwWEJB/ywuXEgugpXH0TOBUQH6Q7AqwoABossTCw2G/jkALFok5II24PaS5qADBztWW7GXSl6eaCkCQaDpJBWsgiixT5hsax0Abl0dCKZBSLzoS0GSwVW0KMMDv7+Fv0KOMSND9LWwICyMkQuTg1xwoRKM5OL1119XkQqmGBqWpBroujCIhZueANRbsBcMPUiGDAmu1Ah7p1A/RVEzS+PoERNI36+qiumPYntFQw/Vz8KAgGLN6urdDj+LkJBwJCfvidraElUFQs8KI7rTfqAgtq6O1Tg2RS7MZsl7U4dHcsHxJdjIBQlFIHbfNNC+MIhFwwNiFnJB+2/2GOGKnn4XwZAaoTcFq8boQtqzp1THBBIY1tc9P6Ki0g1SYQdXySQT0rXV6hByShlpqL2BmehRGO1h5IKW3QbaIyVitmtb6mCzhcJsZiTDSS5iY4OPXBgw0BAhLVW1sv6Yog1uDH21tOwmEMAbn/4pTIXQyprtwbdvR8CCpepMe7Dqg4SJUYpAIxV00mQFCMFVd1dt4+0Kkgj2QykpyVKkS2y5I1VliFTHiApXojtpqrGYs4EZCYZhP+trSIWIDKs69UQxNEX7LAAgwbB7JhkwELRoEbFgY5jHH39c+bGz9IglQqyfpQmJX8DHdyxV3Yxe0H3y668BVkP5exmZKzhvMK1DQkEXTX4f9kkJhKqPxpqBHQ6XyK4u1CQhYOSmtDQLlZX5anVMPQWty+Pi+njsGcIoBUkZwegFXUoNcuF7mEwSCCbR091nec/RA8kgF60DSz3pBcEqBVpau5amugPnpNNOO029hsTatfNqSxbKLIvVHVb1dtVVV7XyW3QdtIhYsF6YndRYA83aZJqo0H+9oSubK2jCwhIV183nsFphen4ajnrqMJjqLD5PjdB2ncJOmqbR82Lbtra/LwcYRka4tYf7Jys+6KiroxT07EhKQsCBuWo9ATKkz7LSrgoeA4pWhVDkqWPDagS6Z7IVPJ0gmwNJGQmIGGlRd7HNZ63XDdQXchI8R9RcENQykVxQ50RRpxG58A501rzpppuUmdbixYuVlwQ9NJrqf8FqFXp0cCHsqZmYtwtl+k3oLqvcaJRloGm0WrZH05GPPvpIGXw0pQZ+7LHHVN2r3tiJzefIy0PIQ/cjY83vGPndY75/f7s3BgkGdQqMXvz5p3/agdP1jyZX7MJLkSarXRilCIQeBu4mUho7cXCWzpviLNkVwagNrbjleNSqXD6jD3Fx/ZR7ZkuOCwmIGGmxcqECZWXZ9gnQgK/A8yOw1SNumlwwPdlZ5ILOjpxsXbt+0hmTttLaZvuBBx5QxlXsBtq7d2+1gKSxE8d9Tqx8PTtxNnTopHEWjahomc2xnq9xdZGk8ySjBFxwEjU1Ncp0iy3FPYHvycmdZlu0rmbnTjba4r55wj777KNavdOYS3dYbe1CmZ/F76s3X/ovBStaTCxovcqDz5PFkBDtQZvyKb/zzjuVmYbeaB3rc2RkwPrCS+rh6K8fQsJ6sY31NZgnJblgSoGahc8/Z8hNjKU6G3SoXb8e+PJL4Oef5f+saOG+BiqoqeDExwkwOrpnl3TUlBbwO+1W3NVqJcyoDQkFow+tJVpmc7TqpyKVDNUOq28DvgLD5uZGUQt/IBd0suSkTPLAlTotsS+44ALl9ujacZT21UwN0Oqb9ttvvfWWagW+bds21fOCFtz33HNPvd4VdLR84YUX1Kp/xowZ+O2333Dbbbc5/s6/cTGqW7DT5ruoqEhZjLsDiQcjCrrVuP4M/p8Oob5CUwtl9k5hj5MRI0ao+YzREANNo8XrWLZoZQMWkoRPP/1U+Z/zIvNELkhAPDFGX8J27nnIeulr9Pv3E4x57gL88dwi1EW0TykHG/RxwmbFCHuNsGPt6NGdo18ggaAtOd0zqafggMUW8YHetbW2tlwJE3UFCCMWXQ1MVeiOpQQFq5GR3X3WAp4eFyQXTIeQVJBcMCrkSaNhwNsom554bHayRkfOapcohoCEgk9l5JPjSVvKvrmqbgnJ5EqdUQDaYI8dO1ZFGBhdrr9/VkVAaJvN8Z1237SCpoU0J3fOBSQXbE2uW3m7lp5S30D7by5AaYlNcFE6c+ZM1T6c70vtA1/vKQrAPiGc9LUVuAb/v2bNGrQVXCiTSNBtkvvWcKF87rnnqj4etAf/77//cPvtt6tj8DlXlQZ8RywYLmN3OIKe5Wzu8vzzz+O1115Dp8JkwvxJryBt/TzEbVuDoTPuwMorXmi3jyOBYL8bph4o7mQghu3FR4wQwyl7s7p2Q1WVEApGTPiT+8MsUwdwuHYHV3g0eCLCwxO7nAEWv7/4dZSq/1NHwbRHe0z4fG+6dFLHwnRLRcV2FRGhSNZAy0FS0atXx3urMN3Qko6dxNNPP61W4ezZwahAwwUgiQEnf9fJPDQ0tF6fDf7OVevwyy+/KILCSZ96Onbj5KTN40LyQ3AiZ68NGmtxoj7ggAPQWWhuocz+KRpM8dC6nFEdRnPYx8SAe7Q5tkxWq/NlnY3q2BTMu+Qd9bj/t9PRbclP7f6ZJBAkEpzUWZLK0tRPPgEWL5a2476s6OMKh1ESlsB++ql8FkkNP5vRkmAgFdquW3QVEY524F0FNP8qLd2sSIX09khGXFzfdo0iuHY61T1YdLdYA8ELTo45OTlqDGfDr4Zo2NhKWsQ3/h1fT/A92ByLGorPPvtMkRVWc+iUhgafTxtwkpQNGzY0uY9MQfB5tAx3Bf/vSZTZmoUyF8kkRBSGcqHsCToy09x+d3W0KGLB/NIxxxyjxDzMy82aNUu1fmUrWn9BzsijkHXsNej3/UsY9fzFmDN9OWrj2r85FSd1EgzqLfLzpf04zXAY1WBqgp4YbBjY0hQFIxMkKLyvaMPNxQFzswkJ8r6BKMpsCiyDZBpEvBe6TqdShsxZ6UFNCUE/CnpP8GdHQI43U04RqKrKVwSHvS/obtowhG/AM7gq37atrJFOhsdSu6G6u6Y5N3PsoLV+a9IiOhrgLTjRs+X2WWedpVbtbB7GtAAFma0FiQRJwzPPPOOIaui24K6gqJIRDUYGWN3Bjp0UZnqa+DnpU1TKNuwEP4P/99QBtD0XyoxuEIxcGPCMFo0YDHlRvcuSG1Z4kJmSVBxxxBHwJ6y++El0W/YzYrevw8hXJmPxrR91mN0diQPJBDcKs1iaum6dc8Dg9cgKE9eBg6SB4wI7jZLYk0ywKpckgs3R+Jh/Y6STVR7B4ALqDnV1VWpSI6gl4CTXNTwpCpQVt3QgDVF+E0wBdUYFDFMgnPx0aoS6i5iYnl3iXPgCPGfuUhK6QRnPL4+vO5Bc8P7nT75Fe1rtUzTJ8D/FlNQWUDfBio1vGQZtJbjyr62txfTp01XFBaMSrOBwxZIlS3DfffeptMOECRNUxccNN9ygNBcsD3UHlpoyRUEtyLhx45QugyJLVzLCeYmtx7VOhMRp1apVjsfbt29XpIDfVafym1soM6LD31GPkpKSojQWN954o2oHz7nPgI+IBVXBgQCKNhffNBMH3Lo/es77H/L2PQnbJ57b4ftBIqFTlCQLJBokGRw8XEkx0xqMeHBA0Qpxzin8HaMe7L4a6GLM5sBBl6WU2q+iK5hgifFXnqrKIJjuoJaCuofOBPcjNraP0ls4RZ20UO9aWhdfghUiNpuQC00wGsK1WoRoq6DTEzh5NhRNvv/++yoNQNOoyZMnt+p9+XoSBQo6OWlzAuZEr0tJqbVglOSiiy5SxENrGL777jtVlTJ37lyV9mgIRlVYIktCkpubq8pgWaniKujcunVrPe0HUzwsY3XVk3AjgeH392ahzGgJNSOayLB8lqZbrIQx0DRMtg5OpHrbz72l4Ip+5kx5zIgAMeijhzB01v2ojUnA7y8sR1W3dvDQaCVINM48Ux5/8IFENHhfBJorpq/AnD7D7wy7U1OgDYaCEZxYWErrbBbGEtLufmdTTv8Fkj2mpghagkdEpHRZL5GGMJur0L17FjIz6SXSfMrKm6iFPE8WH4xMcmERSE0CDQQ+SACzsrLQr18/5XTamvk7qC/ZDWfchcLB4xBWXozRz1/kt1Z3jEZw66qkgm6Szo6lzh4XwVpCSudMTSoomIyN7ed3pILgeaB/iK4QkR4jdEH1z/sosKy+PR9DV4dO3bzMgIFAQlATC1uoGUtufB+WiGh0++839Pum/cpPDbQO9GhgOoBgBQSNm4IRrHJh2/Ly8u0OK25pFpbuM1+K9gDJHrukcj+1DbhhptUWq+/6Dco8wSAXBgIZQU0siPKeg7HqkmfU42Hv3YHYrX7SMM2A3UxIVsBmc5QKswdnfw8pIa2t7bgSUl+DkRWWpLo6deoUiQHvoStsXBuUeX6usysqNyNyYSBQEPTEgthy9JXI2/sYhNZWY69nzoep1rAu9h/L7ip7yD34+oBQ+EhXS/GEqIPZHKlEkfTmCMQyWpI/7j9/iv5iuyOlY8BbNGxQ1jR0y3WmRAxyYSBQEHijW2tgMmHZdW+hJi4FCVlLMeTDBzp7j7o8XC276dfQ2ZUQ7VFCWla22dHrhOmEmJjeAV+26d5MS6p5DHh/DN01KGuOXJBYUHdhHGoD/o6uQSzoypmcgWXXvK4eD/z8CSSt+rOzd6nLoqFldzCVMTJNUF6+FZWV+WqypWaEaQ8KIIMlIqPNtEiW+JjiW35no0Oq10ewRVELTS64MXKhy1GDHXTyvPTSS1V1QlRUlLLQZut0VxdPT2CDMrZBp6cIqxdY+lrpcuDWrVunWqTT2ZN/p604y29dQROu8ePHK1tzunzSfpwW5QaaR5chFkTu+FORfeiFMFmtGDNtEkIrpBdDVwRzvFxNM//PlERFRZ5aeVJgyJ8UVDLMzciC1Vrnw88NTstufi8eR7Y2d6Z30hEbmxlU0RhXkCxJ+/VQ9Z3lu3eRWa+DoxYEXXZJLuiHE0jkwhsi4A5056QTJvtQsVvqc889pwy37rrrrmZJxdFHH40jjzwSCxYsUP2s6NLp6nNB63GSBHZfpWMoPTj4O/pkEMuWLVPGWHwfmnp9/PHH+Prrrx1dWQ00jS5FLIgVlz+Pim69EZO7CXu8fRO6CjjxiSFTvhISFhevR1lZtsr/s4yQVtpceVJgyJ/V1UUqzE2NQEnJBjVp8HltXZUGo2W3OFRuVsdHG3wxSsF0QbBDIjJ9FEmUypdsRVYNtCRq4T1xJ7ng/EhyQS+c1oLOl2yqxUgAXSXZhpwmUBrsarrHHnuoxmS0r3a1z6YZFVf7dLHkav/MM8+s18uD7dhpYvXmm2/W80Jge3Rah7NtO1/HiAIncE/gpE67bxIEunKeeOKJqnlZc51F6Y55/fXXKxLA70DLcu6jbrLGjqnr169Xf6cp1qBBg/D444+rRmkrVqxQzyGR4N9oykWnThprPfnkk6r3CV06DTSNwB/VWwhLTAKW3vgebCYT+vz0JtL++RrBHplg5IETH5X8zP1rp0eupFmZwHQEbaQZ2qbzI6MINENiV1HdrpwrUq7IS0s3qZJJ3dOiK1t289iSfOnyS9Ef9FAW2F2pvwavI7ZfZ0pLKn1y1XExdBfNHTddZtx8hYgrtAsv57fW9H+k0+Q555yjLLxXr16tnChPPfVUx/mi++Y111yjXDHZP4QrdW2DzQgCSUVBQYHq9fHzzz9j06ZNyh3TFWzSxUZkJAG6v8YZZ5yh3C5/+OEHFSXYa6+9VKdQvpe3oDFTMpsueQDf/59//lE9T5jGoDsnScG8efMczyGRItl47733FJli5IJREb6GfUkI9gtpaA5FEkbzKO67gabRdUY/F+weMREbT74ZA794GqNevAy/D1mBmsTWN9/xR3CQqK0tUWRARxkYHeBq2mzmFuX15MfXWyzlKpJBQkEvA258D7bY5s+uZtlNksTvQ0JBMDoh1R7+60nRnuC1xQhUdXWEw1VUNzELhqhUe1aIkFQwauHOztoTaKDFDAPJBaU7/H9LiAUnU5KJPn36qN8xeqHxyCOP4Oabb1Y9PDT22Wcfh+6AZIPOjLS4JjhBMzLAlIN+HtMf/D2jEwQndqYlOPHryAEttr/88ksVPXFtT+4JJCvsQ8LXeQJJjo6a8HmMnHA/SGAYjWB0gtFSWnWzqRn1E0yRkFTQJjwpSczg2ByNVt4ffvihinYwRfLQQw85jp+BptFl7/i15z+Ckj4jEVGcj1EvXh5UUmspc9yqVo6iZQhXkYj4+AFq8GckoiUraj5XHCIzERfXz9EgSzep4gTbXIpEemJwVR+mtAeBraXY3SBKIUZXXZVUaPCaYKSLERuSCaa8mG4zRJ3eRi1a5mhKMlFXJ00K2RnVW1BPwImWZIJRhDfeeAOFhVI2zImffTb4d3dghIOEQpMKYvjw4UhMTFR/0yBh0aSCYMqjrKxMRQuYQtEbCQqbfTUHNhFjaoT7e/nll3t8nm7hfuWVV6omZewXQm0GIxRM7+h7mBEZkok//vhDER6SDPYv0aSB6Rd2Yb3qqqsUERo8eLDSXBCuWg0D7tFlj5A1LEI1KqszhyN9wdfI/FkuukAH89tOAaGUOcbGsiqBZKDtp5skheWhcXH9HRoCRjJoU+0pt87f8zmBbtlNl1BqCLgil8hLnDq2gWR01RFgREpEqzTTqnKQMANN+1o058bpDlz8s1BBd0D2BoyMMIXBlARJAaMAnHg5yTPc7ws07PBKUkGtBtMirtvatWtx6623NvleJDqHHHKISm28/rpU9nmCbmfO7+WKYcOGKW0IQcEmu7h+9NFHqsMqUzIvv/yy+u4zZsyo11WVuhC+jroMpoAIT11Y/QW1tdSzCOnsLHRZYkGU9ttTRS6IEW/egOgdzTNnf4XktvPsZkxWu6iuX7uVOXLS4Cqdwj0xTGKqI1eJPV1XqNRzMN9ORESkepU28Udw9V1aKlUPEvZPV3oKf7bj7kyEhkbanTrD7IRsqyK7BhpDX0PN9RBpilxwMiG58HYy4ZjASfXBBx9UVQ/s5PnFF1+o1EDfvn1VysMdOEFnZ2erTYPtyTkBN5zMXcHJm+kEs9ms9BquG0s+m4pUHHzwwUr7QCFnc9EC7nuPHj0UYXEFy0t12ociTaLhe/H/OuLhepz4fiQdTIswUsPv4q+w2Ekm02SdGYTv0sSC2HjSTdi9x0EwV5VjzHOTOozmkQiEhDCvWtdmkZtM6jmq4oKgEJPh+Y4QEOoJRHsaSPibE3CFi67Cqlb1uplVIKY+SJiYC+f37SoVH76IblHUyWNGDQGjPYYNuO+jFlw3kFxozUVzvRYpbnz00UexcOFCtRqnwJJtyUkatD7hmWeewQsvvKCqJxYvXqyiGgSrR5hCOe+889TvmUZg63EKJMeOHevxM/m6/fffX6UcfvrpJ+VR8ddff+Huu+9W+9EUqejdu7fSS3AfSU50Sah+ztChQ9V+yLEwqQgI953aDeoy7r33XlW6Sk8MgvtBLcWFF16oUjQkHXwNIzbHHXec472ZCqGehKWuDz/8sKoc4fu2RAvTWaSis9ElxZv1EBqKJVNmYOL1eyJ5zV8Y+PmT2HDGnT79CK7YONFytUtBG7fq6jrYhdbK9KamxqRWd2ynzGqJ0NAoZQHdMG1QU1OFXbuyUV7O9AKL2W0wmSqVgjkpKQ2xsb1UKLojIf0vklSURASN1faJmJESqyI4UVHSxCqQILbVuUqo6hRopgXc9+hM8NwzLaIriWgDzmvBH7u5dia0iFNHLVqattTkgiWofBwX57ndOks9586dq8SJbIPNlTyJxDHHHKP+zgmX1Q/UJrC8kxGF008/3f45Jnz11Ve47rrrlOkUV/nUPmji4Xn/TPj+++8VkaD2gSSBplN8D1ZuuAPTNSQG3Hr16lXvb3oxVltbq6ITOgpBTJkyRe0/y05ZcUJNCd+LBlsEvw+FmtwXlrzyPSg+5fficzWYKpo6daqqEOHv+Xd9jPwNdXVOUqHTY50Jk62Da8K87efeUvBAzpwpj1Na0cuq168zMOb5i2ANNeOPpxegZMCYNu0Pc8qsyuCkpMs7XcHQ5RNPyOPbb3eWkLmCq7ysrNVYs2YRNm5chk2blqKgIMfjZ5rN4cjIGICBA8di2LAJGD36CKSn9++EEkymZGiwVaBITlLSHgGnQ+A5YxSI51E6fKYZUYo2G6PtQE2NeAAwwhWIESxXmM1V6N6d1REUNNcvTWwNuODQpIILjNa9h0wu0dFCLgwOHPyos5MKlh6TVHBG53zIqlz6nrQUJGWM3rh6kLR0/jYiFnZsO3SSEnFm/P059nr2fMx9diGsES3XA3BVJo6VssolODExHMwohEQjwlFTE4b160PURRAba0VEhFVFNmprq7B8+W/4/fdZWLLkNxWZaIiIiGjExiYjLCxMDURVVUw/FMFiqUF29mq1zZ79vnpunz4jMWHCGTjiiEuQktIT7Q0OikzF0MFTf3eKNxnNCJSVPic/uoPy2EoVSw8VPTLQegg5o3DXrO4Pp+4msMmFL8FjY7PVtDpq0bDdOh9TQxkgt52BVpIK7WdCUsFz7Q8Fjgax0DCZ8N81ryFp9Z+Iy16FYe/fhZWXPdeiFS7Nn1xzyFylh4XFq58NUxquFwD/xhTHL7+8ja++eg55eVmO58XGJmHEiAkYOHAU+vUbgYyMvkhK6qNysbrBldgqh6sUybZtjHD8jZUr52LVqnnYsmW52j766EGMG3cCTj31dgwduh/ac2VKUiF+GdH2ssNSVFRY/d7TQPQU+Y6Ondx/7rMh0PQluaAWJ0TpVoRc2FQbeQNCyrkJsbCoe7o10O3WmWLlOMPohUEugg9Wq5xjpr80qfAXGMTCBTXxqVh2/dvY96Hj0P/racjb53jsGuW+nltDIga7lHCSExMHz7CwBLUS066VTaMSX375Ar755kmUlupun2yacw4OPvh8DBmyv8pjSiSkQP2kfsFioUFVLBIThzoqLdLS+qpt770lD1hSshv//vsNfv75baxa9Qfmz/9SbUyRXHDBoxg0yLPYqrUQv4oqNRnHxvZXqQSmFEi4mGcXEuRHd4AdrGShPkQ7inKyY+TFH/c10MHjSgi5ECdWg1z4LmpBUF/IhQsnHhINH1WRGvAjUlFq7xnDCJW/DVOGxsINRr48GX1/fBWVqb3w+wvLYYl17xIpYjSaUIk7DX0NOGh6QygqK20466wPAFAouk39Lj19AE455RYceugkle5w/7qdqs8HIyT0pqCgMCKC9tsJTU6CW7euwhdfPI3Zs99T2g0+99BDL8KkSY8iKck3hlVMefB4ECQQWldB0aqIOVkdEmuPXPjPnSDnUUy+dClpMHVc9VeQkJNcEHRwjYxM7tIai8Zai9A2N7CjlosEg+nwBulyAwEKm01IBdNdJBUNRbokHZ2tsfDfuHQnYtUlT6MsYyCidm3DyNeczXcadrIUz4ZadfNzIqWvgTekYvv2dXj44cMBXKBIRWpqb9xww7t45ZW1OOaYqzySCpIJTt4kL3TRZFREWpDnOUo8PaF37+G44Ya38eqr6zFx4nnqO/z66zu45prhmD17ZptLXhml4H4Q3D9XsSYjKuLGyHLUMrt+ofMTgXIeCxzeG9S/xMb2MUhFB4HXiTN64UxBBQr0Jezra5lRC3lflr633NfCU18RfyhDNNA26CiUJ1LhC/jiejaIhRvURcZgyU0zYQ0JRa85H6DHHx+7HHTW429zdLJkpIC+Bt5UPdB85ZtvXsANN4zCihW/URsP4FFMm7YWhx12YZP10VL6mOMwv6I/AF0fJWcdqkiHdCtt2l47Pb0fbr55Jp588i/07z8GZWWFeO65CzB16skoKdnV/BXjYd+oq3D2AWm88tR6BRFzljjEe50FfTw5ocl5jLd7LrQur22gdaAFODeC1wSvjUCB1UrzL07YLW/I1xQk/RHS4s6nnsAJiPvZUutvA/4Fmw1gA1puJIzt5SyuS3dZHNBaGKmQJjB41v0Y8tFDqIlNwpzpy1Ge2E3V4UsJYoi9BNG7ktnCwjxMmzYJS5b8pP4/atSRWLbsVQD98L//NR+mJGHgoCudJPvUExRykpTGT0UulRlMjzTtummx1OLzz5/CRx89oB6npvbCLbd8iOHDD/DqOzkdP6mhKFP7RifOpiy7WXHB5xMkIGzc1dFwTWFJf4vuAd8ULdBBUsGIhdi+9+hwL5bWIjZ2BxITi5Ca2h3h4b6rfJLGZLJAELLb9vdlxIJrF5ahtiZEbqDzQFJBPQXnfJ7Dpjy6SCJZLZKQ0LLzLGN5heoXw94v2h69NakQg1g0AZOlFgfcNh6JGxYib9Rh+Pmml2Ez2eypj55et/1mdcaTT56JgoIdCA+PwiWXPI1DDpmMs86SwaI5YkFCQWLBQYsul55ssSUdsVNpGgjdfIzRgqaQlbVM7R9TNCQsl102Dccdd41Xg6TOk/O52mWxJVqMjvQz0EJbHXKX88j0lZF89g+fi1xHT5mmrnP/gg2xsbmIjS3y+QqSlSEiCHc6c7YVzL1zsuF4Y/TSChzU1Ej1B89Zc+eNJITkgtVArTEJJamgeZm78d/wsfABbOYwLLnpfRw0ZQzSlv2Kwb+8j43HXG4vQfSOCn733Ut4440bVEgzM3M47rjjU2RmDlMXiTfgqtpZ85/S5GCr7bWlXXq+iqwwPcJuppGRaR7LJvv1G4VnnlmIl1++EnPnfojXX78OW7euxBVXvACz2XM4jJOAFt/RTdHbCZrpIx4P7iO/Gyf49l6hkmxx4nK2OU+0tzk3soH+U4qarsgfo1+sIKJjp7fkvfNgQllZBsrLuyMkhBEw371zbW2F0i1pouWLsmcSC/biYh+t8eOlTNGAf2PjRuDff6Wyh4LM5kBPi927ATZjtXeB9xpMf/jCstwIiDWDwrRMLDr7Vox772Hs9dFTKNvvHJTHNn/Y6uoseOONKfj++5fU/1k+es01ryMqKraFoSkKHesUofCmJI+DECduTtSc9FkGy/QDw/+MXniqdoiOjsPNN3+gdBczZtyOH398FXl5m3DHHZ+53Wc2lOJETXC/WmrRzAoAkibuH6MxEu3w/SgnBEbKgQltLx5oTqBdAbr7rZRTSyURr4u2VkZ0BGw26px820PCZIpEXV2pikSKbb/nZl0tQXo6sGKFrGYPOcS9668B/8CGDcDcuRJlYubBG6tu6mi4cKW2prMqgYzlWhOg9wI1FWsPPQc79pwIc2019npukkqRNAU6YT7yyImKVHCwvPDCJ9Sk3RJSQdTUFDpMsFraa4OhU2mZLhO2NIHKcXQ/df8aE0499Vbcc8/XqjKFepB77z2skahTPB+2O8SarR3wuH+c4Lk/DbuithV8T/p+SDt3IRUtEdoa6ByI4ZukGXk9MHLRmo6fwQJdgkv9lFSJtB2ccNjoc9ky4K+/Ore9tgHP2LyZLd6dZDCQYBALD+CKSaowbAiLiMfyKTOViDNxwyIM/vhhjweUJlf33ns4Fi36QekpuOI/7bTbWizqEifPXY4a/9ZWKzA9QbGnVt5T38DSVHf9SzT22ed4PPLIb4iLS8G6dQtw550TUVgo0QkhAdsd5ZlcYbZWsKZXqPxuvppEhFAUKkJB8yXpSMoy0kzlT+GrXLWB9gPPEckFo0u6Z4s/lCd3BmiCx+uX17EWZ/sCDKuzr9eiRQCbi3bRw+u32L5dSAWjDw36rwUEDGLhBtKdUyY5rm6pqahO7YX/rmYVBzDok6lIXDPfbeXHnXcehLVr5ysr7kce+RX7739Ki0+KpEB2uJRvtq1iQSofUtXkKvbhpSgsXI3S0i0qgsHvSi0GN0YOuPXq1RP33/85kpMzkJ29CnfddRB27FiFkpJNyqJbryzbqlGQSYQt3hlKrnJ875aCxIREjPtH3Qb/L30+0hWxak7AasC/oAXSYglf7vBI6WqQzsGyKCBh9lXUgoiNZadP4O+/gf/+89nbGmgj8vKAX34Rv4rMTAQkDGLRAMz7i0uk6BpcXSJ3HHAmtk08DyarFWOeuwChlc5GY0VFO1XagKLH5OQeePzxPzB06P6tOinV1bsVueFkS11EW0HBIvUWnHg54ZIYME1QUrJRfVeK5aSte4UaxPXWvXsa7rxzhiIX27evx/33H4ucnKV2YWiVIiQc8Pn6tkQahAA4DbT4/b0FtR4kR6Wlm+zeInXq/Xjc4uL6NetIasB/wWibjogx0qaFwl0NXFw4oxa+NRGjuI+5+z/+ANau9elbG2gFdu0SUlFYCPTt639W3d7CIBYu0OZXOszvbkW+/MoXldV37I4NGP7OLep31CAw/aFJxaOPzkHv3nu06oSQUHDSJ6SSo3X6Wq76ddqDaQGSCqZ3dAvwqCinO6b+HQdx142/69Nnbzz44NdISemB3NwtmD79TtTVham2zrKvRYpglJRsQFnZVjX4N5Vm8QSSOOpICBGdSnttz9EJ0U/w+/F78vuKw2cPRSgY5TEIReBDNDzd1WMR4QaOgZavIBHH9olaEN26iYDz998lr2+gc1BUJOkPRiz69QtcUkEYxKJB+oGre07m0iyrcT6efUOW3DBDPe7742uImPOhIhXsIMqeG1OnzkaPHgPbVMuvUyAsE23Ne4jGYJNayXNFL43RYhyr+ISEgUhO3lM1MGM1h5CQIpUu4P/1xsmZ4rGMjEG4/fa3kZCQim3bNmD69NsRHp6miBefQ40E34PEhYN/aelmB5lhZMNbyGeKWE1KQ52vZUSEkwqJn0QnpJxWqmDENZMbq14MQhFc4DXmel00ZV0f/FoL0RD5Gj16SMUBJ7Yc8a8z0IEoLQV+/dVZChzoHiMBvvu+Q1XVThX+19qBpiIFu0cdio0n3Qje3rdPm6QMphIT0xSp6NlzcKv3QapASARalwJhikNEi1pjYFbCz7i4AYooaRKgwTSB1MeLSM6dqFPnt9PT++Luuz9BTEwi1qz5C9OmXYLQ0GgHWYmP728vZ41VE7tOv1DH4SQZzUcydJ8RDqBlZdtVRISEj2kb/uT+6OgE9RPsmcLoSmCYKRloLeS6iFPnntVN2o+kq0DrpAgSC19YfTcE8/m0/Sa5yJemswY6AOXlcsw3bQIGDGidqZW/wSAW9htVK66lSqH54t9lZ96LY8KjsLTOgtSwCDzy8K/o1Wtoq0+ETMRSBULjppakQEQXsl0NuNIUzWyf8PuriENTxjqckHWPDJIRpjM4eTesjGFUYMiQibj33m9hNodj/vwv8N577MwqoK6BxIWkTE/2Ej0IcSEZm5slGRKBSITFwjbr2SgsXGFPdVjVPnJwJZHhPot+IgjuQgNeVhClq+tV+rywMqmuC2otIh2l1L4GQ+8Mwe/cKRMdQ/MG2heVlcDs2cC6dUIqgsVqPWiIhcVC+9uWDzScRBlWJ7i698YBsq6uDs+8dDn+qalEAoDfaqsxfsNCtBaSAsmzp0Bi1ITp/f6XqagAf+pcbEs1BtJ/pLdKhXDQ4qDNqIdrZYz20Rg+fAKuv/5t9brPP38SP/30VqP342RPIkK9g5CMHo4URUOSwe/NFAddBnVVBz83JETMskh2uA+s7OD34vczGoV1TUhLe0YTw9R1pL1UuhKcZeNFPvV90WAInqH47GwhF6xMMNA+qK4G5swBVq+WYx5MRmVBQyxyc3egqmozLBbPor+GkMFJr8gTHGY0zeGdd27BX399plbuzx95OUYCGPH6dYjKa53yqba22MUIK60FZERP/qxg0X4Vqa0qAdVlnyQEdXW1KCxcZddd1K+MIQ4++DycffZ96vErr1yF//6b3cT7hiitiJCMgfZIhqRLtLvi7t3/YefO+eozpddJBcLCopGYOMxeFcBSVOl/YqBrg9E3EVWHOmzauxJ47/Beb6+oBcFQPFfPtJKmoJOragO+7/3xxx/A8uUSJaJpWTAhJFiiFRKxsKCmJsde2dG0O6aszHUb8iivJ/SvvnoOX389TT2eMmUGkie/goJhExBWWYoxz01qsY2d2VyL6modMUn1yr5YRxW0iItNvGJi2m6JLTXzqbBaa9RncOBm9Yc7onLOOQ/gwAPPVtbljz12KrZta75Wje/DYx0aGuVYdUo4m42WTCqFw+/A5/BvsiqTKhkRbO7yuSLeQODB1ZjNtV9NVwHv0faMWhAMyXMVzdU0LaU5ERrwDWprgXnzgCVLxAE1GPu1BAWxMJvN6NOHVs0ME9ILoVyF2lmS6ClUyhC8eEWYG63IPWHevE/w9ts3q8cXXfQkDjrobEXvl9z4HixRsUhZ9QcGfPVsi/Y9LY3GP0JuqC1oDq46CBGa9lDW2L6ohOAkX1GxTaVESHIYdpVOpJKmcQU/74Yb3lFeHeXlRZg69URUVDQuBeTrWN2hhZxMdeiKDkYlOEEkJ49EWtoEJCePclR2aI2JpERMqK4uRkHBChQWrlEpFJJCnl+mgPheXS0k3tWhq5y6Yhkqv7toTWztFrUguIqmlwLNszgRetOnwkDT4DGkjfrixUDv3uKAGowICmJBSEklJ8O+Dq0AJzBWOmgxogYnS92emRObN0LJ9ev/xXPPXaBu5uOOuxannCIeFkRFen+suFSiGENn3o34rGVe7XN8fAliYrhv0tmxOXLAKAxJhSZErOjw1FSspdD9OnS5bVLSMBVy1isjXQbrivDwSNx115dITc1ULddffPFyO5GosROSHSgt3agIhS495Xfk+dHiUrqB6moVDpgkM1oAyo3pGaZQxH2UBKNAfX/6XPD8MhVEolFSsl6RSX4mSQwrZAzCEdxg+rJ+GWrXidnrCpH2jFrI58gEyNW10VekbairE5dTdirt2VPamgcrgoZYaDB0r/tCiE10td2mmiryWvV/bQ8sbcibP7u06n700VNQW1uNceNOwGWXTWtEArKPuAS5405EiKUWY569ACE1Tfs3cDDo3l3aoYeHNy9IlBboW9V34HNFbOmb1nW6/wcnfslhswQ1TA3cOppDItawZwMfx8Ul4qab3kFoqBnz5v0Pn332oD2ikKtewygIIyvMDQuZGOAgE80ROv5dVqapyncjNraXIh4mE8toU5UehGFx7p8Qmmp7aHyXqpCpTzhyVOqI5bxGdCPYylBj7T40vIa7Rsye45YsoBi1aN9UECdA+lxwQlywgGNXu35cUMJqBebPl+PHY0k79WBG0BELDelkyeqIJIdVNL0QiopWOyodvGlDXltbgyeeOB27d29X5aQ33TTTfb96kwnLrn0D1QndEL9lOYZ8cG+T71tdnYeQEFr0RiI8vOn94GDJ0kunI6hM/L6ADMg5DvEoIwT1vS7ilPMhdRdMiRQWrlQ9RZyTdhZ69eqFs86SCM4HHzyKrKzlKlRLEkACxIiDNtNqqvS1KUjKSvxFRGdhU9EmdiuNjx+kzjU/g5U9JBwkXfw+TsJRqoShjGDRJZRks7UuoQb8B85GdpH2VJ6ImbsCXBsLNqcpays4EaalyYrbaFrWclLxzz9CLNilNM43QWa/RtASi/qtw6UJFVeszMtzRRsaGuOVLuGtt27EqlXzEB0dr8L+/OkJNYndsezaN9XjAV8+g5Tlv7t/Xk0JLBb21zAhN7fpFIjuXVKfVPim2Fmv8nSqiJOy9tOQNMYWFBevd5TCsnpFV6JwQubvOHlzUD/hhOux774nqIqSl166BTabtFMnwfCVEybJQn3bb8mr8/0llcLPTFYTDc85CQ2Nu0iW9MqW1wSJpZQZi0uomG/lqvRJV27RHahwNbUTEt41uqG6Ri06QsCakCBNy5gSYWqkCxxin5CKBQuEkJGYsS9LV0BQEwsNTsiyio22h9cTlNOm9n/wBHo0fP/9y2riuvnmD9Cr15BmPytv3xOx5cjLYLLZMHrahTCXF7vpcyEpkIKCFFRXR3jRu0TSH7oLaGuh9Q/8zhyICgqWq2NA4sDqC/7UGgVO2kyNcKIV06o4ezkqhZXhqrKDGoiEBEYL+iAmJgNTpryP9PT+2LlzC6ZNuxDWdoiZNmX73RBSaRLWSLvBKIfTJTREnROu+jgh6WgGDdPaexVowHdw2vCHqOhbV+mGysUAUVtb0iHRNzYtS0yUUkmKOg1y4RlWq6SPSMS6dxdi1hHgdVBX17nuZl2CWHAy5UqbK+vExOGqkkIcIaVDpzuB59q1/+DVV69Wj8899yHss8/xXn/eykueRXl6f0Tnb8WI16+v9zex22YHzggUFHhOgYh1seSM9aDpbaRCl4pysqysbChwzFITZ1HRGnu30xp7iiJCvb9Up9DTo5uaiMWuW1INJBEJCUPURM1jx8HMFTExCbj99k8RFhaBf//9Ft988wLaA07bbzlGLRGvSXQjwsUldKDd7jzJ0fNE25izgoURDZ4zkrH2FMkZ8HUZKruhtl/FhL+AUTxtda6de9sbKSkSzqe504oVHfKRARup+PNPafLW3qRCxq0ylaauqNiMujr6AXXeeBUkBqLeNPaSkk4R/4ltNCsMqKqmoM9iYZkl9Q5JqKqqxZNPngmLpQb77XcKzjjjrhZ9Zl10HJZMeQ8T7joImbPfQ964E7Bjwukqz89wuzhkZqhUiOd93mHvRirGVZ40FVpDQAMpTvayNS1gk4qYELs7Jq2x49Sk6o09tjQtsyjCws1kosjTmTQcMGAMLr30Wbz66jV47707MGbMkejdezjaI68uFTJicsYUUWtSLrpBm+70yvdjmkrKWKvsx7ba4RlC8sWIDc8HjxcjSPzZeAsxmqF1AiQd1k2RQVYNhYYyYhXcSW0SbX3NcszoiL45nCwJGmjRrXOP1jVzDmpS8ddfcpwY4Wm/z6pTKer6EVZGamM7Na0b9MSCimk9QevVDMEJgT05uFJ1JRi1tTl4/vlrkZ+/FRkZAzBlyrsIaUWrucLhE7DhtDsw6JNHsefLV2LXkP1QEi5hewnle06ByP4IAWF0paHxFVfODPeynwY3dz0TtNmUngS10RVX4tJjQ4SarRmEuP/cB062JG0kJa77eMwxk7FgwTdYvPhHPPvs+XjqqfkIC/OttZycz56KXIgDY56qBGor5Lsk279jHerqKpTduBC3avW9vY1c1CceIW4JCP8u5yeI/Hw7GbynOcjy+qR2JiYmzGcVVP4I0RfF26M0u1TVVUeAkyZTIex1QRjkQkpK58+XjZqK9ohUSCdpjkvFikxqPRHHEi6YOb5XVpJQo9MQNMRi586dqKlh10vSQ5nkOOFoAxmKON0N3tKwq7uaSHhjfv31c1i8+FeYzWGYPPkpWCy7UFnJVQCtdKNbtApde/b96L7oByRsWoKRz5+P/7vuGZhCmAOOQXX1FvTrx5QIu3iKb7zk+6WXhth7p6tJTHQEtDAut/szVNYTp4mjZbRK9cgmaQ1XiKhN9Bq8AKOje7VpsOWqkPvKtAHTERRLav0HjxH7iVx33Qhs2rQEH3/8EM4//xG0x4BKskgBKs+dpDiSfPb+MunHOVa8XAEIuahVGzUwrhuJiDyWlQIfs6+MNyDJ0K6j1K+09Foz4Pn65PXB6qRgJm+MxDI1KRNOuSMC196gdkA3LeOQNGIEuiyYeSCh+Ocfqf7wtVBT9HEl9jJ+p/6LYz5Tu7rpo2lbNkoq+eEdJOoIVmLBwbuwkC6MPLlFKCuLUgeZE7TuzMmtKXAizs7ehI8+elL9/4ILHkC/fiPsK58itWk/BrNZQudNpQ44yVhslfhz8jM48s6j0XPZHAz8bSayjrzUHmVwNp3hDclNHCrz7c3IYpWgknl+rpo5ofHzqYXQKxReTEIomq68kMF1h5roOLg2LCn1XTqil2M/kpMzcPXVr+GJJ87Ap58+hr33PhbDho2HryHCTGfom5GZ9hpUtSU50HSUh+fPSTisbohHQ0IiJEWiUBWOzxKHxdhmrzUDnq7PHg5DOSG/vVvVRycQIL4zifbKt10dRiwakguOayNHSqfUrgTOPdRTsBS3Rw/flZQKmZAUuqs4Vxo9xqnohGs3bvonjX/qJJjKSoH9vwQmdE6OKiiIBVMV9JagEpYXdE0NSzRz1MqeBIMhcqlu8DyolJUV4cknz4LFUov99z8VJ58sLcElSlBmJwOsHhDGqB0kZeCPVcSEEwSfK/l5iSqUdeuGf065HBM+eQn7f/oayvY5ExW9hqqISHY295kpCWo+6pSIlJ4WksaIRE1NoWOFLKWdEjaX1skyEQnZYL6/8WpMW/5qUZduKOarclVJR8jgzX3hxM7oj8aECafj4IPPx++/z8Rzz03C888vRVSU751hGKUQrwpx+9Rt4DsLvDZo4uXt7cXzxNU1I2y8bngs5VordaTESGY5iPBnMEcyeJ9KRIjpJqs9MmdypJIkbRTaojJUTS5Ifpk+C9bjR8M/3gMirC7tUG0JyUV+vqRFGKQbPbrrkIuqKmfvj8xMitjb9n4yjwiZYHpeQ885XFTqiraGGPHGDUjKWoLK2FRUxRsRizaeCCmJNJspLKyzW1DvtK8wY9SAIqFmSRVo3YEIFmXwpx11Xl4W0tL64brr3nIMPjyB2tlPbliSDOlPIbbSu9WkICdeqio4EBL8HL5mwzFXYMCqpUhf+Sf2f/kG/PnEn7DZwhxdA00mEgCWoHIQtdlNoCxqYOCkKayUV6vVMfFwEtIbRZT8XnweIzO6hJL6B13twtWMr3qKNFbipysix9WS7IczOnTFFdOxYsUc5OZuVH1WrrnmNbQHWD6qJ2cd+g6UVb6uVBGdSqJDkOsUkVY7CKuUS8fbr4nAb4ko31M0LBxEvSnx5XllGo/XWnMRO97nJBM0mBPvkvrkN5hAwsXxgmMSFxNc9HQkiaLmgnI0VotwBT92rPw/mFFeLt935UqxPm+tTbdNzVuaTEjUsj6ZiHP48HhCz9kz0ef/XofNZMJPF87CAT16obMQFBELRiv69euP8HCKGYtgs+WrEyEDtbQXp0aBA7F4MDgrIHji5sz5HH/99alSkF9//cswmy0OnYOslsQymhO7TPwkDLWOAdG1CoO/Y76TaQKJNrBcNBTLbpyJ5Cl7IWn9vxjy4QNYesZUx2vY3bS2VkiAdtPjgMgViBAF5+CgQ5wkDjLZiOaCBKayUlIp/K5Wa5VDNMiBlBNRe4HHmvvNYyZiTj1J0rEvUXWBveeeQ/F///e66oi6556HtGPoe4s9NZPrdXM5f4MMJpw0I5XiX/deYX5VRLMFauNAI7b0gSVMJPmTFVmZWyIhkQmzPUoh7qmSUhLhLAdh3itCmnmfhqpjIRGdxmkqHh/ej0yHkPzKveU7LY4/QbRiRY58fHve955KUUkmuIInudh3X+mUGowoLpYIzfr10vq8NV1KLZYKe6uB8nq6OVcy4U2EOXbrKlUkQKw67T5sG3YEOhNBc8qZDjGb42C1likLameIvMpFzS8TvWaEnPB37crF++8/pP5/+uk3IDOzn9cudjKw0zKch9HqGPQI+h8wZUIiQK+Emvh4/Hf1axj75JkY+OljyBp8JICDkJBQhF9/zcaYMbmIjIy2v0bc9DhJ00zLWeHBmnURafJ31Fhwk5IjaR9NYqGbMenP5gq3vcEJTiI61HPkKDGnDtWRSBx99FX48cdXVWRo+vTliIjwfUmc+H1I6FtMwHapyp9AB4kwv4eUFZbbSUaZYxN7ehIM/22VqMviJFRf02hFxqiDM6IY2kyqhPdwlT3KIVVR0lhQBLycTHnNu76P9KqhFiffrsWhaj74GjbwnuO1IJqjXQ5BX0eCJlrsekC3SbZbHz8++FqDa03Jtm0ssXfq5bxFrd2k0NXgj9euRCNpQuj9G4ZWlmHsE6fDXF2B/FGHY+Wpd8K2m/dY50U0g4ZYEHV1TFOUOBpp6YFWl2fyJHLSJcGQkp1avPHG/aiursSQIWNxzDEXOlZLUp7JSIVEKerneXUqpfEgKJGDArubJclMrb1FeyW27X8iuh92MRb+WoRrpw5S71lcnIQZM/bGxx9X4thjc3HSSdX1VtlSiVBjH4yZepFohqRJEu36ihBHGkXn4El2OHBKS+liR0qlvQYZfmZUFKM0mx2GZK7lnxde+Dj+/fcblRL58MMHcNFFT7TLfvCcsJqGWguu6rXrantCJjtXTYDN8dN53Uj0S5eftgbiuSGpOR5jllLLyl9W71rI2rA8uTMh0ZZCRZh1tYwWQfMaluoX769JbSEvgjWdNqIZXIlD4KaFvCJwTnIcD67mXTvvihbHf46Vr6BFnBx7GL3wpieSr8GKCJILihk5Zh10UNu1B/6CLVvEv6OgABg4UL6nt6itLUd19S6HdkLu6QR7h+dWXIs2G/Z8+SrEZa9GZXIPLLxxBiqqc1Bba0VNTWankYugIRasDKmpERtfmly5rt5IFGRyia/nTPnxx49g48ZliI6Ow5VXPqkmaV0iKCmMcJfyvyivWCQHPJPJqlZHnGw4cEr4WipLbo25C5+gv5pyXFFVFYnPP+8Lm60GF16oJyJZ6emurE5hX60jHC6hYk5q8vyIiARERQ1WxIKDirRVrrUPtrvVBcyBx1cCTldIGSsrRbLV4M3vrid1unJeddXLmDr1JHz55TM48MCzMGDAXmgP8DN12S6jPjxvrVnN6+oOiUSJoLDxY2d5qbcQvU+YC0Fl6iiqRedEl9paranKYVJq2pkKrFDnV4zgOk9jwmtO2teTUNjclsX5Ak4RNaN83eyCVxEw6igG/0aCQdItWhxJY7L8Wsqkg2YYVBADvhSVDuQYIQuKjr8WSCSYIqA7J/VkEydKqiRQwcuYWgqd5mGkwttMq8VSqRZ5rlVfsthLalObBmoqes35ANaQUCy85QMUhlXDWsVFKMeXzksDB80dtXMnG2VZVDkmQ8ZNgSc1K2slPv30KfX/K698Gf36jXdR5Ve6TOYs8RHfdV4AriFb6aBZ/6LgSoEDPH+fkNBfTRq8mHiTFxRsxLe/TIBNiTsbnnT5/1dfReC88zg5OvUjUl4a40KKaDm9U3Ub1aE0Tpy03ebAqSMePA6Scy2xV5jIZCv5edp2J/u8tp+DuFNvkWc/VvJl9t33RBxwwJmqvfr06ZfhmWcWqHbr7ZeaEdEjxZx0GG0odtSlnroKoTFp4OZdpyUdlXBOmPociz5A/9TlpxYLU2b1+5wIAYq0E9kYr8SZIk7kZJnssB6Xa7BERS+4au9InQm/n/SaKXQcO91JmNdGe4L3nE4PiqU9j0OZo4yXx5MDuYiNt9m9XSj0pWtrcKkMed5DQwvska3CZsfE9gJTIFzVb9oEVFQIuWDlRKCBRIJumuz9wU6vPXu2hGDvqtcwkcSf90NbCW3CxsXYw94yYvUFU5Hdp6/dloARbUbsO8+3JSiIBT3RK3jVgiet6W6hRFVVuXKEZDSAYsKDDz7PocxneNWZPhGi4XRd5EQkee36To06NGuyC0XFoIfvx4FW+nVsw+LFSaioaHpwZR34Dz8AJ53k2XFN7FstagDlvsiqLVatzjhpuZqBCTMWNzYSEpIKGXSL1CqXv+ck7MtVG99PKlYqHCFnfU4uv/wFLF36szLOYuTitNNuR/ulZtJhsWxWRI+9UUR7o8sZxTvCm/dxljlSUGi2p5/M9v87hYYtK6fkJikukkM+ltA1xYyl6rk65cUITHNhUvEn6WmvfNjpELCazSVqIu0IcyjpsZLrcCbtTO0HP5Ob9qHR2g6S3aoqEXvK4qFKXaOBKvRtOmqR6qjWaq8opTegeJPkgimE779nGTowfHjgVIxQpMkoxapVQEaGd26aNpvVHlUudEQ0pQdTik/uRXNZEfZ+/HSEWmqwY9wJWHbEWWqO4jmm+WFFReeawQUFsTCbzejTpy/CwyuUwLE5vPPOrcjJWY/U1F6YPFm6lzaEpE9YB65dF6XctP6mJ4Ya2GzFdnMrpj8o6kxEaSkbwmTbxZQm7N7tnWn8jh28EOWuc5a5SimSHrSF+SYrcSYnNQk7i6hPKlO62UOgpkb5edewnB50fRk+d5pnUW9RVU9EmZSUpnqJPP/8xUprQc+QHj2oN2kdtJiP58B1wtZRCCnjKnQI/DjYupIA0dM4iULjx6E+nXBEI+CsmnH9HloD5C7lpct4STSamiDEVKuvIo76HLODrVQGxbdjlCJfXUsEjxs/zx/EkbIvFL6Kx4OumOBjcbXlvcn9F4FsMEE0LJEqn89rqDPLbEkimBbJywN+/hnYvVsqRiL9vKBp61bp5JqT433lR00NhfT5jrGakTpeW65GVm0CO2e/cDFi8rJQ3r0v/rxsKuqs1Q5tYW1t55ehBwWx0OSCPhbNYdmy3/DDD6+oxzfc8C5iY70rO5OogKyCNCSkXeVY9QBcATPyEYmCglV2O3F6bEh30m7dvEswpqVloahIWqXTo8N1Za19DLRwU4Ph8Lq6RBUx0W2jSUTcrVb5HRj+FVOr3Y6SJ94QnHhdCUlrIVbp6fYSPymN1Mfu0EMvxJw5s1Tk4rXXrsUDD/zY7OfpiVenp5wEwuJFqqCHEjqSrOmyVCk91sLXzoe2ZdfpAp3y4jnhT9dyYjn/yR5TJfyOWlPACIJ4e+xQpJOpsrbkdBtCu65qV0B+bkPy5g9w5rQZ5St1WP1braEqssNoi1RaBVcZKhcYonmiiJP5/M5dybJ/Br0eaHtNcsHoBX/nj6mPpUsl/UHDr8GDm4+wcC5gtNBir8rTpNbXRmX9v3oOGfO/RJ05HPOufxGVkWKfQFLBMYH73tkIGmLhDSoqSjF9+iWORlmjRh3WpveT+nmpwpCLKEOtRMWJUsyMSDK4eufvx4/fjlmzolBVRdrrbiK1ITKyGnvvvUUZrzjbIserFZesQDw7L/IzSGDqr1Y3q8GFRKQhOInFxkY7jINEUZ+nXs/VTVtz4tpbQNq35zpKULn/V131Eq69dgSWLPkJf//9OcaPP63ea7XATlfzNNWxVUcXnA3Xwlz+L5OoxdJLmSTpdJJrR1Z/hFROSJ8SKdVkxKpYDV5alCjlzskeUw0cZDjYSNRDKki4Qiex8kV6QvQruXareCGSHWkl3RpIpE8iP7xHxeBOHHULCv5DQsKQejqlQIcmq3oR4YtGfW0F7a6ZGtm8WSorGLkYNsx//C5YSkris24dkJrK9gRNP5/Xj66+c5LYZLsVgW8JdtLqvzBshqSPl1xwP3b2log106D+VOHkJ6eyY/Duu7dh584t6N69Ly666EnF7KhW5saSKP1Yb2wMJv1H3P/kxkE/MZGVByz1rEJERB5CQhhiTUJhYT+UlaUrw63IyEokJW3C3ntn4c8/hzpKETVMynwLOHifHJSXU3hThfDwWoSFSWieE2tYWPNCQnerVZIFDiyMarhLdUj4nB4abL+7SxEMrnI4+VKX0JbcLBm7kIMae0pEwrFMf1Bf8fHHD+PNN6dgzJijEB4e7tYXX8NZQaG7tlLfIumK5iB25jRJylHESYzDugWQo6JTlEii0NDHglECd6FWXSHA5zBqIYLFbDvZbP3qnGkPrs5I1HxtFd8RkNQgibqYjBUXr1XkglocEg66dfqzL0jLoxZbHGXn/jAB0fdh0CAgNxf46ScgOxsYN04m8s4CPTdY9cES2dJSoE+fplMfoqMoVPejU0fBRWC3drkXwovzsfeTZyKkzoIt40/G6oNPdURg/e1aNdm8lb37CCUlJUhISEBxcTHifdj+jbmwGTPEYpWLDV4Yrtu2bb9izZrD1XNjYn5DdfUhiiC0FRkZO5CUVIDu3fOUNTfD7QUFiVi/fhAqKpw55uTkAqSmMu8Wik2b+qmf9d4HOXgR16IG4TgHHyqqYTbXIjm5EElJ1AZYVT4yLIyC0FRERsYiMVHqxV1/UlikDWp4aiV6IY3NdFqgKadGrj5F1V/k6E/CCbgtDn7SAXWbeswUjI6E0D/k2mv3UFbqJ5wwGWeccYPjNSKm1ZbN2jip7TereBjkqsecjLXTaaBB1P4F9co5mxvUREicq0oy5flxKsrQ0lUVCaI2keN1EQwrfKYci4pWqXuFx4PHkdcGf/pbWqc1IKGW/iGxanXrT+CijuM3x7C99pL26x2pveDtw88nocjKkggF7ck9P9+mjiXvA+0cy4md10q7TfB1ddj3oWPRfclPKOkxEN/d/xHqotkHq0cjLVNZWQV27QrFuedG+Ly819v5O2iIBSfTItGOuQEH0pG0NgFwNYCXGrHnqCjZeEG7PmbZJ0N0fE7DnxERVNxnITJyK2y2CFitEaiu7omqqn7KVtsJRhs2w2KxoawsA5WV8apVOu1gCZZfHRi5ADPWj4cZdbgu7l28Y71QlWfx7ISGMipCglGEkBDRW1RWRmHXrlRUVjZOVzAXSJJB9s+te/cqZGTkICGhFnFxJqSmdkP37ly5eD6eohtxlrNKMzf3EQ9vwPciWSG5iYvrK0elphjz53+GZ565XJWdPvLIl+jbd5RXvvhtAVcZzuodTh6duExqIxqXs4XYdTKJHid76YApZFP8MBhGbV7wJW6weY6QbyATM3dg9LG0NEsdT4qwIyJS7ccnvd1LZTuCiFJMzXPIKi1/W+FynNu1S1IjLOUcM6Z1jpYtBSMmy5YBa9fK/3v1avozRfhOHYWMixzPeB+IN0v7ketBHz2EobPuhyU8Cj888DGKeg1WEdiGgmymZQoKNqOoyIozzuiFXr18e912OWIxdKgod2nKolfwrDdmPm/Vqquwfv1rSEhgg7H/kJoaq/5GERHJQ2tyezyBu3f/p0KMumVxYuJg+wrH1TnTpkLPvCAZjqYGQrP0M8+U5/zvf7Ifg/43FUNn3gNLVCzmPLcEZekD1fNIMLiVldWhpISunoUoL+cgTzIVg+3bu6OwMFyVRXGj2KghSEjS0/MQGyur1crKONTVpSMtLQTp6ai3aYGV7o7K/LxEPMytDrtxtUy9hzRskxJOLUqdNu0aLF78K0aMmIipU2d3yOqX34tlwE7BYf3zFmgQ4RhTXtrXJLrJMlMRdOao61i61GY0qY/g+ePzxaOFpbxpHd6HouMmYHZDpb6n2jFhSBO/wI5eMFKnDcMYOfRHMIq8Y4eMj1xwsQV7376+jWCwpJ9zxerV0ueDn8VW5005gwqBz3dE+9pTR9EQqUt/wX73H8nJGn9e8Tg2HXCyuv/c6eYolq+oKENJSQTOP78PUlN9O6Z1OWJBvcMHH8hj1/APq0DuvVdEmpy0Ro482Cefl5+/SK1udOvw5OQ93JbX6dUxLz6u1PVA745YkBGMv+dQpKyci8LB++LPx/+AzY3JiYiFpLxU0hUy8HH1aLOFKnJB9s+NymvXn9wfs5kpGZKGCOTk0Pug8WcwpcKVAxl8r15V6NlzB1JTa5CYyJxed7cXdVPgxFRevgOlpetV2Jn7SrZNw6LCwgKVEqmpqcLNN8/CxInnoCNAnQBX4MES0pfUly57ttp1JCQA7u8zXkckCyQZosVwf17l3G1XWhm+p5CQzi8lbS9oV07Jm5sauZ36rGywg8HJkWMWrxMucPxZaMvxnASDiye2ZKe4k2MRFz2t9b/guMjeHoxO8CdJDN+vqWlIUsMF9QzfxI8itUM0RZG7t+OgKWMQUZyP9QefgfmXPOwxyqrHs9paE8rL+3RqKiRw1FbNwN18wBz+Sy9d4agC8QWpYLh09+4l6gYlGFZMTt5TiQgbQgsWCcl9NxPXCw3Fkpvex0HXj0LSun8w+KOHsPb8hxs9TSIHLC9li+T8Rm6LiYnxSEoyKXFUYyShujoSO3fmoKCgGoWFW5CTk4Ht22NUjTlvZmpSdPSDpjAA9Q19kJ6ei8TEUiQn5yE6uhqJid3Rp49JrSjI+N2lVjg4iyi0QE1kdJUEqu3lUb2VMDE9PRFnnHE3PvjgXrzzzs0YN+4EREW1/8TFSZQTpegOGN6nFXtGwJILEe4mOoSausyUPymabfi9pGlbpv37l9j721QrgqGfK6Rim518UH3ey+/C6L6G+A6kObQ4JO1S8ivRjLYKXzsLOrIqqbBd9j4t/nmtMx3BNuSMvubnS2tyCimZ2uV4Q7LBeY0Raf6+4degEJNRXo5hhYVSgcLxraREorE6KtscSaeYnWO+87ro3mHiV1OdBXs9dbYiFQW9h+Lf8++266hSPcw1OgLLZnudK9ANGmLhDh999JBqepWS0hOTJj3W5verra1EYSHTHxQimpQ5VUrKKLc3p85Hc2CWXgXerfAru/XGf9ewC+pZGPTpo8gfcyQK9jiwiXJCd26LxUqU5ylvzs6iPXv2QVISV6FVGDNme73BkgJY5h7J6rdvl5/btoVg+/Yeir1bLLyAi1BeXotPP+0Bq5WlkRK6pJKaN36fPjb07FmEyEgqpi2OgS0hYbB6D/6OKRZdJXLqqbfi11/fVefr008fwwUXONvKtyd0W3pOwAxzchCJienRqX022gpx4WSZ6W6HEJdaGVlth7s1M6MVvja54sqWUTjCSSpC7aQiMFfrLQVXpc5+J8XqGEmjszKHVwxTTYF2nbACRvdS4Xfx97JrLlZ0ipbRC5IEdk1l8EDr4bRGjiltEhGSCl3Vx5/6uUyR832ai3hI59F8R4k77xmxx+/YKN3Q9+9Gyqp5qI2Mwdxrp8EUnazGdfdzzQ7HXBMa2rJocnugRamQxx57DJ9//jnWrFmDqKgojB8/Hk888QSGDBnS6akQhrVmzpTHDP9s2rQUN900Vk0Ud9/9lepT0VqI1mA3iorWqoGGkyL7cgipcH+V6rAU/07/hoYDuttUiAtGT7sImb/NQEW33pjz/DJYYpu+WJwVILvsYXCuXlNUHtDTqqShGK85rYFePWzfXqraze/aZcW2bVFYsqQnKipkgGVlTEJCMZKTd6syW64KUlJIKFLQq1c8BgwwISODRGib+hxGLfRkNX/+V3j00ZNV5ctLL61Cenp/dBR0u3ceu5YIGv0dYrO9Q90HzaUxxJdCBihG4Gw2k9LEcPKMje0VsCmA1kIP2CSccgx62/0gdrpUWWUEXASHYxjHCV7fsbF9/TZq0RQ4a5E4ULB/hQSlMW2ajKMkDhTdcyPh8Lb7qJjQ5TsahUmZt28MA1uKtH++xrip0tdhznXPY/t+J9hbI4R6rNLi35hur6kxKy+Os89GYKRC5syZg2uuuQb77LOP6s9x11134cgjj8SqVasQ40c9cevqLHjxxcvVYDp+/OltIhVctTC/zCgF69t5fcXF9VdGOp5IhWggJCwl/gItn6CWXzEdyavmISZ3I/Z85SosvuXDJlvpaf8KThqSZ+PkvUtNFlxZuQvfyWpVIhu8obSvvSetgXP1QHMhszouNlslQkK2obS0J7Kzy7BzZwHy82vVhb1zZxiyspKxbFmCmqQ0wsNjMGZMPPr3L1Hpld69+6iUCs/TqFGHY9myX5Tt+p13foaOAtMHvHF1cyqGvJsTNAYCuP+hoX0dWgqeM+ZoSTobnmMpRcxUYmOWJzK/HBmZhri4rkcqXPvN6L5BbGYnFRWRDTxBWq456kxwnHBam4sjZ6CBl66OQmgwHdsakaf7RmFcZCV3SkQqKjcLo6ddqB6vPnIStu17LGJjerndF+1ro16nXHX9IwnRor348ccf6/3/3XffRffu3bFo0SIcdNBB8Bd8880L2LBhIWJiEnHlldNb9R4SAaDwMk9NuqKeN6tBVlwpPa9SnCmQKJXTbA1Yo7z45g8w4fYJ6PnHx9i519HYdthFXobBe9lz5kyPVKnKlabywhLVMLtoDWx2fwPPREbbgnMCrqkpgNmcgyFDEjF0aIjdGplC0gRkZ5tU8yHmONnhcONGCU8uXNgdu3aVIzS0Grt3F6C4OAV9+5qQlvYcTKbRyo1zyZLZGDPmEHQUSL4YXXJOwts8TsKBBK2lkFQH8+u7lQEZiVNDcsxj4KzYsdm7sqLLQqI8PeyVIiQSOer+kuuEVuCl6n6no6kQcv+vGpGKhhS134zESjowsFI6vkDDKC+hNQydZX0eUlOFsU+egfDyIuQPGIUl59yqoqfu9ocLZ4kw2uxCeP9Ja7WJ3jAcQiQ34XlaXV2tNtdQSnsiPz9LiQCJiy9+CklJLbew1RbXEvbcpW46sznC0e+iKd8DnYfVJXltmZCKhuyLdec+qEpQR756DQqH7I/yXt6lnXihMd8m0QtnXpiEwV2vCBlcQtSkKsy96f2XXhYV9iZfxY4bkxoK1/QLBaSuIlKWelEgunFjKLZs6Y7i4h2IiNiN0tI4bNgQjg0bRgC4SnmNPPDAFAwduhhDhoSC2Tb69VO85bpLVpsVeTVZyK3ehDxuNVnIq85Cad1uVFnLUVVXjmprOWpt1QgPiUJkSAwiQmLUzwRzd6RH9EdaRD+khfdDesQApIb1sgsad9oHHemlIjqEzu2z0BbI9SjCM31NkHC6pnw4QHGg4gqO5168WCjezLYb8QR29KZtxKyn3apf+vAw0kctDleLerUrZE360Pg7xGq/0C76KwgYF1pfoaFPj4zrXDB2bmRuxOvXI3HDIlTFJmLuNc8hMr6Px0WsdBKWnlJyvyLwiQVLBqdMmYIJEyZgxAhOBp51GQ8++CA6AhwYZ8y4CtXVFaoC5IgjLm3R612bcmm7VpIJqWTQLpSeVyVkkMy/ElwR+EI9vP60O5Dy32/o9t9v2PupszDvqfmwhke2aEDU9sucTOrqNtvzwo0l0fyu/JsIGYsd5Kjhd+SEK2kTabrGChWKQHkD8NiRWHjeJylj5QbEo7ycFt5lKC7ORXZ2JjZuNGHNmgexcuUs2Gz/YfXqN7F69ZWO1yf2zEf3vf9CRP9/UJ70D3aY/kWlVWrLfYEEczcMjt4Xg2P2Rf+IEcg09UGkBfaeK00bTwUCOKFQqMmwvk75cILk9SCpM+oJeE6l+kN7V/D57lz+ugp4L/P78zjw3qCdPEPl0gxOp0aq7WTN/8txpby4m0qNkWA0bGoYrJBOvLsaOQuzH1Nn39eZv7yDPj+9AZvJhHmTn4YtcxTCPTQwkypAWcC6izx2NlrtYzF58mT88MMPmDdvHnqxwLgFEYvMzMx2EW9effX7eOONSUr8N336cq/acWt7Vl5ouisdSQTNcXQHTAkHW9Wg3FQTH5mQSxwh9aYu1ObEm66I2J2DiTeMQkTJLmw6/jqsvOIFtBQc9KQLZU2zwk5+B+nWKmWyHECZCuLqzDU6wePD9+BNSeava/+FoPTw6kaV2vrNdm1Hd0e65uuvp+PNN69HZFQq9jzsc6wPnYPC7t8APRc0eg+TJRLRNf2Rau6HvvH9MCClHxLD0upFJ8JCIlBjrXREMaqsZSis3eGIcOTWbMLO6s2oQ32fd7MpDEOj9sWoqIMwJvoQ9IgarMiWP/RbaAsaeliQWJBAEK6OfjqKoQkHy3H9KeTa0XD1PiEh050rXY8nwftCurz6NwllTyBpyhevznugoSXjqERuWVJtafe+Hi1F/KalOOC2/RFaU4Wlp16PtWfepRZs7sBFXHk53Z5tbo2yeEwCSrypce211+Lbb7/F3LlzmyQVREREhNraG/n5+fjwwxvV47PPvr9JUqE7XPJCs1ikxNC1MREHB7OZHUtDERoao/whpHuj53AhB2Ut/vG10VJ1Sg8snTID+z50HPp/Ox27Rh2OvBYKUjXZkSqQEsXapQSxcckcbzhGI5gO4GCp279rDsoVmhCKWMf35OqW0RGSC7mBc5vVaTgtcVl3naf2ie/J34085CDEfZeC0h27sGD3QcBRztck1uyB8J37omL9vihbsy9s+Xug3GpGud20fXGcGOpwGz5cOil6Yw1cY63CpsqlWFf+j9rWls9XxGNFxTy1fbD7UfQMG4j9Y4/HIcmT0DNupF8MSq2Bq4cF035cubIhV3x8v3qGWnpFVFlpsut2SDglp9sVwUGclTJcMVJjERsb5uhj46pj4T2jS3z9+RpxNigrsUdfApswuwOJhE7/EdKJOs1vUnthZYUY+9gpilRsGzURa067GdH2MvyG4Lgs1Ws2NVf5q2i4RVc8v8x1112HL774Ar///jv69WNPDP/AzTffiLKy3cjM3BOnnHKL2xNCwiBkosxBJgje+Axx80QJo61Vk62e8AgxGAptormTPE86i/q+/Gzn2GOx8aSbMOCrZzH6hYtVCWpVatOkriF0uaGr9kKqH3o0GlCY/pEbcqc9bCppACEU7m9IsZHu4dBpSJjR/Q3iCkaCSN5Kanbi9x3P4I/SL7CuYgFwKAC6qS4ARh12GA7ofxbGxh+HlHDxWCDoKEonPbY45k9a9NLga8EC2Vw7KWqiQft3Gus02o+QSAyN2U9tGtur1uHf4m/VtrJsLrbXbsCnhdPwWeELGBE1AYcmX4AJKeci0uwfg1RLIJGrVIcAjGXUPOfazdX1eVI/b7I3cZOSVH8d1NobHBdILqS5HitF+qgxxKljibJ3Fq6wp0b8r/ukBjUFJImy2Mh3tBwIBrgrwZdqjxT/SR1YrRj97AWIyduMstSe+Pua5xEd28vjgoy6EM5PUursX7qKVhMLlprOmjULX331FeLi4pBLFyUl2KMdcufdODk5Ofj++2/VxXLRRW+ohlY8+Az/8+aWtt3123AzGsEVmrROFr0B86dO22I2E8tzMEMd8nQH3eVON6RpL6ye9BhSVs5R4p69nj4Xf0/9DbZQcxvy7JIaIbnQ1s8cLLna4nGQYxTlyEU21XtCgxEHTkKcfLhy4/ObK2fbWbMFXxY8hZ93v4Mam4SSQ2HG3nsfi51LNmPzqv+QMLc7jhp3eaPXMtQ3frxs2gqYlSfsA6A37SDK7TN7BSvNvEgyNNmgE5+7e7ln5GD0jLwJJ6fdhDJLEf4p/gq/7HoLK8v/wPLKP7B8+x94e8cdODr5MhyfdgOSIpykJzB8GmioFmNvQ2+2p7os9lSWc/B1ipFD7Db1efaBOvj6hTQH3apaKkWq7eQi03G8mCoiUdc6Fl+0qW9PcMxiqov3Phcb/q4P8QZcREq1joz7HMf8MYU58JOpSF/4HerCwvHHlFcQ3n0Pj6SHIlunBsq/TfxapLHwxKLeeecdXHRR86WQ7WWQxa+wYsVqPPvsL9h335MQG1vj0AG4gpoAkgiSBK4qnLbFNrtIrcxhW+xaESI9PsweL2AOMERL/Pdbkht0RXTOBky8cQzMlWVYe/b9WHfuA2gtGLURAyCKOqvUxCp+BSZHWohRCn2DSjqlt1ds37XJF28Cd3n5jRWL8XneU/iz8BNYIREkphomxp+BI9OvQ3JEBjZuXIKbbtpbnaNnnvkXgwaNbdF35NWtGw6RWPAn3UTddcclyaAOmW2b6SDalEPfjuqN+Hnn6/it8H0UWESPEm6KwsHxZ+DEblPQM2aPdq0OkAhDnSK0vNb5WH5aXdJWznJRudRNjnOrow8i0hXzJz5Xd33lueb17O6653NILnQko6umRXjsGZHgfeROV9S4TX2835akapMl3X3YH/fRm3E0PFw8hJyeFIw8d47JVXNIXfJ/2O+BY1Rzsb8vfww7j7vZ48KNcxMJLOGpAZk/aSyCpgnZ2rUb8OuvMjkxzM2LiKswEgiSCTJWd4OkXrVJ6N5krxk2qwGDf3PXmtb1tWxFzFVJQ2Fn/dCyDPoy0Ieom5buaOeeS3fDkBYRC6Ln7x9gr2fPhy0kBH8/8ht2j5iI1oKDXmnpRsWG9YRCV1HqSfRF7jqANidg9TQBiR20RIayKv7D+zl3YWHJd47njo47Aqd0vxUDTANVmNlVTPbccxdi9uz3fNb9lBEMHc0g2WCEg+JfV/AaYiSDRIMbbcrdOfjV2Sz4Y/cH+DzvaWyuXqF+Z0IIDow7BaclT0Fa1EB17UkePsyrAVuTBiEOcv3wHMhj/pStLbcuiaLuYyPpOzk3fF+eM16rQi4yFSlkhEv23+QIyTLMrFdPwbDKbQ3E7yRbnQumCd3psOq3qY/wy5JUZ/fhWo9NrvybWNgwcyYrPVw9KdgsjOOY/63sI3dukeZiZYVYf/CZWHnDex6jKVJttNVeQJDYbArEIBY+JBZ5ebvw9ddcjYUjNbX+IOgJrpbWeoBkWJiKWypvxYmwpxcsX9qJ8wKgUQ5/cnJsauBnyP6JJ/gzHA8+GIXo6BgV7fB2pTDq+YvR+9d3UZnSU+ktauNbRk11REar2Lm/3G/xmo9olBeWfHG2etwU2XJF/YqCUJSHWfDRzqmYU/AB19EIQSgOTDobp6Tdgv7RoxspnnnseQ7y87MxefJg1f30nnu+Vk3KfAkWLVGbQZKxYgWwZo3cnK6gsawr0ejfvz7R4P4uLfkZn+c9iWVlv6rfhZnCcXj8eTg+8QrEhUoYXHLx5nqDnZNINIw4NA1es3wvXjM8vvJTtobRCSG18lmcPBimJ1Hh9R4RQWdUq524SPRD0nsWhITQTEkMg/i+QtJj1E+aK7kScn8Rw3U0XKuoSLrdpYfqt6lnqjW9yfRqZ4D3KQ3AeD5p9e1v5McdeJ9eeGEFunffifvuY5t7ibo2Z2LYmTDVVGH/2/dHysal2N13D8x7/A+ERLtPk/F6kUWdxS6Qz2x2XjOIRTv2CvEG9UO6UkanffSbS4FwEi4uXm+vIIl2+zw98MvfZJDXk0h1tQWPPy4RlttvF4GhlP3FqoGpuc6DoZVlOOimsYjdvha5407Av3d/1aTlt3O/a+yeFuUuLnxJahMnN+ouqt2WpDo96d33P3EHTlR5JSvxaf7T+LXkQ9ShVv3+gMQzcX6PR9AjsnH1jtiLF6jjxugJP2/GjDvx2WePo1evoaqUmDqa9gKvpQ0bgJUrhWiQcNAt1BWUFOnUCTdWnrAJErGmfD7e234HVpTNkeeGxOGExCtxVMIkRTa8BcmHEIdQdSw4ubtu8reWRW94/UljsQq3qS0dJRHtAF1Vy9TvSCQZAay/f2F2YmqzN8RzRqW6Gpz3Rv3onCukJHWHoxeFP5akSlVXebOLKn+AjMH5ePRRGcvuuINjtn+mPVzHw2HTL8KgX95HdUwCZj/1J2p77QF34H3HxZykocMd3aCbg0EsOpFY6MnLdQWuDW6aSoGIv36xSh/U1lYoVbW2fJa0i4S9xRrZ88DPk3/OOezFUIlXXuEgL22ZNXghUcGsHTE91j7fsi9CLTVYfsUL2Hz8dc00UitQq0yt+ucNyH13JUW6wkXnKEX0JP1EmpuU3H3mbwXv4d3tt6JYdUQFRkYfiIsyn8GgmH28Cssyl8icYnl5Ma68ciBKSnbh6qtfxdFHO02z2htsvkY7cpIMkg1u7ADrClZUs9pEE41Bg2xYXvkj3su5E1mVy9RzekQMxuU9nsOesQe5pMYIZ6TBGXkIbZfBkSkvhuW9IYfSMl0EzYSEx032FuKVdpIs1xUHQU6mCQmDuqzmQqqhnA3L3B1bHi+SED328P5idNBfSlJFzL25XsTQ36C7znIclsivCUVFCZg+PRVRUf6X9nC9n7r9+AL2f+VGZYL1992fYfe4U+AOrmMtrw1eT94amBnEopOIhY5KuAph5ES6T4HwgqB4hheyVJmUobqa6ZMQxMf3t5eqxrZI8OROvEkBJSd0VxMqMlS+P0mGO7ba99vpGPn69agzhytXzpIBYxo9R9qpSySCYMia9rVNTSrcB0Z0pEwrxFFuKixaQnNN6S02Vy7Hq1uvxqryeer/PSOG4LzkOzAian8VAha3OM8Tp2vqRRo/ReHbb6fjdVreJqbh1VfXIzq6c0LJJBrsf0KiockGS1xdwc6KTJ2M3NOK2mEz8WPdbSiy5DmiNZf2ehYp4R27IpS+MZJm8hSyb4j6wmapDOHreB2QWEs1QandF6XasWJnbpsRQH9WrvsaQsRoOFVlX2FmeiQMPGb0weBrdCrVX0L3zoihfwk5JUVHkz66/urUXhwuu4xVLeEt1qp19L6Hrf4ZR9x3Csw1VVh95p3YcP6jHp7rqvsLsZNU76tZDGLRCcSiPqlwOj26S4Fw8hT7aoqCJG2he2MwOsETTlfK1qCpqhAONvwMpmnIzhumLOoN1jYb9pl6MtIXfI2ynoMx99lFqItyrjLE1EiaopGYkFB4u6LkZ+tOqQRXpJxYKEoVl83GkR2aTH244wF8kfe0qvSICInG2en34cTuN8Jkdb7OG4EYB1451tLe2WKpxbXX7oEdOzbg7LPvw7nndoxVfHNg/5PsbCfR4GZvo+NAVFIR4k68D/l9X4LNZEVkSCwu7Pk4jkmdjJAOGLhFaLxFTf4tDXO7apEa3jfOe6IEJSUbHYMhiQXPmzbx6SrdUSUnvtXewyFStZv3RK5cCb+22PaHklSJGGap7+IPQk4ZD+lHIZExPRbxeFkska2qrutIWK21qNm5GkfdeyLi87Ygb8wRWHDfDx77ubum6FujXfIHYuEfVLSDIGFgIRWuNzFvbKYI9KDJC5mq99LSTYpw8GLWHhW8oCU3mtJug4AmEdQX0DaYA5R43O9GSQn3icpnu8GXyYSl17+NytReiN2+DiNfu9ZlMtjpMDPifnNybkmYWndK1SVy2vCHxys8XAiVNhQj1pf/ixvX7I3P8p5QpGL/xFPx8vDVOC39doSFSKmvGC0JkdMTlSdIZYpZDcA8P2Fh4bjwwsfV37744mns3p0DfwDLUlmeetxxopd57z3gxReBK64A9ttPhJ+VhYnYOeMF2F5bCGTvpyzFX8u+FlfPPxxLNzP03L77yPQHz5s4yLasMZ+OVOjrndeVvo/k76Hqb6mpeylSzkhFbW0x6upq7WnDLQ53xw4uQutwiAOnlOmKzf12t6XvhBDm3nanW32/5nh8fkeB97o2thMH0foeQB1rcMXrZ7OKonDM02XQ9A3p7IZh3sBCO4KSzdjv1ZsUqajoloklN3/YBKkQ51aC92mgCqL9I7HXAdAlXwQJgo406MoFKQWLVPljrfAmGJ4kkaASnu6QenXha9tud9BeEtwYitbhZj0p83uwTwcrQhbf9AHG33MIMn+bgfxRh2LtPofUy4176gviDbji5AXOCIJ0d9ypbnAd1Sku24xvS991EAp2Db2m92vYL/HkRu/FQZQVKPwOJCUUBHoKAWvnTirVOcDxOOy//6kYOnQ81qz5Cx9+eD+uvfYN+Bt4mHv3lu344yV1wrbx//0HLF8+Bitm/YmqkS8Dh9+OnIjZuG/HSER/8gzGhlyOPUeasOeeng27WgOeM9fBqjXld9pVkudECxU50DMCpq8rHbYtLzc59EKMjvCeYnrAYtmBkJB8RUKkmVtwrmu0kFX6cEg1CFee7u4/7YbLCChF1dRo8Nh1dkmqc9xhymZHs72PfA3dYVqTGo41erzzV2FmQ9SoaHEuhn/7OjIX/6rS1Qvv+MxjBZ+r7k8bFgYqgvPObgBxCtzpQiqcJ1bao1cq3QR/atEiB0QOktz4WHpnCDFh+V1H3/SyP30cA44ozHNVTpcro4IRB2HdWfep5458eTKit66wm331tFvYtu1mZPSCqwTpLRJiL62twZaK/3DP1hPwSd6jilSwfPSl4SvdkgoNCka5qtX5e90UqKkBThNA4uKLn1I/f/nlbWzduhL+Di5OBgwATjkFuO8+YNYHIXjy9Gtx0o5liNl1ABBRhorDrsTczGPw4jt5KtJx+eXA888Ds2cDu5zBgRZDegvYDbyUFqhtKyBeS7rjrTTkyq0XhXBdsevPZ6SM950moryPGHnjz6bOfSBDVtYkEyFqkqQRXVPRGpJ3rcnQInLd26KzQCJJEioRXZnw2htSjbRNbbKIk9YKjN76c7WHO4FuRcUOpK38G6M/eU79fsUV01E8aB+vSEWg2+UHPbEQB0hNKlLqkQqW0nFVIfbE4nvBgZfhXA4Kritp0SkwFBfZaXlQqeSIUwM10wSSnqhUoWambladehNyh++PsOoKTHxxChLCUn2u6ubNzZucEZw5pZ/h4bxJyK5Zi7iQJNzS+wPc2u9DxJubzslqx0YOvrorZFODrusAxxt22LDxKnJhtVoxc+Y9CDSwLJUVJJeeMhAzj/gdF6U/BzMigYH/h9BrRyFk4M8qR/rrrzQHAy65hN2EgZdfBubNA4qKvP8sXvs8xiSjTTXRawk46GnxrXg41A/f6xQaJwVenyTvjJjFxfVXxFQqjFhyXaBy+fVSe0EEXfEhx6m0EQlz93wuHsRGXypyXFNOHQ2JEuiUyG6X7s++h1Sj7bQTqnJ7ubukgxldDpToloxn21VEL7ogFwe+fAtCbFZsPewibD2qcUuCYCQVRGCcrVaCN6WOMjQUIXG1VVCwVKUUeCMz7MTBkFtDBS4HT62KlxV757Jmuek4UDs7UXLw3lW4FL9f/jAqE1KRuG0dRr3ZuBmbL1BpK8cr+bfg7V33osZWheER43BvypsYGTrK6/ywhIDF7158/YX8uYOrLkD3MbnggqnKvGn+/C+xZs18BCpCTaE4tccUPD9sMfpEjkRdVB5s5x+FAx64E6ecVquap1HDQRvyH38EnnwSmDQJuO464I03gH/+aVz6qiEVRmJgJZ1mfXe7izOqhPfFbnhbPXLgXLHL3xnm1yXOJMaauDu1Q1n29Ern6gt8DS5UXElYc+RCd0l1FZXrVG1ngOfZGV0UvZavweNCgsnIsu7NJIsnWVAECqSp42ZFjEItFhzy4s2ILNmF4n6jsOKqlxrlNrUoOthIRVATCxGY7XZJf6TW6+1RVLRahfI5ACYkDFYrBXdhYt3hU4fw/amJjZSpZagbkESJYrmS6Aj8fe1Lyu679y9vo9dv7/n0M9eXL8SNq/fCH4Ufq0ZhkzKm4s7MWUgwp6ioSWHhKq8HH65ctW03Vd9NiTkZedHlkUwB9ew5CIceKv1p3nvvjoAXBWZGDcPTQ/9RVSJ0JZ2Hx7F6v4m447GtqtrpnnuAE08Ua3GC5a7ffANMnQqcdx5wyy3AjBnA0qXiJFr/uk1ul1JG3i/iBCjkkNE/19SGXrETvD61zkMig5JqJMHgPaXdPjnBSLl1YJ9PV7iWV7uL8HjSs+hFDF/TkLh1JDjhMQqlq8R865mRrQiLjqrJ4s7/LM+bAo8Lo0vcaDIYGhKO8bOeQfKGRaiJTcLCOz9HXUR9wzRN1HhfBBupCErxppwwiqCK6pXGiakKm9OU2rudVik2npQ0vEm3QFlh0PyHKZDWlZa2JyiKI4FiRIaiSN6Q24d0w3+nXIdRnz2Pka9MRtHAsSjrPbzNn/XzrrfxavbVqLVVo3t4X9zS70PVYlwJX0MiUFy8zt5mPUSFvb1RbYunRqo9utS0mJPnkudOBridOOec+zFnzgdYsWIOliz5CXvtdRQCGREhUZjc+2XsGXcoXtx6GdaU/62qbG7t9zHGjTsU48bJ81jKuny5FoNKNINt47mxe6vZbMOECbkYPLgO/fpFYsgQH9ecNQrfZzpy4tT8iMYizKXbbTcVOeQ54+9d03N8LMLoUhVulxLMXISGFvm1LXPryIXJ4QnC4yURHc8rctEUmNVrtK+Lp8Zw7QnpbJyhzi1JDoWmbZkE3bUzb+jyGwggGRJbeyHCOpI8ePan6PvLO2pxt/jWj1CR3r/e6+Qa32Fv/MgoeIbf2bu3FUEVseDJra3NdWmORBOgRDXxsmSJpEIag7HRTppdK+CZVIizW7lLKNnkpw2Q2F0xBsnJIx0e/8tPuAI79hgPc3UF9n7iDIRWeYiXe4Faaw1e3joZ07deqkjFuIQTMG3oEkUqCOkt0Eu5LkrVwM56oc3mwJtRBLI63Op+ZaYV9HoVl5CQhGOPvUb97b337lSai2DAhKTTMW3oUgyI2gslll24f/0R+CLvGcexTEgADjgAuPpq4JVXgLfeAqZMAQ45ROrWY2OLsGNHOX7/PQQPPJCB884z4cEHWaIrDdd8fZh0szKSBr0KdXWR5fnlfUiIpXX9RiySIol3hL95DWkzLxH3SjlzoEP8Q1wjPFvrHSf3r4lRxM1V1NkZ5Z9SHSdRX97fuuKsdav7bQ7zPY6/oqNou8C84+YYEsMcZUcgHkc2Rzl/RtY6jHzjevXc1Rc8ivwxR9Z7PecgOYdVKs0jHbGDi1QEVXfT2lob3n6bZjNliI+X3h+8UEW8JgMThZdyU9rsuU/3JWCajXJy5MVPVXJrjbB83TZdQ5p1ZTtuTq1Ad1Ulm3auw3H3nILo4nxsOeR8/Hfj+y3ez901OXgi63S1ejbBhHMyHsSZ6Xe7NXXi5/KYSbhUuj3KijW92VUWv4fccDXqRmM4tPm+DKGw2WJw5ZVDUFlZiltv/QgHHngWggXV1kq8snUyfiuYof5/YNJZuK73W4gM9VzZYbFUY+vWLcjKsmHFijQsWJDYyBWUnVtHjoQqa+XWs6dvSlt5z0iVUo2jOkSnDoU0bldEvTmLYoaTeY511FEMt1hJlBQQk4+3lQ/OhmQZzYqs9YTMY8vrXvqRdLyPA4khST0nRaaPvbWZJjgJS5dX7ebbrc3h/7aOo95Ct3Kg5UD9dB+NulLE32h3Dg66aW9EFuYiZ/zpWHT7/xw3lozJNL4qancrd38wyAoKYsGVanZ2Dr77jqtyE9LS0lTtPNmhU91Ml7YKdXHIwNanyZOqm/F421GuI28IWblIpKIhqXAFv2/swi9x2GMXKGXygqtfQO5R13r9XdaW/4NHN56MQksuYkITcHPfWRibcKxXvQZYccOPYZhba0Gaa1DlajndVM7R1X5drL7fxaxZ9yMjYyBeemkVzGbvBzt/B7/r97texpvZU1AHixJ43jPga6RF9HX7XFkFV9n1D71UdIJ6jGXLJHVC+/GGDdU4+GiSwa1bt7aSC0mL6BWZdt0U8rjV3lSp+V4zfB5Jqq5G4PtIVYn/6JxaC10Npb+bN14zvN+ld0ulo5S8o5u+yTmUEndxFuXYGNJiB1+ex5aQks4gFtLKodTeysF50/C6pp8GU1X6WjTV1mD83Ycgec1fKOm9h2qvoB2QXVMfhJgrtl+Exh+IRVCkQjigWizC/s3mJPtqp7Re9QRX0M726BlNkgp/ToHwItVCLiE97kmFvoEr9z0LK8+Q6pC93rwNoWt+aTb8Sswr/B/uXnewIhV9IkfgmSELmyUVBNMwLFHjxCaN2Ex2m+Nse07VM4/lQKVFtq7mOA2hu9Hqctujj56EhIRuyuqb3hbBBH7X47pdg6mDZyPJnI4tVctxy9p9sabs70bPFQO1KruxmFTRsKKkXz/g5JPFQ+ODD6Sy5PzzJWrBrrq7d4tfBn0zLr0UuPJK4KWXpLS1oTV5cxDSLq6IjDxokyj5LjIZ6rB+c9UOOsUiIkadHtlib3oW2OJOZ/WHkGfxPWhO1KkjFdH2clRZ/HQk5BxypS3nozkxp3bOlPFUHD1dNTj+OZdUqGuTFvViCljpEBzz+o2LG6C+hyvBHfHmFEUqamMSsPCuLxykwl3qw9862rYHgiJiQVRW1mLGjFxYrRUq1Ct1+1wlS/pDVsLWRgZZ7tg1bwQ+l6Kz9hJstoZpc9+kD4HFvuKTfK0XL8S4+w5H2n+zUdRjAH588BOYE/u69ePg5fBx7iOYtUPMtvaJPx4395uF6NCW5QH1oMcBhAOhrviQEGCGx4HFNWQu39Gz4x9vWg7GxJw53+Ctt25FcnIGXnttAyIaqLCDAfk12Xhk44nIqlyKMFMEru/zDiYmn9OoaRsHfm/ztqwgWbNGohnc1q9vrMFgJYqOZrBza7QXh1ZPfO5W105tkKTLvPHXkCqXPIdpFIkr7+9AKkdsuuEffXJs6r4gkWoqEtGwMVxniP94vTn7/jQeU+V85bpEKZxdkn0JX0UsVD8PewNIV02PdJlOUBEKT4vRzJ/ewugXL1MdSxfc8w127nNch6Y+GsKIWPgIjFbk5LDURwRFFIqJ0Yz02NArAQ5GzREF3bBLvC06vyFQwxCzsyzLS1JBhIRg6S0foTK5BxJzNmKfdx9EZUWe4/1cG4g9u/kCB6k4qfuNuGvAly0mFa7W0bxJG3pW0NCLIUZ30FEipyGW+JC4A+vrtSjwgAOORffufVFQsEN1QQ1GdAvPxOOD/8C4hBOViPaZzediVs4DDhdWQgZB788X272PGgVccAHw1FMS0bj33vqlrbQj//pr4JFHgHPPldLW99+X9AqJiTsImaAwLabR6lpPMgSjD831jHGu8Hs6nF/5XlwJNhSCBiJ4zrT4VRYP2Q5xozsImehRz19COwZ3FERbIOZZEiEuaeBLoaMUvJ+7qe/nbyWkUp0ipby6B5Mer8RvpbeKdnPO8EQIEtctwMhXr1aP1577kCIVdSodvMVBKki6mup0G4wIiogFv8Lmzdn48ccahIeno3t3pxCK6l1OYt7oKsSiOM/e86BPu94ILWHaDCmLKK7abq3du1UXafKKuaqfiMlqxd+XPoINE0+3h83TUBNiUathtjmnP8WVvV/C0alXtNkwhjlhQnLt4faqAAmNkxRoB9HGry1XN7x+rScrate8/d9//4BXXrkRMTGJeOONTYiN9R9i6EvU2erw3vY78MXOp9X/D4g/DZekPIAIc4w9wuO7DKdraSuJxA5nGx0FplLoIspoBgnKwIHiLOrN6topwmWr9UyvS0sljZJjFzKyK2j3oPAAEPdJlsTLhOQadW2u66wm5B3dX0K7Rur+STzPOqrE/dYOu+2F1kQsSEbZJE+qBOvqkSUh5rFe3UPhhXlKrBm1ezt27Hey6gNSYymr102a56+jG4n5Q8QiKCgUL+qMjB7qomLdtwYHLZIKzfCbmow5SLk2KfMXdi2CLS2Gk/x1a5kv+4msOfdhDJt5N8a99zCK+o/GrsyB2FayGE/nXoltNWuVSPOOfp9hVPxhbd533qAc8HVPCXFczFS139JIjaZelfYmTPUHH4kuJdn7vOTCbO7rNkKjoyFcIey775H49tthyM5ejc8+exIXXvgYghF067y411PoGTkEL2+9CvNKPkNxbR7u6P+5z62PdWkrNyI/35k2IdEoKBDiwY3RjqgoYI89nKmTvn3l3uM5FHOoHYiKsqkJkAI23nfS6Gq711UGWvhJQza+lgM5ryPdhTdQIddymrpveLz0ypf3kOTl61//ejJ3plN01KrjyAX3iyX8PBcVFUvV6p7nx998Kbg4Y0UHj5OrdovXm7iLJrRI92Gy1GLsk2cqUlHaayiW3PAuKqvzXVIf0c1q+YIZgXsXNoDZbK5HKqQ7nm6R3rTRjjD/XEfppg6vdzZ0vwCn8EfCpW3BhtPvQN7Y4xBaW42DXrgOpRWb8HDOOYpUJIWm4ZH+P/mEVGiwGkc3TeMxlhVmqktraanN1zdk/dcKwdONqzxBVnZi/3v66dep333zzfN+01a9vXB48oW4Kf1VhJuisLxyHu7POhZFtZ6t0X0BVowcdhhw443AO+9I/5KrrgLGj5cyVlacLFwIvP22eGswxfLEEybMmZOOoqKEeo6D2muGol2JynluMe5eyNjD7nuh3SnrO38GKnS/Ik0QeKw8+cJocsGJUY9jHZkW4fnixio8nkN+NomkP/hSOD0ntqO0dKNKL+nu1LqFg3hopLZ4XB3+zi1IWTkXtVFxWHDHJyi2FTdIffTqsqQiqIiFK3R5D0GS0FyYlCtnLTLzh14griFk2S9dtueDKEpICJbc9D4quvdFTF4W+j13EgpqdiAjrD/u7TELKXUJTeZ3WwpXUyve5DqfLsY/YqOuQ7pMW7mGJkVF7lyRNaWA58DKbfToQzBo0F6oqanExx8/jGCFvj72jD4Q9/T6EHGhKdhQsRC3r5uA3OqsDtkH3ia9egHHHgvccYfoLtg07eKLgbFjJSxND42//qKRlwnXX5+GqVMTlV7jn3/ykJtb2OJKkYZgVMvZ8KwqaHQX2u2SEUoh1+yuvLOeKVNjcpHYoZoLqXiglqLM0eCRGyO/nUXwhEyU26s6NihSwf0TEyumZtIQHz/AnpKLadVYzzYJ/b95QT1edMObyE2MqjdOR3aBqo8uobEgLBaongqcECMiJOfujQeF9l3gYRCnTulH0d5oKjdYPy8tIjhfWxtvXfocLn3oJkRagOeOzkS3yxchrNZaL78rKQrfFIZXVRWoAaehfkUEVIWOUlTdcMw1L8kBlas1riq4kvMU7tY+DqtWzcPUqeerCMbLL69Gjx6DEGzQx4SDWVxcH+TUbMIDG47Czpotqiz1/oE/oH/06E7dR96TrDJhyoSpktWr5XfduuUjKUkaL4WEpKJv3xTsuWcV+vffiuho7ytFGi8mchwr0s7QG7QX5B7hini3Y8LmvcBJnHoVV2M8Xhf6Hm6v8UzSxjsdRJ+pD22CJ1VrtfZS4fZftcs4yrG7Aq++yrR3Wb3FCT+fx8jVc6ItSNi4GBNun4DQmiqsOv1WLD7pMmlpYG+65w9ltFV+oLEIuohFTU2uQ4+gWxZ7gtyIskLiRNZRpKIp6HCmFrs1bN/uC/y0601cb70F19htKab8tB0DVi5T+V1nioKEa6u942TbuSdXlrr+Xh9zQnuNxMT0dqQ9qCmRxkQyQOhQpe734glyvHpg6NB9MWrURPX6Dz6QCpdgAleKuqGXNhrqFTkETwz+C32j9lTeI3euOwjLSn/r1P2kiHPYMBng2Cztww+Bhx4CJk7shrg4nlPmvndh4cJdePLJSNx6a7rq2PrttwX4999iVLTANZrXDnUXOgLG60c3IQx0yD2SqPrvSMrPrO4FVgIxgiHVDBZH8zIdoeXfvam48RacsKW1ubPig/emrsDTbqs6+tSw6syX4Dgireh3YODAjejVi1VH7NlRpz6f441Udcgx8wWpoFhzn6knKVKxfa/Dsej4i9W1Jnb0np1kOxrsGWW1dqy/SUMEVRKotpZNjLwTazpbcNc3FOpsiMq7xPEdfO2s91nuE5iRc4d6vOWIi7G5Aqphzl5Pn4O505YAqUy59LV7BpSqQYv507bWoOt8OktNpXHarnqrUg5MHKBE1FmojgE/lz1dWFbH17IMj2FgrkA8HRfxAcjAGWfciGXL5uCPPz7CqafehgEDxiAYQMKnRXraMl0jJbwHHhs8V7mlLi/7HQ9uOAa39P0Q45NOhT+Apa2jR8sGpKCw0IT16/OxefNuLF9uxbJl3bFqVQ3y8nZj/vw8bN8ejszMKFVtQjMvkpTw8ObSbj3VtcV7W6JgFqWxCobQtBCMJLUAYlSC94KQ7d3q+/JaoN+CLgPl313LkFsLTtYkspKCqXNpHsgJu/4J0aXwuopNmq1l+sRvhN+VhMZiKVM+GmJmJSZwdXWh9nbrcapJmq/Pd0htNfZ57FRE7dqG4oz++OPyR2EKDe3wiiSrtU4dB+l5RdJmc1ik03WaerzSUlYWcS4ZwKUHOgNBQyzKy8tRWytiTebRmlvl86JnaFGeL6uAzoaEMXXpWPP9A1oC3oQf7LgP/8t9RP3/9LQ7cUGPqVh5ZRWSNi1FwqYlqlnZX4/OQUgYB4ceanLXlsrMXbfV218m/TSlpeBASHLgmvIQTUU3NUCIKl7KCmtrZRCTAVXMhFhh4mnw4HsOHnwA9t//ePz997eqrfqDD/4fAh2uniziIyAupa5gVQ/TIM9uPh9/FX2GJ7POxI229zAx+Vz4G5KSkjFqVAgGD87DkUdy4rJh3bpu2LChBjk5pbBat2PTpj5YuzZMpQtZ2kpyoStOBg3iRFb/PbVvAu9nSRdx8q1z6HyCAbxPpLFbkppkOenzHuUKXhyHOcnGqjQmf99acsH7jwSG44DWXHHlz3GgqRLKxuQiu9XkQlcNMYKrLbFdP8dkikV2Nqto6Nprqlfq7DPYbBjx6jXKWbMmOg6zp7yEurhkxKiFX/t137Vaa9V35kKMPyUS4TkCJG0saD9ug9Ua3qnmcZ0/m/rIICs3V8SaZnNiszeQs4smUyCxfpGLlVWWhLdFiOU7Jz1+z7e334yvdj6n/n9hj8dxWvrt6rE1IgoL7/gUB964N5LXzldq55VXiDCJx4U3jtjaVthJRplXTcU8gaTBWYK6Q0VHGr6Xjl6Q+JGAyCplsxKnibVzjfqbu4lVgwPvWWfdjgULflQt1Zcvn42RIw9BIEPKKnWaz/NEGR4SiVv7fYTpWy5TDcxIMqqtFTgy9TL4G3gtSLPAPEREFGHvva2YMIHksxYFBVXIytqOJUt6Y9myEFXaqktdCZa20glUE40+fWT1Ku/LhmUkFzvUxFReXqfIstemcgEAsZmOUxsnHhIAfldOPjoFYrGUoq6OK/1SlaYQ3xj3x4Cvk4msUt3nrtb/uoRUL3Y46ZGwMYLB1bP8tNlX0JLmJLGpqdlpjzCU21Mm0V70FrHYe3SUNCITHI/M5lg7cQpXeoKGvW98jb7fTkefn9+C1RSCuVc/i8rMPRDr41JSm82mvivLpnn8hUi4JxH8XC7SeB51pELIJasHwxEWFq1aW4SRiXcSzMFSapqUlISQkHKEhUkYsClwUtJNknTVQWeipqYAVqszeuJLrYfVZsWr2Vfjx12vqf9f0Ws6ju9+bb3nVKT3V5Ui+z58Avp/Ox2FQ/ZHzkSxiuYFzAGJKxfqGzjJ19VtVsettTbCjD7IzSNVAKLqrz9J6vwtQ7taKMabRwY0hn9JUuI9pmf4+n799schh5yFX375ADNm3Ionn1yAED3zBBjEoVKnyJof1EJNZlzf521EhETjh12v4MWtl6PKWo4Tu98Af4Nc7yZHqaQIqXvAZtuKhIRq7LNPDqKieiInx+RopkYxaFkZ8O+/shHUkjFlwtQJiUZGRpy6x6Vxl1ie+yos72/gJB4VxVV7NzU5ySq/VN0jNhvNoOjhsAoVFYnqvpXrx2TfrA6S0BC8/0NCItQx02OAEAnvdFd8vei0GGnMt9/TJAUkCJFqvzkZkpCIuVaJI81B8HpnI0O+Rjc07EgkL/kJe7x1k3q8+OxbULDPSYjxQdWHTZXoVtjHQSES7kqJeex5jETDEmGP0jjHMC3Y1R2AZbGVgtpaJ8nuDAQFsSCSk70zZCGr4yBNcHLs7BRIQgJzpfkqzCsdDn3nFllns+CFLZdgdsH7quX5tb3fxBGpl7h97s59jse6M+/G4P9NxagXL0NJvz1R1nuPerldrjakSx/DmzkqoiE+Ai0bqLV+REoDK9T58NS/RcKqvdSgwxvIWXoq3VPj4wd7POfcr3POmYq5cz/DunWL8OefM3HggZMQaJDvrs3bunmtu2Fr+6syX0JkSIxy6Xxz2xQVuTgj/U74G3gtcXCU1Bft3tnhtgcqKsQK3GTKRc+e6ejVy4TjjmOIXKzGtVEXu7aWlAB//ikbkZpKghGNPffsjcGDtyE2Voflg9djQCbiaIflttVajdpaNtXKsUcAtYGTu1QGCQZTHjZ1LrhpIu/uc2TFzNVzqH0M4GvUX+2bTKA8t4x61tVVOEpRzWamohmyr7ZPqnUwmcJUZIT3vKRJ4+0kqHOIYHj2f8oEK8Rah00TTsLW0+5GVCuj2zZ7RELIRLlbIsHvKYQrSv2UJo4hzRYf6C7euiM0F12djaC6u5ojFa4VCbzYO7pxT0PExZUgLU26A5IUNdUcraWotdbgmc3n4a+iTxGCUNzY931HwypPWHvOg0haOx/dlv2qhEp/PPMvLNHOG0k3BdMpChFYVjbbNKkpUysOOHw/GQw95ytlxRLtMAnieSwrY3+YOqXI5kDp7vx369YHxx57Nb788ll89NFUjB17HKKifFyD1Y6QHLmk+ThotJR48phc1PNJRITE4KPcB/F+zl2otpbjvIyH/U5zwHNM8aUutZZGgGmOSIaIrCUiSW3FgAGynXIKyZeUtupUCRur7doF/PYbtwiEh2di9OhsDBhQjb59szFsWCYSE4Nq+GsEnl+udqVrcLIi5hI9YN+kBHuvEat9wpPJriHhYsRB3iPCHr3QW8uOHavbtL+GaAFIWChAdE6wISFCYPje/B01BVzNm0wUY3YcuVDt0ndvwoGPnoaI8mLsGjAKK65/D2EtJBU2O5lgFEZSVPUjQrpBo5NIhLdYb+Xsx5Lh0/R5WxHcd1YD8KZi3lC8EppPmbQnmHfMyBBRVViY9MzwFdhM7IlNZ+Dfkm9hNoXjtn7/w36JJzX/wtBQLL7lQxx0416I3b4Oo6ddpPQXrjE1naLgRC4lodI0iROeGMOEtCgETgYvVs85zfZy0eE+TrAS4t5mX8lzlRZpr5KIbzRhnnnmPfj557eQnb0Os2e/gyOOmNzh/v2tgUSGxI1Sq/BbAx6Pc3s8gMjQGLy7/Tb8L3eqSotc2vNZPyQXMWoS0ukLrp4ZpXH17XBHwBnxGz5cNpa3sjnaqlVOorFxYziWLMnErl3bsGgRBYHZCAnJxIgRZpU64eu86doayJAxz2TXLVHUWu1SXUCY7NECknhOdFJC6guI10MU6up2OVbYsrigZw0rOcIcLcu1aJGb1p2R2OhIjDc6jdaCEe3K8u04cPoVSNy+AZVJaVh093cwRXlPKurqauxR1dJ60R5eu3r/eZ23tjyVBIUW+E5Txx5+N551GWIhOXpnCqQzRVzcl8pK2k3bUFLCngndfUoqHtt0KhaV/IBwU6TqTrpX/FHevz6hGxbe9gnG3zURGfO/wKBPH8P6M+9u9DwOPDSr0pUsHAC4yhTthfcXOZ/PCbQpvUVD8NzFxw9UzxPRkhiJMfoREpKv1PIUeuoQKpuRnXrq7Xj//bvw2WfPY999j0Vi4kC/6QfjaXCSttR1jpbLbSUBp6bdqtIir2Zfg693TlOE5bJe0/yOXHDg5XUg5KLS3l49xd5jZpea7JrTIbG0dcwY2QjqMVasCMeKFZnIy8tGYSHJxVZ8910mvvqKK3Bg8GCnEJSN1ZoqbQ1UkPzzfmWKiWkPHkcSdRJyMZEK9+3K3+62KyRRxg2TKUWdVxIXXcHCz9bXIYmOU39Qoe4FPUYIuQyxT86xsFpjfDKNcV85P3Ab9clzyFwyG3VhEVh499eoSe3pxett9khMUT2HYO6rFtgKIWrbvaZ9fsQILrRdfI58gS5BLHSfCkJuIt+VcbYutC2koqwsDrm5vrMQr08qonDfwO+wZ1zLKyGKhu6HFVe9hFEvXo4hH9yL4n6jVTvghtAW6FIemqfYOS96DhJNqc8bv4dTb9HQ38Lz6yT8J+FFmyP6IcJOVtjsVuFeRlI4WJ5wwvWqf0h+/jbMnv0xjjrqIpVC8ccqAblGJM3DwZeDh69WaMd2uxpmUwRe3HoZvsmX6h//JBdRys5aShaZNLbWKzdmPr8lod/YWGC//bjRaC0TubnbsGlTDTZt2oa//spETo5ZpU+46dJWEg02VOM2ZEjgRzQ4yYv4ktcVvww9fHgcGW1M9tnnSOmrrNhdWwNIHyamoGPtoXzpdCyeOcXKs0YbbUljsHiXahVWS1SoSVv8LKSLKlNgvXtHoqyMJIPXQ8uJkdZv8X37zP8eI79+Vf1+2bVvomjwOC88PliSW1SviiPMXm0oKdoQny42uJ/ajKw9O8e2BUFPLLSTJU+6rsHuLHCA1KHt0NAY7NiR4RA5+ZpU3D/we4yMO7jV77f1yMuQsGEh+v74GvZ69jyltyj3YI3NCAW7j+qSWVmhlDuqOpqbtMQ+PN3hb8HJ1JtJg59LUqNDjmwoJGVqUnolNfhF9i6rSTj77Pvw6qvX4KuvXsaBB55s99Xo6VeTKgc5KYWmV0UkoqOlD4YvcWTqpeqnv5MLsUnubScXNfZ+DzHq2qLGhmhNXpnnPT09E7GxWzFiRA1OOWUbysszsXx5qCN1UlgoglBu8hqgf38hGTrlws6vgQCubnVFF8FIXkLCYHXPiJFYvvpdW6rRpERUdw+tadA9lHqO+Hqhf1ltZ9orTXY5+rzwfm7YXVrKK2XVzxJjfh/eJ4xU1tZWITJStvJyOpBGuog+m57e+P1JKHSb95QtazH+TYnObjjlVmw/5HwvIhxO0zA5hmJ34GsXTpk7SCrqHIJ2f3H67JLEgpOMCFx0M6wQvwhth4aynM4/SYXGistfQPzm5coYZp+pJ+OPp+ajLtr9QC7mVt1dzK3YuyEXoaFFKgLRnLhT/C2S1c3K12t1eHPge3OikdVMqWOlI9Umkp7R2/jxR+Dzz/ti587N+OmnmTjhhCu8jpC0NzhpasdITZok/dE+12vgkAux6pbwb42dcEnTJ5IL7m5rRNh6xadNnGJjt+HwwzNxxBEh9EPC9u2i0dDkgr0XNmyQ7auv5D0yM4Vg6KgGO7/6EzgJVVdT00Cra5u9q6dEJ5xk1abuE0YNdFrCWzjD/7KQcJaIhjjSG025YOpqM54/khvtwyFlsnx9otv0gYwNXKmnICTEgry8csTFUbfB9IkYSvH9nJUlsfXuI5IgEZ9LMze+f3xZNQ6ZdjXMNZXI2/sYrJ70mMfvTAKlbdT1/oi+K65d7h+LpcJlQSoRTH+vavLvvWsjtHW0s31354SNJEXAls4kFbwweqG6OsSvSQVhCwsX86ybxiIuexXGPG8XczZx80gIu6+9sRjFslyJZLtdiTQE/65LspgK8CZVQdbOm5rnmYOJHkS0SErMtEgwOLhaccopV+O1127Dd9+9iUMOOV29B6+LzjRJ43fmyomTpU7XdYQNdaCQC/FSyXTkli2WajXA8rgxusMURWvIhV758d7kWMHBW6ed2LWV25FHynPz851Egz+3bgWys2X7P7upK4mFjmjwJ1/fGYfS2divwMWC2/39x8WA9N2g7iLH3vAw2gtHTpKAknrhf977JBOujdG8gTZ80/ex62JANxHjPpGkNCw95d+Li9kUKwExMYxKCzHhvcQFpa6a0N4Z4uTpdBLl+8aGxOLAZ45A1O7tKM0chsU3z2ps6WpP8Ujrdann5LEUITvHHFM7RjBz7NG6aJ+mRdsTQUssnPbHzL+L22NngDceJ1adipHQtv+TCo3q5AwsvOMzEXP+/TkGffKoWzGnK3RjMWoc9IpJbvYyey+DFLdhPG3+xJCoRDx2eJWq4GfxM3Ro19WRU9IsabBaKVorwoQJJ+L7799UFSLffPMqTj11snodWyl3tAhK93nQLomumpWOQuCQC7NdcyGCTk5uPLfO60Qmj5ZCd+HkPSqENsftNUfSMHGibAQ9M0gw9MZIBsnH77/LRjBVQgtyCkG5DRzY/oJQraPQ6QjpPNq9SbJAATUJCF8r5CpTLYAaCzFL7dEJp9WlTPy+EX7qDqFSVcGUqriISp8SXR0S7vB6oLGWzcbPFBKgm49x01bgkg4Vcy4RPIao13M+YEQw3ByDvZ88E4kbFqEmLgUL7v0Wltj6c4VufqirWXR1GqM/7Xmf1Nj1RNoh2hcC7o5C0BILXQrJCayz3DV5s2qxjTMv5pt8ea21ut1JRUvFnA2hnU0Z0tQ5XiEZJR4JhoSoe6qBns/3JlWhuzpyUJRmTI0dObkvUqqajPPOewiPP342fv31fzjkkNMQFyclrwkJA9Xf2zPMqEvqGEERrwYJHzNiwqhaZ4Q4G5MLEy7r9ZzfDWKSl9fVIlItIJ0+LXZCkNHKyIVEEXmvSsVWniJ4TYEunyIGlf/TVnrtWmdUg4+Li4H582Uj2MeCOg1NNLjRxMt30Vln1IvHxVuNkzas4/eXsDvNxJzdhrVuSkc/tBsmyYQn/5i2QMpQ0+wOvRJ1cFaHyKbJOMWb/fubUVMTgaoqulLKfS8eGNX2bqfsm0G3UHaADXMsIJhKG/LZdPT46zPUmcMx/47/oTytn0P15lopolMmXCzJuNW+96mkhMUUT8TwaX53P3Y5YsFVoG47LrqKjlf+80KkGFH3dvCl25/FVounss7uEFJRX8y5CH1/fLVZMaenVSEHPVZr1CcYzKUm1YsWiD1xut0tkGLO8GaFZdLZMcZORvIVOXEHXhP7738mhg59AWvW/IWffvoMZ555mQpvFhWttQ/GFKPG2MOvkW26ocXop9bRA4ADZX31eIwqpezskrH65OJ51W9kUo/H/G4w42qR15I20ZJ24SGOKgOK+1oj6JSS3gz1vrw2SXhbYljHz3V2bpUJb+NGIRq62qSoCFi3Travv5bnkViQYLDqhNGNfv2kIsVb6CooEmPXaKG4EHsfGeXrxD9E0kJsx857gNet08AqzFGa2hEEWKcwnP1J6hz3kTh2kjjUICamHElJhSgvZ+df6WEirw9V+8n7WFwp5ZhI9LQCff74FCO+fFE9d/4lD2FLZk+YStYrN1FdecLn66gMyWZHpNMrK/MdWivusz9owNDViUVdnaxyve1y2h7QzpC8ePVA6CsFb52tDs9tnoT5xV8izBSBewd80+6kQmPF5c8jfstyJK/+s1kxpztIAyEhGKIEr3B0ZBSdQ6LD2pmTg9WaokgiV5BcdTR3LmWFs9meny336KfBAWvSpMdw110TMXv2LOVxERVV6wid8vP1yk/8+nW/BKrTecuI3bFAN12S9sViOORszCQtjhtb93Jlze/rT+ViJBd1tlq8kj0Zn+U9gfCQKJyTcT/8DXqFrR05ebw5iWhnXSk/brlmhhMYryFeb976ZXh+L2dUguAlkJcnkYzVq+VnVpa4g86bJxvBVAlTJix1ZfdWPk5Pb6zV4LVFDQVTBr6KeknXVH7/leq4SrRXNARi6e/76ETL9k9sxMWZUwglYbWyXTjvSTNMJpvqByT22OI6Ko0LqcfJsadCIpGxaTX2f+te9fpVJ12PrQefDVNdjaNUVhtbaVKhqzJ0GkZSMRE+PR42NW/kOaIxJBQkFoGIoCIWvBhqanaom1NKnDqnHkzn4/QqwFeTBxuKsZnUH4UfwWwKwx39P8Oo+MPQUXCIOW/cW8Sc0y5s5MzZEo8CcdajoQw7MFbbB/R8+6TLvG2yI1cqYs4+TRI0iWywcyqFaztVCaynG3/EiIOw115HY/HiH/Hxx1Nxww1v2NNWFjuJibCvjCyO8GtrIYMZlexRLs6B/hUJ0Dim21WosVXhrW034sMdDyiTNd0J158g6S96wITabd5JLkyOzsXa26Sl4Iqck5YmtJysfOFqyNNNgsBN6zTY04E25JpoMKpRWurUbWjExQnBEKJhRd++RYiOLnCszGVFTnF6fV1Ea/Q+jCLy/RhZ46TK1EFnCQad/hW6UVe1m0ZdNMaLRVUVOyKzPFvIBM+/NtXSaRGdGonMWYvxT12AUEsNtu5zFFaecy/CzREqPcnjEBGRoMzDRPAZ4eiXIhbkIg7Vny33c0ybnDQJuW4lCifXNlPIAVLPHMzEghdCTQ1LcqTyorN0Fa5CIw58Le2h0dSF9/q26/Hr7ncQghDc0vdD7JPQvM7B16hOSneKOenM+b9HsP7s+1r1XhwAGF602brZuy8WOfKnOhwtVR6hahBlbp2EpKnUFlMZQlREANYU47/ggkcVsZgzh1GL29CzZ19VIsuByGxOUatiGdxkcOJjiUQwMmG1kwPZ5LGslFybM0l7Y7PfEgl3OKn7FNRYK1VfkRk5dyAsJNIvu6JqbQ0HeOmBIZEj7cJKtGZw5jUkixRtNd+7XSJLkZHSjZUbwd3PyRGCQcLBjVENko2lS63YvLkYixYxNWhRZKN793B0794N/fvHKuLB37UUDXUE+pgxysoKCI6nIo7tGOGgeFRw8mbb9upGfyfZ0ZEIbhZLJLKyZDzggpI6FoHJEVlwflcbQkrzceC0kxFZWojd/fbA3EsfQGXJWnV/k/gzUippk9R6ejjpqVLtcAMVR1hxFhWDLVnYSAo1pkWLh4Z9P8Siu/NMHH2BoCEWO3fS+VFsTjtLPevagZMrCF+VMPKGeHf77fg+/yXVpfSGPjMwPuk0dBYo5lx+1csY/eJlGDrrftUFdcf41u8Pz5lWc7u69kmVh6xGhWhQBW5TVuKea+Op2E5VEwsnm6bywQMGjMGBB56FP/74GO+/fzfuu+9be3mqeGlIk6Ao++v9y4u/vcEOqCQXH+c+rLqiMi1ydOoV8EfoHjW6b4wW2vEaEDvwlleEcVGgraWF0DJa1r5aLV7SPXvKdpg9EFlTY0NWVhGyswuwY4cFO3YAO3aEYf36FCxaxPHFeR8wGkJxaN++8pN6DWo43N0q7vwYpCNqqmMy5nUvgtYyrwStrYXc31Jxoks5NaRHiDTpknuxflSAXW69BbuUjntmEhK2rUFlcg/Mvfkt1JKNWLQFN68dmejp9KqrTZzRCU1Uku3aKZKgckcDNx3ZrHbYjke5aLUimhD4O/t+iEV3gFu8BguxsFjon86LgwYwPTrFkUzX1Du7UPouN/ZR7kP4YudT6vHk3q/ikBTPjnAdhewjL1V6i/7fPI/Rz01CeVp/lAywN2ZoA/TNa7N1t68G2A2xwsVEh6SjWPUK8ZTzJZkwm4scRjkU5XnCeec9jD///BQLF36HVavmYdiwCWr1ouvHuVr1Z4e79sS5GQ+qkmZee69svUqlRQ5N8c+283K/hdjTF85rQuy/5Z5sCSSNSav5rfaSVvF46KgFi3hRsAfPbqSlWZCWBoegtK4uHllZJkdUgxsJR26ubH/9Vd/KnARDbyQcGRn0eGjox9Ct0SqZE5wIWnfYib1UmvgKsoiQVKjTXEsqTqS/Bu9v35G54W/eiO5L/g+WiCj8NmU6yuITEWafzElcpAtpmcOoS8zEUtymgVw7x9KoiwRBW45b7AJt7aNBiIiUJEPSoTyXEoWlN0uVX/f96LLEwmw2o3fvPggPZ2Objmd70him7V0o3eGz3CdVrlv7C/jTqnHVJU8jdtsadbOOm3oi/nh6gfK98AVEwCkumnKTlqqbkQM8RWtW62o1mTgtdM0NOrCmKT8MDhLi4Of+hu3RYxCOOOJS/N//vY733rsTjz021+6lsdXRXbS59EuwQlquP4FaWxW+zZ+OF7ZcrATDByafBX+EkAebI2qoq0WEXNha0XJeop+8FqSPTX67d0V2EoqCegJCVg65NurStuIabLLGKhSmTrht2gRs2ya/X75ctpAQK1JTdyElpRApKfTmoLV3MjIykpCZaUJGRmNfKDHWqrPrn3artF5bPIG0Wye/n6sfhoi3E+wRRt/ea/zMzK+fQf/vpAJk3pVPorDfSERG6GaFMnYwDcJJXky6ZB9JNjieN1dpJK6lYjtOSNpEHIGlh5HFkeIVsDqlxOGrEReX6VdC7rYiKIgFERbGsHXHrywlP7bdboAVbi9v9c2q5tudL2JGjgjnLujxqN/luW2hZiy69SMceOt+iN2+Fvs8egr+evR3WMNbLyJzB1fjG64gSko22fORofY6e6Y84uwNx+SzqbNxNq3aaXfxdH9e2ENk9uz3VMRi0aIfMHbssXYvDU0uOna16k/gdyahZVrkp91v4pnN5ynNxX6JJ8EfocmD6AOs9mqROjvZsLU4kiimdhl2j5RCex8b37u0OlMTu5skFJ7AyATbv3PTYMkrHUJJNLKzy1FcnIdduyjSpKFXAv7+uxvq6pyTOPUJTMPQqlxvvXszwkEnWFdBq5D+1nw/TtZaCC3lpPF24u/bMUN/Ju//1L/+h1Fvyzi65MxbkH/AOYiPSHS7WNCeJlK2vtMRraqtpfaiu9cVN6F223Feb7wOtQBVoho0Mct1VDNFRoapyIWzLXxsu6fd2hsmW0OZbTujpIRGRLRgZTjbdzeoxQLMnCmPycY7ClL3zgqQUIepTEPwBufKoaJCNk9HnMUVrIenRfGC2rfx0jbxFjgz/R6c3+Nh+CtictbjgFv2RXhZIbZNPBdLbprZrl7GMsDlw2qtshMJ52fxxhTXzxhFOkpLs9SNzfxwU0K+d965DV988RT69RuF555brErWtB05Xy+iLt+RxkADy5yf33IRfi+YqSqS7u7/FfZOOAb+Cka1GGEgJOwskzUnh5ZGLuT9dtlX7EyR9PbpRNjQLVMIRbKdULStGoP3gO7DIe8dhrKyNGzdGqMiGtqWnFt1Y62kAqMYTMUMHpyHnj2LkJxsQlJSD6Snx6rfN+e7ob1ltBhTiAnTxUlt9sMgSTrzTHnMrrQUxAqJKVOuv4nrF+HIRy+AuaYKmw6bhBXXvQ2Tl5M234eLFi1sFcO/9DYJK+vqahwRMOo4SKxEEG5rkGaJsnt4eG6mxpdQAVBQIK6vemM6jKkxljDz/HTG/G0QizaAAw0HHBls6nvs19RIjToV3VwJcEWRlCQnmo95A5BIcJ4iKeLzaRPMZkc/bv8QbxWeR2cEHBZzI67q+wwiIvx7QktZ9hv2e+AohNRZsPqCR7HhjDvb9fMozONqRAyBqOIXNbm+QUk4GN3QHQw5KLD7qaeURknJblxxRX9UVJTg5ptnYeLEcxyDIiNSIgJMavdQuD+jzmbB01nn4s+iT5Te4t6B32FU3KHwV+j7k+DqUU9szZHM5soBxV68b5tXleLnku/ilhnqEqFoe3mntrLWpbhNaQasVpmUNMlgpEMTDy6GBDakp+ciPp69NkzYvr0nqqpilECUaRSObbQ+5//5MyWFzd34+aIzkNW5pC99Vb7akFiEhoqPERcFsfnbcPSDZyGqZDfy9joK/977rYqythS8bqgz0dcPSZ8Ihk1t6FAa4TBNlIoT6ZEkLqNV6nyQNHD+KCmJRkFBAvLzY7F7dwh27xYywfnFExkkli6tH8HyBQxi0c7QvvoNByq66/EGJWngjTZggKi1ebMxEtEcvlj9Bc745Ay1Qjw18yqcEv4ydu0yqQuN7+fDII/P0eeHV7HnK5PV43/v+gK5+53c7iZkEi3SJmRmF/tha6MJpTli8PHHj+CDD+5FevoAvPzyakdqTcoORZhLkRsHx64Kur4+vuk0LCj+BhEh0Xhw4P9heOwB8FeQVIpKn0ZnEQ7BItMbLQ/nWx19bKT7bPN9bNyBr5c8vtMPQaf6fKHl4fszZSGrYu1km9aqKAt5OicxlsFKRYo4CpeXl6lJLiuLZan19Utay5GYWKTISEwMV+CMUKQgKSkUiYlQGxda+jG3ljiONiQWZrMFb73FNI20QI8oL8HRj5yH+O3rVQuCPx+b2yIzP/fdh/MdVgLaqdVbYbfFUomiom0oK6PmJxJlZb1QVBSq5gtav3PTj8vK6JlRhpiYUkRFOXUoVmsISkvjVcM1+nZocKFKIqdJHY8li13uv18qhHwJg1i0I3Q4iysBCpl405JFkkGylpyueSQUPXq41lU3jx83/IgTPzwRtdZaTBo1Ce+c9A7qLCHqhmZtO8VZZLEkGLx4/BEjXrsO/b57EZbIGPz5xJ8o6edjytxoFbndrrdwlmpJu2jdFlmvBqoU+YuP7+dRJFVZWYYrrhiA4uKdmDz5FRxzzFWOv0lr6Z2tXvEGE1gpMnXjSVhS+hOiQuLw8KBfMDhmHPwRQkDFoVPsmcPtKvzW+QWQpJJc8H1bSjLFLXN3vXbd0jOHngltl7s1dONsr2ZZrvddeTknx17IzY1U0dbCQgoW81BeXmufLOOQn09vmeYblHGC5LjGxVNMjGz8nX7s+n+xbhfic889xejefSduvdWKqCgTokKicPBj5yF15R+oTM1UDsHVKT1a+V0llU0Cw62iotR+PdE3ieZsGSpqw3FZb2Vlzo3/r6srQ3w8Ix4kFVHYvr2XIgnNgYvTbt1q0atXCdLTi5GUVKu+P49PXFwEkpIS0K0bU7T1rx3uJ8/F2Wf7XhZgEIt2gqxaRNRH1lpXl4ncXJM62WyVTAvf1pzM2VmzceysY1FlqcIZw8/ArNNmwdxgsNGtm7kxPMm2zN5EQToSpjoL9n3wWHRb+rO6qec+8y9qktrPrKy+uUyIfbKIaZRfFgOlGkUCExKGehxov/12Ol5//XokJaXj1VfXIyoqtpGHv3Z97MxW652NamsFHtpwHJaX/Y7Y0CRMHfQ7+kXvCX+E60RINb50RdXkomeLnTWlxXiuPQWa2WyJoIgIi+zXoG5jzuqxbj6pBHBWktCTwvn+vNbbq1Sa9500LatUKZzo6ExVBq5X9FIam6YmXdf8P6MfemVeWCiPubXEj0LDZLIqQhEWRitu9vcIRXFhPN6ruwRnWj9CiSkex8b/ibVhIxxpZ276MX8yEsxUND+fm37s+ruG4Of16LEDERGMfpmwc2d3FBW5X+klJBQjLU2qkv6/veuAjqpauzuZ9F4hkEZHRJr0JqLYUOyKYsH27PrUZ8HeC+Lzt+tTn4q9YnsqFlQUAVEEBKW3hDTSe6b/a58zZzIJScgk0xLOXusyMyHJTO7cuWff79vf3rW13Be9ERcX7KzSMAFXba5fU7dqSofvMcWfyuOn+XiuayCcJhZdULzJMqA0bwpBWRlHXEPE2Nfw4R1/3uW5y3H0G0ej1lyLWYNm4cMzP0RYGxHEZKNr1kgrYFZESDCaj4n5E6E15ZgiJkW2oOygiVjxwPcenxRpvXKx76IvTY5YvqUQk6XZdMTF9WvxpGs2m3DVVUNQWLgDc+bcKyZGWtN2dAeHvM6gzlqNu7cdjc21KxEfkoqHB/2EjAhHOEaAwXUhZLuB5KIzpkTS26Fqv3qLlmLMpWeEZwzX9v39LXtSeAMkSTU10kCLpEJqJ6gT4RRJart1FFwjeXWviIbr1b6qADSvBpjNtN4vQ3ExTfUaP8dxqMCruAiz8DmOxWJ8D89FHrBVQ21ceDgrJtSbFCEhoVJ83WZjwFmKaPvExMjKSkxMCaKiSsXPREfHIzGxp/j/zhaPlKEY9zkrsQoq28Zmi0dJSaiuWHQVYqGU5lVVQaivz0S/fpEYO1Yu7B09WFbnr8YRrx+BKmMVjup3FD47+zNEtKMXSqa9axfw229SaEXxFBluoCA6b4ucFKmtwJ5p52DNDW94dVLEteRNsLzsmk7J/+eECMvYvGplO0Na9+57pbFs2ft49NHZiIiIxn/+s01UL1p6no5e8XYn1FgqcMfWI7Cjfg2SQnsLctErvD8CEXIhzHUkDkurdV4FKo2OO+ZE+9NbyOybvU6dgxRmprRrdLS9XhBSpGj0+O93ByZTLcrK1jr2aRiSkoZ2aOrGHbDa9MYbFVi0SFVCG//eIOGYCVxx8FIMvmy6OE9KN015zmx+y6oFL8q48SKtpVu2XEgmWrp4cxUIk8xJM76gJmFiPA950lis6b4wOpOiVbWKrZuqqmjMnt0DvXrtvwXlDnQrxMPgCaKycg/27rUjJqYnJkxIEB7/HREcKWzYuwHTXpuGsvoyTM2aiq/O+QrRYe4tUmyJ/PGHVADzw8LZ80CpXqSs/Q7j7z1OTIpsPusubJlzr1efTwqsSpyRwzzJkjyoEy0Xg6qqbY4pERryxDlKxmlNetz8PTfdNAFbtqzCscdejiuvfL4N4ei+E0EHGqosJbhty+HIafgLPcKy8fCgn5EalolABNtjbGVyWojVA5VkK8fF3TMpknoLaq1sTiKrwrzUorK/aQz3CQUrFKVNRjc9Kfx0BzIcsNCRq1LpcLyVAYPeasHI83AeLr20D8xmfmZbIlEcDQ0SUyIkBd4GLzJ4sSFHUklYOapudBj1cbzZ+4I4NWLLKkZdHT1LgnDOOf3Ro4fBL8TC95F1XRA8GRUXFwhFdGZmPE49NQGHHto5UrGldAtmvD5DkIpx6ePwvzn/c5tUENRYTJkCnHACkJRE4xvX8TD/omTkDPx5xQvi/uB370PGkoVefT7ZBkl1kgnZC5fBdPL/g4UXhRTL0ZXRKton1dW7nAp99XsuuEBaqH/zzUvYs2dTC8/TS1yh8AMtvf4DZKf7AXEhKbhv4LfoHT4Qe027cefWI1FuliFggQYSSDlBZHAuzpyakJkNuW6l2JKEqCkjktXq6hxRFVOkgsSVI848JjtDKvjaqF3g72ZLTy5aUpgZG9vPMfroW1JBcsPXIj1e4pCSMhqhoRROm0VVSPmGeH4Sbw9+/plJpDz5tlaZkVN0X30Fn4B/P7U26hiqcZBNtkp9QSoaCWysOLajo/vBYEiDwY9XmJpY7Ac2mx27dxegqsqCYcPCcfLJPcT4aGews3wnjnz9SBTVFmFEzxGiUhEX3jm9CceKZs2SWg/OnnNKJRDATJGtp0tPixHPXCL8LrwNfphlEF2wgziwZC17kfzwSc/+GEc4kFpU8lFXV+QcU2Ws+rhxJ4ry4sKF8/Z5jkaNRbSzf69yAQ5EJIX2wv0Dl4iKRb5xK+7cOkNUMgIR0iE3w1mtUImZMrvBPXLBY0nahheKhZ8XITyuaJbnzjhi6/lDhcJplsSFi7X0gkgWGiFJkH27eEg9EwP+5HvLSgnbQNynXFx56w1yobJ7+Px797ZPP8JpOl9BnV+Uz1WQYwLJP6COw7+m2ppYtAH2qrZsKUVISB3Gjg3GUUf1RmRk53bZnqo9glTwdkjKEHxz3jdIivSMLwIrU0xFnD5dCp2ovfCtr2rL2HTuA8ibepZoiYx95FTE5Pzt9edkNUE5ocoTXQ6Mxgqn+yKJAa/8eHJWNs9U7quJH+KCC+aLE/evv36Kv/76eZ/naNRYxLgISOUc/YEItj9ILqi1YFvkrq1HCw1GIIKeDsp+n++ZTNAMd+T+7NnvokjRHAWc1dU7xGMu+DxWuJi4q9do2upgJkmJICkkxMqTRVqLpzkJhT+ya1RolhIvszKoPkuN1SDPkwtpUidJBasDPXq0T8NB3Zm3IWPl8wXx43vCcfbo6HTxf5KktuFg5QWwPVtXtwsWC6uonq8atReaWLQCthO2batFamqpEGgeemgawsM7x0CLaooEqdhZsRP9E/vju/O/Q49ozzo5svo1ejRw3HFSmczWSEdGuTyK4GCs/eerKBsyGaG1lRh/30yEl3u/VM6TMcmFWvgpqOJiwKtIKtgJinF5olYGW8qngCQkI+MgHH30JeL7Xn31pia2u/tWLmKbuDMeqKBw84GBS8SUCAWd924/TkyPBCJ4XKjAQLYaqBFQi6IkFzJOvOlYZ5Ugnyrgjl9jCyAx8RCx0Mq2hdT47A8yQ0ISCS7CVVVbxa3UUJic5W0ew7GxfTzmyNkR8PXU1korajnWnd5imb+x1RTa6n50B3w+RSr4GaMeaubMIBiCbE6hZkugKJPnQG+Cr02SP6m1IsniexUTk+0kqXw/XcPWvEn6uJ/kvqLTKve//64qNbFoARx7yskxo2/fArFIZ2UlIJbOV51AaV0pjnrjKKGtyIzLxJLzl6B3bMdMW9oDxiPPnCknVhir3Jb1qy/AcdPfbv8ENb0GIGrvbox94EQYjN7XJaiESjn+FuRYGHaLErbqs7NSwZYGTwiytSFJCLUTs2ffKaZDtmz5VcSrt/wcQU4nR0UueLI5UMGR0/sGfCv8LTiK+uD2E2G0ef/k2hFwcVQVK/pA8D4XRbmQSvtl6YdSKqoTJKZS7MlFP04cM9xolKX0FsyXaGkxIZGQuRkkEjlCSKyIBBcpKf7jyGCcOJ7i4gaIY9ffUdp8bSo+nvtGkvXW9WDyezJd9mNuh8gF96FrarSqMEWgAU8ly8Tn1sjFSSd5T7gpzw/FzoqMagOpaZhgMYIs/U1km1WOOXsLvJCpqdnlJDhhYckICaEVgr9aMZpY7AMGuJSV2TFsWAGGDrUiLi4CPXp0rqpQ0VCBY948Buv3rkdaTBq+n/s9shOy4W3Q4pWsnT4bTDj0t6jTFJeCVXd/CVNsMhK3/oZR/z7HJ+UUqc5OcqlKMLEwz1FOtjsSJTkXHyKuxFR5lx/Y0NAGnHTSdeL3MFadPhetPYfyz2icGpGjrwci+kaNEHbfdOakidbDO06F2eZndtsKWLFiZUAtGCrFkoLesrJ1ggCQDKhjhN9P0SQXOlebbFYUXMkljzMSCbkISSLBRUYSifpmRCJNCD3j4vo7Saq/qhOuYNuDr5kLpJz4yGrX5ExnyYVMFZakgpoVqZkKEueLUY+fiytL7sc7IechLMiyT6XilFOACy/s0J/bjtfV4KhoNk6ekVg2J39BQQbntJirh4onwf3J44z7SaZrywotx479HZbo/yM3QMAqNzUJ9MOYMKEEffrUIyzMgN69HQd0B1FtrMbMt2ZidcFqpESliErFgKQB8BVYaJkxg60cKepk0Jk/Udt7oKhcWEPC0GvlJzjk5et8JgSRoro+zkXEYpHVCqtVlqMJGWqW6KLPsGDGjNOQkNADhYXbsXixnHJpm1zEOxaXAueEwIGIgdFjcfeAL0WmyB9Vi7Fg51kiayTQoKZ85BWmTMRVY6NsifHYUPHpcgojeR8LbumMaBQiUI6E8mRfUvK7WFC4CDUSiVAnkaBeopFIxLeYjOwvKJJFoabSNvCq3B3r8Y6SC/W9isxQsyBIlt2OYf+5Gr2XfyTOH1l3X4RX3mzcZ3PnyiAyb5AKKdCVBFF6drDlky7ex9YIYJCL+ZonyYVMXa0Q02yqSsFKm2zBeM+I0B1oYuEwm9qxQ/rPT5tWg8RE2jYzPIwRuR1XddeZ6zDrnVlYsWcFEiIS8O153+Lg1IPha9DcZdo0YOJEoKhItnr8ibKDp2Dt9a+L+8wV6b/oUZ89t7Qf7i02gyEUBkMU6uulWM61wsAPKD+oPOGHh0fhlFOuEl9/9937UFvbOllQojbVf+aJWYlGD0QwoIwR66FB4VhZ+Qme2DVXBOy5eyLlQs+TMqtIJGvSwrrCuUmToBpRtpfpkGbnmHH7nkMmTpJMcAHhRgJBHYZylOR9vr+KREj/gmKxYLAawRO98kjh76PAk9/HY6iRSMhKB7/mLa8HT9nkq6ty7gfVhnAX7pKLxu/h+xHRSCoADHr3PvRZ/ALsQUFYc8ObKBlxZJOR/+OP9077Q42kq/h0qXth23T/0ylBDnLhOj3WGXKh9g9btfKY5XkqyzHSHDgJ2P6dSQkAsBJPUsFux7RpZhiNheJriYm8au24LS4zP0557xQs3b0UsWGx+ObcbzAybST8BbrIkViQZCxbJiszbJX4C/lTZyO8rACH/Pd6HLxwHoyJvbDniPN99vw8OVB0R1LBioXZXIeysvWir62uSKVILU1ccUybdgYWL16IgoIdePfdu3HxxU/sl1ywAyzDy2RWgLcdCQMVI+NmYF6/D/HQ9lPwU/k7CAuOxNVZLyG4lSs9SSLqxAmYC7PNZmxRONse8L3g+0hiIDfX+1Jjw5YHjwFGgZMUNJ74Wc7OFG2z2tpqNDTsFWZXrGq0LORlDkmEuMrm99GsSLY6EjqULOoPyKmYPGeWiicycRS5kK6ncmFsqfrhKvZUseJq+oXJyYPfkbqK9Zc9g4IpZ8DbcM0aUn8H22Tu2qUHOTKMVKYR/0b3nV5ZpSh1khvpY5LiIL2BQygUDmhiwcWViaFZWRzRZK+dpMKKiIgIpHZi1TVbzTjzgzPxzfZvEBUahS/P+RJj08fC32D/kWJUsvylS2Wlhkmp/sLOk65DRFkeBnz8GEY8fTGM8T1QPPpYnz2/FHb2FCcKkgqlQKc9rqubIU+s8fEROOec2/HYYxfjiy+ew/Tpp6NPn/FtXnVKMR/JRZkjGZXk4sCMXB8bfwL+1fdtPLbzLHxX+opoj1ya8ZRLBYDVCCZj1rY4oicJQoiD8LmOWqqTqk1cEcrN6nLf7qhcuFYv2AaTz2ezNWpm2IqgvwnfN57E6U3BtgZJAcmHJDomx3FB74tw8TMkI1wkOGrqepKvraVOh+N/+YiNzfbLiKg7kCO0sl8vK3vpHhOO7o9cuI75SjGkNDEjei3/CMNeuFLc3zL7TuyeKe97E6yAsRolJywoiGT+CbULHSvyB+1DLvIQE5PRrtYFjzsei8pfhecrqQMKzIrXAU0s6FFBUsF4c3o/WCxlqKurE46MvXp1rOxHWGwWnLPoHHy+5XOR+fH52Z9jStYUBAr4Z40YISsYP/4oxaqdNfzqDDbOnY+IsgJkLH0LY+afjuUP/ojKgWN8+hpYpoyPH+gMMuOHXfbXywURYFuDJ7spUy7At9++iXXrfsAbb9yL6657br9XDapEqUrsMm7biyl5AYwpiWfAbGvAE7vn4oviZxCGMMxOvhkWC0P9Ghd+7i++BwZDpFjUuXBLq2T3PpOKVKhNtVFkiCAXT7bCSBCixTHQeAXNxMgIUc2S5eYoxMUlw2gsFt1jThTJq+m2Xw9Ja3W1bMvQfC062ntTYJ60pZbVgnSPL1zNyQU/b9Kxku61e5xTJ0pkTST/+QNGPTYHQXY7dh9zKTZ7ORaAr4EVRuWkK91V0zxScQpykAvVDpGVC6nlagkkxjKiQCXGUjjcQ1RbAx0HJLEwmSSpYMQ5zaRCQupRVCStKnv27NnhMR2b3YaLPr0IH/z9AUKDQ7HozEU4ou8RCEQw4p2eF99/Lx3qfGEm06rHxbWvILyiCKnrvhMeF8vmL0ddb98JXAkSCC46XMTkVYTso6sPtqpg/OMfz+Daa4dj9ervsGHDLxg6dKI4KZNAtJYXIgOISC5KHCJRu9dCiQId05PPQ52lAv/JuxYfFz+OIIsZJydeJU6a0hGVi3yUx67uWZGQGQo1TrMmPgdP5tQ5hIZS69Dyc1Fdz1I4yUV4OLU28eKKk4sOK1AkDu0Zdab/A8kMtSC+snh2t8RO4usapOWtiRRFHCiCZIVETn5YXQSR0gODSNj8K8Y9eCIMFhMKJp6KPy9/zmtBhnI/lIl9IVsNFESmOKpTnnvOIEfgHSs28u/PFRqJ5iSueZVC5h6lBnzV64AVb9LPgaSCI5isVERFWVFQUCAOJoaqdDTKnT9/+f8uxxt/vgFDkAHvnf4ejhvoZYeWToLEivuAmpL8fP+9DntoGH67dREq+41CeGUxJtxzLMIq2DrwHZTBDcGePqcEpMBTCvGkG+IO9OiRhuOOu0J83zvvLBAmNHIELdeR49DyOCqrFDwxEKp6cSBBhiRVi1G9yeFHY06ytHlfVP40vqv7yDG+yX5+bIdOnry6U3oJvldKUMn3hcRQ2mEHO8YDaTjV1+FZ0fpzcURZGalJY7UQcfVKcJpItrfaBq906aFCUKPhayfG9og0Fang/lBW+N6EbHXQndIujgdWCPg+cMFVV++xO/8UAYYh9TUoHnEk/vjXW15LV+QiztfB40YacdHTpo94/72hXwgSlYuMJiZaStAqp0/2uviGSLIlp0+6Bqkg3D6CfvrpJ8yaNcs5hvnJJ5+gK5EKCjUPOUQuqNHRwN69e2E2m8X0R0f9Kngw/nPxP/HSH1KQ9uapb+KUIaegK2DwYOCII6Tewpfe+s1hjYrFr3d/idqefRFduF1ULgx1vjWZ4tWaMsiiWZJSf/MKTo6ekmAU44QTzkdMTCJycv7GihVLxFWo9L3gwsnJAHmV2xw8cTeaKCndRfeHPHHnCOLFqzSeWE/qcR3m9JRivNcLb8fnhY+LEzunaEgK6GjISR3mZFRVbXds21zuN36tsnKr2Kjc53NwoWRLiydpLlhyVLK3Y7QzzS3dgBTrKUV/nvhZ/g5CCnP3/x7yqrfR9l0Gd/kbyuaelRxl8ObLyQJWBaWtvkkcHwZDjNMfIzpvCybcfTTCaspRdtBE/HbbJ8Jgz1sjtcp6W+pKejUhON5CsAuRkqLVXDE6KqdPZOuDJJiOq22ZkXUbYlFbW4sRI0bg2WefRVdCQ4M0iWJIFxdSjpYyApYbD3DqKjqSBseDc9538/D0qqfF41dOfAVnHXIWuhJILtgSou6Emgt/wZiYhl/vWQxjXAoStq3GuAdPQrBJhvv4CuxhKnMsLk6NDot9nAQjOjoOp556tfj+t9++EyaTvYlrJ0kDF0WWvptPD3CRkRMjcmGSwWcBEOjiAcixUIujckCHyTJUVGxGefkGUdblVT6rQQTvHxt9FmYlXCYev1xwI74pftGhgaCAk6OaJnHS5e+Um3TBbLpJoSbBKzpWCGTZuKc4KUv3SibRxnboSlwtuo05InkOa2nX91BqE9oCKx3KnE1OCfkP6gq9sf2Q2enJD3egDOS4y2SLMVlM0IiWYnEOJt45AxEVRajsOxK/3vUlrJEdn85rex+4jpDyM97Xp/sh2FGN4HFLglpautbxnoR2ySpFpzQWxx13nNi6Kqk4/HAuHjywLKJaQSQns0zdMfXzvUvvxaPLpQ/D88c/j7kj56Irgm0RftCpuaDXhb+mRWrTB+HXu7/CpDumI2X9Dxi94Cz8Pu9D2A2+kQPJ3nuCWDBYug4J6eOYSJAEg4sKJxeOOupCLFnyLvLytuKNN27BBRc8ICoSoaH82WLnAmIylYtSuOuImqpwyP+nx4XdGfUeaGDlRS7ucoGXj+WUhVzU1QRG4wIvzcdIzKqdCy71J9JN0tDkiv3M5BthhgmLK17Ff4vvRHRYKqYmnimmLuT+kPt+34hsCjObj5N6p4QvXRTTneZIrDpwYqLxPax0vIdprb6Hyj9FXplWCaLijwkhOe0gyaz0iejt8+kCfq6UsVN8/CDxeeLnzV6wHhMemovIklzUpA/Gynu/hiXGs5oU/t2sjPFzqZxP+dlzd4TUU7BaTQ7Pk3pnO49CcneMyAIRXn/1RqNRbAqsEPgSfOpdu5qSCh5QhYWNo6VJSR37gD+y7BFBLIj/O+b/cPmYy9GVMWSIbIksWQIUF/vP54JTIavu+Bzj7zkWab9+ihFPXSxCzMS8rA9APYT0NjCJhd/Vf4InQ56E4uNjcPHF/4f77jsBS5a8jSOOOAu9e/cTJ2mGWXHqRrp6mpwldAo2lcCTV9VcLOWV/P4XJl9AntgaHB4SNJoyul2258+z2iPbEGFisoN/txJkynFRNTYqycMVcf+FPTcUX5e8iKfzrkBkWDImJZ6KQIK8iiS5yHXYdBcIHQ6Lvsq+nX+z03q6BchjoIdY2FmCp1DYV2VuuaAWO8vsJMhtuUZ6C8rNlOD+49/Pz0RI1V5Mf/QixBRsR11qNlbc/x1MCZ4NaJTTObIdR5DoSvt+31cF7HarOAaUMy/fCzWpxOOjreOoK8DrR9XDDz+M+Ph455aZmQl/aCoUqSAqK+l/L8vcHR0tJam4dYkUoD10xEO4boLMk+jq4LQI91V1NVAqNV1+Qemww7H6lg9gCzYg84fXMfS/1/vM+psnGjW1oTIiWsKYMcdj3LgTYbVa8O67/xY/x5MXleUmU5lzZJIEQpZecx1jdY0nNuVoyIVJpTj6Cq4x3TJd0zUUS15BEXJig6ZPsYJkcd/whKz60VKHIj0P+DfLtNjeSEoahtTUQxEbm+WIp6fWINbh+dA4PirIRebzmJ50HmywYsHO2VhR8TECDfzb1AmfV9wsX3OfqK+RUHGEsi3HT1arJKmUgtDWxL6ej/bOc5IKvhfenPxoDcoeneDxo8YmKdAkqUjM3YK6hFQsue0N1CfL6HHPumfudmh8ZAVK7gPfkwqzucZhxy1JBT8XrNxQA6SOI3+3yzoLrx9Zt956q1jI1ZbLwAofjZS2RCpMJhOKeTkuQrpSOzRaOn/ZfCepuO/w+3DrVHm/u2DYMGDqVGn97U/776Jxs7D2n6+J+/0+f0pY+voKsuoQ4Zwlbw0XXfQYQkJCsXbtEmzZsskpDpSLNrUCMgmT5EKlW/IEp0Kq5JVj48KkAp+8Afma6gVxaB7TvW+6JkOx+oiyLE94nKTg6+SCwIoOT4b8Pv6trO7U1/NKUP6tLPFz6sKdfjVFz9dmv4JpiXNghQWP7jgzIMkFr7BlpUJWpHhsyBFNaT3N91elXrYGlt5V8uX+iEhnwWNMijRrHaOOTPpN9vnVsCRicrFUxw9hqK8RQm2GEppikrDkloWoSJZVHU8SGrWfSQ5pVuaP1odNaHRcQ8PCHHbcrJoEO4TBirhKg66uCq8Ti/DwcOcYZ2fGOTtifsWRUooSlXxCtUBsNpYso5CQkNAhUjFvyTwnqbhz2p3obuA5Z9QoYNIk2RLxZ3BZ3vRzsf5SKYylpW/fz570yfPKRFRZiuWHXJVPm6N374GYNeuf4v4rr9yIoCCZAMlFWTl3yit/agJszjYDfycFniQYSqzFk4uMqO5YzHRbRKJx/DJHLIbNiYQUO/ZtFooV3upVLX9W/Q1KAMeTNUWucrrA/VOLISgE1/VZ2IRcrKwIvKkzXmkr8aYyUpMjitJJki0kpcdoXRAqtQ3SKEqOu3sakuQ0ji3y9ZHI+hqqdUQoB0vC0FCLcfefgOS/l8EcHY+V930D86DDnAurqrB0dupDaUqkQHNfzwhfwCQ+K7sECZfnlmTxWWk+oSRdNZUwmL4afg526iCCu6tNtzK/ctVklpVxxK9euGsyYMxd1v7oL492e1KhwF0zdiyTXuUYak2N/17LrhOuxqY5slrBNNSMJQt98ryy/B/nFJy1dvI/88w7EB/fA3l5m/H550+6OPb1cIROybwR2VLgbagjPKtULCocleQJhCeUxoVJqvbbC2mLbXIGYzW2NiSRcB2/VFMNrkRCuYu2B6ys8PVxGkJdeZEYsbzc2TE9RS4OSzxbkIv5O87AyopPEWjg/lILJFsiXDhUIFSjP4GsFLQ+ESA9I+QEjWdHj7koqat0GXfun+RLtv1Ui08SMknWDcY6jH3gRKRsWApzVBxW3vsNKgeMFgStsQ1Z7HTA7BipKHQJUlPtH99WamyO/BM5OaRCw7Id9uAtvxaSeuV9Io8tP0dS+0K8WVNTg23btjkf79y5E2vXrhUCyCyGbvgZXARZyudIKX0qFCggLS1tdNd0N7WUpOKW724R9+89/N5uTSoUqJUcP15WgH77DcjObkrUfImts+9AWE0Z+n32BEY+fRGs4ZEomHKm15+XH3CZmslsieoWy/vR0fG44IL5ePLJC/Huu/fisMPORkpKhvg/ZcrEjYsNc0h4oiC54ElHOjJWipMovyYjlplPECzKx3JUUh7IrpUPOZ1hcaR4qtuWgrE4gklr7CgHqWmaZ+EOZPWj2BnSJbUoyR4PQiK5uL6PTL9laNn8Hafjln4fYkLCSQgk8G/neyEXcTmnLQ24Mh2eHcyeyRMkTukq9tVspInvJdEMCgoVpkydN70qFMeVfD1xfhMFy0WV5MYmjj22kPg6OEI+9sGTkfrn97BExogR84pB45w/x1aaSo/lvmHrwp0qgzL+UuPinghScxd2UdGTrTK+HnedPHkc8HMtvVIKHem60d2XWPz++++YzlKAAzfccIO4nTt3Ll57TfbD/QXaULD9QVLhGkzKN1m5azKx1N12THNScde0u3CggNMNkydLzcratUC/fjIh1ecICsJfF/0bhvpqZH/7Xxz62BysNoSicKJ3jch4Zck5ey6o3GR09r6FvunTz8c337yMjRt/wcsvX4958z5o5XclOU6cNAaSoVs8gcp2iwy5knbiXLxDxKLFk1FrduH7pmvSklzaknPrDJEglFaEJzh19cjncQ1p8wYUubDDjp/L38WjO8/AzX0/CDhyId1U7U38LFjNYAVHTvxUOSo75hZt3GX1iJqCvQ5yKVtTHYEaheUxpFp5/rIQJ/FtmlQqx3ODzUaMefhUpK79FpaIaDFaXn7QxH1+nmSMduzK9puVoPa01zgCXVe3x2nExpaTrxdkq9XoCLCT7VNJqnq6Xc3jRQ33oxJ2u5uI6k8E2X3szsNxU06HUMjpSb0F/4oNG2RSaXyziwOKNdkGCQkJQZ8+fdwywlrwywLc/N3N4v490+7B3YffjQMR9ALhGOrff8vgNjcLPp6D1YqRT12IzB/egC0kVFiB7x17glefkh8RmunIZEu6Z7Y8h7tz55+4/vpDxcntnnsW49BDj2n37+dJ1GSqEYsLqxq8WuEJRaY9RjhFk9LXgSfYYLEI8UpO3TZ6P3QeXBCkWVWVc3JBjtrGO2PlfQGr3YLHd50nyEVIUChu6fshxieciEADiYHqh/MYUaVumQ9Tut/qgfp5/p9cQPZPJF0hxX57He2uULGg+iuqXYWKkYhKbQcrDiEIMpsw5pHTkPbb/2ANi8Sv93yF0kOmtfp7ZDtpt7iVAtl9RzB5XjrTUbh8910zrFYVZubZdNaORZsbxLmipWqVO79ThSNKt87WQ8tc9wktms46ix5N8Mv63W00Fjze2AJpTiqoqSCpUC0QTSo6Bk7VcLpm4EA5bcN8Eb/AYMC6a19B3tTZCLaYMebh05D6x9defUp59SfJBI11WhsR7Nt3OE444Rpx/z//uRqmdrqGyjRPajKSkZh4EFJSDnWOn8mFyCBOVlygGOvN18IALNmGiHPqNjpLKrgosf0iLbV3iEVRXv0GOyY9qBeROhBfgZWLG/q8gamJZ8FiN2P+ztPxa8VnCDRI4pfiYtfOCqnN0duXZEKW9lue+uF7Sg2CXJTz2q2vUW6gslpic4hIs/1GKgh5tV7nDNxSpGL0gtkOUhGBX+/8X5ukguDPuU5MKb1ESwgPZ7VGCVUphs7yKamQ0zfMG5EhZiRCFHB3hlS4Cn35fvKCRVWBAh3dhli0BDUFQpBdsQ3iTvtDVSrunnb3AVupcAU1K+yCsSpEckEzLX+ALpxrrn8DBRNOEcmHYx86GcnrvvdZjgirCq1hzpx7kZTUCwUF27Bo0YIOPZeMR04RxCIhYZAzRZMnrfLy9c5cDC4mvMplP51tlNZ0Fm3Zb0vhoBo/3ebsTfP/SVio8ZAEJ9VvboCN5GK2k1wE4rQIiV6jL4kMXCNB4OKixlHl1I9cAF0htQC9HBob5pLIK++2QKIiJw1k3ockMYw7958NtHS1lDEJKsRPtD/mn45eKz+BNTQcv93+KUpHtC/1meSgcQKHIuR9VeSRkfXIzMwRVT4+nxTQejfrwxX8e5tapPd2xM6HeDi0TOWKBD656NbEoqSEB7lJtEDaGzDGE+o9P97j1FSQVNxzuAxL0pAVIQa4cXfSJt1fMRf2kFCsvuldFI49AQZTA8Y9MAtJf/3s0xyRlhAVFYeLLnpc3P/ww4dQWLijw8+nhJ+JiUORnDxK3FfEhs+vyt8UuHGxYmBXZeUWVFbKsC6OgtIzg6ShcVPhXvJ7eJJyHT/lyYsLJCdGKEKUNtz+P01IcvGmk1w8suN0/FT2LgINMvBMjZ1KDwmSPxIGNero6i3hCtkGkYuxrES0vIDIxSXfMabqOmnge3+KfQ2wZNtH2mRHI9hYL4Saaas+F5UKkoriUUe79Xt53Cvfi+amYjxuMzL2IDjYJszo1MivL6CEsvJ9kAJVmRkU67XQMjU1Fujkwv9nDC+hoaEB5Q53p/a2QHhiJaFQNt101NSkYl+wb0dyQRuQnBz4NW6d7px7Rx2DEGOdNNrZtMLLOSKJ+x0/nTp1NoYPP0K0QtgS8YSMiSK8pKRDxJUQr0xV2bslJ0s1McITsKtFt9xkuJdSqsu/SVobk0xw4+/35RWfu+RCOXT+e9ccfFf6KgINcrxTplK6xmDzPsmFqzlWc58C6QrZNPVSZrPIhYwLd1M/hBTniKs/4ToyK1t08WKklIS/xx+LYQmPwq93foHiduqOWmoVyf0mJz6UJ0x9fR6Cgvg1GpfJQC9fQJFD5Z4p3Wblwu8tyBZPo1eKPDYCk1x0G/GmK/gn7d69W4yY8jlo270/2Ow2XPvVtXj2N5na+sQxT+CfE6TxkUbLIKlYvFhWLXr39t9e4lURjXY4vmaOZPz6Vyg/eLJXnosLAk/s/ECzPdBakNSePZtw7bUjYLGYcOON7+CwwzyTeMvnlXkH9S2O0qlgMIAjqdzkeConF4jGwC6DR3QZ/gA/qy/kXonFJf8Rjy/PfBYzU69EIEI5KCpdBVtqYWFJMJsrnP4EHNeV7otB+8Saq/wI/pzMI7E2aRH4m1AQJK+shvE4k22fNOGoyc8kfSrESOldX6Js6NROPY+rmFMSLwqMbbjrrmjk56fjvfdItOB1SK+YIodQljoQ2cLyFawif2iPQ9gtPWRcx3G1eNNLoF8FSUV7WyBWmxX/+OwfglQEIQj/OeE/mlS0A9RaUNBJUzKHS7pfYAuPxG93fIaSYdMRWl+NCfccg+QNS32QI1La6hVDRsZBOPPM28X9l166FlVVpR6NWmalQirGCxyz8nZnyZQnG5bHebLjVTNFgSQfMp01xpHp0bkxVH+C9t/MFjmxh8zneSH3Knxc9G8EIrjQKhFfo227dOVUVQkKgvk1ZQMuySCNrWKEYJFElroatZBQuxAIVYqWvSp6IqSuChPuPqaJ+VVnSYWrmJMTVKpqYzBIUmG3B/m89dEolPUdqSCkFXimS1utbQt5fyC4O7ZA1BQIScX+WiBmqxnnfXweXln7ijhhLTx5IS4dfamPXm3Xx6BBwGGHSdtvf+aKWCOisequ/6F45FEIaajF+HuOQ8q6JX7NETnttHnIyhqKyspivPrqjR57finm6uWslpDgeDtzItDARfri9MdxRs/bxONX827EuwX3+zTEzb0FMU20R6RmJUgQCxWZzSkK6l727v0VZWUbRIYLtTE0WJK+KVw0ab/ONkm2M7zL35BeFXkuXhW9EVZbgQl3HYWkTcthik4QKaUt+VR0Bnw+6TTbIKo/viAVyqadFaimQln/CJqDg0MFuVDkVAqC2zeF5gsEd8cpEN7GxsaKrS0YLUbM/nA23tnwDkKCQ/Duae/ivBHn+ez1dhcw6E3lijAV1V+whkdh1R2foWj0cTCYHO0RL4yitjdHJDQ0DFdf/ZL4/iVLXsPatd959DWwFaNSKhtzIdpvA97VwX1wXvqDOLfXA+Lx2wV34fX8WwOSXBCy2qCmbHo4qkfRCA/nKLNBEA3pZ8FYcXqGRIvFKyVltKgESOGuPL/5G3IsNt9lEiId4ZWlmHjHkUjcsgqm2GSseOB7VA4c67Hn5MLJFgArBCTVJBUNDQUwGLxLqPkZV58tVTH0t1DWVXPRaCGf26qo3NcI7o4tEFYpKNhsCzWmGpzwzgn4eNPHCDOEYdGZi3DG0DN89lq7E/j5GjNGZovk51O57b/XYguLwO+3fYzCcbPEtAjzCHr8/qXfckQOOmgiZs68Stx/7rnLYDR6dufIYKXMZtMGfmR3fsCZvW4X1Qvio6L5eD73ClgDuHrDdhqnHLgYy5HiwUhNHYv4+AFOwsHFguSV1s4ybdY1rl2GavkTzb0qoksLMPnWqYjfsQbG+FQsf/AHVPUf5XFdgWq5UMgcEhIuRkx79pSWAt5rfRT6tfXRFlS4nBpTZuXSZGrd78NX6DbEgoSivUZYJXUlOGLhEfhux3eIDo3GF3O+wKzBs3z4artnrsjEicDIkcDu3Xw//PdabKHh+P2WD5v4XPRc6fkgKyrVpTcBc0RaDwo677yHRHYIR0/fftvzo8tq3LDRAyHf4cLo/ytbX+Gkntfjyqz/CI0URZ0Ldp4Fsy3wqzfC5lqE08kAM+lSGeoQRFKAXu4wXJJx7Y2R2v6rXDT3qogr2IXJt0xBTN4W1KVm4ZdHlqG6zzCPPZ/rdAyPdeURwedmZScmpgbx8azyeA6sQnL/B0rroy2oSSI1jm40Ms8nX6R4+wvB3a0FQhOstlogOZU5mPrqVPyW/xuSI5Px/dzvMaPfDJ++3u4K2nxPmQIMHSoNtCjq9Oso6s3vIX/yGdKhkwY9y973So4IocKGWkJUVCyuuOJ5cf/TT/+NrVt/9+jrkK9FnlyU7oILkjwZB5aoy5s4NuVS3NT3PWH9vbziQ9y3/XjUWX1TvVER9WxjsKIg3Ut3Ca8QCi8rKjY7PEa2Cr8Rlq35fcq2XYH6CYo9m46q7hbVAZkOqshFlV/IBZ/X1asiJWczJs+bgsiSXFRnHCRIRW36II89n6ufh5qAUL4qrOrINhL1dMVC1NlZyHZTmUNgq1w8A6P10RYkyUtzmIkFwWargcnkP2LdLYgFmRmj0PfXAtlYvBGTX5mMTSWbkBGXgZ8v/Bnj0htT9TQ8Z/09YICMr/eb9bfDROuPG9/GnmlzEGy1YPSCs5C1+EWPPgdL2mr0TZ1wW8LYsSdg6tSzxLH6xBPnt9vuuyO6Cxn4ZBALHRelQOm7+gJTEs/AXf2/RERwNNZVL8EdW49AlaV1gW3niESdi2vpVtGGIlkgueA+Z09eCg0l4VSjvyQS/Fl+HycMSDQo1uSCpsZLuZhxoSBhlMLBXFGJYmWj0d2T5EKGK/oCPJ5IZggS2LQt6zDxtsMRXlWCigGjsfzhn9CQmunxILPGBZ4tv6aV6NDQBOFhQS+L+noZz95RKFdLGtCpmHcmqwZS66M9fjdRUdRd0PLff4Fl3YJYkFBkZGSI2HaOmLaEVXmrRKViT9UeHJRyEJZftBxDUof4/LUeKNbfTJhNT5eVC39W5IX993WvY9exl9O0BSOeuwz9P5rv8xwR4rLLnkFCQk/k5m7EW295LyFX5hRki7KxyhdwHUnt7hgZNwMPDvwBcSEp2Fb3O27ZPAXFps47uZEUcFxUkoFtYrF3dS3losdKAxddkgKSA1Yf4uL6CS2F3PqJloea6qFWR06JNIgFjRktMnK93jGq2tcZtU3tDKdHWKaPiOjp1FzI8UfvvrdcdOXkEdsyscja8KsY6+Z4d8kh04RQ0xTfcjhfR9Boa94omGypDcF9UFiYBqvVAJvN2OaUVuvPJdNpWWFSuhG+f1LX4j979I6CDqQGQ+cySjqLbkEs1AEWFtayW+C3278VmorS+lJRoWClIjPec8xaY1/QlZPunHTppObCrzAYsP6K57D1DDmaePDCeRjy2i0eYzxNc0Sk+2BLiItLxlVXyYrJJ588hr///gXeHUfLEuZLBK+sA90G2JMYGD0Wjwz6GSmhmcgzbsYtmycjt36j27+H7ymrDzQlkxboeQ6jKmmOJF1LewoCEBc3QCyAKtGSx4TIynAm0MoUWiX85ffxPYqN5ZRIT4ezJJ+POSM5griQqFLQ2aihsTsC6fYiOJg+FiQ7MjjOW+PGjRHoUuMwaNV3GPfQKUIcTZE0DeksUZ5MqpZBbDL6vNGJtDVYLCEoKkoT97lv3KnQyWmq3c5kWOmaypFe/y7MXR3dhli0htfXvY7j3z4eteZaHNXvKCw5fwlSoqTBkYZ3QW8ykovISDpR+nlvBwVh03kP4q8LZTDYgEWPYvizl3qsV9OYI1LbYlCSwvjxJ+KII+aKk+eTT16AhoZaL/ddezpHUmUAluzXHwjIiDgI8wf/gsyIISgx78EtWybjr5r25clwEeUiVVOzSyyqrAyoSHJWGiQh6OeoPCR0ygKdlQ7+Dvk7G820VGAZKxh8/6j+Z5uLiztfC6scViuD5KodZMTzFs+NY6UmBAcZMHLxWzj0/+aK1uKew8/F7/M+EgZ1nnw+6SzbOHHSHiOwmhqSe0mipfbE2g5CkeusipDAyCqT9IbQ6By6LbHgAXrf0vsw95O5MNvMmD10Nj4/+3PEhLU/4VSj88jIkImohCNo1q/YccqNWHv1y7AHByP7m5eF7oLpi57MEdnfRMYllzwhpkSYgLpw4Tx4G3IkNbtJuJWKd+7uSA3LxMODfsbg6AmosZbjzq0zsLTsnf2U/GlYtV1YcTfGxnPhzxatDFYaVAvD0+B7xAWOFRBWm1xbICzzs2rBNpciGMpllf/H18ty/v5SUd0Bj0VZvPMAAEXHSURBVGUu8sF2Oya+tQAHvyHdZLef/C+suW6h0DF5CjweSQpUWiv/Rnfi3ynkVHonvu59fz/JYoXQs/AzIMlLkCCKcXF9nYROo/PolsTCZDXhos8uwt0/yqjzmyfdjLdPexvhIf63wD0Q0b8/MG0aT1L0GvH3qwFyj74Yq29+H9aQMPRe/iHG3T8LhrrOTw9QOc5yNxcnXu22hpiYBFxzzX/F/S++eAbrvBz53mgDzNZInKNlU+LMG+juiAtJxgMDv8fEhFNhsZtEeNkHhQ83IVaSUBSJBZwjhjLplULJNIehFVsVPgiicICVEVabXFsgMoCMr6/KqaPh4sv7nE6yWuvFJFB5+YY2q2btBXUHdP80GOsx/Zl/od/iF2EPCsKGS57A3xc9JmfMPQiSAdcxVndFkySArlMzrDLJPJFK0VqhSJbiWlZ6JFlMFASORLEraikCGd2OWFQ2VGLmWzPx2trXhEX388c/j/lHzRf3NfyHIUPkKCptvytlIKBfUTDpNKy66wtYIqKRuvZbTL5tGsLLCjr1O3myUkJOEou2Fu1Ro47GscdeLu4/+eRcVFd739RGWYFzsVStEWkd3boHR3dBeHAkbu77Pk7qcYN4/Eb+bXg25zKYrA1iQZMLdoXTM0K2JWSv3Z+x8axgNLZA5NU4xZrKSlsSjD5OkhEUFCquyktKfkd1tUxU7QhITLhfwqvKcMyjl6D3b1/CGhou0oR3nuj5cEZWW7j/CQbr8e9yB0FBtPg2CsMsvl8kRWVl68SILytQ/Hu4L7gPSSTYxqJ2xTW8S8Nz6FarLT0qOE66ZOcSYXzF1sflY+TJW8O/YIWR5lkTJsiWSE3nL6g6jZKRM4RDIJ0C6Rg45aYJiMn5u1O/kxUBFe9MlX9buPDCBejdeyBKSvbg6acv8VlrgoulvBJW8d0FjsmCwHWr9AQMQQZcnPFvXJrxNIIRjG9KX8K9W45GRT2TOe3iClku4hli3wQSuNAya4RGTSrMjG0PRQolweiH5ORhYkySY82cXCkpWSPGWN0hGGyl8HiIKcrBcQ+cg+Stq2GKTcKK+5cIQu5psBKjKnysDLmm9TYHj1E1qkviU1e3B3377sDAgSQQu5yEiwSDf4eouBgiRDWR5EtO2STtM7aq4Vl0G2LxR8EfGP/yePxV/Bd6xfQSkx8zB87098vScAErp+PGSftvijkZ7+tvMMtg2YKVqEkfhKjiHEy5ZRKS1//Yqd/Jk6MaBWxLKBkZGYObbnoXISGhWLnyY3z9tWc9NtqCNBvKdC5UXKBYvTgQhJ3HJl2E63q9gLCgSKyv/xkP5p+HhjApjgxkzwI52pzs0MtEOEmhWkzlZFw8kpNHCy0I23JsA1RWbhITLVyM90de5e/MQ/LWP3Dc/WcjtnAn6nr0wS/zf0H5wZM9/jexsqBGRFlJoJaluekYiZGcytmByko55iv9QjjeXYvQUFUZDBbtKu4Dtq+4r6h74mMe59xnGr5BtyAWuZW5OOzVw1BYU4hDehyClZesxKhenvOp1/Ac6LTOwLLhw4GdO+n94P+9W5fWD8vmL0fZQZMQWluJ8Xcfg95LWxf4tad8rcbV9ifk7N//UMydK301Xn75OuTk/AVfL1RKCS9TEnnSlgZB3Q1SR5Ev/saRkYfhjvS3EB/SAzmmjZi3fRo21/6KrgDZHslqVr2Q2hCCZoFsjyQljRA6AqvV7CAge8SUS2tZMnIiowBZP3+Eox8+HxFVpajofyiWLViBmoyDPP53SGtyKbLkcchKghy3rXGO93IqhpU/qZeQBILtC6krSUJERBpyc7OwfXt/xMYOFKRLtvt6iX3Etgh/3pOCVo0DhFjQk+LqcVcLa+5lFy5DVnyWv1+SRhug3Qij1qm78Lf1t4I5LllEPOdPOk3ki4z+9xxppNXBBTY8nCd96ZqoesetYdasf2L06OOEG+eCBWfBaKyHL9F8dl+OWe7uNkmpsi1V6mgdVDsmARIwIvVEPDb4V2RHHIIycwFu3XIYlpQuRFdAY/Wij7P1Ri2BHDmVC3B4eDwSEoY4piuiYTTKlgMrHC2NHRvrizH07Qcw5YWbYDCbUDj+JCx/aCmMidIjwpNgtYGvl+D0C02d+LjRK4TjvVbxGSKJoHaJLSoGtbEaw7+JFY7Q0HjU10fCat3XPIu/V+Xn+NKhVAM0I/Tt3q6qqkJ8fDwqKysRF+c5UxUb57ptVoQatBinq4A6i2++keSCFuBt5Mb5DjYbDn71RvT/9P/Ew13HXoYNlz7dobE6lRvBkyN7u231dSsq9uLaa4ejoqIIM2deicsvfxb+gBTtFQofB7kAyyvJrjiGJ69+mW1R4vR34EJD0Z6rNwLzRJ7YdT5WVn4iHlPgeUH6fBiCAi9wqrW/k+RV5dXIiYdkp2Mn30u+p2x3SRGj2THKKp1CWflAbQUO/b/zkbX6W/E7t542T/i+eHrygyDJU6+VlTK+XteKAls4dPfkxvZFW8ce26lnninvv/++jBRwBUkWW3wkKfw7Sca6OxoagL17gbPOkgaF/li/u0XFguDUhyYVXQsxMdL6m14XJBd+DONrRHAw/r74cTFSx9G6Pov/gwl3H4PQKvfnZFkB4ALGk9r+hJwJCT1w/fWvi/tffvkcli37AP4UCTY6iZY4rm59W0XpLLiAsuzPq2CVv8ERRuoomhsuRRliMa/fR5iddqd4/Onex3HftuNRYylHV4AkgIlNEm6lPbgcTZUBdemIju4tKjUkFWZznRhPFYZuO5Zh6q3TBKngCDb9KTbNfdjjpEJWVfKd4Wt8fr43yiuEr4vvj5rY8IRXCN93/i6CFRuOmmp4H92GWGh0XevvGTOkSyc1F4FSreRI3W+3fQJLZAxS1v+AqTeOd3tiRIaC9XT2k2lR3BY4gnraabeI+089daHIFPEHVDYD+9SNIVg5YlEI5F61vHKvdhgg5TnCqwxiYZGGU7FtXpic0/s+MZIaHhyFNdXf4MbN4ztkA+4vqPRP+b5JPxVqJhQxVNNAJI3cFxxNTdi8EjPvnY3k3C2oj03Aj3cuQu70cz3+2ngMUXjJEVgSC74vbM+ohZ9iS/p2kBh5ujrGKRP+vUpD0tERXI32QxMLDb8jJUVaf5Nk7NqFgEHR+BOFqJOq+OjC7WIctcdv/3Prd6hcCIL5DvvrPJ577gMYPvwIYfX90EOnoK7Ofx4T0rFTOkASXLRlFaAgoAgGFwoZIrXTQX6kAZIcMWwM8WpvOur8Qb8gNSwL+catuGnzBKys+BRdBXIyJE783VLcSb+SBkf2SI4gG0y/5P8N/OVzHDf/UkRXlaG0d198cdc7yO87oIlJWGfBsVcSveLi3x2GbEZHSyJFVJAa3x/vLkUMbSPZ4nHbkaAyDfegiYVGQKBXL9kWiYoKgFwRF1T3GYafH/9NJDgyyXHcAyei/0ePulVaofBMnuBZem7b4dNgCMGNN74jLL/z8jbjyScv9KvojFeWvJLklIFqj8jRVLWI+0/gyQWTV7/SUXGvWDT5erlosZwuF1b3hTv9okbi34N/w8ExU1Fnq8JDO07Gq3tugsXedVxKXYmVsgbn8cfFvb5iCw596UZMeulWhFhM2DVsIr664y3UpKSJ45OiTlnpyOnQ+DGJHkloZeVWFBX9IgSZPE5Ishm4Fhc30OECG+sz7Y6sXKmgsvIDYqzan+g24k2N7gFqLSjo5Pmmd28EDILMJhzy0rVCc0HkTj8Pf171Imxh7ZuN5yw++968auLJfn9XaFu2rMK8eVNhsZgwd+4jzhaJv8HFnL1qV8toWZVJEPoMb1958vlV6Jars6kKB+PVuqdeA4nEwrxb8OleKeQdEj0ZN/d9D8lh6ehqoJaBEyEhBZtw2FPXIGXHn0JDtHrWhfj7lH8hOCRMmEpxNbBYamQ+SDBzSMJFRYFW2SEtRCJw+eD7wEqEem/4PBZLrRCNurZoWos+7wz2J95sDtq2U+gqP4d9uqWVd0MAiDc1sdAIOGzaBCxZIk8S1F4EErK/fA6HvHgtgm1WVAwYg99v+QD1Pfvs9+d4AmYbgaVYLoAcldsfFi/+D5577nLhS3Dvvd9gxIgjESjgFagiGOrahAs6yUVICJMmozxy0ubiZLXWiYWOQkNXMqGeLzQ0ziu9eYXl5Yvw1O4LRfUiLiQF/+rzNkbFHYWuhuQ/f8DoBbMRXlkMY1QsvrvwVuSPmOaclOC+luSCE0GSxLmKdqmJkM6yNOeyO9wtSSpM4n3hMdHoNREi3hO2O6gz8pbTpbvEgtUUOUptEn8L9SjdDQ2aWOiKhUbL2LAB+P57gIeIp1l3Z5G87nuMefQMhFWXwRSTiDU3vIm9Y/bv8sqFkaVoLoCcvNhfPDNP3k89dTGWLHkVMTGJWLBgJdLTByGQoEKeuDVd9IMQHBzuSODkbZi4AibZaIkAyIXK6rj6NYlFimSieatFkoloMYrIhc5XOR4Fxu2Yv+MM7KhfgyAEYXbaXZjd605hEx7wsNvR/+PHMOT1eQiy2VCePRQ/XvMEantmCZKr9rUSNcoqhNHxdZKLasfkhuwAkiRIF0v5XsotRFSNWNWgtwTbUHyPvN3qcJdYELIlJG3cOSnD19md0KCJhSYWGi2DJ7C1a4GlS4GkJCBRJpIHDCKLczB6/hlI3LJKPN5y5u3YfPa9+zXj4LQCr/K5OLI0vD/QLOv226djy5Zf0avXACxYsAJxcSkIRCgNSUuEwBXy6jVYLDqy2mETi1prXVkSE179qs1foWAmWwNe2vNPfF0irddHxM7A9X1eR1Jo4F71htRUYMQzl6D38o/E413TZmP5ufNgi2AuSpbT5pr7vpHM1TepPhDS6K3KoU2wN/GbYMWDlSODIcpjlSpvEgv5cyXCT0N6zPTxeIvGn9DEQhMLjTbAdWb1auDnn4HUVCBeGkMGDILNRhz833+h75fSzKp4xJH4419vw5TQev+GV35sicirJRl5vT+UlxfhppvGY+/e3Tj44Km4//5vERq6b787kCD9CerFFa+8+jU5yuytS7rklS+vhsMd/f1Iod8ItJP+D6Vv4rncy2C01SHWkIxrsl/GhISTEWhI3LQChz52NqL27oYtJBR/XrQAG6YcK2gB2xOuuRwtgWRPBXrJ942VDIsgxiSQshghSR4rUmyBSfIX2WnypwinbM9YHcRT3vJ1qP83GoHrriNBDcJTT9HPg5WyEMcmzbda+/0Up3KCqL0kv6ugQVcsdMVCo23QNGvVKmD5cqBnT9kaCTQwV2TEs/9ASEMt6pPTsfqm99oMbFJXSywdSwHZ/k/CzBC5+eZJYvz08MPPFWZaXc0NU7U75CYXKrCx4CAUrbVJAhH0t/j3rnNEa4Q4OvkSXJzxf4g0uBf37RXYbBjw0XwMfutOoQWqTeuH1f96E7m9eghi4Altgcr0MJsrHW2UpoSRx7YkiCGiTdL4vsrbxkpVU9Ig22HyGGkPzGZgvozawS230OCt6f+T8LAqIwlPdBOSKv1Z6MppbxfR6ipo0MQiAFcJjYAkFytWyC09XTp2BhponjVm/umIzd0ImyEEm859ANtPvrHF1ghPoBzX5EneHZvhNWu+xb33HidOvHPm3IuzzrrLC3+JRnthtpnwVsGd+LhoAa+hkRbeHzf0eRMHRU/w204MLyvAqP87D6nrlojHew47G+uvfAGVdk7S1IiFliZZnmwnkQRQP0SCwc21hdJZ8HU2kk7ely00WSlhKi9w0038Pjvmz7cjLIzkxOLQ6uxLTuQEU7xD/xEsRk85qsz7MjW2bd1TV0CDJhaaWGi0D1YrsGwZ8NtvgUsuDPU1GPHMP5D+87viccmww7HmutfRkJq5z/dyzp8+EDxJyhyR9mWRLF78Ip577jJx/5pr/oujjrrIw3+FhrtYX/0j/m/X+Sgx5yIYBiHqPDPtdp9njaSuXoxRT5wvpj4s4VHYcNkzyD3yAhhFimiRQzTcqKvwFrigu7a/ZE5L8xZYkAtRMLRAINpXwWpLYyHbcUZHS47akYZ9Jpg4USTHY+sE6WDSb1epmrUGTSw0sdBwA0xBVeQiK0uaaQUc7HZkfveq8Lxga4RTI/S7KJh8+j7fyiRKntB49UR1envx2mu3YNGiR8UY6o03vospU87w8B+h4S5qLBV4IfdK/FT+jng8KGocrs1+BVmRQ72+M4ON9Rjyxm3o99kT4nFln+H44+b3RNS5smNnlYwjzpwC6erVSy6c1FawDVJbC/zzn/L/nn4aiI6W6ckkGLzdd4KJQWyVTZxjSWCoGSHhor14Vw8qawiAioV23tToMggJASZPBkaPpuaAZjcIPAQFIfeoi/DTE2tQPnAswmrKMWb+GRjx5EUw1DV13eRJjFdHapKivaBh1tFHXyLskh9//BysXr3YC3+IhjuICUnAjX3fxr/6vIVoQzy21K3CdZtG4Z2Ce0XLxFtI2LQS064b6SQVO4+/Gsse+1WQCtdsDJkPEmCjVe2sVJaWSqv/LVuA7dvlY15kkDhwYkyBpILFBp4X8vLk92/dCuTny69RXxERkSQqhNL5M15ULpSegwmwdAkl+dDoHLRBlkaXA69UOIa6Zk0AVy744bKYMfidezDgw4f5QUNtWn/88a+3UDF4vPN72N9ln5dCN9n7bl8Z1mq1ClLx88/vISwsEvfe+zWGDp3qxb9Go70oMe3B8zlX4LcqmSuTHXEIrs5+GYOjG993T0wkDXr7Hgz4+FHhTVGf1Bt/Xv1SEz8VdWxxvJe+KYE2XdMWmSgvlxvBDKG0NNkC5f3Y2MbKBAmDaovW1MhKBa/Yq6t5dQ0UF8uLkLIy7g/5c8wmUi0TkgoSCbpxMgmXI9NSVJ0tHEc56dLVWiMNAVCx0MRCo0uCoq2ffgp8ckEkb1iKUY+fh8iSXNiCDdh+6s3YctZdwg6cJzYp5LSKCgZPZu2F2WzCww+fgt9//xJRUXF48MEf0L//oV79WzTaB1YLfi5/Dy/tuRaVlmJhqnVij+twTq/7EWGI7tRujN/+B0Y+MRdxuzeIx3sOPxcbLn0K5pjGY4dCTXqmEBylZMWiKyyIRUXylpWIAQOAzExJKiIjW/4ZtkJciQWJQ0vtk5ISoKBAVjF4y4sTuvqSqDROuVSjomKjEKJSf8GKBskY7erV/a6ABk0stHhTwzPkIju79ZNPICC0phzDnr/SKeyszjgI6659BeUHTRSulbxaYllWCjnbfwKjgdY99xyLv/76Sbhz3nPPYgwaNM6Lf4mGO6iylOK/e67HD2VviMc9w/riiqzncWjcMR2qgA384CEMfP8BBFstMMan4s8r/4PCiafsoyWgVwrJqsz5CDBf/BbIARf74GBJJA4+uP0XC+0hFs2rIXwutkhIMljVIMGgAR8LEyRkTGOV2ieafcnPIqsW1EKRZFDkGcho0MRCEwuNzpOLH38E1q0L/MoFkbZ8EYa9cCUiKopECNTOE67FxnMfQJW1VJhJMfGR+QrugN4WJBebNq1AZGQs7rrrC90WCTCsrlwsTLWKTTni8fj4k3BxxuNIC+/Xrp9P/PsXDH/uMsTl/CUe5086DeuveB6m+KaZM1JXQXfXWrfba76G0kKwpcHqBAlFRoYkGO2Fu8TCFWyPbNwI/PWXJBhMWOaSRJJPsk9SQSGn2VzVJDNFBbNxoiQQ922DJhaaWGgcWG0RIrS6DEP/ewMyv18oHtf27Is1Vz6LXf36Oxw53S9d19fX4IEHTsT69T8IzcXtt3+KUaO6XlBWd0adtRrvFNyNz/c+BRusCA0Kx6k9b8bpafMQHhzV6rEyZOE8ZH/zknhsjEvBhn88hfzDzpKX2K2k6AayLwM/ryQUnPwcNAgYPlwmGXdkje4MsVCgGJTZRNz42tLTbTCbWfExixZIVFSaGFU1GisEyVAjq41tkgSvhax1BJpYaGKhcYCSC+U7MOLZS4X2gtgxfQ5+O/0aWOJ7tNuRs3lb5JFHTsPq1V8hJCQM8+Z9iHHjZnnp1Wt0FDn1fwvtxbpqaWKVEpqJizL+jckJpzdeAdvtyPjxTRz8yr+ELwWx+6iLsXHufJjjWlbkseJVW8vRUrtYDLkoBhKodaCGgsLKvn2BQw+Vn1V3KhTeIBYKnB754w/ZIomMrEd0dK4w3nK13qcmymhk6F65w59DtUniRRUjEIhcg65Y6IqFhudAQRZzRZgvwpJqIJpoNUdIXZW4Iu3z1fPicQPTUs+8AXuOvhQRUe73xs1mIxYsOBsrV34MgyEEV131ImbMuNALr1yjM+Div6LiY7ySdwP2mnaLrw2LmS7aI8PKozDs+SuQ+uf34uvVmQfjzytfQFkbUz/SzVVdZbvfTvM2SCZYpaCegePigwfva7/tb2KhNBibN0uvnMLCYiQnlyEyct+pGiX25NQNqxkKaqw31I9iWU0sNLHQ8AK5+OUX4PffZXmVo2ldAUl//Sy0F0rpX9x/BDZc8QJqBrlvD221WvDkkxfixx/fFI9PP/1WnHvuA8JQSyOwwCCzjwofxaKi+Qivb8BtPwM3rAxGmNUGa1gEtsy+C9tP/hfsoW1fCdOvgmOTalTSlwmj+1uoOe5JsOXBKkVXOO1Tc7FqlR1r1+5GSIgRPXrEIDY2vcXvpdCTBIPCTwWDIUwQDOay+DqNVxOLrnCEaXQ50DyH5IJXHUqQ1RVA1X/fL57BoLfuRGhDLWxBwcg5+mJsnnM/TIk93fpdNM96++278f77D4jHkyadLoLLwsMDW9F+QMJqRfzXj2HoW/cguVpe/S4eEIT3z52DacMW7DeWnYSCxIIleVpSB8rUQmWlnMDgpMeECXJyKwC1jm22bv7+24iff96Nyko7srLSEBvbenuJbp70wzCZKh0prNLVk+SCbZL22vZ3FppYdJUzvkaXA6+UVq6Um+u8eldAWMluDH7xKvRZ+YV4bI6MxbYzbsOOE68T3hfuYMmShXj22X/AYjGLMVSKOhMT07z0yjXcRfL6H4WQN36HTEktT8vCvcen4smM1SIIlKLOE1Ovwyk9bxLuni0tZjKh0+ZWoJ0vqhQskI0aJbeuoHlqDTt3lmHFimLk5gYjNbUPUlPbJgh2u02QC5IMV+tw6jSk6ZZ3d4YmFppYaHj5ioNVC0auc07d0y503gSDkWLXfoUxb89H8s714mt1PbKx8byHkT91tluKtw0bluKhh05BTU05kpPTceON7+hxVD8jbvsaDHn9VvRY87V4bI6OF20PWnKz7bGheikW5s/D5tqV4v9jDImY1eOfOCH1GsSGJDn7/BRrUrTJxYrTRP4ef6TOYc8eqXGaOBHo0wddHtzPu3blYuPGemzdGomgoExkZQW1FFy8z89ZLHVC6MnxX9dxVTlN4p02iSYWmlho+IBccFKE4WXUW6Q2HfsPWPCkxCtRq7keA1d9hxHvzUdkqXRSrOw7ApvOfVDaN7dzIcnL2yLGUfPyNovRuHPOuR+nnXaL1l34GFEF2zH4rTuR8ZMMK7MZQrD7mEux5ex7WvSk+LXyM7yRfxtyG/4WX4sMjsGxKZfjpJ43INISIggoy+2cIvKnMyQnMNn2oG32iBHAuHGdF1IGEsxmM3bt2oWiIhu2bUtFcXGSIE2uaaptwSraJOWibdW0TcJpkgSPtkk0sdDEQsNHJz3OqHMclUFmFHV2BdCUh8mURHxoMgb97wX0/3gBQutkSFLZQZOw6fyHUHrItHZ7XTz//BVOUeehhx4rdBfxzRY0Dc8jqnAHBnzwkPAuoWsmseews7H5nPtR16t/mz9rtVuxomIRPih8EDvr14mv0QNjauypOD7+YvRJGO8ch/TXqDdDwmjDzSoFvSm6o06Y+RiFhYWorw/Cnj3Z2LQp3Ona2V7YHdkkFHtygodglSkkJFo4e/J97GwVQxMLTSw0fIhNm6RLJ6sYFJR1BdTVFYleLVXmHHkLqy7DgEWPou//nobBJN0AS4Ydjq1n3I6SEUfut4LBq+Bvv30FL754NUymBtEaufrqlzF69LE++osOLETlb8PADx5Exg9vINgmUzT3jjoGG89/GFX9R7n1u/jera76Cu8XPoBNtSvE14JhwGFJZ2NW6rUYGD0WvgaDwuhNcdBBFAh3rXZjR5CXl4eamhrRzigpycaqVUHCOdRdgy+7aJPUis+2a5uEpEISjFjR3upIa0sTC00sNHyMHTuAH36Q8+8sZQa6Sl2GlNGfwCKEeRToEeFlBRj4/oPI/uZFBFvklU/5oPHYeubtKBp7wn7/sF271uPRR8/Enj2bxOPp08/HxRc/jrhWzJc03NdQ9P/kMZENw/RRYu+hx4rwOebDdBRSV7EHG6p/xOeVL2F93c/O/xscPUFoMCYlnI7QYO8aNfFPopaC1cAxY+QYKRfY7g6LxSJaIkwXTkpKRnl5ivDOoU8Hzyf701201iahoycrGaqKQbBlyXRVd0mGJhaaWGj4ATTqWbJEJh7269exk4EvQSOe2tp8cWKRNs3hzv+LKM4VC1j21y/CYJKjilXZw8QESd60OW1OkTQ01OLNN+/A558/KRas+PgeuPzyZzF58uk++bu6Hex2pP7xtXg/UtdJV02iaMxMIcysGNz52HSW0BmHro6FHQ3r8Xnxk1hW/h4sdrkoJYak4ZiUy3Bs6mX7HVXt2GuQrQ+2AaZMkZ+hAwnV1dXIz5efx8zMTFRWRoo26+7d0lE0vPHj2aH2JwmGxVItQuQUqMdgm4Qb2yZtkQxNLDSx0PATioslueBVF0+MnnAB9CZILEgwQkIiEB2dtc+JJay8CP0++z/0/fJZhNRLox5jfA/sOu4KsbXlg7Fp00o8/fRFyM3dKB7TBvyCCxYgI2Owl/+q7gFDfQ0ylr6FPl884zQ4swUbkD/lTOw45UZUeijKng6P1NyQBEZG9hSiP4VycxG+LnkRi0teQJk5X74uhGBCwik4MvkCjIo7GgZHUmdnUFFBR0pgyBBg8mT39AXdCQUFBaiqqkJYWBiys7NRWxssKhcMNEtP77wxH99jq7VefOZpvKXswxvbJaqSsS/J0MRCEwsNP4InSWoumA1ActGZKw1vgycWtkTYGmEMNufhW4tnz/rmZaHBUBkk1pAwFEw+Q0wfCFvoFq52aAX+3nsP4KOPHhHOnSzDHnvs5Tj77Lu1uLMVxOT8LazYM75fiND6avE1S2QMdh/9D+yc9U/U98j22PvPSQIxJWQ1iUWF+RUtgVWLFeWL8L/ip7Gx9hfn11m5mJ50viAZGREHdeD5ZaWPzrac+KAtd6CTcW+CrRC2RNgaSUxMRI8ePYSIlb45v/8uhaye0ps0kowaQTRaIhmcLlH+GJpYaGKh4WdQa8ErjfXrAz9fhKY7jHTmyUSOF7Z+Zg+yWpC2YhH6ffp/SNosvRCImvTBgmDsOeJ8mOKkXsMVrFosXHgLVq36XDyOiorDGWfchpkzr0JkZADvHB9mu/Re9r4gE8l/L3N+vab3QOw67krsOXIuzDGev4xXUd4cKZW5Ffvv3+2sW4fvSl/F0vK3UGUpaaLFODLpAkxKPB1xIftf/Ugmdu4EUlJklaJ//8DXJvkCtbW12MOSJygGz0RUVJTQnqxbJ71zOBnDc4onIUlGg6OS0ZRkqDh3qzUWxcXBOOssz4tpWaWJj4/f7/odZFcZsD5Ce1+YhoavwCuNFStkeBlPnoFa3lXCPZruMOSIhkjtQfzW30XsdvpPbzvbJPRP2Dv6OORNOwdF42bBGt7UDXDduu/x6qs3YofDETI2NgnHH38NTjjhasS1QEi6M0jSUv78XpCJXis+dk7j2IODUTjuROyaeRVKhh/htRlLpbEhYmIy3XZuNNtM+L3qCywpfRW/V34pIttVq2R43JGYnHAGJiSc3CLJUOFhAwcCU6d2/6kPd8HxU65loaGh6NOHhE8eA9u2AUuXNia5euPQaCQZVU38MSwWA6qq4nH22aykeNbbRBMLDQ03bYhppMUrDZreMGMkECEtnHc5orF7Cfe+9sJQV430n94RkyQJ21Y7v87yfcGEU1Ew+XQUj5gBmyNPhHkj9Lx47737UVCwTXwtPDwKRx/9D8ya9U+kpfVFdwVzW1LW/4Bev3wgyERYdanz/6ozDkLukRcg7/Bz0ZDcckvCU+CUQHU1LbutTaaCOopycyF+LHsLP5S9jl31fzq/zrHVEbFHYnKiIhkpQkvBih4nPtj+aK8Z1IEEfkbYEqGBlmqJuMawcwKNxmHe1nG5+mMYjWbR5j377L7o1cuzozqaWGhouP3hlJHJvNKg8p2hSYFo9NPQUIaGhuJOOS5SH0DBYfrStxG1d5fz65aIaDEWWTj+ZOwde7wo67OfvGLFIqG/2L79D/F9FIwNH34kZsy4CBMnnoIwNzNMAhEhNRVIXfsNev7+JXr+9rnwDFEwxqUIMeaeI+aiYuBYn/QCZIUqV0wKtCba7QzyGrbgl/IP8EvFB07jLSIYwcg2TMLI6Jk4d/xMnDxhOIKDde/DnZaIq88HyQUrGKxceJucyWOmFnv3NuDcc1N0K0RDI1DAACWOj9H4h1cadOsMSLtvq1FULFi56MQvQ+LG5cJvIe3XT52CT/FfwcGoGDAWxaOORvHIo1A2aDzWbFiKjz9egLVrv3V+X0xMIg47bI4YUz344CkwGAJsh7VRlYjf/oeoTPRY/RUSN/7iNLEijPGpKJh4KgomnY7SYYfD7uO/q6GhFA0NJUJTI8eMvWcUkd+wFb9UfIifSz/ALqNsfymkx6Zj5sCZYjuy75GIDe/kyEM3RFFRESoqKvZpifhDx6XFm1pjoRGgKC2VlQteadD4JjIwkqidYPAUA6hIMjgh4BFLZ3pZbP8DaSs/QdrKjxGX81fT54yMQfngiSgbMhl/9eyHj3L/wjdL30aJCxmhFmPMmBMwfvxJGDnyKERFBc4ixFYQU0STNv6C5A1LkbTpF6fmRKE6cwj2jp6JotEzUXbIYT4nEwqsUrBa0ZGWV0dBXxdeYfcctBsliV9hSc6XWLJzCerMdc7vMQQZMDZ9LA7PPhzT+07HpMxJiAnTol7XlkhCQgJ69uzZoo6LEyPUcXFqxFvQxEITC40ABq80fvkF+PNPgOeJQIter68vFiFUnA5hS8TTSYk030pd9x1S1n6L1LXfIryqcbKAsAcFoSJjCL5I6IkP66rwY8FWVDpyTAhOLvTrNwpDhx4mNlYzfOLsabcLZ9LYPRsRm/MX4retRsK23xCzZxPV6k2+1RSTiLKhh2HvqKOx99DjUO8l3QgXHrO5AUYjDZC4NThuOUZoFGZIaqOOpra2EBaLSSj9Q0JIKuxif7a2sUrELSwsUrSl5K3cwsMj26wicZKB5k7UAEyYAAwf3mga12BpwNJdS/Hl1i/xxdYvsL18e5OfDQkOwdjeY3F4n8MxNWsqxqWPQ3LUganwbKslovbzH39IHRcvVNLS4BVoYqGJhUaAw2KR0yK//ip9LgIpwIwqcGn3bRZjZvS38BpsNsTtXi/aJkmbliNx03JEF+5o8i0cfFsO4KOQcHweBOw0G/f5NalJvdGn3yj06TsCffoMR0bGQejRow+io+PdmtIIrS5DWFUxIotzEVmcg6ji3fK2YJsgFKG1lS3+bH1KptBIMLit5JDDUZ19SKtCGpIBupPW1XHMt8qxNd6vr69CbW2luOVj1/vq++rrqwWJIEnwJxTpoPiWI8TcIiPjEBERB6s1DsnJcRg0KA4ZGXFiWk9tSUlJSE5OFrfc8mrzBNH4cfeP+GHnD9hduXuf5xqYNBDjM8ZjQvoEcTu853CEebGN01VaIgR57caNstVKwTgzizwt19HEQhMLjS4AngxoosU+aU1NxzMBvAEGGHEElYiJyUJIiO96NqwKsHUSv3Mt4nauQ9yudYjO3+qsCrBBwiSLnxyb9PVsGQmGEGSGRSIjPArJoeFIDo1AcnAwUhGEeLsNMVYLYk0NiK+vQlx9NXi6Dmq2ERy4I52pDwpCeUoGKlKyUdazL8p69kFpUjqqgoJcFn+58CuS4EoY1P95Yxq/sbIgqwuhoeHia6w4SXGmTSxIfC8NhlBRkeDXXasazTeamlksZlEVUdUQVkI8jeZkIyI2ArWhtSixlaDAVoBiWzHAC3WXLTwqXJCLET1HYGTaSIxIGyEex4XHHXAtEQVaolPUWVnp+fOJJhaaWGh0IXD8TmUCcGIkUHQXyjxJJqBme7wl4g6CjfWIKtqBmPytonrAW1YSwssLUF+aj61VxVhPnwwAHHbkEGvTBkvggQs7Kyq8wle3vOJ3vR8VFe+sBLjej4iIEVWCxvZERKttCTlKzNFSmxgr5Xhp59svRmfLhYRDVmCqkZMjCVRaWhUSEipRW1slRgldN155l5eXo7S0VNzvMMniohm175aQlICsXlno27svBmcNxvC+wzG6/2hk985GZKB8uDqAuro65OZK3VFGRgaio6NbPZ+QXNAnxJPjqJpYaGKh0cXAigV1F1R4p6Z6V4TVkQRUr7dEOgm2McIqixFaVylcLLmZKopQVJyDfN5WlaCivgrlddUoN9WhvKEWNWYj6s0m1FuMaLCY0GA2uixydnFfPeaVvawCRDirAbzPWy7ysgUQ62wFNJIB+XX1Nd4nceB9EgJPjnm2PiaYI0S5NMCi+Zk3nrOjAWIcOSa5IMkoKysTt63dLykpEbfFxcVo4CrXAQSHBSMqPgrxSfFITUlFWo80ZKVlIT0tHSkpKftsrKCEB5Anf9F+WiLNx1G3b+98gJmCJhaaWGh0Ud3F2rVSd0FwhMzffhfMEaitzeuwO6NGYAhxpTdJdpt27R0FFzGOUPsyQIxX7yQazbecghxszd2K3QW7UVxSjMqyStRX1cNWY5P9rA4gJjZGkJCWiEdLG1s5IV6aJbe5tEToNJ3WhlLT0+OogUAsusbAuYZGAIHnojFjZLVi2TJg61bZJ/XnBZMKIlJ5It6YEtHwnk6GpIKIiurpcVLBaQQOK7Coc9hh0knTVwFinIzIysoSW3tQWleKNbvWYPX21fh799/Ymb8TeYV5KCouQm1FLcDJ1+YbHdbtQE11jdh2MtiknaBbZmvEgxoJLp5cSJvfxsbGtlqFIPh/JBNsiXAR5ve31hLhl484QppnUSjOSmigxgq0Fx3KCnn22WexYMEC4ZM+YsQIPP300xhHz9d2QGeFaHQn8CqQrZFNm2R52Z8nBNcpkbCwBLFIaQQ22L6irkK2sRJEHLonwatXaoJ4wTxpUvtbH4GIamM1dlXsws6KndhRvgM7y3cipyoHeZV5yNubh8K9hbDV2lomH823jnVomoBkoSXSEeeYqCGRUMsrv5fkShEMEi7eum5sua1eHSQSUkk2WtF9domKhdvE4r333sP555+PF154AePHj8cTTzyBDz74AJs3b27ik97ZF6ah0VXA9EfOp9P8hp8mjpD5qzXCgLKaGikcY5+eYWUagQmeeuvq8kTFgn4VnOrxZJWJhlc0ehs6VJKK+PZP9HZJWG1WFNcVI786v8lWUF2AkvoSlNSVoLi2WNyW1JTAXmdvm3wYHQTE6LLxcQdbNe1BeGQ4QsMjEBwcCUNIGCIiwxHm0AhRMxQSEt7oVUIdUai8Hx4WJbbQEPmzDQ0RePjhs5GdHdM1iAXJxNixY/HMM884e0k0A7nmmmswb968fb7faDSKzfWF8fs1sdDobmAFltULhg6x8tvMH8dnqK/fK8KImCEiWyIBMhur0Urmi2ctu+mPQIEmS+ssJNPwKtBs6QOBhFQ0VEiyUVcsWjCVxkpUNlSKrzvvGyvErev/VdRUwFhr3JdwNH9sdmym/dw2Jp97FD+sWoPDx44MfI2FyWTC6tWrceuttzbpJc2YMQMr6FfaAh5++GHce++97jyNhkaXBFXdLD3yo7BhA2f+veeu1xY4qmix1Irxxbq6IkRHB5Crl4bTsttolIO2nOLxFKlQMecch6ZAM9274atdFoZgg3AI5TYYg93+eZvdJqzOa0218pZ+Mi736xz/p+7vrdiLyppKmO1mhEeHw2KzwGg1wmTllFMD6uvrUV9bL24b6hpgrDeivsGE2iqTWHftNjNsZgtsVhtsZivsZhvsVrskJa6btfF+TLT/7PTdIhZU83LsqLnpBx9vYpO5BZCE3HDDDftULDQ0uiNIJmbMkCd09kpprEVhZ5gPjQd5BRwZ2UuML5rNdH6sFMJOjcAAx4Pr6gpEK4QZIJ54byjQZEw3MylYpRg71n8VswMBwawyhcW0OyfFbrdj9+7donpPPQX9Ldqr4frxx8bMItd0VJIbq90CGyzi1mI3i9v6Bgv2lliQldq+5/AGvF4g42xxIM0Xa2h4G3TRO+QQKeZU5ILBQ54WUrUFxmyHh6eIUjtbIwYDXRwPDFvlwNdVFAqBLd8PT4g16+pkIi+PN5LaAQN8kuqu4QaCgoLQq1cvQS6YKUKPC06d7A8Ugx9zjCSJzCxipIDqQJDcBAfxM930cx1pBSwGVmX89xa59dQcwTEYDML8wxV83NacrobGgQie6I87Dpg+XSq1aYJDoaevQLMs+llwWqS+Xl4ha/gXHCul5wgXmqio3p0Sa/LtpJ6HrQ/qKE4+GRg4UJOKQEV4eDhSOUsKTm1QB9U+y3WSCo6jTpwopz0oyg10uHVUh4WFYfTo0ViyZInzaxRv8vFE/tUaGhpNQL+A0aOBk06Sgk6SCyr1fQG5eKUJ8SYdHY1GHz2xRqsTO+o9YKWCkyAdBYkqK2EUZfKKlpWK7j710R2QkJDgHEMtKGg/2ed5hJM9vEhhhUr5kgQq3KbL1Eu89NJLWLhwITZu3IgrrrhClHYuvPBC77xCDY1ugF69gBNOkCcGXqjQVKudFyydAs2WVLm9oaFULG4avgd9Khp1FfEd1lWoKgVbHwcfLKsUHCcNlFA8jbZBss/qPiv/rFjQ9ry94Aj7yJGSSFJdwCk0TgAFItzWWMyePVvsjLvuuksYZI0cORKLFy9uNcVNQ0NDggJOOnZSu7xqFbB5s7zK5EfHmz3xsLBYWCzKlbMAMTHMLtArkW91FfmCXLBK0dEsF16pMtuKjq/HHgscdJAmFF0RISEhglzk5eWJkDeaZcW44eNNDQ2/nRkjFHVyGs2X4nCvOW92BtogS0ND5o1wkIoEo6xMTpF0NiOgLVBnQYdHjqDS/lv297XCz7c5IB3zq+BVKasUrHCxSsGJj65u+awBobMgsWD1Ijs7WwSWuQNGrjNtmecR14yRQHDe1GECGhp+AHvjnBw59VRg1CiAFVGWNr0l7uSipsgExYMmU7l3nkijCTju25gD0sttUsHFg1qK2Fhg5kyppdCkonsgNTVVxMPTwiE/P99tcTWrnUcdJaugJJ6+0m61B5pYaGj4EZw4o+L7xBOlDmPHDqCw0DvCLJbhIyJkGb6hoUSYNGl4D9KgrFDcDw9PEpWi9oJ+FBT6klhQF08txaBB/k/R1fD8CKrBYBDx8u7oLRToa8FgucMPlympgSLq1IephoafwY4EzW84OcIrEArxqL/gouJpMOiKpkyy718Amy1A1V9dHGw9UVfB25CQSOGG6o7RFatX6piYOtW7bTIN/yE0NFSQC4JtkWpap7oJni+YWOsq6vQ3tIO8hkaAgAKsESPkgrJuHfDXX7JXSv2FJ10UOSVitTaIK+r6+kKtt/ACaEpmtRpFXkt79Sx0WaRFEP1PpkyRFQpfxZtr+A/R0dFITk5GaWmpGIigrUNHTCUp6qTsYelSeSz5E1q8qaERoGDfdO1aWb1gCZyue54yseWiRzEnKxe8mo6I8KEtaDeHnL4pFGSCCbM0KWsLLGHT5IpR2cOGSbMraio0DhzY7Xbs2bMHdXV1glgwYp0tko6AxxN1ORT6etr02ishZBoaGr4DK6QcReVY4Zo1MrGSJwp+vbNXsnLssadYAGnaZDAwmllHrHcWNCKrr5fOxOHhyW2SCk55kFCwmEEhL0W8rFZoHHgICgpC7969heU3Q8donpWent6hyS0SVB5L/oQmFhoaAQxWKjinTu8LCjtZwWAPNTJSJqd2hmDQpIkCTuVvERubLQy1NDpjgpUnrj4p1KRgsyVw8keNj/brJxcBvr9amHlgw2AwCHKRk5MjTCfZGmGMRleEJhYaGl1kPJU9d5IMTgsogkFVeGcqGKxa2GxGcaVdW5uPmJjMTuVXHKhoaoIVJkZLm19tklBw4odGV7R3p4siiQXfWw0NIiIiQphnsWJBYkGtRWwX7IvpQ1pDowuBBIKtES5IrGAw8ZAtEi5OJBiuscrtgQrDkuZZLOPvFfkiGu6B+43VH+ayREWlNyFnilDU10udDG3dKbTTwkyNlkDtAu2+y8rKOiXm9Cc0sdDQ6KITJCQY/ftLYrF+vcyP4Aw7WyTujCey/UFyUVu7R7RFqLfgWKpG+2A0VsBkqtjHBIutDhIK3tIZkaJMvl+BZr+sEXhISUkR5IItEYo66cxJK/Cugq7zSjU0NPYBr3oZlc0KBs1x/v5bVjIoCmR7li6N7endU2QYHp6ChoZiNDTsFYvj/qYZNCjWrBf7i+B0DQWwNTVybJSgdoKTHmxh6QqFhrvmWdRbUMxJcsFJkeAuIsTR46YaGt0IrFjQ+4LpqRxT5Tw7VeKpqe0bPaOI02SqEiX9mBiOvOnL69ZAH5Da2hxhMhYSEgujsbewVWY7il4kHPejlkInj2p0FGazWZALi8Ui/C46OiniKehxUw2NAxA853BElRvNtnbvllUMVjPo6shkzLaqGFLMaRJiTk44kFyQZGg0BckE94/JZEVVVQSMxjSxbxkQRpGttxNrNQ4cZ8709HTk5uaKtkhRUZEQdwY6dCtEQ6ObgmJy+iNQi8HxRrZIWMlg1DL7/Ew+bC44l2Fl6c4kVFYwpBhRr5IKFosdRUX5qKoyCX1KRkY6hg4NFlWKLijg1+gCkyK9evUSQWU0piLZoFNnIEO3QjQ0DiCw/5+bKwkGdRh06aNdOK+22TJR4IRITU2uyLoID09EZOSB7dzEFlNVlUyQbGgoQExMFXr1CsbIkVnIzg7X7Q4Nr6OiokJULFQyahI/tD6GboVoaGjsA06LDBkiqxhlZZJcsILB6QW2S2i8xcTVmJgIMXZKbwujsVxcmZNgHEhg64hkgjoVpo2yGpGZWYqEhCqkpAShf//eiI7uWmOAGl0XCQkJImK9pKTEmYTqD3LRHuhWiIbGAQh2NlhN5caphZISSS5UbDs3gyEWkZEpCAsrET4N1FowGbU7gwSCqbLcSCxIJjgiyqmb6OgK1NeXiO/r2bOHENNpaPgSycnJwoyN5lkkF2xRJlI0FWDQxEJD4wAHSQanRrhRk8FFlZMlrGDk5CSjvNwKk6kcBkMhEhODkZAQ0228GGhexfYQ06ppYMWR0Ph4abPNVFmKMJm1xN52YWGR8+TOq0cNDX8gxWHzTXKxlx9UIODIhSYWGhoaTUgG10xunG7gFXxxcSq2b7diz54qlJfnIzc3A1ZrlJgs4UU7N+o0At2/hxUIkgdaapNMkFRwFJRVCY6FcuM5mwTLlThVV1c7e9s8gXfV/AaN7oPm5IJVjEBqiwT4qUBDQ8Of4AKbns7kxTTk59tQXl6D2to8RERkoqIiAvn58mqfLV+rVRIT+ji4br42huLroNslNxIJbuq1UUOidCasRvBczHYQv94SampqRG4DT9yMi+6h40c1ApBcFBcXC68LijoDYYJLEwsNDY12xzrbbHsQGloHg2EPBg/OQHh4hLj6Z/uEQkfekmRQ8EjCQe0GKwPOE06IJBrcWC3gY95yYwWEG8+L6tzIaQxVbVAbSQI3i0Vu/P2srKjvdSU3JA6sQLBSzJYG2xzc2mNaRd8AjviRVDC/oSeZiIZGgJELg8Egqhbl5eVC3EmfC3+TC00sNDQ02gWerGjWQ3vh+vp6YdqTkZGB2NjIffwbuPBzlJVtB26uLQi1kQyQFDQ0yO8naSA54G3T520kHIqEcGM1hSSBFQiSBrZjWHngrWrPuBvK5tr+UJUKpksGwslaQ6MlsD1HcsHAMo6DklzwIsCf9t+aWGhoaLQbPFmRTOTl5aGurk6QDJ7Emk9IcOHnYs+tNZBAkFioyoOqRJBcqE1VL3iOVIRCVT146421nkJNaioUqaA5kSYVGoGMuLg4QS5YYWOljaSfFwH+Ci7TxEJDQ8NtcsGTljqJkWSQXMS4E6kqfo/MLwmkRGh6BLBnTVBTwfaHJhUaXQHR0dHIzMwUZJ/BZdRc+ItYdI2oNA0NjYAkF7yi55U9SQadAbsqbDabaH0oUkGFvSYVGl3R/jsrK0t8NnnfX9AVCw0NjU5FO5NkqPYBr5QCRZneXvA1kxgZjUbxukkoWK3Q0OiKCAsLE5s/oYmFhoZGh8GFmMJGBiOxjUBlOhdqEg72fAMdHCel6I2CN75etnSiqPrU0NDoMHQrRENDo9OgG6VSolN3sWvXLjE5Eqhg+4az/9SHkFRERkaiT58+mlRoaHgAumKhoaHhEVBvwRIs2wqsWlCZTq0CSUcgtUbY8mCVooFzro5xva7WvtHQCGRoYqGhoeExhIeHIzs7W+gtOFNPMSTbDWyX+FNMpqoUZWVl4jXxPlsf1FOQEGloaHgOmlhoaGh4FGyHUGPB8VMSDFYIdu/eLYK7WL3w9QgcSQTJDVsfZocNKEfzSHb8NY6nodGdoT9VGhoaXgErAdQuUNTJqRGOo7KKwdaDcgv0BaFghYLkhiCRYNuDhkIaGhregSYWGhoaXgMXclYGuJCzYkBdAxd6To+QeHCsky0ST+obqO8ggSGZoUmQqqKQzFDz4U+rYw2NAwGaWGhoaHgdHOGkcY9rBYELPzeSD7YmWN0gyeDoqjuLP6c6OIHCjb+fxEKBVRG2YHxRIdHQ0JDQxEJDQ8MnYFWCVQpuzBkhqSARYFVBkQwFkg0SAbWRaHBje4MbyQQ3kgjeNn8eEhlWQ6jz0NMeGhq+hSYWGhoaPgcXfm4kCSQZ3NgmYSWDRIFkQ7Ux2gOOubLiwd/J6oeuTmho+A+aWGhoaPgNrCaQCLimo5JYcHpDVSWY48FbkhD1M6qSwbYJSYXWTWhoBA40sdDQ0AgoKNKgoaHRNaHl0RoaGhoaGhoegyYWGhoaGhoaGh6DJhYaGhoaGhoaHoMmFhoaGhoaGhoegyYWGhoaGhoaGh6DJhYaGhoaGhoaHoMmFhoaGhoaGhoegyYWGhoaGhoaGh6DJhYaGhoaGhoaHoMmFhoaGhoaGhoegyYWGhoaGhoaGh6DJhYaGhoaGhoaHoMmFhoaGhoaGhpdN91URR9XVVX5+qk1NDQ0NDQ0Ogi1bqt1PGCIRXV1tbjNzMz09VNraGhoaGhoeGAdj4+Pb/X/g+z7ox4ehs1mQ35+PmJjYxEUFORRJkWykpubi7i4OI/9Xg29n/0FfUzr/dydoI/nrr+fSRdIKnr37o3g4ODAqVjwxWRkZHjt93NHamLhfej97Dvofa33c3eCPp679n5uq1KhoMWbGhoaGhoaGh6DJhYaGhoaGhoaHkO3IRbh4eG4++67xa2G3s/dAfqY1vu5O0EfzwfOfva5eFNDQ0NDQ0Oj+6LbVCw0NDQ0NDQ0/A9NLDQ0NDQ0NDQ8Bk0sNDQ0NDQ0NDwGTSw0NDQ0NDQ0PAZNLDQ0NDQ0NDQOTGLx7LPPok+fPoiIiMD48eOxatWqNr//gw8+wEEHHSS+f9iwYfjyyy999lq7MtzZzy+99BKmTp2KxMREsc2YMWO/74uG+/vZFe+++66wwz/55JP1rvTCMU1UVFTgqquuQq9evcTY3qBBg/T5wwv7+YknnsDgwYMRGRkpbKivv/56NDQ06OO6Dfz000+YNWuWsNXmeeCTTz7Z7/768ccfceihh4pjecCAAXjttde8u4/tXQTvvvuuPSwszP7KK6/Y//rrL/s//vEPe0JCgr2oqKjF7//ll1/sBoPB/uijj9r//vtv+x133GEPDQ21r1+/3uevvSvB3f08Z84c+7PPPmtfs2aNfePGjfYLLrjAHh8fb9+zZ4/PX3t33s8KO3futKenp9unTp1qP+mkk3z2eg+kfW00Gu1jxoyxz5w5075s2TKxz3/88Uf72rVrff7au/N+fuutt+zh4eHilvv466+/tvfq1ct+/fXX+/y1dyV8+eWX9ttvv92+aNEiWkXYP/744za/f8eOHfaoqCj7DTfcINbCp59+WqyNixcv9tpr7DLEYty4cfarrrrK+dhqtdp79+5tf/jhh1v8/jPPPNN+/PHHN/na+PHj7ZdddpnXX2tXhrv7uTksFos9NjbWvnDhQi++ygNzP3PfTpo0yf7yyy/b586dq4mFl/b1888/b+/Xr5/dZDK1/w3VcHs/83uPOOKIJl/j4jd58mS9N9uJ9hCLm2++2T506NAmX5s9e7b9mGOOsXsLXaIVYjKZsHr1alFmdw0z4+MVK1a0+DP8uuv3E8ccc0yr36/Rsf3cHHV1dTCbzUhKStK71IPHM3HfffehR48euPjii/W+9eK+/uyzzzBx4kTRCunZsycOOeQQPPTQQ7BarXq/e3A/T5o0SfyMapfs2LFDtJtmzpyp97MH4Y+10Ofpph1BSUmJ+FDzQ+4KPt60aVOLP1NYWNji9/PrGp7bz81xyy23iN5f8wNZo3P7edmyZfjvf/+LtWvX6l3p5X3NBe7777/HOeecIxa6bdu24corrxSEmVbJGp7Zz3PmzBE/N2XKFBHHbbFYcPnll+O2227Tu9iDaG0tZLx6fX290Ld4Gl2iYqHRNfDII48IYeHHH38sxFsankF1dTXOO+88IZRNSUnRu9XLsNlsojL04osvYvTo0Zg9ezZuv/12vPDCC3rfexAUFLIS9Nxzz+GPP/7AokWL8MUXX+D+++/X+7mLo0tULHgyNRgMKCoqavJ1Pk5LS2vxZ/h1d75fo2P7WeGxxx4TxOK7777D8OHD9e704PG8fft27Nq1SyjBXRc/IiQkBJs3b0b//v31PvfAviY4CRIaGip+TmHIkCHiyo8l/7CwML2vPbCf77zzTkGYL7nkEvGYk3u1tbW49NJLBZFjK0Wj82htLYyLi/NKtYLoEu8cP8i8cliyZEmTEysfsxfaEvh11+8nvv3221a/X6Nj+5l49NFHxVXG4sWLMWbMGL0rPXw8c2R6/fr1og2ithNPPBHTp08X9zmmp+GZfU1MnjxZtD8UeSO2bNkiCIcmFZ7bz9RjNScPiszpbEzPwS9rob0LjTJxNOm1114TIzOXXnqpGGUqLCwU/3/eeefZ582b12TcNCQkxP7YY4+JMci7775bj5t6YT8/8sgjYsTsww8/tBcUFDi36upqzx8EB/B+bg49FeK9fZ2TkyMmm66++mr75s2b7f/73//sPXr0sD/wwAOdeMe7P9zdzzwncz+/8847YiTym2++sffv319M9Gm0Dp5bOd7PjUv4448/Lu7v3r1b/D/3Mfd183HTm266SayFtAfQ46Yu4PxtVlaWWMg42rRy5Urn/02bNk2cbF3x/vvv2wcNGiS+n+M2X3zxRRtvl0ZH9nN2drY4uJtvPGloePZ4doUmFt7d18uXLxfj6VwoOXr64IMPinFfDc/tZ7PZbL/nnnsEmYiIiLBnZmbar7zySnt5ebnezW3ghx9+aPGcq/Ytb7mvm//MyJEjxfvC4/nVV1+1exNB/Md79RANDQ0NDQ2NAwldQmOhoaGhoaGh0TWgiYWGhoaGhoaGx6CJhYaGhoaGhobHoImFhoaGhoaGhsegiYWGhoaGhoaGx6CJhYaGhoaGhobHoImFhoaGhoaGhsegiYWGhoaGhoaGx6CJhYaGhoaGhobHoImFhoaGhoaGhsegiYWGhoaGhoYGPIX/BxKCz8OAH6FQAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "DIST = Normal(0.3, 0.2)\n", + "\n", + "\n", + "def objective_func(X: torch.Tensor) -> torch.Tensor: # noqa: N803\n", + " prb = DIST.log_prob(X).exp()\n", + " y_true = underling_function(X)\n", + " return y_true * prb\n", + "\n", + "\n", + "def plot_gp_and_dist(gp: Model, acquisiton_function: AcquisitionFunction | None = None, ax: Axes | None = None):\n", + " X = torch.linspace(0, 1, 201).reshape(-1, 1) # noqa: N806\n", + "\n", + " ax = plot_gp(gp, ax=ax)\n", + "\n", + " # Add additional plots we find useful.\n", + " # The env dist\n", + " _ = ax.plot(X.numpy(), DIST.log_prob(X).exp(), color=\"green\", label=\"dist pdf\")\n", + " # true fucntion:\n", + " _ = ax.plot(X.numpy(), underling_function(X), color=\"red\", label=\"True underling\")\n", + " # The objectiove function\n", + " objective_results = objective_func(X)\n", + " x_max = X[objective_results.argmax()][0]\n", + " _ = ax.plot(\n", + " X,\n", + " objective_results,\n", + " color=\"black\",\n", + " label=f\"Objective function.\\nxmax {x_max:.3f}\\nscore {objective_results.max():.3f}\",\n", + " )\n", + " # formatting\n", + " _ = ax.legend(loc=\"upper right\")\n", + "\n", + " ax2 = None\n", + " if acquisiton_function:\n", + " scores = acquisiton_function(X.reshape(-1, 1, 1))\n", + " ax2 = ax.twinx()\n", + " _ = ax2.plot(X.detach().numpy(), scores.detach().numpy(), label=\"ac score\", color=\"orange\")\n", + " _ = ax2.set_ylabel(\"ac_function_score\", color=\"orange\")\n", + " _ = ax2.tick_params(\"y\", color=\"orange\")\n", + "\n", + " return ax2 or ax\n", + "\n", + "\n", + "_ = plot_gp_and_dist(gp)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Brute force the best result" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "gp xmax est 0.274. objective_score 1.8181057940929743\n" + ] + } + ], + "source": [ + "def estimate_xmax_with_gp(model: Model):\n", + " test_x = torch.linspace(0, 1, 1001)\n", + "\n", + " with torch.no_grad():\n", + " posterior = model.posterior(test_x)\n", + "\n", + " y_pred = posterior.mean.flatten()\n", + " prb = DIST.log_prob(test_x).exp()\n", + "\n", + " objective = y_pred * prb\n", + "\n", + " return test_x[objective.argmax()]\n", + "\n", + "\n", + "gp_xmax_est = estimate_xmax_with_gp(gp)\n", + "print(f\"gp xmax est {gp_xmax_est}. objective_score {objective_func(gp_xmax_est)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Custom Acqusition function\n", + "Define the custom acquisiton function that can be optimisted through `botorch` and `Ax`.\n", + "\n", + "Requirements from `botorch` are detailed here. Requirements from `Ax` are detailed section \"Putting into Ax\"" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO(sw 2024-11-13): need to check if this is the right type of class - there are more specific ones (e.g analytical)\n", + "class CustomAcq(AcquisitionFunction):\n", + " \"A simple AcquisitionFunction for a 1d problem to demonstrate interface and integeraton.\"\n", + "\n", + " def __init__(\n", + " self,\n", + " model: Model, # Mandatory Param required by the interface\n", + " # Every thing below this point is option that we choose to inlucde\n", + " dist: Distribution,\n", + " ) -> None:\n", + " r\"\"\"Constructor for the AcquisitionFunction base class.\n", + "\n", + " Args:\n", + " model: A fitted model.\n", + " dist: A distribtuion\n", + " \"\"\"\n", + " super().__init__(model=model) # create the attribute self.model\n", + "\n", + " self.dist: Distribution = dist\n", + "\n", + " # Helper to show the hyperparams of the GP. This is useful to know if the GO is being refit between DOE rounds\n", + " # print(f\"\\nCustomAcq GP recieved:\\n{gp.likelihood.noise=}\\n{gp.covar_module.base_kernel.lengthscale=}\\n{gp.covar_module.outputscale=}\") # noqa: E501, ERA001\n", + "\n", + " @t_batch_mode_transform(expected_q=1) # Ensure function gets X.shape = (t,1,d)\n", + " def forward(self, X: torch.Tensor) -> torch.Tensor: # type: ignore # noqa: N803\n", + " r\"\"\"Evaluate the acquisition function on the candidate set X.\n", + "\n", + " Args:\n", + " X: A `(b) x q x d`-dim Tensor of `(b)` t-batches with `q` `d`-dim\n", + " design points each. Loosely speaking, q-btaches and t-batchs translate to.\n", + " - `q-batch`: number of points output for a single DoE step. e.g q-batch=2, each time a new GP is trained\n", + " in the DoE process, it has 2 additional points\n", + " - `t-batch`: The number of independant q-batches being run in parrallel to best make use of hardware.\n", + "\n", + " Returns:\n", + " A `(b)`-dim Tensor of acquisition function values at the given\n", + " design points `X`. Larger values are considered better.\n", + "\n", + "\n", + " Botorch requirements:\n", + " - Requirement from optimisers:\n", + " Gradient: If `X.requires_grad = True` the output must support auto-differentiation from outputs to inputs.\n", + " The use of gradient is determined by the optimisation function applied to this function, and can not\n", + " be turned on/off from within the acquisition function (if turned on will be ignored, if turned off\n", + " ptimisation will throw error). Use of gradient though botorch is controlled with\n", + " `optimize_acqf(..., options = {\"with_grad\":False})`\n", + " See Notebook section \"Botorch Optimisation\" for details.\n", + "\n", + " Ax requirement:\n", + " - Problem/Outcome space vs. Model space\n", + " - Ax shifts everything from problem-space to model-space at the ModelBridge level (e.g TorchModelBridge).\n", + " - As a result, the x value received are in model-space. Need to act accordingly.\n", + "\n", + " Specific implementation:\n", + " - Provides a simple heuristic of optimising prblem with distributions by focusing on region with high\n", + " distribution probablity, and high GP uncertainty.\n", + " \"\"\"\n", + " assert X.shape[-1] == 1, \"Function only supports 1d input (d=1)\"\n", + "\n", + " prbs = self.dist.log_prob(X).exp()\n", + " # was: (b,1,1), now (b,)\n", + " prbs = prbs.flatten()\n", + "\n", + " posterior = self.model.posterior(X)\n", + " std = posterior.variance.sqrt().flatten() # type: ignore\n", + "\n", + " return prbs * std" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run the acquisition function" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.4965, 1.2382, 0.0104], grad_fn=)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cust_ac = CustomAcq(gp, DIST)\n", + "X = torch.tensor([[[0.1]], [[0.5]], [[0.9]]])\n", + "\n", + "# Note: .model.posterior turns of gradient tracking by default. gradient behavior is detailed in the following section\n", + "cust_ac(X)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Checking Gradient behaviour\n", + "Optimisation is controlled by `botorch.optim.optimize.optimize_acqf`, and gradient information is extracted in `botorch.generation.gen.gen_candidates_scipy`. The following mimics how gradient info is acquired in that function. This must produce the correct gradient for gradient based optimisation to be sucessful. Details covered in [Botroch Optimisation](#botroch-optimisation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Single point" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# An acquisition function needs to be optimised with respect to its inputs.\n", + "X = torch.tensor([[[0.1]]], requires_grad=True)\n", + "# Is turned a maximisation to minimisation problem\n", + "loss = -1 * cust_ac(X)\n", + "_ = torch.autograd.grad(loss, X)\n", + "\n", + "\n", + "## This can be used to show the grad graph\n", + "# torchviz.make_dot(\n", + "# loss,\n", + "# dict(X = X), # noqa: ERA001\n", + "# show_attrs=True, # noqa: ERA001\n", + "# show_saved=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Multiple points (t-batch)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# An acquisition function needs to be optimised with respect to its inputs.\n", + "X = torch.tensor([[[0.1]], [[0.2]]], requires_grad=True)\n", + "# Is turned a maximisation to minimisation problem\n", + "loss = -1 * cust_ac(X)\n", + "_ = torch.autograd.grad(loss.sum(), X)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Optimisation of Acquisition:\n", + "The acqusition function needs to be compatible with the optimiser that optimises it.\n", + "- in `botorch`: `botorch.optim.optimize.optimize_acqf` is used to achieved this.\n", + "- in `ax`: When a new point in requested from a Generator in the DoE loop it connects this to `botorch.optim.optimize.optimize_acqf`.\n", + "\n", + "The relationship between from `ax` (bottom), through `botorch`, to `scipy` (top) is described in the following stack trace:\n", + "\n", + "```sh\n", + "minimize_with_timeout (botorch\\optim\\utils\\timeout.py:80) \n", + "# scipy.optimize.minimize is called here\n", + "gen_candidates_scipy (botorch\\generation\\gen.py:252)\n", + "# \"with_grad\" used here to determine optimisation approach:\n", + "# if True (line 192): \n", + "# - makes a wrapper around the acquisition function that give: acq_wrapper(x) -> (funct_value, func_grad).\n", + "# - jac=True in scipy.optimize.minimize\n", + "# if False (line 224):\n", + "# - wrapper returns: acq_wrapper(x) -> funct_value\n", + "# - jac=False in scipy.optimize.minimize\n", + "_optimize_batch_candidates (botorch\\optim\\optimize.py:333)\n", + "_optimize_acqf_batch (botorch\\optim\\optimize.py:349)\n", + "_optimize_acqf (botorch\\optim\\optimize.py:584)\n", + "optimize_acqf (botorch\\optim\\optimize.py:563)\n", + "optimize (ax\\models\\torch\\botorch_modular\\acquisition.py:439)\n", + "gen (ax\\models\\torch\\botorch_modular\\model.py:395)\n", + "_gen (ax\\modelbridge\\torch.py:682)\n", + "gen (ax\\modelbridge\\base.py:791)\n", + "TorchModelBridge.gen()\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Brute force\n", + "Finding the maximum of the acquisition function. Note, at this point, the optimal of the objective is a long way for the best part of the objective" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimal values of acquisition: Best x 0.36. score 1.810266278702369\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "test_x = torch.linspace(0, 1, 101)\n", + "scores = cust_ac(test_x.reshape(-1, 1, 1))\n", + "\n", + "print(f\"Optimal values of acquisition: Best x {test_x[scores.argmax()]}. score {scores.max()}\")\n", + "\n", + "_ = plot_gp_and_dist(gp, acquisiton_function=cust_ac)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Botroch Optimisation" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([[0.3583]]), tensor(1.8104))" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Need to provide this with correct gradient information (in the tensor output object)\n", + "# OR manually tell it to ignore gradient\n", + "candidate, result = optimize_acqf(\n", + " cust_ac,\n", + " bounds=bounds,\n", + " q=1,\n", + " # This is how many different start location will be tried by the optimiser\n", + " num_restarts=5,\n", + " # TODO(sw 2024-11-13): confirm the impact of this paramerter\n", + " # Think this required when using a MCAcquisitionFunction (e.g the Acquisition function output at x is noisey).\n", + " # Controls how many time to repeat an x\n", + " raw_samples=100,\n", + " # Key parameter to control if optimisation should use gradient from the acquisiton fucntion\n", + " options={\"with_grad\": True}, # True by default\n", + ")\n", + "candidate, result" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Demonstaration of lower level Botorch optimisation\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### `optimize_acqf` internals\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([[0.3583]]), tensor(1.8104))" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "initial_conditions = gen_batch_initial_conditions(cust_ac, bounds, q=1, num_restarts=10, raw_samples=10)\n", + "candidates, scores = gen_candidates_scipy(\n", + " initial_conditions=initial_conditions,\n", + " acquisition_function=cust_ac,\n", + " lower_bounds=torch.tensor([0.0]),\n", + " upper_bounds=torch.tensor([1.0]),\n", + " # NOTE: Optimisation fails when this is true\n", + " # if false does an optimisation that ignore the gradient\n", + " # Must mean that we are giveing it bad gradient info in one way or another\n", + " # options = dict(with_grad = False) # noqa: ERA001\n", + ")\n", + "\n", + "\n", + "# get_best_candidates(candidates, scores) # noqa: ERA001\n", + "candidates[scores.argmax()], scores.max()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Scipy direct optimisation\n", + "Internally botorch evarually used this" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"Make AcqusitionFunction compatible with scipy.optimisation:\n", + "- turn it into a minimisation problem\n", + "- use numpy\n", + "\n", + "This version doesn't use gradient information\n", + "\"\"\"\n", + "\n", + "\n", + "def acq_wrapper(x: torch.Tensor):\n", + " with torch.no_grad():\n", + " x = torch.tensor(x, dtype=torch.float64).reshape(-1, 1, 1)\n", + " acq_result = cust_ac(x)\n", + "\n", + " # we are using a minimise function, so we need to flip the sign\n", + " return -1 * acq_result.item()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " message: Optimization terminated successfully\n", + " success: True\n", + " status: 0\n", + " fun: -1.8103649877035044\n", + " x: [ 3.583e-01]\n", + " nit: 3\n", + " jac: [-5.911e-03]\n", + " nfev: 8\n", + " njev: 3\n", + " multipliers: []" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scipy.optimize.minimize(acq_wrapper, x0=[0.3], method=\"SLSQP\", bounds=[(0.0, 1.0)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## DoE\n", + "Perform a loop of DoE, where we use the gp and the acquisition function to give use the next datapoint for our acquisition function\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Botorch\n", + "#### Retraining the model at each step:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\SEBWIN\\Documents\\technical\\code\\axtreme\\.venv\\Lib\\site-packages\\botorch\\models\\utils\\assorted.py:202: InputDataWarning: Input data is not standardized (mean = tensor([1.6864]), std = tensor([0.6887])). Please consider scaling the input to zero mean and unit variance.\n", + " warnings.warn(msg, InputDataWarning)\n", + "c:\\Users\\SEBWIN\\Documents\\technical\\code\\axtreme\\.venv\\Lib\\site-packages\\botorch\\models\\utils\\assorted.py:202: InputDataWarning: Input data is not standardized (mean = tensor([1.2855]), std = tensor([0.8482])). Please consider scaling the input to zero mean and unit variance.\n", + " warnings.warn(msg, InputDataWarning)\n", + "c:\\Users\\SEBWIN\\Documents\\technical\\code\\axtreme\\.venv\\Lib\\site-packages\\botorch\\models\\utils\\assorted.py:202: InputDataWarning: Input data is not standardized (mean = tensor([1.2047]), std = tensor([0.7111])). Please consider scaling the input to zero mean and unit variance.\n", + " warnings.warn(msg, InputDataWarning)\n", + "c:\\Users\\SEBWIN\\Documents\\technical\\code\\axtreme\\.venv\\Lib\\site-packages\\botorch\\models\\utils\\assorted.py:202: InputDataWarning: Input data is not standardized (mean = tensor([0.9837]), std = tensor([0.7896])). Please consider scaling the input to zero mean and unit variance.\n", + " warnings.warn(msg, InputDataWarning)\n", + "c:\\Users\\SEBWIN\\Documents\\technical\\code\\axtreme\\.venv\\Lib\\site-packages\\botorch\\models\\utils\\assorted.py:202: InputDataWarning: Input data is not standardized (mean = tensor([1.3198]), std = tensor([1.0846])). Please consider scaling the input to zero mean and unit variance.\n", + " warnings.warn(msg, InputDataWarning)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(5, 1, figsize=(8, 20))\n", + "\n", + "bounds = torch.tensor([[0.0], [1.0]]) # 1D search space [lower_bound, upper_bound]\n", + "train_x_opt = torch.tensor([[0.1], [0.85]])\n", + "train_y_opt = underling_function(train_x_opt)\n", + "\n", + "\n", + "for ax in axes:\n", + " # Train the GP on the available data\n", + " gp = SingleTaskGP(train_X=train_x_opt, train_Y=train_y_opt)\n", + " mll = gpytorch.mlls.ExactMarginalLogLikelihood(gp.likelihood, gp)\n", + " _ = fit_gpytorch_model(mll)\n", + " # Plot it and the acquisition function\n", + " cust_ac = CustomAcq(gp, DIST)\n", + "\n", + " # estimate the best point in the objective function with the current model\n", + " gp_xmax_est = estimate_xmax_with_gp(gp)\n", + " test_str = f\"gp xmax est {gp_xmax_est:.2f}.\\nobjective_score {objective_func(gp_xmax_est):.2f}\"\n", + " ax.text(\n", + " 0.05,\n", + " 0.05,\n", + " test_str,\n", + " transform=ax.transAxes,\n", + " fontsize=12,\n", + " verticalalignment=\"bottom\",\n", + " bbox={\"boxstyle\": \"round,pad=0.3\", \"edgecolor\": \"black\", \"facecolor\": \"lightgray\"},\n", + " )\n", + "\n", + " _ = plot_gp_and_dist(gp, acquisiton_function=cust_ac, ax=ax)\n", + "\n", + " candidate, result = optimize_acqf(\n", + " cust_ac,\n", + " bounds=bounds,\n", + " q=1,\n", + " num_restarts=5,\n", + " raw_samples=100,\n", + " # If can't provide grad information need to be able to manually set this\n", + " options={\"with_grad\": True}, # this is True by default\n", + " )\n", + "\n", + " # call the simulator to give us the new results\n", + " train_x_opt = torch.cat([train_x_opt, candidate])\n", + " train_y_opt = torch.cat([train_y_opt, underling_function(candidate)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Repeat the same, but do not optimise the model hyperparams after the first fit\n", + "condition on new data but don't update hyperparams" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\SEBWIN\\Documents\\technical\\code\\axtreme\\.venv\\Lib\\site-packages\\botorch\\models\\utils\\assorted.py:202: InputDataWarning: Input data is not standardized (mean = tensor([1.6864]), std = tensor([0.6887])). Please consider scaling the input to zero mean and unit variance.\n", + " warnings.warn(msg, InputDataWarning)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(3, 1, figsize=(8, 12))\n", + "\n", + "bounds = torch.tensor([[0.0], [1.0]]) # 1D search space [lower_bound, upper_bound]\n", + "train_x_opt = torch.tensor([[0.1], [0.85]])\n", + "train_y_opt = underling_function(train_x_opt)\n", + "\n", + "\n", + "gp = SingleTaskGP(train_X=train_x_opt, train_Y=train_y_opt)\n", + "mll = gpytorch.mlls.ExactMarginalLogLikelihood(gp.likelihood, gp)\n", + "_ = fit_gpytorch_model(mll)\n", + "\n", + "for ax in axes:\n", + " # Plot it and the acquisition function\n", + " cust_ac = CustomAcq(gp, DIST)\n", + "\n", + " # estimate the best point in the objective function with the current model\n", + " gp_xmax_est = estimate_xmax_with_gp(gp)\n", + " test_str = f\"gp xmax est {gp_xmax_est:.2f}.\\nobjective_score {objective_func(gp_xmax_est):.2f}\"\n", + " ax.text(\n", + " 0.05,\n", + " 0.05,\n", + " test_str,\n", + " transform=ax.transAxes,\n", + " fontsize=12,\n", + " verticalalignment=\"bottom\",\n", + " bbox={\"boxstyle\": \"round,pad=0.3\", \"edgecolor\": \"black\", \"facecolor\": \"lightgray\"},\n", + " )\n", + "\n", + " _ = plot_gp_and_dist(gp, acquisiton_function=cust_ac, ax=ax)\n", + "\n", + " candidate, result = optimize_acqf(\n", + " cust_ac,\n", + " bounds=bounds,\n", + " q=1,\n", + " num_restarts=5,\n", + " raw_samples=100,\n", + " # If can't provide grad information need to be able to manually set this\n", + " options={\"with_grad\": True}, # This is true by default\n", + " )\n", + "\n", + " # Update the model\n", + " new_x_point = candidate.flatten()\n", + " new_y_point = underling_function(new_x_point)\n", + " gp = gp.get_fantasy_model(inputs=new_x_point, targets=new_y_point)\n", + "\n", + " # Justed used for plotting now\n", + " train_x_opt = torch.cat([train_x_opt, new_x_point.unsqueeze(0)])\n", + " train_y_opt = torch.cat([train_y_opt, new_y_point.unsqueeze(0)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## AX\n", + "Put this into the ax framework and optimise it that way.\n", + "- Come from botorch custom acquisitions [here.](https://archive.botorch.org/v/0.10.0/tutorials/custom_acquisition)\n", + "- and Ax example here [here](https://ax.dev/tutorials/modular_botax.html)\n", + "\n", + "There are likely otherways to acheive this with the ax interface" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set up" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create the experiment" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# For our purposes, the metric is a wrapper that structures the function output.\n", + "class DummyMetric(Metric):\n", + " def fetch_trial_data(self, trial): # type: ignore # noqa: ANN001\n", + " records = []\n", + " for arm_name, arm in trial.arms_by_name.items():\n", + " params = arm.parameters\n", + " tensor_params = torch.tensor([params[\"x\"]])\n", + " records.append(\n", + " {\n", + " \"arm_name\": arm_name,\n", + " \"metric_name\": self.name,\n", + " \"trial_index\": trial.index,\n", + " \"mean\": underling_function(tensor_params),\n", + " \"sem\": float(\"nan\"), # SEM (observation noise) - NaN indicates unknown\n", + " }\n", + " )\n", + " # OK just wtapps saying it contains a sucessful value\n", + " return Ok(value=Data(df=pd.DataFrame.from_records(records)))\n", + "\n", + "\n", + "# Search space defines the parameters, their types, and acceptable values.\n", + "search_space = SearchSpace(\n", + " parameters=[\n", + " RangeParameter(name=\"x\", parameter_type=ParameterType.FLOAT, lower=0, upper=1),\n", + " ]\n", + ")\n", + "\n", + "\n", + "optimization_config = OptimizationConfig(\n", + " objective=Objective(\n", + " # NOTE: we don't care about lower_is_better because are not just trying to maximise or minimise this value\n", + " # This just needs to be the y value we want to fit our GP to\n", + " metric=DummyMetric(name=\"dummy_metric\", lower_is_better=True),\n", + " minimize=True, # This is optional since we specified `lower_is_better=True`\n", + " )\n", + ")\n", + "\n", + "\n", + "class MyRunner(Runner):\n", + " def run(self, trial): # type: ignore # noqa: ANN001\n", + " trial_metadata = {\"name\": str(trial.index)}\n", + " return trial_metadata\n", + "\n", + "\n", + "exp = Experiment(\n", + " name=\"Dummy_experiment\",\n", + " search_space=search_space,\n", + " optimization_config=optimization_config,\n", + " runner=MyRunner(),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Register the input constructor" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# Super hacky way of making sure the input constructure is not already in there,\n", + "# so we can make updates to this functions without having to restart the notebook\n", + "input_constructors.ACQF_INPUT_CONSTRUCTOR_REGISTRY.pop(CustomAcq, None)\n", + "\n", + "\n", + "@acqf_input_constructor(CustomAcq)\n", + "def construct_inputs_custom_acq(\n", + " model: Model,\n", + " dist: Distribution,\n", + " **kwargs: Any, # noqa: ANN401, ARG001\n", + ") -> dict[str, Any]:\n", + " return {\n", + " \"model\": model,\n", + " \"dist\": dist,\n", + " }" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Optional: register default optimisation parameters that will be used in overrides are not passed. Ax internally calls this function when `.gen()` is called." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "from ax.models.torch.botorch_modular.optimizer_argparse import _argparse_base, optimizer_argparse\n", + "\n", + "\n", + "@optimizer_argparse.register(CustomAcq)\n", + "def _argparse_custom_acquisition(\n", + " acqf: CustomAcq,\n", + " **kwargs: dict[Any, Any],\n", + ") -> dict[str, Any]:\n", + " \"\"\"Contruct the default arguements to `optimize_acqf`, pick out the relevant overrides from `kwargs`.\n", + "\n", + " Kwargs contians a varitiey of values, not all useful. \"Value\" specififed in the orginal `.gen() call\n", + " (e.g. `ModelBridge.gen(model_gen_options = {\"optimizer_kwargs\": })`) need to be extracted and override\n", + " defaults here. The flow of optimisation parameters from Ax through to scipy is complicated, documentation is\n", + " provided in `docs/source/technical_details/ax_botorch/options_routing_guide.md`\n", + "\n", + " Details:\n", + " Function is used in ax.models.torch.botorch_modular.acquisition.Acquisition.optimize().\n", + "\n", + " Called with:\n", + " ```\n", + " optimizer_options_with_defaults = optimizer_argparse(\n", + " self.acqf,\n", + " bounds=bounds,\n", + " q=n,\n", + " optimizer_options=optimizer_options,\n", + " )\n", + " ```\n", + " Output is then used in:\n", + " ```\n", + " optimize_acqf(\n", + " acq_function=self.acqf,\n", + " bounds=bounds,\n", + " q=n,\n", + " inequality_constraints=inequality_constraints,\n", + " fixed_features=fixed_features,\n", + " post_processing_func=post_processing_func,\n", + " **optimizer_options_with_defaults,\n", + " )\n", + " ```\n", + "\n", + " Args:\n", + " acqf: Acquisition function being optimised. This variable is unused.\n", + " **kwargs: Variety of kwargs. will have a key \"optimizer_options\", which has user override that need to be used.\n", + " See \"Args:Example\". The \"optimizer_options\" can contian an object similar to \"Returns:Example\"\n", + "\n", + " Example `**kwargs`:\n", + " ```\n", + " {\n", + " \"bounds\": torch.tensor(...),\n", + " \"q\": 1,\n", + " \"optimizer_options\": { # Content specified in the original `.gen()` call (\"\")\n", + " \"options\": {\"with_grad\": True}\n", + " },\n", + " }\n", + " ```\n", + "\n", + "\n", + " Returns:\n", + " dict[str, Any]: kwargs passed to `botorch.optim.optimize.optimize_acqf`. If not present in this output\n", + " `optimize_acqf` will use its default values.\n", + "\n", + " Example:\n", + " ```\n", + " {\n", + " # Top-level kwargs of optimize_acqf:\n", + " \"num_restarts\": 10,\n", + " \"raw_samples\": 100,\n", + " \"sequential\": True,\n", + " \"timeout_sec\": 60.0,\n", + " \"retry_on_optimization_warning\": False,\n", + " # ─── Goes to `botorch.generation.gen.gen_candidates_scipy()` ───\n", + " \"options\": {\n", + " # Init-phase options (consumed by gen_batch_initial_conditions):\n", + " \"init_batch_limit\": 32,\n", + " \"batch_limit\": 5,\n", + " \"seed\": 42,\n", + " \"sample_around_best\": True,\n", + " # gen_candidates_scipy options (consumed before scipy):\n", + " \"with_grad\": False,\n", + " \"method\": \"Nelder-Mead\",\n", + " \"callback\": my_callback_fn,\n", + " # ─── Goes to scipy.optimize.minimize(options={...}) ───\n", + " \"maxiter\": 500,\n", + " \"maxfev\": 1000,\n", + " \"xatol\": 1e-8,\n", + " \"fatol\": 1e-8,\n", + " # ... any scipy method-specific option\n", + " },\n", + " }\n", + " ```\n", + " \"\"\"\n", + " # Use the default argument constructor as a starting point.\n", + " args = _argparse_base(acqf, **kwargs)\n", + "\n", + " # Check if a user override is provided, otherwise set the default value. Example. default \"with_grad\" to False.\n", + " args[\"options\"][\"with_grad\"] = kwargs.get(\"optimizer_options\", {}).get(\"options\", {}).get(\"with_grad\", False)\n", + " return args" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'sequential': True,\n", + " 'num_restarts': 20,\n", + " 'raw_samples': 1024,\n", + " 'options': {'init_batch_limit': 32, 'batch_limit': 999}}" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "_argparse_base(CustomAcq, optimizer_options={\"options\": {\"batch_limit\": 999}})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Option 1: low level Ax\n", + "Note, with this hyperparams are refitted every round of DoE" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Manually add some data to the experiment" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
arm_namemetric_namemeansemtrial_index
00_0dummy_metric2.173439NaN0
11_0dummy_metric1.199449NaN1
\n", + "
" + ], + "text/plain": [ + " arm_name metric_name mean sem trial_index\n", + "0 0_0 dummy_metric 2.173439 NaN 0\n", + "1 1_0 dummy_metric 1.199449 NaN 1" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "{0: Trial(experiment_name='Dummy_experiment', index=0, status=TrialStatus.COMPLETED, arm=Arm(name='0_0', parameters={'x': 0.1})),\n", + " 1: Trial(experiment_name='Dummy_experiment', index=1, status=TrialStatus.COMPLETED, arm=Arm(name='1_0', parameters={'x': 0.85}))}" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "manual_exp_locations = [[0.1], [0.85]]\n", + "for x in manual_exp_locations:\n", + " # this is just a quick and diry unpacking for now, will need to extend to x in higher dims\n", + " trial_arm = exp.new_trial().add_arm(Arm(parameters={\"x\": x[0]}))\n", + " trial_arm.run()\n", + " trial_arm.mark_completed()\n", + "\n", + "# Check this has been properly attached\n", + "_ = display(exp.fetch_data().df)\n", + "exp.trials" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each loop build a new GP from the available data, and use the custom acquisition function to select a new point" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "for _ in range(5):\n", + " model_bridge_cust_ac = Models.BOTORCH_MODULAR(\n", + " experiment=exp,\n", + " data=exp.fetch_data(),\n", + " # surrogate=Surrogate(FixedNoiseGP), # Optional, will use default if unspecified # noqa: ERA001\n", + " botorch_acqf_class=CustomAcq, # Optional, will use default if unspecified\n", + " acquisition_options={\"dist\": DIST},\n", + " )\n", + " trial = exp.new_trial(\n", + " generator_run=model_bridge_cust_ac.gen(\n", + " 1,\n", + " # This section is optional. with_grad default to True if not specified here\n", + " model_gen_options={\n", + " \"optimizer_kwargs\": {\n", + " \"options\": {\"with_grad\": True},\n", + " }\n", + " },\n", + " )\n", + " )\n", + " _ = trial.run()\n", + " _ = trial.mark_completed()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Show the resulting experiment object" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
arm_namemetric_namemeansemtrial_index
00_0dummy_metric2.173439NaN0
11_0dummy_metric1.199449NaN1
22_0dummy_metric0.486447NaN2
33_0dummy_metric0.955847NaN3
44_0dummy_metric0.101406NaN4
55_0dummy_metric3.000000NaN5
66_0dummy_metric0.168751NaN6
\n", + "
" + ], + "text/plain": [ + " arm_name metric_name mean sem trial_index\n", + "0 0_0 dummy_metric 2.173439 NaN 0\n", + "1 1_0 dummy_metric 1.199449 NaN 1\n", + "2 2_0 dummy_metric 0.486447 NaN 2\n", + "3 3_0 dummy_metric 0.955847 NaN 3\n", + "4 4_0 dummy_metric 0.101406 NaN 4\n", + "5 5_0 dummy_metric 3.000000 NaN 5\n", + "6 6_0 dummy_metric 0.168751 NaN 6" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "exp.fetch_data().df" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "linkText": "Export to plot.ly", + "plotlyServerURL": "https://plot.ly", + "showLink": false + }, + "data": [ + { + "fill": "toself", + "fillcolor": "rgba(128, 177, 211, 0.2)", + "hoverinfo": "none", + "line": { + "color": "rgba(128, 177, 211, 0.0)" + }, + "showlegend": false, + "type": "scatter", + "visible": true, + "x": [ + 0, + 0.02040816326530612, + 0.04081632653061224, + 0.061224489795918366, + 0.08163265306122448, + 0.1020408163265306, + 0.12244897959183672, + 0.14285714285714285, + 0.16326530612244897, + 0.18367346938775508, + 0.2040816326530612, + 0.22448979591836732, + 0.24489795918367344, + 0.26530612244897955, + 0.2857142857142857, + 0.3061224489795918, + 0.32653061224489793, + 0.3469387755102041, + 0.36734693877551017, + 0.3877551020408163, + 0.4081632653061224, + 0.42857142857142855, + 0.44897959183673464, + 0.4693877551020408, + 0.4897959183673469, + 0.5102040816326531, + 0.5306122448979591, + 0.5510204081632653, + 0.5714285714285714, + 0.5918367346938775, + 0.6122448979591836, + 0.6326530612244897, + 0.6530612244897959, + 0.673469387755102, + 0.6938775510204082, + 0.7142857142857142, + 0.7346938775510203, + 0.7551020408163265, + 0.7755102040816326, + 0.7959183673469387, + 0.8163265306122448, + 0.836734693877551, + 0.8571428571428571, + 0.8775510204081632, + 0.8979591836734693, + 0.9183673469387754, + 0.9387755102040816, + 0.9591836734693876, + 0.979591836734694, + 1, + 1, + 0.979591836734694, + 0.9591836734693876, + 0.9387755102040816, + 0.9183673469387754, + 0.8979591836734693, + 0.8775510204081632, + 0.8571428571428571, + 0.836734693877551, + 0.8163265306122448, + 0.7959183673469387, + 0.7755102040816326, + 0.7551020408163265, + 0.7346938775510203, + 0.7142857142857142, + 0.6938775510204082, + 0.673469387755102, + 0.6530612244897959, + 0.6326530612244897, + 0.6122448979591836, + 0.5918367346938775, + 0.5714285714285714, + 0.5510204081632653, + 0.5306122448979591, + 0.5102040816326531, + 0.4897959183673469, + 0.4693877551020408, + 0.44897959183673464, + 0.42857142857142855, + 0.4081632653061224, + 0.3877551020408163, + 0.36734693877551017, + 0.3469387755102041, + 0.32653061224489793, + 0.3061224489795918, + 0.2857142857142857, + 0.26530612244897955, + 0.24489795918367344, + 0.22448979591836732, + 0.2040816326530612, + 0.18367346938775508, + 0.16326530612244897, + 0.14285714285714285, + 0.12244897959183672, + 0.1020408163265306, + 0.08163265306122448, + 0.061224489795918366, + 0.04081632653061224, + 0.02040816326530612, + 0 + ], + "y": [ + 3.033781505152954, + 2.8693731817412216, + 2.706251807912652, + 2.5364458833478323, + 2.3628563401814366, + 2.1930441560622476, + 2.0327900813246353, + 1.879786398997685, + 1.7296379082661133, + 1.580089484802722, + 1.4308612411697812, + 1.283289073642656, + 1.140268236110893, + 1.0059453800892333, + 0.8831705251195227, + 0.7701290256962638, + 0.6641705016555317, + 0.5665293397081264, + 0.48123451363368086, + 0.4091347972372933, + 0.3469017154525536, + 0.2911706715413006, + 0.24003244742514568, + 0.19337823727036535, + 0.15458571242680147, + 0.13709261807888365, + 0.15504662771657512, + 0.1986408697131, + 0.2589646206066321, + 0.33147403380797247, + 0.41278024427765536, + 0.49986851841398094, + 0.5899419434089989, + 0.6804034611086149, + 0.7688722257239864, + 0.8532084814719494, + 0.9315406441632612, + 1.0022953499981933, + 1.0642387586258086, + 1.116562973873546, + 1.1592051403260524, + 1.1954342085785976, + 1.2808326148487632, + 1.4591626679958802, + 1.6528694749306203, + 1.8527806945663845, + 2.056516616394515, + 2.262489433291742, + 2.4693882779828784, + 2.6760745495539036, + 1.0862437547048889, + 1.1248635912127627, + 1.1572568323480157, + 1.1826641108285425, + 1.2002691440125868, + 1.2091104123951544, + 1.2075844103692563, + 1.1874651855151876, + 1.072336879786786, + 0.9073120672831212, + 0.7495233093433421, + 0.6039558107415373, + 0.4723947489591964, + 0.3559789435556083, + 0.2554875432755015, + 0.1713941564626169, + 0.10387541390086004, + 0.05280725112223983, + 0.01775660798282694, + -0.002031299066165948, + -0.007657080245450781, + -0.000629117892835096, + 0.016931925788778474, + 0.04145910090341649, + 0.06466836312729327, + 0.07696451262412303, + 0.09225030665216744, + 0.12331612781944118, + 0.17259064115995482, + 0.2388124208853263, + 0.31880947650378116, + 0.407934507312417, + 0.5016446359012239, + 0.5997218725157802, + 0.7053008821277698, + 0.818867521090673, + 0.9371356341141948, + 1.0577342676567691, + 1.1829949035475595, + 1.3165246612759334, + 1.46059306798846, + 1.6157565501886737, + 1.780731396537403, + 1.9519597582408792, + 2.123365416874829, + 2.290497759004233, + 2.456500268605279, + 2.6259412152498567, + 2.798592355574992, + 2.963438028716299 + ] + }, + { + "hoverinfo": "x+y", + "line": { + "color": "rgba(128, 177, 211, 1)" + }, + "showlegend": false, + "type": "scatter", + "visible": true, + "x": [ + 0, + 0.02040816326530612, + 0.04081632653061224, + 0.061224489795918366, + 0.08163265306122448, + 0.1020408163265306, + 0.12244897959183672, + 0.14285714285714285, + 0.16326530612244897, + 0.18367346938775508, + 0.2040816326530612, + 0.22448979591836732, + 0.24489795918367344, + 0.26530612244897955, + 0.2857142857142857, + 0.3061224489795918, + 0.32653061224489793, + 0.3469387755102041, + 0.36734693877551017, + 0.3877551020408163, + 0.4081632653061224, + 0.42857142857142855, + 0.44897959183673464, + 0.4693877551020408, + 0.4897959183673469, + 0.5102040816326531, + 0.5306122448979591, + 0.5510204081632653, + 0.5714285714285714, + 0.5918367346938775, + 0.6122448979591836, + 0.6326530612244897, + 0.6530612244897959, + 0.673469387755102, + 0.6938775510204082, + 0.7142857142857142, + 0.7346938775510203, + 0.7551020408163265, + 0.7755102040816326, + 0.7959183673469387, + 0.8163265306122448, + 0.836734693877551, + 0.8571428571428571, + 0.8775510204081632, + 0.8979591836734693, + 0.9183673469387754, + 0.9387755102040816, + 0.9591836734693876, + 0.979591836734694, + 1 + ], + "y": [ + 2.9986097669346266, + 2.8339827686581067, + 2.6660965115812543, + 2.4964730759765557, + 2.326677049592835, + 2.1582047864685383, + 1.9923749197827576, + 1.830258897767544, + 1.6726972292273934, + 1.520341276395591, + 1.3736929512228573, + 1.2331419885951078, + 1.099001251883831, + 0.971540507101714, + 0.8510190231050978, + 0.7377149539120168, + 0.631946187085656, + 0.5340869878046751, + 0.4445845104730489, + 0.3639721368705372, + 0.29285706816893997, + 0.2318806563506277, + 0.18167428762229343, + 0.1428142719612664, + 0.11577511252546224, + 0.10088049060308846, + 0.0982528643099958, + 0.10778639775093923, + 0.1291677513568985, + 0.16190847678126086, + 0.2053744726057447, + 0.25881256319840396, + 0.32137459726561934, + 0.39213943750473745, + 0.4701331910933017, + 0.5543480123737254, + 0.6437597938594347, + 0.7373450494786948, + 0.834097284683673, + 0.933043141608444, + 1.0332586038045868, + 1.1338855441826918, + 1.2341489001819754, + 1.3333735391825683, + 1.4309899436628877, + 1.5265249192894856, + 1.619590363611529, + 1.7098731328198788, + 1.7971259345978206, + 1.881159152129396 + ] + }, + { + "error_y": { + "array": [ + null, + null, + null, + null, + null, + null + ], + "color": "black", + "type": "data", + "visible": true + }, + "hoverinfo": "x+y", + "line": { + "color": "black" + }, + "mode": "markers", + "showlegend": false, + "type": "scatter", + "visible": true, + "x": [ + 0.1, + 0.85, + 0.3576860948594309, + 0.26792058201081304, + 0.5072161820836099, + 0 + ], + "y": [ + 2.173439380015981, + 1.1994488478257488, + 0.4864466552251665, + 0.9558474405423882, + 0.10140559931573856, + 3 + ] + } + ], + "layout": { + "hovermode": "closest", + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermap": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermap" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "xaxis": { + "anchor": "y", + "autorange": false, + "exponentformat": "e", + "range": [ + 0, + 1 + ], + "tickfont": { + "size": 11 + }, + "tickmode": "auto", + "title": { + "text": "x" + }, + "type": "linear" + }, + "yaxis": { + "anchor": "x", + "tickfont": { + "size": 11 + }, + "tickmode": "auto", + "title": { + "text": "dummy_metric" + } + } + } + } + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render(\n", + " plot_slice(\n", + " model=model_bridge_cust_ac,\n", + " param_name=\"x\",\n", + " metric_name=\"dummy_metric\",\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see this produces the same points as the botorch model that is fully retrained at each step, as expected.\n", + "\n", + "- TODO(sw 2024-11-13): Build the equivalent plot to the botorch component using the Ax interface to the model." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Option 2: Higher level Ax: Generation Stratergy\n", + "Uses higher level ax services. Note, with this hyperparams are refitted every round of DoE" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "# Make the experiment fresh\n", + "exp = Experiment(\n", + " name=\"Dummy_experiment\",\n", + " search_space=search_space,\n", + " optimization_config=optimization_config,\n", + " runner=MyRunner(),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "gs = GenerationStrategy(\n", + " steps=[\n", + " # Quasi-random initialization step\n", + " GenerationStep(\n", + " model=Models.SOBOL,\n", + " num_trials=2, # How many trials should be produced from this generation step\n", + " model_kwargs={\"seed\": 999}, # Any kwargs you want passed into the model\n", + " ),\n", + " # Bayesian optimization step using the custom acquisition function\n", + " GenerationStep(\n", + " model=Models.BOTORCH_MODULAR,\n", + " num_trials=-1, # No limitation on how many trials should be produced from this step\n", + " # For `BOTORCH_MODULAR`, we pass in kwargs to specify what surrogate or acquisition function to use.\n", + " # `acquisition_options` specifies the set of additional arguments to pass into the input constructor.\n", + " model_kwargs={\n", + " \"botorch_acqf_class\": CustomAcq,\n", + " \"acquisition_options\": {\"dist\": DIST},\n", + " },\n", + " ),\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[INFO 05-07 15:03:20] ax.service.ax_client: Starting optimization with verbose logging. To disable logging, set the `verbose_logging` argument to `False`. Note that float values in the logs are rounded to 6 decimal points.\n" + ] + } + ], + "source": [ + "from ax.service.ax_client import AxClient\n", + "\n", + "# Initialize the client - AxClient offers a convenient API to control the experiment\n", + "ax_client = AxClient(generation_strategy=gs)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "# Not yet supported ax_client.load_experiment('Dummy_experiment')\n", + "\n", + "# Bit of a hacky way to attach it to the higher level thing\n", + "_ = ax_client._set_runner(experiment=exp) # noqa: SLF001\n", + "_ = ax_client._set_experiment( # noqa: SLF001\n", + " experiment=exp,\n", + " overwrite_existing_experiment=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "# NOTE we have already defined the objective inside the experiement, annoying we need to define it again\n", + "def evaluate(parameters): # type: ignore # noqa: ANN001\n", + " # Note this is just because our objective function works with tensors\n", + " x = torch.tensor([parameters.get(\"x\")], dtype=torch.float64)\n", + " # In our case, standard error is 0, since we are computing a synthetic function.\n", + " return {\"dummy_metric\": (underling_function(x).item(), 0.0)}" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[INFO 05-07 15:03:20] ax.service.ax_client: Generated new trial 0 with parameters {'x': 0.62873} using model Sobol.\n", + "[INFO 05-07 15:03:20] ax.service.ax_client: Completed trial 0 with data: {'dummy_metric': (0.192786, 0.0)}.\n", + "[INFO 05-07 15:03:20] ax.service.ax_client: Generated new trial 1 with parameters {'x': 0.277899} using model Sobol.\n", + "[INFO 05-07 15:03:20] ax.service.ax_client: Completed trial 1 with data: {'dummy_metric': (0.896038, 0.0)}.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running trial 1/30...\n", + "Running trial 2/30...\n", + "Running trial 3/30...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[INFO 05-07 15:03:20] ax.service.ax_client: Generated new trial 2 with parameters {'x': 0.110243} using model BoTorch.\n", + "[INFO 05-07 15:03:20] ax.service.ax_client: Completed trial 2 with data: {'dummy_metric': (2.090818, 0.0)}.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running trial 4/30...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[INFO 05-07 15:03:20] ax.service.ax_client: Generated new trial 3 with parameters {'x': 0.426317} using model BoTorch.\n", + "[INFO 05-07 15:03:20] ax.service.ax_client: Completed trial 3 with data: {'dummy_metric': (0.243532, 0.0)}.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running trial 5/30...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[INFO 05-07 15:03:21] ax.service.ax_client: Generated new trial 4 with parameters {'x': 0.0} using model BoTorch.\n", + "[INFO 05-07 15:03:21] ax.service.ax_client: Completed trial 4 with data: {'dummy_metric': (3.0, 0.0)}.\n" + ] + } + ], + "source": [ + "for i in range(5):\n", + " print(f\"Running trial {i + 1}/30...\")\n", + " parameters, trial_index = ax_client.get_next_trial()\n", + " # Local evaluation here can be replaced with deployment to external system.\n", + " ax_client.complete_trial(trial_index=trial_index, raw_data=evaluate(parameters))" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "linkText": "Export to plot.ly", + "plotlyServerURL": "https://plot.ly", + "showLink": false + }, + "data": [ + { + "fill": "toself", + "fillcolor": "rgba(128, 177, 211, 0.2)", + "hoverinfo": "none", + "line": { + "color": "rgba(128, 177, 211, 0.0)" + }, + "showlegend": false, + "type": "scatter", + "visible": true, + "x": [ + 0, + 0.02040816326530612, + 0.04081632653061224, + 0.061224489795918366, + 0.08163265306122448, + 0.1020408163265306, + 0.12244897959183672, + 0.14285714285714285, + 0.16326530612244897, + 0.18367346938775508, + 0.2040816326530612, + 0.22448979591836732, + 0.24489795918367344, + 0.26530612244897955, + 0.2857142857142857, + 0.3061224489795918, + 0.32653061224489793, + 0.3469387755102041, + 0.36734693877551017, + 0.3877551020408163, + 0.4081632653061224, + 0.42857142857142855, + 0.44897959183673464, + 0.4693877551020408, + 0.4897959183673469, + 0.5102040816326531, + 0.5306122448979591, + 0.5510204081632653, + 0.5714285714285714, + 0.5918367346938775, + 0.6122448979591836, + 0.6326530612244897, + 0.6530612244897959, + 0.673469387755102, + 0.6938775510204082, + 0.7142857142857142, + 0.7346938775510203, + 0.7551020408163265, + 0.7755102040816326, + 0.7959183673469387, + 0.8163265306122448, + 0.836734693877551, + 0.8571428571428571, + 0.8775510204081632, + 0.8979591836734693, + 0.9183673469387754, + 0.9387755102040816, + 0.9591836734693876, + 0.979591836734694, + 1, + 1, + 0.979591836734694, + 0.9591836734693876, + 0.9387755102040816, + 0.9183673469387754, + 0.8979591836734693, + 0.8775510204081632, + 0.8571428571428571, + 0.836734693877551, + 0.8163265306122448, + 0.7959183673469387, + 0.7755102040816326, + 0.7551020408163265, + 0.7346938775510203, + 0.7142857142857142, + 0.6938775510204082, + 0.673469387755102, + 0.6530612244897959, + 0.6326530612244897, + 0.6122448979591836, + 0.5918367346938775, + 0.5714285714285714, + 0.5510204081632653, + 0.5306122448979591, + 0.5102040816326531, + 0.4897959183673469, + 0.4693877551020408, + 0.44897959183673464, + 0.42857142857142855, + 0.4081632653061224, + 0.3877551020408163, + 0.36734693877551017, + 0.3469387755102041, + 0.32653061224489793, + 0.3061224489795918, + 0.2857142857142857, + 0.26530612244897955, + 0.24489795918367344, + 0.22448979591836732, + 0.2040816326530612, + 0.18367346938775508, + 0.16326530612244897, + 0.14285714285714285, + 0.12244897959183672, + 0.1020408163265306, + 0.08163265306122448, + 0.061224489795918366, + 0.04081632653061224, + 0.02040816326530612, + 0 + ], + "y": [ + 3.2076307064868104, + 3.006045736094455, + 2.7993548914622064, + 2.5897254217176373, + 2.3797684457303045, + 2.1725941426126707, + 2.047731591266688, + 1.9548297481531096, + 1.8368670935585831, + 1.696314452106438, + 1.5370781208859552, + 1.3643240591660528, + 1.184292535992005, + 1.0040943200603032, + 0.8622061176142587, + 0.7763211055784129, + 0.6914535109612557, + 0.6047283469035333, + 0.5147108444914573, + 0.4214778012198098, + 0.3266798148976676, + 0.24355261780346313, + 0.24813696409067823, + 0.2621794266808726, + 0.27967111732797, + 0.295524253710776, + 0.3054599693516108, + 0.306094261975546, + 0.2949981836838055, + 0.27073773830749626, + 0.2329046193441064, + 0.21343823133392692, + 0.3309166242800837, + 0.4641039355521773, + 0.6099514323351376, + 0.7656865708735009, + 0.9287720245582004, + 1.0969165594796355, + 1.2680775869379868, + 1.4404565731830945, + 1.6124893057142662, + 1.782832691379899, + 1.9503493857558152, + 2.1140912350426726, + 2.2732822586577885, + 2.427301703760497, + 2.5756675511782285, + 2.7180207359130275, + 2.8541102567456536, + 2.983779282227986, + -1.2562454597064814, + -1.1964792586617945, + -1.1323462791240788, + -1.0638699349178429, + -0.9911359590237344, + -0.9143027870413988, + -0.8336127048233991, + -0.7494036566750255, + -0.6621215478387934, + -0.5723327918911882, + -0.4807367441576416, + -0.3881775186397356, + -0.295654498794856, + -0.2043306111114923, + -0.11553712603827282, + -0.030773391447610043, + 0.04830040096888999, + 0.1198784742386335, + 0.1819724300991714, + 0.11450357978891272, + 0.03730454239149594, + -0.0163408431471167, + -0.0454197443825142, + -0.0498841545952696, + -0.030639214905858025, + 0.01047350907775388, + 0.07070792257414008, + 0.14646479447078117, + 0.23313745553215895, + 0.2537372626506841, + 0.2853720594034318, + 0.3420790272418264, + 0.4259643841015074, + 0.5371177439479012, + 0.6735578304239862, + 0.8311647225450322, + 0.9528445163259884, + 1.053172462104622, + 1.166582772189094, + 1.2954882483598156, + 1.4410461996394817, + 1.603212278979389, + 1.7808083711750455, + 1.9716039946914503, + 2.114529019646324, + 2.1561028303074723, + 2.1737228946530545, + 2.1692176052762404, + 2.144601956670865, + 2.101993597630493 + ] + }, + { + "hoverinfo": "x+y", + "line": { + "color": "rgba(128, 177, 211, 1)" + }, + "showlegend": false, + "type": "scatter", + "visible": true, + "x": [ + 0, + 0.02040816326530612, + 0.04081632653061224, + 0.061224489795918366, + 0.08163265306122448, + 0.1020408163265306, + 0.12244897959183672, + 0.14285714285714285, + 0.16326530612244897, + 0.18367346938775508, + 0.2040816326530612, + 0.22448979591836732, + 0.24489795918367344, + 0.26530612244897955, + 0.2857142857142857, + 0.3061224489795918, + 0.32653061224489793, + 0.3469387755102041, + 0.36734693877551017, + 0.3877551020408163, + 0.4081632653061224, + 0.42857142857142855, + 0.44897959183673464, + 0.4693877551020408, + 0.4897959183673469, + 0.5102040816326531, + 0.5306122448979591, + 0.5510204081632653, + 0.5714285714285714, + 0.5918367346938775, + 0.6122448979591836, + 0.6326530612244897, + 0.6530612244897959, + 0.673469387755102, + 0.6938775510204082, + 0.7142857142857142, + 0.7346938775510203, + 0.7551020408163265, + 0.7755102040816326, + 0.7959183673469387, + 0.8163265306122448, + 0.836734693877551, + 0.8571428571428571, + 0.8775510204081632, + 0.8979591836734693, + 0.9183673469387754, + 0.9387755102040816, + 0.9591836734693876, + 0.979591836734694, + 1 + ], + "y": [ + 2.6548121520586516, + 2.57532384638266, + 2.4842862483692234, + 2.381724158185346, + 2.2679356380188884, + 2.1435615811294975, + 2.0096677929790694, + 1.8678190596640776, + 1.7200396862689862, + 1.5686803258729598, + 1.4162831846228854, + 1.2654534156775734, + 1.1187324990483134, + 0.9784694181931458, + 0.8466854200796454, + 0.7249394680011996, + 0.6142856274545785, + 0.5153463655025203, + 0.42839493586664185, + 0.3534249303116208, + 0.29020853877417585, + 0.23834503666781104, + 0.1973008792807297, + 0.1664436746275063, + 0.14507231320286196, + 0.132442519402459, + 0.12778790737817058, + 0.13033725879651592, + 0.1393286702683444, + 0.1540211403494961, + 0.17370409956650956, + 0.19770533071654917, + 0.22539754925935865, + 0.25620216826053366, + 0.2895890204437638, + 0.32507472241761404, + 0.3622207067233541, + 0.40063103034238984, + 0.4399500341491256, + 0.4798599145127264, + 0.520078256911539, + 0.5603555717705528, + 0.600472864540395, + 0.6402392651096368, + 0.6794897358081948, + 0.7180828723683813, + 0.755898808130193, + 0.7928372283944745, + 0.8288154990419297, + 0.8637669112607524 + ] + }, + { + "error_y": { + "array": [ + 0, + 0, + 0, + 0 + ], + "color": "black", + "type": "data", + "visible": true + }, + "hoverinfo": "x+y", + "line": { + "color": "black" + }, + "mode": "markers", + "showlegend": false, + "type": "scatter", + "visible": true, + "x": [ + 0.6287298016250134, + 0.2778989737853408, + 0.11024311660507176, + 0.4263171068199194 + ], + "y": [ + 0.1927861274874907, + 0.8960375861049727, + 2.0908178230009353, + 0.2435317156325567 + ] + } + ], + "layout": { + "hovermode": "closest", + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermap": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermap" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "xaxis": { + "anchor": "y", + "autorange": false, + "exponentformat": "e", + "range": [ + 0, + 1 + ], + "tickfont": { + "size": 11 + }, + "tickmode": "auto", + "title": { + "text": "x" + }, + "type": "linear" + }, + "yaxis": { + "anchor": "x", + "tickfont": { + "size": 11 + }, + "tickmode": "auto", + "title": { + "text": "dummy_metric" + } + } + } + } + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render(\n", + " plot_slice(\n", + " model=ax_client.generation_strategy.model,\n", + " param_name=\"x\",\n", + " metric_name=\"dummy_metric\",\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Option 3: Alternate way of interacting with the model\n", + "- create a botorch model useing the interface `ax.models.torch.botorch` [here](https://ax.dev/api/models.html#module-ax.models.torch.botorch)\n", + "- also a relevant tutorial [here](https://botorch.org/tutorials/custom_botorch_model_in_ax)\n", + "\n", + "TODO: Explore this further" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "axtreme", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tutorials/ax_botorch/botrch_minimal_example_custom_acq.ipynb b/tutorials/ax_botorch/botrch_minimal_example_custom_acq.ipynb deleted file mode 100644 index 8408a90f..00000000 --- a/tutorials/ax_botorch/botrch_minimal_example_custom_acq.ipynb +++ /dev/null @@ -1,1207 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# A Minimal example of custom acquisiton function\n", - "This notebooks covers the consideration for setting up a Custom Acquisitions function, and optimising it with botorch and Ax.\n", - "\n", - "Problem description:\n", - "- TODO: flesh this out: why do we not just use the gp to model objective = pdf * underling function in this example (and in general)\n", - "\n", - "This notebook covers:\n", - "- Set up (through botorch):\n", - " - problem (true underling function and datapoint)\n", - " - Setup GP\n", - "- Basic Acquisition function:\n", - " - `__init__` and `forward` inputs and outputs\n", - " - Behaviour expected by the things that then optimise this.\n", - "- Optimisation of Acqusitions function (through Botorch):\n", - " - Brute force scoring of acquisiton function over the domain\n", - " - High level botorch automatic tool `optimise_acqf` (builds on the bellow)\n", - " - lower level botorch (`gen_batch_initial_conditions`, `gen_candidates_scipy`)\n", - " - Direct `scipy` optimisation\n", - "- Multiple rounds of DOE (gp + acquisition -> pick new point and train new gp)\n", - " - TODO: what is the true optimal of the problem\n", - " - refit hyperparams every step (and condition)\n", - " - don't refit hyperparms each step (just condition)\n", - "- Put into `Ax` framework.\n", - " - Set up the `acqf_input_constructor` required\n", - " - ax.BotorchModel using custom acquisition and acquisition args (all wraped in TorchModelBridge)\n", - " - Wrapping above into a `GenerationStratergy`\n", - "- Exploration\n", - " - WIP: Supporting q = 2 optimisation, using sequential q=1. This is similar to lookahead\n", - " - Differntiation through 2 levels of fantasy GPs" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import Any\n", - "\n", - "import gpytorch\n", - "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", - "import scipy\n", - "import torch\n", - "from ax.core import (\n", - " Arm,\n", - " Data,\n", - " Experiment,\n", - " Metric,\n", - " Objective,\n", - " OptimizationConfig,\n", - " ParameterType,\n", - " RangeParameter,\n", - " Runner,\n", - " SearchSpace,\n", - ")\n", - "from ax.modelbridge.generation_strategy import GenerationStep, GenerationStrategy\n", - "from ax.modelbridge.registry import Models\n", - "from ax.plot.slice import plot_slice\n", - "from ax.utils.common.result import Ok\n", - "from ax.utils.notebook.plotting import render\n", - "from botorch.acquisition import input_constructors\n", - "from botorch.acquisition.acquisition import AcquisitionFunction\n", - "from botorch.acquisition.input_constructors import acqf_input_constructor\n", - "from botorch.fit import fit_gpytorch_model\n", - "from botorch.generation.gen import gen_candidates_scipy\n", - "from botorch.models import SingleTaskGP\n", - "from botorch.models.model import Model\n", - "from botorch.optim import optimize_acqf\n", - "from botorch.optim.initializers import gen_batch_initial_conditions\n", - "from botorch.posteriors.gpytorch import GPyTorchPosterior\n", - "from botorch.utils.transforms import t_batch_mode_transform\n", - "from matplotlib.axes import Axes\n", - "from torch.distributions.distribution import Distribution\n", - "from torch.distributions.normal import Normal" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "device = torch.device(\"cpu\") # \"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - "\n", - "# As explained here there are a lot of issues that come up when using dtype = float32 (This is the default for torch\n", - "# because its faster than float64) .Specifically this will cause issues with scipy optimise, because it will recommends\n", - "# a small step (.4 ->.40000000001), but in the conversion to float34 it will be truncated back to .4, and the model will\n", - "# produce the exact same output\n", - "# https://github.com/pytorch/botorch/discussions/1444\n", - "\n", - "torch.set_default_dtype(torch.float64)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Set up" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Set up the true underlying function\n", - "This is the find we model with our GP (e.g the simulator)." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def underling_function(x: torch.Tensor) -> torch.Tensor:\n", - " return -3 * torch.sin(3 * x) - x**2 + 0.7 * x + 3\n", - "\n", - "\n", - "x = torch.linspace(0, 1, 100)\n", - "y_true = underling_function(x)\n", - "\n", - "_ = plt.plot(x.numpy(), y_true.numpy())\n", - "_ = plt.title(\"true function\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Set up the training data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "bounds = torch.tensor([[0.0], [1.0]]) # 1D search space [lower_bound, upper_bound]\n", - "random_initial_points = 2\n", - "\n", - "train_x = torch.tensor([[0.1], [0.85]])\n", - "train_y = underling_function(train_x)\n", - "\n", - "\n", - "_ = plt.plot(x.numpy(), y_true.numpy())\n", - "_ = plt.scatter(train_x.numpy(), train_y.numpy(), c=\"red\")\n", - "_ = plt.title(\"true function\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Create the GP" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Single task GP: Single independant output, with homoskedastic noise (fit from data)\n", - "# Note: this model can be used as is, but the hyperparams have not yet been fit for this specific problem\n", - "gp = SingleTaskGP(train_X=train_x, train_Y=train_y)\n", - "\n", - "print(gp)\n", - "\n", - "# mll: marginal log likelihood. This can be thought of as the \"loss\" function which is thin optimised\n", - "# with `fit_gpytorch_model(mll)` to find the hyperparameters (e.g length_scale etc).\n", - "mll = gpytorch.mlls.ExactMarginalLogLikelihood(gp.likelihood, gp)\n", - "_ = fit_gpytorch_model(mll);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Show the result of the fitted Gp" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Like gypytorch, model should be set to eval prior to making predictions\n", - "_ = gp.eval()\n", - "# The Likelihood also needs to be set to eval if its not automatically within the model likelihood.eval()\n", - "\n", - "\n", - "# Helper\n", - "def plot_gp(model: Model, X: torch.Tensor | None = None, posterior_samples: int = 10, ax: None | Axes = None) -> Axes: # noqa: N803\n", - " \"\"\"Plots each of the model targets over the domain. Also plots the training data.\n", - "\n", - " Args:\n", - " model: assumed to be relevant to this demo problem (targets, domain etc).\n", - " # TODO(sw 2024-11-8): currently only testing with SingleTaskGP\n", - " X: (n,1): Linspace of [0,1] is used by default. Only 1d is currently supported.\n", - " posterior_samples: Number of posterior samples to draw and plot\n", - " ax: will plot to this axis if provied\n", - " \"\"\"\n", - " X = X if (X is not None) else torch.linspace(0, 1, 201).reshape(-1, 1) # noqa: N806\n", - "\n", - " if ax is None:\n", - " _, ax = plt.subplots()\n", - "\n", - " # Quick and dirty way to ensure consistent colours\n", - " colours = [\"b\", \"c\", \"m\", \"y\", \"k\", \"r\"]\n", - "\n", - " train_x_all = model.train_inputs[0].detach()\n", - " train_y_all = model.train_targets.detach()\n", - " train_var_all = model.likelihood.noise.detach()\n", - "\n", - " # t = 1 then:\n", - " # shape model.train_targets: (n)\n", - " # shape model.train_inputs: ((n,d),)\n", - " if len(model.train_targets.shape) == 1:\n", - " n_targets = 1\n", - " # need to add a t dimension to all of these so they can be treated the same way as the multicase\n", - " train_x_all = train_x_all.unsqueeze(0)\n", - " train_y_all = train_y_all.unsqueeze(0)\n", - " train_var_all = train_var_all.unsqueeze(0)\n", - "\n", - " # t > 1 then:\n", - " # shape model.train_targets: (t,n)\n", - " # shape model.train_inputs: ((t,n,d),)\n", - " else:\n", - " n_targets = model.train_targets.shape[-1]\n", - "\n", - " for target_idx in range(n_targets):\n", - " c = colours[target_idx % len(colours)]\n", - "\n", - " train_x = train_x_all[target_idx]\n", - " train_y = train_y_all[target_idx]\n", - " train_var = train_var_all[target_idx]\n", - "\n", - " with torch.no_grad():\n", - " posterior: GPyTorchPosterior = model.posterior(X) # type: ignore\n", - "\n", - " mean = posterior.mean[:, target_idx]\n", - " var = posterior.variance[:, target_idx]\n", - " _ = ax.fill_between(X.flatten(), mean - 1.95 * var**0.5, mean + 1.95 * var**0.5, alpha=0.3, color=c)\n", - " _ = ax.plot(X, mean, color=c)\n", - " _ = ax.scatter(train_x.flatten(), train_y, color=c)\n", - " _ = ax.errorbar(train_x.flatten(), train_y, 1.95 * train_var**0.5, fmt=\"o\", color=c)\n", - "\n", - " if posterior_samples > 0:\n", - " samples = posterior.rsample(torch.Size([posterior_samples]))[..., target_idx]\n", - " for sample in samples:\n", - " _ = ax.plot(X.cpu().numpy(), sample.cpu().numpy(), \"grey\", alpha=0.3)\n", - "\n", - " _ = ax.set_title(\"Gp prediction\")\n", - " return ax\n", - "\n", - "\n", - "# test model on 101 regular spaced points on the interval [0, 1]\n", - "_ = plot_gp(gp)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define mock optimisation problem\n", - "Typically, bayesian optimisation is about find the max of the true underling function.\n", - "\n", - "In axtreme, we need to integrated the GP over weather conditions, and we want to find areas of the GP that could reduce uncertainty in this calculation. This is not the same as standard ofptimisation of the GP, so a different approach is needed. This is discussed further in the axtreme package.\n", - "\n", - "Here we set up a more minimal example where:\n", - "- We have a GP surrogating some underlying funtion\n", - "- The next points that we want to chose if effected by a distribution as well as the GP\n", - "\n", - "While bayesian optimisation could be performed directly on the the objective function we define, the purpose of this is to use a GP and a simple distribution as a placeholder for more complex functionality, and show how CustomAcquisiton functions are integrated." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "DIST = Normal(0.3, 0.2)\n", - "\n", - "\n", - "def objective_func(X: torch.Tensor) -> torch.Tensor: # noqa: N803\n", - " prb = DIST.log_prob(X).exp()\n", - " y_true = underling_function(X)\n", - " return y_true * prb\n", - "\n", - "\n", - "def plot_gp_and_dist(gp: Model, acquisiton_function: AcquisitionFunction | None = None, ax: Axes | None = None):\n", - " X = torch.linspace(0, 1, 201).reshape(-1, 1) # noqa: N806\n", - "\n", - " ax = plot_gp(gp, ax=ax)\n", - "\n", - " # Add additional plots we find useful.\n", - " # The env dist\n", - " _ = ax.plot(X.numpy(), DIST.log_prob(X).exp(), color=\"green\", label=\"dist pdf\")\n", - " # true fucntion:\n", - " _ = ax.plot(X.numpy(), underling_function(X), color=\"red\", label=\"True underling\")\n", - " # The objectiove function\n", - " objective_results = objective_func(X)\n", - " x_max = X[objective_results.argmax()][0]\n", - " _ = ax.plot(\n", - " X,\n", - " objective_results,\n", - " color=\"black\",\n", - " label=f\"Objective function.\\nxmax {x_max:.3f}\\nscore {objective_results.max():.3f}\",\n", - " )\n", - " # formatting\n", - " _ = ax.legend(loc=\"upper right\")\n", - "\n", - " ax2 = None\n", - " if acquisiton_function:\n", - " scores = acquisiton_function(X.reshape(-1, 1, 1))\n", - " ax2 = ax.twinx()\n", - " _ = ax2.plot(X.detach().numpy(), scores.detach().numpy(), label=\"ac score\", color=\"orange\")\n", - " _ = ax2.set_ylabel(\"ac_function_score\", color=\"orange\")\n", - " _ = ax2.tick_params(\"y\", color=\"orange\")\n", - "\n", - " return ax2 or ax\n", - "\n", - "\n", - "_ = plot_gp_and_dist(gp)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Brute force the best result" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def estimate_xmax_with_gp(model: Model):\n", - " test_x = torch.linspace(0, 1, 1001)\n", - "\n", - " with torch.no_grad():\n", - " posterior = model.posterior(test_x)\n", - "\n", - " y_pred = posterior.mean.flatten()\n", - " prb = DIST.log_prob(test_x).exp()\n", - "\n", - " objective = y_pred * prb\n", - "\n", - " return test_x[objective.argmax()]\n", - "\n", - "\n", - "gp_xmax_est = estimate_xmax_with_gp(gp)\n", - "print(f\"gp xmax est {gp_xmax_est}. objective_score {objective_func(gp_xmax_est)}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Custom Acqusition function\n", - "Define the custom acquisiton function that can be optimisted through `botorch` and `Ax`.\n", - "\n", - "Requirements from `botorch` are detailed here. Requirements from `Ax` are detailed section \"Putting into Ax\"" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# TODO(sw 2024-11-13): need to check if this is the right type of class - there are more specific ones (e.g analytical)\n", - "class CustomAcq(AcquisitionFunction):\n", - " \"A simple AcquisitionFunction for a 1d problem to demonstrate interface and integeraton.\"\n", - "\n", - " def __init__(\n", - " self,\n", - " model: Model, # Mandatory Param required by the interface\n", - " # Every thing below this point is option that we choose to inlucde\n", - " dist: Distribution,\n", - " ) -> None:\n", - " r\"\"\"Constructor for the AcquisitionFunction base class.\n", - "\n", - " Args:\n", - " model: A fitted model.\n", - " dist: A distribtuion\n", - " \"\"\"\n", - " super().__init__(model=model) # create the attribute self.model\n", - "\n", - " self.dist: Distribution = dist\n", - "\n", - " # Helper to show the hyperparams of the GP. This is useful to know if the GO is being refit between DOE rounds\n", - " # print(f\"\\nCustomAcq GP recieved:\\n{gp.likelihood.noise=}\\n{gp.covar_module.base_kernel.lengthscale=}\\n{gp.covar_module.outputscale=}\") # noqa: E501, ERA001\n", - "\n", - " @t_batch_mode_transform(expected_q=1) # Ensure function gets X.shape = (t,1,d)\n", - " def forward(self, X: torch.Tensor) -> torch.Tensor: # type: ignore # noqa: N803\n", - " r\"\"\"Evaluate the acquisition function on the candidate set X.\n", - "\n", - " Args:\n", - " X: A `(b) x q x d`-dim Tensor of `(b)` t-batches with `q` `d`-dim\n", - " design points each. Loosely speaking, q-btaches and t-batchs translate to.\n", - " - `q-batch`: number of points output for a single DoE step. e.g q-batch=2, each time a new GP is trained\n", - " in the DoE process, it has 2 additional points\n", - " - `t-batch`: The number of independant q-batches being run in parrallel to best make use of hardware.\n", - "\n", - " Returns:\n", - " A `(b)`-dim Tensor of acquisition function values at the given\n", - " design points `X`. Larger values are considered better.\n", - "\n", - "\n", - " Botorch requirements:\n", - " - Requirement from optimisers:\n", - " Gradient: If `X.requires_grad = True` the output must support auto-differentiation from outputs to inputs.\n", - " The use of gradient is determined by the optimisation function applied to this function, and can not\n", - " be turned on/off from within the acquisition function (if turned on will be ignored, if turned off\n", - " ptimisation will throw error). Use of gradient though botorch is controlled with\n", - " `optimize_acqf(..., options = {\"with_grad\":False})`\n", - " See Notebook section \"Botorch Optimisation\" for details.\n", - "\n", - " Ax requirement:\n", - " - Problem/Outcome space vs. Model space\n", - " - Ax shifts everything from problem-space to model-space at the ModelBridge level (e.g TorchModelBridge).\n", - " - As a result, the x value received are in model-space. Need to act accordingly.\n", - "\n", - " Specific implementation:\n", - " - Provides a simple heuristic of optimising prblem with distributions by focusing on region with high\n", - " distribution probablity, and high GP uncertainty.\n", - " \"\"\"\n", - " assert X.shape[-1] == 1, \"Function only supports 1d input (d=1)\"\n", - "\n", - " prbs = self.dist.log_prob(X).exp()\n", - " # was: (b,1,1), now (b,)\n", - " prbs = prbs.flatten()\n", - "\n", - " posterior = self.model.posterior(X)\n", - " std = posterior.variance.sqrt().flatten() # type: ignore\n", - "\n", - " return prbs * std" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Run the acquisition function" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "cust_ac = CustomAcq(gp, DIST)\n", - "X = torch.tensor([[[0.1]], [[0.5]], [[0.9]]])\n", - "\n", - "# Note: .model.posterior turns of gradient tracking by default. gradient behavior is detailed in the following section\n", - "cust_ac(X)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Checking Gradient behaviour\n", - "Optimisation is controlled by `botorch.optim.optimize.optimize_acqf`, and gradient information is extracted in `botorch.generation.gen.gen_candidates_scipy`. The following mimics how gradient info is acquired in that function. This must produce the correct gradient for gradient based optimisation to be sucessful. Details covered in [Botroch Optimisation](#botroch-optimisation)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Single point" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# An acquisition function needs to be optimised with respect to its inputs.\n", - "X = torch.tensor([[[0.1]]], requires_grad=True)\n", - "# Is turned a maximisation to minimisation problem\n", - "loss = -1 * cust_ac(X)\n", - "_ = torch.autograd.grad(loss, X)\n", - "\n", - "\n", - "## This can be used to show the grad graph\n", - "# torchviz.make_dot(\n", - "# loss,\n", - "# dict(X = X), # noqa: ERA001\n", - "# show_attrs=True, # noqa: ERA001\n", - "# show_saved=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Multiple points (t-batch)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# An acquisition function needs to be optimised with respect to its inputs.\n", - "X = torch.tensor([[[0.1]], [[0.2]]], requires_grad=True)\n", - "# Is turned a maximisation to minimisation problem\n", - "loss = -1 * cust_ac(X)\n", - "_ = torch.autograd.grad(loss.sum(), X)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Optimisation of Acquisition:\n", - "The acqusition function needs to be compatible with the optimiser that optimises it.\n", - "- in `botorch`: `botorch.optim.optimize.optimize_acqf` is used to achieved this.\n", - "- in `ax`: When a new point in requested from a Generator in the DoE loop it connects this to `botorch.optim.optimize.optimize_acqf`.\n", - "\n", - "The relationship between from `ax` (bottom), through `botorch`, to `scipy` (top) is described in the following stack trace:\n", - "\n", - "```sh\n", - "minimize_with_timeout (botorch\\optim\\utils\\timeout.py:80) \n", - "# scipy.optimize.minimize is called here\n", - "gen_candidates_scipy (botorch\\generation\\gen.py:252)\n", - "# \"with_grad\" used here to determine optimisation approach:\n", - "# if True (line 192): \n", - "# - makes a wrapper around the acquisition function that give: acq_wrapper(x) -> (funct_value, func_grad).\n", - "# - jac=True in scipy.optimize.minimize\n", - "# if False (line 224):\n", - "# - wrapper returns: acq_wrapper(x) -> funct_value\n", - "# - jac=False in scipy.optimize.minimize\n", - "_optimize_batch_candidates (botorch\\optim\\optimize.py:333)\n", - "_optimize_acqf_batch (botorch\\optim\\optimize.py:349)\n", - "_optimize_acqf (botorch\\optim\\optimize.py:584)\n", - "optimize_acqf (botorch\\optim\\optimize.py:563)\n", - "optimize (ax\\models\\torch\\botorch_modular\\acquisition.py:439)\n", - "gen (ax\\models\\torch\\botorch_modular\\model.py:395)\n", - "_gen (ax\\modelbridge\\torch.py:682)\n", - "gen (ax\\modelbridge\\base.py:791)\n", - "TorchModelBridge.gen()\n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Brute force\n", - "Finding the maximum of the acquisition function. Note, at this point, the optimal of the objective is a long way for the best part of the objective" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "test_x = torch.linspace(0, 1, 101)\n", - "scores = cust_ac(test_x.reshape(-1, 1, 1))\n", - "\n", - "print(f\"Optimal values of acquisition: Best x {test_x[scores.argmax()]}. score {scores.max()}\")\n", - "\n", - "_ = plot_gp_and_dist(gp, acquisiton_function=cust_ac)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Botroch Optimisation" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Need to provide this with correct gradient information (in the tensor output object)\n", - "# OR manually tell it to ignore gradient\n", - "candidate, result = optimize_acqf(\n", - " cust_ac,\n", - " bounds=bounds,\n", - " q=1,\n", - " # This is how many different start location will be tried by the optimiser\n", - " num_restarts=5,\n", - " # TODO(sw 2024-11-13): confirm the impact of this paramerter\n", - " # Think this required when using a MCAcquisitionFunction (e.g the Acquisition function output at x is noisey).\n", - " # Controls how many time to repeat an x\n", - " raw_samples=100,\n", - " # Key parameter to control if optimisation should use gradient from the acquisiton fucntion\n", - " options={\"with_grad\": True}, # True by default\n", - ")\n", - "candidate, result" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Demonstaration of lower level Botorch optimisation\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### `optimize_acqf` internals\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "initial_conditions = gen_batch_initial_conditions(cust_ac, bounds, q=1, num_restarts=10, raw_samples=10)\n", - "candidates, scores = gen_candidates_scipy(\n", - " initial_conditions=initial_conditions,\n", - " acquisition_function=cust_ac,\n", - " lower_bounds=torch.tensor([0.0]),\n", - " upper_bounds=torch.tensor([1.0]),\n", - " # NOTE: Optimisation fails when this is true\n", - " # if false does an optimisation that ignore the gradient\n", - " # Must mean that we are giveing it bad gradient info in one way or another\n", - " # options = dict(with_grad = False) # noqa: ERA001\n", - ")\n", - "\n", - "\n", - "# get_best_candidates(candidates, scores) # noqa: ERA001\n", - "candidates[scores.argmax()], scores.max()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "##### Scipy direct optimisation\n", - "Internally botorch evarually used this" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"Make AcqusitionFunction compatible with scipy.optimisation:\n", - "- turn it into a minimisation problem\n", - "- use numpy\n", - "\n", - "This version doesn't use gradient information\n", - "\"\"\"\n", - "\n", - "\n", - "def acq_wrapper(x: torch.Tensor):\n", - " with torch.no_grad():\n", - " x = torch.tensor(x, dtype=torch.float64).reshape(-1, 1, 1)\n", - " acq_result = cust_ac(x)\n", - "\n", - " # we are using a minimise function, so we need to flip the sign\n", - " return -1 * acq_result.item()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "scipy.optimize.minimize(acq_wrapper, x0=[0.3], method=\"SLSQP\", bounds=[(0.0, 1.0)])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## DoE\n", - "Perform a loop of DoE, where we use the gp and the acquisition function to give use the next datapoint for our acquisition function\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Botorch\n", - "#### Retraining the model at each step:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "fig, axes = plt.subplots(5, 1, figsize=(8, 20))\n", - "\n", - "bounds = torch.tensor([[0.0], [1.0]]) # 1D search space [lower_bound, upper_bound]\n", - "train_x_opt = torch.tensor([[0.1], [0.85]])\n", - "train_y_opt = underling_function(train_x_opt)\n", - "\n", - "\n", - "for ax in axes:\n", - " # Train the GP on the available data\n", - " gp = SingleTaskGP(train_X=train_x_opt, train_Y=train_y_opt)\n", - " mll = gpytorch.mlls.ExactMarginalLogLikelihood(gp.likelihood, gp)\n", - " _ = fit_gpytorch_model(mll)\n", - " # Plot it and the acquisition function\n", - " cust_ac = CustomAcq(gp, DIST)\n", - "\n", - " # estimate the best point in the objective function with the current model\n", - " gp_xmax_est = estimate_xmax_with_gp(gp)\n", - " test_str = f\"gp xmax est {gp_xmax_est:.2f}.\\nobjective_score {objective_func(gp_xmax_est):.2f}\"\n", - " ax.text(\n", - " 0.05,\n", - " 0.05,\n", - " test_str,\n", - " transform=ax.transAxes,\n", - " fontsize=12,\n", - " verticalalignment=\"bottom\",\n", - " bbox={\"boxstyle\": \"round,pad=0.3\", \"edgecolor\": \"black\", \"facecolor\": \"lightgray\"},\n", - " )\n", - "\n", - " _ = plot_gp_and_dist(gp, acquisiton_function=cust_ac, ax=ax)\n", - "\n", - " candidate, result = optimize_acqf(\n", - " cust_ac,\n", - " bounds=bounds,\n", - " q=1,\n", - " num_restarts=5,\n", - " raw_samples=100,\n", - " # If can't provide grad information need to be able to manually set this\n", - " options={\"with_grad\": True}, # this is True by default\n", - " )\n", - "\n", - " # call the simulator to give us the new results\n", - " train_x_opt = torch.cat([train_x_opt, candidate])\n", - " train_y_opt = torch.cat([train_y_opt, underling_function(candidate)])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Repeat the same, but do not optimise the model hyperparams after the first fit\n", - "condition on new data but don't update hyperparams" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "fig, axes = plt.subplots(3, 1, figsize=(8, 12))\n", - "\n", - "bounds = torch.tensor([[0.0], [1.0]]) # 1D search space [lower_bound, upper_bound]\n", - "train_x_opt = torch.tensor([[0.1], [0.85]])\n", - "train_y_opt = underling_function(train_x_opt)\n", - "\n", - "\n", - "gp = SingleTaskGP(train_X=train_x_opt, train_Y=train_y_opt)\n", - "mll = gpytorch.mlls.ExactMarginalLogLikelihood(gp.likelihood, gp)\n", - "_ = fit_gpytorch_model(mll)\n", - "\n", - "for ax in axes:\n", - " # Plot it and the acquisition function\n", - " cust_ac = CustomAcq(gp, DIST)\n", - "\n", - " # estimate the best point in the objective function with the current model\n", - " gp_xmax_est = estimate_xmax_with_gp(gp)\n", - " test_str = f\"gp xmax est {gp_xmax_est:.2f}.\\nobjective_score {objective_func(gp_xmax_est):.2f}\"\n", - " ax.text(\n", - " 0.05,\n", - " 0.05,\n", - " test_str,\n", - " transform=ax.transAxes,\n", - " fontsize=12,\n", - " verticalalignment=\"bottom\",\n", - " bbox={\"boxstyle\": \"round,pad=0.3\", \"edgecolor\": \"black\", \"facecolor\": \"lightgray\"},\n", - " )\n", - "\n", - " _ = plot_gp_and_dist(gp, acquisiton_function=cust_ac, ax=ax)\n", - "\n", - " candidate, result = optimize_acqf(\n", - " cust_ac,\n", - " bounds=bounds,\n", - " q=1,\n", - " num_restarts=5,\n", - " raw_samples=100,\n", - " # If can't provide grad information need to be able to manually set this\n", - " options={\"with_grad\": True}, # This is true by default\n", - " )\n", - "\n", - " # Update the model\n", - " new_x_point = candidate.flatten()\n", - " new_y_point = underling_function(new_x_point)\n", - " gp = gp.get_fantasy_model(inputs=new_x_point, targets=new_y_point)\n", - "\n", - " # Justed used for plotting now\n", - " train_x_opt = torch.cat([train_x_opt, new_x_point.unsqueeze(0)])\n", - " train_y_opt = torch.cat([train_y_opt, new_y_point.unsqueeze(0)])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## AX\n", - "Put this into the ax framework and optimise it that way.\n", - "- Come from botorch custom acquisitions [here.](https://botorch.org/tutorials/custom_acquisition)\n", - "- and Ax example here [here](https://ax.dev/tutorials/modular_botax.html)\n", - "\n", - "There are likely otherways to acheive this with the ax interface" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Set up" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create the experiment" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# For our purposes, the metric is a wrapper that structures the function output.\n", - "class DummyMetric(Metric):\n", - " def fetch_trial_data(self, trial): # type: ignore # noqa: ANN001\n", - " records = []\n", - " for arm_name, arm in trial.arms_by_name.items():\n", - " params = arm.parameters\n", - " tensor_params = torch.tensor([params[\"x\"]])\n", - " records.append(\n", - " {\n", - " \"arm_name\": arm_name,\n", - " \"metric_name\": self.name,\n", - " \"trial_index\": trial.index,\n", - " \"mean\": underling_function(tensor_params),\n", - " \"sem\": float(\"nan\"), # SEM (observation noise) - NaN indicates unknown\n", - " }\n", - " )\n", - " # OK just wtapps saying it contains a sucessful value\n", - " return Ok(value=Data(df=pd.DataFrame.from_records(records)))\n", - "\n", - "\n", - "# Search space defines the parameters, their types, and acceptable values.\n", - "search_space = SearchSpace(\n", - " parameters=[\n", - " RangeParameter(name=\"x\", parameter_type=ParameterType.FLOAT, lower=0, upper=1),\n", - " ]\n", - ")\n", - "\n", - "\n", - "optimization_config = OptimizationConfig(\n", - " objective=Objective(\n", - " # NOTE: we don't care about lower_is_better because are not just trying to maximise or minimise this value\n", - " # This just needs to be the y value we want to fit our GP to\n", - " metric=DummyMetric(name=\"dummy_metric\", lower_is_better=True),\n", - " minimize=True, # This is optional since we specified `lower_is_better=True`\n", - " )\n", - ")\n", - "\n", - "\n", - "class MyRunner(Runner):\n", - " def run(self, trial): # type: ignore # noqa: ANN001\n", - " trial_metadata = {\"name\": str(trial.index)}\n", - " return trial_metadata\n", - "\n", - "\n", - "exp = Experiment(\n", - " name=\"Dummy_experiment\",\n", - " search_space=search_space,\n", - " optimization_config=optimization_config,\n", - " runner=MyRunner(),\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Register the input constructor" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Super hacky way of making sure the input constructure is not already in there,\n", - "# so we can make updates to this functions without having to restart the notebook\n", - "input_constructors.ACQF_INPUT_CONSTRUCTOR_REGISTRY.pop(CustomAcq, None)\n", - "\n", - "\n", - "@acqf_input_constructor(CustomAcq)\n", - "def construct_inputs_custom_acq(\n", - " model: Model,\n", - " dist: Distribution,\n", - " **kwargs: Any, # noqa: ANN401, ARG001\n", - ") -> dict[str, Any]:\n", - " return {\n", - " \"model\": model,\n", - " \"dist\": dist,\n", - " }" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Option 1: low level Ax\n", - "Note, with this hyperparams are refitted every round of DoE" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Manually add some data to the experiment" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "manual_exp_locations = [[0.1], [0.85]]\n", - "for x in manual_exp_locations:\n", - " # this is just a quick and diry unpacking for now, will need to extend to x in higher dims\n", - " trial_arm = exp.new_trial().add_arm(Arm(parameters={\"x\": x[0]}))\n", - " trial_arm.run()\n", - " trial_arm.mark_completed()\n", - "\n", - "# Check this has been properly attached\n", - "_ = display(exp.fetch_data().df)\n", - "exp.trials" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Each loop build a new GP from the available data, and use the custom acquisition function to select a new point" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "for _ in range(5):\n", - " model_bridge_cust_ac = Models.BOTORCH_MODULAR(\n", - " experiment=exp,\n", - " data=exp.fetch_data(),\n", - " # surrogate=Surrogate(FixedNoiseGP), # Optional, will use default if unspecified # noqa: ERA001\n", - " botorch_acqf_class=CustomAcq, # Optional, will use default if unspecified\n", - " acquisition_options={\"dist\": DIST},\n", - " )\n", - " trial = exp.new_trial(\n", - " generator_run=model_bridge_cust_ac.gen(\n", - " 1,\n", - " # This section is optional. with_grad default to True if not specified here\n", - " model_gen_options={\n", - " \"optimizer_kwargs\": {\n", - " \"options\": {\"with_grad\": True},\n", - " }\n", - " },\n", - " )\n", - " )\n", - " _ = trial.run()\n", - " _ = trial.mark_completed()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Show the resulting experiment object" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "exp.fetch_data().df" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "render(\n", - " plot_slice(\n", - " model=model_bridge_cust_ac,\n", - " param_name=\"x\",\n", - " metric_name=\"dummy_metric\",\n", - " )\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can see this produces the same points as the botorch model that is fully retrained at each step, as expected.\n", - "\n", - "- TODO(sw 2024-11-13): Build the equivalent plot to the botorch component using the Ax interface to the model." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Option 2: Higher level Ax: Generation Stratergy\n", - "Uses higher level ax services. Note, with this hyperparams are refitted every round of DoE" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Make the experiment fresh\n", - "exp = Experiment(\n", - " name=\"Dummy_experiment\",\n", - " search_space=search_space,\n", - " optimization_config=optimization_config,\n", - " runner=MyRunner(),\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "gs = GenerationStrategy(\n", - " steps=[\n", - " # Quasi-random initialization step\n", - " GenerationStep(\n", - " model=Models.SOBOL,\n", - " num_trials=2, # How many trials should be produced from this generation step\n", - " model_kwargs={\"seed\": 999}, # Any kwargs you want passed into the model\n", - " ),\n", - " # Bayesian optimization step using the custom acquisition function\n", - " GenerationStep(\n", - " model=Models.BOTORCH_MODULAR,\n", - " num_trials=-1, # No limitation on how many trials should be produced from this step\n", - " # For `BOTORCH_MODULAR`, we pass in kwargs to specify what surrogate or acquisition function to use.\n", - " # `acquisition_options` specifies the set of additional arguments to pass into the input constructor.\n", - " model_kwargs={\n", - " \"botorch_acqf_class\": CustomAcq,\n", - " \"acquisition_options\": {\"dist\": DIST},\n", - " },\n", - " ),\n", - " ]\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from ax.service.ax_client import AxClient\n", - "\n", - "# Initialize the client - AxClient offers a convenient API to control the experiment\n", - "ax_client = AxClient(generation_strategy=gs)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Not yet supported ax_client.load_experiment('Dummy_experiment')\n", - "\n", - "# Bit of a hacky way to attach it to the higher level thing\n", - "_ = ax_client._set_runner(experiment=exp) # noqa: SLF001\n", - "_ = ax_client._set_experiment( # noqa: SLF001\n", - " experiment=exp,\n", - " overwrite_existing_experiment=True,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# NOTE we have already defined the objective inside the experiement, annoying we need to define it again\n", - "def evaluate(parameters): # type: ignore # noqa: ANN001\n", - " # Note this is just because our objective function works with tensors\n", - " x = torch.tensor([parameters.get(\"x\")], dtype=torch.float64)\n", - " # In our case, standard error is 0, since we are computing a synthetic function.\n", - " return {\"dummy_metric\": (underling_function(x).item(), 0.0)}" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "for i in range(5):\n", - " print(f\"Running trial {i + 1}/30...\")\n", - " parameters, trial_index = ax_client.get_next_trial()\n", - " # Local evaluation here can be replaced with deployment to external system.\n", - " ax_client.complete_trial(trial_index=trial_index, raw_data=evaluate(parameters))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "render(\n", - " plot_slice(\n", - " model=ax_client.generation_strategy.model,\n", - " param_name=\"x\",\n", - " metric_name=\"dummy_metric\",\n", - " )\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Option 3: Alternate way of interacting with the model\n", - "- create a botorch model useing the interface `ax.models.torch.botorch` [here](https://ax.dev/api/models.html#module-ax.models.torch.botorch)\n", - "- also a relevant tutorial [here](https://botorch.org/tutorials/custom_botorch_model_in_ax)\n", - "\n", - "TODO: Explore this further" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -}