Skip to content

Start optimizing

To start with the optimization, make sure to first install the paretos package.

pip install paretos


With the paretos package installed, the initialization can start. By setting your username and password to the pre-built Config class, everything is set automatically in the background for the user.

from paretos import Config

config = Config(username='put here your username', password='put here your password')

Define the optimization problem

Before starting the optimization itself, the optimization problem needs to be described with the provided helper functions from the paretos package. Here is an example for an optimization problem having three input design variables and two KPIs to be optimized:

from paretos import DesignParameter, KpiParameter
from paretos import OptimizationProblem
from paretos import KpiGoalMinimum, KpiGoalMaximum

# Design parameter to be varied between minimum and maximum for a certain type of parameter
# By default the continuity is always set to continuous and is an optional parameter
design_1 = DesignParameter(name="design_1", minimum=0, maximum=1, continuity="continuous")
design_2 = DesignParameter(name="design_2", minimum=0, maximum=17, continuity="discrete")
design_3 = DesignParameter(name="design_3", minimum=-1.2, maximum=1.4)

design_space = [design_1, design_2, design_3]

kpi_1 = KpiParameter("kpi_1", KpiGoalMinimum)  # To minimize
kpi_2 = KpiParameter("kpi_2", KpiGoalMaximum)  # To maximize

kpi_space = [kpi_1, kpi_2]

optimization_problem = OptimizationProblem(design_space, kpi_space)

Initialize the model environment

With the optimization problem set it is time to make the connection to the customer model. For further details how to wrap the customer model environment visit here. In the example here a simplified example is taken which just adds up the different design parameters above in two different ways to receive the two KPIs.

from typing import Dict
from paretos import EnvironmentInterface

class CustomerEnvironment(EnvironmentInterface):

    def evaluate(self, design_values: Dict[str, float]) -> Dict[str, float]:
        # Here the KPIs are calculated directly or by calling the wrapped model
        kpi_1_value = design_values['design_1'] - design_values['design_2']
        kpi_2_value = design_values['design_3'] * design_values['design_2']

        return {
            "kpi_1": kpi_1_value,
            "kpi_2": kpi_2_value

Each customer problem is different and therefore needs a specific wrapping around the model including the mapping of the right KPIs. Examples for common environments and applications can also be found within the instructions how to wrap a model

Setup the stop criterion for the optimization

The last things to do is to define stop criterion for the optimization to return the results. If you don't specify at least one Terminator the default terminator is set which stops the optimization after 100 runs. If you prefer custom criterion just specify the list of custom terminators like here:

from paretos import RunTerminator

termination_criterion_1 = RunTerminator(number_of_runs=300)
custom_terminators = [termination_criterion_1]

Start the optimization

With all the above defined variables the optimization can now be started.

from paretos import Paretos

project_name = "my_first_optimization_project"

paretos = Paretos(config)


Avoid below possible errors while using above code snippet

  • The above code snippet will throw an error if you run it more than once with the same project name. Cannot start optimization of the project which has already started.

Get optimization results from the database

Paretos package enables the user to get the results for all possibilities fast to go ahead processing them.

from paretos import Paretos

result = paretos.obtain(name="my_first_optimization_project")

# Transform results in pandas dataframe
import pandas as pd

result_df = pd.DataFrame(result)

# Save Data to .csv

Resume optimization run

We can resume optimization run of already existing project by just adding resume=True


Complete Code Example

import math

from typing import Dict
from paretos import Config, DesignParameter, KpiParameter,

KpiGoalMinimum, KpiGoalMaximum, OptimizationProblem,
EnvironmentInterface, Paretos, RunTerminator

class SecretModel():
    Random Model predicting the Costs and CO2 which is emitted
    for a system based on five secret inputs ;)

    def predict(x_sim: list) -> list:
        Function has a convex pareto optimal front.
        costs = x_sim[0]
        g = 1 + 9 / 29 * sum(x_sim[1:])
        h = 1 - math.sqrt(costs / g)
        co2_emission = g * h

        return [costs, co2_emission]

class SecretModelEnvironment(EnvironmentInterface):

    def evaluate(self, design_values: Dict[str, float]) -> Dict[str, float]:
        customer_model = SecretModel()

        # Here we bring design parameter in the shape customer model needs them
        # Dicts are not ordered thats why we need to guarantee design parameter order
        design_params_order = ["design_1", "design_2", "design_3", "design_4"]
        design_list = [design_values[design_name] for design_name in design_params_order]

        cost_val, co2_emission_val = customer_model.predict(design_list)

        return {
            "System cost": cost_val,
            "CO2 emission": co2_emission_val

secret_env = SecretModelEnvironment()

config = Config(username="your username", password="your password")

design_1 = DesignParameter("design_1", minimum=0, maximum=1, continuity="continuous")
design_2 = DesignParameter("design_2", minimum=0, maximum=1)
design_3 = DesignParameter("design_3", minimum=0, maximum=1)
design_4 = DesignParameter("design_4", minimum=0, maximum=1)

design_space = [design_1, design_2, design_3, design_4]

kpi_1 = KpiParameter("System cost", KpiGoalMinimum)
kpi_2 = KpiParameter("CO2 emission", KpiGoalMinimum)

kpi_space = [kpi_1, kpi_2]

optimization_problem = OptimizationProblem(design_space, kpi_space)

# Stop after 50 runs
terminator_creator = RunTerminator(number_of_runs=50)
customer_terminators = [terminator_creator]

# Initialize Paretos class and run optimization
paretos = Paretos(config)

    resume = True

# Get the results in dict form from the database
result_data = paretos.obtain("secret_system_design")

# Save results to csv file

Avoid below possible errors while using above code snippet

  • Enter the correct customer token before running the optimization code