examol.solution

Specifications for different solution methods

class examol.solution.MultiFidelityActiveLearning(starter: ~examol.start.base.Starter = <examol.start.fast.RandomStarter object>, num_to_run: int = Ellipsis, selector: ~examol.select.base.Selector = Ellipsis, scorer: ~examol.score.base.Scorer = Ellipsis, models: list[list[object]] = Ellipsis, minimum_training_size: int = 10, train_options: dict = <factory>, score_options: dict = <factory>, steps: ~typing.Sequence[~typing.Collection[~examol.store.recipes.PropertyRecipe]] = (), pipeline_target: float = 0.1)

Bases: SingleFidelityActiveLearning

Tools needed for solving a multi-fidelity active learning problem

Users must define a series of recipes to be run at each step in the workflow, steps. The next step is run each time a molecule is selected for execution. For example, a Thinker would run all recipes in the first step for a molecule for which no data is available and then the second step of recipes after all from the first have completed.

The user also specifies a set fraction of entries to progress through each stage, which sets the probability of selecting a certain step in the calculation. For example a pipeline_target of 0.1 means that 10% of entries will pass through each stage of the pipeline. We can achieve this target by selecting to run the first stage of the pipeline 10 times more often then the next stage.

get_levels_for_property(recipe: PropertyRecipe) → list[PropertyRecipe]

Get the list of levels at which we compute a certain property

pipeline_target: float = 0.1

Fraction of entries to progress through each stage of the pipeline

steps: Sequence[Collection[PropertyRecipe]] = ()

Incremental steps to perform along the way to a maximum level of fidelity

class examol.solution.SingleFidelityActiveLearning(starter: ~examol.start.base.Starter = <examol.start.fast.RandomStarter object>, num_to_run: int = Ellipsis, selector: ~examol.select.base.Selector = Ellipsis, scorer: ~examol.score.base.Scorer = Ellipsis, models: list[list[object]] = Ellipsis, minimum_training_size: int = 10, train_options: dict = <factory>, score_options: dict = <factory>)

Bases: SolutionSpecification

Tools needed to solve a multi-objective problem using active learning

generate_functions() → list[Callable]

Generate functions to be run on compute nodes

Returns:

List of functions ready for use in a workflow system

minimum_training_size: int = 10

Minimum database size before starting training. Thinkers will run selections from starter before them

models: list[list[object]] = Ellipsis

List of machine learning models used to predict outcome of recipes.

models[i][j] is model ``j for property i

score_options: dict

Options passed to the score() function

scorer: Scorer = Ellipsis

Defines algorithms used to retrain and run models

selector: Selector = Ellipsis

How to identify which computation to perform next

train_options: dict

Options passed to the retrain() function

class examol.solution.SolutionSpecification(starter: ~examol.start.base.Starter = <examol.start.fast.RandomStarter object>, num_to_run: int = Ellipsis)

Bases: object

Define the components of a solution to a problem

generate_functions() → list[Callable]

Generate functions to be run on compute nodes

Returns:

List of functions ready for use in a workflow system

num_to_run: int = Ellipsis

Number of quantum chemistry computations to perform

starter: Starter = <examol.start.fast.RandomStarter object>

Pick a single random molecule

Type:

How to initialize the database if too small. Default