def test_with_software_exact_solver(self): sampler = DWaveSampler(solver_features={'software': True}) bqm = dimod.BinaryQuadraticModel.empty(dimod.SPIN) # plant a solution for v in sampler.nodelist: bqm.add_variable(v, .001) for u, v in sampler.edgelist: bqm.add_interaction(u, v, -1) resp = sampler.sample(bqm, num_reads=100) # the ground solution should be all spin down ground = dict(next(iter(resp))) self.assertEqual(ground, {v: -1 for v in bqm})
csp = dwavebinarycsp.ConstraintSatisfactionProblem(dwavebinarycsp.BINARY) # At least one qubit must be set csp.add_constraint(or4, ['x1', 'x2', 'x3', 'x4']) # No more than one qubit can be set csp.add_constraint(nand, ['x1', 'x2']) csp.add_constraint(nand, ['x1', 'x3']) csp.add_constraint(nand, ['x1', 'x4']) csp.add_constraint(nand, ['x2', 'x3']) csp.add_constraint(nand, ['x2', 'x4']) csp.add_constraint(nand, ['x3', 'x4']) bqm = dwavebinarycsp.stitch(csp) response = sampler.sample(bqm, num_reads=samples) # aggregate the results answers = {} valid, invalid = 0, 0 for datum in response.data(): sample, energy, num = datum if (csp.check(sample)): valid = valid + num result = '' for i in range(1, 5): result += str(sample['x' + str(i)]) try: answers[result] += num except: answers[result] = num
import minorminer # Find an embedding embedding = minorminer.find_embedding(bqm.quadratic, target_edgelist) if bqm and not embedding: raise ValueError("no embedding found") # Apply the embedding to the factoring problem to map it to the QPU bqm_embedded = dimod.embed_bqm(bqm, embedding, target_adjacency, 3.0) # Request num_reads samples kwargs = {} kwargs['num_reads'] = 1000 if 'answer_mode' in sampler.parameters: kwargs['answer_mode'] = 'histogram' response = sampler.sample(bqm_embedded, **kwargs) # Map back to the BQM's graph (nodes labeled "a0", "b0" etc,) response = dimod.unembed_response(response, embedding, source_bqm=bqm) print("\nThe solution in problem variables: \n", next(response.data(fields=['sample']))) ## Viewing the Solution from collections import OrderedDict #from helpers.convert import to_base_ten def to_base_ten(qs): def getbits(kyref): li = [ky for ky in qs.keys() if ky[0] == kyref and ky[1] < '9']
def execute(circuit, backend=None, config=None, basis_gates=None, coupling_map=None, initial_layout=None, shots=1024, max_credits=10, seed=None, qobj_id=None, hpc=None, skip_transpiler=False, seed_mapper=None): outputs = list() inputs = list() for qubit in circuit.annealergraph.qubits.keys(): if isinstance(circuit.annealergraph.qubits[qubit], dict): if circuit.annealergraph.qubits[qubit]['measured'] == True: outputs.append( circuit.annealergraph.qubits[qubit]['components'][-1]) # can't omit output bit from being included as input, but is its put # first in the list, it will be zero the top portion of the readout inputs.append( circuit.annealergraph.qubits[qubit]['components'][0]) for qubit in circuit.annealergraph.qubits.keys(): if isinstance(circuit.annealergraph.qubits[qubit], dict): if circuit.annealergraph.qubits[qubit]['measured'] == False: inputs.append( circuit.annealergraph.qubits[qubit]['components'][0]) sampler = DWaveSampler( endpoint='https://cloud.dwavesys.com/sapi', token='DEV-beb5d0babc40334f66b655704f1b5315917b4c41', solver='DW_2000Q_2_1') ''' qubit_weights, coupler_weights, dwavemap = circuit.annealergraph.map_to_Dwave_graph(list(sampler._nodelist), list(sampler.edgelist)) ins = list() outs = list() for name in inputs: ins.append(dwavemap[name][0]) for name in outputs: outs.append(dwavemap[name][0]) inputs = ins outputs = outs ''' qubit_weights = circuit.annealergraph.qubitweights coupler_weights = circuit.annealergraph.couplerweights bqm = dimod.BinaryQuadraticModel(qubit_weights, coupler_weights, 0, dimod.BINARY) kwargs = {} if 'num_reads' in sampler.parameters: kwargs['num_reads'] = 100 if 'answer_mode' in sampler.parameters: kwargs['answer_mode'] = 'histogram' print("Running...") response = EmbeddingComposite(sampler).sample(bqm, **kwargs) sampler.client.close() print("Done.") print(response.data) groundstate = 1000000 for sample, energy in response.data(['sample', 'energy']): if energy < groundstate: groundstate = round(energy, 1) function = list() for sample, energy in response.data(['sample', 'energy']): if round(energy, 1) == groundstate: print(sample, round(energy, 1)) row = [] for inp in inputs: row.append(sample[inp]) for outp in outputs: row.append(sample[outp]) function.append(row) print('\n') function.sort() for i in range(len(function)): print(function[i]) print(embedding) if len(circuit.annealergraph.qubitweights) < 18: # ExactSolver simulation print("\nExactSolver Check:") print("Simulating problem with {} qubits".format( len(circuit.annealergraph.qubitweights))) qubit_weights = circuit.annealergraph.qubitweights coupler_weights = circuit.annealergraph.couplerweights bqm = dimod.BinaryQuadraticModel(qubit_weights, coupler_weights, 0, dimod.BINARY) sampler = dimod.ExactSolver() response = sampler.sample(bqm) groundstate = 1000000 for sample, energy in response.data(['sample', 'energy']): if energy < groundstate: groundstate = round(energy, 1) function = list() for sample, energy in response.data(['sample', 'energy']): if round(energy, 1) == groundstate: print(sample, round(energy, 1)) row = [] for inp in inputs: row.append(sample[inp]) for outp in outputs: row.append(sample[outp]) function.append(row) print('\n') function.sort() for i in range(len(function)): print(function[i]) else: print("Problem to large to simulate. Used {} qubits".format( len(circuit.annealergraph.qubitweights)))
# Convert the binary constraint satisfaction problem to a binary quadratic model bqm = dwavebinarycsp.stitch(csp) --------- #The next code sets up the D-Wave sampler --------- from dwave.system.samplers import DWaveSampler from dwave.systems.composites import Embedding Composite sampler = EmbeddingComposite(DWaveSampler(endpoint= 'path', token= 'token', solver='SolverName')) #Next we as for 1000 samples and separate those that satisfy the CSP from those that fail to do so. response = sampler.sample(bqm, num_reads=1000) # Check how many solutions meet the constraints (are valid) valid, invalid, data = 0,0, [] for datum in response.data(['sample', 'energy', 'num_occurences']): if (csp.check(datum.sample)): valid = valid+datum.num_occurences for i in range(datum.num_occurences): data.append((datum.sample, datum.energy, '1')) else: invalid = invalid+datum.num_occurences for i in range(datum.num_occurences): data.append((datum.sample, datum.energy, '0')) print(valid, invalid)
def factor(P, use_saved_embedding=True): #################################################################################################### # get circuit #################################################################################################### construction_start_time = time.time() validate_input(P, range(2 ** 6)) # get constraint satisfaction problem csp = dbc.factories.multiplication_circuit(3) # get binary quadratic model bqm = dbc.stitch(csp, min_classical_gap=.1) # we know that multiplication_circuit() has created these variables p_vars = ['p0', 'p1', 'p2', 'p3', 'p4', 'p5'] # convert P from decimal to binary fixed_variables = dict(zip(reversed(p_vars), "{:06b}".format(P))) fixed_variables = {var: int(x) for(var, x) in fixed_variables.items()} # fix product qubits for var, value in fixed_variables.items(): bqm.fix_variable(var, value) log.debug('bqm construction time: %s', time.time() - construction_start_time) #################################################################################################### # run problem #################################################################################################### sample_time = time.time() # get QPU sampler sampler = DWaveSampler() _, target_edgelist, target_adjacency = sampler.structure if use_saved_embedding: # load a pre-calculated embedding from factoring.embedding import embeddings embedding = embeddings[sampler.solver.id] else: # get the embedding embedding = minorminer.find_embedding(bqm.quadratic, target_edgelist) if bqm and not embedding: raise ValueError("no embedding found") # apply the embedding to the given problem to map it to the sampler bqm_embedded = dimod.embed_bqm(bqm, embedding, target_adjacency, 3.0) # draw samples from the QPU 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) # convert back to the original problem space response = dimod.unembed_response(response, embedding, source_bqm=bqm) sampler.client.close() log.debug('embedding and sampling time: %s', time.time() - sample_time) #################################################################################################### # output results #################################################################################################### output = { "results": [], # { # "a": Number, # "b": Number, # "valid": Boolean, # "numOfOccurrences": Number, # "percentageOfOccurrences": Number # } "timing": { "actual": { "qpuProcessTime": None # microseconds } }, "numberOfReads": None } # we know that multiplication_circuit() has created these variables a_vars = ['a0', 'a1', 'a2'] b_vars = ['b0', 'b1', 'b2'] # histogram answer_mode should return counts for unique solutions if 'num_occurrences' not in response.data_vectors: response.data_vectors['num_occurrences'] = [1] * len(response) # should equal num_reads total = sum(response.data_vectors['num_occurrences']) results_dict = OrderedDict() for sample, num_occurrences in response.data(['sample', 'num_occurrences']): # convert A and B from binary to decimal a = b = 0 for lbl in reversed(a_vars): a = (a << 1) | sample[lbl] for lbl in reversed(b_vars): b = (b << 1) | sample[lbl] # aggregate results by unique A and B values (ignoring internal circuit variables) if (a, b, P) in results_dict: results_dict[(a, b, P)]["numOfOccurrences"] += num_occurrences results_dict[(a, b, P)]["percentageOfOccurrences"] = 100 * \ results_dict[(a, b, P)]["numOfOccurrences"] / total else: results_dict[(a, b, P)] = {"a": a, "b": b, "valid": a * b == P, "numOfOccurrences": num_occurrences, "percentageOfOccurrences": 100 * num_occurrences / total} output['results'] = list(results_dict.values()) output['numberOfReads'] = total if 'timing' in response.info: output['timing']['actual']['qpuProcessTime'] = response.info['timing']['qpu_access_time'] return output
# # Constrain qubits 0 and 5 to have the same value - and yes, we will embed # 1 and 5 to have the same value # q_0 + 0.5 (q_1 + q_5) - 2 q_0 q_5 - 1 # # Constrain qubits 1 and 5 to have the same value, explicitly # chainstrength (q_1 + q_5 - 2q_1 q_5 - 1) numruns = 1000 chainstrength = float(sys.argv[1]) sampler = DWaveSampler(solver={'topology__type': 'chimera'}) # Add all the equations together Q = { (0, 0): 2, (1, 1): chainstrength, (5, 5): chainstrength, (0, 4): -2, (1, 4): 2, (0, 5): -2, (1, 5): -2 * chainstrength } bqm = dimod.BinaryQuadraticModel.from_qubo(Q, offset=-2 - chainstrength) results = sampler.sample(bqm, num_reads=numruns) # print the results for sample, energy in results.data(['sample', 'energy']): print(sample, energy)
embeddedQ = embed_qubo(Q, embedding, sampler.adjacency) ### 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 }
def execute(circuit, backend=None, config=None, basis_gates=None, coupling_map=None, initial_layout=None, shots=1024, max_credits=10, seed=None, qobj_id=None, hpc=None, skip_transpiler=False, seed_mapper=None): outputs = list() inputs = list() for qubit in circuit.annealergraph.qubits.keys(): if isinstance(circuit.annealergraph.qubits[qubit], dict): if circuit.annealergraph.qubits[qubit]['measured'] == True: outputs.append( circuit.annealergraph.qubits[qubit]['components'][-1]) # can't omit output bit from being included as input, but is its put # first in the list, it will be zero the top portion of the readout inputs.append( circuit.annealergraph.qubits[qubit]['components'][0]) for qubit in circuit.annealergraph.qubits.keys(): if isinstance(circuit.annealergraph.qubits[qubit], dict): if circuit.annealergraph.qubits[qubit]['measured'] == False: inputs.append( circuit.annealergraph.qubits[qubit]['components'][0]) circuit.annealergraph.print_chimera_graph_to_file() sampler = DWaveSampler( endpoint='https://cloud.dwavesys.com/sapi', token='DEV-beb5d0babc40334f66b655704f1b5315917b4c41', solver='DW_2000Q_2_1') qubit_weights = circuit.annealergraph.qubitweights coupler_weights = circuit.annealergraph.couplerweights bqm = dimod.BinaryQuadraticModel(qubit_weights, coupler_weights, 0, dimod.BINARY) kwargs = {} if 'num_reads' in sampler.parameters: kwargs['num_reads'] = 5000 if 'answer_mode' in sampler.parameters: kwargs['answer_mode'] = 'histogram' #if 'annealing_time' in sampler.parameters: # kwargs['annealing_time'] = 100 print("Running...") response = sampler.sample(bqm, **kwargs) sampler.client.close() print("Done.") print(response.data) groundstate = 1000000 for sample, energy in response.data(['sample', 'energy']): if energy < groundstate: groundstate = round(energy, 1) print("Ground State: ", groundstate) function = list() for sample, energy in response.data(['sample', 'energy']): if round(energy, 1) == groundstate: print(sample, round(energy, 1)) row = [] for inp in inputs: row.append(sample[inp]) for outp in outputs: row.append(sample[outp]) function.append(row) print('\n') function.sort() for i in range(len(function)): print(function[i]) ''' qubit_weights = {'targ': 4, 'ctl1in': 5, 'ctl2in': 5, 'outin': 8, 'outout': 12, 'ctl1out': 5, 'ctl2out': 5, 'anc': 9} coupler_weights = {('outin','outout'): -17, ('ctl1in','ctl1out'): -10, ('ctl2in','ctl2out'): -10, ('anc','targ'): -9, ('anc','ctl1in'): -4, ('anc','ctl2in'): -5, ('anc','outin'): 9, ('outout','targ'): -7, ('outin','ctl1out'): -2, ('outin','ctl2out'): -2, ('targ','ctl1out'): 2, ('targ','ctl2out'): 2, ('ctl1in','ctl2out'): 1} inputs = ['targ','ctl1in','ctl2in'] outputs = ['outout'] ''' if len(circuit.annealergraph.qubitweights) <= 19: # ExactSolver simulation print("\nExactSolver Check:") print("Simulating problem with {} qubits".format( len(circuit.annealergraph.qubitweights))) qubit_weights = circuit.annealergraph.qubitweights coupler_weights = circuit.annealergraph.couplerweights print("\nQubit Weights:") for key in qubit_weights.keys(): print(key, "\t", qubit_weights[key]) print("\nCoupler Weights") for key in coupler_weights.keys(): print(key, "\t", coupler_weights[key]) print("\n") bqm = dimod.BinaryQuadraticModel(qubit_weights, coupler_weights, 0, dimod.BINARY) sampler = dimod.ExactSolver() response = sampler.sample(bqm) groundstate = 1000000 for sample, energy in response.data(['sample', 'energy']): if energy < groundstate: groundstate = round(energy, 1) print("Ground State: ", groundstate) function = list() for sample, energy in response.data(['sample', 'energy']): if round(energy, 1) == groundstate: print(sample, round(energy, 1)) row = [] for inp in inputs: row.append(sample[inp]) for outp in outputs: row.append(sample[outp]) function.append(row) print('\n') function.sort() for i in range(len(function)): print(function[i]) else: print("Problem too large to simulate. Used {} qubits".format( len(circuit.annealergraph.qubitweights)))
class DictRep(ProbRep): """ A concrete class that represents problems on the D-Wave as a dictionary of values. """ def __init__(self, H, qpu, vartype, encoding): """ Class that takes a dictionary representation of an ising-hamiltonian and submits problem to a quantum annealer qpu: string specifies quantum processing unit to be used during calculation--referring to name specifying this information in dwave config file vartype: string QUBO or Ising (all case variants acceptable) encoding: string logical or direct. If logical, embeds onto chip under the hood. If direct, assumes manual embedding and tries to put directly onto chip as is. H: dict The hamiltonian represented as a dict of the form {(0, 0): h0, (0, 1): J01, ...} OR {(0, 0): 'h0', (0, 1): 'J0', (1, 1): 'h1', ...} """ # poplate run information super().__init__(qpu, vartype, encoding) # create a set of regex rules to parse h/J string keys in H # also creates a "rules" dictionary to relate qubit weights to relevant factor self.hvrule = re.compile('h[0-9]*') self.Jvrule = re.compile('J[0-9]*') self.weight_rules = {} # create list of qubits/ couplers and # dicts that map indepndent params to # all qubits/ couplers that have that value self.H = H self.qubits = [] self.params_to_qubits = {} self.couplers = [] self.params_to_couplers = {} for key, value in H.items(): if key[0] == key[1]: self.qubits.append(key[0]) if type(value) != str: div_idx = -1 else: div_idx = value.find('/') if div_idx == -1: self.weight_rules[key[0]] = 1 else: self.weight_rules[key[0]] = float(value[div_idx + 1:]) value = value[:div_idx] self.params_to_qubits.setdefault(value, []).append(key[0]) else: self.couplers.append(key) if type(value) != str: div_idx = -1 else: div_idx = value.find('/') if div_idx == -1: self.weight_rules[key] = 1 else: self.weight_rules[key] = float(value[div_idx + 1:]) value = value[:div_idx] self.params_to_couplers.setdefault(value, []).append(key) self.nqubits = len(self.qubits) self.Hsize = 2**(self.nqubits) if qpu == 'dwave': try: # let OCEAN handle embedding if encoding == "logical": # encode several times on graph # based on qubits encoded if len(self.qubits) <= 4: self.sampler = EmbeddingComposite( TilingComposite(DWaveSampler(), 1, 1, 4)) else: self.sampler = EmbeddingComposite(DWaveSampler()) # otherwise, assume 1-1 else: self.sampler = DWaveSampler() except: raise ConnectionError( "Cannot connect to DWave sampler. Have you created a DWave config file using 'dwave config create'?" ) elif qpu == 'test': self.sampler = dimod.SimulatedAnnealingSampler() elif qpu == 'numerical': self.processordata = loadAandB() self.graph = nx.Graph() self.graph.add_edges_from(self.couplers) self.data = pd.DataFrame() # save values/ metadata self.H = copy.deepcopy(H) if encoding == 'direct': self.wqubits = self.sampler.properties['qubits'] self.wcouplers = self.sampler.properties['couplers'] def save_config(self, fname, config_data={}): """ Saves Hamiltonian configuration for future use """ # if config data not supplied, at least dump Hamiltonian if config_data == {}: config_data = {'H': self.H} with open(fname + ".yml", 'w') as yamloutput: yaml.dump(config_data, yamloutput) def tile_H(self): pqubits = self.qubits pcouplers = self.couplers wqubits = self.wqubits wcouplers = self.wcouplers H = copy.deepcopy(self.H) for unitcell in range(1, 16 * 16): # create list of qubits/couplers that should be working in this unit cell unit_qubits = [q for q in range(8 * unitcell, 8 * (unitcell + 1))] unit_couplers = [[q, q + (4 - q % 4) + i] for q in unit_qubits[:4] for i in range(4)] # ensure that all qubits and couplers are working if all(q in wqubits for q in unit_qubits) and all(c in wcouplers for c in unit_couplers): # init_state.extend(init_state[:]) # copy the initial state # if so, create copies of H on other unit cells for q in unit_qubits: if (q % 8) in pqubits: H[(q, q)] = H[(q % 8, q % 8)] for c in unit_couplers: if (c[0] % 8, c[1] % 8) in pcouplers: H[tuple(c)] = H[(c[0] % 8, c[1] % 8)] # else: #init_state.extend([3 for q in range(len(unit_qubits))]) #self.init_state = init_state self.H = H self.qubits = [] self.params_to_qubits = {} self.couplers = [] self.params_to_couplers = {} for key, value in H.items(): if key[0] == key[1]: self.qubits.append(key[0]) self.params_to_qubits.setdefault(value, []).append(key[0]) else: self.couplers.append(key) self.params_to_couplers.setdefault(value, []).append(key) def populate_parameters(self, parameters): # generate all independent combinations of parameters self.params = [] self.values = [] for key, value in parameters.items(): self.params.append(key) self.values.append(value) self.combos = list(itertools.product(*self.values)) # format pandas DataFrame # columns = self.params[:] # columns.extend(['energy', 'state']) self.data = pd.DataFrame() self.data.H = str(self.H) self.data.vartype = self.vartype self.data.encoding = self.encoding return def call_annealer(self, **kwargs): """ Calls qpu on problem encoded by H. cull: bool if true, only outputs lowest energy states, otherwise shows all results """ # parse the input data # cull = kwargs.get('cull', False) # only takes lowest energy data s_to_hx = kwargs.get('s_to_hx', '') # relates s to transverse-field bias spoint = kwargs.get( 'spoint', 0) # can start sampling data midway through if interuptted # if H.values() only contains floats, # run sinlge problem as is if all( type(value) == int or type(value) == float for value in self.H.values()): if self.vartype == 'ising': h, J = get_dwaveH(self.H, 'ising') response = self.sampler.sample_ising(h, J) return response elif self.vartype == 'qubo': H = get_dwaveH(self.H, 'vartype') response = self.sampler.sample_ising(H) return response # otherwise, run a parameter sweep for combo in self.combos[spoint::]: # init single run's data/inputs rundata = {} runh = {} runJ = {} optional_args = {} count = 0 # map params to values in combo for param in self.params: rundata[param] = combo[count] # if param is qubit param if self.hvrule.match(param): for qubit in self.params_to_qubits[param]: runh[qubit] = combo[count] / self.weight_rules[qubit] elif self.Jvrule.match(param): for coupler in self.params_to_couplers[param]: runJ[coupler] = combo[count] / self.weight_rules[ coupler] elif param == 'anneal_schedule': anneal_schedule = combo[count] optional_args['anneal_schedule'] = anneal_schedule # if transverse field terms, get hx if s_to_hx: hx = s_to_hx[anneal_schedule[1][1]] rundata['hx'] = hx elif param == 'num_reads': num_reads = combo[count] optional_args['num_reads'] = num_reads elif param == 'initial_state': initial_state = combo[count] optional_args['initial_state'] = initial_state elif param == 'reinitialize_state': reinitialize_state = combo[count] optional_args['reinitialize_state'] = reinitialize_state count += 1 # run the sim and collect data if self.qpu == 'dwave': response = self.sampler.sample_ising(h=runh, J=runJ, **optional_args) for energy, state, num in response.data( fields=['energy', 'sample', 'num_occurrences']): rundata['energy'] = energy rundata['state'] = tuple(state[key] for key in sorted(state.keys())) for n in range(num): self.data = self.data.append(rundata, ignore_index=True) elif self.qpu == 'test': bqm = dimod.BinaryQuadraticModel.from_ising(h=runh, J=runJ) response = self.sampler.sample(bqm, num_reads=num_reads) for energy, state in response.data( fields=['energy', 'sample']): rundata['energy'] = energy rundata['state'] = tuple(state[key] for key in sorted(state.keys())) self.data = self.data.append(rundata, ignore_index=True) elif self.qpu == 'numerical': continue return self.data def visualize_graph(self): G = nx.Graph() G.add_edges_from(self.couplers) nx.draw_networkx(G) return G def save_data(self, filename): self.data.to_csv(filename, index=False) def get_state_plot(self, figsize=(12, 8), filename=None, title='Distribution of Final States'): data = self.data ncount = len(data) plt.figure(figsize=figsize) ax = sns.countplot(x="state", data=data) plt.title(title) plt.xlabel('State') # Make twin axis ax2 = ax.twinx() # Switch so count axis is on right, frequency on left ax2.yaxis.tick_left() ax.yaxis.tick_right() # Also switch the labels over ax.yaxis.set_label_position('right') ax2.yaxis.set_label_position('left') ax2.set_ylabel('Frequency [%]') for p in ax.patches: x = p.get_bbox().get_points()[:, 0] y = p.get_bbox().get_points()[1, 1] ax.annotate('{:.1f}%'.format(100. * y / ncount), (x.mean(), y), ha='center', va='bottom') # set the alignment of the text # Use a LinearLocator to ensure the correct number of ticks ax.yaxis.set_major_locator(ticker.LinearLocator(11)) # Fix the frequency range to 0-100 ax2.set_ylim(0, 100) ax.set_ylim(0, ncount) # And use a MultipleLocator to ensure a tick spacing of 10 ax2.yaxis.set_major_locator(ticker.MultipleLocator(10)) # Need to turn the grid on ax2 off, otherwise the gridlines end up on top of the bars # ax2.grid(None) if filename: plt.savefig(filename, dpi=300) return plt def get_ferro_diagram(self, xparam, yparam, divideby=None, title=''): """ Plot the probability that output states are ferromagnetic on a contour plot with xaxis as xparam/divdeby and yaxis as yparam/divideby. """ df = self.data # obtain denominator of expression (if constant value is used across-the-board) if divideby: denom = abs(df[divideby].unique()[0]) xlabel = xparam + '/|' + divideby + '|' ylabel = yparam + '/|' + divideby + '|' else: denom = 1 xlabel = xparam ylabel = yparam xs = df[xparam].unique() ys = df[yparam].unique() pfm_meshgrid = [] # iterate over trials and obtain pFM for given xparam and yparam for y in ys: pfms = [] for x in xs: # get length of unique elements in state bitstrings lubs = [ len(set(state)) for state in df.loc[(df[yparam] == y) & (df[xparam] == x)]['state'] ] pfms.append(lubs.count(1) / len(lubs)) pfm_meshgrid.append(pfms) X, Y = np.meshgrid(xs / denom, ys / denom) # plot the figure plt.figure() plt.title(title) plt.contourf(X, Y, pfm_meshgrid, np.arange(0, 1.2, .2), cmap='viridis', extent=(-4, 4, 0, 4)) cbar = plt.colorbar(ticks=np.arange(0, 1.2, .2)) cbar.ax.set_title('$P_{FM}$') plt.clim(0, 1) plt.xlabel(xlabel) plt.ylabel(ylabel) return plt def diag_H(self): """ Returns probability of each state. """ numericH = get_numeric_H(self) HZ = numericH['HZ'] gs = gs_calculator(HZ) num_qubits = len(self.qubits) Hsize = 2**(num_qubits) probs = np.array([abs(gs[i].flatten()[0])**2 for i in range(Hsize)]) return probs def nf_anneal(self, schedule): """ Performs a numeric forward anneal on H using QuTip. inputs: --------- schedule - a numeric anneal schedule defined with anneal length outputs: --------- probs - probability of each output state as a list ordered in canconically w.r.t. tensor product """ times, svals = schedule # create a numeric representation of H ABfuncs = time_interpolation(schedule, self.processordata) numericH = get_numeric_H(self) A = ABfuncs['A(t)'] B = ABfuncs['B(t)'] HX = numericH['HX'] HZ = numericH['HZ'] # "Analytic" or function H(t) analH = lambda t: A(t) * HX + B(t) * HZ # Define list_H for QuTiP listH = [[HX, A], [HZ, B]] # perform a numerical forward anneal on H results = qt.sesolve(listH, gs_calculator(analH(0)), times) probs = np.array([ abs(results.states[-1][i].flatten()[0])**2 for i in range(self.Hsize) ]) return probs def nr_anneal(self, schedule, init_state): """ Performs a numeric reverse anneal on H using QuTip. inputs: --------- schedule - a numeric anneal schedule init_state - the starting state for the reverse anneal listed as string or list e.g. '111' or [010] outputs: --------- probs - probability of each output state as a list ordered in canconically w.r.t. tensor product """ times, svals = schedule # create a numeric representation of H ABfuncs = time_interpolation(schedule, self.processordata) numericH = get_numeric_H(self) A = ABfuncs['A(t)'] B = ABfuncs['B(t)'] HX = numericH['HX'] HZ = numericH['HZ'] # Define list_H for QuTiP listH = [[HX, A], [HZ, B]] # create a valid QuTip initial state qubit_states = [qts.ket([int(i)]) for i in init_state] QuTip_init_state = qt.tensor(*qubit_states) # perform a numerical reverse anneal on H results = qt.sesolve(listH, QuTip_init_state, times) probs = np.array([ abs(results.states[-1][i].flatten()[0])**2 for i in range(self.Hsize) ]) return probs def frem_anneal(self, schedules, partition, HR_init_state): """ Performs a numeric FREM anneal on H using QuTip. inputs: --------- schedules - a numeric annealing schedules [reverse, forward] partition - a parition of H in the form [HR, HF] init_state - the starting state for the reverse anneal listed as string or list e.g. '111' or [010] outputs: --------- probs - probability of each output state as a list ordered in canconically w.r.t. tensor product """ # retrieve useful quantities from input data f_sch, r_sch = schedules times = f_sch[0] HR = DictRep(H=partition['HR'], qpu='numerical', vartype='ising', encoding='logical') HF = DictRep(H=partition['HF'], qpu='numerical', vartype='ising', encoding='logical') Rqubits = partition['Rqubits'] # prepare the initial state statelist = [] fidx = 0 ridx = 0 for qubit in self.qubits: # if part of HR, give assigned value by user if qubit in Rqubits: statelist.append(qts.ket(HR_init_state[ridx])) ridx += 1 # otherwise, put in equal superposition (i.e. gs of x-basis) else: xstate = (qts.ket('0') - qts.ket('1')).unit() statelist.append(xstate) fidx += 1 init_state = qto.tensor(*statelist) # Create the numeric Hamiltonian for HR ABfuncs = time_interpolation(r_sch, self.processordata) numericH = get_numeric_H(HR) A = ABfuncs['A(t)'] B = ABfuncs['B(t)'] HX = numericH['HX'] HZ = numericH['HZ'] # Define list_H for QuTiP listHR = [[HX, A], [HZ, B]] # create the numeric Hamiltonian for HF ABfuncs = time_interpolation(f_sch, self.processordata) numericH = get_numeric_H(HF) A = ABfuncs['A(t)'] B = ABfuncs['B(t)'] HX = numericH['HX'] HZ = numericH['HZ'] # "Analytic" or function H(t) analHF = lambda t: A(t) * HX + B(t) * HZ # Define list_H for QuTiP listHF = [[HX, A], [HZ, B]] # create the total Hamitlontian of HF + HR list_totH = listHR + listHF # run the numerical simulation and find probabilities of each state frem_results = qt.sesolve(list_totH, init_state, times) probs = np.array([ abs(frem_results.states[-1][i].flatten()[0])**2 for i in range(self.Hsize) ]) return probs def frem_comparison(self, T, sval, ftr): """ Performs FREM algorithm and compares it to direct forward annealing. inputs: --------- T: total anneal time sval: svalue to go to in reverse annealing/ frem anneal ftr: the ratio of time spent in reverse and forward in frem outputs: --------- KL_div - the KL divergence of forward and FREM annealing w.r.t. diagonalization """ f_sch = make_numeric_schedule(.1, **{'direction': 'forward', 'ta': T}) r_sch = make_numeric_schedule( .1, **{ 'direction': 'reverse', 'ta': ftr * T, 'sa': sval, 'tq': (1 - ftr) * T }) # first, do direct diag on H # then extract non-zero entires ("gs" entries) dprobs = self.diag_H() nonzeroidxs = np.nonzero(dprobs) gs_dprobs = dprobs[nonzeroidxs] # perform forward anneal fprobs = self.nf_anneal(f_sch) gs_fprobs = fprobs[nonzeroidxs] # next, find a random partition of H into HR/HF partition = random_partition(self) # get qubits that belong to HR Rqubits = partition['Rqubits'] # find the most probable state of Rqubits from forward anneal init_state = ml_measurement(fprobs, self.nqubits) # perform reverse anneal using initial state guess rprobs = self.nr_anneal(r_sch, init_state) gs_rprobs = rprobs[nonzeroidxs] # find initial state of sub-system (i.e. Rqubits) sub_system_state = [] for (idx, qs) in enumerate(init_state): if idx in Rqubits: sub_system_state.append(qs) sub_init_state = ''.join([str(i) for i in sub_system_state]) # perform FREM anneal fremprobs = self.frem_anneal([f_sch, r_sch], partition, sub_init_state) gs_fremprobs = fremprobs[nonzeroidxs] # save data in a pandas dataframe fdata = { 'method': 'forward', 'T': T, 's': sval, 'ftr': ftr, 'part_size': self.nqubits, 'probs': fprobs, 'KL_div': entropy(dprobs, fprobs), 'gs_KL_div': entropy(gs_dprobs, gs_fprobs), 'gs_prob': sum(gs_fprobs) } rdata = { 'method': 'reverse', 'T': T, 's': sval, 'ftr': ftr, 'part_size': self.nqubits, 'probs': rprobs, 'KL_div': entropy(dprobs, rprobs), 'gs_KL_div': entropy(gs_dprobs, gs_rprobs), 'gs_prob': sum(gs_rprobs) } fremdata = { 'method': 'frem', 'T': T, 's': sval, 'ftr': ftr, 'part_size': len(Rqubits), 'probs': fremprobs, 'KL_div': entropy(dprobs, fremprobs), 'gs_KL_div': entropy(gs_dprobs, gs_fremprobs), 'gs_prob': sum(gs_fremprobs) } self.data = self.data.append(fdata, ignore_index=True) self.data = self.data.append(rdata, ignore_index=True) self.data = self.data.append(fremdata, ignore_index=True) return {'fdata': fdata, 'rdata': rdata, 'fremdata': fremdata} def sudden_anneal_test(self): pass def get_QUBO_rep(self): pass def get_Ising_rep(self): pass
fname = "results_%s_N%d_D%d_s%d.p" % (topology, nurses, days, numSampling) previous = pickle.load(open(fname, "rb")) initial = previous['results'].first.sample embedding = previous['embedding'] embeddedQ = embed_qubo(Q, embedding, sampler.adjacency) ### 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, initial_state=initial, reinitialize_state=reinitialize, anneal_schedule=schedule) samples = unembed_sampleset(results, embedding, sbqm, chain_break_fraction=True) ### Save data with pickle for analysis ### 結果分析のため pickle を用いてデータを保存します fout = "reinitialized_reverse_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 execute(circuit, backend = None, config=None, basis_gates=None, coupling_map=None, initial_layout=None, shots=1024, max_credits=10, seed=None, qobj_id=None, hpc=None, skip_transpiler=False, seed_mapper=None): outputs = list() inputs = list() qubit_biases = circuit.annealergraph.qubitbiases coupler_strengths = circuit.annealergraph.couplerstrengths print("\nDone building embedding.") print("\t# qubits: ", len(qubit_biases)) print("\t# couplers: ", len(coupler_strengths)) print("\t# non-gate couplers: {}\n".format(len(coupler_strengths)-circuit.annealergraph.numgatecouplers)) for qubit in circuit.annealergraph.qubits.keys(): if isinstance(circuit.annealergraph.qubits[qubit], dict): if circuit.annealergraph.qubits[qubit]['measured'] == True: outputs.append(circuit.annealergraph.qubits[qubit]['components'][-1]) # can't omit output bit from being included as input, but is its put # first in the list, it will be zero the top portion of the readout ans = input("Constrain input of measured qubit {} to be 0 (y/n)? ".format(qubit)) if ans == 'y': change = circuit.annealergraph.qubits[qubit]['components'][0] circuit.annealergraph.qubitbiases[change] = circuit.annealergraph.qubitbiases[change] + 5 else: inputs.append(circuit.annealergraph.qubits[qubit]['components'][0]) for qubit in circuit.annealergraph.qubits.keys(): if isinstance(circuit.annealergraph.qubits[qubit], dict): if circuit.annealergraph.qubits[qubit]['measured'] == False: ans = input("Constrain input of unmeasured qubit {} to be 0 (y/n)? ".format(qubit)) if ans == 'y': change = circuit.annealergraph.qubits[qubit]['components'][0] circuit.annealergraph.qubitbiases[change] = circuit.annealergraph.qubitbiases[change] + 5 else: inputs.append(circuit.annealergraph.qubits[qubit]['components'][0]) circuit.annealergraph.print_chimera_graph_to_file() samp = input("\nHow many samples? ") samp = int(samp) if 'source' in sys.argv: writedwavesource(circuit, circuit.annealergraph.token, samp, inputs, outputs) if ('run' in sys.argv) or (len(sys.argv)==1): try: import dimod from dwave.system.samplers import DWaveSampler from dwave.cloud.exceptions import SolverOfflineError from dwave.system.composites import EmbeddingComposite import minorminer except: print('Dwave Ocean not installed - cannot run or simulate generated embeddings. Run with "source" command line argument or install DWave Ocean.') return sampler = DWaveSampler(endpoint='https://cloud.dwavesys.com/sapi', token = circuit.annealergraph.token, solver = 'DW_2000Q_2_1') bqm = dimod.BinaryQuadraticModel(qubit_biases, coupler_strengths, 0, dimod.BINARY) print(qubit_biases) print(coupler_strengths) kwargs = {} if 'num_reads' in sampler.parameters: kwargs['num_reads'] = samp if 'answer_mode' in sampler.parameters: kwargs['answer_mode'] = 'histogram' #if 'annealing_time' in sampler.parameters: # kwargs['annealing_time'] = 100 print("\nRunning...") response = sampler.sample(bqm, **kwargs) sampler.client.close() print("Done.") print(response.data) groundstate = 1000000 for sample, energy in response.data(['sample','energy']): if energy<groundstate: groundstate = round(energy,1) print("Ground State: ", groundstate) function = list() for sample, energy in response.data(['sample', 'energy']): if round(energy,1) == groundstate: print(sample, round(energy,1)) row = [] for inp in inputs: row.append(sample[inp]) for outp in outputs: row.append(sample[outp]) function.append(row) print('\n') function.sort() for i in range(len(function)): print(function[i]) if 'sim' in sys.argv: try: import dimod from dwave.system.samplers import DWaveSampler from dwave.cloud.exceptions import SolverOfflineError from dwave.system.composites import EmbeddingComposite import minorminer except: print('Dwave Ocean not installed - cannot run or simulate generated embedding. Run with "source" command line argument or install DWave Ocean.') return ans = 'y' if len(circuit.annealergraph.qubitbiases) > 19: ans = input("WARNING: Embedding uses {} qubits - ExactSolver simulation could take way too long or cause your computer to crash. Type 'y' to continue: ".format(len(circuit.annealergraph.qubitbiases))) if ans == 'y' or ans == 'Y': print("Simulating problem with {} qubits".format(len(circuit.annealergraph.qubitbiases))) qubit_biases = circuit.annealergraph.qubitbiases coupler_strengths = circuit.annealergraph.couplerstrengths print("\nQubit Biases:") for key in qubit_biases.keys(): print(key, "\t", qubit_biases[key]) print("\nCoupler Strengths:") for key in coupler_strengths.keys(): print(key, "\t", coupler_strengths[key]) print("\n") bqm = dimod.BinaryQuadraticModel(qubit_biases, coupler_strengths, 0, dimod.BINARY) sampler = dimod.ExactSolver() response = sampler.sample(bqm) groundstate = 1000000 for sample, energy in response.data(['sample','energy']): if energy<groundstate: groundstate = round(energy,1) print("Ground State: ", groundstate) function = list() for sample, energy in response.data(['sample', 'energy']): if round(energy,1) == groundstate: print(sample, round(energy,1)) row = [] for inp in inputs: row.append(sample[inp]) for outp in outputs: row.append(sample[outp]) function.append(row) print('\n') function.sort() for i in range(len(function)): print(function[i]) else: print('Quitting.')
token=token, solver='DW_2000Q_2_1') bqm = dimod.BinaryQuadraticModel(qubit_biases, coupler_strengths, 0, dimod.BINARY) kwargs = {} if 'num_reads' in sampler.parameters: kwargs['num_reads'] = numofsamples if 'answer_mode' in sampler.parameters: kwargs['answer_mode'] = 'histogram' #if 'annealing_time' in sampler.parameters: # kwargs['annealing_time'] = 100 print('\nRunning...') response = sampler.sample(bqm, **kwargs) sampler.client.close() print('Done.') print(response.data) groundstate = 1000000 for sample, energy in response.data(['sample', 'energy']): if energy < groundstate: groundstate = round(energy, 1) print('Ground State: ', groundstate) function = list() for sample, energy in response.data(['sample', 'energy']): if round(energy, 1) == groundstate: print(sample, round(energy, 1))
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))