def from_bqm_sampleset(bqm,
sampleset,
sampler,
embedding_context=None,
warnings=None,
params=None):
"""Construct problem data for visualization based on the BQM and sampleset
in logical space (both unembedded).
In order for the embedded problem/response to be reconstructed, an embedding
is required in either the sampleset, or as a standalone argument.
Note:
This adapter can only provide best-effort estimate of the submitted
problem and received samples. Namely, because values of logical
variables in `sampleset` are produced by a chain break resolution
method, information about individual physical qubit values is lost.
Please have in mind you will never see "broken chains" when using this
adapter.
Args:
bqm (:class:`dimod.BinaryQuadraticModel`/:class:`dimod.core.bqm.BQM`):
Problem in logical (unembedded) space, given as a BQM.
sampleset (:class:`~dimod.sampleset.SampleSet`):
Sampling response as a sampleset.
sampler (:class:`~dimod.Sampler` or :class:`~dimod.ComposedSampler`):
The :class:`~dwave.system.samplers.dwave_sampler.DWaveSampler`-
derived sampler used to produce the sampleset off the bqm.
embedding_context (dict, optional):
A map containing an embedding of logical problem onto the
solver's graph (the ``embedding`` key) and embedding parameters
used (e.g. ``chain_strength``). It is optional only if
``sampleset.info`` contains it (see `return_embedding` argument of
:meth:`~dwave.system.composites.embedding.EmbeddingComposite`).
warnings (list[dict], optional):
Optional list of warnings.
params (dict, optional):
Sampling parameters used.
"""
logger.debug("from_bqm_sampleset({!r})".format(
dict(bqm=bqm,
sampleset=sampleset,
sampler=sampler,
warnings=warnings,
embedding_context=embedding_context,
params=params)))
if not isinstance(sampler, dimod.Sampler):
raise TypeError("dimod.Sampler instance expected for 'sampler'")
# get embedding parameters
if embedding_context is None:
embedding_context = sampleset.info.get('embedding_context', {})
if embedding_context is None:
raise ValueError("embedding_context not given")
embedding = embedding_context.get('embedding')
if embedding is None:
raise ValueError("embedding not given")
chain_strength = embedding_context.get('chain_strength')
def find_solver(sampler):
if hasattr(sampler, 'solver'):
return sampler.solver
for child in getattr(sampler, 'children', []):
try:
return find_solver(child)
except:
pass
raise TypeError("'sampler' doesn't use DWaveSampler")
solver = find_solver(sampler)
if not isinstance(solver, StructuredSolver):
raise TypeError("only structured solvers are supported")
topology = _get_solver_topology(solver)
if topology['type'] not in SUPPORTED_SOLVER_TOPOLOGY_TYPES:
raise TypeError("unsupported solver topology type")
solver_id = solver.id
problem_type = "ising" if sampleset.vartype is dimod.SPIN else "qubo"
# bqm vartype must match sampleset vartype
if bqm.vartype is not sampleset.vartype:
bqm = bqm.change_vartype(sampleset.vartype, inplace=False)
# if `embedding` is `dwave.embedding.transforms.EmbeddedStructure`, we don't
# need `target_adjacency`
emb_params = dict(embedding=embedding)
if not hasattr(embedding, 'embed_bqm'):
# proxy for detecting dict vs. EmbeddedStructure, without actually
# importing EmbeddedStructure (did not exist in dwave-system<0.9.10)
target_adjacency = edgelist_to_adjacency(solver.edges)
emb_params.update(target_adjacency=target_adjacency)
# get embedded bqm
bqm_embedded = embed_bqm(bqm,
chain_strength=chain_strength,
smear_vartype=dimod.SPIN,
**emb_params)
# best effort reconstruction of (unembedded/qmi) response/solutions
# NOTE: we **can not** reconstruct physical qubit values from logical variables
# (sampleset we have access to has variable values after chain breaks resolved!)
active_variables = sorted(list(bqm_embedded.variables))
active_variables_set = set(active_variables)
logical_variables = list(sampleset.variables)
var_to_idx = {var: idx for idx, var in enumerate(logical_variables)}
unembedding = {q: var_to_idx[v] for v, qs in embedding.items() for q in qs}
# sanity check
assert set(unembedding) == active_variables_set
def expand_sample(sample):
return [int(sample[unembedding[q]]) for q in active_variables]
solutions = [expand_sample(sample) for sample in sampleset.record.sample]
# adjust energies to values returned by SAPI (offset embedding)
energies = list(map(float, sampleset.record.energy - bqm_embedded.offset))
num_occurrences = list(map(int, sampleset.record.num_occurrences))
num_variables = solver.num_qubits
timing = sampleset.info.get('timing')
linear, quadratic, offset = bqm_embedded.to_ising()
problem_data = {
"format":
"qp", # SAPI non-conforming (nulls vs nans)
"lin": [
uniform_get(linear, v, 0 if v in active_variables_set else None)
for v in solver._encoding_qubits
],
"quad": [
quadratic.get((q1, q2), 0) + quadratic.get((q2, q1), 0)
for (q1, q2) in solver._encoding_couplers
if q1 in active_variables_set and q2 in active_variables_set
],
"embedding":
embedding
}
# try to get problem id. if not available, auto-generate one
problem_id = sampleset.info.get('problem_id')
if problem_id is None:
problem_id = "local-%s" % uuid.uuid4()
# try to reconstruct sampling params
if params is None:
params = {'num_reads': int(sum(num_occurrences))}
# expand with defaults
params = _expand_params(solver, params, timing)
# try to get warnings from sampleset.info
if warnings is None:
warnings = sampleset.info.get('warnings')
# construct problem stats
problem_stats = _problem_stats(response=None,
sampleset=sampleset,
embedding_context=embedding_context)
data = {
"ready":
True,
"details": {
"id": problem_id,
"type": problem_type,
"solver": solver.id,
"label": sampleset.info.get('problem_label'),
},
"data":
_problem_dict(solver_id, problem_type, problem_data, params,
problem_stats),
"answer":
_answer_dict(solutions, active_variables, energies, num_occurrences,
timing, num_variables),
"unembedded_answer":
_unembedded_answer_dict(sampleset),
"warnings":
_warnings(warnings),
"rel":
dict(solver=solver),
}
logger.trace("from_bqm_sampleset returned %r", data)
return data
def from_bqm_response(bqm,
embedding_context,
response,
warnings=None,
params=None,
sampleset=None):
"""Construct problem data for visualization based on the unembedded BQM,
the embedding used when submitting, and the low-level sampling response.
Args:
bqm (:class:`dimod.BinaryQuadraticModel`/:class:`dimod.core.bqm.BQM`):
Problem in logical (unembedded) space, given as a BQM.
embedding_context (dict):
A map containing an embedding of logical problem onto the
solver's graph (the ``embedding`` key) and embedding parameters
used (e.g. ``chain_strength``, ``chain_break_method``, etc).
response (:class:`dwave.cloud.computation.Future`):
Sampling response, as returned by the low-level sampling interface
in the Cloud Client (e.g. :meth:`dwave.cloud.solver.sample_ising`
for Ising problems).
warnings (list[dict], optional):
Optional list of warnings.
params (dict, optional):
Sampling parameters used.
sampleset (:class:`dimod.SampleSet`, optional):
Optional unembedded sampleset.
"""
logger.debug("from_bqm_response({!r})".format(
dict(bqm=bqm,
response=response,
response_energies=response['energies'],
embedding_context=embedding_context,
warnings=warnings,
params=params,
sampleset=sampleset)))
solver = response.solver
if not isinstance(response.solver, StructuredSolver):
raise TypeError("only structured solvers are supported")
topology = _get_solver_topology(solver)
if topology['type'] not in SUPPORTED_SOLVER_TOPOLOGY_TYPES:
raise TypeError("unsupported solver topology type")
solver_id = solver.id
problem_type = response.problem_type
active_variables = response['active_variables']
active = set(active_variables)
solutions = list(map(itemsgetter(*active_variables),
response['solutions']))
energies = response['energies']
num_occurrences = response.num_occurrences
num_variables = solver.num_qubits
timing = response.timing
# bqm vartype must match response vartype
if problem_type == "ising":
bqm = bqm.change_vartype(dimod.SPIN, inplace=False)
else:
bqm = bqm.change_vartype(dimod.BINARY, inplace=False)
# get embedding parameters
if 'embedding' not in embedding_context:
raise ValueError("embedding not given")
embedding = embedding_context.get('embedding')
chain_strength = embedding_context.get('chain_strength')
chain_break_method = embedding_context.get('chain_break_method')
# if `embedding` is `dwave.embedding.transforms.EmbeddedStructure`, we don't
# need `target_adjacency`
emb_params = dict(embedding=embedding)
if not hasattr(embedding, 'embed_bqm'):
# proxy for detecting dict vs. EmbeddedStructure, without actually
# importing EmbeddedStructure (did not exist in dwave-system<0.9.10)
target_adjacency = edgelist_to_adjacency(solver.edges)
emb_params.update(target_adjacency=target_adjacency)
# get embedded bqm
bqm_embedded = embed_bqm(bqm,
chain_strength=chain_strength,
smear_vartype=dimod.SPIN,
**emb_params)
linear, quadratic, offset = bqm_embedded.to_ising()
problem_data = {
"format":
"qp", # SAPI non-conforming (nulls vs nans)
"lin": [
uniform_get(linear, v, 0 if v in active else None)
for v in solver._encoding_qubits
],
"quad": [
quadratic.get((q1, q2), 0) + quadratic.get((q2, q1), 0)
for (q1, q2) in solver._encoding_couplers
if q1 in active and q2 in active
],
"embedding":
embedding
}
# try to reconstruct sampling params
if params is None:
params = {'num_reads': int(sum(num_occurrences))}
# expand with defaults
params = _expand_params(solver, params, timing)
# TODO: if warnings are missing, calculate them here (since we have the
# low-level response)
# construct problem stats
problem_stats = _problem_stats(response=response,
sampleset=sampleset,
embedding_context=embedding_context)
data = {
"ready":
True,
"details":
_details_dict(response),
"data":
_problem_dict(solver_id, problem_type, problem_data, params,
problem_stats),
"answer":
_answer_dict(solutions, active_variables, energies, num_occurrences,
timing, num_variables),
"warnings":
_warnings(warnings),
"rel":
dict(solver=solver),
}
if sampleset is not None:
data["unembedded_answer"] = _unembedded_answer_dict(sampleset)
logger.trace("from_bqm_response returned %r", data)
return data
