Simulated Annealing

Short Name: SA
Algorithm Type: Classical
Category: Classical
Native Input Format: BQM

Simulated Annealing is a probabilistic technique for approximating the global optimum of a given function. It performs well on problems where approximate global optima are more desirable than exact local optima. For more details, check the D-Wave website.

Usage via LunaSolve

# Example of using SA using the Luna backend in LunaSolve
solution = ls.solution.create(
    optimization_id=optimization.id,
    solver_name="SA",
    provider="dwave",
    solver_parameters={
        "num_reads": None,
        "num_sweeps": 1000,
        "beta_range": None,
        "beta_schedule_type": "geometric",
        "initial_states_generator": "random",
        "num_sweeps_per_beta": 1,
        "seed": None,
        "beta_schedule": None,
        "initial_states": None,
        "randomize_order": False,
        "proposal_acceptance_criteria": "Metropolis",
    },
    qpu_tokens=None,
)

Usage via LunaBench

# Example of adding SA using the Luna backend as an algorithm to LunaBench
algorithms = {
    "SA": {
        "location": "cloud",
        "provider": "dwave",
    },
}

Backends

This algorithm can be run on the following backends:

Luna

Simulated Annealing available on Luna

Luna provides powerful servers designed to run classical algorithms. These servers offer the computational capacity required to efficiently solve non-quantum tasks, ensuring high performance for optimization and other classical workloads.

Population Annealing

Short Name: PA
Algorithm Type: Classical
Category: Classical
Native Input Format: BQM

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.

Usage via LunaSolve

# Example of using PA using the Luna backend in LunaSolve
solution = ls.solution.create(
    optimization_id=optimization.id,
    solver_name="PA",
    provider="dwave",
    solver_parameters={
        "fixed_temperature_sampler": {
            "num_sweeps": 10000,
            "num_reads": None,
        },
        "max_iter": 20,
        "max_time": 2,
    },
    qpu_tokens=None,
)

Usage via LunaBench

# Example of adding PA using the Luna backend as an algorithm to LunaBench
algorithms = {
    "PA": {
        "location": "cloud",
        "provider": "dwave",
    },
}

Backends

This algorithm can be run on the following backends:

Luna

Population Annealing available on Luna

Parallel Tempering

Short Name: PT
Algorithm Type: Classical
Category: Classical
Native Input Format: BQM

Parallel Tempering uses multiple optimization procedures per temperature. During the cooling process, an exchange of replicas can take place between the parallel procedures, thus enabling higher energy mountains to be overcome.

Usage via LunaSolve

# Example of using PT using the Luna backend in LunaSolve
solution = ls.solution.create(
    optimization_id=optimization.id,
    solver_name="PT",
    provider="dwave",
    solver_parameters={
        "n_replicas": 2,
        "random_swaps_factor": 1,
        "fixed_temperature_sampler": {
            "num_sweeps": 10000,
            "num_reads": None,
        },
        "cpu_count_multiplier": 5,
        "loop": {
            "max_iter": 100,
            "max_time": 5,
            "convergence": 3,
            "target": None,
            "rtol": 1e-05,
            "atol": 1e-08,
        },
    },
    qpu_tokens=None,
)

Usage via LunaBench

# Example of adding PT using the Luna backend as an algorithm to LunaBench
algorithms = {
    "PT": {
        "location": "cloud",
        "provider": "dwave",
    },
}

Backends

This algorithm can be run on the following backends:

Luna

Parallel Tempering available on Luna

Repeated Reverse Simulated Annealing

This solver is only available for commercial and academic licenses.

Short Name: RRSA
Algorithm Type: Classical
Category: Classical
Native Input Format: BQM

Repeated Reverse Simulated Annealing finds the solution to a problem using an annealing process. Initially, random states are chosen in the solution landscape. Afterwards, as the temperature decreases, states are chosen that are more energetically favorable. At the end of the complete annealing process, the resulting states make up the solution.

Usage via LunaSolve

# Example of using RRSA using the Luna backend in LunaSolve
solution = ls.solution.create(
    optimization_id=optimization.id,
    solver_name="RRSA",
    provider="dwave",
    solver_parameters={
        "simulated_annealing": {
            "num_reads": None,
            "num_sweeps": None,
            "beta_range": None,
            "beta_schedule_type": "geometric",
            "initial_states_generator": "random",
            "num_sweeps_per_beta": 1,
            "beta_schedule": None,
            "randomize_order": False,
            "proposal_acceptance_criteria": "Metropolis",
        },
        "num_reads_per_iter": None,
        "initial_states": None,
        "timeout": 5.0,
        "max_iter": 10,
        "target": None,
    },
    qpu_tokens=None,
)

Usage via LunaBench

# Example of adding RRSA using the Luna backend as an algorithm to LunaBench
algorithms = {
    "RRSA": {
        "location": "cloud",
        "provider": "dwave",
    },
}

Backends

This algorithm can be run on the following backends:

Luna

Repeated Reverse Simulated Annealing available on Luna

QBSolv Like Simulated Annealing

This solver is only available for commercial and academic licenses.

Short Name: QLSA
Algorithm Type: Hybrid
Category: Classical
Native Input Format: BQM

QBSolv Like Simulated Annealing breaks down the problem and solves the parts individually using a classic solver that uses Simulated Annealing. This particular implementation uses hybrid.SimulatedAnnealingSubproblemSampler as a sampler for the subproblems to achieve a QBSolv like behaviour.

Usage via LunaSolve

# Example of using QLSA using the Luna backend in LunaSolve
solution = ls.solution.create(
    optimization_id=optimization.id,
    solver_name="QLSA",
    provider="dwave",
    solver_parameters={
        "qbsolv_like": {
            "decomposer_size": 50,
            "rolling": True,
            "rolling_history": 0.15,
            "cpu_count_multiplier": 1,
            "loop": {
                "max_iter": 100,
                "max_time": 5,
                "convergence": 3,
                "target": None,
                "rtol": 1e-05,
                "atol": 1e-08,
            },
        },
        "simulated_annealing": {
            "num_reads": None,
            "num_sweeps": 1000,
            "beta_range": None,
            "beta_schedule_type": "geometric",
            "initial_states_generator": "random",
        },
    },
    qpu_tokens=None,
)

Usage via LunaBench

# Example of adding QLSA using the Luna backend as an algorithm to LunaBench
algorithms = {
    "QLSA": {
        "location": "cloud",
        "provider": "dwave",
    },
}

Backends

This algorithm can be run on the following backends:

Luna

QBSolv Like Simulated Annealing available on Luna