Composites

dimod composites that provide layers of pre- and post-processing (e.g., minor-embedding) when using the D-Wave system:

Other Ocean packages provide additional composites; for example, dimod provides composites that operate on the problem (e.g., scaling values), track inputs and outputs for debugging, and other useful functionality relevant to generic samplers.

CutOffs

Prunes the binary quadratic model (BQM) submitted to the child sampler by retaining only interactions with values commensurate with the sampler’s precision.

CutOffComposite

class CutOffComposite(child_sampler, cutoff, cutoff_vartype=Vartype.SPIN, comparison=<built-in function lt>)[source]

Composite to remove interactions below a specified cutoff value.

Prunes the binary quadratic model (BQM) submitted to the child sampler by retaining only interactions with values commensurate with the sampler’s precision as specified by the cutoff argument. Also removes variables isolated post- or pre-removal of these interactions from the BQM passed on to the child sampler, setting these variables to values that minimize the original BQM’s energy for the returned samples.

Parameters
  • sampler (dimod.Sampler) – A dimod sampler.

  • cutoff (number) – Lower bound for absolute value of interactions. Interactions with absolute values lower than cutoff are removed. Isolated variables are also not passed on to the child sampler.

  • cutoff_vartype (Vartype/str/set, default=’SPIN’) –

    Variable space to execute the removal in. Accepted input values:

    • Vartype.SPIN, 'SPIN', {-1, 1}

    • Vartype.BINARY, 'BINARY', {0, 1}

  • comparison (function, optional) – A comparison operator for comparing interaction values to the cutoff value. Defaults to operator.lt().

Examples

This example removes one interaction, 'ac': -0.7, before embedding on a D-Wave system. Note that the lowest-energy sample for the embedded problem is {'a': 1, 'b': -1, 'c': -1} but with a large enough number of samples (here num_reads=1000), the lowest-energy solution to the complete BQM is likely found and its energy recalculated by the composite.

>>> import dimod
>>> sampler = DWaveSampler(solver={'qpu': True})
>>> bqm = dimod.BinaryQuadraticModel({'a': -1, 'b': 1, 'c': 1},
...                            {'ab': -0.8, 'ac': -0.7, 'bc': -1},
...                            0,
...                            dimod.SPIN)
>>> CutOffComposite(AutoEmbeddingComposite(sampler), 0.75).sample(bqm,
...                 num_reads=1000).first.energy
-3.5

Properties

CutOffComposite.child

The child sampler.

CutOffComposite.children

List of child samplers that that are used by this composite.

CutOffComposite.properties

A dict containing any additional information about the sampler.

CutOffComposite.parameters

A dict where keys are the keyword parameters accepted by the sampler methods and values are lists of the properties relevent to each parameter.

Methods

CutOffComposite.sample(bqm, **parameters)

Cut off interactions and sample from the provided binary quadratic model.

CutOffComposite.sample_ising(h, J, **parameters)

Sample from an Ising model using the implemented sample method.

CutOffComposite.sample_qubo(Q, **parameters)

Sample from a QUBO using the implemented sample method.

PolyCutOffComposite

Prunes the polynomial submitted to the child sampler by retaining only interactions with values commensurate with the sampler’s precision.

class PolyCutOffComposite(child_sampler, cutoff, cutoff_vartype=Vartype.SPIN, comparison=<built-in function lt>)[source]

Composite to remove polynomial interactions below a specified cutoff value.

Prunes the binary polynomial submitted to the child sampler by retaining only interactions with values commensurate with the sampler’s precision as specified by the cutoff argument. Also removes variables isolated post- or pre-removal of these interactions from the polynomial passed on to the child sampler, setting these variables to values that minimize the original polynomial’s energy for the returned samples.

Parameters
  • sampler (dimod.PolySampler) – A dimod binary polynomial sampler.

  • cutoff (number) – Lower bound for absolute value of interactions. Interactions with absolute values lower than cutoff are removed. Isolated variables are also not passed on to the child sampler.

  • cutoff_vartype (Vartype/str/set, default=’SPIN’) –

    Variable space to do the cutoff in. Accepted input values:

    • Vartype.SPIN, 'SPIN', {-1, 1}

    • Vartype.BINARY, 'BINARY', {0, 1}

  • comparison (function, optional) – A comparison operator for comparing the interaction value to the cutoff value. Defaults to operator.lt().

Examples

This example removes one interaction, 'ac': 0.2, before submitting the polynomial to child sampler ExactSolver.

>>> import dimod
>>> sampler = dimod.HigherOrderComposite(dimod.ExactSolver())
>>> poly = dimod.BinaryPolynomial({'a': 3, 'abc':-4, 'ac': 0.2}, dimod.SPIN)
>>> PolyCutOffComposite(sampler, 1).sample_poly(poly).first.sample['a']
-1

Properties

PolyCutOffComposite.child

The child sampler.

PolyCutOffComposite.children

List of child samplers that that are used by this composite.

PolyCutOffComposite.properties

A dict containing any additional information about the sampler.

PolyCutOffComposite.parameters

A dict where keys are the keyword parameters accepted by the sampler methods and values are lists of the properties relevent to each parameter.

Methods

PolyCutOffComposite.sample_poly(poly, **kwargs)

Cutoff and sample from the provided binary polynomial.

PolyCutOffComposite.sample_hising(h, J, **kwargs)

Sample from a higher-order Ising model.

PolyCutOffComposite.sample_hubo(H, **kwargs)

Sample from a higher-order unconstrained binary optimization problem.

Embedding

Minor-embed a problem BQM into a D-Wave system.

Embedding composites for various types of problems and application. For example:

AutoEmbeddingComposite

class AutoEmbeddingComposite(child_sampler, **kwargs)[source]

Maps problems to a structured sampler, embedding if needed.

This composite first tries to submit the binary quadratic model directly to the child sampler and only embeds if a dimod.exceptions.BinaryQuadraticModelStructureError is raised.

Parameters
  • child_sampler (dimod.Sampler) – Structured dimod sampler, such as a DWaveSampler().

  • find_embedding (function, optional) – A function find_embedding(S, T, **kwargs) where S and T are edgelists. The function can accept additional keyword arguments. Defaults to minorminer.find_embedding().

  • kwargs – See the EmbeddingComposite class for additional keyword arguments.

Properties

AutoEmbeddingComposite.child

The child sampler.

AutoEmbeddingComposite.parameters

Parameters in the form of a dict.

AutoEmbeddingComposite.properties

Properties in the form of a dict.

Methods

AutoEmbeddingComposite.sample(bqm, **parameters)

Sample from the provided binary quadratic model.

AutoEmbeddingComposite.sample_ising(h, J, ...)

Sample from an Ising model using the implemented sample method.

AutoEmbeddingComposite.sample_qubo(Q, ...)

Sample from a QUBO using the implemented sample method.

EmbeddingComposite

class EmbeddingComposite(child_sampler, find_embedding=<function find_embedding>, embedding_parameters=None, scale_aware=False, child_structure_search=<function child_structure_dfs>)[source]

Maps problems to a structured sampler.

Automatically minor-embeds a problem into a structured sampler such as a D-Wave system. A new minor-embedding is calculated each time one of its sampling methods is called.

Parameters
  • child_sampler (dimod.Sampler) – A dimod sampler, such as a DWaveSampler, that accepts only binary quadratic models of a particular structure.

  • find_embedding (function, optional) – A function find_embedding(S, T, **kwargs) where S and T are edgelists. The function can accept additional keyword arguments. Defaults to minorminer.find_embedding().

  • embedding_parameters (dict, optional) – If provided, parameters are passed to the embedding method as keyword arguments.

  • scale_aware (bool, optional, default=False) – Pass chain interactions to child samplers that accept an ignored_interactions parameter.

  • child_structure_search (function, optional) – A function child_structure_search(sampler) that accepts a sampler and returns the dimod.Structured.structure. Defaults to dimod.child_structure_dfs().

Examples

>>> from dwave.system import DWaveSampler, EmbeddingComposite
...
>>> sampler = EmbeddingComposite(DWaveSampler())
>>> h = {'a': -1., 'b': 2}
>>> J = {('a', 'b'): 1.5}
>>> sampleset = sampler.sample_ising(h, J, num_reads=100)
>>> sampleset.first.energy
-4.5

Properties

EmbeddingComposite.child

The child sampler.

EmbeddingComposite.parameters

Parameters in the form of a dict.

EmbeddingComposite.properties

Properties in the form of a dict.

EmbeddingComposite.return_embedding_default

Defines the default behaviour for sample()'s return_embedding kwarg.

EmbeddingComposite.warnings_default

Defines the default behavior for sample()'s warnings kwarg.

Methods

EmbeddingComposite.sample(bqm[, ...])

Sample from the provided binary quadratic model.

EmbeddingComposite.sample_ising(h, J, ...)

Sample from an Ising model using the implemented sample method.

EmbeddingComposite.sample_qubo(Q, **parameters)

Sample from a QUBO using the implemented sample method.

FixedEmbeddingComposite

class FixedEmbeddingComposite(child_sampler, embedding=None, source_adjacency=None, **kwargs)[source]

Maps problems to a structured sampler with the specified minor-embedding.

Parameters
  • child_sampler (dimod.Sampler) – Structured dimod sampler such as a D-Wave system.

  • embedding (dict[hashable, iterable], optional) – Mapping from a source graph to the specified sampler’s graph (the target graph).

  • source_adjacency (dict[hashable, iterable]) – Deprecated. Dictionary to describe source graph as {node: {node neighbours}}.

  • kwargs – See the EmbeddingComposite class for additional keyword arguments. Note that find_embedding and embedding_parameters keyword arguments are ignored.

Examples

To embed a triangular problem (a problem with a three-node complete graph, or clique) in the Chimera topology, you need to chain two qubits. This example maps triangular problems to a composed sampler (based on the unstructured ExactSolver) with a Chimera unit-cell structure.

>>> import dimod
>>> import dwave_networkx as dnx
>>> from dwave.system import FixedEmbeddingComposite
...
>>> c1 = dnx.chimera_graph(1)
>>> embedding = {'a': [0, 4], 'b': [1], 'c': [5]}
>>> structured_sampler = dimod.StructureComposite(dimod.ExactSolver(),
...                                               c1.nodes, c1.edges)
>>> sampler = FixedEmbeddingComposite(structured_sampler, embedding)
>>> sampler.edgelist
[('a', 'b'), ('a', 'c'), ('b', 'c')]

Properties

FixedEmbeddingComposite.properties

Properties in the form of a dict.

FixedEmbeddingComposite.parameters

Parameters in the form of a dict.

FixedEmbeddingComposite.children

List containing the structured sampler.

FixedEmbeddingComposite.child

The child sampler.

FixedEmbeddingComposite.nodelist

Nodes available to the composed sampler.

FixedEmbeddingComposite.edgelist

Edges available to the composed sampler.

FixedEmbeddingComposite.adjacency

Adjacency structure for the composed sampler.

FixedEmbeddingComposite.structure

Structure of the structured sampler formatted as a namedtuple, Structure(nodelist, edgelist, adjacency), where the 3-tuple values are the nodelist, edgelist and adjacency attributes.

Methods

FixedEmbeddingComposite.sample(bqm, **parameters)

Sample the binary quadratic model.

FixedEmbeddingComposite.sample_ising(h, J, ...)

Sample from an Ising model using the implemented sample method.

FixedEmbeddingComposite.sample_qubo(Q, ...)

Sample from a QUBO using the implemented sample method.

LazyFixedEmbeddingComposite

class LazyFixedEmbeddingComposite(child_sampler, find_embedding=<function find_embedding>, embedding_parameters=None, scale_aware=False, child_structure_search=<function child_structure_dfs>)[source]

Maps problems to the structure of its first given problem.

This composite reuses the minor-embedding found for its first given problem without recalculating a new minor-embedding for subsequent calls of its sampling methods.

Parameters
  • child_sampler (dimod.Sampler) – Structured dimod sampler.

  • find_embedding (function, default=:func:minorminer.find_embedding) – A function find_embedding(S, T, **kwargs) where S and T are edgelists. The function can accept additional keyword arguments. The function is used to find the embedding for the first problem solved.

  • embedding_parameters (dict, optional) – If provided, parameters are passed to the embedding method as keyword arguments.

Examples

>>> from dwave.system import LazyFixedEmbeddingComposite, DWaveSampler
...
>>> sampler = LazyFixedEmbeddingComposite(DWaveSampler())
>>> sampler.nodelist is None  # no structure prior to first sampling
True
>>> __ = sampler.sample_ising({}, {('a', 'b'): -1})
>>> sampler.nodelist  # has structure based on given problem
['a', 'b']

Properties

LazyFixedEmbeddingComposite.parameters

Parameters in the form of a dict.

LazyFixedEmbeddingComposite.properties

Properties in the form of a dict.

LazyFixedEmbeddingComposite.nodelist

Nodes available to the composed sampler.

LazyFixedEmbeddingComposite.edgelist

Edges available to the composed sampler.

LazyFixedEmbeddingComposite.adjacency

Adjacency structure for the composed sampler.

LazyFixedEmbeddingComposite.structure

Structure of the structured sampler formatted as a namedtuple, Structure(nodelist, edgelist, adjacency), where the 3-tuple values are the nodelist, edgelist and adjacency attributes.

Methods

LazyFixedEmbeddingComposite.sample(bqm, ...)

Sample the binary quadratic model.

LazyFixedEmbeddingComposite.sample_ising(h, ...)

Sample from an Ising model using the implemented sample method.

LazyFixedEmbeddingComposite.sample_qubo(Q, ...)

Sample from a QUBO using the implemented sample method.

TilingComposite

class TilingComposite(sampler, sub_m, sub_n, t=4)[source]

Composite to tile a small problem across a structured sampler.

Enables parallel sampling on Chimera or Pegasus structured samplers of small problems. The small problem should be defined on a Chimera graph of dimensions sub_m, sub_n, t, or minor-embeddable to such a graph.

Notation CN refers to a Chimera graph consisting of an NxN grid of unit cells, where each unit cell is a bipartite graph with shores of size t. The D-Wave 2000Q QPU supports a C16 Chimera graph: its 2048 qubits are logically mapped into a 16x16 matrix of unit cells of 8 qubits (t=4). See also :func:dwave_networkx.chimera_graph

Notation PN referes to a Pegasus graph consisting of a 3x(N-1)x(N-1) grid of cells, where each unit cell is a bipartite graph with shore of size t, supplemented with odd couplers (see nice_coordinate definition). The Advantage QPU supports a P16 Pegasus graph: its qubits may be mapped to a 3x15x15 matrix of unit cells, each of 8 qubits. This code supports tiling of Chimera-structured problems, with an option of additional odd-couplers, onto Pegasus. See also :func:dwave_networkx.pegasus_graph .

A problem that can be minor-embedded in a single chimera unit cell, for example, can therefore be tiled across the unit cells of a D-Wave 2000Q as 16x16 duplicates (or Advantage as 3x15x15 duplicates), subject to solver yield. This enables up to 256 (625) parallel samples per read.

Parameters
  • sampler (dimod.Sampler) – Structured dimod sampler such as a DWaveSampler().

  • sub_m (int) – Minimum number of Chimera unit cell rows required for minor-embedding a single instance of the problem.

  • sub_n (int) – Minimum number of Chimera unit cell columns required for minor-embedding a single instance of the problem.

  • t (int, optional, default=4) – Size of the shore within each Chimera unit cell.

Examples

This example submits a two-variable QUBO problem representing a logical NOT gate to a D-Wave system. The QUBO—two nodes with biases of -1 that are coupled with strength 2—needs only any two coupled qubits and so is easily minor-embedded in a single unit cell. Composite TilingComposite tiles it multiple times for parallel solution: the two nodes should typically have opposite values.

>>> from dwave.system import DWaveSampler, EmbeddingComposite
>>> from dwave.system import TilingComposite
...
>>> qpu_2000q = DWaveSampler(solver={'topology__type': 'chimera'})
>>> sampler = EmbeddingComposite(TilingComposite(qpu_2000q, 1, 1, 4))
>>> Q = {(1, 1): -1, (1, 2): 2, (2, 1): 0, (2, 2): -1}
>>> sampleset = sampler.sample_qubo(Q)
>>> len(sampleset)> 1
True

See Ocean Glossary for explanations of technical terms in descriptions of Ocean tools.

Properties

TilingComposite.properties

Properties in the form of a dict.

TilingComposite.parameters

Parameters in the form of a dict.

TilingComposite.children

The single wrapped structured sampler.

TilingComposite.child

The child sampler.

TilingComposite.nodelist

List of active qubits for the structured solver.

TilingComposite.edgelist

List of active couplers for the D-Wave solver.

TilingComposite.adjacency

Adjacency structure formatted as a dict, where keys are the nodes of the structured sampler and values are sets of all adjacent nodes for each key node.

TilingComposite.structure

Structure of the structured sampler formatted as a namedtuple, Structure(nodelist, edgelist, adjacency), where the 3-tuple values are the nodelist, edgelist and adjacency attributes.

Methods

TilingComposite.sample(bqm, **kwargs)

Sample from the specified binary quadratic model.

TilingComposite.sample_ising(h, J, **parameters)

Sample from an Ising model using the implemented sample method.

TilingComposite.sample_qubo(Q, **parameters)

Sample from a QUBO using the implemented sample method.

VirtualGraphComposite

class VirtualGraphComposite(sampler, embedding, chain_strength=None, flux_biases=None, flux_bias_num_reads=1000, flux_bias_max_age=3600)[source]

Composite to use the D-Wave virtual graph feature for minor-embedding.

Calibrates qubits in chains to compensate for the effects of biases and enables easy creation, optimization, use, and reuse of an embedding for a given working graph.

Inherits from dimod.ComposedSampler and dimod.Structured.

Parameters
  • sampler (DWaveSampler) – A dimod dimod.Sampler. Typically a DWaveSampler or derived composite sampler; other samplers may not work or make sense with this composite layer.

  • embedding (dict[hashable, iterable]) – Mapping from a source graph to the specified sampler’s graph (the target graph).

  • chain_strength (float, optional, default=None) – Desired chain coupling strength. This is the magnitude of couplings between qubits in a chain. If None, uses the maximum available as returned by a SAPI query to the D-Wave solver.

  • flux_biases (list/False/None, optional, default=None) – Per-qubit flux bias offsets in the form of a list of lists, where each sublist is of length 2 and specifies a variable and the flux bias offset associated with that variable. Qubits in a chain with strong negative J values experience a J-induced bias; this parameter compensates by recalibrating to remove that bias. If False, no flux bias is applied or calculated. If None, flux biases are pulled from the database or calculated empirically.

  • flux_bias_num_reads (int, optional, default=1000) – Number of samples to collect per flux bias value to calculate calibration information.

  • flux_bias_max_age (int, optional, default=3600) – Maximum age (in seconds) allowed for a previously calculated flux bias offset to be considered valid.

Attention

D-Wave’s virtual graphs feature can require many seconds of D-Wave system time to calibrate qubits to compensate for the effects of biases. If your account has limited D-Wave system access, consider using FixedEmbeddingComposite instead.

Examples

This example uses VirtualGraphComposite to instantiate a composed sampler that submits a QUBO problem to a D-Wave solver. The problem represents a logical AND gate using penalty function \(P = xy - 2(x+y)z +3z\), where variables x and y are the gate’s inputs and z the output. This simple three-variable problem is manually minor-embedded to a single Chimera unit cell: variables x and y are represented by qubits 1 and 5, respectively, and z by a two-qubit chain consisting of qubits 0 and 4. The chain strength is set to the maximum allowed found from querying the solver’s extended J range. In this example, the ten returned samples all represent valid states of the AND gate.

>>> from dwave.system import DWaveSampler, VirtualGraphComposite
>>> embedding = {'x': {1}, 'y': {5}, 'z': {0, 4}}
>>> qpu_2000q = DWaveSampler(solver={'topology__type': 'chimera'})
>>> qpu_2000q.properties['extended_j_range']
[-2.0, 1.0]
>>> sampler = VirtualGraphComposite(qpu_2000q, embedding, chain_strength=2) 
>>> Q = {('x', 'y'): 1, ('x', 'z'): -2, ('y', 'z'): -2, ('z', 'z'): 3}
>>> sampleset = sampler.sample_qubo(Q, num_reads=10) 
>>> print(sampleset)    
   x  y  z energy num_oc. chain_.
0  1  0  0    0.0       2     0.0
1  0  1  0    0.0       3     0.0
2  1  1  1    0.0       3     0.0
3  0  0  0    0.0       2     0.0
['BINARY', 4 rows, 10 samples, 3 variables]

See Ocean Glossary for explanations of technical terms in descriptions of Ocean tools.

Properties

VirtualGraphComposite.properties

Properties in the form of a dict.

VirtualGraphComposite.parameters

Parameters in the form of a dict.

VirtualGraphComposite.children

List containing the structured sampler.

VirtualGraphComposite.child

The child sampler.

VirtualGraphComposite.nodelist

Nodes available to the composed sampler.

VirtualGraphComposite.edgelist

Edges available to the composed sampler.

VirtualGraphComposite.adjacency

Adjacency structure for the composed sampler.

VirtualGraphComposite.structure

Structure of the structured sampler formatted as a namedtuple, Structure(nodelist, edgelist, adjacency), where the 3-tuple values are the nodelist, edgelist and adjacency attributes.

Methods

VirtualGraphComposite.sample(bqm[, ...])

Sample from the given Ising model.

VirtualGraphComposite.sample_ising(h, J, ...)

Sample from an Ising model using the implemented sample method.

VirtualGraphComposite.sample_qubo(Q, ...)

Sample from a QUBO using the implemented sample method.

Reverse Anneal

Composites that do batch operations for reverse annealing based on sets of initial states or anneal schedules.

ReverseBatchStatesComposite

class ReverseBatchStatesComposite(child_sampler)[source]

Composite that reverse anneals from multiple initial samples. Each submission is independent from one another.

Parameters

sampler (dimod.Sampler) – A dimod sampler.

Examples

This example runs 100 reverse anneals each from two initial states on a problem constructed by setting random \(\pm 1\) values on a clique (complete graph) of 15 nodes, minor-embedded on a D-Wave system using the DWaveCliqueSampler sampler.

>>> import dimod
>>> from dwave.system import DWaveCliqueSampler, ReverseBatchStatesComposite
...
>>> sampler = DWaveCliqueSampler()      
>>> sampler_reverse = ReverseBatchStatesComposite(sampler)    
>>> schedule = [[0.0, 1.0], [10.0, 0.5], [20, 1.0]]
...
>>> bqm = dimod.generators.ran_r(1, 15)
>>> init_samples = [{i: -1 for i in range(15)}, {i: 1 for i in range(15)}]
>>> sampleset = sampler_reverse.sample(bqm,
...                                    anneal_schedule=schedule,
...                                    initial_states=init_samples,
...                                    num_reads=100,
...                                    reinitialize_state=True)   

Properties

ReverseBatchStatesComposite.child

The child sampler.

ReverseBatchStatesComposite.children

List of child samplers that that are used by this composite.

ReverseBatchStatesComposite.properties

A dict containing any additional information about the sampler.

ReverseBatchStatesComposite.parameters

A dict where keys are the keyword parameters accepted by the sampler methods and values are lists of the properties relevent to each parameter.

Methods

ReverseBatchStatesComposite.sample(bqm[, ...])

Sample the binary quadratic model using reverse annealing from multiple initial states.

ReverseBatchStatesComposite.sample_ising(h, ...)

Sample from an Ising model using the implemented sample method.

ReverseBatchStatesComposite.sample_qubo(Q, ...)

Sample from a QUBO using the implemented sample method.

ReverseAdvanceComposite

class ReverseAdvanceComposite(child_sampler)[source]

Composite that reverse anneals an initial sample through a sequence of anneal schedules.

If you do not specify an initial sample, a random sample is used for the first submission. By default, each subsequent submission selects the most-found lowest-energy sample as its initial state. If you set reinitialize_state to False, which makes each submission behave like a random walk, the subsequent submission selects the last returned sample as its initial state.

Parameters

sampler (dimod.Sampler) – A dimod sampler.

Examples

This example runs 100 reverse anneals each for three schedules on a problem constructed by setting random \(\pm 1\) values on a clique (complete graph) of 15 nodes, minor-embedded on a D-Wave system using the DWaveCliqueSampler sampler.

>>> import dimod
>>> from dwave.system import DWaveCliqueSampler, ReverseAdvanceComposite
...
>>> sampler = DWaveCliqueSampler()     
>>> sampler_reverse = ReverseAdvanceComposite(sampler)    
>>> schedule = [[[0.0, 1.0], [t, 0.5], [20, 1.0]] for t in (5, 10, 15)]
...
>>> bqm = dimod.generators.ran_r(1, 15)
>>> init_samples = {i: -1 for i in range(15)}
>>> sampleset = sampler_reverse.sample(bqm,
...                                    anneal_schedules=schedule,
...                                    initial_state=init_samples,
...                                    num_reads=100,
...                                    reinitialize_state=True)     

Properties

ReverseAdvanceComposite.child

The child sampler.

ReverseAdvanceComposite.children

List of child samplers that that are used by this composite.

ReverseAdvanceComposite.properties

A dict containing any additional information about the sampler.

ReverseAdvanceComposite.parameters

A dict where keys are the keyword parameters accepted by the sampler methods and values are lists of the properties relevent to each parameter.

Methods

ReverseAdvanceComposite.sample(bqm[, ...])

Sample the binary quadratic model using reverse annealing along a given set of anneal schedules.

ReverseAdvanceComposite.sample_ising(h, J, ...)

Sample from an Ising model using the implemented sample method.

ReverseAdvanceComposite.sample_qubo(Q, ...)

Sample from a QUBO using the implemented sample method.