SBArchOpt

https://sbarchopt.readthedocs.io/en/stable/
Admin
SBArchOpt is a Python library providing classes and interfaces for applying surrogate-based...
Tokens:41,775
Snippets:265
Trust Score:9.6
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install arch_sbo dependencies with pip

Source: https://sbarchopt.readthedocs.io/en/stable/tutorial

Install the optional dependencies required for the ArchSBO algorithm. Run this command before using the ArchSBO example.

```bash
pip install sb-arch-opt[arch_sbo]
```

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

### Install sb-arch-opt with BoTorch support

Source: https://sbarchopt.readthedocs.io/en/stable/algo/botorch

Install the package with the botorch extra to enable BoTorch functionality.

```bash
pip install sb-arch-opt[botorch]

```

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

### Install sb-arch-opt with Egor support

Source: https://sbarchopt.readthedocs.io/en/stable/algo/egor

Install the sb-arch-opt package with the egor extra to enable the Egor optimizer interface.

```bash
pip install sb-arch-opt[egor]

```

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

### Install HEBO with pip

Source: https://sbarchopt.readthedocs.io/en/stable/algo/hebo

Install the sb-arch-opt package with the HEBO extra using pip.

```bash
pip install sb-arch-opt[hebo]

```

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

### Install ArchSBO with pip

Source: https://sbarchopt.readthedocs.io/en/stable/algo/arch_sbo

Install the sb-arch-opt package with the arch_sbo extra to use the ArchSBO algorithm.

```bash
pip install sb-arch-opt[arch_sbo]

```

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

### Getting a ready-to-use NSGA2

Source: https://sbarchopt.readthedocs.io/en/stable/algo/pymoo

Retrieves a pre-configured NSGA2 algorithm instance.

```python
from sb_arch_opt.algo.pymoo_interface import get_nsga2

nsga2 = get_nsga2(pop_size=100)
```

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

### Install TPE algorithm

Source: https://sbarchopt.readthedocs.io/en/stable/algo/tpe

Use pip to install the package with the TPE dependency.

```bash
pip install sb-arch-opt[tpe]
```

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

### Initialize and run TPE algorithm

Source: https://sbarchopt.readthedocs.io/en/stable/algo/tpe

Configure the TPEAlgorithm with a results folder and integrate it with the pymoo minimize interface. The example demonstrates initializing from previous results to skip initial evaluations.

```python
from pymoo.optimize import minimize
from sb_arch_opt.algo.tpe_interface import *

problem = ...  # Subclass of ArchOptProblemBase

# Enable intermediate results storage
results_folder_path = 'path/to/results/folder'

# Get TPE algorithm
n_init = 100
algo = TPEAlgorithm(n_init=n_init, results_folder=results_folder_path)

# Start from previous results (skipped if no previous results are available)
if initialize_from_previous_results(algo, problem, results_folder_path):
    # No need to evaluate any initial points, as they already have been evaluated
    n_init = 0

n_infill = 10
result = minimize(problem, algo, termination=('n_eval', n_init + n_infill))
```

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

### Run Evolutionary Algorithm (SBO) Optimization

Source: https://sbarchopt.readthedocs.io/en/stable/tutorial

This example initializes a HierZDT1Small problem, configures the SBO algorithm with parallel evaluation, and executes the optimization process.

```python
from sb_arch_opt.algo.pymoo_interface import plot from pymoo.optimize import minimize from sb_arch_opt.problems.hierarchical import HierZDT1Small from sb_arch_opt.algo.arch_sbo.api import get_arch_sbo_gp # Create the problem problem = HierZDT1Small() # Create the algorithm (with an initial database size of 10*n_var = 10*6 = 60) n_init = problem.n_var*10 sbo = get_arch_sbo_gp(problem, n_parallel=4, init_size=n_init) # Run the optimization: 100 infill points (60 + 100 = 160 evaluations) # NOTE: remove "seed" argument when using in production! n_infill = 100 result_sbo = minimize(problem, sbo, termination=('n_eval', n_init+n_infill), seed=42) # Plot results plot(result_nsga2.opt.get('F'), result_sbo.opt.get('F'), labels=['NSGA2 (2000 evaluations)', 'SBO (160 evaluations)'])
```

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

### Install SBArchOpt Package

Source: https://sbarchopt.readthedocs.io/en/stable

Install the required dependencies and the SBArchOpt package via Conda and pip.

```bash
conda install numpy
pip install sb-arch-opt
```

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

### Continue optimization from previous DoE results

Source: https://sbarchopt.readthedocs.io/en/stable/tutorial

Example of loading previous results and continuing an NSGA2 optimization.

```python
# Continue with an optimization from previous DoE results nsga2 = get_nsga2(pop_size=100) initialize_from_previous_results(nsga2, problem, results_folder) result = minimize(problem, nsga2, termination=('n_gen', 10), copy_algorithm=False, seed=42) assert abs(nsga2.evaluator.n_eval - 1100) < 10 # 200 from DoE + 9*100 from optimization plot(problem.pareto_front(), result.opt.get('F'), labels=['Known Pareto front', 'NSGA2 (10 gen)'])
```

```text
INFO     2025-12-01 16:24:26,393 sb_arch_opt.pymoo : Previous results loaded from pymoo results: 200 design points
INFO     2025-12-01 16:24:26,393 sb_arch_opt.pymoo : Evaluation status: 200 of 200 (100.0%) are already evaluated
```

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

### Install Trieste via pip

Source: https://sbarchopt.readthedocs.io/en/stable/algo/trieste

Use this command to install the Trieste library as part of the sb-arch-opt package.

```bash
pip install sb-arch-opt[trieste]
```

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

### Implement Jenatton Test Problem Implicitly

Source: https://sbarchopt.readthedocs.io/en/stable/tutorial

This example demonstrates how to implement a hierarchical architecture optimization problem by extending ArchOptProblemBase and defining custom correction functions for variable activeness.

```python
import numpy as np
from pymoo.core.variable import Real, Choice
from sb_arch_opt.problem import ArchOptProblemBase


# Define the evaluation function
# You can clearly see the hierarchical structure
def jenatton_evaluate(x):
     if x[0] == 0:
          if x[1] == 0:
               return x[3]**3 + .1 + x[7]
          else:
               return x[4]**3 + .1 + x[7]
     else:
          if x[2] == 0:
               return x[5]**3 + .1 + x[8]
          else:
               return x[6]**3 + .1 + x[8]


class JenattonImplicit(ArchOptProblemBase):

     def __init__(self):
          # Define the design variables using pymoo variable classes
          des_vars = [
               Choice(options=[0, 1]), Choice(options=[0, 1]), Choice(options=[0, 1]),  # x1,2,3
               Real(bounds=[0, 1]), Real(bounds=[0, 1]), Real(bounds=[0, 1]),  # x4,5,6
               Real(bounds=[0, 1]), Real(bounds=[0, 1]), Real(bounds=[0, 1]),  # x7,8,9
          ]

          super().__init__(des_vars=des_vars)

     def _arch_evaluate(self, x: np.ndarray, is_active_out: np.ndarray, f_out: np.ndarray, g_out: np.ndarray,
                        h_out: np.ndarray, *args, **kwargs):
          """
          Implement evaluation and write results in the provided output matrices:
          - x (design vectors): discrete variables have integer values, imputed design vectors can be output here
          - is_active (activeness): vector specifying for each design variable whether it was active or not
          - f (objectives): written as a minimization
          - g (inequality constraints): written as "<= 0"
          - h (equality constraints): written as "= 0"
          """

          # Call the correction function to output which variables are inactive
          self._correct_x_impute(x, is_active_out)

          # Evaluate the design vectors
          for i, xi in enumerate(x):
               f_out[i, 0] = jenatton_evaluate(xi)

     def _correct_x(self, x: np.ndarray, is_active: np.ndarray):
          """Fill the activeness matrix and (if needed) impute any design variables that are partially inactive.
          Imputation of inactive design variables is always applied after this function."""

          # Start from everything inactive except the first variable
          is_active[:, 1:] = False

          # First branch
          branch1_1 = x[:, 0] == 0
          branch1_2 = x[:, 0] == 1

          is_active[branch1_1, 1] = True  # x2 and x8 are active in branch 1,1
          is_active[branch1_1, 7] = True
          is_active[branch1_2, 2] = True  # x3 and x9 are active in branch 1,2
          is_active[branch1_2, 8] = True

          # x1 and x2 branch
          branch2_1 = branch1_1 & (x[:, 1] == 0)
          branch2_2 = branch1_1 & (x[:, 1] == 1)
          branch2_3 = branch1_2 & (x[:, 2] == 0)
          branch2_4 = branch1_2 & (x[:, 2] == 1)

          is_active[branch2_1, 3] = True
          is_active[branch2_2, 4] = True
          is_active[branch2_3, 5] = True
          is_active[branch2_4, 6] = True

     def _is_conditionally_active(self):
          """Return for each design variable whether it is conditionally active (i.e. might become inactive). Not needed
          if an explicit design space is provided."""
          # Only the first variable never becomes inactive
          return [False if i == 0 else True for i in range(self.n_var)]

     def _get_n_active_cont_mean(self) -> int:
          """Get the mean number of active continuous dimensions, as seen over all discrete design vectors."""
          # Each of the four discrete branches has 2 active continuous variables
          return 2

     def _get_n_valid_discrete(self) -> int:
          """Return the number of valid discrete design points (ignoring continuous dimensions); enables calculation of
          the imputation ratio. Not needed if an explicit design space is provided."""
          return 4

     def __repr__(self):
          return f'{self.__class__.__name__}()'

JenattonImplicit().print_stats()
```

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

### Use get_hebo_optimizer to run HEBO optimization

Source: https://sbarchopt.readthedocs.io/en/stable/algo/hebo

Shows how to create a HEBO optimizer interface for an ArchOptProblemBase subclass, run the optimization loop, and extract the results as a pymoo Population object. The example uses n_init=100 and n_infill=50 with a fixed seed.

```python
from sb_arch_opt.algo.hebo_interface import get_hebo_optimizer

problem = ...  # Subclass of ArchOptProblemBase

# Get the interface and optimization loop
hebo = get_hebo_optimizer(problem, n_init=100, seed=42)

# Run the optimization loop
hebo.optimize(n_infill=50)

# Extract data as a pymoo Population object
pop = hebo.pop

```

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

### Initialize temporary directory for SBO

Source: https://sbarchopt.readthedocs.io/en/stable/tutorial

Sets up a temporary directory to store SBO results.

```python
td_sbo = tempfile.TemporaryDirectory()
results_folder = td_sbo.name
```

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

### ArchOptNSGA2(pop_size=100, sampling=HierarchicalSampling(), repair=ArchOptRepair(), mating=MixedDiscreteMating(repair=ArchOptRepair(), eliminate_duplicates=LargeDuplicateElimination()), eliminate_duplicates=LargeDuplicateElimination(), survival=RankAndCrowdingSurvival(), output=EHVMultiObjectiveOutput(), results_folder=None, **kwargs)

Source: https://sbarchopt.readthedocs.io/en/stable/api/pymoo

NSGA2 preconfigured with mixed-variable operators and other architecture optimization measures.

```APIDOC
## ArchOptNSGA2(pop_size=100, sampling=HierarchicalSampling(), repair=ArchOptRepair(), mating=MixedDiscreteMating(repair=ArchOptRepair(), eliminate_duplicates=LargeDuplicateElimination()), eliminate_duplicates=LargeDuplicateElimination(), survival=RankAndCrowdingSurvival(), output=EHVMultiObjectiveOutput(), results_folder=None, **kwargs)

### Description
NSGA2 preconfigured with mixed-variable operators and other architecture optimization measures.

### Parameters
- **pop_size** (int) - Optional - Population size (default 100).
- **sampling** - Optional - Sampling strategy (default HierarchicalSampling()).
- **repair** - Optional - Repair operator (default ArchOptRepair()).
- **mating** - Optional - Mating strategy (default MixedDiscreteMating with repair and duplicate elimination).
- **eliminate_duplicates** - Optional - Duplicate elimination strategy (default LargeDuplicateElimination()).
- **survival** - Optional - Survival strategy (default RankAndCrowdingSurvival()).
- **output** - Optional - Output strategy (default EHVMultiObjectiveOutput()).
- **results_folder** - Optional - Folder to store results.
- **kwargs** - Additional keyword arguments.

### Returns
- ArchOptNSGA2 instance.
```

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

### g property

Source: https://sbarchopt.readthedocs.io/en/stable/api/egor

Gets the inequality constraints.

```APIDOC
## g property

### Description
Inequality constraints.

### Returns
- **g** (np.ndarray) - The inequality constraints.
```

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

### Initialize Algorithm with Results Folder

Source: https://sbarchopt.readthedocs.io/en/stable/tutorial

Creates an NSGA2 algorithm instance with a specified results folder and runs it for a set number of generations.

```python
import tempfile

# We create a temporary folder for demonstration purposes
td = tempfile.TemporaryDirectory()
results_folder = td.name

# Create the algorithm with the results folder
nsga2 = get_nsga2(pop_size=100, results_folder=results_folder)

# Run for a few generations
result5 = minimize(problem, nsga2, termination=('n_gen', 5), copy_algorithm=False, seed=42)

assert abs(nsga2.evaluator.n_eval - 500) < 10  # 5*100
plot(problem.pareto_front(), result5.opt.get('F'),
     labels=['Known Pareto front', 'NSGA2 (5 gen)'])
```

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

### f property

Source: https://sbarchopt.readthedocs.io/en/stable/api/egor

Gets the objective values.

```APIDOC
## f property

### Description
Objective values.

### Returns
- **f** (np.ndarray) - The objective values.
```

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

### x property

Source: https://sbarchopt.readthedocs.io/en/stable/api/egor

Gets the design vectors.

```APIDOC
## x property

### Description
Design vectors.

### Returns
- **x** (np.ndarray) - The design vectors.
```

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

### Continue optimization from previous DoE results

Source: https://sbarchopt.readthedocs.io/en/stable/tutorial

Initializes an NSGA2 algorithm from previous DoE results and continues the optimization process.

```python
# Continue with an optimization from previous DoE results
nsga2 = get_nsga2(pop_size=100)
initialize_from_previous_results(nsga2, problem, results_folder)

result = minimize(problem, nsga2, termination=('n_gen', 10), copy_algorithm=False, seed=42)

assert abs(nsga2.evaluator.n_eval - 1100) < 10  # 200 from DoE + 9*100 from optimization
plot(problem.pareto_front(), result.opt.get('F'), labels=['Known Pareto front', 'NSGA2 (10 gen)'])
```

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

### AxInterface.get_population(opt_loop)

Source: https://sbarchopt.readthedocs.io/en/stable/api/botorch

Gets the population from the optimization loop.

```APIDOC
## AxInterface.get_population(opt_loop)

### Description
Gets the population from the optimization loop.

### Method
Method

### Signature
`get_population(opt_loop: OptimizationLoop) -> Population`

### Parameters
- **opt_loop** (OptimizationLoop) - Required - The optimization loop.

### Returns
- **Population** - The population.
```

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

### pop property

Source: https://sbarchopt.readthedocs.io/en/stable/api/egor

Gets the population of all evaluated points.

```APIDOC
## pop property

### Description
Population of all evaluated points.

### Returns
- **pop** (Population) - The population of all evaluated points.
```

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

### AxInterface.get_search_space()

Source: https://sbarchopt.readthedocs.io/en/stable/api/botorch

Gets the search space as defined by the underlying problem.

```APIDOC
## AxInterface.get_search_space()

### Description
Gets the search space as defined by the underlying problem.

### Method
Method

### Signature
`get_search_space() -> SearchSpace`

### Returns
- **SearchSpace** - The search space.
```

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

### Run Optimization with Preconfigured NSGA2

Source: https://sbarchopt.readthedocs.io/en/stable/tutorial

Instantiate the NSGA2 algorithm using get_nsga2 and execute the optimization process via the pymoo minimize function.

```python
from pymoo.optimize import minimize
from sb_arch_opt.algo.pymoo_interface import get_nsga2

# Create the pre-configured NSGA2 algorithm
nsga2 = get_nsga2(pop_size=100)

# Run the optimization
result = minimize(problem, nsga2, termination=('n_gen', 20), seed=42)

# Compare results
plot(problem.pareto_front(), result.opt.get('F'), labels=['Known Pareto front', 'NSGA2'])
```

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

### Use ArchSBO with pymoo minimize

Source: https://sbarchopt.readthedocs.io/en/stable/algo/arch_sbo

Shows how to set up and run the ArchSBO algorithm (Kriging or RBF) with pymoo's minimize function. It includes initializing from previous results and setting the termination criterion. The seed is set to 42 for reproducibility but should be removed in production.

```python
from pymoo.optimize import minimize
from sb_arch_opt.algo.arch_sbo import get_arch_sbo_gp, get_arch_sbo_rbf

problem = ...  # Subclass of ArchOptProblemBase

# Get Kriging or RBF algorithm
n_init = 100
results_folder_path = 'path/to/results/folder'
gp_arch_sbo_algo = get_arch_sbo_gp(problem, init_size=n_init,
                                   results_folder=results_folder_path)

# Start from previous results (skipped if no previous results are available)
gp_arch_sbo_algo.initialize_from_previous_results(problem, results_folder_path)

n_infill = 10
result = minimize(problem, gp_arch_sbo_algo,
                  termination=('n_eval', n_init + n_infill), seed=42)  # Remove seed in production

```

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

### egor property

Source: https://sbarchopt.readthedocs.io/en/stable/api/egor

Gets the native Egor optimizer object.

```APIDOC
## egor property

### Description
Get the native Egor optimizer object. See help(egobox.Egor) for more information.

### Returns
- **egor** - The native Egor optimizer object.
```

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

### initialize_from_previous_results(algorithm, problem, result_folder, **kwargs) -> bool

Source: https://sbarchopt.readthedocs.io/en/stable/api/pymoo

Initialize an Algorithm from previously stored results.

```APIDOC
## initialize_from_previous_results(algorithm: Algorithm, problem: ArchOptProblemBase, result_folder: str, **kwargs) -> bool

### Description
Initialize an Algorithm from previously stored results.

### Parameters
- **algorithm** (Algorithm) - Required - The algorithm to initialize.
- **problem** (ArchOptProblemBase) - Required - The optimization problem.
- **result_folder** (str) - Required - Folder containing previous results.
- **kwargs** - Additional keyword arguments.

### Returns
- bool - Whether initialization was successful.
```

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

### ArchDesignSpace.get_categorical_values

Source: https://sbarchopt.readthedocs.io/en/stable/api/problem

Gets the associated categorical variable values for some design variable.

```APIDOC
## get_categorical_values(x: np.ndarray, i_dv) -> np.ndarray

### Description
Gets the associated categorical variable values for some design variable.

### Method
get_categorical_values

### Parameters
- **x** (np.ndarray) - Required - Design vectors.
- **i_dv** - Required - Index of the design variable.

### Returns
- **np.ndarray** - Categorical values for the specified design variable.
```

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

### Initialize and run the Trieste optimizer

Source: https://sbarchopt.readthedocs.io/en/stable/algo/trieste

This snippet demonstrates how to obtain the Trieste optimizer interface, initialize it from existing results, and execute the optimization loop.

```python
from sb_arch_opt.algo.trieste_interface import get_trieste_optimizer

problem = ...  # Subclass of ArchOptProblemBase

# Get the interface and optimization loop
optimizer = get_trieste_optimizer(problem, n_init=100, n_infill=50, seed=42)

# Start from previous results (skipped if no previous results are available)
results_folder_path = 'path/to/results/folder'
optimizer.initialize_from_previous(results_folder_path)

# Run the optimization loop (the results folder is optional)
result = optimizer.run_optimization(results_folder=results_folder_path)

# Extract data as a pymoo Population object
pop = optimizer.to_population(result.datasets)
```

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

### Provisioning a pymoo GA algorithm

Source: https://sbarchopt.readthedocs.io/en/stable/algo/pymoo

Demonstrates how to provision a standard pymoo Genetic Algorithm with architecture optimization repair operators.

```python
from pymoo.optimize import minimize
from pymoo.algorithms.soo.nonconvex.ga import GA
from sb_arch_opt.algo.pymoo_interface import provision_pymoo

problem = ...  # Subclass of ArchOptProblemBase

ga_algorithm = GA(pop_size=100)
provision_pymoo(ga_algorithm)  # See intermediate results storage below
result = minimize(problem, ga_algorithm, termination=('n_gen', 10), seed=42)  # Remove seed when using in production!
```

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

### design_space property

Source: https://sbarchopt.readthedocs.io/en/stable/api/egor

Gets the design space as a native Egor input specification.

```APIDOC
## design_space property

### Description
Get the design space a native Egor input specification.

### Returns
- **design_space** (list[egx.XSpec]) - The design space specification.
```

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

### ArchOptBayesianOptimizer(problem, n_init, n_infill, pof, rule, seed)

Source: https://sbarchopt.readthedocs.io/en/stable/api/trieste

Bayesian optimization loop controller with some extra helper functions. Use the run_optimization function to run the DOE and infill loops. Use initialize_from_previous to initialize the optimization state from previously saved results.

```APIDOC
## ArchOptBayesianOptimizer(problem, n_init, n_infill, pof, rule, seed)

### Description
Bayesian optimization loop controller with some extra helper functions. Use the run_optimization function to run the DOE and infill loops. Use initialize_from_previous to initialize the optimization state from previously saved results.

### Parameters
- **problem** (ArchOptProblemBase) - Required - The optimization problem.
- **n_init** (int) - Required - Number of initial samples.
- **n_infill** (int) - Required - Number of infill samples.
- **pof** (float) - Optional - Probability of feasibility, default 0.5.
- **rule** (AcquisitionRule) - Optional - Acquisition rule.
- **seed** (int) - Optional - Random seed.

### Methods
#### initialize_from_previous(results_folder)
- **results_folder** (str) - Required - Folder containing previously saved results.

#### run_optimization(results_folder=None) -> Record
- **results_folder** (str) - Optional - Folder to save results.
- Returns a Record object.

#### to_population(datasets) -> Population
- **datasets** (Dict[Hashable, Dataset]) - Required - Datasets to convert.
- Returns a Population object.
```

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

### AxInterface.get_optimization_loop(n_init, n_infill, seed)

Source: https://sbarchopt.readthedocs.io/en/stable/api/botorch

Gets the optimization loop for the Ax optimization process.

```APIDOC
## AxInterface.get_optimization_loop(n_init, n_infill, seed)

### Description
Gets the optimization loop for the Ax optimization process.

### Method
Method

### Signature
`get_optimization_loop(n_init: int, n_infill: int, seed: int = None) -> OptimizationLoop`

### Parameters
- **n_init** (int) - Required - Number of initial points.
- **n_infill** (int) - Required - Number of infill points.
- **seed** (int) - Optional - Random seed.

### Returns
- **OptimizationLoop** - The optimization loop.
```

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

### SEGOMOEInterface.initialize_from_previous

Source: https://sbarchopt.readthedocs.io/en/stable/api/segomoe

Method to initialize the optimization from a previous run.

```APIDOC
## SEGOMOEInterface.initialize_from_previous

### Description
Initializes the optimization from a previous run, optionally using a different results folder.

### Method
`initialize_from_previous(results_folder: str = None)`

### Parameters
- **results_folder** (str) - Optional - Path to the results folder of the previous run. If None, uses the current results folder.
```

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

### get_botorch_interface(problem)

Source: https://sbarchopt.readthedocs.io/en/stable/api/botorch

Gets the main interface to Ax and BoTorch for a given optimization problem.

```APIDOC
## get_botorch_interface(problem)

### Description
Gets the main interface to Ax and BoTorch.

### Method
Function

### Signature
`sb_arch_opt.algo.botorch_interface.api.get_botorch_interface(problem: ArchOptProblemBase)`

### Parameters
- **problem** (ArchOptProblemBase) - Required - The optimization problem to interface with.
```

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

### get_smarty_optimizer(problem, n_init, n_infill)

Source: https://sbarchopt.readthedocs.io/en/stable/api/smarty

Gets the main interface to SMARTy. Use the optimize method to run the DOE and infill loops.

```APIDOC
## get_smarty_optimizer(problem: ArchOptProblemBase, n_init: int, n_infill: int)

### Description
Gets the main interface to SMARTy. Use the `optimize` method to run the DOE and infill loops.

### Parameters
- **problem** (ArchOptProblemBase) - Required - The optimization problem.
- **n_init** (int) - Required - Number of initialization points.
- **n_infill** (int) - Required - Number of infill points.

### Returns
- **SMARTyArchOptInterface** - The SMARTy interface object.
```

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

### initialize_from_previous(results_folder=None)

Source: https://sbarchopt.readthedocs.io/en/stable/api/egor

Initializes the algorithm from previously stored results.

```APIDOC
## initialize_from_previous(results_folder=None)

### Description
Initialize the algorithm from previously stored results. Note: Previous results might be generated on a previous run when the results_folder is specified in EgorArchOptInterface constructor.

### Parameters
- **results_folder** (str) - Optional - Folder containing previous results.
```
Tokens:
Raw