Skip to main content

D-Wave

D-Wave's quantum annealing hardware relies on metal loops of niobium that have tiny electrical currents running through them.

Solvers

We offer access to D-Wave QPU Samplers, classical simulators, and D-Wave Leap Hybrid.

ModelBackends (see catalog for complete list)
BinaryQuadraticModeldwave.Advantage_system6.4, dwave.Advantage2_prototype2.3, dwave.SimulatedAnnealingSampler, dwave.RandomSampler, dwave.hybrid_binary_quadratic_model_version2p
ConstrainedQuadraticModeldwave.hybrid_constrained_quadratic_model_version1p
DiscreteQuadraticModeldwave.hybrid_discrete_quadratic_model_version1p

Samplers

D-Wave samplers are designed to solve problems that can be formulated as binary quadratic models (BQM). The samplers are used to find the lowest energy state of the BQM.

Advantage QPUs

  • Advantage_system6.4
  • Advantage2_prototype2.3

https://www.dwavesys.com/solutions-and-products/systems/

import strangeworks as sw
from strangeworks_optimization import StrangeworksOptimizer
from strangeworks_optimization_models.parameter_models import DwaveSamplerParameterModel
from dimod import BinaryQuadraticModel

sw.authenticate('your-api-key')

linear = {1: -2, 2: -2, 3: -3, 4: -3, 5: -2}
quadratic = {(1, 2): 2, (1, 3): 2, (2, 4): 2, (3, 4): 2, (3, 5): 2, (4, 5): 2}
model = BinaryQuadraticModel(linear, quadratic, "BINARY")

# solver = "dwave.Advantage_system6.4"
solver = "dwave.Advantage2_prototype2.3"
options = DwaveSamplerParameterModel(num_reads=100, chain_strength=50)

optimizer = StrangeworksOptimizer(model=model, solver=solver, options=options)
sw_job = optimizer.run()

print(f"Job slug: {sw_job.slug}")
print(f"Job status: {optimizer.status(sw_job.slug)}")

results = optimizer.results(sw_job.slug)

print(f"Best solution:\n{results.solution.first}")

Simulators

import strangeworks as sw
from strangeworks_optimization import StrangeworksOptimizer
from strangeworks_optimization_models.parameter_models import DwaveSamplerParameterModel
from dimod import BinaryQuadraticModel

sw.authenticate('your-api-key')

linear = {1: -2, 2: -2, 3: -3, 4: -3, 5: -2}
quadratic = {(1, 2): 2, (1, 3): 2, (2, 4): 2, (3, 4): 2, (3, 5): 2, (4, 5): 2}
model = BinaryQuadraticModel(linear, quadratic, "BINARY")

# solver = "dwave.SimulatedAnnealingSampler"
solver = "dwave.RandomSampler"

optimizer = StrangeworksOptimizer(model=model, solver=solver)
sw_job = optimizer.run()

print(f"Job slug: {sw_job.slug}")
print(f"Job status: {optimizer.status(sw_job.slug)}")

results = optimizer.results(sw_job.slug)

print(f"Best solution:\n{results.solution.first}")

Leap Hybrid Solvers

  • hybrid_binary_quadratic_model_version2p
  • hybrid_constrained_quadratic_model_version1p
  • hybrid_discrete_quadratic_model_version1p

https://www.dwavesys.com/solutions-and-products/cloud-platform/

BinaryQuadraticModel

import strangeworks as sw
from strangeworks_optimization import StrangeworksOptimizer
from strangeworks_optimization_models.parameter_models import DwaveSamplerParameterModel
from dimod import BinaryQuadraticModel

sw.authenticate('your-api-key')

linear = {1: -2, 2: -2, 3: -3, 4: -3, 5: -2}
quadratic = {(1, 2): 2, (1, 3): 2, (2, 4): 2, (3, 4): 2, (3, 5): 2, (4, 5): 2}
model = BinaryQuadraticModel(linear, quadratic, "BINARY")

solver = "dwave.hybrid_binary_quadratic_model_version2p"

optimizer = StrangeworksOptimizer(model=model, solver=solver)
sw_job = optimizer.run()

ConstrainedQuadraticModel

import strangeworks as sw
from strangeworks_optimization import StrangeworksOptimizer
from strangeworks_optimization_models.parameter_models import DwaveSamplerParameterModel
from dimod import Binary, ConstrainedQuadraticModel

sw.authenticate('your-api-key')

weights = [0.9, 0.7, 0.2, 0.1]
capacity = 1
y = [Binary(f"y_{j}") for j in range(len(weights))]
x = [[Binary(f"x_{i}_{j}") for j in range(len(weights))] for i in range(len(weights))]
model = ConstrainedQuadraticModel()
model.set_objective(sum(y))

for i in range(len(weights)):
model.add_constraint(sum(x[i]) == 1, label=f"item_placing_{i}")

for j in range(len(weights)):
model.add_constraint(
sum(weights[i] * x[i][j] for i in range(len(weights))) - y[j] * capacity <= 0,
label=f"capacity_bin_{j}",
)

solver = "dwave.hybrid_constrained_quadratic_model_version1p"

optimizer = StrangeworksOptimizer(model=model, solver=solver)
sw_job = optimizer.run()

DiscreteQuadraticModel

import strangeworks as sw
from strangeworks_optimization import StrangeworksOptimizer
from strangeworks_optimization_models.parameter_models import DwaveSamplerParameterModel
from dimod import DiscreteQuadraticModel
import random

sw.authenticate('your-api-key')

model = DiscreteQuadraticModel()
for i in range(10):
model.add_variable(4)
for i in range(9):
for j in range(i + 1, 10):
model.set_quadratic_case(i, random.randrange(0, 4), j, random.randrange(0, 4), random.random())

solver = "dwave.hybrid_discrete_quadratic_model_version1p"

optimizer = StrangeworksOptimizer(model=model, solver=solver)
sw_job = optimizer.run()

DwaveSamplerParameterModel

For more information on the parameters, please refer to the D-Wave Solver Parameters documentation.

NameTypeDescriptionDefaultValues (Range)
num_readsintSpecifies the number of reads (solutions) to be obtained.1[1, max_num_reads]
chain_strengthintSets the strength of the chains in the embedding.Determined by solver[Depends on system]
anneal_offsetsList[float]Provides offsets to annealing paths, per qubit.No offsetsSpecified per qubit
anneal_scheduleList[List[float]]Specifies the custom annealing schedule as time and fraction.Standard scheduleSpecified per system
annealing_timefloatSets the duration of the annealing process per read.Default system valueSpecified per system
auto_scaleboolAutomatically rescales h and J values to the QPU's range.True[True, False]
flux_biasesList[float]Applies manual flux biases for qubit calibration.No biases[Depends on system]
flux_drift_compensationboolCompensates for flux drift in qubits.True[True, False]
h_gain_scheduleList[List[float]]Sets time-dependent gains for qubit biases.Not specified[Depends on system]
initial_statedictSets the initial state for reverse annealing.Not specified[Depends on system]
max_answersintLimits the number of answers returned.num_reads[1, num_reads]
num_spin_reversal_transformsintApplies spin reversal transforms to reduce noise.0[0, max_transforms]
programming_thermalizationfloatTime to wait post-programming for thermalization.1000 μs[0μs, max_thermal]
readout_thermalizationfloatTime to wait post-readout for thermalization.0 μs[0μs, max_thermal]
reduce_intersample_correlationboolAdds delays between samples to reduce correlations.False[True, False]
reinitialize_stateboolReinitializes to the initial state for each anneal cycle.False[True, False]