Nevergrad

https://facebookresearch.github.io/nevergrad/
Admin
Nevergrad is a gradient-free optimization platform providing algorithms, parametrization tools, and...
Tokens:28,512
Snippets:388
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install Nevergrad with Benchmark Requirements

Source: https://facebookresearch.github.io/nevergrad/_sources/benchmarking.rst.txt

Ensure all necessary packages for benchmarks are installed by using the 'benchmark' or 'all' flag during installation.

```bash
pip install 'nevergrad[benchmark]'
```

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

### R Setup and Optimization Loop with Nevergrad

Source: https://facebookresearch.github.io/nevergrad/_sources/r.rst.txt

This snippet demonstrates the complete setup for using Nevergrad in R, including installing the library via conda, initializing an optimizer, and running an optimization loop with parallel processing. Ensure 'pip=TRUE' is used during conda installation for Nevergrad.

```R
library("reticulate")
conda_create("r-reticulate")
conda_install("r-reticulate", "nevergrad", pip=TRUE)
use_condaenv("r-reticulate")

# Only if you use parallelism.
library(doParallel)

# Choose your optimization method below.
optimizer_name <- "NgIohTuned"
# optimizer_name <- "DoubleFastGADiscreteOnePlusOne"
# optimizer_name <- "OnePlusOne"
# optimizer_name <- "DE"
# optimizer_name <- "RandomSearch"
# optimizer_name <- "TwoPointsDE"
# optimizer_name <- "Powell"
# optimizer_name <- "MetaModel"  CRASH !!!!
# optimizer_name <- "SQP"
# optimizer_name <- "Cobyla"
# optimizer_name <- "NaiveTBPSA"
# optimizer_name <- "DiscreteOnePlusOne"
# optimizer_name <- "cGA"
# optimizer_name <- "ScrHammersleySearch"

# Now we can play with Nevergrad as usual.
# We assume here that we have 17 continuous hyperparameters with values in [0, 1].
# We can do other instrumentations, as discussed below.
my_tuple <- tuple(17)
instrumentation <- ng$p$Array(shape=my_tuple)
instrumentation$set_bounds(0., 1.)
num_workers <- 3  # We want to be able to evaluate 3 hyperparametrizations simultaneously.
num_iterations <- 100 * num_workers  # Let us say we have a budget of 100xnum_workers hyperparameters to evaluate.

# Let us create a Nevergrad optimization method.
optimizer <-  ng$optimizers$registry[optimizer_name](instrumentation, budget=num_iterations, num_workers=num_workers)

# Dummy initializations.
nevergrad_hp <- 0
nevergrad_hp_val <- 0
score <- 0

for (i in 1:num_iterations) {
    for (j in 1:num_workers) {
       nevergrad_hp[j] <- optimizer$ask()
       nevergrad_hp_val[j] <- nevergrad_hp[j]$value
    }

    # Sequential version.
    # for (j in 1:num_workers) {  # In a perfect world this would be parallel.
    #    score[j] <- norm(nevergrad_hp_val[j])
    # }

    # Parallel version.
    # Actually this could be asynchronous, Nevergrad is ok for that, you do not have to
    # do the tell's in the same order as the ask's.
    registerDoParallel(cores=num_workers)
    getDoParWorkers()
    foreach(i=1:num_workers) %dopar% score[j] <- norm(nevergrad_hp_val[j])

    for (j in 1:num_workers) {
       optimizer$tell(nevergrad_hp[j], score[j])
    }
}
print(optimizer$recommend()$value)
```

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

### Install and Use Pre-commit Hooks

Source: https://facebookresearch.github.io/nevergrad/contributing.html

Install the pre-commit hooks to ensure code adheres to the project's coding style. These hooks are activated automatically for commits.

```bash
pre-commit install
```

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

### Install Nevergrad from main branch

Source: https://facebookresearch.github.io/nevergrad/_sources/getting_started.rst.txt

Install the latest development version directly from the GitHub repository.

```bash
pip install git+https://github.com/facebookresearch/nevergrad@main#egg=nevergrad
```

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

### Install Nevergrad Dependencies

Source: https://facebookresearch.github.io/nevergrad/_sources/windows.md.txt

Navigate to the requirements directory within the cloned Nevergrad repository and install the necessary packages using pip. Then, install PyTorch using conda.

```bash
cd nevergrad/requirements/
pip install -r main.txt
pip install -r bench.txt
pip install -r dev.txt
conda install pytorch
cd ..
```

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

### Install Nevergrad via pip

Source: https://facebookresearch.github.io/nevergrad/_sources/index.rst.txt

Standard installation command for the Nevergrad library.

```bash
pip install nevergrad
```

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

### Install Nevergrad in Development Mode

Source: https://facebookresearch.github.io/nevergrad/contributing.html

Clone the repository and install Nevergrad with all optional dependencies for development. Use the second command if you are using zsh.

```bash
pip install -e .[all]
```

```bash
pip install -e '.[all]'
```

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

### Reinforcement Learning Parameter Optimization

Source: https://facebookresearch.github.io/nevergrad/_sources/machinelearning.rst.txt

Demonstrates optimizing parameters in a noisy environment using various Nevergrad algorithms. The example shows how to handle asynchronous ask/tell loops.

```python
import nevergrad as ng
import numpy as np

# Similar, but with a noisy case: typically a case in which we train in reinforcement learning.
# This is about parameters rather than hyperparameters. TBPSA is a strong candidate in this case.
# We do *not* manually average over multiple evaluations; the algorithm will take care
# of averaging or reevaluate whatever it wants to reevaluate.


print("Optimization of parameters in reinforcement learning ===============")


def simulate_and_return_test_error_with_rl(x, noisy=True):
    return np.linalg.norm([int(50. * abs(x_ - 0.2)) for x_ in x]) + noisy * len(x) * np.random.normal()


budget = 1200  # How many trainings we will do before concluding.


for tool in ["TwoPointsDE", "RandomSearch", "TBPSA", "CMA", "NaiveTBPSA",
        "PortfolioNoisyDiscreteOnePlusOne"]:

    optim = ng.optimizers.registry[tool](parametrization=300, budget=budget)

    for u in range(budget // 3):
        # Ask and tell can be asynchronous.
        # Just be careful that you "tell" something that was asked.
        # Here we ask 3 times and tell 3 times in order to fake asynchronicity
        x1 = optim.ask()
        x2 = optim.ask()
        x3 = optim.ask()
        # The three folowing lines could be parallelized.
        # We could also do things asynchronously, i.e. do one more ask
        # as soon as a training is over.
        y1 = simulate_and_return_test_error_with_rl(*x1.args)
        y2 = simulate_and_return_test_error_with_rl(*x2.args)
        y3 = simulate_and_return_test_error_with_rl(*x3.args)
        optim.tell(x1, y1)
        optim.tell(x2, y2)
        optim.tell(x3, y3)

    recommendation = optim.recommend()
    print("* ", tool, " provides a vector of parameters with test error ",
          simulate_and_return_test_error_with_rl(*recommendation.args, noisy=False))
```

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

### Minimize with Chained Optimizers

Source: https://facebookresearch.github.io/nevergrad/_sources/optimization.rst.txt

Example of initializing a chained optimizer and minimizing a simple objective function.

```python
import nevergrad as ng

def square(x):
    return sum((x - .5)**2)

optimizer = DEwithLHS30(parametrization=2, budget=300)
recommendation = optimizer.minimize(square)
print(recommendation.value)
>>> [0.50843113, 0.5104554]
```

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

### Manual Parametrization with Mixed Continuous and Discrete Parts

Source: https://facebookresearch.github.io/nevergrad/machinelearning.html

An alternative manual parametrization example demonstrating a function that splits input into continuous and discrete parts, processing the discrete part with a softmax-like logic.

```python
def train_and_return_test_error_mixed(x):
    cx = x[:(len(x) // 2)]  # continuous part.
    presoftmax_values = x[(len(x) // 2):]  # discrete part.
    values_for_this_softmax = []
    dx = []
    for g in presoftmax:
        values_for_this_softmax += [g]
        if len(values_for_this_softmax) > 4:
            dx += softmax(values_for_this_softmax)
            values_for_this_softmax = []
    return np.linalg.norm([int(50. * abs(x_ - 0.2)) for x_ in cx]) + [
            1 if d != 1 else 0 for d in dx]

parametrization = 300
```

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

### Asynchronous Ask and Tell Interface for Optimization

Source: https://facebookresearch.github.io/nevergrad/_sources/machinelearning.rst.txt

Demonstrates the asynchronous 'ask and tell' interface for optimization. Multiple 'ask' calls can be made before 'tell' calls, allowing for parallel execution of the training function. This example simulates asynchronicity by asking three times before telling.

```python
for name in names:
    optim = ng.optimizers.registry[name](parametrization=parametrization, budget=budget, num_workers=3)
    for u in range(budget // 3):
        x1 = optim.ask()
        # Ask and tell can be asynchronous.
        # Just be careful that you "tell" something that was asked.
        # Here we ask 3 times and tell 3 times in order to fake asynchronicity
        x2 = optim.ask()
        x3 = optim.ask()
        # The three folowing lines could be parallelized.
        # We could also do things asynchronously, i.e. do one more ask
        # as soon as a training is over.
        y1 = train_and_return_test_error(*x1.args, **x1.kwargs)  # here we only defined an arg, so we could omit kwargs
```

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

### Install Nevergrad via conda

Source: https://facebookresearch.github.io/nevergrad/_sources/getting_started.rst.txt

Installation command for users of the conda-forge channel.

```bash
conda install -c conda-forge nevergrad
```

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

### Chaining Nevergrad optimizers with different budget allocations

Source: https://facebookresearch.github.io/nevergrad/optimization.html

Create a sequence of optimizers where the budget is distributed among them. This example shows chaining LHSSearch and DE with different budget allocation strategies based on 'num_workers', 'dimension', or a fixed number.

```python
# Running LHSSearch with budget num_workers and then DE:
DEwithLHS = Chaining([LHSSearch, DE], ["num_workers"])

# Runnning LHSSearch with budget the dimension and then DE:
DEwithLHSdim = Chaining([LHSSearch, DE], ["dimension"])

# Runnning LHSSearch with budget 30 and then DE:
DEwithLHS30 = Chaining([LHSSearch, DE], [30])

# Running LHS for 100 iterations, then DE for 60, then CMA:
LHSthenDEthenCMA = Chaining([LHSSearch, DE, CMA], [100, 60])
```

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

### Minimize a function with NgIohTuned

Source: https://facebookresearch.github.io/nevergrad/_sources/optimization.rst.txt

Basic example of minimizing a function using the NgIohTuned optimizer with a simple continuous parametrization.

```python
def square(x):
    return sum(x**2)

optimizer = ng.optimizers.NgIohTuned(parametrization=10, budget=100)
recommendation = optimizer.minimize(square)
print(recommendation.value)
```

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

### Optimize discrete functions

Source: https://facebookresearch.github.io/nevergrad/_sources/optimization.rst.txt

Example of applying the one-max function on a discrete space.

```python
def onemax(x):
    return -sum(x)

parametrization = ng.p.Array(shape=(10,)).set_mutation(sigma=1).set_integer_casting()
optimizer = ng.optimizers.DiscreteOnePlusOne(parametrization=parametrization, budget=100)
optimizer.minimize(onemax)
```

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

### Minimizing with Cheap Constraints

Source: https://facebookresearch.github.io/nevergrad/_sources/optimization.rst.txt

Use `register_cheap_constraint` for constraints where reducing calls is not critical. This example minimizes a function under the constraint that x[0] must be greater than or equal to 1.

```python
def constraint_x0_ge_1(candidate):
    return float(candidate.x[0] >= 1)

optimizer.register_cheap_constraint(constraint_x0_ge_1)
```

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

### Format Code with Black

Source: https://facebookresearch.github.io/nevergrad/contributing.html

If not using pre-commit hooks, install Black separately and use it to format the Nevergrad codebase to comply with the project's style.

```bash
pip install black
```

```bash
black nevergrad
```

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

### Observe Parameter Mutation

Source: https://facebookresearch.github.io/nevergrad/_sources/parametrization.rst.txt

Shows how parameters can be mutated. This example specifically focuses on the mutation of Array variables, which can be adapted to specific needs.

```python
child = parametrization.spawn()
# The mutation is applied on the standardized space, so we need to export it first.
# print(child.mutate().export())
# Example output: array([ 7.11775528,  0.11      ,  0.21      ,  0.        ])
```

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

### Adding a Callback for Tell Method

Source: https://facebookresearch.github.io/nevergrad/_sources/optimization.rst.txt

Register a callback function to monitor the `tell` method. The callback receives the optimizer, candidate, and value. This example prints the candidate and value.

```python
def tell_callback(optimizer, candidate, value):
    print(f"Candidate: {candidate}, Value: {value}")

optimizer.register_callback(tell=tell_callback)
```

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

### Multiobjective Function Example

Source: https://facebookresearch.github.io/nevergrad/optimization.html

Defines a sample multiobjective function that returns an array of two loss values. This is used to demonstrate how Nevergrad handles multiple objectives.

```python
import nevergrad as ng
import numpy as np

def multiobjective(x):
    return [np.sum(x**2), np.sum((x - 1) ** 2)]

print("Example: ", multiobjective(np.array([1.0, 2.0, 0])))
# >>> Example: [5.0, 2.0]
```

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

### Optimize Continuous Hyperparameters with Various Algorithms

Source: https://facebookresearch.github.io/nevergrad/_sources/machinelearning.rst.txt

Optimize continuous hyperparameters using different algorithms like RandomSearch, TwoPointsDE, CMA, PSO, and ScrHammersleySearch. This example optimizes a 300-dimensional array and uses a budget of 1200.

```python
import nevergrad as ng
import numpy as np


print("Optimization of continuous hyperparameters ================")


def train_and_return_test_error(x):
    return np.linalg.norm([int(50. * abs(x_ - 0.2)) for x_ in x])

parametrization = ng.p.Array(shape=(300,))  # optimize on R^300

budget = 1200  # How many trainings we will do before concluding.

names = ["RandomSearch", "TwoPointsDE", "CMA", "PSO", "ScrHammersleySearch"]
```

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

### Manual Parametrization Techniques

Source: https://facebookresearch.github.io/nevergrad/_sources/machinelearning.rst.txt

Examples of defining custom parametrization logic directly within the objective function. This approach is generally not recommended compared to using Nevergrad's built-in parametrization tools.

```python
def softmax(x, possible_values=None):
    expx = [np.exp(x_ - max(x)) for x_ in x]
    probas = [e / sum(expx) for e in expx]
    return np.random.choice(len(x) if possible_values is None
            else possible_values, size=1, p=probas)


def train_and_return_test_error_mixed(x):
    cx = [x_ - 0.1 for x_ in x[3:]]
    activation = softmax(x[:3], ["tanh", "sigmoid", "relu"])
    return np.linalg.norm(cx) + (1. if activation != "tanh" else 0.)

parametrization = 10  # you can just provide the size of your input in this case

#This version is bigger.
def train_and_return_test_error_mixed(x):
    cx = x[:(len(x) // 2)]  # continuous part.
    presoftmax_values = x[(len(x) // 2):]  # discrete part.
    values_for_this_softmax = []
    dx = []
    for g in presoftmax:
        values_for_this_softmax += [g]
        if len(values_for_this_softmax) > 4:
            dx += softmax(values_for_this_softmax)
            values_for_this_softmax = []
    return np.linalg.norm([int(50. * abs(x_ - 0.2)) for x_ in cx]) + [
            1 if d != 1 else 0 for d in dx]

parametrization = 300
```

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

### Create and navigate to repository directory

Source: https://facebookresearch.github.io/nevergrad/windows.html

Initializes a local directory for project files.

```bash
mkdir repos 
cd repos
```

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

### Create and Navigate to Repository Directory

Source: https://facebookresearch.github.io/nevergrad/_sources/windows.md.txt

Use these commands to create a new directory for your repositories and then navigate into it. This is a standard practice for organizing project files.

```bash
mkdir repos
cd repos
```

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

### R: Setup Nevergrad with Reticulate

Source: https://facebookresearch.github.io/nevergrad/r.html

Installs and configures Nevergrad within an R environment using reticulate and conda. Ensure 'pip=TRUE' is used during conda_install for proper installation.

```R
# Library and environment for Reticulate/Nevergrad.
library("reticulate")
conda_create("r-reticulate")
conda_install("r-reticulate", "nevergrad", pip=TRUE)
use_condaenv("r-reticulate")

# Only if you use parallelism.
library(doParallel)

# Choose your optimization method below.
optimizer_name <- "NgIohTuned"
# optimizer_name <- "DoubleFastGADiscreteOnePlusOne"
# optimizer_name <- "OnePlusOne"
# optimizer_name <- "DE"
# optimizer_name <- "RandomSearch"
# optimizer_name <- "TwoPointsDE"
# optimizer_name <- "Powell"
# optimizer_name <- "MetaModel"  CRASH !!!!
# optimizer_name <- "SQP"
# optimizer_name <- "Cobyla"
# optimizer_name <- "NaiveTBPSA"
# optimizer_name <- "DiscreteOnePlusOne"
# optimizer_name <- "cGA"
# optimizer_name <- "ScrHammersleySearch"

# Now we can play with Nevergrad as usual.
# We assume here that we have 17 continuous hyperparameters with values in [0, 1].
# We can do other instrumentations, as discussed below.
my_tuple <- tuple(17)
instrumentation <- ng$p$Array(shape=my_tuple)
instrumentation$set_bounds(0., 1.)
num_workers <- 3  # We want to be able to evaluate 3 hyperparametrizations simultaneously.
num_iterations <- 100 * num_workers  # Let us say we have a budget of 100xnum_workers hyperparameters to evaluate.

# Let us create a Nevergrad optimization method.
optimizer <-  ng$optimizers$registry[optimizer_name](instrumentation, budget=num_iterations, num_workers=num_workers)

# Dummy initializations.
nevergrad_hp <- 0
nevergrad_hp_val <- 0
score <- 0

for (i in 1:num_iterations) {
    for (j in 1:num_workers) {
       nevergrad_hp[j] <- optimizer$ask()
       nevergrad_hp_val[j] <- nevergrad_hp[j]$value
    }

    # Sequential version.
    # for (j in 1:num_workers) {  # In a perfect world this would be parallel.
    #    score[j] <- norm(nevergrad_hp_val[j])
    # }

    # Parallel version.
    # Actually this could be asynchronous, Nevergrad is ok for that, you do not have to
    # do the tell's in the same order as the ask's.
    registerDoParallel(cores=num_workers)
    getDoParWorkers()
    foreach(i=1:num_workers) %dopar% score[j] <- norm(nevergrad_hp_val[j])

    for (j in 1:num_workers) {
       optimizer$tell(nevergrad_hp[j], score[j])
    }
}
print(optimizer$recommend()$value)

```

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

### Run a Nevergrad Benchmark Experiment

Source: https://facebookresearch.github.io/nevergrad/_sources/windows.md.txt

After setting up the environment and navigating to the Nevergrad repository, you can run benchmark experiments using the command line.

```bash
python -m nevergrad.benchmark parallel
```

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

### Build Documentation

Source: https://facebookresearch.github.io/nevergrad/contributing.html

Generate the HTML documentation for Nevergrad by running the make command from the 'docs' folder.

```bash
make html
```

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

### Suggesting Points with Instrumentation

Source: https://facebookresearch.github.io/nevergrad/optimization.html

Shows how to inoculate information by suggesting a point using `optimizer.suggest` with an `ng.p.Instrumentation` parametrization. The suggested point can then be retrieved using `optimizer.ask()` and used with `optimizer.tell()`.

```python
param = ng.p.Instrumentation(ng.p.Choice(["a", "b", "c"]),
                             lr=ng.p.Log(lower=0.001, upper=1.0))
optim = ng.optimizers.NGOpt(parametrization=param, budget=100)
optim.suggest("c", lr=0.02)
candidate = optim.ask()
# equivalent to:
candidate = optim.parametrization.spawn_child(new_value=(("c",), {"lr": 0.02}))
# you can then use to tell the loss
optim.tell(candidate, 2.0)
```

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

### Navigate to repository

Source: https://facebookresearch.github.io/nevergrad/windows.html

Changes the working directory to the project root.

```bash
cd repos/nevergrad
```

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

### Inoculating Data with Instrumentation

Source: https://facebookresearch.github.io/nevergrad/_sources/optimization.rst.txt

Use `optimizer.suggest` to provide a point for the next `ask` call. Ensure arguments match your function's signature. This is for optimizers parametrized with `ng.p.Instrumentation`.

```python
candidate = optimizer.parametrization.spawn_child(new_value=your_value)
tell(candidate, loss)
```

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

### Suggesting Points with Array Parametrization

Source: https://facebookresearch.github.io/nevergrad/optimization.html

Demonstrates inoculating information using `optimizer.suggest` with an `Array` parametrization. The suggested point is then retrieved with `optimizer.ask()` and can be used with `optimizer.tell()`.

```python
optim = ng.optimizers.NGOpt(parametrization=2, budget=100)
optim.suggest([12, 12])
candidate = optim.ask()
# equivalent to:
candidate = optim.parametrization.spawn_child(new_value=[12, 12])
# you can then use to tell the loss
optim.tell(candidate, 2.0)
```

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

### Sequential Optimization with Ask and Tell

Source: https://facebookresearch.github.io/nevergrad/optimization.html

Demonstrates the sequential ask and tell process for optimization. Ensure your function returns a float and is set for minimization.

```python
import nevergrad as ng

def square(x, y=12):
    return sum((x - 0.5) ** 2) + abs(y)

instrum = ng.p.Instrumentation(ng.p.Array(shape=(2,)), y=ng.p.Scalar())  # We are working on R^2 x R.
optimizer = ng.optimizers.NGOpt(parametrization=instrum, budget=100, num_workers=1)

for _ in range(optimizer.budget):
    x = optimizer.ask()
    loss = square(*x.args, **x.kwargs)
    optimizer.tell(x, loss)

recommendation = optimizer.provide_recommendation()
print(recommendation.value)
```

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

### Define continuous hyperparameter test case

Source: https://facebookresearch.github.io/nevergrad/machinelearning.html

Setup for comparing multiple optimization algorithms on a continuous parameter space.

```python
import nevergrad as ng
import numpy as np


print("Optimization of continuous hyperparameters =========")


def train_and_return_test_error(x):
    return np.linalg.norm([int(50. * abs(x_ - 0.2)) for x_ in x])

parametrization = ng.p.Array(shape=(300,))  # optimize on R^300

budget = 1200  # How many trainings we will do before concluding.

names = ["RandomSearch", "TwoPointsDE", "CMA", "PSO", "ScrHammersleySearch"]
```

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

### List available optimizers

Source: https://facebookresearch.github.io/nevergrad/_sources/optimization.rst.txt

Print the full registry of available optimization algorithms.

```python
print(sorted(ng.optimizers.registry.keys()))
```

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

### Use the ask and tell interface

Source: https://facebookresearch.github.io/nevergrad/_sources/optimization.rst.txt

Manually control the optimization loop using ask, tell, and provide_recommendation methods.

```python
optimizer = ng.optimizers.NgIohTuned(parametrization=10, budget=100)
for _ in range(optimizer.budget):
    candidate = optimizer.ask()
    loss = square(candidate.value)
    optimizer.tell(candidate, loss)
recommendation = optimizer.provide_recommendation()
```

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

### List available optimizers

Source: https://facebookresearch.github.io/nevergrad/_sources/getting_started.rst.txt

Retrieve and print the registry of all available optimization algorithms.

```python
import nevergrad as ng
print(sorted(ng.optimizers.registry.keys()))
```

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

### Run One-Shot Optimization Benchmark (Dim 10, Small Budget)

Source: https://facebookresearch.github.io/nevergrad/_sources/benchmarks.rst.txt

This command runs one-shot optimization benchmarks in a 10-dimensional space with a small budget. It's useful for understanding performance when evaluation counts are limited.

```bash
python -m nevergrad.benchmark dim10_smallbudget --seed=12 --repetitions=400 --plot
```

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

### Multiobjective Optimization with Nevergrad

Source: https://facebookresearch.github.io/nevergrad/optimization.html

Demonstrates setting up and running a multiobjective optimization using Nevergrad's CMA optimizer. It includes setting a budget, providing an initial reference for losses, minimizing the multiobjective function, and accessing the Pareto front.

```python
optimizer = ng.optimizers.CMA(parametrization=3, budget=100)

# for all but DE optimizers, deriving a volume out of the losses,
# it's not strictly necessary but highly advised to provide an
# upper bound reference for the losses (if not provided, such upper
# bound is automatically inferred with the first few "tell")
optimizer.tell(ng.p.MultiobjectiveReference(), [5, 5])
# note that you can provide a Parameter to MultiobjectiveReference,
# which will be passed to the optimizer

optimizer.minimize(multiobjective, verbosity=2)

# The function embeds its Pareto-front:
print("Pareto front:")
for param in sorted(optimizer.pareto_front(), key=lambda p: p.losses[0]):
    print(f"{param} with losses {param.losses}")

# >>> Array{(3,)}:[0. 0. 0.] with loss [0. 3.]
#     Array{(3,)}:[0.39480968 0.98105712 0.55785803] with loss [1.42955333 0.56210368]
#     Array{(3,)}:[1.09901515 0.97673712 0.97153943] with loss [3.10573857 0.01115516]

# It can also provide subsets:
print("Random subset:", optimizer.pareto_front(2, subset="random"))
print("Loss-covering subset:", optimizer.pareto_front(2, subset="loss-covering"))
print("Domain-covering subset:", optimizer.pareto_front(2, subset="domain-covering"))
print("EPS subset:", optimizer.pareto_front(2, subset="EPS"))
```

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

### Perform discrete optimization

Source: https://facebookresearch.github.io/nevergrad/optimization.html

Use TransitionChoice for discrete variables and manual ask/tell loops for optimization.

```python
import nevergrad as ng

def onemax(x):
    return len(x) - x.count(1)

# Discrete, ordered
param = ng.p.TransitionChoice(range(7), repetitions=10)
optimizer = ng.optimizers.DiscreteOnePlusOne(parametrization=param, budget=100, num_workers=1)

recommendation = optimizer.provide_recommendation()
for _ in range(optimizer.budget):
    x = optimizer.ask()
    # loss = onemax(*x.args, **x.kwargs)  # equivalent to x.value if not using Instrumentation
    loss = onemax(x.value)
    optimizer.tell(x, loss)

recommendation = optimizer.provide_recommendation()
print(recommendation.value)
# >>> (1, 1, 0, 1, 1, 4, 1, 1, 1, 1)
```

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

### Run an Experiment Plan

Source: https://facebookresearch.github.io/nevergrad/_sources/benchmarking.rst.txt

Execute an experiment plan using the nevergrad.benchmark module. Use --num_workers for parallel computation and --output to specify the output file.

```bash
python -m nevergrad.benchmark <experiment_name>
```

```bash
python -m nevergrad.benchmark --num_workers=4 --output=<experiment_name>.csv <experiment_name>
```

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

### Run Optimization Loop

Source: https://facebookresearch.github.io/nevergrad/machinelearning.html

Executes optimization using ask-and-tell interface, demonstrating manual batching for potential parallelization.

```python
import nevergrad as ng
budget = 1200  # How many episode we will do before concluding.
for name in ["RandomSearch", "ScrHammersleySearch", "TwoPointsDE", "PortfolioDiscreteOnePlusOne", "CMA", "PSO"]:
    optim = ng.optimizers.registry[name](parametrization=instru, budget=budget)
    for u in range(budget // 3):
        x1 = optim.ask()
        # Ask and tell can be asynchronous.
        # Just be careful that you "tell" something that was asked.
        # Here we ask 3 times and tell 3 times in order to fake asynchronicity
        x2 = optim.ask()
        x3 = optim.ask()
        # The three folowing lines could be parallelized.
        # We could also do things asynchronously, i.e. do one more ask
        # as soon as a training is over.
        y1 = myfunction(*x1.args, **x1.kwargs)  # here we only defined an arg, so we could omit kwargs
        y2 = myfunction(*x2.args, **x2.kwargs)  # (keeping it here for the sake of consistency)
        y3 = myfunction(*x3.args, **x3.kwargs)
        optim.tell(x1, y1)
        optim.tell(x2, y2)
        optim.tell(x3, y3)
    recommendation = optim.recommend()
    print("* ", name, " provides a vector of parameters with test error ",
          myfunction(*recommendation.args, **recommendation.kwargs))
```

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

### Update and Standardize Parameter Values

Source: https://facebookresearch.github.io/nevergrad/parametrization.html

Demonstrates spawning a child parameter, manually updating its value, and exporting it to the standardized space used by optimizers. Manual value setting is useful for providing an initial prior.

```python
# create a new instance
child = param.spawn_child()
# update its value
child.value = {"log": 0.2, "array": np.array([12.0, 13.0]), "char": "c"}

# export to standardized space
data = child.get_standardized_data(reference=param)
print(data)
# np.array([12., 13.,  0.,  0., 0.69, 0.90])
```

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

### Run an experiment plan

Source: https://facebookresearch.github.io/nevergrad/benchmarking.html

Execute a specific experiment plan by name to generate a CSV file containing performance results.

```bash
python -m nevergrad.benchmark <experiment_name>
```

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

### List available optimizers

Source: https://facebookresearch.github.io/nevergrad/getting_started.html

Print all registered optimizer keys.

```python
import nevergrad as ng

print(sorted(ng.optimizers.registry.keys()))
```

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

### Run Benchmark with Custom Imports

Source: https://facebookresearch.github.io/nevergrad/_sources/benchmarking.rst.txt

Execute benchmarks with custom experiments, functions, or optimizers by specifying an import file. This feature is not yet supported on Windows.

```bash
python -m nevergrad.benchmark additional_experiment --imports=nevergrad/benchmark/additional/example.py
```

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

### Run One-Shot Optimization Benchmark (Dim 12, 2 Features)

Source: https://facebookresearch.github.io/nevergrad/_sources/benchmarks.rst.txt

Use this command to run benchmarks for one-shot optimization in a 12-dimensional space with two useful features. This helps compare algorithm performance when multiple features are relevant.

```bash
python -m nevergrad.benchmark dim10_select_two_features --seed=12 --repetitions=400 --plot
```

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

### Import Nevergrad Pyomo utilities

Source: https://facebookresearch.github.io/nevergrad/pyomo.html

Load the necessary Nevergrad modules to parse Pyomo models for optimization.

```python
import nevergrad as ng
import nevergrad.functions.pyomo as ng_pyomo
```

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

### Run One-Shot Optimization Benchmark (Dim 11, 1 Feature)

Source: https://facebookresearch.github.io/nevergrad/_sources/benchmarks.rst.txt

Execute this command to benchmark one-shot optimization in a 11-dimensional space with one useful feature. This is useful for feature selection contexts.

```bash
python -m nevergrad.benchmark dim10_select_one_feature --seed=12 --repetitions=400 --plot
```

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

### Define input space with parametrization

Source: https://facebookresearch.github.io/nevergrad/_sources/index.rst.txt

Configure bounded continuous and discrete variables for optimization.

```python
import nevergrad as ng

parametrization = ng.p.Instrumentation(
    ng.p.Scalar(lower=0, upper=1),
    ng.p.Choice(["a", "b", "c"]),
    value=ng.p.Scalar().set_bounds(lower=0, upper=10)
)
```

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

### Run Benchmark and Plot Directly

Source: https://facebookresearch.github.io/nevergrad/_sources/benchmarking.rst.txt

Combine benchmark execution and plotting with the --plot argument. Specify a path to save figures or it will be saved in a default folder.

```bash
python -m nevergrad.benchmark --plot <experiment_name>
```

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

### Run basic optimization

Source: https://facebookresearch.github.io/nevergrad/getting_started.html

Minimize a simple square function using the NGOpt optimizer.

```python
import nevergrad as ng

def square(x):
    return sum((x - 0.5) ** 2)

# optimization on x as an array of shape (2,)
optimizer = ng.optimizers.NGOpt(parametrization=2, budget=100)
recommendation = optimizer.minimize(square)  # best value
print(recommendation.value)
# >>> [0.49999998 0.50000004]
```

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

### Manipulate and Export Parameter Values

Source: https://facebookresearch.github.io/nevergrad/_sources/parametrization.rst.txt

Demonstrates how to duplicate a parameter, manually update its value, and export it to the standardized space. Manually setting the 'value' can provide an initial prior to the optimizer.

```python
child = parametrization.spawn()
child.value = (100, [0.1, 0.2], 'a')
# The standardized space is a numpy array, which is used by the optimizers.
# Unless implementing an algorithm, users should not have any need for this export.
# print(child.export())
# Example output: array([6.90775528, 0.1       , 0.2       , 0.        ])
```

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

### Run Optimization Loop

Source: https://facebookresearch.github.io/nevergrad/_sources/machinelearning.rst.txt

Executes the optimization process using various strategies with ask/tell interface.

```python
import nevergrad as ng
budget = 1200  # How many episode we will do before concluding.
for name in ["RandomSearch", "ScrHammersleySearch", "TwoPointsDE", "PortfolioDiscreteOnePlusOne", "CMA", "PSO"]:
    optim = ng.optimizers.registry[name](parametrization=instru, budget=budget)
    for u in range(budget // 3):
        x1 = optim.ask()
        # Ask and tell can be asynchronous.
        # Just be careful that you "tell" something that was asked.
        # Here we ask 3 times and tell 3 times in order to fake asynchronicity
        x2 = optim.ask()
        x3 = optim.ask()
        # The three folowing lines could be parallelized.
        # We could also do things asynchronously, i.e. do one more ask
        # as soon as a training is over.
        y1 = myfunction(*x1.args, **x1.kwargs)  # here we only defined an arg, so we could omit kwargs
        y2 = myfunction(*x2.args, **x2.kwargs)  # (keeping it here for the sake of consistency)
        y3 = myfunction(*x3.args, **x3.kwargs)
        optim.tell(x1, y1)
        optim.tell(x2, y2)
```

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

### Stage files for commit

Source: https://facebookresearch.github.io/nevergrad/windows.html

Adds specific documentation files to the staging area.

```bash
git add .\docs\windows.md
git add .\docs\resources\windows_screenshots\*
```

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

### Run discrete optimization benchmark

Source: https://facebookresearch.github.io/nevergrad/benchmarks.html

Executes the benchmark for discrete objective functions.

```bash
python -m nevergrad.benchmark discrete --seed=12 --repetitions=10 --plot
```

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

### Implement ask-and-tell optimization loop

Source: https://facebookresearch.github.io/nevergrad/machinelearning.html

Execute an optimization loop using the ask-and-tell interface, supporting synchronous or asynchronous execution.

```python
for name in names:
    optim = ng.optimizers.registry[name](parametrization=parametrization, budget=budget, num_workers=3)
    for u in range(budget // 3):
        x1 = optim.ask()
        # Ask and tell can be asynchronous.
        # Just be careful that you "tell" something that was asked.
        # Here we ask 3 times and tell 3 times in order to fake asynchronicity
        x2 = optim.ask()
        x3 = optim.ask()
        # The three folowing lines could be parallelized.
        # We could also do things asynchronously, i.e. do one more ask
        # as soon as a training is over.
        y1 = train_and_return_test_error(*x1.args, **x1.kwargs)  # here we only defined an arg, so we could omit kwargs
        y2 = train_and_return_test_error(*x2.args, **x2.kwargs)  # (keeping it here for the sake of consistency)
        y3 = train_and_return_test_error(*x3.args, **x3.kwargs)
        optim.tell(x1, y1)
        optim.tell(x2, y2)
        optim.tell(x3, y3)
    recommendation = optim.recommend()
    print("* ", name, " provides a vector of parameters with test error ",
          train_and_return_test_error(*recommendation.args, **recommendation.kwargs))
```

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

### Run Design of Experiments Benchmark (Dim 4)

Source: https://facebookresearch.github.io/nevergrad/_sources/benchmarks.rst.txt

Execute this command to generate benchmarks for Design of Experiments (DOE) in a 4-dimensional space. This is useful for understanding how scrambling and LHS perform in moderate dimensions.

```bash
python -m nevergrad.benchmark doe_dim4 --seed=12 --repetitions=400 --plot
```

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

### Run Unit Tests with Coverage

Source: https://facebookresearch.github.io/nevergrad/contributing.html

Execute the unit tests for Nevergrad and generate a coverage report. This command should be run from the repository's root directory.

```bash
pytest nevergrad --cov=nevergrad
```

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

### Run one-shot optimization benchmarks

Source: https://facebookresearch.github.io/nevergrad/benchmarks.html

Executes various one-shot optimization benchmarks for different dimensions and feature counts.

```bash
python -m nevergrad.benchmark dim10_select_one_feature --seed=12 --repetitions=400 --plot
```

```bash
python -m nevergrad.benchmark dim10_select_two_features --seed=12 --repetitions=400 --plot
```

```bash
python -m nevergrad.benchmark dim10_smallbudget --seed=12 --repetitions=400 --plot
```

```bash
python -m nevergrad.benchmark doe_dim4 --seed=12 --repetitions=400 --plot
```

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

### Define an Abstract Pyomo Model

Source: https://facebookresearch.github.io/nevergrad/_sources/pyomo.rst.txt

Demonstrates the declaration of components for an AbstractModel before instance creation.

```python
model = pyomo.environ.AbstractModel()
model.x = pyomo.environ.Var(range(2), bounds=(0, 1))
model.obj = pyomo.environ.Objective(expr=model.x[0]**2 + model.x[1]**2)
```

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

### Run comparison-based ill-conditioned benchmark

Source: https://facebookresearch.github.io/nevergrad/benchmarks.html

Executes the benchmark for comparison-based methods on ill-conditioned problems.

```bash
python -m nevergrad.benchmark compabasedillcond --seed=12 --repetitions=400 --plot
```

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

### Stage and Commit Changes

Source: https://facebookresearch.github.io/nevergrad/_sources/windows.md.txt

Add new or modified files to the staging area and then commit them with a descriptive message. This prepares your changes for pushing to the remote repository.

```bash
git add .\docs\windows.md
git add .\docs\resources\windows_screenshots\*
git commit -am "windows documentation"
```

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

### Construct an AbstractModel instance

Source: https://facebookresearch.github.io/nevergrad/pyomo.html

Load data into an AbstractModel using a DataPortal to create a ConcreteModel instance.

```python
data = pyomo.DataPortal()
data.load(filename=data_path, model=abstract_model)
model = abstract_model.create_instance(data)
```

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

### Instrumentation and Optimization

Source: https://facebookresearch.github.io/nevergrad/parametrization.html

How to group parameters using Instrumentation and use them to optimize a function.

```APIDOC
## Instrumentation and Optimization

### Description
Defines a parameter container using `Instrumentation` and performs optimization using `NGOpt`.

### Request Example
```python
import nevergrad as ng

arg1 = ng.p.Choice(["Helium", "Nitrogen", "Oxygen"])
arg2 = ng.p.TransitionChoice(["Solid", "Liquid", "Gas"])
values = ng.p.Tuple(ng.p.Scalar().set_integer_casting(), ng.p.Scalar())

# Define instrumentation
instru = ng.p.Instrumentation(arg1, arg2, "blublu", amount=values)

# Perform optimization
def myfunction(arg1, arg2, arg3, amount=(2, 2)):
    return amount[0] ** 2 + amount[1] ** 2

optimizer = ng.optimizers.NGOpt(parametrization=instru, budget=100)
recommendation = optimizer.minimize(myfunction)
```
```

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

### Format Code with Black

Source: https://facebookresearch.github.io/nevergrad/_sources/contributing.rst.txt

Make your code compliant with the Black code formatter. This command can be run manually if pre-commit hooks are not used.

```bash
black nevergrad
```

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

### Perform Multiobjective Optimization

Source: https://facebookresearch.github.io/nevergrad/_sources/optimization.rst.txt

Provide multiobjective results as an array or list of floats to the tell method.

```python
    # Multiobjective minimization example
    parametrization = ng.p.Instrumentation(ng.p.Scalar(), ng.p.Scalar())
    optimizer = ng.optimizers.registry["DE"](parametrization=parametrization, budget=100)
    optimizer.tell(ng.p.MultiobjectiveReference(parametrization), [1.0, 2.0])
    optimizer.tell(ng.p.MultiobjectiveReference(parametrization), [0.5, 1.5])
```

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

### Instrument Continuous and Discrete Parameters

Source: https://facebookresearch.github.io/nevergrad/_sources/machinelearning.rst.txt

Instrument hyperparameters using Nevergrad's parameter objects. Use Log for continuous learning rates and TransitionChoice for discrete parameters like the number of layers. Define the overall instrumentation with Instrumentation, specifying fixed values for arguments not to be optimized.

```python
import nevergrad as ng
# instrument learning rate and number of layers, keep arg3 to 3 and arg4 to 4
lr = ng.p.Log(lower=0.0001, upper=1)  # log distributed between 0.001 and 1
num_layers = ng.p.TransitionChoice([4, 5, 6])
parametrization = ng.p.Instrumentation(lr, num_layers, 3., arg4=4)
```

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

### Define a Pyomo ConcreteModel

Source: https://facebookresearch.github.io/nevergrad/pyomo.html

Create a fully initialized Pyomo model with variables, an objective function, and constraints.

```python
import pyomo.environ as pyomo

def square(m):
    return pyomo.quicksum((m.x[i] - 0.5) ** 2 for i in m.x)

model = pyomo.ConcreteModel()
model.x = pyomo.Var([0, 1], domain=pyomo.Reals)
model.obj = pyomo.Objective(rule=square)
model.Constraint1 = pyomo.Constraint(rule=lambda m: m.x[0] >= 1)
model.Constraint2 = pyomo.Constraint(rule=lambda m: m.x[1] >= 0.8)
```
Tokens:
Raw