Using Leap’s Hybrid Solvers#

Introduces Leap‘s quantum-classical hybrid solvers and provides references to usage information.

Note

Not all accounts have access to this type of solver.

Leap’s Hybrid Solvers#

Leap’s quantum-classical hybrid solvers are intended to solve arbitrary application problems formulated as quadratic and nonlinear models[1].

These solvers, which implement state-of-the-art classical algorithms together with intelligent allocation of the quantum computer to parts of the problem where it benefits most, are designed to accommodate even very large problems. Leap’s hybrid solvers enable you to benefit from D-Wave’s deep investment in researching, developing, optimizing, and maintaining hybrid algorithms.

The generally available hybrid solvers depend on your Leap™ account. Check your Leap dashboard to see which hybrid solvers are available to you.

Generally-available hybrid solvers currently supported in Leap include:

  • Hybrid BQM solver (e.g., hybrid_binary_quadratic_model_version2)

    Binary quadratic models (BQM) typically represent problems of decisions that could either be true (or yes) or false (no); for example, should an antenna transmit, or did a network node fail?

    These solvers accept arbitrarily structured, unconstrained problems formulated as BQMs, with any constraints typically represented through penalty models.

  • Hybrid CQM solver (e.g., hybrid_constrained_quadratic_model_version1)

    Constrained quadratic models (CQM) typically represent problems that might include real, integer and/or binary variables and one or more constraints.

    These solvers accept arbitrarily structured problems formulated as CQMs, with any constraints represented natively.

  • Hybrid DQM solver (e.g., hybrid_discrete_quadratic_model_version1)

    Discrete quadratic models (DQM) typically represent problems with several distinct options; for example, which shift should employee X work, or should the state on a map be colored red, blue, green, or yellow?

    These solvers accept arbitrarily structured, unconstrained problems formulated as DQMs, with any constraints typically represented through penalty models.

  • Hybrid nonlinear-program solver (e.g., hybrid_nonlinear_program_version1)

    Nonlinear models typically represent problems that might include integer and/or binary variables and one or more constraints. Such models are especially suited for use with decision variables that represent a common logic, such as subsets of choices or permutations of ordering. For example, in a traveling salesperson problem, permutations of the variables representing cities can signify the order of the route being optimized, and in a knapsack problem, the variables representing items can be divided into subsets of packed and not packed.

    These solvers accept arbitrarily structured problems formulated as nonlinear models, with any constraints represented natively.

Contact D-Wave at sales@dwavesys.com if your application requires scale or performance that exceeds the currently advertised capabilities of Leap’s generally available hybrid solvers.

Solver Properties and Parameters#

The Solver Properties and Parameters Reference guide details limitations on problem size, the range of time allowed for solving problems, etc and input arguments that enable you to configure execution.

Solver Timing#

The table below lists the timing information returned from Leap‘s quantum-classical hybrid solvers. Ocean users access to this information is from the info field in the dimod SampleSet class, as in the example below.

>>> import dimod
>>> from dwave.system import LeapHybridSampler
...
>>> sampler = LeapHybridSampler(solver={'category': 'hybrid'})
>>> bqm = dimod.generators.ran_r(1, 300)
>>> sampleset = sampler.sample(bqm)
>>> sampleset.info     
{'qpu_access_time': 41990, 'charge_time': 2991424, 'run_time': 2991424}
Table 3 Timing Information from Leap’s Hybrid Solvers#

Field

Meaning

run_time

Time, in microseconds, the hybrid solver spent working on the problem.

charge_time

Time, in microseconds, charged to the account. [2]

qpu_access_time

QPU time, in microseconds, used by the hybrid solver. [3]

Solver Usage Charges#

D-Wave charges you for time that solvers run your problems, with rates depending on QPU usage. You can see the rate at which your account’s quota is consumed for a particular solver in the solver’s quota_conversion_rate property.

You can see the time you are charged for in the responses returned for your submitted problems. The relevant field in the response is 'charge_time'. The example in the Solver Timing section shows 'charge_time': 2991424 in the returned response, meaning almost 3 seconds are being charged.

Instantiating the needed compute resources for your problem can introduce a delay before the problem is processed. This delay tends to be small compared to the overall solution time for large problems. The charge_time does not include this delay.

Examples#

Use a hybrid solver as you would any Ocean sampler. For example, given a 1000-variable problem formulated as a quadratic unconstrained binary optimization (QUBO) model, \(Q\), you can submit it for solution to a hybrid BQM solver as follows:

from dwave.system import LeapHybridSampler

# Select a solver
sampler = LeapHybridSampler()

# Submit for solution
answer = sampler.sample_qubo(Q)

Further Information#

You can find more detailed information and usage examples here: