def sample_qubo(self, Q, **parameters):
"""Samples from a QUBO using an implemented sample method.
Examples:
This example implements a placeholder Ising sampler and samples using
the mixin QUBO sampler.
>>> import dimod
>>> class ImplementIsingSampler(dimod.Sampler):
... def sample_ising(self, h, J):
... return dimod.Response.from_dicts([{1: -1, 2: +1}], {'energy': [-1.0]}) # Placeholder
... @property
... def properties(self):
... return self._properties
... @property
... def parameters(self):
... return dict()
...
>>> sampler = ImplementIsingSampler()
>>> Q = {(0, 0): -0.5, (0, 1): 1, (1, 1): -0.75}
>>> res = sampler.sample_qubo(Q)
>>> print(res)
[[0 1]]
"""
bqm = BinaryQuadraticModel.from_qubo(Q)
response = self.sample(bqm, **parameters)
return response
def sample_qubo(self, Q, **parameters):
"""Sample from a QUBO using the implemented sample method.
This method is inherited from the :class:`.Sampler` base class.
Converts the QUBO into a :obj:`.BinaryQuadraticModel` and then
calls :meth:`.sample`.
Args:
Q (dict):
Coefficients of a quadratic unconstrained binary optimization
(QUBO) problem. Should be a dict of the form `{(u, v): bias, ...}`
where `u`, `v`, are binary-valued variables and `bias` is their
associated coefficient.
**kwargs:
See the implemented sampling for additional keyword definitions.
Returns:
:obj:`.SampleSet`
See also:
:meth:`.sample`, :meth:`.sample_ising`
"""
bqm = BinaryQuadraticModel.from_qubo(Q)
return self.sample(bqm, **parameters)
def sample_qubo(self, Q, num_samps=100):
"""
Sample from the QUBO problem
:param qubo: QUBO problem
:type qubo: numpy dictionary
:return: samples, energy, num_occurrences
"""
self.num_samps = num_samps
if not hasattr(self, 'sampler'):
bqm = BinaryQuadraticModel.from_qubo(Q)
# apply the embedding to the given problem to map it to the child sampler
__, target_edgelist, target_adjacency = self.child.structure
# add self-loops to edgelist to handle singleton variables
source_edgelist = list(bqm.quadratic) + [(v, v)
for v in bqm.linear]
# get the embedding
embedding = minorminer.find_embedding(source_edgelist,
target_edgelist)
if bqm and not embedding:
raise ValueError("no embedding found")
self.sampler = FixedEmbeddingComposite(self.child, embedding)
response = self.sampler.sample_qubo(Q,
chain_strength=self.chainstrength,
num_reads=self.num_samps)
return np.array(response.__dict__['_samples_matrix'].tolist()), response.__dict__['_data_vectors']["energy"], \
response.__dict__['_data_vectors']["num_occurrences"]
def sample_qubo(self, Q, num_samps=100):
"""
Sample from the QUBO problem
:param qubo: QUBO problem
:type qubo: numpy dictionary
:return: samples, energy, num_occurrences
"""
#print(Q)
self.num_samps = num_samps
if not hasattr(self, 'sampler'):
bqm = BinaryQuadraticModel.from_qubo(Q)
# apply the embedding to the given problem to map it to the child sampler
__, target_edgelist, target_adjacency = self.child.structure
# add self-loops to edgelist to handle singleton variables
source_edgelist = list(bqm.quadratic) + [(v, v)
for v in bqm.linear]
# get the embedding
embedding = minorminer.find_embedding(source_edgelist,
target_edgelist)
if bqm and not embedding:
raise ValueError("no embedding found")
self.sampler = FixedEmbeddingComposite(self.child, embedding)
response = EmbeddingComposite(
DWaveSampler(token="DEV-db4d47e5313cf3c52cac31dace7c5080a5ffc46d")
).sample_qubo(Q, num_reads=1000)
#response = self.sampler.sample_qubo(Q, chain_strength=self.chainstrength, num_reads=self.num_samps)
#for sample, energy, num_occurrences, chain_break_fraction in list(response.data()):
# print(sample, "Energy: ", energy, "Occurrences: ", num_occurrences)
#print(response.samples()[0,[range(0,71)]])
#print(response._asdict()['vectors']['energy'])
#print(response._asdict()['vectors']['num_occurrences'])
saempeul = np.empty((0, 72))
for sample, in response.data(fields=['sample']):
saempeul = np.append(saempeul, sample)
#print(saempeul)
return saempeul, response._asdict()['vectors']['energy']['data'], \
response._asdict()['vectors']['num_occurrences']['data']
def embed_qubo(source_Q, embedding, target_adjacency, chain_strength=1.0):
"""Embed a QUBO onto a target graph.
Args:
source_Q (dict[(variable, variable), bias]):
Coefficients of a quadratic unconstrained binary optimization (QUBO) model.
embedding (dict):
Mapping from source graph to target graph as a dict of form {s: {t, ...}, ...},
where s is a source-model variable and t is a target-model variable.
target_adjacency (dict/:class:`networkx.Graph`):
Adjacency of the target graph as a dict of form {t: Nt, ...},
where t is a target-graph variable and Nt is its set of neighbours.
chain_strength (float, optional):
Magnitude of the quadratic bias (in SPIN-space) applied between variables to form a chain. Note
that the energy penalty of chain breaks is 2 * `chain_strength`.
Returns:
dict[(variable, variable), bias]: Quadratic biases of the target QUBO.
Examples:
This example embeds a square source graph onto fully connected :math:`K_5` graph.
Embedding is accomplished by an edge deletion operation on the target graph: target-node
0 is not used.
>>> import dimod
>>> import networkx as nx
>>> # QUBO problem for a square graph
>>> Q = {(1, 1): -4.0, (1, 2): 4.0, (2, 2): -4.0, (2, 3): 4.0,
... (3, 3): -4.0, (3, 4): 4.0, (4, 1): 4.0, (4, 4): -4.0}
>>> # Target graph is a fully connected k5 graph
>>> K_5 = nx.complete_graph(5)
>>> 0 in K_5
True
>>> # Embedding from source to target graph
>>> embedding = {1: {4}, 2: {3}, 3: {1}, 4: {2}}
>>> # Embed the QUBO
>>> target_Q = dimod.embed_qubo(Q, embedding, K_5)
>>> (0, 0) in target_Q
False
>>> target_Q # doctest: +SKIP
{(1, 1): -4.0,
(1, 2): 4.0,
(2, 2): -4.0,
(2, 4): 4.0,
(3, 1): 4.0,
(3, 3): -4.0,
(4, 3): 4.0,
(4, 4): -4.0}
This example embeds a square graph onto the target graph of a dimod reference structured
sampler, `StructureComposite`, using the dimod reference `ExactSolver` sampler with a
fully connected :math:`K_5` graph specified.
>>> import dimod
>>> import networkx as nx
>>> # QUBO problem for a square graph
>>> Q = {(1, 1): -4.0, (1, 2): 4.0, (2, 2): -4.0, (2, 3): 4.0,
... (3, 3): -4.0, (3, 4): 4.0, (4, 1): 4.0, (4, 4): -4.0}
>>> # Structured dimod sampler with a structure defined by a K5 graph
>>> sampler = dimod.StructureComposite(dimod.ExactSolver(), list(K_5.nodes), list(K_5.edges))
>>> sampler.adjacency # doctest: +SKIP
{0: {1, 2, 3, 4},
1: {0, 2, 3, 4},
2: {0, 1, 3, 4},
3: {0, 1, 2, 4},
4: {0, 1, 2, 3}}
>>> # Embedding from source to target graph
>>> embedding = {0: [4], 1: [3], 2: [1], 3: [2], 4: [0]}
>>> # Embed the QUBO
>>> target_Q = dimod.embed_qubo(Q, embedding, sampler.adjacency)
>>> # Sample
>>> response = sampler.sample_qubo(target_Q)
>>> for datum in response.data(): # doctest: +SKIP
... print(datum)
...
Sample(sample={1: 0, 2: 1, 3: 1, 4: 0}, energy=-8.0)
Sample(sample={1: 1, 2: 0, 3: 0, 4: 1}, energy=-8.0)
Sample(sample={1: 1, 2: 0, 3: 0, 4: 0}, energy=-4.0)
Sample(sample={1: 1, 2: 1, 3: 0, 4: 0}, energy=-4.0)
Sample(sample={1: 0, 2: 1, 3: 0, 4: 0}, energy=-4.0)
Sample(sample={1: 1, 2: 1, 3: 1, 4: 0}, energy=-4.0)
>>> # Snipped above response for brevity
"""
source_bqm = BinaryQuadraticModel.from_qubo(source_Q)
target_bqm = embed_bqm(source_bqm, embedding, target_adjacency, chain_strength=chain_strength)
target_Q, __ = target_bqm.to_qubo()
return target_Q
def get_qubo_embedding(self, Q, **parameters):
"""Retrieve or create a minor-embedding from QUBO
"""
bqm = BinaryQuadraticModel.from_qubo(Q)
embedding = self.get_embedding(bqm, **parameters)
return embedding
def sample_qubo(self, Q, **parameters):
"""Samples from the given QUBO using the instantiated sample method."""
bqm = BinaryQuadraticModel.from_qubo(Q)
response = self.sample(bqm, **parameters)
return response
def sample_qubo(self, Q, **parameters):
"""Samples from a QUBO using an implemented sample method.
"""
bqm = BinaryQuadraticModel.from_qubo(Q)
return self.sample(bqm, **parameters)
def combinations(n: Union[int, Collection[Variable]],
k: int,
strength: float = 1,
vartype: VartypeLike = BINARY) -> BinaryQuadraticModel:
r"""Generate a binary quadratic model that is minimized when k of n
variables are selected.
More fully, generates a binary quadratic model (BQM) that is minimized for
each of the k-combinations of its variables.
The energy for the BQM is given by
:math:`(\sum_{i} x_i - k)^2`.
Args:
n: If ``n`` is an integer, variables are labelled `[0, n)`. If ``n`` is
a list or set, variables are labelled accordingly.
k: The generated BQM has ``0`` energy when any ``k`` of its variables
are ``1``.
strength: The energy of the first excited state of the binary quadratic
model.
vartype: Variable type for the BQM. Accepted input values:
* :class:`.Vartype.SPIN`, ``'SPIN'``, ``{-1, 1}``
* :class:`.Vartype.BINARY`, ``'BINARY'``, ``{0, 1}``
Returns:
A binary quadratic model.
Examples:
>>> bqm = dimod.generators.combinations(['a', 'b', 'c'], 2)
>>> bqm.energy({'a': 1, 'b': 0, 'c': 1})
0.0
>>> bqm.energy({'a': 1, 'b': 1, 'c': 1})
1.0
>>> bqm = dimod.generators.combinations(5, 1)
>>> bqm.energy({0: 0, 1: 0, 2: 1, 3: 0, 4: 0})
0.0
>>> bqm.energy({0: 0, 1: 0, 2: 1, 3: 1, 4: 0})
1.0
>>> bqm = dimod.generators.combinations(['a', 'b', 'c'], 2, strength=3.0)
>>> bqm.energy({'a': 1, 'b': 0, 'c': 1})
0.0
>>> bqm.energy({'a': 1, 'b': 1, 'c': 1})
3.0
"""
if isinstance(n, Collection):
variables = n
else:
try:
variables = range(n)
except TypeError:
raise TypeError('n should be a collection or an integer')
if k > len(variables) or k < 0:
raise ValueError("cannot select k={} from {} variables".format(
k, len(variables)))
# (\sum_i x_i - k)^2
# = \sum_i x_i \sum_j x_j - 2k\sum_i x_i + k^2
# = \sum_{i,j} x_ix_j + (1 - 2k)\sum_i x_i + k^2
lbias = float(strength * (1 - 2 * k))
qbias = float(2 * strength)
if not isinstance(n, int):
num_vars = len(n)
variables = n
else:
num_vars = n
try:
variables = range(n)
except TypeError:
raise TypeError('n should be a collection or an integer')
Q = np.triu(np.ones((num_vars, num_vars)) * qbias, k=1)
np.fill_diagonal(Q, lbias)
bqm = BinaryQuadraticModel.from_qubo(Q, offset=strength * (k**2))
if not isinstance(n, int):
bqm.relabel_variables(dict(zip(range(len(n)), n)))
return bqm.change_vartype(vartype, inplace=True)
