Current git-hash: e82f9eaa2bf28981bfedf32ca86bf6fb67634126 (last fully tested stable version 4 commits ago [ac6b16e91a732d78f06205417c10392572a05f84, 8987])
⠋Importing logging...⠋Importing warnings...⠋Importing argparse...⠋Importing datetime...⠋Importing dataclass...⠋Importing socket...⠋Importing stat...⠋Importing pwd...⠋Importing base64...⠋Importing json...⠋Importing yaml...⠋Importing toml...⠋Importing csv...⠋Importing ast...⠋Importing rich.table...⠋Importing rich print...⠋Importing rich.pretty...⠋Importing pformat...⠋Importing rich.prompt...⠋Importing types.FunctionType...⠋Importing typing...⠋Importing ThreadPoolExecutor...⠋Importing submitit.LocalExecutor...⠋Importing submitit.Job...⠋Importing importlib.util...⠋Importing platform...⠋Importing inspect frame info...⠋Importing pathlib.Path...⠋Importing uuid...⠋Importing cowsay...⠋Importing shutil...⠋Importing itertools.combinations...⠋Importing os.listdir...⠋Importing os.path...⠋Importing PIL.Image...⠋Importing sixel...⠋Importing subprocess...⠋Importing tqdm...⠋Importing beartype...⠋Importing statistics...⠋Trying to import pyfiglet...⠙Importing helpers...⠋Importing pareto...⠋Parsing arguments...⠼Importing torch...⠋Importing numpy...
[WARNING 11-01 12:39:12] ax.service.utils.with_db_settings_base: Ax currently requires a sqlalchemy version below 2.0. This will be addressed in a future release. Disabling SQL storage in Ax for now, if you would like to use SQL storage please install Ax with mysql extras via `pip install ax-platform[mysql]`.
⠇Importing ax...⠋Importing ax.core.generator_run...⠋Importing Cont_X_trans and Y_trans from ax.adapter.registry...⠋Importing ax.core.arm...⠋Importing ax.core.objective...⠋Importing ax.core.Metric...⠋Importing ax.exceptions.core...⠋Importing ax.exceptions.generation_strategy...⠋Importing CORE_DECODER_REGISTRY...⠋Trying ax.generation_strategy.generation_node...⠋Importing GenerationStep, GenerationStrategy from generation_strategy...⠋Importing GenerationNode from generation_node...⠋Importing ExternalGenerationNode...⠋Importing MaxTrials...⠋Importing GeneratorSpec...⠋Importing Models from ax.generation_strategy.registry...⠋Importing get_pending_observation_features...⠋Importing load_experiment...⠋Importing save_experiment...⠋Importing save_experiment_to_db...⠋Importing TrialStatus...⠋Importing Data...⠋Importing Experiment...⠋Importing parameter types...⠋Importing TParameterization...⠋Importing pandas...⠋Importing AxClient and ObjectiveProperties...⠋Importing RandomForestRegressor...⠋Importing botorch...⠋Importing submitit...⠋Importing ax logger...⠋Importing SQL-Storage-Stuff...
Run-UUID: 19220cca-eba6-4d90-a220-8447a29b9654
_________________________________________________
/ \
| OmniOpt2 - The Montana Sacra of optimization – on |
| ly the enlightened reach the peak. |
\ /
=================================================
\
\
\
\
/- _ `-/ '
(/\/ \ \ /\
/ / | ` \
O O ) / |
`-^--'`< '
(_.) _ ) /
`.___/` /
`-----' /
<----. __ / __ \
<----|====O)))==) \) /====
<----' `--' `.__,' \
| |
\ /
______( (_ / \______
,' ,-----' | \
`--{__________) \/
⠋Writing worker creation log...
./omniopt --live_share --send_anonymized_usage_stats --partition alpha --experiment_name=__main__tests__BOTORCH_MODULAR___nogridsearch --mem_gb=1 --time=60 --worker_timeout=5 --max_eval 2 --num_parallel_jobs 2 --gpus=0 --run_program Li8udGVzdHMvb3B0aW1pemF0aW9uX2V4YW1wbGUgIC0taW50X3BhcmFtPSclKGludF9wYXJhbSknIC0tZmxvYXRfcGFyYW09JyUoZmxvYXRfcGFyYW0pJyAtLWNob2ljZV9wYXJhbT0nJShjaG9pY2VfcGFyYW0pJyAtLWludF9wYXJhbV90d289JyUoaW50X3BhcmFtX3R3byknIC0tbnJfcmVzdWx0cz0x --parameter int_param range -100 10 int --parameter float_param range -100 10 float --parameter choice_param choice 1,2,4,8,16,hallo --parameter int_param_two range -100 10 int --num_random_steps 1 --model BOTORCH_MODULAR --auto_exclude_defective_hosts --generate_all_jobs_at_once --follow --show_generate_time_table
⠋Disabling logging...⠋Setting run folder...⠋Creating folder /home/norman/repos/OmniOpt/runs/__main__tests__BOTORCH_MODULAR___nogridsearch/12...⠋Writing revert_to_random_when_seemingly_exhausted file ...⠋Writing username state file...⠋Writing result names file...⠋Writing result min/max file...⠋Saving state files...Run-folder: /home/norman/repos/OmniOpt/runs/__main__tests__BOTORCH_MODULAR___nogridsearch/12⠋Writing live_share file if it is present...⠋Writing job_start_time file...⠋Writing git information⠋Checking max_eval...⠋Calculating number of steps...⠋Adding excluded nodes...⠋Initializing ax_client...⠋Setting orchestrator...See https://imageseg.scads.de/omniax/share?user_id=norman&experiment_name=__main__tests__BOTORCH_MODULAR___nogridsearch&run_nr=12 for live-results.You have 4 CPUs available for the main process.No CUDA devices found.Generation strategy: SOBOL for 1 step and then BOTORCH_MODULAR for 1 step.
Run-Program: ./.tests/optimization_example --int_param='%(int_param)' --float_param='%(float_param)' --choice_param='%(choice_param)' --int_param_two='%(int_param_two)' --nr_results=1
Experiment parameters
┏━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━━┓
┃Name ┃Type ┃Lower bound┃Upper bound┃Values ┃Type ┃Log Scale?┃
┡━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━━┩
│int_param │range │-100 │10 ││int │No │
│float_param │range │-100 │10 ││float│No │
│choice_param │choice│││1, 2, 4, 8, 16, hallo│││
│int_param_two│range │-100 │10 ││int │No │
└───────────────┴────────┴─────────────┴─────────────┴───────────────────────┴───────┴────────────┘
Result-Names
┏━━━━━━━━━━━━━┳━━━━━━━━━━━━━┓
┃Result-Name┃Min or max?┃
┡━━━━━━━━━━━━━╇━━━━━━━━━━━━━┩
│RESULT │ min│
└─────────────┴─────────────┘
⠋Write files and show overview
0%|░░░░░░░░░░| 0/2 [00:00 'None'
|
| GenerationStrategy describes which node should be used to generate new
| points for which trials, enabling and automating use of different nodes
| throughout the optimization process. For instance, it allows to use one
| node for the initialization trials, and another one for all subsequent
| trials. In the general case, this allows to automate use of an arbitrary
| number of nodes to generate an arbitrary numbers of trials.
|
| Args:
| nodes: A list of `GenerationNode`. Each `GenerationNode` in the list
| represents a single node in a `GenerationStrategy` which, when
| composed of `GenerationNodes`, can be conceptualized as a graph instead
| of a linear list. `TransitionCriterion` defined in each `GenerationNode`
| represent the edges in the `GenerationStrategy` graph. `GenerationNodes`
| are more flexible than `GenerationSteps` and new `GenerationStrategies`
| should use nodes. Notably, either, but not both, of `nodes` and `steps`
| must be provided.
| steps: A list of `GenerationStep` describing steps of this strategy.
| name: An optional name for this generation strategy. If not specified,
| strategy's name will be names of its nodes' generators joined with '+'.
|
| Method resolution order:
| GenerationStrategy
| ax.utils.common.base.Base
| builtins.object
|
| Methods defined here:
|
| __init__(self, steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| String representation of this generation strategy.
|
| clone_reset(self) -> 'GenerationStrategy'
| Copy this generation strategy without it's state.
|
| current_generator_run_limit(self) -> 'tuple[int, bool]'
| First check if we can move the generation strategy to the next node, which
| is safe, as the next call to ``gen`` will just pick up from there. Then
| determine how many generator runs this generation strategy can generate right
| now, assuming each one of them becomes its own trial, and whether optimization
| is completed.
|
| Returns: a two-item tuple of:
| - the number of generator runs that can currently be produced, with -1
| meaning unlimited generator runs,
| - whether optimization is completed and the generation strategy cannot
| generate any more generator runs at all.
|
| gen(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int | None' = None, fixed_features: 'ObservationFeatures | None' = None, num_trials: 'int' = 1, arms_per_node: 'dict[str, int] | None' = None) -> 'list[list[GeneratorRun]]'
| Produce GeneratorRuns for multiple trials at once with the possibility of
| using multiple models per trial, getting multiple GeneratorRuns per trial.
|
| Args:
| experiment: ``Experiment``, for which the generation strategy is producing
| a new generator run in the course of ``gen``, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's ``gen``, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the ``experiment``.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
| n: Integer representing how many total arms should be in the generator
| runs produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output generator runs with number of
| arms that can differ from `n`.
| fixed_features: An optional set of ``ObservationFeatures`` that will be
| passed down to the underlying nodes. Note: if provided this will
| override any algorithmically determined fixed features so it is
| important to specify all necessary fixed features.
| num_trials: Number of trials to generate generator runs for in this call.
| If not provided, defaults to 1.
| arms_per_node: An optional map from node name to the number of arms to
| generate from that node. If not provided, will default to the number
| of arms specified in the node's ``InputConstructors`` or n if no
| ``InputConstructors`` are defined on the node. We expect either n or
| arms_per_node to be provided, but not both, and this is an advanced
| argument that should only be used by advanced users.
|
| Returns:
| A list of lists of lists generator runs. Each outer list represents
| a trial being suggested and each inner list represents a generator
| run for that trial.
|
| gen_single_trial(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int' = 1, fixed_features: 'ObservationFeatures | None' = None) -> 'GeneratorRun'
| Produce the next points in the experiment. Additional kwargs passed to
| this method are propagated directly to the underlying node's `gen`, along
| with the `model_gen_kwargs` set on the current generation node.
|
| NOTE: Each generator run returned from this function must become a single
| trial on the experiment to comply with assumptions made in generation
| strategy. Do not split one generator run produced from generation strategy
| into multiple trials (never making a generator run into a trial is allowed).
|
| Args:
| experiment: Experiment, for which the generation strategy is producing
| a new generator run in the course of `gen`, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's `gen`, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the `experiment`.
| n: Integer representing how many arms should be in the generator run
| produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output a generator run with number of
| arms that can differ from `n`.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| adapter
| The adapter from the current node of this strategy. Returns None
| if no adapter has been set yet. This can happen if no generator runs have
| been produced from this GS or if the current node does not utilize
| adapters (the case for ``ExternalGenerationNode``).
|
| current_node
| Current generation node.
|
| current_node_name
| Current generation node name.
|
| current_step
| Current generation step.
|
| current_step_index
| Returns the index of the current generation step. This attribute
| is replaced by node_name in newer GenerationStrategies but surfaced here
| for backward compatibility.
|
| is_node_based
| Whether this strategy consists of GenerationNodes only.
| This is useful for determining initialization properties and
| other logic.
|
| last_generator_run
| Latest generator run produced by this generation strategy.
| Returns None if no generator runs have been produced yet.
|
| name
| Name of this generation strategy.
|
| nodes_dict
| Returns a dictionary mapping node names to nodes.
|
| optimization_complete
| Checks whether all nodes are completed in the generation strategy.
|
| trials_as_df
| Puts information on individual trials into a data frame for easy
| viewing.
|
| THIS METHOD IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE.
| Please use `Experiment.to_df()` instead.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| experiment
| Experiment, currently set on this generation strategy.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| DEFAULT_N = 1
|
| __annotations__ = {'DEFAULT_N': 'int', '_curr': 'GenerationNode', '_ex...
|
| ----------------------------------------------------------------------
| Methods inherited from ax.utils.common.base.Base:
|
| __eq__ = _type_safe_equals(self, other)
| # no type annotation for now; breaks sphinx-autodoc-typehints
| # pyre-fixme[3]: Return type must be annotated.
| # pyre-fixme[2]: Parameter must be annotated.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ax.utils.common.base.Base:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| db_id
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from ax.utils.common.base.Base:
|
| __hash__ = None
!!!!! gs: SOBOL !!!!
SOBOL, Started OmniOpt2 run...: 0%|░░░░░░░░░░| 0/2 [00:00 'None'
|
| GenerationStrategy describes which node should be used to generate new
| points for which trials, enabling and automating use of different nodes
| throughout the optimization process. For instance, it allows to use one
| node for the initialization trials, and another one for all subsequent
| trials. In the general case, this allows to automate use of an arbitrary
| number of nodes to generate an arbitrary numbers of trials.
|
| Args:
| nodes: A list of `GenerationNode`. Each `GenerationNode` in the list
| represents a single node in a `GenerationStrategy` which, when
| composed of `GenerationNodes`, can be conceptualized as a graph instead
| of a linear list. `TransitionCriterion` defined in each `GenerationNode`
| represent the edges in the `GenerationStrategy` graph. `GenerationNodes`
| are more flexible than `GenerationSteps` and new `GenerationStrategies`
| should use nodes. Notably, either, but not both, of `nodes` and `steps`
| must be provided.
| steps: A list of `GenerationStep` describing steps of this strategy.
| name: An optional name for this generation strategy. If not specified,
| strategy's name will be names of its nodes' generators joined with '+'.
|
| Method resolution order:
| GenerationStrategy
| ax.utils.common.base.Base
| builtins.object
|
| Methods defined here:
|
| __init__(self, steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| String representation of this generation strategy.
|
| clone_reset(self) -> 'GenerationStrategy'
| Copy this generation strategy without it's state.
|
| current_generator_run_limit(self) -> 'tuple[int, bool]'
| First check if we can move the generation strategy to the next node, which
| is safe, as the next call to ``gen`` will just pick up from there. Then
| determine how many generator runs this generation strategy can generate right
| now, assuming each one of them becomes its own trial, and whether optimization
| is completed.
|
| Returns: a two-item tuple of:
| - the number of generator runs that can currently be produced, with -1
| meaning unlimited generator runs,
| - whether optimization is completed and the generation strategy cannot
| generate any more generator runs at all.
|
| gen(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int | None' = None, fixed_features: 'ObservationFeatures | None' = None, num_trials: 'int' = 1, arms_per_node: 'dict[str, int] | None' = None) -> 'list[list[GeneratorRun]]'
| Produce GeneratorRuns for multiple trials at once with the possibility of
| using multiple models per trial, getting multiple GeneratorRuns per trial.
|
| Args:
| experiment: ``Experiment``, for which the generation strategy is producing
| a new generator run in the course of ``gen``, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's ``gen``, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the ``experiment``.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
| n: Integer representing how many total arms should be in the generator
| runs produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output generator runs with number of
| arms that can differ from `n`.
| fixed_features: An optional set of ``ObservationFeatures`` that will be
| passed down to the underlying nodes. Note: if provided this will
| override any algorithmically determined fixed features so it is
| important to specify all necessary fixed features.
| num_trials: Number of trials to generate generator runs for in this call.
| If not provided, defaults to 1.
| arms_per_node: An optional map from node name to the number of arms to
| generate from that node. If not provided, will default to the number
| of arms specified in the node's ``InputConstructors`` or n if no
| ``InputConstructors`` are defined on the node. We expect either n or
| arms_per_node to be provided, but not both, and this is an advanced
| argument that should only be used by advanced users.
|
| Returns:
| A list of lists of lists generator runs. Each outer list represents
| a trial being suggested and each inner list represents a generator
| run for that trial.
|
| gen_single_trial(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int' = 1, fixed_features: 'ObservationFeatures | None' = None) -> 'GeneratorRun'
| Produce the next points in the experiment. Additional kwargs passed to
| this method are propagated directly to the underlying node's `gen`, along
| with the `model_gen_kwargs` set on the current generation node.
|
| NOTE: Each generator run returned from this function must become a single
| trial on the experiment to comply with assumptions made in generation
| strategy. Do not split one generator run produced from generation strategy
| into multiple trials (never making a generator run into a trial is allowed).
|
| Args:
| experiment: Experiment, for which the generation strategy is producing
| a new generator run in the course of `gen`, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's `gen`, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the `experiment`.
| n: Integer representing how many arms should be in the generator run
| produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output a generator run with number of
| arms that can differ from `n`.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| adapter
| The adapter from the current node of this strategy. Returns None
| if no adapter has been set yet. This can happen if no generator runs have
| been produced from this GS or if the current node does not utilize
| adapters (the case for ``ExternalGenerationNode``).
|
| current_node
| Current generation node.
|
| current_node_name
| Current generation node name.
|
| current_step
| Current generation step.
|
| current_step_index
| Returns the index of the current generation step. This attribute
| is replaced by node_name in newer GenerationStrategies but surfaced here
| for backward compatibility.
|
| is_node_based
| Whether this strategy consists of GenerationNodes only.
| This is useful for determining initialization properties and
| other logic.
|
| last_generator_run
| Latest generator run produced by this generation strategy.
| Returns None if no generator runs have been produced yet.
|
| name
| Name of this generation strategy.
|
| nodes_dict
| Returns a dictionary mapping node names to nodes.
|
| optimization_complete
| Checks whether all nodes are completed in the generation strategy.
|
| trials_as_df
| Puts information on individual trials into a data frame for easy
| viewing.
|
| THIS METHOD IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE.
| Please use `Experiment.to_df()` instead.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| experiment
| Experiment, currently set on this generation strategy.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| DEFAULT_N = 1
|
| __annotations__ = {'DEFAULT_N': 'int', '_curr': 'GenerationNode', '_ex...
|
| ----------------------------------------------------------------------
| Methods inherited from ax.utils.common.base.Base:
|
| __eq__ = _type_safe_equals(self, other)
| # no type annotation for now; breaks sphinx-autodoc-typehints
| # pyre-fixme[3]: Return type must be annotated.
| # pyre-fixme[2]: Parameter must be annotated.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ax.utils.common.base.Base:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| db_id
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from ax.utils.common.base.Base:
|
| __hash__ = None
!!!!! gs: SOBOL !!!!
Help on GenerationStrategy in module ax.generation_strategy.generation_strategy object:
class GenerationStrategy(ax.utils.common.base.Base)
| GenerationStrategy(steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
|
| GenerationStrategy describes which node should be used to generate new
| points for which trials, enabling and automating use of different nodes
| throughout the optimization process. For instance, it allows to use one
| node for the initialization trials, and another one for all subsequent
| trials. In the general case, this allows to automate use of an arbitrary
| number of nodes to generate an arbitrary numbers of trials.
|
| Args:
| nodes: A list of `GenerationNode`. Each `GenerationNode` in the list
| represents a single node in a `GenerationStrategy` which, when
| composed of `GenerationNodes`, can be conceptualized as a graph instead
| of a linear list. `TransitionCriterion` defined in each `GenerationNode`
| represent the edges in the `GenerationStrategy` graph. `GenerationNodes`
| are more flexible than `GenerationSteps` and new `GenerationStrategies`
| should use nodes. Notably, either, but not both, of `nodes` and `steps`
| must be provided.
| steps: A list of `GenerationStep` describing steps of this strategy.
| name: An optional name for this generation strategy. If not specified,
| strategy's name will be names of its nodes' generators joined with '+'.
|
| Method resolution order:
| GenerationStrategy
| ax.utils.common.base.Base
| builtins.object
|
| Methods defined here:
|
| __init__(self, steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| String representation of this generation strategy.
|
| clone_reset(self) -> 'GenerationStrategy'
| Copy this generation strategy without it's state.
|
| current_generator_run_limit(self) -> 'tuple[int, bool]'
| First check if we can move the generation strategy to the next node, which
| is safe, as the next call to ``gen`` will just pick up from there. Then
| determine how many generator runs this generation strategy can generate right
| now, assuming each one of them becomes its own trial, and whether optimization
| is completed.
|
| Returns: a two-item tuple of:
| - the number of generator runs that can currently be produced, with -1
| meaning unlimited generator runs,
| - whether optimization is completed and the generation strategy cannot
| generate any more generator runs at all.
|
| gen(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int | None' = None, fixed_features: 'ObservationFeatures | None' = None, num_trials: 'int' = 1, arms_per_node: 'dict[str, int] | None' = None) -> 'list[list[GeneratorRun]]'
| Produce GeneratorRuns for multiple trials at once with the possibility of
| using multiple models per trial, getting multiple GeneratorRuns per trial.
|
| Args:
| experiment: ``Experiment``, for which the generation strategy is producing
| a new generator run in the course of ``gen``, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's ``gen``, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the ``experiment``.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
| n: Integer representing how many total arms should be in the generator
| runs produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output generator runs with number of
| arms that can differ from `n`.
| fixed_features: An optional set of ``ObservationFeatures`` that will be
| passed down to the underlying nodes. Note: if provided this will
| override any algorithmically determined fixed features so it is
| important to specify all necessary fixed features.
| num_trials: Number of trials to generate generator runs for in this call.
| If not provided, defaults to 1.
| arms_per_node: An optional map from node name to the number of arms to
| generate from that node. If not provided, will default to the number
| of arms specified in the node's ``InputConstructors`` or n if no
| ``InputConstructors`` are defined on the node. We expect either n or
| arms_per_node to be provided, but not both, and this is an advanced
| argument that should only be used by advanced users.
|
| Returns:
| A list of lists of lists generator runs. Each outer list represents
| a trial being suggested and each inner list represents a generator
| run for that trial.
|
| gen_single_trial(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int' = 1, fixed_features: 'ObservationFeatures | None' = None) -> 'GeneratorRun'
| Produce the next points in the experiment. Additional kwargs passed to
| this method are propagated directly to the underlying node's `gen`, along
| with the `model_gen_kwargs` set on the current generation node.
|
| NOTE: Each generator run returned from this function must become a single
| trial on the experiment to comply with assumptions made in generation
| strategy. Do not split one generator run produced from generation strategy
| into multiple trials (never making a generator run into a trial is allowed).
|
| Args:
| experiment: Experiment, for which the generation strategy is producing
| a new generator run in the course of `gen`, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's `gen`, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the `experiment`.
| n: Integer representing how many arms should be in the generator run
| produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output a generator run with number of
| arms that can differ from `n`.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| adapter
| The adapter from the current node of this strategy. Returns None
| if no adapter has been set yet. This can happen if no generator runs have
| been produced from this GS or if the current node does not utilize
| adapters (the case for ``ExternalGenerationNode``).
|
| current_node
| Current generation node.
|
| current_node_name
| Current generation node name.
|
| current_step
| Current generation step.
|
| current_step_index
| Returns the index of the current generation step. This attribute
| is replaced by node_name in newer GenerationStrategies but surfaced here
| for backward compatibility.
|
| is_node_based
| Whether this strategy consists of GenerationNodes only.
| This is useful for determining initialization properties and
| other logic.
|
| last_generator_run
| Latest generator run produced by this generation strategy.
| Returns None if no generator runs have been produced yet.
|
| name
| Name of this generation strategy.
|
| nodes_dict
| Returns a dictionary mapping node names to nodes.
|
| optimization_complete
| Checks whether all nodes are completed in the generation strategy.
|
| trials_as_df
| Puts information on individual trials into a data frame for easy
| viewing.
|
| THIS METHOD IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE.
| Please use `Experiment.to_df()` instead.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| experiment
| Experiment, currently set on this generation strategy.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| DEFAULT_N = 1
|
| __annotations__ = {'DEFAULT_N': 'int', '_curr': 'GenerationNode', '_ex...
|
| ----------------------------------------------------------------------
| Methods inherited from ax.utils.common.base.Base:
|
| __eq__ = _type_safe_equals(self, other)
| # no type annotation for now; breaks sphinx-autodoc-typehints
| # pyre-fixme[3]: Return type must be annotated.
| # pyre-fixme[2]: Parameter must be annotated.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ax.utils.common.base.Base:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| db_id
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from ax.utils.common.base.Base:
|
| __hash__ = None
!!!!! gs: SOBOL !!!!
Help on GenerationStrategy in module ax.generation_strategy.generation_strategy object:
class GenerationStrategy(ax.utils.common.base.Base)
| GenerationStrategy(steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
|
| GenerationStrategy describes which node should be used to generate new
| points for which trials, enabling and automating use of different nodes
| throughout the optimization process. For instance, it allows to use one
| node for the initialization trials, and another one for all subsequent
| trials. In the general case, this allows to automate use of an arbitrary
| number of nodes to generate an arbitrary numbers of trials.
|
| Args:
| nodes: A list of `GenerationNode`. Each `GenerationNode` in the list
| represents a single node in a `GenerationStrategy` which, when
| composed of `GenerationNodes`, can be conceptualized as a graph instead
| of a linear list. `TransitionCriterion` defined in each `GenerationNode`
| represent the edges in the `GenerationStrategy` graph. `GenerationNodes`
| are more flexible than `GenerationSteps` and new `GenerationStrategies`
| should use nodes. Notably, either, but not both, of `nodes` and `steps`
| must be provided.
| steps: A list of `GenerationStep` describing steps of this strategy.
| name: An optional name for this generation strategy. If not specified,
| strategy's name will be names of its nodes' generators joined with '+'.
|
| Method resolution order:
| GenerationStrategy
| ax.utils.common.base.Base
| builtins.object
|
| Methods defined here:
|
| __init__(self, steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| String representation of this generation strategy.
|
| clone_reset(self) -> 'GenerationStrategy'
| Copy this generation strategy without it's state.
|
| current_generator_run_limit(self) -> 'tuple[int, bool]'
| First check if we can move the generation strategy to the next node, which
| is safe, as the next call to ``gen`` will just pick up from there. Then
| determine how many generator runs this generation strategy can generate right
| now, assuming each one of them becomes its own trial, and whether optimization
| is completed.
|
| Returns: a two-item tuple of:
| - the number of generator runs that can currently be produced, with -1
| meaning unlimited generator runs,
| - whether optimization is completed and the generation strategy cannot
| generate any more generator runs at all.
|
| gen(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int | None' = None, fixed_features: 'ObservationFeatures | None' = None, num_trials: 'int' = 1, arms_per_node: 'dict[str, int] | None' = None) -> 'list[list[GeneratorRun]]'
| Produce GeneratorRuns for multiple trials at once with the possibility of
| using multiple models per trial, getting multiple GeneratorRuns per trial.
|
| Args:
| experiment: ``Experiment``, for which the generation strategy is producing
| a new generator run in the course of ``gen``, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's ``gen``, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the ``experiment``.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
| n: Integer representing how many total arms should be in the generator
| runs produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output generator runs with number of
| arms that can differ from `n`.
| fixed_features: An optional set of ``ObservationFeatures`` that will be
| passed down to the underlying nodes. Note: if provided this will
| override any algorithmically determined fixed features so it is
| important to specify all necessary fixed features.
| num_trials: Number of trials to generate generator runs for in this call.
| If not provided, defaults to 1.
| arms_per_node: An optional map from node name to the number of arms to
| generate from that node. If not provided, will default to the number
| of arms specified in the node's ``InputConstructors`` or n if no
| ``InputConstructors`` are defined on the node. We expect either n or
| arms_per_node to be provided, but not both, and this is an advanced
| argument that should only be used by advanced users.
|
| Returns:
| A list of lists of lists generator runs. Each outer list represents
| a trial being suggested and each inner list represents a generator
| run for that trial.
|
| gen_single_trial(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int' = 1, fixed_features: 'ObservationFeatures | None' = None) -> 'GeneratorRun'
| Produce the next points in the experiment. Additional kwargs passed to
| this method are propagated directly to the underlying node's `gen`, along
| with the `model_gen_kwargs` set on the current generation node.
|
| NOTE: Each generator run returned from this function must become a single
| trial on the experiment to comply with assumptions made in generation
| strategy. Do not split one generator run produced from generation strategy
| into multiple trials (never making a generator run into a trial is allowed).
|
| Args:
| experiment: Experiment, for which the generation strategy is producing
| a new generator run in the course of `gen`, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's `gen`, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the `experiment`.
| n: Integer representing how many arms should be in the generator run
| produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output a generator run with number of
| arms that can differ from `n`.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| adapter
| The adapter from the current node of this strategy. Returns None
| if no adapter has been set yet. This can happen if no generator runs have
| been produced from this GS or if the current node does not utilize
| adapters (the case for ``ExternalGenerationNode``).
|
| current_node
| Current generation node.
|
| current_node_name
| Current generation node name.
|
| current_step
| Current generation step.
|
| current_step_index
| Returns the index of the current generation step. This attribute
| is replaced by node_name in newer GenerationStrategies but surfaced here
| for backward compatibility.
|
| is_node_based
| Whether this strategy consists of GenerationNodes only.
| This is useful for determining initialization properties and
| other logic.
|
| last_generator_run
| Latest generator run produced by this generation strategy.
| Returns None if no generator runs have been produced yet.
|
| name
| Name of this generation strategy.
|
| nodes_dict
| Returns a dictionary mapping node names to nodes.
|
| optimization_complete
| Checks whether all nodes are completed in the generation strategy.
|
| trials_as_df
| Puts information on individual trials into a data frame for easy
| viewing.
|
| THIS METHOD IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE.
| Please use `Experiment.to_df()` instead.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| experiment
| Experiment, currently set on this generation strategy.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| DEFAULT_N = 1
|
| __annotations__ = {'DEFAULT_N': 'int', '_curr': 'GenerationNode', '_ex...
|
| ----------------------------------------------------------------------
| Methods inherited from ax.utils.common.base.Base:
|
| __eq__ = _type_safe_equals(self, other)
| # no type annotation for now; breaks sphinx-autodoc-typehints
| # pyre-fixme[3]: Return type must be annotated.
| # pyre-fixme[2]: Parameter must be annotated.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ax.utils.common.base.Base:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| db_id
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from ax.utils.common.base.Base:
|
| __hash__ = None
!!!!! gs: SOBOL !!!!
Help on GenerationStrategy in module ax.generation_strategy.generation_strategy object:
class GenerationStrategy(ax.utils.common.base.Base)
| GenerationStrategy(steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
|
| GenerationStrategy describes which node should be used to generate new
| points for which trials, enabling and automating use of different nodes
| throughout the optimization process. For instance, it allows to use one
| node for the initialization trials, and another one for all subsequent
| trials. In the general case, this allows to automate use of an arbitrary
| number of nodes to generate an arbitrary numbers of trials.
|
| Args:
| nodes: A list of `GenerationNode`. Each `GenerationNode` in the list
| represents a single node in a `GenerationStrategy` which, when
| composed of `GenerationNodes`, can be conceptualized as a graph instead
| of a linear list. `TransitionCriterion` defined in each `GenerationNode`
| represent the edges in the `GenerationStrategy` graph. `GenerationNodes`
| are more flexible than `GenerationSteps` and new `GenerationStrategies`
| should use nodes. Notably, either, but not both, of `nodes` and `steps`
| must be provided.
| steps: A list of `GenerationStep` describing steps of this strategy.
| name: An optional name for this generation strategy. If not specified,
| strategy's name will be names of its nodes' generators joined with '+'.
|
| Method resolution order:
| GenerationStrategy
| ax.utils.common.base.Base
| builtins.object
|
| Methods defined here:
|
| __init__(self, steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| String representation of this generation strategy.
|
| clone_reset(self) -> 'GenerationStrategy'
| Copy this generation strategy without it's state.
|
| current_generator_run_limit(self) -> 'tuple[int, bool]'
| First check if we can move the generation strategy to the next node, which
| is safe, as the next call to ``gen`` will just pick up from there. Then
| determine how many generator runs this generation strategy can generate right
| now, assuming each one of them becomes its own trial, and whether optimization
| is completed.
|
| Returns: a two-item tuple of:
| - the number of generator runs that can currently be produced, with -1
| meaning unlimited generator runs,
| - whether optimization is completed and the generation strategy cannot
| generate any more generator runs at all.
|
| gen(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int | None' = None, fixed_features: 'ObservationFeatures | None' = None, num_trials: 'int' = 1, arms_per_node: 'dict[str, int] | None' = None) -> 'list[list[GeneratorRun]]'
| Produce GeneratorRuns for multiple trials at once with the possibility of
| using multiple models per trial, getting multiple GeneratorRuns per trial.
|
| Args:
| experiment: ``Experiment``, for which the generation strategy is producing
| a new generator run in the course of ``gen``, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's ``gen``, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the ``experiment``.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
| n: Integer representing how many total arms should be in the generator
| runs produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output generator runs with number of
| arms that can differ from `n`.
| fixed_features: An optional set of ``ObservationFeatures`` that will be
| passed down to the underlying nodes. Note: if provided this will
| override any algorithmically determined fixed features so it is
| important to specify all necessary fixed features.
| num_trials: Number of trials to generate generator runs for in this call.
| If not provided, defaults to 1.
| arms_per_node: An optional map from node name to the number of arms to
| generate from that node. If not provided, will default to the number
| of arms specified in the node's ``InputConstructors`` or n if no
| ``InputConstructors`` are defined on the node. We expect either n or
| arms_per_node to be provided, but not both, and this is an advanced
| argument that should only be used by advanced users.
|
| Returns:
| A list of lists of lists generator runs. Each outer list represents
| a trial being suggested and each inner list represents a generator
| run for that trial.
|
| gen_single_trial(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int' = 1, fixed_features: 'ObservationFeatures | None' = None) -> 'GeneratorRun'
| Produce the next points in the experiment. Additional kwargs passed to
| this method are propagated directly to the underlying node's `gen`, along
| with the `model_gen_kwargs` set on the current generation node.
|
| NOTE: Each generator run returned from this function must become a single
| trial on the experiment to comply with assumptions made in generation
| strategy. Do not split one generator run produced from generation strategy
| into multiple trials (never making a generator run into a trial is allowed).
|
| Args:
| experiment: Experiment, for which the generation strategy is producing
| a new generator run in the course of `gen`, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's `gen`, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the `experiment`.
| n: Integer representing how many arms should be in the generator run
| produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output a generator run with number of
| arms that can differ from `n`.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| adapter
| The adapter from the current node of this strategy. Returns None
| if no adapter has been set yet. This can happen if no generator runs have
| been produced from this GS or if the current node does not utilize
| adapters (the case for ``ExternalGenerationNode``).
|
| current_node
| Current generation node.
|
| current_node_name
| Current generation node name.
|
| current_step
| Current generation step.
|
| current_step_index
| Returns the index of the current generation step. This attribute
| is replaced by node_name in newer GenerationStrategies but surfaced here
| for backward compatibility.
|
| is_node_based
| Whether this strategy consists of GenerationNodes only.
| This is useful for determining initialization properties and
| other logic.
|
| last_generator_run
| Latest generator run produced by this generation strategy.
| Returns None if no generator runs have been produced yet.
|
| name
| Name of this generation strategy.
|
| nodes_dict
| Returns a dictionary mapping node names to nodes.
|
| optimization_complete
| Checks whether all nodes are completed in the generation strategy.
|
| trials_as_df
| Puts information on individual trials into a data frame for easy
| viewing.
|
| THIS METHOD IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE.
| Please use `Experiment.to_df()` instead.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| experiment
| Experiment, currently set on this generation strategy.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| DEFAULT_N = 1
|
| __annotations__ = {'DEFAULT_N': 'int', '_curr': 'GenerationNode', '_ex...
|
| ----------------------------------------------------------------------
| Methods inherited from ax.utils.common.base.Base:
|
| __eq__ = _type_safe_equals(self, other)
| # no type annotation for now; breaks sphinx-autodoc-typehints
| # pyre-fixme[3]: Return type must be annotated.
| # pyre-fixme[2]: Parameter must be annotated.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ax.utils.common.base.Base:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| db_id
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from ax.utils.common.base.Base:
|
| __hash__ = None
!!!!! gs: SOBOL !!!!
Help on GenerationStrategy in module ax.generation_strategy.generation_strategy object:
class GenerationStrategy(ax.utils.common.base.Base)
| GenerationStrategy(steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
|
| GenerationStrategy describes which node should be used to generate new
| points for which trials, enabling and automating use of different nodes
| throughout the optimization process. For instance, it allows to use one
| node for the initialization trials, and another one for all subsequent
| trials. In the general case, this allows to automate use of an arbitrary
| number of nodes to generate an arbitrary numbers of trials.
|
| Args:
| nodes: A list of `GenerationNode`. Each `GenerationNode` in the list
| represents a single node in a `GenerationStrategy` which, when
| composed of `GenerationNodes`, can be conceptualized as a graph instead
| of a linear list. `TransitionCriterion` defined in each `GenerationNode`
| represent the edges in the `GenerationStrategy` graph. `GenerationNodes`
| are more flexible than `GenerationSteps` and new `GenerationStrategies`
| should use nodes. Notably, either, but not both, of `nodes` and `steps`
| must be provided.
| steps: A list of `GenerationStep` describing steps of this strategy.
| name: An optional name for this generation strategy. If not specified,
| strategy's name will be names of its nodes' generators joined with '+'.
|
| Method resolution order:
| GenerationStrategy
| ax.utils.common.base.Base
| builtins.object
|
| Methods defined here:
|
| __init__(self, steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| String representation of this generation strategy.
|
| clone_reset(self) -> 'GenerationStrategy'
| Copy this generation strategy without it's state.
|
| current_generator_run_limit(self) -> 'tuple[int, bool]'
| First check if we can move the generation strategy to the next node, which
| is safe, as the next call to ``gen`` will just pick up from there. Then
| determine how many generator runs this generation strategy can generate right
| now, assuming each one of them becomes its own trial, and whether optimization
| is completed.
|
| Returns: a two-item tuple of:
| - the number of generator runs that can currently be produced, with -1
| meaning unlimited generator runs,
| - whether optimization is completed and the generation strategy cannot
| generate any more generator runs at all.
|
| gen(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int | None' = None, fixed_features: 'ObservationFeatures | None' = None, num_trials: 'int' = 1, arms_per_node: 'dict[str, int] | None' = None) -> 'list[list[GeneratorRun]]'
| Produce GeneratorRuns for multiple trials at once with the possibility of
| using multiple models per trial, getting multiple GeneratorRuns per trial.
|
| Args:
| experiment: ``Experiment``, for which the generation strategy is producing
| a new generator run in the course of ``gen``, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's ``gen``, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the ``experiment``.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
| n: Integer representing how many total arms should be in the generator
| runs produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output generator runs with number of
| arms that can differ from `n`.
| fixed_features: An optional set of ``ObservationFeatures`` that will be
| passed down to the underlying nodes. Note: if provided this will
| override any algorithmically determined fixed features so it is
| important to specify all necessary fixed features.
| num_trials: Number of trials to generate generator runs for in this call.
| If not provided, defaults to 1.
| arms_per_node: An optional map from node name to the number of arms to
| generate from that node. If not provided, will default to the number
| of arms specified in the node's ``InputConstructors`` or n if no
| ``InputConstructors`` are defined on the node. We expect either n or
| arms_per_node to be provided, but not both, and this is an advanced
| argument that should only be used by advanced users.
|
| Returns:
| A list of lists of lists generator runs. Each outer list represents
| a trial being suggested and each inner list represents a generator
| run for that trial.
|
| gen_single_trial(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int' = 1, fixed_features: 'ObservationFeatures | None' = None) -> 'GeneratorRun'
| Produce the next points in the experiment. Additional kwargs passed to
| this method are propagated directly to the underlying node's `gen`, along
| with the `model_gen_kwargs` set on the current generation node.
|
| NOTE: Each generator run returned from this function must become a single
| trial on the experiment to comply with assumptions made in generation
| strategy. Do not split one generator run produced from generation strategy
| into multiple trials (never making a generator run into a trial is allowed).
|
| Args:
| experiment: Experiment, for which the generation strategy is producing
| a new generator run in the course of `gen`, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's `gen`, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the `experiment`.
| n: Integer representing how many arms should be in the generator run
| produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output a generator run with number of
| arms that can differ from `n`.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| adapter
| The adapter from the current node of this strategy. Returns None
| if no adapter has been set yet. This can happen if no generator runs have
| been produced from this GS or if the current node does not utilize
| adapters (the case for ``ExternalGenerationNode``).
|
| current_node
| Current generation node.
|
| current_node_name
| Current generation node name.
|
| current_step
| Current generation step.
|
| current_step_index
| Returns the index of the current generation step. This attribute
| is replaced by node_name in newer GenerationStrategies but surfaced here
| for backward compatibility.
|
| is_node_based
| Whether this strategy consists of GenerationNodes only.
| This is useful for determining initialization properties and
| other logic.
|
| last_generator_run
| Latest generator run produced by this generation strategy.
| Returns None if no generator runs have been produced yet.
|
| name
| Name of this generation strategy.
|
| nodes_dict
| Returns a dictionary mapping node names to nodes.
|
| optimization_complete
| Checks whether all nodes are completed in the generation strategy.
|
| trials_as_df
| Puts information on individual trials into a data frame for easy
| viewing.
|
| THIS METHOD IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE.
| Please use `Experiment.to_df()` instead.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| experiment
| Experiment, currently set on this generation strategy.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| DEFAULT_N = 1
|
| __annotations__ = {'DEFAULT_N': 'int', '_curr': 'GenerationNode', '_ex...
|
| ----------------------------------------------------------------------
| Methods inherited from ax.utils.common.base.Base:
|
| __eq__ = _type_safe_equals(self, other)
| # no type annotation for now; breaks sphinx-autodoc-typehints
| # pyre-fixme[3]: Return type must be annotated.
| # pyre-fixme[2]: Parameter must be annotated.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ax.utils.common.base.Base:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| db_id
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from ax.utils.common.base.Base:
|
| __hash__ = None
!!!!! gs: SOBOL !!!!
Help on GenerationStrategy in module ax.generation_strategy.generation_strategy object:
class GenerationStrategy(ax.utils.common.base.Base)
| GenerationStrategy(steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
|
| GenerationStrategy describes which node should be used to generate new
| points for which trials, enabling and automating use of different nodes
| throughout the optimization process. For instance, it allows to use one
| node for the initialization trials, and another one for all subsequent
| trials. In the general case, this allows to automate use of an arbitrary
| number of nodes to generate an arbitrary numbers of trials.
|
| Args:
| nodes: A list of `GenerationNode`. Each `GenerationNode` in the list
| represents a single node in a `GenerationStrategy` which, when
| composed of `GenerationNodes`, can be conceptualized as a graph instead
| of a linear list. `TransitionCriterion` defined in each `GenerationNode`
| represent the edges in the `GenerationStrategy` graph. `GenerationNodes`
| are more flexible than `GenerationSteps` and new `GenerationStrategies`
| should use nodes. Notably, either, but not both, of `nodes` and `steps`
| must be provided.
| steps: A list of `GenerationStep` describing steps of this strategy.
| name: An optional name for this generation strategy. If not specified,
| strategy's name will be names of its nodes' generators joined with '+'.
|
| Method resolution order:
| GenerationStrategy
| ax.utils.common.base.Base
| builtins.object
|
| Methods defined here:
|
| __init__(self, steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| String representation of this generation strategy.
|
| clone_reset(self) -> 'GenerationStrategy'
| Copy this generation strategy without it's state.
|
| current_generator_run_limit(self) -> 'tuple[int, bool]'
| First check if we can move the generation strategy to the next node, which
| is safe, as the next call to ``gen`` will just pick up from there. Then
| determine how many generator runs this generation strategy can generate right
| now, assuming each one of them becomes its own trial, and whether optimization
| is completed.
|
| Returns: a two-item tuple of:
| - the number of generator runs that can currently be produced, with -1
| meaning unlimited generator runs,
| - whether optimization is completed and the generation strategy cannot
| generate any more generator runs at all.
|
| gen(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int | None' = None, fixed_features: 'ObservationFeatures | None' = None, num_trials: 'int' = 1, arms_per_node: 'dict[str, int] | None' = None) -> 'list[list[GeneratorRun]]'
| Produce GeneratorRuns for multiple trials at once with the possibility of
| using multiple models per trial, getting multiple GeneratorRuns per trial.
|
| Args:
| experiment: ``Experiment``, for which the generation strategy is producing
| a new generator run in the course of ``gen``, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's ``gen``, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the ``experiment``.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
| n: Integer representing how many total arms should be in the generator
| runs produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output generator runs with number of
| arms that can differ from `n`.
| fixed_features: An optional set of ``ObservationFeatures`` that will be
| passed down to the underlying nodes. Note: if provided this will
| override any algorithmically determined fixed features so it is
| important to specify all necessary fixed features.
| num_trials: Number of trials to generate generator runs for in this call.
| If not provided, defaults to 1.
| arms_per_node: An optional map from node name to the number of arms to
| generate from that node. If not provided, will default to the number
| of arms specified in the node's ``InputConstructors`` or n if no
| ``InputConstructors`` are defined on the node. We expect either n or
| arms_per_node to be provided, but not both, and this is an advanced
| argument that should only be used by advanced users.
|
| Returns:
| A list of lists of lists generator runs. Each outer list represents
| a trial being suggested and each inner list represents a generator
| run for that trial.
|
| gen_single_trial(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int' = 1, fixed_features: 'ObservationFeatures | None' = None) -> 'GeneratorRun'
| Produce the next points in the experiment. Additional kwargs passed to
| this method are propagated directly to the underlying node's `gen`, along
| with the `model_gen_kwargs` set on the current generation node.
|
| NOTE: Each generator run returned from this function must become a single
| trial on the experiment to comply with assumptions made in generation
| strategy. Do not split one generator run produced from generation strategy
| into multiple trials (never making a generator run into a trial is allowed).
|
| Args:
| experiment: Experiment, for which the generation strategy is producing
| a new generator run in the course of `gen`, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's `gen`, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the `experiment`.
| n: Integer representing how many arms should be in the generator run
| produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output a generator run with number of
| arms that can differ from `n`.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| adapter
| The adapter from the current node of this strategy. Returns None
| if no adapter has been set yet. This can happen if no generator runs have
| been produced from this GS or if the current node does not utilize
| adapters (the case for ``ExternalGenerationNode``).
|
| current_node
| Current generation node.
|
| current_node_name
| Current generation node name.
|
| current_step
| Current generation step.
|
| current_step_index
| Returns the index of the current generation step. This attribute
| is replaced by node_name in newer GenerationStrategies but surfaced here
| for backward compatibility.
|
| is_node_based
| Whether this strategy consists of GenerationNodes only.
| This is useful for determining initialization properties and
| other logic.
|
| last_generator_run
| Latest generator run produced by this generation strategy.
| Returns None if no generator runs have been produced yet.
|
| name
| Name of this generation strategy.
|
| nodes_dict
| Returns a dictionary mapping node names to nodes.
|
| optimization_complete
| Checks whether all nodes are completed in the generation strategy.
|
| trials_as_df
| Puts information on individual trials into a data frame for easy
| viewing.
|
| THIS METHOD IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE.
| Please use `Experiment.to_df()` instead.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| experiment
| Experiment, currently set on this generation strategy.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| DEFAULT_N = 1
|
| __annotations__ = {'DEFAULT_N': 'int', '_curr': 'GenerationNode', '_ex...
|
| ----------------------------------------------------------------------
| Methods inherited from ax.utils.common.base.Base:
|
| __eq__ = _type_safe_equals(self, other)
| # no type annotation for now; breaks sphinx-autodoc-typehints
| # pyre-fixme[3]: Return type must be annotated.
| # pyre-fixme[2]: Parameter must be annotated.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ax.utils.common.base.Base:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| db_id
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from ax.utils.common.base.Base:
|
| __hash__ = None
!!!!! gs: SOBOL !!!!
SOBOL, new result: RESULT: -163584.906728 : 50%|█████░░░░░| 1/2 [00:11 'None'
|
| GenerationStrategy describes which node should be used to generate new
| points for which trials, enabling and automating use of different nodes
| throughout the optimization process. For instance, it allows to use one
| node for the initialization trials, and another one for all subsequent
| trials. In the general case, this allows to automate use of an arbitrary
| number of nodes to generate an arbitrary numbers of trials.
|
| Args:
| nodes: A list of `GenerationNode`. Each `GenerationNode` in the list
| represents a single node in a `GenerationStrategy` which, when
| composed of `GenerationNodes`, can be conceptualized as a graph instead
| of a linear list. `TransitionCriterion` defined in each `GenerationNode`
| represent the edges in the `GenerationStrategy` graph. `GenerationNodes`
| are more flexible than `GenerationSteps` and new `GenerationStrategies`
| should use nodes. Notably, either, but not both, of `nodes` and `steps`
| must be provided.
| steps: A list of `GenerationStep` describing steps of this strategy.
| name: An optional name for this generation strategy. If not specified,
| strategy's name will be names of its nodes' generators joined with '+'.
|
| Method resolution order:
| GenerationStrategy
| ax.utils.common.base.Base
| builtins.object
|
| Methods defined here:
|
| __init__(self, steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| String representation of this generation strategy.
|
| clone_reset(self) -> 'GenerationStrategy'
| Copy this generation strategy without it's state.
|
| current_generator_run_limit(self) -> 'tuple[int, bool]'
| First check if we can move the generation strategy to the next node, which
| is safe, as the next call to ``gen`` will just pick up from there. Then
| determine how many generator runs this generation strategy can generate right
| now, assuming each one of them becomes its own trial, and whether optimization
| is completed.
|
| Returns: a two-item tuple of:
| - the number of generator runs that can currently be produced, with -1
| meaning unlimited generator runs,
| - whether optimization is completed and the generation strategy cannot
| generate any more generator runs at all.
|
| gen(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int | None' = None, fixed_features: 'ObservationFeatures | None' = None, num_trials: 'int' = 1, arms_per_node: 'dict[str, int] | None' = None) -> 'list[list[GeneratorRun]]'
| Produce GeneratorRuns for multiple trials at once with the possibility of
| using multiple models per trial, getting multiple GeneratorRuns per trial.
|
| Args:
| experiment: ``Experiment``, for which the generation strategy is producing
| a new generator run in the course of ``gen``, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's ``gen``, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the ``experiment``.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
| n: Integer representing how many total arms should be in the generator
| runs produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output generator runs with number of
| arms that can differ from `n`.
| fixed_features: An optional set of ``ObservationFeatures`` that will be
| passed down to the underlying nodes. Note: if provided this will
| override any algorithmically determined fixed features so it is
| important to specify all necessary fixed features.
| num_trials: Number of trials to generate generator runs for in this call.
| If not provided, defaults to 1.
| arms_per_node: An optional map from node name to the number of arms to
| generate from that node. If not provided, will default to the number
| of arms specified in the node's ``InputConstructors`` or n if no
| ``InputConstructors`` are defined on the node. We expect either n or
| arms_per_node to be provided, but not both, and this is an advanced
| argument that should only be used by advanced users.
|
| Returns:
| A list of lists of lists generator runs. Each outer list represents
| a trial being suggested and each inner list represents a generator
| run for that trial.
|
| gen_single_trial(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int' = 1, fixed_features: 'ObservationFeatures | None' = None) -> 'GeneratorRun'
| Produce the next points in the experiment. Additional kwargs passed to
| this method are propagated directly to the underlying node's `gen`, along
| with the `model_gen_kwargs` set on the current generation node.
|
| NOTE: Each generator run returned from this function must become a single
| trial on the experiment to comply with assumptions made in generation
| strategy. Do not split one generator run produced from generation strategy
| into multiple trials (never making a generator run into a trial is allowed).
|
| Args:
| experiment: Experiment, for which the generation strategy is producing
| a new generator run in the course of `gen`, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's `gen`, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the `experiment`.
| n: Integer representing how many arms should be in the generator run
| produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output a generator run with number of
| arms that can differ from `n`.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| adapter
| The adapter from the current node of this strategy. Returns None
| if no adapter has been set yet. This can happen if no generator runs have
| been produced from this GS or if the current node does not utilize
| adapters (the case for ``ExternalGenerationNode``).
|
| current_node
| Current generation node.
|
| current_node_name
| Current generation node name.
|
| current_step
| Current generation step.
|
| current_step_index
| Returns the index of the current generation step. This attribute
| is replaced by node_name in newer GenerationStrategies but surfaced here
| for backward compatibility.
|
| is_node_based
| Whether this strategy consists of GenerationNodes only.
| This is useful for determining initialization properties and
| other logic.
|
| last_generator_run
| Latest generator run produced by this generation strategy.
| Returns None if no generator runs have been produced yet.
|
| name
| Name of this generation strategy.
|
| nodes_dict
| Returns a dictionary mapping node names to nodes.
|
| optimization_complete
| Checks whether all nodes are completed in the generation strategy.
|
| trials_as_df
| Puts information on individual trials into a data frame for easy
| viewing.
|
| THIS METHOD IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE.
| Please use `Experiment.to_df()` instead.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| experiment
| Experiment, currently set on this generation strategy.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| DEFAULT_N = 1
|
| __annotations__ = {'DEFAULT_N': 'int', '_curr': 'GenerationNode', '_ex...
|
| ----------------------------------------------------------------------
| Methods inherited from ax.utils.common.base.Base:
|
| __eq__ = _type_safe_equals(self, other)
| # no type annotation for now; breaks sphinx-autodoc-typehints
| # pyre-fixme[3]: Return type must be annotated.
| # pyre-fixme[2]: Parameter must be annotated.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ax.utils.common.base.Base:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| db_id
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from ax.utils.common.base.Base:
|
| __hash__ = None
!!!!! gs: SOBOL !!!!
SOBOL, best RESULT: -163584.906727896, finishing jobs, finished 1 job: 50%|█████░░░░░| 1/2 [00:12 'None'
|
| GenerationStrategy describes which node should be used to generate new
| points for which trials, enabling and automating use of different nodes
| throughout the optimization process. For instance, it allows to use one
| node for the initialization trials, and another one for all subsequent
| trials. In the general case, this allows to automate use of an arbitrary
| number of nodes to generate an arbitrary numbers of trials.
|
| Args:
| nodes: A list of `GenerationNode`. Each `GenerationNode` in the list
| represents a single node in a `GenerationStrategy` which, when
| composed of `GenerationNodes`, can be conceptualized as a graph instead
| of a linear list. `TransitionCriterion` defined in each `GenerationNode`
| represent the edges in the `GenerationStrategy` graph. `GenerationNodes`
| are more flexible than `GenerationSteps` and new `GenerationStrategies`
| should use nodes. Notably, either, but not both, of `nodes` and `steps`
| must be provided.
| steps: A list of `GenerationStep` describing steps of this strategy.
| name: An optional name for this generation strategy. If not specified,
| strategy's name will be names of its nodes' generators joined with '+'.
|
| Method resolution order:
| GenerationStrategy
| ax.utils.common.base.Base
| builtins.object
|
| Methods defined here:
|
| __init__(self, steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| String representation of this generation strategy.
|
| clone_reset(self) -> 'GenerationStrategy'
| Copy this generation strategy without it's state.
|
| current_generator_run_limit(self) -> 'tuple[int, bool]'
| First check if we can move the generation strategy to the next node, which
| is safe, as the next call to ``gen`` will just pick up from there. Then
| determine how many generator runs this generation strategy can generate right
| now, assuming each one of them becomes its own trial, and whether optimization
| is completed.
|
| Returns: a two-item tuple of:
| - the number of generator runs that can currently be produced, with -1
| meaning unlimited generator runs,
| - whether optimization is completed and the generation strategy cannot
| generate any more generator runs at all.
|
| gen(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int | None' = None, fixed_features: 'ObservationFeatures | None' = None, num_trials: 'int' = 1, arms_per_node: 'dict[str, int] | None' = None) -> 'list[list[GeneratorRun]]'
| Produce GeneratorRuns for multiple trials at once with the possibility of
| using multiple models per trial, getting multiple GeneratorRuns per trial.
|
| Args:
| experiment: ``Experiment``, for which the generation strategy is producing
| a new generator run in the course of ``gen``, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's ``gen``, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the ``experiment``.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
| n: Integer representing how many total arms should be in the generator
| runs produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output generator runs with number of
| arms that can differ from `n`.
| fixed_features: An optional set of ``ObservationFeatures`` that will be
| passed down to the underlying nodes. Note: if provided this will
| override any algorithmically determined fixed features so it is
| important to specify all necessary fixed features.
| num_trials: Number of trials to generate generator runs for in this call.
| If not provided, defaults to 1.
| arms_per_node: An optional map from node name to the number of arms to
| generate from that node. If not provided, will default to the number
| of arms specified in the node's ``InputConstructors`` or n if no
| ``InputConstructors`` are defined on the node. We expect either n or
| arms_per_node to be provided, but not both, and this is an advanced
| argument that should only be used by advanced users.
|
| Returns:
| A list of lists of lists generator runs. Each outer list represents
| a trial being suggested and each inner list represents a generator
| run for that trial.
|
| gen_single_trial(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int' = 1, fixed_features: 'ObservationFeatures | None' = None) -> 'GeneratorRun'
| Produce the next points in the experiment. Additional kwargs passed to
| this method are propagated directly to the underlying node's `gen`, along
| with the `model_gen_kwargs` set on the current generation node.
|
| NOTE: Each generator run returned from this function must become a single
| trial on the experiment to comply with assumptions made in generation
| strategy. Do not split one generator run produced from generation strategy
| into multiple trials (never making a generator run into a trial is allowed).
|
| Args:
| experiment: Experiment, for which the generation strategy is producing
| a new generator run in the course of `gen`, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's `gen`, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the `experiment`.
| n: Integer representing how many arms should be in the generator run
| produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output a generator run with number of
| arms that can differ from `n`.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| adapter
| The adapter from the current node of this strategy. Returns None
| if no adapter has been set yet. This can happen if no generator runs have
| been produced from this GS or if the current node does not utilize
| adapters (the case for ``ExternalGenerationNode``).
|
| current_node
| Current generation node.
|
| current_node_name
| Current generation node name.
|
| current_step
| Current generation step.
|
| current_step_index
| Returns the index of the current generation step. This attribute
| is replaced by node_name in newer GenerationStrategies but surfaced here
| for backward compatibility.
|
| is_node_based
| Whether this strategy consists of GenerationNodes only.
| This is useful for determining initialization properties and
| other logic.
|
| last_generator_run
| Latest generator run produced by this generation strategy.
| Returns None if no generator runs have been produced yet.
|
| name
| Name of this generation strategy.
|
| nodes_dict
| Returns a dictionary mapping node names to nodes.
|
| optimization_complete
| Checks whether all nodes are completed in the generation strategy.
|
| trials_as_df
| Puts information on individual trials into a data frame for easy
| viewing.
|
| THIS METHOD IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE.
| Please use `Experiment.to_df()` instead.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| experiment
| Experiment, currently set on this generation strategy.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| DEFAULT_N = 1
|
| __annotations__ = {'DEFAULT_N': 'int', '_curr': 'GenerationNode', '_ex...
|
| ----------------------------------------------------------------------
| Methods inherited from ax.utils.common.base.Base:
|
| __eq__ = _type_safe_equals(self, other)
| # no type annotation for now; breaks sphinx-autodoc-typehints
| # pyre-fixme[3]: Return type must be annotated.
| # pyre-fixme[2]: Parameter must be annotated.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ax.utils.common.base.Base:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| db_id
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from ax.utils.common.base.Base:
|
| __hash__ = None
!!!!! gs: SOBOL !!!!
Help on GenerationStrategy in module ax.generation_strategy.generation_strategy object:
class GenerationStrategy(ax.utils.common.base.Base)
| GenerationStrategy(steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
|
| GenerationStrategy describes which node should be used to generate new
| points for which trials, enabling and automating use of different nodes
| throughout the optimization process. For instance, it allows to use one
| node for the initialization trials, and another one for all subsequent
| trials. In the general case, this allows to automate use of an arbitrary
| number of nodes to generate an arbitrary numbers of trials.
|
| Args:
| nodes: A list of `GenerationNode`. Each `GenerationNode` in the list
| represents a single node in a `GenerationStrategy` which, when
| composed of `GenerationNodes`, can be conceptualized as a graph instead
| of a linear list. `TransitionCriterion` defined in each `GenerationNode`
| represent the edges in the `GenerationStrategy` graph. `GenerationNodes`
| are more flexible than `GenerationSteps` and new `GenerationStrategies`
| should use nodes. Notably, either, but not both, of `nodes` and `steps`
| must be provided.
| steps: A list of `GenerationStep` describing steps of this strategy.
| name: An optional name for this generation strategy. If not specified,
| strategy's name will be names of its nodes' generators joined with '+'.
|
| Method resolution order:
| GenerationStrategy
| ax.utils.common.base.Base
| builtins.object
|
| Methods defined here:
|
| __init__(self, steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| String representation of this generation strategy.
|
| clone_reset(self) -> 'GenerationStrategy'
| Copy this generation strategy without it's state.
|
| current_generator_run_limit(self) -> 'tuple[int, bool]'
| First check if we can move the generation strategy to the next node, which
| is safe, as the next call to ``gen`` will just pick up from there. Then
| determine how many generator runs this generation strategy can generate right
| now, assuming each one of them becomes its own trial, and whether optimization
| is completed.
|
| Returns: a two-item tuple of:
| - the number of generator runs that can currently be produced, with -1
| meaning unlimited generator runs,
| - whether optimization is completed and the generation strategy cannot
| generate any more generator runs at all.
|
| gen(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int | None' = None, fixed_features: 'ObservationFeatures | None' = None, num_trials: 'int' = 1, arms_per_node: 'dict[str, int] | None' = None) -> 'list[list[GeneratorRun]]'
| Produce GeneratorRuns for multiple trials at once with the possibility of
| using multiple models per trial, getting multiple GeneratorRuns per trial.
|
| Args:
| experiment: ``Experiment``, for which the generation strategy is producing
| a new generator run in the course of ``gen``, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's ``gen``, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the ``experiment``.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
| n: Integer representing how many total arms should be in the generator
| runs produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output generator runs with number of
| arms that can differ from `n`.
| fixed_features: An optional set of ``ObservationFeatures`` that will be
| passed down to the underlying nodes. Note: if provided this will
| override any algorithmically determined fixed features so it is
| important to specify all necessary fixed features.
| num_trials: Number of trials to generate generator runs for in this call.
| If not provided, defaults to 1.
| arms_per_node: An optional map from node name to the number of arms to
| generate from that node. If not provided, will default to the number
| of arms specified in the node's ``InputConstructors`` or n if no
| ``InputConstructors`` are defined on the node. We expect either n or
| arms_per_node to be provided, but not both, and this is an advanced
| argument that should only be used by advanced users.
|
| Returns:
| A list of lists of lists generator runs. Each outer list represents
| a trial being suggested and each inner list represents a generator
| run for that trial.
|
| gen_single_trial(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int' = 1, fixed_features: 'ObservationFeatures | None' = None) -> 'GeneratorRun'
| Produce the next points in the experiment. Additional kwargs passed to
| this method are propagated directly to the underlying node's `gen`, along
| with the `model_gen_kwargs` set on the current generation node.
|
| NOTE: Each generator run returned from this function must become a single
| trial on the experiment to comply with assumptions made in generation
| strategy. Do not split one generator run produced from generation strategy
| into multiple trials (never making a generator run into a trial is allowed).
|
| Args:
| experiment: Experiment, for which the generation strategy is producing
| a new generator run in the course of `gen`, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's `gen`, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the `experiment`.
| n: Integer representing how many arms should be in the generator run
| produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output a generator run with number of
| arms that can differ from `n`.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| adapter
| The adapter from the current node of this strategy. Returns None
| if no adapter has been set yet. This can happen if no generator runs have
| been produced from this GS or if the current node does not utilize
| adapters (the case for ``ExternalGenerationNode``).
|
| current_node
| Current generation node.
|
| current_node_name
| Current generation node name.
|
| current_step
| Current generation step.
|
| current_step_index
| Returns the index of the current generation step. This attribute
| is replaced by node_name in newer GenerationStrategies but surfaced here
| for backward compatibility.
|
| is_node_based
| Whether this strategy consists of GenerationNodes only.
| This is useful for determining initialization properties and
| other logic.
|
| last_generator_run
| Latest generator run produced by this generation strategy.
| Returns None if no generator runs have been produced yet.
|
| name
| Name of this generation strategy.
|
| nodes_dict
| Returns a dictionary mapping node names to nodes.
|
| optimization_complete
| Checks whether all nodes are completed in the generation strategy.
|
| trials_as_df
| Puts information on individual trials into a data frame for easy
| viewing.
|
| THIS METHOD IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE.
| Please use `Experiment.to_df()` instead.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| experiment
| Experiment, currently set on this generation strategy.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| DEFAULT_N = 1
|
| __annotations__ = {'DEFAULT_N': 'int', '_curr': 'GenerationNode', '_ex...
|
| ----------------------------------------------------------------------
| Methods inherited from ax.utils.common.base.Base:
|
| __eq__ = _type_safe_equals(self, other)
| # no type annotation for now; breaks sphinx-autodoc-typehints
| # pyre-fixme[3]: Return type must be annotated.
| # pyre-fixme[2]: Parameter must be annotated.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ax.utils.common.base.Base:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| db_id
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from ax.utils.common.base.Base:
|
| __hash__ = None
!!!!! gs: SOBOL !!!!
Help on GenerationStrategy in module ax.generation_strategy.generation_strategy object:
class GenerationStrategy(ax.utils.common.base.Base)
| GenerationStrategy(steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
|
| GenerationStrategy describes which node should be used to generate new
| points for which trials, enabling and automating use of different nodes
| throughout the optimization process. For instance, it allows to use one
| node for the initialization trials, and another one for all subsequent
| trials. In the general case, this allows to automate use of an arbitrary
| number of nodes to generate an arbitrary numbers of trials.
|
| Args:
| nodes: A list of `GenerationNode`. Each `GenerationNode` in the list
| represents a single node in a `GenerationStrategy` which, when
| composed of `GenerationNodes`, can be conceptualized as a graph instead
| of a linear list. `TransitionCriterion` defined in each `GenerationNode`
| represent the edges in the `GenerationStrategy` graph. `GenerationNodes`
| are more flexible than `GenerationSteps` and new `GenerationStrategies`
| should use nodes. Notably, either, but not both, of `nodes` and `steps`
| must be provided.
| steps: A list of `GenerationStep` describing steps of this strategy.
| name: An optional name for this generation strategy. If not specified,
| strategy's name will be names of its nodes' generators joined with '+'.
|
| Method resolution order:
| GenerationStrategy
| ax.utils.common.base.Base
| builtins.object
|
| Methods defined here:
|
| __init__(self, steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| String representation of this generation strategy.
|
| clone_reset(self) -> 'GenerationStrategy'
| Copy this generation strategy without it's state.
|
| current_generator_run_limit(self) -> 'tuple[int, bool]'
| First check if we can move the generation strategy to the next node, which
| is safe, as the next call to ``gen`` will just pick up from there. Then
| determine how many generator runs this generation strategy can generate right
| now, assuming each one of them becomes its own trial, and whether optimization
| is completed.
|
| Returns: a two-item tuple of:
| - the number of generator runs that can currently be produced, with -1
| meaning unlimited generator runs,
| - whether optimization is completed and the generation strategy cannot
| generate any more generator runs at all.
|
| gen(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int | None' = None, fixed_features: 'ObservationFeatures | None' = None, num_trials: 'int' = 1, arms_per_node: 'dict[str, int] | None' = None) -> 'list[list[GeneratorRun]]'
| Produce GeneratorRuns for multiple trials at once with the possibility of
| using multiple models per trial, getting multiple GeneratorRuns per trial.
|
| Args:
| experiment: ``Experiment``, for which the generation strategy is producing
| a new generator run in the course of ``gen``, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's ``gen``, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the ``experiment``.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
| n: Integer representing how many total arms should be in the generator
| runs produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output generator runs with number of
| arms that can differ from `n`.
| fixed_features: An optional set of ``ObservationFeatures`` that will be
| passed down to the underlying nodes. Note: if provided this will
| override any algorithmically determined fixed features so it is
| important to specify all necessary fixed features.
| num_trials: Number of trials to generate generator runs for in this call.
| If not provided, defaults to 1.
| arms_per_node: An optional map from node name to the number of arms to
| generate from that node. If not provided, will default to the number
| of arms specified in the node's ``InputConstructors`` or n if no
| ``InputConstructors`` are defined on the node. We expect either n or
| arms_per_node to be provided, but not both, and this is an advanced
| argument that should only be used by advanced users.
|
| Returns:
| A list of lists of lists generator runs. Each outer list represents
| a trial being suggested and each inner list represents a generator
| run for that trial.
|
| gen_single_trial(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int' = 1, fixed_features: 'ObservationFeatures | None' = None) -> 'GeneratorRun'
| Produce the next points in the experiment. Additional kwargs passed to
| this method are propagated directly to the underlying node's `gen`, along
| with the `model_gen_kwargs` set on the current generation node.
|
| NOTE: Each generator run returned from this function must become a single
| trial on the experiment to comply with assumptions made in generation
| strategy. Do not split one generator run produced from generation strategy
| into multiple trials (never making a generator run into a trial is allowed).
|
| Args:
| experiment: Experiment, for which the generation strategy is producing
| a new generator run in the course of `gen`, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's `gen`, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the `experiment`.
| n: Integer representing how many arms should be in the generator run
| produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output a generator run with number of
| arms that can differ from `n`.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| adapter
| The adapter from the current node of this strategy. Returns None
| if no adapter has been set yet. This can happen if no generator runs have
| been produced from this GS or if the current node does not utilize
| adapters (the case for ``ExternalGenerationNode``).
|
| current_node
| Current generation node.
|
| current_node_name
| Current generation node name.
|
| current_step
| Current generation step.
|
| current_step_index
| Returns the index of the current generation step. This attribute
| is replaced by node_name in newer GenerationStrategies but surfaced here
| for backward compatibility.
|
| is_node_based
| Whether this strategy consists of GenerationNodes only.
| This is useful for determining initialization properties and
| other logic.
|
| last_generator_run
| Latest generator run produced by this generation strategy.
| Returns None if no generator runs have been produced yet.
|
| name
| Name of this generation strategy.
|
| nodes_dict
| Returns a dictionary mapping node names to nodes.
|
| optimization_complete
| Checks whether all nodes are completed in the generation strategy.
|
| trials_as_df
| Puts information on individual trials into a data frame for easy
| viewing.
|
| THIS METHOD IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE.
| Please use `Experiment.to_df()` instead.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| experiment
| Experiment, currently set on this generation strategy.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| DEFAULT_N = 1
|
| __annotations__ = {'DEFAULT_N': 'int', '_curr': 'GenerationNode', '_ex...
|
| ----------------------------------------------------------------------
| Methods inherited from ax.utils.common.base.Base:
|
| __eq__ = _type_safe_equals(self, other)
| # no type annotation for now; breaks sphinx-autodoc-typehints
| # pyre-fixme[3]: Return type must be annotated.
| # pyre-fixme[2]: Parameter must be annotated.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ax.utils.common.base.Base:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| db_id
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from ax.utils.common.base.Base:
|
| __hash__ = None
!!!!! gs: SOBOL !!!!
Help on GenerationStrategy in module ax.generation_strategy.generation_strategy object:
class GenerationStrategy(ax.utils.common.base.Base)
| GenerationStrategy(steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
|
| GenerationStrategy describes which node should be used to generate new
| points for which trials, enabling and automating use of different nodes
| throughout the optimization process. For instance, it allows to use one
| node for the initialization trials, and another one for all subsequent
| trials. In the general case, this allows to automate use of an arbitrary
| number of nodes to generate an arbitrary numbers of trials.
|
| Args:
| nodes: A list of `GenerationNode`. Each `GenerationNode` in the list
| represents a single node in a `GenerationStrategy` which, when
| composed of `GenerationNodes`, can be conceptualized as a graph instead
| of a linear list. `TransitionCriterion` defined in each `GenerationNode`
| represent the edges in the `GenerationStrategy` graph. `GenerationNodes`
| are more flexible than `GenerationSteps` and new `GenerationStrategies`
| should use nodes. Notably, either, but not both, of `nodes` and `steps`
| must be provided.
| steps: A list of `GenerationStep` describing steps of this strategy.
| name: An optional name for this generation strategy. If not specified,
| strategy's name will be names of its nodes' generators joined with '+'.
|
| Method resolution order:
| GenerationStrategy
| ax.utils.common.base.Base
| builtins.object
|
| Methods defined here:
|
| __init__(self, steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| String representation of this generation strategy.
|
| clone_reset(self) -> 'GenerationStrategy'
| Copy this generation strategy without it's state.
|
| current_generator_run_limit(self) -> 'tuple[int, bool]'
| First check if we can move the generation strategy to the next node, which
| is safe, as the next call to ``gen`` will just pick up from there. Then
| determine how many generator runs this generation strategy can generate right
| now, assuming each one of them becomes its own trial, and whether optimization
| is completed.
|
| Returns: a two-item tuple of:
| - the number of generator runs that can currently be produced, with -1
| meaning unlimited generator runs,
| - whether optimization is completed and the generation strategy cannot
| generate any more generator runs at all.
|
| gen(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int | None' = None, fixed_features: 'ObservationFeatures | None' = None, num_trials: 'int' = 1, arms_per_node: 'dict[str, int] | None' = None) -> 'list[list[GeneratorRun]]'
| Produce GeneratorRuns for multiple trials at once with the possibility of
| using multiple models per trial, getting multiple GeneratorRuns per trial.
|
| Args:
| experiment: ``Experiment``, for which the generation strategy is producing
| a new generator run in the course of ``gen``, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's ``gen``, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the ``experiment``.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
| n: Integer representing how many total arms should be in the generator
| runs produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output generator runs with number of
| arms that can differ from `n`.
| fixed_features: An optional set of ``ObservationFeatures`` that will be
| passed down to the underlying nodes. Note: if provided this will
| override any algorithmically determined fixed features so it is
| important to specify all necessary fixed features.
| num_trials: Number of trials to generate generator runs for in this call.
| If not provided, defaults to 1.
| arms_per_node: An optional map from node name to the number of arms to
| generate from that node. If not provided, will default to the number
| of arms specified in the node's ``InputConstructors`` or n if no
| ``InputConstructors`` are defined on the node. We expect either n or
| arms_per_node to be provided, but not both, and this is an advanced
| argument that should only be used by advanced users.
|
| Returns:
| A list of lists of lists generator runs. Each outer list represents
| a trial being suggested and each inner list represents a generator
| run for that trial.
|
| gen_single_trial(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int' = 1, fixed_features: 'ObservationFeatures | None' = None) -> 'GeneratorRun'
| Produce the next points in the experiment. Additional kwargs passed to
| this method are propagated directly to the underlying node's `gen`, along
| with the `model_gen_kwargs` set on the current generation node.
|
| NOTE: Each generator run returned from this function must become a single
| trial on the experiment to comply with assumptions made in generation
| strategy. Do not split one generator run produced from generation strategy
| into multiple trials (never making a generator run into a trial is allowed).
|
| Args:
| experiment: Experiment, for which the generation strategy is producing
| a new generator run in the course of `gen`, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's `gen`, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the `experiment`.
| n: Integer representing how many arms should be in the generator run
| produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output a generator run with number of
| arms that can differ from `n`.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| adapter
| The adapter from the current node of this strategy. Returns None
| if no adapter has been set yet. This can happen if no generator runs have
| been produced from this GS or if the current node does not utilize
| adapters (the case for ``ExternalGenerationNode``).
|
| current_node
| Current generation node.
|
| current_node_name
| Current generation node name.
|
| current_step
| Current generation step.
|
| current_step_index
| Returns the index of the current generation step. This attribute
| is replaced by node_name in newer GenerationStrategies but surfaced here
| for backward compatibility.
|
| is_node_based
| Whether this strategy consists of GenerationNodes only.
| This is useful for determining initialization properties and
| other logic.
|
| last_generator_run
| Latest generator run produced by this generation strategy.
| Returns None if no generator runs have been produced yet.
|
| name
| Name of this generation strategy.
|
| nodes_dict
| Returns a dictionary mapping node names to nodes.
|
| optimization_complete
| Checks whether all nodes are completed in the generation strategy.
|
| trials_as_df
| Puts information on individual trials into a data frame for easy
| viewing.
|
| THIS METHOD IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE.
| Please use `Experiment.to_df()` instead.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| experiment
| Experiment, currently set on this generation strategy.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| DEFAULT_N = 1
|
| __annotations__ = {'DEFAULT_N': 'int', '_curr': 'GenerationNode', '_ex...
|
| ----------------------------------------------------------------------
| Methods inherited from ax.utils.common.base.Base:
|
| __eq__ = _type_safe_equals(self, other)
| # no type annotation for now; breaks sphinx-autodoc-typehints
| # pyre-fixme[3]: Return type must be annotated.
| # pyre-fixme[2]: Parameter must be annotated.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ax.utils.common.base.Base:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| db_id
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from ax.utils.common.base.Base:
|
| __hash__ = None
!!!!! gs: SOBOL !!!!
Help on GenerationStrategy in module ax.generation_strategy.generation_strategy object:
class GenerationStrategy(ax.utils.common.base.Base)
| GenerationStrategy(steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
|
| GenerationStrategy describes which node should be used to generate new
| points for which trials, enabling and automating use of different nodes
| throughout the optimization process. For instance, it allows to use one
| node for the initialization trials, and another one for all subsequent
| trials. In the general case, this allows to automate use of an arbitrary
| number of nodes to generate an arbitrary numbers of trials.
|
| Args:
| nodes: A list of `GenerationNode`. Each `GenerationNode` in the list
| represents a single node in a `GenerationStrategy` which, when
| composed of `GenerationNodes`, can be conceptualized as a graph instead
| of a linear list. `TransitionCriterion` defined in each `GenerationNode`
| represent the edges in the `GenerationStrategy` graph. `GenerationNodes`
| are more flexible than `GenerationSteps` and new `GenerationStrategies`
| should use nodes. Notably, either, but not both, of `nodes` and `steps`
| must be provided.
| steps: A list of `GenerationStep` describing steps of this strategy.
| name: An optional name for this generation strategy. If not specified,
| strategy's name will be names of its nodes' generators joined with '+'.
|
| Method resolution order:
| GenerationStrategy
| ax.utils.common.base.Base
| builtins.object
|
| Methods defined here:
|
| __init__(self, steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| String representation of this generation strategy.
|
| clone_reset(self) -> 'GenerationStrategy'
| Copy this generation strategy without it's state.
|
| current_generator_run_limit(self) -> 'tuple[int, bool]'
| First check if we can move the generation strategy to the next node, which
| is safe, as the next call to ``gen`` will just pick up from there. Then
| determine how many generator runs this generation strategy can generate right
| now, assuming each one of them becomes its own trial, and whether optimization
| is completed.
|
| Returns: a two-item tuple of:
| - the number of generator runs that can currently be produced, with -1
| meaning unlimited generator runs,
| - whether optimization is completed and the generation strategy cannot
| generate any more generator runs at all.
|
| gen(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int | None' = None, fixed_features: 'ObservationFeatures | None' = None, num_trials: 'int' = 1, arms_per_node: 'dict[str, int] | None' = None) -> 'list[list[GeneratorRun]]'
| Produce GeneratorRuns for multiple trials at once with the possibility of
| using multiple models per trial, getting multiple GeneratorRuns per trial.
|
| Args:
| experiment: ``Experiment``, for which the generation strategy is producing
| a new generator run in the course of ``gen``, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's ``gen``, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the ``experiment``.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
| n: Integer representing how many total arms should be in the generator
| runs produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output generator runs with number of
| arms that can differ from `n`.
| fixed_features: An optional set of ``ObservationFeatures`` that will be
| passed down to the underlying nodes. Note: if provided this will
| override any algorithmically determined fixed features so it is
| important to specify all necessary fixed features.
| num_trials: Number of trials to generate generator runs for in this call.
| If not provided, defaults to 1.
| arms_per_node: An optional map from node name to the number of arms to
| generate from that node. If not provided, will default to the number
| of arms specified in the node's ``InputConstructors`` or n if no
| ``InputConstructors`` are defined on the node. We expect either n or
| arms_per_node to be provided, but not both, and this is an advanced
| argument that should only be used by advanced users.
|
| Returns:
| A list of lists of lists generator runs. Each outer list represents
| a trial being suggested and each inner list represents a generator
| run for that trial.
|
| gen_single_trial(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int' = 1, fixed_features: 'ObservationFeatures | None' = None) -> 'GeneratorRun'
| Produce the next points in the experiment. Additional kwargs passed to
| this method are propagated directly to the underlying node's `gen`, along
| with the `model_gen_kwargs` set on the current generation node.
|
| NOTE: Each generator run returned from this function must become a single
| trial on the experiment to comply with assumptions made in generation
| strategy. Do not split one generator run produced from generation strategy
| into multiple trials (never making a generator run into a trial is allowed).
|
| Args:
| experiment: Experiment, for which the generation strategy is producing
| a new generator run in the course of `gen`, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's `gen`, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the `experiment`.
| n: Integer representing how many arms should be in the generator run
| produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output a generator run with number of
| arms that can differ from `n`.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| adapter
| The adapter from the current node of this strategy. Returns None
| if no adapter has been set yet. This can happen if no generator runs have
| been produced from this GS or if the current node does not utilize
| adapters (the case for ``ExternalGenerationNode``).
|
| current_node
| Current generation node.
|
| current_node_name
| Current generation node name.
|
| current_step
| Current generation step.
|
| current_step_index
| Returns the index of the current generation step. This attribute
| is replaced by node_name in newer GenerationStrategies but surfaced here
| for backward compatibility.
|
| is_node_based
| Whether this strategy consists of GenerationNodes only.
| This is useful for determining initialization properties and
| other logic.
|
| last_generator_run
| Latest generator run produced by this generation strategy.
| Returns None if no generator runs have been produced yet.
|
| name
| Name of this generation strategy.
|
| nodes_dict
| Returns a dictionary mapping node names to nodes.
|
| optimization_complete
| Checks whether all nodes are completed in the generation strategy.
|
| trials_as_df
| Puts information on individual trials into a data frame for easy
| viewing.
|
| THIS METHOD IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE.
| Please use `Experiment.to_df()` instead.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| experiment
| Experiment, currently set on this generation strategy.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| DEFAULT_N = 1
|
| __annotations__ = {'DEFAULT_N': 'int', '_curr': 'GenerationNode', '_ex...
|
| ----------------------------------------------------------------------
| Methods inherited from ax.utils.common.base.Base:
|
| __eq__ = _type_safe_equals(self, other)
| # no type annotation for now; breaks sphinx-autodoc-typehints
| # pyre-fixme[3]: Return type must be annotated.
| # pyre-fixme[2]: Parameter must be annotated.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ax.utils.common.base.Base:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| db_id
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from ax.utils.common.base.Base:
|
| __hash__ = None
!!!!! gs: SOBOL !!!!
Help on GenerationStrategy in module ax.generation_strategy.generation_strategy object:
class GenerationStrategy(ax.utils.common.base.Base)
| GenerationStrategy(steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
|
| GenerationStrategy describes which node should be used to generate new
| points for which trials, enabling and automating use of different nodes
| throughout the optimization process. For instance, it allows to use one
| node for the initialization trials, and another one for all subsequent
| trials. In the general case, this allows to automate use of an arbitrary
| number of nodes to generate an arbitrary numbers of trials.
|
| Args:
| nodes: A list of `GenerationNode`. Each `GenerationNode` in the list
| represents a single node in a `GenerationStrategy` which, when
| composed of `GenerationNodes`, can be conceptualized as a graph instead
| of a linear list. `TransitionCriterion` defined in each `GenerationNode`
| represent the edges in the `GenerationStrategy` graph. `GenerationNodes`
| are more flexible than `GenerationSteps` and new `GenerationStrategies`
| should use nodes. Notably, either, but not both, of `nodes` and `steps`
| must be provided.
| steps: A list of `GenerationStep` describing steps of this strategy.
| name: An optional name for this generation strategy. If not specified,
| strategy's name will be names of its nodes' generators joined with '+'.
|
| Method resolution order:
| GenerationStrategy
| ax.utils.common.base.Base
| builtins.object
|
| Methods defined here:
|
| __init__(self, steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| String representation of this generation strategy.
|
| clone_reset(self) -> 'GenerationStrategy'
| Copy this generation strategy without it's state.
|
| current_generator_run_limit(self) -> 'tuple[int, bool]'
| First check if we can move the generation strategy to the next node, which
| is safe, as the next call to ``gen`` will just pick up from there. Then
| determine how many generator runs this generation strategy can generate right
| now, assuming each one of them becomes its own trial, and whether optimization
| is completed.
|
| Returns: a two-item tuple of:
| - the number of generator runs that can currently be produced, with -1
| meaning unlimited generator runs,
| - whether optimization is completed and the generation strategy cannot
| generate any more generator runs at all.
|
| gen(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int | None' = None, fixed_features: 'ObservationFeatures | None' = None, num_trials: 'int' = 1, arms_per_node: 'dict[str, int] | None' = None) -> 'list[list[GeneratorRun]]'
| Produce GeneratorRuns for multiple trials at once with the possibility of
| using multiple models per trial, getting multiple GeneratorRuns per trial.
|
| Args:
| experiment: ``Experiment``, for which the generation strategy is producing
| a new generator run in the course of ``gen``, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's ``gen``, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the ``experiment``.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
| n: Integer representing how many total arms should be in the generator
| runs produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output generator runs with number of
| arms that can differ from `n`.
| fixed_features: An optional set of ``ObservationFeatures`` that will be
| passed down to the underlying nodes. Note: if provided this will
| override any algorithmically determined fixed features so it is
| important to specify all necessary fixed features.
| num_trials: Number of trials to generate generator runs for in this call.
| If not provided, defaults to 1.
| arms_per_node: An optional map from node name to the number of arms to
| generate from that node. If not provided, will default to the number
| of arms specified in the node's ``InputConstructors`` or n if no
| ``InputConstructors`` are defined on the node. We expect either n or
| arms_per_node to be provided, but not both, and this is an advanced
| argument that should only be used by advanced users.
|
| Returns:
| A list of lists of lists generator runs. Each outer list represents
| a trial being suggested and each inner list represents a generator
| run for that trial.
|
| gen_single_trial(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int' = 1, fixed_features: 'ObservationFeatures | None' = None) -> 'GeneratorRun'
| Produce the next points in the experiment. Additional kwargs passed to
| this method are propagated directly to the underlying node's `gen`, along
| with the `model_gen_kwargs` set on the current generation node.
|
| NOTE: Each generator run returned from this function must become a single
| trial on the experiment to comply with assumptions made in generation
| strategy. Do not split one generator run produced from generation strategy
| into multiple trials (never making a generator run into a trial is allowed).
|
| Args:
| experiment: Experiment, for which the generation strategy is producing
| a new generator run in the course of `gen`, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's `gen`, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the `experiment`.
| n: Integer representing how many arms should be in the generator run
| produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output a generator run with number of
| arms that can differ from `n`.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| adapter
| The adapter from the current node of this strategy. Returns None
| if no adapter has been set yet. This can happen if no generator runs have
| been produced from this GS or if the current node does not utilize
| adapters (the case for ``ExternalGenerationNode``).
|
| current_node
| Current generation node.
|
| current_node_name
| Current generation node name.
|
| current_step
| Current generation step.
|
| current_step_index
| Returns the index of the current generation step. This attribute
| is replaced by node_name in newer GenerationStrategies but surfaced here
| for backward compatibility.
|
| is_node_based
| Whether this strategy consists of GenerationNodes only.
| This is useful for determining initialization properties and
| other logic.
|
| last_generator_run
| Latest generator run produced by this generation strategy.
| Returns None if no generator runs have been produced yet.
|
| name
| Name of this generation strategy.
|
| nodes_dict
| Returns a dictionary mapping node names to nodes.
|
| optimization_complete
| Checks whether all nodes are completed in the generation strategy.
|
| trials_as_df
| Puts information on individual trials into a data frame for easy
| viewing.
|
| THIS METHOD IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE.
| Please use `Experiment.to_df()` instead.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| experiment
| Experiment, currently set on this generation strategy.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| DEFAULT_N = 1
|
| __annotations__ = {'DEFAULT_N': 'int', '_curr': 'GenerationNode', '_ex...
|
| ----------------------------------------------------------------------
| Methods inherited from ax.utils.common.base.Base:
|
| __eq__ = _type_safe_equals(self, other)
| # no type annotation for now; breaks sphinx-autodoc-typehints
| # pyre-fixme[3]: Return type must be annotated.
| # pyre-fixme[2]: Parameter must be annotated.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ax.utils.common.base.Base:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| db_id
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from ax.utils.common.base.Base:
|
| __hash__ = None
!!!!! gs: SOBOL !!!!
SOBOL, best RESULT: -163584.906727896, new result: RESULT: -48680.643826 : 100%|██████████| 2/2 [00:23 'None'
|
| GenerationStrategy describes which node should be used to generate new
| points for which trials, enabling and automating use of different nodes
| throughout the optimization process. For instance, it allows to use one
| node for the initialization trials, and another one for all subsequent
| trials. In the general case, this allows to automate use of an arbitrary
| number of nodes to generate an arbitrary numbers of trials.
|
| Args:
| nodes: A list of `GenerationNode`. Each `GenerationNode` in the list
| represents a single node in a `GenerationStrategy` which, when
| composed of `GenerationNodes`, can be conceptualized as a graph instead
| of a linear list. `TransitionCriterion` defined in each `GenerationNode`
| represent the edges in the `GenerationStrategy` graph. `GenerationNodes`
| are more flexible than `GenerationSteps` and new `GenerationStrategies`
| should use nodes. Notably, either, but not both, of `nodes` and `steps`
| must be provided.
| steps: A list of `GenerationStep` describing steps of this strategy.
| name: An optional name for this generation strategy. If not specified,
| strategy's name will be names of its nodes' generators joined with '+'.
|
| Method resolution order:
| GenerationStrategy
| ax.utils.common.base.Base
| builtins.object
|
| Methods defined here:
|
| __init__(self, steps: 'list[GenerationStep] | None' = None, name: 'str | None' = None, nodes: 'list[GenerationNode] | None' = None) -> 'None'
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self) -> 'str'
| String representation of this generation strategy.
|
| clone_reset(self) -> 'GenerationStrategy'
| Copy this generation strategy without it's state.
|
| current_generator_run_limit(self) -> 'tuple[int, bool]'
| First check if we can move the generation strategy to the next node, which
| is safe, as the next call to ``gen`` will just pick up from there. Then
| determine how many generator runs this generation strategy can generate right
| now, assuming each one of them becomes its own trial, and whether optimization
| is completed.
|
| Returns: a two-item tuple of:
| - the number of generator runs that can currently be produced, with -1
| meaning unlimited generator runs,
| - whether optimization is completed and the generation strategy cannot
| generate any more generator runs at all.
|
| gen(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int | None' = None, fixed_features: 'ObservationFeatures | None' = None, num_trials: 'int' = 1, arms_per_node: 'dict[str, int] | None' = None) -> 'list[list[GeneratorRun]]'
| Produce GeneratorRuns for multiple trials at once with the possibility of
| using multiple models per trial, getting multiple GeneratorRuns per trial.
|
| Args:
| experiment: ``Experiment``, for which the generation strategy is producing
| a new generator run in the course of ``gen``, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's ``gen``, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the ``experiment``.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
| n: Integer representing how many total arms should be in the generator
| runs produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output generator runs with number of
| arms that can differ from `n`.
| fixed_features: An optional set of ``ObservationFeatures`` that will be
| passed down to the underlying nodes. Note: if provided this will
| override any algorithmically determined fixed features so it is
| important to specify all necessary fixed features.
| num_trials: Number of trials to generate generator runs for in this call.
| If not provided, defaults to 1.
| arms_per_node: An optional map from node name to the number of arms to
| generate from that node. If not provided, will default to the number
| of arms specified in the node's ``InputConstructors`` or n if no
| ``InputConstructors`` are defined on the node. We expect either n or
| arms_per_node to be provided, but not both, and this is an advanced
| argument that should only be used by advanced users.
|
| Returns:
| A list of lists of lists generator runs. Each outer list represents
| a trial being suggested and each inner list represents a generator
| run for that trial.
|
| gen_single_trial(self, experiment: 'Experiment', data: 'Data | None' = None, pending_observations: 'dict[str, list[ObservationFeatures]] | None' = None, n: 'int' = 1, fixed_features: 'ObservationFeatures | None' = None) -> 'GeneratorRun'
| Produce the next points in the experiment. Additional kwargs passed to
| this method are propagated directly to the underlying node's `gen`, along
| with the `model_gen_kwargs` set on the current generation node.
|
| NOTE: Each generator run returned from this function must become a single
| trial on the experiment to comply with assumptions made in generation
| strategy. Do not split one generator run produced from generation strategy
| into multiple trials (never making a generator run into a trial is allowed).
|
| Args:
| experiment: Experiment, for which the generation strategy is producing
| a new generator run in the course of `gen`, and to which that
| generator run will be added as trial(s). Information stored on the
| experiment (e.g., trial statuses) is used to determine which node
| will be used to produce the generator run returned from this method.
| data: Optional data to be passed to the underlying node's `gen`, which
| is called within this method and actually produces the resulting
| generator run. By default, data is all data on the `experiment`.
| n: Integer representing how many arms should be in the generator run
| produced by this method. NOTE: Some underlying nodes may ignore
| the `n` and produce a node-determined number of arms. In that
| case this method will also output a generator run with number of
| arms that can differ from `n`.
| pending_observations: A map from metric name to pending
| observations for that metric, used by some nodes to avoid
| resuggesting points that are currently being evaluated.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| adapter
| The adapter from the current node of this strategy. Returns None
| if no adapter has been set yet. This can happen if no generator runs have
| been produced from this GS or if the current node does not utilize
| adapters (the case for ``ExternalGenerationNode``).
|
| current_node
| Current generation node.
|
| current_node_name
| Current generation node name.
|
| current_step
| Current generation step.
|
| current_step_index
| Returns the index of the current generation step. This attribute
| is replaced by node_name in newer GenerationStrategies but surfaced here
| for backward compatibility.
|
| is_node_based
| Whether this strategy consists of GenerationNodes only.
| This is useful for determining initialization properties and
| other logic.
|
| last_generator_run
| Latest generator run produced by this generation strategy.
| Returns None if no generator runs have been produced yet.
|
| name
| Name of this generation strategy.
|
| nodes_dict
| Returns a dictionary mapping node names to nodes.
|
| optimization_complete
| Checks whether all nodes are completed in the generation strategy.
|
| trials_as_df
| Puts information on individual trials into a data frame for easy
| viewing.
|
| THIS METHOD IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE.
| Please use `Experiment.to_df()` instead.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| experiment
| Experiment, currently set on this generation strategy.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| DEFAULT_N = 1
|
| __annotations__ = {'DEFAULT_N': 'int', '_curr': 'GenerationNode', '_ex...
|
| ----------------------------------------------------------------------
| Methods inherited from ax.utils.common.base.Base:
|
| __eq__ = _type_safe_equals(self, other)
| # no type annotation for now; breaks sphinx-autodoc-typehints
| # pyre-fixme[3]: Return type must be annotated.
| # pyre-fixme[2]: Parameter must be annotated.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ax.utils.common.base.Base:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| db_id
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from ax.utils.common.base.Base:
|
| __hash__ = None
!!!!! gs: SOBOL !!!!
SOBOL, best RESULT: -163584.906727896, finishing jobs, finished 1 job : 100%|██████████| 2/2 [00:30<00:00, 15.23s/it]
Best RESULT, min (total: 2)
┏━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┓
┃OO_Info_int_param┃OO_Info_int_param_two┃OO_Info_float_param┃OO_Info_choice_param┃int_param┃float_param ┃int_param_two┃choice_param┃RESULT ┃
┡━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━┩
│-66 │-94 │-34.762277007102966│4 │-66 │-34.762277007102966│-94 │4 │-163584.906727896│
└───────────────────┴───────────────────────┴─────────────────────┴──────────────────────┴───────────┴─────────────────────┴───────────────┴──────────────┴───────────────────┘
Runtime Infos
┏━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┓
┃Number of evaluations┃Min time ┃Max time ┃Average time┃Median time┃
┡━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━┩
│ 2 │ 6.00 sec │ 6.00 sec │ 6.00 sec │ 6.00 sec │
└───────────────────────┴───────────┴───────────┴──────────────┴─────────────┘
Model generation times
┏━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━┳━━━━━━━━━━━━━━┓
┃Iteration┃Seconds┃Jobs┃Time per job┃
┡━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━╇━━━━━━━━━━━━━━┩
│ 1 │ 0.062 │ 1 │ 0.062 │
│ 2 │ 0.468 │ 1 │ 0.468 │
├───────────┼─────────┼──────┼──────────────┤
│ Average │ 0.265 │ │ │
│ Median │ 0.265 │ │ │
│ Total │ 0.530 │ │ │
│ Max │ 0.468 │ │ │
│ Min │ 0.062 │ │ │
└───────────┴─────────┴──────┴──────────────┘
Job submission durations
┏━━━━━━━━━┳━━━━━━━━━┳━━━━━━┳━━━━━━━━━━━━━━┓
┃ Batch┃Seconds┃Jobs┃Time per job┃
┡━━━━━━━━━╇━━━━━━━━━╇━━━━━━╇━━━━━━━━━━━━━━┩
│ 1 │ 0.140 │ 1 │ 0.140 │
│ 2 │ 0.123 │ 1 │ 0.123 │
├─────────┼─────────┼──────┼──────────────┤
│ Average │ 0.131 │ │ │
│ Median │ 0.131 │ │ │
│ Total │ 0.263 │ │ │
│ Max │ 0.140 │ │ │
│ Min │ 0.123 │ │ │
└─────────┴─────────┴──────┴──────────────┘
2025-11-01 12:39:20 (fcce1a72-8d98-44da-b13c-ce3689fb256b): SOBOL, Started OmniOpt2 run...
2025-11-01 12:39:20 (fcce1a72-8d98-44da-b13c-ce3689fb256b): SOBOL, getting new HP set (no sbatch)
2025-11-01 12:39:20 (fcce1a72-8d98-44da-b13c-ce3689fb256b): SOBOL, requested 1 jobs, got 1, 0.06 s/job
2025-11-01 12:39:20 (fcce1a72-8d98-44da-b13c-ce3689fb256b): SOBOL, eval #1/1 start
2025-11-01 12:39:20 (fcce1a72-8d98-44da-b13c-ce3689fb256b): SOBOL, starting new job
2025-11-01 12:39:20 (fcce1a72-8d98-44da-b13c-ce3689fb256b): SOBOL, started new job
2025-11-01 12:39:31 (fcce1a72-8d98-44da-b13c-ce3689fb256b): SOBOL, new result: RESULT: -163584.906728
2025-11-01 12:39:33 (fcce1a72-8d98-44da-b13c-ce3689fb256b): SOBOL, best RESULT: -163584.906727896, finishing jobs, finished 1 job
2025-11-01 12:39:33 (fcce1a72-8d98-44da-b13c-ce3689fb256b): SOBOL, best RESULT: -163584.906727896, getting new HP set (no sbatch)
2025-11-01 12:39:33 (fcce1a72-8d98-44da-b13c-ce3689fb256b): SOBOL, best RESULT: -163584.906727896, requested 1 jobs, got 1, 0.47 s/job
2025-11-01 12:39:33 (fcce1a72-8d98-44da-b13c-ce3689fb256b): SOBOL, best RESULT: -163584.906727896, eval #1/1 start
2025-11-01 12:39:33 (fcce1a72-8d98-44da-b13c-ce3689fb256b): SOBOL, best RESULT: -163584.906727896, starting new job
2025-11-01 12:39:33 (fcce1a72-8d98-44da-b13c-ce3689fb256b): SOBOL, best RESULT: -163584.906727896, started new job
2025-11-01 12:39:44 (fcce1a72-8d98-44da-b13c-ce3689fb256b): SOBOL, best RESULT: -163584.906727896, new result: RESULT: -48680.643826
2025-11-01 12:39:50 (fcce1a72-8d98-44da-b13c-ce3689fb256b): SOBOL, best RESULT: -163584.906727896, finishing jobs, finished 1 job
Job submission durations
┏━━━━━━━━━┳━━━━━━━━━┳━━━━━━┳━━━━━━━━━━━━━━┓
┃ Batch ┃ Seconds ┃ Jobs ┃ Time per job ┃
┡━━━━━━━━━╇━━━━━━━━━╇━━━━━━╇━━━━━━━━━━━━━━┩
│ 1 │ 0.140 │ 1 │ 0.140 │
│ 2 │ 0.123 │ 1 │ 0.123 │
├─────────┼─────────┼──────┼──────────────┤
│ Average │ 0.131 │ │ │
│ Median │ 0.131 │ │ │
│ Total │ 0.263 │ │ │
│ Max │ 0.140 │ │ │
│ Min │ 0.123 │ │ │
└─────────┴─────────┴──────┴──────────────┘
Model generation times
┏━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━┳━━━━━━━━━━━━━━┓
┃ Iteration ┃ Seconds ┃ Jobs ┃ Time per job ┃
┡━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━╇━━━━━━━━━━━━━━┩
│ 1 │ 0.062 │ 1 │ 0.062 │
│ 2 │ 0.468 │ 1 │ 0.468 │
├───────────┼─────────┼──────┼──────────────┤
│ Average │ 0.265 │ │ │
│ Median │ 0.265 │ │ │
│ Total │ 0.530 │ │ │
│ Max │ 0.468 │ │ │
│ Min │ 0.062 │ │ │
└───────────┴─────────┴──────┴──────────────┘
