Solver Parameters

The quantum machine instructions (QMI) you send to D-Wave QPU solvers comprise problem parameters (e.g., linear biases, h, of an Ising problem) and solver parameters that control how the problem is run (e.g., an annealing schedule, anneal_schedule). Likewise, Leap hybrid solvers accept parameters that control how the problem is run.

This chapter describes, in alphabetical order, the solver parameters[1] accepted by SAPI solvers[2].

[1]Ocean software tools include various other parameters that are processed client-side, not sent on to SAPI; for example, the DWaveSampler class might accept a retry_interval to configure the time its failover routine waits for a solver if no solver is found. See the Ocean documentation for those parameters.
[2]Ocean software also provides classical solvers such as dwave-greedy that you can run locally. See the Ocean documentation for information on parameters of such solvers.

anneal_offsets

Supported on: DW-2000Q and its VFYC Solvers, and Advantage

Provides offsets to annealing paths, per qubit.

Provide an array of anneal offset values, in normalized offset units, for all qubits, working or not. Use 0 for no offset. Negative values produce a negative offset (qubits are annealed after the standard annealing trajectory); positive values produce a positive offset (qubits are annealed before the standard trajectory). Before using this parameter, query the solver properties to see whether the anneal_offset_ranges property exists and, if so, to obtain the permitted offset values per qubit.

Default is no offsets.

Relevant Properties

Example

This example offsets the anneal of a qubit in a two-qubit illustrative Ising problem.

>>> from dwave.system import FixedEmbeddingComposite, DWaveSampler
>>> qpu = DWaveSampler(solver={'topology__type': 'pegasus'})
>>> J = {(1, 2): -1}
>>> embedding = {1: [30], 2: [2940]}
>>> print(qpu.properties['anneal_offset_ranges'][2940])         
[-0.7012257815714587, 0.6717794151250857]
>>> sampler = FixedEmbeddingComposite(qpu, embedding)
>>> offset = [0]*qpu.properties['num_qubits']
>>> offset[2940]=0.2                                            
>>> sampleset = FixedEmbeddingComposite(qpu, embedding).sample_ising({}, J,
...                                     num_reads=1000, anneal_offsets=offset)   

The D-Wave system used for this example is an Advantage that has couplers between active qubits 30 and 2940. Select a suitable embedding for the QPU you run examples on.

anneal_schedule

Supported on: DW-2000Q and its VFYC Solvers, and Advantage

Introduces variations to the global anneal schedule. For a reverse anneal, use the anneal_schedule parameter with the initial_state and reinitialize_state parameters.

An anneal schedule variation is defined by a series of pairs of floating-point numbers identifying points in the schedule at which to change slope. The first element in the pair is time \(t\) in microseconds; the second, normalized persistent current \(s\) in the range [0,1]. The resulting schedule is the piecewise-linear curve that connects the provided points.

The following rules apply to the set of anneal schedule points provided:

  • Time \(t\) must increase for all points in the schedule.
  • For forward annealing, the first point must be \((0, 0)\).
  • For reverse annealing, the anneal fraction \(s\) must start and end at \(s = 1\).
  • In the final point, anneal fraction \(s\) must equal 1 and time \(t\) must not exceed the maximum value in the annealing_time_range property.
  • The number of points must be \(\geq 2\).
  • The upper bound is system-dependent; check the max_anneal_schedule_points property. For reverse annealing, the maximum number of points allowed is one more than the number given by this property.
  • Additional rules that govern maximum slope vary by product; check the QPU properties document for your system.

Default anneal schedules are described in the QPU-specific anneal schedules document provided through Leap.

Relevant Properties

Interacts with Parameters

Example

This illustrative example configures a reverse-anneal schedule on a random native problem.

>>> from dwave.system import DWaveSampler
>>> import random
>>> qpu = DWaveSampler()
>>> J = {coupler: random.choice([-1, 1]) for coupler in qpu.edgelist}
>>> initial = {qubit: random.randint(0, 1) for qubit in qpu.nodelist}
>>> reverse_schedule = [[0.0, 1.0], [5, 0.45], [99, 0.45], [100, 1.0]]
>>> reverse_anneal_params = dict(anneal_schedule=reverse_schedule,
...                              initial_state=initial,
...                              reinitialize_state=True)
>>> sampleset = qpu.sample_ising({}, J, num_reads=1000, **reverse_anneal_params)

annealing_time

Supported on: QPU and VFYC Solvers

Sets the duration, in microseconds, of quantum annealing time, per read. This value populates the qpu_anneal_time_per_sample field returned in the timing structure. Must be a positive integer.

Default value is shown by default_annealing_time.

Relevant Properties

Interacts with Parameters

Example

This illustrative example configures the anneal time on a random native problem.

>>> from dwave.system import DWaveSampler
>>> import random
>>> qpu = DWaveSampler()
>>> J = {coupler: random.choice([-1, 1]) for coupler in qpu.edgelist}
>>> long_time = qpu.properties["annealing_time_range"][1]
>>> sampleset = qpu.sample_ising({}, J, num_reads=10, annealing_time=long_time)

answer_mode

Supported on: QPU and VFYC Solvers, and Emulators

Indicates how answers are returned from the solver[3]. Supported values are,

  • raw—Answers returned individually in the order they were read from the solver. Use this setting if the returned time sequences are an important part of the solution data.

    The answer contains two fields, solutions and energies. The solutions field is a list of lists; the inner lists all have length num_qubits and entries from \({-1, +1}\) for Ising problems or \({0, 1}\) for QUBO problems. Values of \(3\) denote unused or inactive qubits. The energies field contains the energy of each corresponding solution.

  • histogram—Answers returned as a histogram sorted in order of increasing energies. Answers contain the solutions and energies fields, but solutions are unique and sorted in increasing-energy order. Duplicate answers are merged and include a num_occurrences field, which indicates how many times each solution appeared.

[3]Ocean tools receive these answers from SAPI and process them. For example, if you submit a problem using Ocean’s EmbeddingComposite, the answer is mapped from qubits to the logical variables of your problem.

For optimizing emulator solvers, when answer_mode is histogram, the num_occurrences field contains all ones, except possibly for the lowest-energy solution. That first entry is set so that the sum of all entries is num_reads.

Default value is histogram.

Interacts with Parameters

Example

This illustrative example sets the answer format to raw.

>>> from dwave.system import DWaveSampler, EmbeddingComposite
>>> J = {('s1', 's2'): 0.5, ('s1', 's3'): 0.5, ('s2', 's3'): 0.5}
>>> sampleset = EmbeddingComposite(DWaveSampler()).sample_ising({}, J,
...                                            num_reads=100, answer_mode='raw')

auto_scale

Supported on: QPU and VFYC Solvers

Indicates whether \(h\) and \(J\) values are rescaled:

  • true\(h\) and \(J\) values in the problem are rescaled to use as much of the range of \(h\) (h_range) and the range of \(J\) (j_range) as possible. When enabled, \(h\) and \(J\) values need not lie within the solver’s range of \(h\) and \(J\), but must still be finite.
  • false\(h\) and \(J\) values in the problem are used as is. If the \(h\) and \(J\) values are outside the range of the solver, problem submission fails.

For problems that use the regular \(J\) range of a solver, this parameter is enabled by default. For problems that use the extended \(J\) range, it is disabled (and cannot be enabled while the extended range is in use). See also j_range and extended_j_range.

Auto-scaling works as follows. Each QPU has an allowed range of values for the biases and strengths of qubits and couplers. Unless you explicitly disable auto-scaling, the values defined in your problem are adjusted to fit the entire available range, by dividing them by a positive (non-zero) factor defined as:

\[ \begin{align}\begin{aligned}\max \bigl\{& \max \left( \frac{\max (h)}{\max (h\_range)}, 0 \right),\\ & \max \left( \frac{\min (h)}{\min(h\_range)}, 0 \right),\\ & \max \left( \frac{\max(J)}{\max(J\_range)}, 0 \right),\\ & \max \left( \frac{\min(J)}{\min(J\_range)}, 0 \right) \bigr\}\end{aligned}\end{align} \]

Ocean software’s samplers often have a chain strength parameter: because the QPU’s qubits are sparsely connected, problem variables might be represented by more than one physical qubit (a “chain” of qubits), strongly coupled so as to return the same value. Typically, chains are generated by minor-embedding tools such as Ocean’s minorminer. Setting a value for chain strength determines the values set for the couplers used in forming these chains. When using auto-scaling, the \(J\) values of chain couplers are scaled together with the given or converted \(J\) values. Similarly, if you disable auto-scaling, any chain strength you specify must result in coupling values within the allowed range for the QPU.

Problems specified in QUBO form are always converted to Ising for the submitted QMIs. When using auto-scaling, the converted problem’s \(h\) and \(J\) values are rescaled as described above. Note that bias values in the converted form, which have a dependency on the number of quadratic interactions in the QUBO, can be larger than the maximum bias of the original form. For example, the four-variable QUBO below, which has a maximum bias value of 2,

\[\begin{split}\begin{bmatrix} 2 & 2 & 1.5 & 2 \\ 0 & 1.5 & 0 & 0 \\ 0 & 0 & -0.5 & 0 \\ 0 & 0 & 0 & -1.0 \end{bmatrix}\end{split}\]

when converted to an Ising model, has a bias with a value greater than 2.0, \(h_1=2.375\), as shown below:

>>> import dimod
>>> Q = {(1, 1): 2, (2, 2): 1.5, (3, 3): -0.5, (4, 4): -1.0,
...      (1, 2): 2, (1, 3): 1.5, (1, 4): 2}
>>> dimod.qubo_to_ising(Q)
({1: 2.375, 2: 1.25, 3: 0.125, 4: 0.0}, {(1, 2): 0.5, (1, 3): 0.375, (1, 4): 0.5}, 2.375)

Default is to auto-scale problems.

Interacts with Parameters

Example

The example checks a QPU’s range of \(h\) and \(J\) before submitting a two-variable Ising problem to a QPU. auto_scale is implicitly True for the DWaveSampler class, so the \(h\) and \(J\) values are automatically rescaled by \(\frac{-3.6}{-2}=1.8\).

>>> from dwave.system import DWaveSampler, EmbeddingComposite
>>> sampler = EmbeddingComposite(DWaveSampler())
...
>>> sampler.child.properties['j_range']          
[-1.0, 1.0]
>>> sampler.child.properties['h_range']
[-2.0, 2.0]
>>> h = {'a': -3.6, 'b': 2.3}
>>> J = {('a', 'b'): 1.5}
>>> sampleset = sampler.sample_ising(h, J)

beta

Supported on: DW-2000Q and its VFYC Solvers, and Sampling Emulators

Provides a value for the Boltzmann distribution parameter. Used when sampling postprocessing is enabled on D-Wave 2000Q and earlier systems. Can be any finite float.

As in statistical mechanics, \(\beta\) represents inverse temperature: \(1/(k_B T)\), where \(T\) is the thermodynamic temperature in kelvin and \(k_B\) is Boltzmann’s constant. In the D-Wave software, postprocessing refines the returned solutions to target a Boltzmann distribution characterized by \(\beta\), which is represented by a floating point number without units. When choosing a value for \(\beta\), be aware that lower values result in samples less constrained to the lowest energy states. For more information on \(\beta\) and how it is used in the sampling postprocessing algorithm, see the Postprocessing Methods on D-Wave Systems guide.

Default value is 3.0 for sampling emulators and 10.0 for the D-Wave 2000Q VFYC .

Relevant Properties

Interacts with Parameters

  • postprocess defines what type of postprocessing the system runs.

Example

This illustrative example sets beta on a DW-2000Q system.

>>> from dwave.system import DWaveSampler
>>> import random
>>> qpu = DWaveSampler(solver={'topology__type': 'chimera'})
>>> J = {coupler: random.choice([-1, 1]) for coupler in qpu.edgelist}
>>> sampleset = qpu.sample_ising({}, J, num_reads=10, postprocess='sampling',
...                              beta=100)

chains

Supported on: DW-2000Q and its VFYC Solvers

Defines which qubits represent the same logical variable. Used only when postprocessing is enabled on D-Wave 2000Q and earlier systems. Ensures that all qubits in the same chain have the same value within each sample.

Provide the indices of the qubits that are in a chain. Qubits in a chain must be connected, and no qubit may appear more than once.

Default is no chains.

Interacts with Parameters

  • postprocess defines what type of postprocessing the system runs.

Example

This illustrative example provides the chains found by Ocean software’s minorminer.

>>> from dwave.system import DWaveSampler, FixedEmbeddingComposite
>>> import minorminer
...
>>> J = {('s1', 's2'): 0.5, ('s1', 's3'): 0.5, ('s2', 's3'): 0.5}
>>> qpu = DWaveSampler(solver={'topology__type': 'chimera'})
>>> embedding = minorminer.find_embedding(J.keys(), qpu.edgelist)
>>> sampleset = FixedEmbeddingComposite(qpu, embedding).sample_ising({}, J,
...                                           num_reads=10,
...                                           postprocess='sampling',
...                                           chains=list(embedding.values()))

flux_biases

Supported on: DW-2000Q and its VFYC Solvers, and Advantage

List of flux-bias offset values with which to calibrate a chain. Often required when using the extended \(J\) range to create a strongly coupled chain for certain embeddings, as described in the Technical Description of the D-Wave Quantum Processing Unit guide.

Provide an array of flux-bias offset values, in normalized offset units[4], for all qubits, working or not. Use 0 for no offset.

[4]Flux-biases applied to the qubit body are in units of \(\Phi_0\).

Default is no flux-bias offsets.

Relevant Properties

Interacts with Parameters

Example

This example sets a flux-bias value of a qubit in a two-qubit illustrative Ising problem.

>>> from dwave.system import FixedEmbeddingComposite, DWaveSampler
>>> qpu = DWaveSampler(solver={'topology__type': 'chimera'})
>>> J = {('s1', 's2'): 0.5, ('s1', 's3'): 0.5, ('s2', 's3'): 0.5}
>>> embedding = {'s1': [1444], 's2': [1441], 's3': [1445, 1443]}
>>> fb = [0]*qpu.properties['num_qubits']
>>> fb[1445] = 5*qpu.properties["anneal_offset_step_phi0"]            
>>> fb[1443] = -2*qpu.properties["anneal_offset_step_phi0"]           
>>> sampleset = FixedEmbeddingComposite(qpu, embedding).sample_ising({}, J,
...                num_reads=100, flux_drift_compensation=False, flux_biases=fb)   

The D-Wave system used for this example is a DW-2000Q that has particular couplers. Select a suitable embedding for the QPU you run examples on.

flux_drift_compensation

Supported on: DW-2000Q and its VFYC Solvers, and Advantage

Boolean flag indicating whether the D-Wave system compensates for flux drift. The procedure it follows to do so is described in detail in Appendix A of the Postprocessing Methods on D-Wave Systems guide.

  • flux_drift_compensation=true—Compensate for flux drift.
  • flux_drift_compensation=false—Do not compensate for flux drift.

Default is to compensate for flux drift.

Interacts with Parameters

  • flux_biases enables you to apply flux-bias offsets manually, which you may want to do If you disable this parameter.

Example

This example disables flux-drift compensation.

>>> from dwave.system import EmbeddingComposite, DWaveSampler
>>> sampler = EmbeddingComposite(DWaveSampler())
>>> J = {('s1', 's2'): 0.5, ('s1', 's3'): 0.5, ('s2', 's3'): 0.5}
>>> sampleset = sampler.sample_ising({}, J, num_reads=100,
...                                  flux_drift_compensation=False)

h_gain_schedule

Supported on: DW-2000Q and its VFYC Solvers, and Advantage

Sets a time-dependent gain for linear coefficients (qubit biases, see the h parameter) in the Hamiltonian. This parameter enables you to specify the \(g(t)\) function in,

\begin{equation} {\cal H}_{ising} = - \frac{A({s})}{2} \left(\sum_i {\hat\sigma_{x}^{(i)}}\right) + \frac{B({s})}{2} \left(g(t) \sum_{i} h_i {\hat\sigma_{z}^{(i)}} + \sum_{i>j} J_{i,j} {\hat\sigma_{z}^{(i)}} {\hat\sigma_{z}^{(j)}}\right) \end{equation}

where \({\hat\sigma_{x,z}^{(i)}}\) are Pauli matrices operating on a qubit \(q_i\) and \(h_i\) and \(J_{i,j}\) are the qubit biases and coupling strengths.

This time-dependent gain, \(g(t)\), is specified, similarly to the anneal_schedule parameter, by a series of pairs of floating-point numbers identifying points in the schedule at which to change the gain applied to h. The first element in the pair is time, \(t\) in microseconds; the second, the unitless \(g\) in the range h_gain_schedule_range. The resulting time-dependent gain is the piecewise-linear curve that connects the provided points over the same range of times as the anneal_schedule.

The following rules apply to the set of gain points provided:

  • Time \(t\), in microseconds, must increase for all points in the schedule.
  • The first point of time must be zero, \(t=0.0\).
  • The last point of time must match the last time in the anneal_schedule or the annealing_time.
  • The number of points must be \(\geq 2\).
  • Additional rules that govern maximum slope (i.e., how quickly \(g(t)\) can change) vary by product; check the QPU properties document for your system.

Default \(g(t)\), when left unspecified, is 1, which can be explicitly coded as

h_gain_schedule=[[0,1],[t_final,1]]

where t_final is the requested annealing time.

Relevant Properties

  • h_gain_schedule_range defines the range of the time-dependent gain values permitted for the solver.

    Note

    In conjunction with the auto_scale parameter, the h_gain_schedule parameter enables you to extend the range of your submitted problem’s linear coefficients (h) beyond the advertised h_range. Such use is not recommended for standard problem solving: the QPU is calibrated for linearity only within the advertised h_range and j_range. Increased integrated control errors (ICE) are expected outside that range.

    If you configure auto_scale=False when using this parameter, ensure that \(\max_i(h\_gain*h_i)\) and \(\min_i(h\_gain*h_i)\) are within h_range.

  • max_anneal_schedule_points defines the maximum number of points permitted.

  • max_h_gain_schedule_points defines the maximum number of gain changes allowed.

Interacts with Parameters

  • h defines the linear biases for the problem.
  • anneal_schedule defines the anneal schedule.

Example

This illustrative example sets an h-gain schedule.

>>> from dwave.system import EmbeddingComposite, DWaveSampler
>>> sampler = EmbeddingComposite(DWaveSampler())
>>> h = {'s1': 1, 's2': 1.5, 's3': -0.75}
>>> J = {('s1', 's2'): 0.5, ('s1', 's3'): 0.5, ('s2', 's3'): 0.5}
>>> anneal_schedule = [[0.0, 0.0], [40.0, 0.4], [140.0, 0.4], [150, 1.0]]
>>> h_schedule = [[0.0, 1], [40.0, 1], [140.0, 2], [143.0, 0], [150, 0]]
>>> sampleset = sampler.sample_ising(h, J, num_reads=500,
...                                  anneal_schedule=anneal_schedule,
...                                  h_gain_schedule=h_schedule)

initial_state

Supported on: DW-2000Q and its VFYC Solvers, and Advantage

Initial state to which the system is set for reverse annealing. Specifies the initial classical state of all qubits.

Provide (qubit, state) pairs, where qubit is the qubit index, i, and state is:

  • -1 or 1—Ising problems, active qubits
  • 0 or 1—QUBO problems, active qubits
  • 3—Unused or inactive qubits

Interacts with Parameters

Example

This illustrative example configures a reverse-anneal schedule on a random native problem.

>>> from dwave.system import DWaveSampler
>>> import random
>>> qpu = DWaveSampler()
>>> J = {coupler: random.choice([-1, 1]) for coupler in qpu.edgelist}
>>> initial = {qubit: random.randint(0, 1) for qubit in qpu.nodelist}
>>> reverse_schedule = [[0.0, 1.0], [5, 0.45], [99, 0.45], [100, 1.0]]
>>> reverse_anneal_params = dict(anneal_schedule=reverse_schedule,
...                              initial_state=initial,
...                              reinitialize_state=True)
>>> sampleset = qpu.sample_ising({}, J, num_reads=1000, **reverse_anneal_params)

max_answers

Supported on: QPU and VFYC Solvers, and Emulators

Specifies the maximum number of answers returned from the solver. Must be an integer > 0.

  • If answer_mode is histogram—Total number of distinct answers. Because answers in this mode are sorted by energy, these are the best max_answers answers.
  • If answer_mode is raw—Limits the returned values to the first max_answers of num_reads samples. In this mode, max_answers should never be more than num_reads.

Default value is num_reads.

Interacts with Parameters

Example

This illustrative example resulted in fewer samples than the configured num_reads.

>>> from dwave.system import EmbeddingComposite, DWaveSampler
>>> sampler = EmbeddingComposite(DWaveSampler())
>>> J = {('s1', 's2'): 0.5, ('s1', 's3'): 0.5, ('s2', 's3'): 0.5}
>>> sampleset = sampler.sample_ising({}, J, num_reads=1000,
...                                  max_answers=5)
>>> print(sampleset)                                     
  s1 s2 s3 energy num_oc. chain_.
0 +1 -1 -1   -0.5     202     0.0
1 -1 -1 +1   -0.5     132     0.0
2 +1 -1 +1   -0.5     112     0.0
3 -1 +1 -1   -0.5     248     0.0
4 -1 +1 +1   -0.5      95     0.0
['SPIN', 5 rows, 789 samples, 3 variables]

num_reads

Supported on: QPU and VFYC Solvers, and Emulators

Indicates the number of states (output solutions) to read[5] from the solver. Must be a positive integer.

[5]Terms synonymous to reads are anneals and samples.

Default value is 1.

Interacts with Parameters

Example

This illustrative example requests 1250 samples.

>>> from dwave.system import EmbeddingComposite, DWaveSampler
>>> sampler = EmbeddingComposite(DWaveSampler())
>>> Q = {('x1', 'x2'): 1, ('x1', 'z'): -2, ('x2', 'z'): -2, ('z', 'z'): 3}
>>> sampleset = sampler.sample_qubo(Q, answer_mode='raw', num_reads=1250)
>>> len(sampleset)
1250

num_spin_reversal_transforms

Supported on: QPU and VFYC Solvers

Specifies the number of spin-reversal transforms[6] to perform.

[6]Also known as gauge transformations.

Applying a spin-reversal transform can improve results by reducing the impact of analog errors that may exist on the QPU. This technique works as follows: Given an \(n\)-variable Ising problem, we can select a random \(g\in\{\pm1\}^n\) and transform the problem via \(h_i\mapsto h_ig_i\) and \(J_{ij}\mapsto J_{ij}g_ig_j\). A spin-reversal transform does not alter the mathematical nature of the Ising problem. Solutions \(s\) of the original problem and \(s^\prime\) of the transformed problem are related by \(s^\prime_i=s_ig_i\) and have identical energies. However, the sample statistics can be affected by the spin-reversal transform because the QPU is a physical object with asymmetries.

Spin-reversal transforms work correctly with postprocessing and chains. Majority voting happens on the original problem state, not on the transformed state.

Use this parameter to specify how many spin-reversal transforms to perform on the problem. Valid values range from 0 (do not transform the problem; the default value) to a value equal to but no larger than the num_reads specified. If you specify a nonzero value, the system divides the number of reads by the number of spin-reversal transforms to determine how many reads to take for each transform. For example, if the number of reads is 10 and the number of transforms is 2, then 5 reads use the first transform and 5 use the second.

Be aware that each transform reprograms the QPU; therefore, using more than 1 transform will increase the amount of time required to solve the problem. For more information about timing, see Solver Computation Time.

Default is no spin-reversal transforms.

Interacts with Parameters

  • num_reads defines the maximum number of requested answers, and this is the maximum allowed value of spin-reversal transforms.
  • flux_biases and extended_j_range ranges are incompatible with spin-reversal transforms.

Example

This illustrative example executes 5 spin-reversal transforms.

>>> from dwave.system import EmbeddingComposite, DWaveSampler
>>> sampler = EmbeddingComposite(DWaveSampler())
>>> Q = {('x1', 'x2'): 1, ('x1', 'z'): -2, ('x2', 'z'): -2, ('z', 'z'): 3}
>>> sampleset = sampler.sample_qubo(Q, num_reads=100,
...                                 num_spin_reversal_transforms=5)

postprocess

Supported on: DW-2000Q and its VFYC Solvers

Postprocessing optimization and sampling algorithms provide local improvements with minimal overhead to solutions obtained from the quantum processing unit (QPU).

Ocean software provides postprocessing tools, and you can optionally run postprocessing online on D-Wave 2000Q and earlier systems.

Defines what type of postprocessing the system runs online on raw solutions:

  • “” (empty string)—No postprocessing (default). Note that if this option is selected for the VFYC solver, sampling postprocessing runs.
  • sampling—Runs a short Markov-chain Monte Carlo (MCMC) algorithm with single bit-flips starting from each sample. The target probability distribution is a Boltzmann distribution at inverse temperature \(\beta\).
  • optimization—Performs a local search on each sample, stopping at a local minimum.

When postprocessing is enabled, qubits in the same chain, defined by the chains parameter, are first set to the same value by majority vote. Postprocessing is performed on the logical problem but qubit-level answers are returned. For more information about postprocessing, see the Postprocessing Methods on D-Wave Systems guide.

For problems that use the VFYC solver, postprocessing always runs. If you do not choose a postprocessing option, sampling postprocessing runs. When sampling postprocessing runs, the default \(\beta\) value is 10.

Example

This illustrative example uses postprocessing on a DW-2000Q system.

>>> from dwave.system import EmbeddingComposite, DWaveSampler
>>> sampler = EmbeddingComposite(DWaveSampler(solver={'topology__type': 'chimera'}))
>>> Q = {('x1', 'x2'): 1, ('x1', 'z'): -2, ('x2', 'z'): -2, ('z', 'z'): 3}
>>> sampleset = sampler.sample_qubo(Q, num_reads=10, postprocess='sampling')

programming_thermalization

Supported on: QPU and VFYC Solvers

Sets the time, in microseconds, to wait after programming the QPU for it to cool back to base temperature (i.e., post-programming thermalization time). Lower values accelerate solving at the expense of solution quality. Must be an integer. This value contributes to the total qpu_programming_time, which is returned by SAPI with the problem solutions.

Default value for a solver is given in the default_programming_thermalization property.

Relevant Properties

Interacts with Parameters

Example

This illustrative example sets a value of half the supported maximum.

>>> from dwave.system import EmbeddingComposite, DWaveSampler
>>> sampler = EmbeddingComposite(DWaveSampler())
>>> Q = {('x1', 'x2'): 1, ('x1', 'z'): -2, ('x2', 'z'): -2, ('z', 'z'): 3}
>>> pt = int(sampler.child.properties["programming_thermalization_range"][1]/2)  
>>> sampleset = sampler.sample_qubo(Q, num_reads=10,
...                                 programming_thermalization=pt)      

readout_thermalization

Supported on: QPU and VFYC Solvers

Sets the time, in microseconds, to wait after each state is read from the QPU for it to cool back to base temperature (i.e., post-readout thermalization time). This value contributes to the qpu_delay_time_per_sample field, which is returned with the problem solutions. Must be an integer.

Default value for a solver is given in the default_readout_thermalization property.

Relevant Properties

Interacts with Parameters

Example

This illustrative example sets a value of half the supported maximum.

>>> from dwave.system import EmbeddingComposite, DWaveSampler
>>> sampler = EmbeddingComposite(DWaveSampler())
>>> Q = {('x1', 'x2'): 1, ('x1', 'z'): -2, ('x2', 'z'): -2, ('z', 'z'): 3}
>>> rt = int(sampler.child.properties["readout_thermalization_range"][1]/2)    
>>> sampleset = sampler.sample_qubo(Q, num_reads=10,
...                                 readout_thermalization=rt)       

reduce_intersample_correlation

Supported on: DW-2000Q and its VFYC Solvers, and Advantage

Reduces sample-to-sample correlations caused by the spin-bath polarization effect[7] by adding a delay between reads.

[7]See the Technical Description of the D-Wave Quantum Processing Unit for more information on this effect.

Boolean flag indicating whether the system adds a delay.

  • reduce_intersample_correlation=true—Adds delay.
  • reduce_intersample_correlation=false (default)—Does not add delay.

Important

Enabling this parameter drastically increases problem run times. To avoid exceeding the maximum problem run time configured for your system, limit the number of reads when using this feature. For more information on timing, see the Solver Computation Time guide.

Default is to not add delay between reads.

Example

This illustrative example configures a delay between reads.

>>> from dwave.system import EmbeddingComposite, DWaveSampler
>>> sampler = EmbeddingComposite(DWaveSampler())
>>> Q = {('x1', 'x2'): 1, ('x1', 'z'): -2, ('x2', 'z'): -2, ('z', 'z'): 3}
>>> sampleset = sampler.sample_qubo(Q, num_reads=10,
...                                 reduce_intersample_correlation=True)

reinitialize_state

Supported on: DW-2000Q and its VFYC Solvers, and Advantage

When using the reverse annealing feature, you must supply the initial state to which the system is set; see the initial_state parameter. If multiple reads are requested in a single call to the Solver API, you have two options for the starting state of the system. These are controlled by the reinitialize_state Boolean parameter:

  • reinitialize_state=true—Reinitialize to the specified initial state for every anneal-readout cycle. Each anneal begins from the state given in the initial_state parameter. The amount of time required to reinitialize varies by system; typical D-Wave 2000Q systems require between 100 and 600 microseconds for this operation.
  • reinitialize_state=false—Initialize only at the beginning, before the first anneal cycle. Each anneal (after the first) is initialized from the final state of the qubits after the previous cycle. Be aware that even if this parameter is disabled, reverse annealing adds a small amount of time (\(\approx 10 \ \mu s\)) for each read.

See also anneal_schedule.

Default is to reinitialize to the specified initial state for every anneal in reverse-anneal submissions.

Interacts with Parameters

Example

This illustrative example configures a reverse-anneal schedule on a random native problem with each anneal initialized from the final state of the previous cycle.

>>> from dwave.system import DWaveSampler
>>> import random
>>> qpu = DWaveSampler()
>>> J = {coupler: random.choice([-1, 1]) for coupler in qpu.edgelist}
>>> initial = {qubit: random.randint(0, 1) for qubit in qpu.nodelist}
>>> reverse_schedule = [[0.0, 1.0], [5, 0.45], [99, 0.45], [100, 1.0]]
>>> reverse_anneal_params = dict(anneal_schedule=reverse_schedule,
...                              initial_state=initial,
...                              reinitialize_state=False)
>>> sampleset = qpu.sample_ising({}, J, num_reads=1000, **reverse_anneal_params)

time_limit

Supported on: Leap’s Hybrid Solvers

Specifies the maximum run time, in seconds, the solver is allowed to work on the given problem. Can be a float or integer.

Default value is problem dependent.

Relevant Properties

Example

This illustrative example configures a time limit of 6 seconds.

>>> from dwave.system import LeapHybridSampler
>>> Q = {('x1', 'x2'): 1, ('x1', 'z'): -2, ('x2', 'z'): -2, ('z', 'z'): 3}
>>> sampleset = LeapHybridSampler().sample_qubo(Q, time_limit=6)