### SPOTPY Calibration Setup Class

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/api_reference/evolutionary.md

Handles the setup and execution of calibration procedures using SPOTPY.

```APIDOC
## class calisim.evolutionary.spotpy_wrapper.SPOTSetup

### Description
The SPOTPY calibration setup.

### Methods
* **evaluation() -> ndarray | DataFrame**: Get the observed data.
* **objectivefunction(simulation: ndarray | DataFrame, evaluation: ndarray | DataFrame) -> float**: Call the objective function on simulated and observed data.
* **parameters() -> ndarray**: Generate parameters from the prior specification.
* **setup_from_workflow(workflow: CalibrationWorkflowBase) -> None**: Configure the calibration procedure from the workflow object.
* **simulation(X: ndarray) -> ndarray**: Run the simulation.

### Parameters
* **workflow** (CalibrationWorkflowBase) - The calibration workflow object.
* **objective_function** (Callable) - The objective function to minimize.
* **evolutionary_name** (str) - The name of the evolutionary algorithm.

### Parameters for `objectivefunction` method:
* **simulation** (np.ndarray | pd.DataFrame) - The simulated data.
* **evaluation** (np.ndarray | pd.DataFrame) - The observed data.

### Parameters for `simulation` method:
* **X** (np.ndarray) - The simulation parameter vector.
```

--------------------------------

### Run Calisim Optimization Example with Docker

Source: https://github.com/plant-food-research-open/calisim/blob/main/README.md

Execute the Optuna optimization example using Docker Compose. Ensure the CALISIM_VERSION environment variable is set.

```bash
export CALISIM_VERSION=latest
wget https://raw.githubusercontent.com/Plant-Food-Research-Open/calisim/refs/heads/main/docker-compose.yaml
docker compose pull calisim
docker compose run --rm calisim python examples/optimisation/optuna_example.py
```

--------------------------------

### get_examples_outdir

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/api_reference/utils.md

Provides the designated output directory for calibration examples.

```APIDOC
## get_examples_outdir

### Description
Get the output directory for calibration examples.

### Method
GET

### Endpoint
/get_examples_outdir

### Response
#### Success Response (200)
- **output_directory** (str) - The output directory.

### Response Example
```json
{
  "output_directory": "/path/to/calibration/examples/output"
}
```
```

--------------------------------

### Install Calisim with Pip

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/basics/installation.md

Install the base Calisim package using pip. This is the simplest installation method.

```bash
pip install calisim
```

--------------------------------

### Install Calisim with PyTorch Extras

Source: https://context7.com/plant-food-research-open/calisim/llms.txt

Install Calisim with PyTorch extras for advanced Gaussian Process models and deep learning capabilities. This requires PyTorch to be installed.

```bash
pip install calisim[torch]
```

--------------------------------

### Install Calisim with TorchX Extras

Source: https://context7.com/plant-food-research-open/calisim/llms.txt

Install Calisim with TorchX extras for orchestration. This enables TorchX capabilities for managing and running experiments.

```bash
pip install calisim[torchx]
```

--------------------------------

### Install Calisim with Optional Dependencies

Source: https://github.com/plant-food-research-open/calisim/blob/main/README.md

Install Calisim using pip, with options to include extra dependencies like PyTorch, Hydra, or TorchX.

```bash
pip install calisim
```

```bash
# Install PyTorch extras
pip install calisim[torch]
```

```bash
# Install Hydra extras
pip install calisim[hydra]
```

```bash
# Install TorchX extras
pip install calisim[torchx]
```

```bash
# Install multiple extras
pip install calisim[torch,hydra,torchx]
```

--------------------------------

### Install Calisim with Multiple Extras

Source: https://context7.com/plant-food-research-open/calisim/llms.txt

Install Calisim with multiple optional dependencies, including PyTorch, Hydra, and TorchX. This provides a comprehensive set of features.

```bash
pip install calisim[torch,hydra,torchx]
```

--------------------------------

### Install Calisim with Hydra Extras

Source: https://context7.com/plant-food-research-open/calisim/llms.txt

Install Calisim with Hydra extras for configuration management. This integrates Calisim with Hydra's configuration system.

```bash
pip install calisim[hydra]
```

--------------------------------

### Example output of plugin verification

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/advanced/calibrator_plugins.ipynb

Shows the resulting DataFrame after verifying plugin registration, indicating the name, module, target class, and group of the registered 'optuna_extended' plugin.

```text
Result:
              name                               module  \
0  optuna_extended  calisim.optimisation.optuna_wrapper   

                       target                          group  
0  ExtendedOptunaOptimisation  calisim.external.optimisation  
```

--------------------------------

### Configure and Run Hyperparameter Optimization

Source: https://context7.com/plant-food-research-open/calisim/llms.txt

Sets up and executes a hyperparameter optimization workflow using the OptimisationMethod. This example uses the Lotka-Volterra model and the Optuna backend to minimize MeanSquaredError.

```python
import numpy as np
import pandas as pd
from calisim.data_model import (
    DistributionModel,
    ParameterDataType,
    ParameterSpecification,
)
from calisim.example_models import LotkaVolterraModel
from calisim.optimisation import OptimisationMethod, OptimisationMethodModel
from calisim.statistics import MeanSquaredError
from calisim.utils import get_examples_outdir

# Setup model and data
model = LotkaVolterraModel()
observed_data = model.get_observed_data()

# Define parameter search space
parameter_spec = ParameterSpecification(
    parameters=[
        DistributionModel(
            name="alpha",
            distribution_name="uniform",
            distribution_args=[0.45, 0.55],
            data_type=ParameterDataType.CONTINUOUS,
        ),
        DistributionModel(
            name="beta",
            distribution_name="uniform",
            distribution_args=[0.02, 0.03],
            data_type=ParameterDataType.CONTINUOUS,
        ),
    ]
)

# Define objective function
def objective(
    parameters: dict,
    simulation_id: str,
    observed_data: np.ndarray | None,
    t: pd.Series
) -> float:
    simulation_parameters = dict(
        h0=34.0, l0=5.9, t=t, gamma=0.84, delta=0.026
    )
    for k in ["alpha", "beta"]:
        simulation_parameters[k] = parameters[k]

    simulated_data = model.simulate(simulation_parameters).lynx.values
    metric = MeanSquaredError()
    return metric.calculate(observed_data, simulated_data)

# Configure optimization
specification = OptimisationMethodModel(
    experiment_name="optuna_optimisation",
    parameter_spec=parameter_spec,
    observed_data=observed_data.lynx.values,
    outdir=get_examples_outdir(),
    method="tpes",  # Tree-structured Parzen Estimator
    directions=["minimize"],
    n_iterations=100,
    method_kwargs=dict(n_startup_trials=50),
    calibration_func_kwargs=dict(t=observed_data.year),
)

# Run optimization workflow
calibrator = OptimisationMethod(
    calibration_func=objective,
    specification=specification,
    engine="optuna"  # Options: "optuna", "botorch", "emukit", "openturns"
)

calibrator.specify().execute().analyze()

# Get results
print(f"Parameter estimates: {calibrator.get_parameter_estimates()}")
print(f"Artifacts: {calibrator.get_artifacts()}")
```

--------------------------------

### Instantiate and Run OptimisationMethod Calibrator

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/advanced/calibrator_plugins.ipynb

Initializes the OptimisationMethod calibrator with the objective function and specification, setting the engine to 'optuna_extended'. This starts the calibration workflow.

```python
calibrator = OptimisationMethod(
	calibration_func=objective, specification=specification, engine="optuna_extended"
)
type(calibrator.implementation)
```

--------------------------------

### Get Implementations

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/api_reference/quadrature.md

Retrieves the available calibration implementations for quadrature methods.

```APIDOC
## calisim.quadrature.implementation.get_implementations()

### Description
Get the calibration implementations for quadrature.

### Returns
- **Dict[str, str]** - The dictionary of calibration implementations for quadrature.
```

--------------------------------

### ExampleModelBase Class

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/api_reference/base.md

Abstract base class for example simulation models.

```APIDOC
### class calisim.base.example_model_base.ExampleModelBase

### Description
The example simulation model abstract class.

### Abstract Base Classes
Abstract base classes are defined for the example simulation models.
```

--------------------------------

### Run SBI Calibration

Source: https://context7.com/plant-food-research-open/calisim/llms.txt

Executes a Simulation-Based Inference calibration process. Ensure the 'sbi' engine is installed.

```python
import numpy as np
import pandas as pd
from calisim.inference import (
    SimulationBasedInferenceMethod,
    SimulationBasedInferenceMethodModel,
)
from calisim.data_model import (
    DistributionModel,
    ParameterDataType,
    ParameterSpecification,
)
from calisim.example_models import LotkaVolterraModel
from calisim.utils import get_examples_outdir

model = LotkaVolterraModel()
observed_data = model.get_observed_data()

parameter_spec = ParameterSpecification(
    parameters=[
        DistributionModel(
            name="alpha",
            distribution_name="normal",
            distribution_args=[0.5, 0.04],
            data_type=ParameterDataType.CONTINUOUS,
        ),
        DistributionModel(
            name="beta",
            distribution_name="normal",
            distribution_args=[0.025, 0.003],
            data_type=ParameterDataType.CONTINUOUS,
        ),
    ]
)

def sbi_func(
    parameters: dict,
    simulation_id: str,
    observed_data: np.ndarray | None,
    t: pd.Series
) -> np.ndarray:
    simulation_parameters = dict(
        h0=34.0, l0=5.9, t=t, gamma=0.84, delta=0.026
    )
    for k in ["alpha", "beta"]:
        simulation_parameters[k] = parameters[k]

    return model.simulate(simulation_parameters).lynx.values

specification = SimulationBasedInferenceMethodModel(
    experiment_name="sbi_inference",
    parameter_spec=parameter_spec,
    observed_data=observed_data.lynx.values,
    outdir=get_examples_outdir(),
    n_samples=300,
    n_iterations=250,
    num_simulations=400,
    method="nsf",  # Neural Spline Flow
    verbose=True,
    calibration_func_kwargs=dict(t=observed_data.year),
    method_kwargs=dict(hidden_features=40, num_transforms=40),
)

calibrator = SimulationBasedInferenceMethod(
    calibration_func=sbi_func,
    specification=specification,
    engine="sbi"  # Options: "sbi", "lampe"
)

calibrator.specify().execute().analyze()
```

--------------------------------

### Run Evolutionary Algorithm Calibration

Source: https://context7.com/plant-food-research-open/calisim/llms.txt

Executes an evolutionary algorithm calibration using SPOTPY or EvoTorch. Ensure the specified engine is installed.

```python
import numpy as np
import pandas as pd
from calisim.evolutionary import (
    EvolutionaryMethod,
    EvolutionaryMethodModel,
)
from calisim.data_model import (
    DistributionModel,
    ParameterDataType,
    ParameterSpecification,
)
from calisim.example_models import LotkaVolterraModel
from calisim.utils import get_examples_outdir

model = LotkaVolterraModel()
observed_data = model.get_observed_data()

parameter_spec = ParameterSpecification(
    parameters=[
        DistributionModel(
            name="alpha",
            distribution_name="normal",
            distribution_args=[0.5, 0.04],
            data_type=ParameterDataType.CONTINUOUS,
        ),
        DistributionModel(
            name="beta",
            distribution_name="normal",
            distribution_args=[0.025, 0.003],
            data_type=ParameterDataType.CONTINUOUS,
        ),
    ]
)

def evolutionary_func(
    parameters: dict,
    simulation_id: str,
    observed_data: np.ndarray | None,
    t: pd.Series
) -> np.ndarray:
    simulation_parameters = dict(
        h0=34.0, l0=5.9, t=t, gamma=0.84, delta=0.026
    )
    for k in ["alpha", "beta"]:
        simulation_parameters[k] = parameters[k]

    return model.simulate(simulation_parameters).lynx.values

specification = EvolutionaryMethodModel(
    experiment_name="spotpy_evolutionary",
    parameter_spec=parameter_spec,
    observed_data=observed_data.lynx.values,
    outdir=get_examples_outdir(),
    n_samples=250,
    method="dream",  # DREAM algorithm
    objective="gaussianLikelihoodMeasErrorOut",
    verbose=True,
    calibration_func_kwargs=dict(t=observed_data.year),
    method_kwargs=dict(nChains=4, nCr=3, delta=1),
)

calibrator = EvolutionaryMethod(
    calibration_func=evolutionary_func,
    specification=specification,
    engine="spotpy"  # Options: "spotpy", "evotorch"
)

calibrator.specify().execute().analyze()
```

--------------------------------

### Construct Surrogate Model

Source: https://context7.com/plant-food-research-open/calisim/llms.txt

Builds surrogate models (emulators) using specified backends like scikit-learn or GPyTorch. Requires appropriate libraries to be installed.

```python
import numpy as np
import pandas as pd
import sklearn.gaussian_process.kernels as kernels
from calisim.surrogate import (
    SurrogateModelMethod,
    SurrogateModelMethodModel,
)
from calisim.data_model import (
    DistributionModel,
    ParameterDataType,
    ParameterSpecification,
)
from calisim.example_models import LotkaVolterraModel
from calisim.utils import get_examples_outdir

model = LotkaVolterraModel()
observed_data = model.get_observed_data()

parameter_spec = ParameterSpecification(
    parameters=[
        DistributionModel(
            name="alpha",
            distribution_name="uniform",
            distribution_args=[0.45, 0.55],
            data_type=ParameterDataType.CONTINUOUS,
        ),
        DistributionModel(
            name="beta",
            distribution_name="uniform",
            distribution_args=[0.02, 0.03],
            data_type=ParameterDataType.CONTINUOUS,
        ),
    ]
)

```

--------------------------------

### Calisim Lotka-Volterra Model Optimization Example

Source: https://github.com/plant-food-research-open/calisim/blob/main/README.md

This Python script demonstrates how to use Calisim for model calibration using the Lotka-Volterra model. It sets up parameter specifications, defines an objective function for optimization, and runs the calibration process.

```python
import numpy as np
import pandas as pd

from calisim.data_model import (
	DistributionModel,
	ParameterDataType,
	ParameterSpecification,
)
from calisim.example_models import LotkaVolterraModel
from calisim.optimisation import OptimisationMethod, OptimisationMethodModel
from calisim.statistics import MeanSquaredError
from calisim.utils import get_examples_outdir

# Get model
model = LotkaVolterraModel()
observed_data = model.get_observed_data()

# Specify model parameter distributions
parameter_spec = ParameterSpecification(
	parameters=[
		DistributionModel(
			name="alpha",
			distribution_name="uniform",
			distribution_args=[0.45, 0.55],
			data_type=ParameterDataType.CONTINUOUS,
		)
	]
)

# Define objective function
def objective(
	parameters: dict, simulation_id: str, observed_data: np.ndarray | None, t: pd.Series
) -> float | list[float]:
	simulation_parameters = dict(
		alpha=parameters["alpha"],
		beta=0.024, h0=34.0, l0=5.9,
		t=t, gamma=0.84, delta=0.026,
	)

	simulated_data = model.simulate(simulation_parameters).lynx.values
	metric = MeanSquaredError()
	discrepancy = metric.calculate(observed_data, simulated_data)
	return discrepancy

# Specify calibration parameter values
specification = OptimisationMethodModel(
	experiment_name="optuna_optimisation",
	parameter_spec=parameter_spec,
	observed_data=observed_data.lynx.values,
	outdir=get_examples_outdir(),
	method="tpes",
	directions=["minimize"],
	n_iterations=100,
	method_kwargs=dict(n_startup_trials=50),
	calibration_func_kwargs=dict(t=observed_data.year),
)

# Choose calibration engine
calibrator = OptimisationMethod(
	calibration_func=objective, specification=specification, engine="optuna"
)

# Run the workflow
calibrator.specify().execute().analyze()

# View the results
result_artifacts = "\n".join(calibrator.get_artifacts())
print(f"View results: \n{result_artifacts}")
print(f"Parameter estimates: {calibrator.get_parameter_estimates()}")
```

--------------------------------

### Configure Bayesian Calibration with MCMC

Source: https://context7.com/plant-food-research-open/calisim/llms.txt

Sets up Bayesian parameter inference using MCMC sampling with the BayesianCalibrationMethod. This example defines priors with bounds for the Lotka-Volterra model parameters.

```python
import numpy as np
import pandas as pd
from calisim.bayesian import (
    BayesianCalibrationMethod,
    BayesianCalibrationMethodModel,
)
from calisim.data_model import (
    DistributionModel,
    ParameterDataType,
    ParameterSpecification,
)
from calisim.example_models import LotkaVolterraModel
from calisim.statistics import GaussianLogLikelihood
from calisim.utils import get_examples_outdir

model = LotkaVolterraModel()
observed_data = model.get_observed_data()

# Define priors with bounds
parameter_spec = ParameterSpecification(
    parameters=[
        DistributionModel(
            name="alpha",
            distribution_name="normal",
            distribution_args=[0.5, 0.1],  # [mean, std]
            distribution_bounds=[0.3, 0.7],
            data_type=ParameterDataType.CONTINUOUS,
        ),
        DistributionModel(
            name="beta",
            distribution_name="normal",
            distribution_args=[0.025, 0.01],
            distribution_bounds=[0.01, 0.04],
            data_type=ParameterDataType.CONTINUOUS,
        ),
    ]
)

```

--------------------------------

### Perform Active Learning with ActiveLearningMethod

Source: https://context7.com/plant-food-research-open/calisim/llms.txt

Utilize ActiveLearningMethod for adaptive sampling to efficiently construct surrogate models. This example uses 'gp' as the method and 'greedy_sampling_target' as the query strategy with SHAP enabled. Specify initial samples, iterations, and candidate pool size.

```python
import numpy as np
import pandas as pd
from calisim.active_learning import (
    ActiveLearningMethod,
    ActiveLearningMethodModel,
)
from calisim.data_model import (
    DistributionModel,
    ParameterDataType,
    ParameterSpecification,
)
from calisim.example_models import LotkaVolterraModel
from calisim.utils import get_examples_outdir

model = LotkaVolterraModel()
observed_data = model.get_observed_data()

parameter_spec = ParameterSpecification(
    parameters=[
        DistributionModel(
            name="alpha",
            distribution_name="uniform",
            distribution_args=[0.45, 0.55],
            data_type=ParameterDataType.CONTINUOUS,
        ),
        DistributionModel(
            name="beta",
            distribution_name="uniform",
            distribution_args=[0.02, 0.03],
            data_type=ParameterDataType.CONTINUOUS,
        ),
    ]
)

def active_learning_func(
    parameters: dict,
    simulation_id: str,
    observed_data: np.ndarray | None,
    t: pd.Series
) -> np.ndarray:
    simulation_parameters = dict(
        h0=34.0, l0=5.9, t=t, gamma=0.84, delta=0.026
    )
    for k in ["alpha", "beta"]:
        simulation_parameters[k] = parameters[k]

    return model.simulate(simulation_parameters).lynx.values

specification = ActiveLearningMethodModel(
    experiment_name="skactiveml_al",
    parameter_spec=parameter_spec,
    observed_data=observed_data.lynx.values,
    outdir=get_examples_outdir(),
    n_init=20,             # Initial training samples
    n_iterations=10,       # Active learning iterations
    n_samples=50,          # Candidate pool size
    method="gp",
    query_strategy="greedy_sampling_target",
    use_shap=True,
    method_kwargs=dict(alpha=1e-10),
    calibration_func_kwargs=dict(t=observed_data.year),
)

calibrator = ActiveLearningMethod(
    calibration_func=active_learning_func,
    specification=specification,
    engine="skactiveml"
)

calibrator.specify().execute().analyze()
```

--------------------------------

### Import necessary libraries for TorchX and Calisim

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/advanced/torchx_jobs.ipynb

Imports required libraries including numpy, pandas, os, torchx, and various components from calisim. This setup is necessary for utilizing the TorchX job launcher with Calisim.

```python
import numpy as np
import pandas as pd
import os
import os.path as osp
import torchx

from calisim.data_model import OrchestrationModel
from calisim.orchestration import TorchXJobLauncher
from calisim.data_model import (
	DistributionModel,
	ParameterDataType,
	ParameterSpecification,
)
from calisim.abc import (
	ApproximateBayesianComputationMethod,
	ApproximateBayesianComputationMethodModel,
)
from calisim.statistics import L2Norm

import warnings
warnings.filterwarnings("ignore")
```

--------------------------------

### Run Calisim with Docker

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/basics/installation.md

Execute Calisim within a Docker container. This involves setting the version, downloading the docker-compose.yaml file, pulling the image, and running an example script.

```bash
export CALISIM_VERSION=latest

wget https://raw.githubusercontent.com/Plant-Food-Research-Open/calisim/refs/heads/main/docker-compose.yaml

docker compose pull calisim

docker compose run --rm calisim python examples/optimisation/optuna_example.py
```

--------------------------------

### Initialize and Run SALib Sensitivity Analysis

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/sir_sensitivity_analysis.ipynb

Instantiate the SensitivityAnalysisMethod calibrator with the defined function and specification, using the 'salib' engine. Then, execute the specify, execute, and analyze steps to perform the sensitivity analysis.

```python
calibrator = SensitivityAnalysisMethod(
	calibration_func=sensitivity_func, specification=specification, engine="salib"
)

calibrator.specify().execute().analyze()
```

--------------------------------

### Instantiate and Observe Model Data

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/advanced/custom_calibrators.ipynb

Instantiate the LotkaVolterraModel and retrieve its observed data. This is the first step in setting up the calibration process.

```python
model = LotkaVolterraModel()
observed_data = model.get_observed_data()
observed_data.head(5)
```

--------------------------------

### Initialize and Run OpenTurns Sensitivity Analysis

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/sir_sensitivity_analysis.ipynb

Instantiate the SensitivityAnalysisMethod calibrator with the wrapper function and OpenTurns specification, setting the engine to 'openturns'. Execute the calibration process to obtain sensitivity indices.

```python
calibrator = SensitivityAnalysisMethod(
	calibration_func=sensitivity_func, specification=specification, engine="openturns"
)

calibrator.specify().execute().analyze()
```

--------------------------------

### Get Implementations Function

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/api_reference/reliability.md

Retrieves available calibration implementations for reliability analysis.

```APIDOC
## calisim.reliability.implementation.get_implementations()

### Description
Get the calibration implementations for reliability analysis.

### Returns
- **dict[str, str]**: A dictionary mapping implementation names to their descriptions.
```

--------------------------------

### List Configuration Directory Contents

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/advanced/hydra_config.ipynb

Lists the contents of the 'conf' directory, showing the main config file and subdirectories for calibration, metric, and model.

```bash
! ls conf
```

--------------------------------

### Configure and Execute OpenTurns Optimization

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/sir_optimisation.ipynb

Set up the OptimisationMethodModel with OpenTurns' kriging method and execute the calibration process. Ensure parameter_spec and observed_data are defined beforehand.

```python
specification = OptimisationMethodModel(
	experiment_name="openturns_optimisation",
	parameter_spec=parameter_spec,
	observed_data=observed_data.dotI.values,
	method="kriging",
	n_init=20,
	n_iterations=25,
	n_out=1,
	directions=["minimize"],
	output_labels=["Number of Infected"],
    calibration_func_kwargs=dict(t=observed_data.day),
)

calibrator = OptimisationMethod(
	calibration_func=objective, specification=specification, engine="openturns"
)

calibrator.specify().execute().analyze()
```

--------------------------------

### Get Evolutionary Algorithm Implementations

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/api_reference/evolutionary.md

Retrieves a dictionary of available evolutionary algorithm implementations.

```APIDOC
## calisim.evolutionary.implementation.get_implementations()

### Description
Get the calibration implementations for evolutionary algorithm.

### Returns
* **Dict[str, str]** - A dictionary mapping implementation names to their descriptions.
```

--------------------------------

### Get Active Learning Implementations

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/api_reference/active_learning.md

Utility function to retrieve available active learning implementations.

```APIDOC
## calisim.active_learning.implementation.get_implementations()

### Description
Get the calibration implementations for active learning.

### Returns
- **dict[str, str]**: A dictionary of calibration implementations for active learning.
```

--------------------------------

### Instantiate Configuration Objects from YAML

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/advanced/hydra_config.ipynb

Constructs a configuration object by parsing YAML files and instantiating classes defined with '_target_' keys.

```python
cfg = hydra_config.get_configuration("config", "conf")
```

--------------------------------

### Get History Matching Implementations

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/api_reference/history_matching.md

Retrieves a dictionary of available calibration implementations for history matching. Use this to see which methods are supported.

```python
calisim.history_matching.implementation.get_implementations()
```

--------------------------------

### Initialize and Run Calibrator

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/sir_optimisation.ipynb

Instantiate the OptimisationMethod calibrator with the objective function and specification, then execute the calibration process using the 'specify', 'execute', and 'analyze' methods.

```python
calibrator = OptimisationMethod(
	calibration_func=objective, specification=specification, engine="emukit"
)

calibrator.specify().execute().analyze()
```

--------------------------------

### Verify plugin registration

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/advanced/calibrator_plugins.ipynb

Uses `entry_points()` to retrieve and display registered plugins for the 'calisim.external.optimisation' group. The output confirms that 'optuna_extended' is correctly mapped to the 'ExtendedOptunaOptimisation' class.

```python
pd.DataFrame([
    {
        "name": entrypoint.name, 
        "module": entrypoint.value.split(":")[0],
        "target": entrypoint.value.split(":")[1],
        "group": entrypoint.group 
    }
    for entrypoint in entry_points().select(group="calisim.external.optimisation") 
])
```

--------------------------------

### Get Observed Data from LotkaVolterraModel

Source: https://context7.com/plant-food-research-open/calisim/llms.txt

Retrieve historical observed data (lynx and hare populations by year) from the LotkaVolterraModel. The data spans from 1900 to 1920.

```python
# Get historical observed data (1900-1920 lynx-hare populations)
observed_data = model.get_observed_data()
print(observed_data.head())
# Output:
#     year  lynx  hare
# 0  1900.0   4.0  30.0
# 1  1901.0   6.1  47.2
# 2  1902.0   9.8  70.2
# ...

```

--------------------------------

### Configure and Run Bayesian Calibration

Source: https://context7.com/plant-food-research-open/calisim/llms.txt

Sets up and executes Bayesian calibration using the emcee engine. Requires a log-density function and parameter specifications.

```python
def bayesian_func(
    parameters: dict,
    simulation_id: str,
    observed_data: np.ndarray | None,
    t: pd.Series
) -> float:
    simulation_parameters = dict(
        h0=34.0, l0=5.9, t=t, gamma=0.84, delta=0.026
    )
    for k in ["alpha", "beta"]:
        simulation_parameters[k] = parameters[k]

    simulated_data = model.simulate(simulation_parameters).lynx.values
    metric = GaussianLogLikelihood()
    return metric.calculate(observed_data, simulated_data)

# Configure Bayesian calibration
specification = BayesianCalibrationMethodModel(
    experiment_name="emcee_bayesian_calibration",
    parameter_spec=parameter_spec,
    observed_data=observed_data.lynx.values,
    outdir=get_examples_outdir(),
    n_iterations=100,      # MCMC iterations
    n_samples=32,          # Number of walkers
    n_jobs=1,
    log_density=False,     # Return log-likelihood directly
    verbose=True,
    calibration_func_kwargs=dict(t=observed_data.year),
)

# Run MCMC sampling
calibrator = BayesianCalibrationMethod(
    calibration_func=bayesian_func,
    specification=specification,
    engine="emcee"  # Options: "emcee", "dynesty", "openturns"
)

calibrator.specify().execute().analyze()

# Access posterior samples
print(f"Parameter estimates: {calibrator.get_parameter_estimates()}")
```

--------------------------------

### Get Calibration Implementations for Optimisation

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/api_reference/optimisation.md

Retrieves a dictionary of available calibration implementations for optimisation tasks. This function is useful for understanding which optimisation backends are supported.

```python
get_implementations()
```

--------------------------------

### Configure SALib Sensitivity Analysis Specification

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/sir_sensitivity_analysis.ipynb

Set up the specification for a SALib-based Sobol sensitivity analysis. This includes experiment name, parameter specification, observed data, method, sample size, output labels, and method-specific arguments.

```python
specification = SensitivityAnalysisMethodModel(
	experiment_name="salib_sensitivity_analysis",
	parameter_spec=parameter_spec,
    observed_data=observed_data.dotI.values,
	method="sobol",
	n_samples=256,
	output_labels=["Number of Infected"],
    calibration_func_kwargs=dict(t=observed_data.day),
	method_kwargs=dict(calc_second_order=False, scramble=True),
	analyze_kwargs=dict(
		calc_second_order=False,
		num_resamples=300,
		conf_level=0.95,
	),
)
```

--------------------------------

### Run Calibration Workflow

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/advanced/custom_calibrators.ipynb

Instantiate the OptimisationMethod calibrator with the objective function and specification, then execute the calibration workflow by calling specify(), execute(), and analyze().

```python
calibrator = OptimisationMethod(
	calibration_func=objective, 
    specification=specification, 
    implementation=SciPyDEOptimisation
)

calibrator.specify().execute().analyze()
```

--------------------------------

### Import necessary libraries for Calisim

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/advanced/custom_calibrators.ipynb

Imports essential libraries for data manipulation, plotting, optimization, and Calisim's core components. Ensure these are installed before use.

```python
from matplotlib import pyplot as plt
import numpy as np
import pandas as pd
from scipy.optimize import differential_evolution

from calisim.base import CalibrationWorkflowBase
from calisim.data_model import (
	DistributionModel,
	ParameterDataType,
	ParameterSpecification,
)
from calisim.data_model import ParameterDataType, ParameterEstimateModel

from calisim.example_models import LotkaVolterraModel
from calisim.optimisation import OptimisationMethod, OptimisationMethodModel
from calisim.statistics import MeanSquaredError

import warnings
warnings.filterwarnings("ignore")
```

--------------------------------

### Define Parameter Specification for Calibration

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/advanced/custom_calibrators.ipynb

Define the parameter specification including parameter names, data types, distribution types, and bounds. This guides the optimization process.

```python
parameter_spec = ParameterSpecification(
	parameters=[
		DistributionModel(
			name="alpha",
			distribution_name="uniform",
			distribution_args=[0.45, 0.55],
			data_type=ParameterDataType.CONTINUOUS,
		),
		DistributionModel(
			name="beta",
			distribution_name="uniform",
			distribution_args=[0.02, 0.03],
			data_type=ParameterDataType.CONTINUOUS,
		),
	]
)
```

--------------------------------

### Configure OptimisationMethodSpecification

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/advanced/calibrator_plugins.ipynb

Sets up the specification for the optimization procedure, including experiment name, parameter specification, observed data, optimization method (e.g., 'nsgaiii'), directions, number of iterations, and calibration function arguments.

```python
specification = OptimisationMethodModel(
	experiment_name="optuna_extended_optimisation",
	parameter_spec=parameter_spec,
	observed_data=observed_data.lynx.values,
	method="nsgaiii",
	directions=["minimize"],
	n_iterations=100,
	calibration_func_kwargs=dict(t=observed_data.year),
)
```

--------------------------------

### Instantiate and Execute Calibration Workflow

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/advanced/hydra_config.ipynb

Instantiates a calibrator object, specifies calibration parameters, executes the calibration, and analyzes the results. The `calibration_func` is dynamically specified using the previously defined objective function. Ensure `observed_data` is available.

```python
calibrator = cfg["calibration"](calibration_func=objective)
calibrator.specification.calibration_func_kwargs=dict(t=observed_data.year)
calibrator.specification.observed_data=observed_data.lynx.values
calibrator.specify().execute().analyze()
```

--------------------------------

### Configure Uncertainty Analysis Method (Sobol)

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/sir_uncertainty_analysis.ipynb

Set up the uncertainty analysis specification using the 'sobol' method and 'linear' solver. This configuration is used to initialize the UncertaintyAnalysisMethod calibrator.

```python
specification = UncertaintyAnalysisMethodModel(
	experiment_name="chaospy_uncertainty_analysis",
	parameter_spec=parameter_spec,
	observed_data=observed_data.dotI.values,
	solver="linear",
	algorithm="least_squares",
	method="sobol",
	order=2,
	n_samples=200,
	output_labels=["Number of Infected"],
	calibration_func_kwargs=dict(t=observed_data.day)
)

calibrator = UncertaintyAnalysisMethod(
	calibration_func=uncertainty_func, specification=specification, engine="chaospy"
)
```

--------------------------------

### Run Calisim Docker Image with PyTorch

Source: https://github.com/plant-food-research-open/calisim/blob/main/README.md

Pull and run the Calisim Docker image with PyTorch dependencies included. This command is used for specific examples that require PyTorch.

```bash
# Pull and run the image with PyTorch dependencies included
# docker compose pull calisim_torch
# docker compose run --rm calisim_torch python examples/optimisation/botorch_example.py
```

--------------------------------

### Run Simulation with Custom Parameters

Source: https://context7.com/plant-food-research-open/calisim/llms.txt

Run a simulation using the LotkaVolterraModel with custom parameters for prey growth rate, predation rate, predator death rate, predator growth rate, and initial populations. The time points are set to match the observed data years.

```python
# Run simulation with custom parameters
simulation_parameters = {
    "alpha": 0.52,    # Prey growth rate
    "beta": 0.024,    # Predation rate
    "gamma": 0.84,    # Predator death rate
    "delta": 0.026,   # Predator growth rate
    "h0": 34.0,       # Initial hare population
    "l0": 5.9,        # Initial lynx population
    "t": observed_data.year,  # Time points
}

simulated_data = model.simulate(simulation_parameters)
print(simulated_data.head())
# Output:
#        lynx       hare
# 0   5.900000  34.000000
# 1   6.234567  35.123456
# ...

```

--------------------------------

### Import Dependencies for Calisim Sensitivity Analysis

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/sir_sensitivity_analysis.ipynb

Imports required classes and functions from calisim, numpy, pandas, and scipy for sensitivity analysis and SIR model simulation. Ensure these libraries are installed.

```python
from calisim.data_model import (
	DistributionModel,
	ParameterDataType,
	ParameterSpecification,
)
from calisim.example_models import SirOdesModel
from calisim.sensitivity import (
	SensitivityAnalysisMethod,
	SensitivityAnalysisMethodModel,
)
import numpy as np
import pandas as pd
from scipy.integrate import solve_ivp
```

--------------------------------

### Import Dependencies for Calisim Uncertainty Analysis

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/sir_uncertainty_analysis.ipynb

Import necessary classes and functions from calisim, numpy, pandas, and scipy for uncertainty analysis and SIR model simulation. Ensure these libraries are installed.

```python
from calisim.data_model import (
	DistributionModel,
	ParameterDataType,
	ParameterSpecification,
)
from calisim.example_models import SirOdesModel
from calisim.uncertainty import (
	UncertaintyAnalysisMethod,
	UncertaintyAnalysisMethodModel,
)
import numpy as np
import pandas as pd
from scipy.integrate import solve_ivp
```

--------------------------------

### Initialize LotkaVolterraModel

Source: https://context7.com/plant-food-research-open/calisim/llms.txt

Initialize the built-in LotkaVolterraModel, which simulates predator-prey dynamics. This model comes with historical lynx-hare population data.

```python
from calisim.example_models import LotkaVolterraModel
import numpy as np

# Initialize model
model = LotkaVolterraModel()
```

--------------------------------

### Configure Uncertainty Analysis Method (Quadrature)

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/sir_uncertainty_analysis.ipynb

Modify the uncertainty analysis specification to use 'quadrature' solver and 'grid' method for comparison. This allows for evaluating different analysis approaches with minimal code changes.

```python
specification.solver="quadrature"
specification.method="grid"

calibrator = UncertaintyAnalysisMethod(
	calibration_func=uncertainty_func, specification=specification, engine="chaospy"
)
```

--------------------------------

### Instantiate SIR Model and Display Ground Truth Parameters

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/sir_approximate_bayesian_computation.ipynb

Creates an instance of the SirOdesModel and displays its ground-truth parameters used for simulation. These parameters define the simulation's baseline behavior.

```python
model = SirOdesModel()
pd.DataFrame(model.GROUND_TRUTH, index=[0])
```

--------------------------------

### Initialize Calibrator with Surrogate Model

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/sir_surrogate_model.ipynb

Initialize the SurrogateMethod calibrator using the defined calibration function, specification, and the scikit-learn engine for surrogate modelling.

```python
calibrator = SurrogateMethod(
	calibration_func=surrogate_modelling_func,
	specification=specification,
	engine="sklearn",
)
```

--------------------------------

### TorchX Scheduler Options Table

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/advanced/torchx_jobs.ipynb

Presents a table of available TorchX scheduler options, including local and cluster-based execution environments.

```python
Result:
                 0
0     local_docker
1        local_cwd
2            slurm
3       kubernetes
4  kubernetes_mcad
5        aws_batch
6    aws_sagemaker
7              lsf
```

--------------------------------

### Initialize and Run History Matching Calibrator (SIES)

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/sir_history_matching.ipynb

Initialize the `HistoryMatchingMethod` calibrator with the defined wrapper function and specification, using the 'ies' engine. The calibration process is then executed in three steps: specify, execute, and analyze.

```python
calibrator = HistoryMatchingMethod(
	calibration_func=history_matching_func, specification=specification, engine="ies"
)

calibrator.specify().execute().analyze()
```

--------------------------------

### Initialize Random Forest Surrogate Model

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/sir_surrogate_model.ipynb

Set the method to 'rf' and initialize the SurrogateModelMethod with the scikit-learn engine to use a Random Forest model for calibration.

```python
specification.method = "rf"

calibrator = SurrogateModelMethod(
	calibration_func=surrogate_modelling_func,
	specification=specification,
	engine="sklearn",
)

calibrator.specify().execute().analyze()
```

--------------------------------

### List Available TorchX Schedulers

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/advanced/torchx_jobs.ipynb

Retrieves and displays the keys of available TorchX scheduler factories. Useful for understanding distributed execution options.

```python
pd.DataFrame(torchx.schedulers.get_scheduler_factories().keys())
```

--------------------------------

### Calibration Workflow API

Source: https://context7.com/plant-food-research-open/calisim/llms.txt

Demonstrates the unified specify-execute-analyze workflow pattern for all calibration methods. Shows how to access results, artifacts, and internal data.

```python
from calisim.optimisation import OptimisationMethod, OptimisationMethodModel

# Create calibrator
calibrator = OptimisationMethod(
    calibration_func=objective,
    specification=specification,
    engine="optuna"
)

# Execute workflow (fluent API)
calibrator.specify().execute().analyze()

# Access results
parameter_estimates = calibrator.get_parameter_estimates()
# Returns: ParameterEstimatesModel(estimates=[
#     ParameterEstimateModel(name="alpha", estimate=0.52, uncertainty=0.01),
#     ParameterEstimateModel(name="beta", estimate=0.024, uncertainty=0.001),
# ])

# Get output artifacts (plots, files)
artifacts = calibrator.get_artifacts()
# Returns: ["outdir/2024-01-01-optimisation-experiment-contour.png", ...]

# Access internal data
X = calibrator.get_X()              # Parameter values (np.ndarray)
Y = calibrator.get_Y()              # Simulation outputs (np.ndarray)
observed = calibrator.get_observed_data()  # Observed data
sim_ids = calibrator.get_simulation_ids()  # Simulation UUIDs

# For surrogate methods
emulator = calibrator.get_emulator()  # Trained surrogate model
sampler = calibrator.get_sampler()    # Parameter sampler
samples = calibrator.sample_parameters(n_samples=100)  # New samples
```

--------------------------------

### Configure History Matching Method Model (SIES)

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/sir_history_matching.ipynb

Set up the `HistoryMatchingMethodModel` specification for the calibration procedure, specifying the experiment name, parameter specification, observed data, method (e.g., 'sies'), number of samples, iterations, output labels, and covariance matrix.

```python
specification = HistoryMatchingMethodModel(
	experiment_name="ies_history_matching",
	parameter_spec=parameter_spec,
	observed_data=observed_data.dotI.values,
	method="sies",
	n_samples=50,
	n_iterations=8,
	output_labels=["Number of Infected"],

covariance=np.eye(observed_data.dotI.values.shape[0]),
	calibration_func_kwargs=dict(t=observed_data.day),
)
```

--------------------------------

### Configure and Run Approximate Bayesian Computation

Source: https://context7.com/plant-food-research-open/calisim/llms.txt

Sets up and executes ABC using the PyMC engine. Requires a custom simulator function and parameter specifications.

```python
specification = ApproximateBayesianComputationMethodModel(
    experiment_name="pymc_abc",
    parameter_spec=parameter_spec,
    observed_data=observed_data.lynx.values,
    outdir=get_examples_outdir(),
    n_samples=100,
    n_chains=2,
    epsilon=0.1,           # Acceptance threshold
    sum_stat="identity",   # Summary statistic
    verbose=True,
    calibration_func_kwargs=dict(t=observed_data.year),
    method_kwargs=dict(compute_convergence_checks=True),
)

calibrator = ApproximateBayesianComputationMethod(
    calibration_func=abc_func,
    specification=specification,
    engine="pymc"  # Options: "pymc", "pyabc"
)

calibrator.specify().execute().analyze()
```

--------------------------------

### Initialize and Run Calibrator

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/sir_approximate_bayesian_computation.ipynb

Initialize the ApproximateBayesianComputationMethod calibrator with the defined calibration function and specification. The calibration process is then executed by calling specify(), execute(), and analyze().

```python
calibrator = ApproximateBayesianComputationMethod(
	calibration_func=abc_func, specification=specification, engine="pyabc"
)
```

```python
import logging
logging.getLogger("pyabc").setLevel(logging.INFO)
calibrator.specify().execute().analyze()
```

--------------------------------

### Configure and Execute Bayesian Optimization Calibration

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/advanced/hydra_config.ipynb

Sets up a calibration workflow using Bayesian optimization with a Kriging surrogate model via the OpenTurns engine. This involves configuring the calibration settings and then executing the calibration process.

```python
cfg = hydra_config.get_configuration(
    "config", 
    "conf", 
    overrides=[
        "calibration.engine=openturns",
        "+calibration.specification.method=kriging",
        "calibration.specification.method_kwargs=null"
    ]
)
metric = cfg["metric"]
model = cfg["model"]
observed_data = model.get_observed_data()

def objective(
	parameters: dict, simulation_id: str, observed_data: np.ndarray | None, t: pd.Series
) -> float | list[float]:
	simulation_parameters = dict(h0=34.0, l0=5.9, t=t, gamma=0.84, delta=0.026)

	for k in ["alpha", "beta"]:
		simulation_parameters[k] = parameters[k]

	simulated_data = model.simulate(simulation_parameters).lynx.values
	discrepancy = metric.calculate(observed_data, simulated_data)
	return discrepancy

calibrator = cfg["calibration"](calibration_func=objective)
calibrator.specification.calibration_func_kwargs=dict(t=observed_data.year)
calibrator.specification.observed_data=observed_data.lynx.values
calibrator.specify().execute().analyze()
```

--------------------------------

### Register Calisim plugin using Poetry's pyproject.toml

Source: https://github.com/plant-food-research-open/calisim/blob/main/docs/source/tutorials/usage/advanced/calibrator_plugins.ipynb

Alternative configuration for pyproject.toml when using Poetry, registering the ExtendedOptunaOptimisation class as a plugin under the 'calisim.external.optimisation' group.

```toml
[tool.poetry.plugins."calisim.external.optimisation"]
optuna_extended = "calisim.optimisation.optuna_wrapper:ExtendedOptunaOptimisation"
```