About Amplify-BBOpt

Overview

In materials development and product design, as well as in various parametric studies, it is common to face the challenge that the number of simulations or experiments is limited, making it difficult to perform sufficient trial-and-error for optimization.

Amplify-BBOpt is a Python library designed to efficiently solve such black-box optimization problems by leveraging Ising machines.

This documentation provides an introduction — from the basics of black-box optimization to the features and usage of Amplify-BBOpt — even for engineers who have no prior experience with Ising machines.

What is black-box optimization?

Black-box optimization is an optimization approach used when the objective function is unknown or too complex to handle analytically. It finds the optimal input parameters (decision variables) by iteratively performing simulations or experiments.

Application examples (CAE domain)

  • Optimizing building design or equipment layout to maximize air-conditioning performance

  • Searching for a mixing condition for a mixing machine that minimize concentration fluctuations for a more uniform mixture

  • Optimizing material composition to maximize a specific performance metric

  • Adjusting component placement or loading conditions to minimize structural displacement

  • Finding experimental conditions that reproduce certain results (minimizing the difference — inverse problem)

In such problems, each evaluation (simulation or experiment) tends to be computationally or physically expensive, so it is crucial to explore efficiently within a limited number of trials.

Hint

Amplify-BBOpt performs minimization by default — it determines parameter values that minimize the (black-box) objective function. To solve a maximization problem, you can convert it into a minimization one by considering the negative of the original objective function.

What is Ising machine?

An Ising machine is a specialized computing device designed to efficiently solve combinatorial optimization problems.
Examples include quantum annealing machines (such as D-Wave) and quantum-inspired technologies based on advanced semiconductor architectures (such as Fixstars Amplify Annealing Engine).

Some practical Ising machines are already capable of solving large-scale and highly constrained optimization problems, and they are increasingly being applied in real-world business use cases.

Overview and key features of Amplify-BBOpt

Amplify-BBOpt allows you to easily perform black-box optimization as follows:

  • Define your objective function (simulation or experiment) in Python
    → Within the evaluation function, you can call an external CAE solver or display experimental conditions.

  • The Ising machine efficiently searches for optimal parameters
    → Even with a large number of parameters, better results can be obtained with fewer trials.

  • Automatically proposes the next promising conditions based on past results
    → Using the outcomes of simulations or experiments, Amplify-BBOpt continuously suggests new and more promising candidates.

Optimization methods implemented

Amplify-BBOpt implements several methods based on Black-Box Optimization with Ising Machines (QA-BBO[1]).
Currently, it supports:

  • Factorization Machine with Quadratic-Optimization Annealing (FMQA) [2]

  • Polynomial-Based Kernel with Quadratic-Optimization Annealing (Kernel-QA) [3]

QA-BBO is particularly effective for large-scale black-box optimization problems with or without constraints.
It has demonstrated high performance in challenging cases such as high-dimensional problems — which are often difficult for conventional methods due to the ``curse of dimensionality’’ — and optimization problems with complex constraints [4].

Note

Amplify-BBOpt uses the Amplify SDK,
a Python library that supports the formulation of optimization problems
and their execution using external solvers such as Ising machines.

Implementation example

Below is an example implementation of Amplify-BBOpt.

from amplify import FixstarsClient
from amplify_bbopt import blackbox, KMTrainer, Optimizer, RealVariable, IntegerVariable BinaryVariable


# Define decision variables and a black-box objective function
@blackbox
def blackbox_func(
    x0: float = RealVariable(bounds=(0, 2.5)),
    x1: int = IntegerVariable(bounds=(1, 4)),
    x2: int = BinaryVariable(),
) -> float:
    # In practice, you can call a CAE solver or other external process here and return its results or any post-processed values.
    return simulate(x0, x1, x2)


# Instantiate the optimizer class and perform optimization
optimizer = Optimizer(
    blackbox=blackbox_func,
    trainer=KMTrainer(),  # Set a surrogate model
    client=FixstarsClient(),  # Set an Ising machine
)

optimizer.add_random_training_data(num_data=2) # Generate and add initial training data samples (2 samples)

optimizer.optimize(num_iterations=10) # Perform optimization cycles for 10 times


# Display optimization result
print(f"{optimizer.best=}")