PopulationAnnealingQpu

Population Annealing uses a sequential Monte Carlo method to minimize the energy of a population. The population consists of walkers that can explore their neighborhood during the cooling process. Afterwards, walkers are removed and duplicated using bias to lower energy. Eventually, a population collapse occurs where all walkers are in the lowest energy state.

Note

This solver is only available for commercial and academic licenses.

---

Compatible Backends

The PopulationAnnealingQpu algorithm supports the following backends:

• DWaveQpu

By default, PopulationAnnealingQpu uses the DWaveQpu backend.

---

Initialization

The following section outlines the default configurations of PopulationAnnealingQpu. You can also specify other compatible backends for the algorithm. When backend=None is specified, the default backend will be initialized automatically. In this case, if the backend requires a token, it will be taken from the environment variables.

Default Configuration

from luna_quantum.solve.parameters.algorithms import PopulationAnnealingQpu
from luna_quantum.solve.parameters.algorithms.base_params import (
    Decomposer,
    QuantumAnnealingParams
)

algorithm = PopulationAnnealingQpu(
    backend=None,
    num_reads=100,
    num_retries=0,
    max_iter=20,
    max_time=2,
    fixed_temp_sampler_num_sweeps=10000,
    fixed_temp_sampler_num_reads=None,
    decomposer=Decomposer(
        size=10,
        min_gain=None,
        rolling=True,
        rolling_history=1.0,
        silent_rewind=True,
        traversal='energy'
    ),
    quantum_annealing_params=QuantumAnnealingParams(
        anneal_offsets=None,
        anneal_schedule=None,
        annealing_time=None,
        auto_scale=None,
        fast_anneal=False,
        flux_biases=None,
        flux_drift_compensation=True,
        h_gain_schedule=None,
        initial_state=None,
        max_answers=None,
        num_reads=1,
        programming_thermalization=None,
        readout_thermalization=None,
        reduce_intersample_correlation=False,
        reinitialize_state=None
    )
)

Parameter Details

For a complete overview of available parameters and their usage, see the PopulationAnnealingQpu API Reference.

---

Usage

from luna_quantum import LunaSolve

LunaSolve.authenticate("<YOUR_LUNA_API_KEY>")

# Define your model and algorithm
model = ...
algorithm = ...

solve_job = algorithm.run(model, name="my-solve-job")

---

API Reference

Bases: LunaAlgorithm[DWaveQpu]

Parameters for the Population Annealing QPU algorithm.

Population Annealing uses a sequential Monte Carlo method to minimize the energy of a population. The population consists of walkers that can explore their neighborhood during the cooling process. Afterwards, walkers are removed and duplicated using bias to lower energy. Eventually, a population collapse occurs where all walkers are in the lowest energy state.

Attributes:

Name	Type	Description
num_reads	int	Number of annealing cycles to perform on the D-Wave QPU. Default is 100.
num_retries	int	Number of attempts to retry embedding the problem onto the quantum hardware. Default is 0.
max_iter	int	Maximum number of iterations. Controls how many rounds of annealing and population adjustments are performed. Default is 20.
max_time	int	Maximum time in seconds that the algorithm is allowed to run. Serves as a stopping criterion alongside max_iter. Default is 2.
fixed_temp_sampler_num_sweeps	int	Number of Monte Carlo sweeps to perform, where one sweep attempts to update all variables once. More sweeps produce better equilibrated samples but increase computation time. Default is 10,000, which is suitable for thorough exploration of moderate-sized problems.
fixed_temp_sampler_num_reads	int | None	Number of independent sampling runs to perform. Each run produces one sample from the equilibrium distribution. Multiple reads provide better statistical coverage of the solution space. Default is None, which typically defaults to 1 or matches the number of initial states provided.
decomposer	Decomposer	Decomposer: Breaks down problems into subproblems of manageable size Default is a Decomposer instance with default settings.
quantum_annealing_params	QuantumAnnealingParams	Parameters that control the quantum annealing process, including annealing schedule, temperature settings, and other quantum-specific parameters. These settings determine how the system transitions from quantum superposition to classical states during the optimization process.

backend class-attribute instance-attribute

backend: BACKEND_TYPE | None = Field(default=None, exclude=True, repr=False)

decomposer class-attribute instance-attribute

decomposer: Decomposer = Field(default_factory=Decomposer)

fixed_temp_sampler_num_reads class-attribute instance-attribute

fixed_temp_sampler_num_reads: int | None = None

fixed_temp_sampler_num_sweeps class-attribute instance-attribute

fixed_temp_sampler_num_sweeps: int = 10000

max_iter class-attribute instance-attribute

max_iter: int = 20

max_time class-attribute instance-attribute

max_time: int = 2

model_config class-attribute instance-attribute

model_config = ConfigDict(
    arbitrary_types_allowed=True, extra="allow", validate_assignment=True
)

num_reads class-attribute instance-attribute

num_reads: int = 100

num_retries class-attribute instance-attribute

num_retries: int = 0

quantum_annealing_params class-attribute instance-attribute

quantum_annealing_params: QuantumAnnealingParams = Field(
    default_factory=QuantumAnnealingParams
)

get_compatible_backends classmethod

get_compatible_backends() -> tuple[type[DWaveQpu], ...]

Check at runtime if the used backend is compatible with the solver.

Returns:

Type	Description
tuple[type[IBackend], ...]	True if the backend is compatible with the solver, False otherwise.

get_default_backend classmethod

get_default_backend() -> DWaveQpu

Return the default backend implementation.

This property must be implemented by subclasses to provide the default backend instance to use when no specific backend is specified.

Returns:

Type	Description
IBackend	An instance of a class implementing the IBackend interface that serves as the default backend.

run

run(
    model: Model | str,
    name: str | None = None,
    backend: BACKEND_TYPE | None = None,
    client: LunaSolve | str | None = None,
    *args: Any,
    **kwargs: Any,
) -> SolveJob

Run the configured solver.

Parameters:

Name	Type	Description	Default
model	Model or str	The model to be optimized or solved. It could be an Model instance or a string identifier representing the model id.	required
name	str | None	If provided, the name of the job. Defaults to None.	None
backend	BACKEND_TYPE | None	Backend to use for the solver. If not provided, the default backend is used.	None
client	LunaSolve or str	The client interface used to interact with the backend services. If not provided, a default client will be used.	None
*args	Any	Additional arguments that will be passed to the solver or client.	()
**kwargs	Any	Additional keyword parameters for configuration or customization.	{}

Returns:

Type	Description
SolveJob	The job object containing the information about the solve process.