def __init__(self, raw_results, answer, problem, all_vars): # Store our arguments. self.raw_results = raw_results self.answer = answer self.problem = problem # Unembed the solutions. Fix rather than discard invalid solutions. if self.problem.embedding == {}: fixed_answer = self.answer.copy() else: fixed_answer = unembed_sampleset(self.answer, self.problem.embedding, self.problem.logical.bqm, chain_break_method=chain_breaks.majority_vote) # Construct one Solution object per solution. self.solutions = [] energies = fixed_answer.record.energy tallies = fixed_answer.record.num_occurrences fixed_solns = fixed_answer.record.sample raw_solns = self.answer.record.sample sym2col, num2col = self._map_to_column(fixed_answer, self.problem.embedding, self.problem.qmasm.sym_map) for i in range(len(fixed_solns)): sset = self.answer.slice(i, i + 1) self.solutions.append(Solution(self.problem, sym2col, num2col, sset, fixed_solns[i], tallies[i], energies[i], all_vars)) # Store the frequency of chain breaks across the entire SampleSet. self.chain_breaks = chain_break_frequency(self.answer, self.problem.embedding)
def postprocess(X, embedded_solution_set, embedding, model): ''' Find centroids and assignments from binary solution of embedded model Args: X: input data embedded_solution: embedded solution set produced by annealing embedding: embedding used to convert from logical to embedded model model: logical BQM model Returns: centroids: Array containing each centnroid as a row vector in a k x d matrix assignments: cluster assignments of each point as list ''' sample_set = unembed_sampleset(embedded_solution_set, embedding, model) solution = sample_set.first.sample N = np.shape(X)[0] d = np.shape(X)[1] k = len(solution) // N assignments = np.array([0] * N) M = np.zeros((k, d)) cluster_sizes = np.zeros(k) for i in range(N): for j in range(k): if solution[i + j * N] == 1: M[j] += X[i] cluster_sizes[j] += 1.0 assignments[i] = j break for i in range(k): M[i] /= cluster_sizes[i] return M, assignments
def solve_qubo_dwave(Q, num_reads=1000): # Create the solver (connecting to D-Wave) and the Sampler config_file = '../dwave.conf' client = Client.from_config(config_file, profile='ocete') solver = client.get_solver( ) # Available QPUs: DW_2000Q_2_1 (2038 qubits), DW_2000Q_5 (2030 qubits) dwsampler = DWaveSampler(config_file=config_file) # We need to embed Q into a valid graph for the D-Wave architecture edgelist = solver.edges adjdict = edgelist_to_adjacency(edgelist) embed = minorminer.find_embedding(Q, edgelist) Q_embeded = embed_qubo(Q, embed, adjdict) # Obtain the response from the solver. This is the actual D-Wave execution! start = time.time() response_qpt = dwsampler.sample_qubo(Q_embeded, num_reads=num_reads) qpu_time = time.time() - start client.close() # Transform the response from the embeded graph to our original architecture bqm = dimod.BinaryQuadraticModel.from_qubo(Q) unembedded = unembed_sampleset(response_qpt, embed, bqm, chain_break_method=majority_vote) # Order the solutions by lower energy return unembedded, qpu_time
def broken_chains(self): "Return True if the solution contains broken chains." unbroken = unembed_sampleset(self.raw_ss, self.problem.embedding, self.problem.logical.bqm, chain_break_method=chain_breaks.discard) return len(unbroken) == 0
def async_unembed(response): # unembed the sampleset aysnchronously. warninghandler.chain_break(response, embedding) sampleset = unembed_sampleset( response, embedding, source_bqm=bqm, chain_break_method=chain_break_method, chain_break_fraction=chain_break_fraction, return_embedding=return_embedding) if return_embedding: sampleset.info['embedding_context'].update( embedding_parameters=embedding_parameters, chain_strength=embedding.chain_strength) if chain_break_fraction and len(sampleset): warninghandler.issue( "All samples have broken chains", func=lambda: (sampleset.record.chain_break_fraction.all(), None)) if warninghandler.action is WarningAction.SAVE: # we're done with the warning handler so we can just pass the list # off, if later we want to pass in a handler or similar we should # do a copy sampleset.info.setdefault('warnings', []).extend(warninghandler.saved) return sampleset
def load_samplesets(self, bqm, target, embedding, tags=[], unembed_args=None): bqm_id = self.id_bqm(bqm) target_id = self.id_target(target) embedding_id = self.id_embedding(embedding) dir_path = [self.samplesets_path,bqm_id,target_id,embedding_id] samplesets_path = os.path.join(*dir_path) samplesets = [] for root, dirs, files in os.walk(samplesets_path): root_dirs = os.path.normpath(root).split(os.path.sep) if all(tag in root_dirs for tag in tags): for file in files: sampleset_path = os.path.join(root,file) with open(sampleset_path,'r') as fp: sampleset = _load(fp,cls=DimodDecoder) samplesets.append(sampleset) if embedding is "": return samplesets elif not isinstance(embedding,(Embedding,dict)): raise ValueError("Embedding alias or id cannot be used to unembed") if unembed_args is None: return samplesets else: return [unembed_sampleset(s,embedding,bqm,**unembed_args) for s in samplesets]
def solve_ising_dwave(hii, Jij): config_file = '/media/sf_QWorld/QWorld/QA_DeNovoAsb/dwcloud.conf' client = Client.from_config(config_file, profile='aritra') solver = client.get_solver( ) # Available QPUs: DW_2000Q_2_1 (2038 qubits), DW_2000Q_5 (2030 qubits) dwsampler = DWaveSampler(config_file=config_file) edgelist = solver.edges adjdict = edgelist_to_adjacency(edgelist) embed = minorminer.find_embedding(Jij.keys(), edgelist) [h_qpu, j_qpu] = embed_ising(hii, Jij, embed, adjdict) response_qpt = dwsampler.sample_ising(h_qpu, j_qpu, num_reads=solver.max_num_reads()) client.close() bqm = dimod.BinaryQuadraticModel.from_ising(hii, Jij) unembedded = unembed_sampleset(response_qpt, embed, bqm, chain_break_method=majority_vote) print("Maximum Sampled Configurations from D-Wave\t===>") solnsMaxSample = sorted(unembedded.record, key=lambda x: -x[2]) for i in range(0, 10): print(solnsMaxSample[i]) print("Minimum Energy Configurations from D-Wave\t===>") solnsMinEnergy = sorted(unembedded.record, key=lambda x: +x[1]) for i in range(0, 10): print(solnsMinEnergy[i])
def solve_qubo_dwave(Q, n_genome_reads, num_reads=100, label='', annealing_time=20): # Create the solver (connecting to D-Wave) and the Sampler config_file = '../dwave_adv.conf' client = Client.from_config(config_file, profile='ocete') solver = client.get_solver('Advantage_system1.1') dwsampler = DWaveSampler( solver={ 'qpu': True, 'topology__type': 'pegasus', 'annealing_time': annealing_time }, # Watch out, Leap doesn seem to take into account # this parameter, you have to give it as a paramater in the dwsampler.sample() call token=token, endpoint=endpoint) # We need to embed Q into a valid graph for the D-Wave architecture adjdict = edgelist_to_adjacency(solver.edges) embed = minorminer.find_embedding(Q, solver.edges) Q_embeded = embed_qubo(Q, embed, adjdict) # Obtain the response from the solver. This is the actual D-Wave execution! start = time.time() response_qpt = dwsampler.sample_qubo(Q_embeded, num_reads=num_reads, label=label, annealing_time=annealing_time) qpu_time = time.time() - start client.close() # Transform the response from the embeded graph to our original architecture bqm = dimod.BinaryQuadraticModel.from_qubo(Q) unembedded = unembed_sampleset(response_qpt, embed, bqm, chain_break_method=majority_vote) # Sort the solutions from lowest energy and format them to quboDict format unformated_solutions_list = sorted(unembedded.record, key=lambda x: +x[1]) solutions_list = [] for sol, energy, num_appereances in unformated_solutions_list: solutions_list.append([ rebuild_quboDict_from_vector(sol, n_genome_reads), energy, num_appereances ]) return solutions_list, qpu_time, get_max_chain_length(embed)
## Embedding logical qubits to physical ones embedding = embeddings[sampler.solver.id] ## Set connections betweeen physical qubits bqm_embedded = embed_bqm(bqm, embedding, target_adjacency, 4.0) #print(bqm_embedded) # Return num_reads solutions (responses are in the D-Wave's graph of indexed qubits) kwargs = {} if 'num_reads' in sampler.parameters: kwargs['num_reads'] = 50 if 'answer_mode' in sampler.parameters: kwargs['answer_mode'] = 'histogram' response = sampler.sample(bqm_embedded, **kwargs) print("A solution indexed by qubits: \n", next(response.data(fields=['sample']))) # Map back to the BQM's graph (nodes labeled "a0", "b0" etc,) response = unembed_sampleset(response, embedding, source_bqm=bqm) print("\nThe solution in problem variables: \n", next(response.data(fields=['sample']))) from helpers.convert import to_base_ten # Select just the first sample. sample = next(response.samples(n=1)) dict(sample) a, b = to_base_ten(sample) print("Given integer P={}, found factors a={} and b={}".format(P, a, b))
adjacency = {key: 1.0 for key in qubo.keys() if key[0] != key[1]} # Run QUBO on DW_2000Q_5 sampler = DWaveSampler(solver='DW_2000Q_5') embedding = find_embedding(adjacency, sampler.edgelist) qubo_emb = embed_qubo(qubo, embedding, sampler.adjacency) response = sampler.sample_qubo(qubo_emb, num_reads=1000, postprocess='optimization') # Unembed samples by specifying chain_break_method argument of unembed_sampleset bqm = dimod.BinaryQuadraticModel.from_qubo(qubo) # majority_vote (default) sample_majority_vote = unembed_sampleset(response, embedding, bqm, chain_break_method=majority_vote) # discard sample_discard = unembed_sampleset(response, embedding, bqm, chain_break_method=discard) # weighted_random sample_weighted_random = unembed_sampleset(response, embedding, bqm, chain_break_method=weighted_random) # MinimizeEnergy cbm = MinimizeEnergy(bqm, embedding) sample_MinimizeEnergy = unembed_sampleset(response, embedding,
def sample(self, bqm, chain_strength=1.0, chain_break_fraction=True, **parameters): """Sample from the provided binary quadratic model. Also set parameters for handling a chain, the set of vertices in a target graph that represents a source-graph vertex; when a D-Wave system is the sampler, it is a set of qubits that together represent a variable of the binary quadratic model being minor-embedded. Args: bqm (:obj:`dimod.BinaryQuadraticModel`): Binary quadratic model to be sampled from. chain_strength (float, optional, default=1.0): Magnitude of the quadratic bias (in SPIN-space) applied between variables to create chains. The energy penalty of chain breaks is 2 * `chain_strength`. chain_break_fraction (bool, optional, default=True): If True, the unembedded response contains a ‘chain_break_fraction’ field that reports the fraction of chains broken before unembedding. **parameters: Parameters for the sampling method, specified by the child sampler. Returns: :class:`dimod.SampleSet`: A `dimod` :obj:`~dimod.SampleSet` object. Examples: This example submits an triangle-structured problem to a D-Wave solver, selected by the user's default :std:doc:`D-Wave Cloud Client configuration file <cloud-client:intro>`, using a specified minor-embedding of the problem’s variables to physical qubits. >>> from dwave.system.samplers import DWaveSampler >>> from dwave.system.composites import FixedEmbeddingComposite >>> import dimod ... >>> sampler = FixedEmbeddingComposite(DWaveSampler(), {'a': [0, 4], 'b': [1, 5], 'c': [2, 6]}) >>> response = sampler.sample_ising({}, {'ab': 0.5, 'bc': 0.5, 'ca': 0.5}, chain_strength=2) >>> response.first # doctest: +SKIP Sample(sample={'a': 1, 'b': -1, 'c': 1}, energy=-0.5, num_occurrences=1, chain_break_fraction=0.0) See `Ocean Glossary <https://docs.ocean.dwavesys.com/en/latest/glossary.html>`_ for explanations of technical terms in descriptions of Ocean tools. """ # solve the problem on the child system child = self.child # apply the embedding to the given problem to map it to the child sampler __, __, target_adjacency = child.structure # get the embedding embedding = self.embedding bqm_embedded = embed_bqm(bqm, embedding, target_adjacency, chain_strength=chain_strength, smear_vartype=dimod.SPIN) if 'initial_state' in parameters: parameters['initial_state'] = _embed_state( embedding, parameters['initial_state']) response = child.sample(bqm_embedded, **parameters) return unembed_sampleset(response, embedding, source_bqm=bqm, chain_break_fraction=chain_break_fraction)
# or, load it from file (if provided) if len(sys.argv) > 1: path = sys.argv[1] with open(path) as fp: bqm = dimod.BinaryQuadraticModel.from_coo(fp).spin # get solver print("solver init") client = Client.from_config() solver = client.get_solver(qpu=True) # embed print("embedding") source_edgelist = list(bqm.quadratic) + [(v, v) for v in bqm.linear] target_edgelist = solver.edges embedding = find_embedding(source_edgelist, target_edgelist) target_adjacency = edgelist_to_adjacency(target_edgelist) bqm_embedded = embed_bqm(bqm, embedding, target_adjacency) # sample print("sampling") response = solver.sample_ising(bqm_embedded.linear, bqm_embedded.quadratic, num_reads=100) sampleset_embedded = response.sampleset sampleset = unembed_sampleset(sampleset_embedded, embedding, bqm) # inspect print("inspecting") dwave.inspector.show(bqm, dict(embedding=embedding), response)
def sample(self, bqm, chain_strength=1.0, chain_break_method=None, chain_break_fraction=True, embedding_parameters=None, return_embedding=None, warnings=None, **parameters): """Sample from the provided binary quadratic model. Args: bqm (:obj:`dimod.BinaryQuadraticModel`): Binary quadratic model to be sampled from. chain_strength (float, optional, default=1.0): Magnitude of the quadratic bias (in SPIN-space) applied between variables to create chains. The energy penalty of chain breaks is 2 * `chain_strength`. chain_break_method (function, optional): Method used to resolve chain breaks during sample unembedding. See :func:`~dwave.embedding.unembed_sampleset`. chain_break_fraction (bool, optional, default=True): Add a `chain_break_fraction` field to the unembedded response with the fraction of chains broken before unembedding. embedding_parameters (dict, optional): If provided, parameters are passed to the embedding method as keyword arguments. Overrides any `embedding_parameters` passed to the constructor. return_embedding (bool, optional): If True, the embedding, chain strength, chain break method and embedding parameters are added to :attr:`dimod.SampleSet.info` of the returned sample set. The default behaviour is defined by :attr:`return_embedding_default`, which itself defaults to False. warnings (:class:`~dwave.system.warnings.WarningAction`, optional): Defines what warning action to take, if any. See :mod:`~dwave.system.warnings`. The default behaviour is defined by :attr:`warnings_default`, which itself defaults to :class:`~dwave.system.warnings.IGNORE` **parameters: Parameters for the sampling method, specified by the child sampler. Returns: :obj:`dimod.SampleSet` Examples: See the example in :class:`EmbeddingComposite`. """ if return_embedding is None: return_embedding = self.return_embedding_default # solve the problem on the child system child = self.child # apply the embedding to the given problem to map it to the child sampler __, target_edgelist, target_adjacency = self.target_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 if embedding_parameters is None: embedding_parameters = self.embedding_parameters else: # we want the parameters provided to the constructor, updated with # the ones provided to the sample method. To avoid the extra copy # we do an update, avoiding the keys that would overwrite the # sample-level embedding parameters embedding_parameters.update( (key, val) for key, val in self.embedding_parameters if key not in embedding_parameters) embedding = self.find_embedding(source_edgelist, target_edgelist, **embedding_parameters) if warnings is None: warnings = self.warnings_default elif 'warnings' in child.parameters: parameters.update(warnings=warnings) warninghandler = WarningHandler(warnings) warninghandler.chain_strength(bqm, chain_strength) warninghandler.chain_length(embedding) if bqm and not embedding: raise ValueError("no embedding found") bqm_embedded = embed_bqm(bqm, embedding, target_adjacency, chain_strength=chain_strength, smear_vartype=dimod.SPIN) if 'initial_state' in parameters: # if initial_state was provided in terms of the source BQM, we want # to modify it to now provide the initial state for the target BQM. # we do this by spreading the initial state values over the # chains state = parameters['initial_state'] parameters['initial_state'] = { u: state[v] for v, chain in embedding.items() for u in chain } if self.scale_aware and 'ignored_interactions' in child.parameters: ignored = [] for chain in embedding.values(): # just use 0 as a null value because we don't actually need # the biases, just the interactions ignored.extend(chain_to_quadratic(chain, target_adjacency, 0)) parameters['ignored_interactions'] = ignored response = child.sample(bqm_embedded, **parameters) warninghandler.chain_break(response, embedding) sampleset = unembed_sampleset( response, embedding, source_bqm=bqm, chain_break_method=chain_break_method, chain_break_fraction=chain_break_fraction, return_embedding=return_embedding) if return_embedding: sampleset.info['embedding_context'].update( embedding_parameters=embedding_parameters, chain_strength=chain_strength) if chain_break_fraction and len(sampleset): warninghandler.issue( "all samples had broken chains", func=lambda: (sampleset.record.chain_break_fraction.all(), None)) if warninghandler.action is WarningAction.SAVE: # we're done with the warning handler so we can just pass the list # off, if later we want to pass in a handler or similar we should # do a copy sampleset.info.setdefault('warnings', []).extend(warninghandler.saved) return sampleset
A = dwave_sampler.edgelist Adj = dwave_sampler.adjacency embedding = find_embedding(Q, A) print(embedding) bqm = BinaryQuadraticModel.from_qubo(Q) # Cannot use a Composite to get the broken chains, so do the embedding # directly bqm_embedded = embed_bqm(bqm, embedding, Adj, chain_strength=chainstrength) response = DWaveSampler().sample(bqm_embedded, num_reads=numruns) # We need to get the chains directly, as a list chains = [embedding[v] for v in list(bqm)] # Obtain the broken chains broken = broken_chains(response, chains) # Interpret the results in terms of the embedding. Be sure to # tell the method to compute the chain_break_frequency. print( unembed_sampleset(response, embedding, source_bqm=bqm, chain_break_fraction=True), broken) # Use NumPy method to obtain the indices of the broken chains w = np.where(broken == True) indices = list(zip(*w)) print(indices)
# https://docs.ocean.dwavesys.com/projects/system/en/latest/reference/generated/dwave.embedding.unembed_sampleset.html import dimod from dwave.embedding import unembed_sampleset # Triangular binary quadratic model and an embedding J = {('a', 'b'): -1, ('b', 'c'): -1, ('a', 'c'): -1} bqm = dimod.BinaryQuadraticModel.from_ising({}, J) embedding = {'a': [0, 1], 'b': [2], 'c': [3]} # Samples from the embedded binary quadratic model samples = [ { 0: -1, 1: -1, 2: -1, 3: -1 }, # [0, 1] is unbroken { 0: -1, 1: +1, 2: +1, 3: +1 } ] # [0, 1] is broken energies = [-3, 1] embedded = dimod.SampleSet.from_samples(samples, dimod.SPIN, energies) # Unembed samples = unembed_sampleset(embedded, embedding, bqm) print(samples.record.sample) # doctest: +SKIP
#Create a complete Ising model on a QPU target_h, target_J = embed_ising(h, J, embedding, target_adjacency) # print('__________________') # print('Linear coeff on QPU:', target_h) # print('Quadratic coeff on QPU:', target_J) # print('__________________') # Set parameters for calculations. num_reas is a number of experiments runs = 4 response = sampler.sample_ising(target_h, target_J, num_reads=runs, answer_mode='histogram', annealing_time = 1000) #Get a SampleSet with spins and energies (WARNING: results are for the task, embedded on QPU) # print('Resulting spins on QPU:') # print(response) # print('__________________') #Return to the original spins: unembedding = unembed_sampleset(response, embedding, dimod.BinaryQuadraticModel.from_ising({}, J)) # print('Resulting spins in terms of original task:') # print(unembedding) # print('__________________') # plt.hist(unembedding.record.energy,rwidth=1,align='left') # plt.show() print(unembedding) print("QPU time used:", unembedding.info['timing']['qpu_access_time'], "microseconds.")
### Energy offset ### エネルギー オフセット e_offset = lagrange_hard_shift * days * workforce(1)**2 e_offset += lagrange_soft_nurse * nurses * duty_days**2 ### BQM bqm = BinaryQuadraticModel.from_qubo(embeddedQ, offset=e_offset) sbqm = BinaryQuadraticModel.from_qubo(Q, offset=e_offset) # Sample solution # 解をサンプリングします print("Connected to {}. N = {}, D = {}".format(sampler.solver.id, nurses, days)) results = sampler.sample(bqm, num_reads=numSampling) samples = unembed_sampleset(results, embedding, sbqm, chain_break_fraction=True) ### Save data with pickle for analysis and reverse annealing ### 結果分析と逆アニーリングのため pickle を用いてデータを保存します fout = "results_%s_N%d_D%d_s%d.p" % (topology, nurses, days, numSampling) saveDict = { 'results': results, 'embedding': embedding, 'bqm': sbqm, 'samples': samples } pickle.dump(saveDict, open(fout, "wb"))
def sample(self, bqm, chain_strength=1.0, chain_break_method=None, chain_break_fraction=True, embedding_parameters=None, return_embedding=False, **parameters): """Sample from the provided binary quadratic model. Args: bqm (:obj:`dimod.BinaryQuadraticModel`): Binary quadratic model to be sampled from. chain_strength (float, optional, default=1.0): Magnitude of the quadratic bias (in SPIN-space) applied between variables to create chains. The energy penalty of chain breaks is 2 * `chain_strength`. chain_break_method (function, optional): Method used to resolve chain breaks during sample unembedding. See :func:`~dwave.embedding.unembed_sampleset`. chain_break_fraction (bool, optional, default=True): Add a `chain_break_fraction` field to the unembedded response with the fraction of chains broken before unembedding. embedding_parameters (dict, optional): If provided, parameters are passed to the embedding method as keyword arguments. Overrides any `embedding_parameters` passed to the constructor. return_embedding (bool, optional, default=False): If True, the embedding is added to :attr:`dimod.SampleSet.info` of the returned sample set. **parameters: Parameters for the sampling method, specified by the child sampler. Returns: :obj:`dimod.SampleSet` Examples: See the example in :class:`EmbeddingComposite`. """ # solve the problem on the child system child = self.child # apply the embedding to the given problem to map it to the child sampler __, target_edgelist, target_adjacency = self.target_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 if embedding_parameters is None: embedding_parameters = self.embedding_parameters else: # we want the parameters provided to the constructor, updated with # the ones provided to the sample method. To avoid the extra copy # we do an update, avoiding the keys that would overwrite the # sample-level embedding parameters embedding_parameters.update( (key, val) for key, val in self.embedding_parameters if key not in embedding_parameters) embedding = self.find_embedding(source_edgelist, target_edgelist, **embedding_parameters) if bqm and not embedding: raise ValueError("no embedding found") bqm_embedded = embed_bqm(bqm, embedding, target_adjacency, chain_strength=chain_strength, smear_vartype=dimod.SPIN) if 'initial_state' in parameters: # if initial_state was provided in terms of the source BQM, we want # to modify it to now provide the initial state for the target BQM. # we do this by spreading the initial state values over the # chains state = parameters['initial_state'] parameters['initial_state'] = { u: state[v] for v, chain in embedding.items() for u in chain } if self.scale_aware and 'ignored_interactions' in child.parameters: ignored = [] for chain in embedding.values(): # just use 0 as a null value because we don't actually need # the biases, just the interactions ignored.extend(chain_to_quadratic(chain, target_adjacency, 0)) parameters['ignored_interactions'] = ignored response = child.sample(bqm_embedded, **parameters) return unembed_sampleset(response, embedding, source_bqm=bqm, chain_break_method=chain_break_method, chain_break_fraction=chain_break_fraction, return_embedding=return_embedding)
if manual_embed: # Pick the method for fixing broken chains. from dwave.embedding.chain_breaks import majority_vote # weighted_random method = majority_vote # Submit the job via an embedded BinaryQuadraticModel. from dimod import BinaryQuadraticModel as BQM from dwave.embedding import embed_bqm, unembed_sampleset # Generate a BQM from the QUBO. q = BQM.from_qubo(qubo) # Embed the BQM onto the target structure. embedded_q = embed_bqm(q, embedding, adjacency) # chain_strength=chain_strength, smear_vartype=dimod.SPIN # Collect the sample output. response = unembed_sampleset( sampler.sample(embedded_q, num_reads=num_samples), embedding, q, chain_break_method=method, chain_break_fraction=True) else: # Use a FixedEmbeddingComposite if we don't care about chains. from dwave.system.composites import FixedEmbeddingComposite system_composite = FixedEmbeddingComposite(sampler, embedding) response = system_composite.sample_qubo(qubo, num_reads=num_samples) constant = 0 # Cycle through the results and yield them to the caller. for out in response.data(): # Get the output from the data. bits = (out.sample[b] for b in sorted(out.sample)) occurrence = out.num_occurrences