def startIBMQ(): global Q, backend # Written to work with versions of IBMQ-Provider both before and after 0.3 IBMQP_Vers=float(IBMQVersion['qiskit-ibmq-provider'][:3]) print('IBMQ Provider v',IBMQP_Vers) print ('Pinging IBM Quantum Experience before start') p=ping('https://api.quantum-computing.ibm.com',1,0.5,True) try: print("requested backend: ",backendparm) except: sleep(0) # specify the simulator as the backend backend='ibmq_qasm_simulator' if p==200: if (IBMQP_Vers > 0.2): # The new authentication technique with provider as the object provider0=IBMQ.load_account() try: Q=provider0.get_backend(backendparm) except: Q=provider0.get_backend(backend) else: interval = 300 else: # The older IBMQ authentication technique IBMQ.load_accounts() try: Q=IBMQ.get_backend(backendparm) except: Q=IBMQ.get_backend(backend) else: interval = 300 else: exit()
def set_backend(b='qasm_simulator'): global _backend if b == 'ibmqx4' or b == 'ibmqx5': _backend = IBMQ.get_backend(b) setqbits(5) elif b == 'ibmq_16_melbourne': _backend = IBMQ.get_backend(b) setqbits(16) elif b == 'ibmq_qasm_simulator': _backend = IBMQ.get_backend(b) setqbits(32) else: _backend = qiskit.BasicAer.get_backend('qasm_simulator') setqbits(8)
def startIBMQ(): global Q, backend # Written to work with versions of IBMQ-Provider both before and after 0.3 sQPV = IBMQVersion['qiskit-ibmq-provider'] pd = '.' dot1 = [pos for pos, char in enumerate(sQPV) if char == pd][0] dot2 = [pos for pos, char in enumerate(sQPV) if char == pd][1] IBMQP_Vers = float(sQPV[dot1 + 1:dot2]) print('IBMQ Provider v', IBMQP_Vers) if not UseLocal: print('Pinging IBM Quantum Experience before start') p = ping('https://api.quantum-computing.ibm.com', 1, 0.5, True) #p=ping('https://quantum-computing.ibm.com/',1,0.5,True) try: print("requested backend: ", backendparm) except: sleep(0) # specify the simulator as the backend backend = 'ibmq_qasm_simulator' if p == 200: if ( IBMQP_Vers > 2 ): # The new authentication technique with provider as the object provider0 = IBMQ.load_account() try: Q = provider0.get_backend(backendparm) except: Q = provider0.get_backend(backend) else: interval = 300 else: # The older IBMQ authentication technique IBMQ.load_accounts() try: Q = IBMQ.get_backend(backendparm) except: Q = IBMQ.get_backend(backend) else: interval = 300 else: exit() else: # THIS IS THE CASE FOR USING LOCAL SIMULATOR backend = 'local aer qasm_simulator' print("Building ", backend, "with requested attributes...") if not AddNoise: Q = Aer.get_backend('qasm_simulator') else: fake_backend = fake_qc() Q = QasmSimulator.from_backend(fake_backend)
def load_devise(self, devise_name): IBMQ.save_account( '53d53f699d4b706ce125b3fea389764d22ca4a5e031581e0db1e13abaa8a565b1ec61e5b9f3ddeaf507b912aff0e1229b38ad38783ecc072df17686610e7b00d', overwrite=True) IBMQ.update_account() IBMQ.load_account() return IBMQ.get_backend(devise_name)
def test_get_jobs_filter_counts(self, qe_token, qe_url): # TODO: consider generalizing backend name # TODO: this tests depends on the previous executions of the user IBMQ.enable_account(qe_token, qe_url) backend = IBMQ.get_backend('ibmq_qasm_simulator') my_filter = { 'backend.name': 'ibmq_qasm_simulator', 'shots': 1024, 'qasms.result.data.counts.00': { 'lt': 500 } } self.log.info('searching for at most 5 jobs with 1024 shots, a count ' 'for "00" of < 500, on the ibmq_qasm_simulator backend') job_list = backend.jobs(limit=5, skip=0, db_filter=my_filter) self.log.info('found %s matching jobs', len(job_list)) for i, job in enumerate(job_list): self.log.info('match #%d', i) result = job.result() self.assertTrue( any(cresult.data['counts']['00'] < 500 for cresult in result.results.values())) for circuit_name in result.get_names(): self.log.info('\tcircuit_name: %s', circuit_name) if circuit_name: counts = result.get_counts(circuit_name) self.log.info('\t%s', str(counts))
def get_appropriate_backend(n, real, online, backend_name): # Online, real or simuator? if (not online): global Aer from qiskit import Aer max_credits = 10 shots = 4098 print("Local simulator backend") backend = Aer.get_backend('qasm_simulator') # list of online devices: ibmq_qasm_simulator, ibmqx2, ibmqx4, ibmqx5, ibmq_16_melbourne else: global IBMQ from qiskit import IBMQ print("Online {0} backend".format("real" if real else "simulator")) max_credits = 3 shots = 4098 import Qconfig IBMQ.load_accounts() if (backend_name is not None): backend = IBMQ.get_backend(backend_name) else: large_enough_devices = IBMQ.backends( filters=lambda x: x.configuration()['n_qubits'] >= n and x.configuration()[ 'simulator'] == (not real) ) backend = least_busy(large_enough_devices) print("Backend name is {0}; max_credits = {1}, shots = {2}".format( backend, max_credits, shots)) return backend, max_credits, shots
def _circuit_validator(self, circuit, qregs, init_state, remote=False, test_shots=100000, threshold=1e-4): # TODO check with unitary simulator(currently, ansilla is bothering...) nc = ClassicalRegister(self.n_qubit) circuit.add_register(nc) for q, c in zip(qregs, nc): circuit.measure(q, c) if remote: backend = IBMQ.get_backend('ibmq_qasm_simulator') else: backend = Aer.get_backend('qasm_simulator') theoretical_prob = self._theoretical_prob(init_state) print(theoretical_prob) vjob = execute(circuit, backend=backend, shots=test_shots) result = vjob.result().get_counts(circuit) rb = self.n_qubit bins = [format(i, '0%sb' % rb) for i in range(2**rb)] probs = np.array([result.get(bi, 0)/test_shots for bi in bins]) print(probs) # TODO check L2 norm is good enough to validate in larger case # and check threshold l2dist = self._L2_dist(theoretical_prob, probs) if l2dist < threshold: flag = True else: flag = False circuit.remove_final_measurements() return circuit, flag
def test_get_backend_name(self, qe_token, qe_url): IBMQ.enable_account(qe_token, qe_url) backend = IBMQ.get_backend('ibmq_qasm_simulator') qobj = compile(self._qc, backend) job = backend.run(qobj) self.assertTrue(job.backend().name() == backend.name())
def get_job_status(backend, job_id): backend = IBMQ.get_backend(backend) try: print("Backend {0} is operational? {1}".format( backend.name(), backend.status()['operational'])) print("Backend was last updated in {0}".format( backend.properties()['last_update_date'])) print("Backend has {0} pending jobs".format( backend.status()['pending_jobs'])) except: print("Maybe some errors in the properties of backend") ibmq_job = backend.retrieve_job(job_id) status = ibmq_job.status() print(status.name) print(ibmq_job.creation_date()) if (status.name == 'DONE'): print("EUREKA") result = ibmq_job.result() counts = result.get_counts() print("Result is: {0}".format(counts)) plot_histogram(counts) else: print("... Work in progress ...") print("Queue position = {0}".format(ibmq_job.queue_position())) print("Error message = {0}".format(ibmq_job.error_message()))
def set_backend(back): global backend if back == "ibmq": backend = IBMQ.get_backend('ibmqx4') else: backend = Aer.get_backend('qasm_simulator') print(backend.name)
def test_execute_several_circuits_simulator_online(self, qe_token, qe_url): """Test execute_several_circuits_simulator_online. If all correct should return correct counts. """ IBMQ.enable_account(qe_token, qe_url) backend = IBMQ.get_backend('ibmq_qasm_simulator') qr = QuantumRegister(2) cr = ClassicalRegister(2) qcr1 = QuantumCircuit(qr, cr) qcr2 = QuantumCircuit(qr, cr) qcr1.h(qr) qcr2.h(qr[0]) qcr2.cx(qr[0], qr[1]) qcr1.measure(qr[0], cr[0]) qcr1.measure(qr[1], cr[1]) qcr2.measure(qr[0], cr[0]) qcr2.measure(qr[1], cr[1]) shots = 1024 qobj = compile([qcr1, qcr2], backend=backend, seed=73846087, shots=shots) job = backend.run(qobj) result = job.result() counts1 = result.get_counts(qcr1) counts2 = result.get_counts(qcr2) target1 = {'00': shots / 4, '01': shots / 4, '10': shots / 4, '11': shots / 4} target2 = {'00': shots / 2, '11': shots / 2} threshold = 0.04 * shots self.assertDictAlmostEqual(counts1, target1, threshold) self.assertDictAlmostEqual(counts2, target2, threshold)
def test_online_qasm_simulator_two_registers(self, qe_token, qe_url): """Test online_qasm_simulator_two_registers. If all correct should return correct counts. """ IBMQ.enable_account(qe_token, qe_url) backend = IBMQ.get_backend('ibmq_qasm_simulator') qr1 = QuantumRegister(2) cr1 = ClassicalRegister(2) qr2 = QuantumRegister(2) cr2 = ClassicalRegister(2) qcr1 = QuantumCircuit(qr1, qr2, cr1, cr2) qcr2 = QuantumCircuit(qr1, qr2, cr1, cr2) qcr1.x(qr1[0]) qcr2.x(qr2[1]) qcr1.measure(qr1[0], cr1[0]) qcr1.measure(qr1[1], cr1[1]) qcr1.measure(qr2[0], cr2[0]) qcr1.measure(qr2[1], cr2[1]) qcr2.measure(qr1[0], cr1[0]) qcr2.measure(qr1[1], cr1[1]) qcr2.measure(qr2[0], cr2[0]) qcr2.measure(qr2[1], cr2[1]) shots = 1024 qobj = transpiler.compile([qcr1, qcr2], backend, seed=8458, shots=shots) job = backend.run(qobj) result = job.result() result1 = result.get_counts(qcr1) result2 = result.get_counts(qcr2) self.assertEqual(result1, {'00 01': 1024}) self.assertEqual(result2, {'10 00': 1024})
def test_run_simulator(self, qe_token, qe_url): IBMQ.enable_account(qe_token, qe_url) backend = IBMQ.get_backend('ibmq_qasm_simulator') qr = QuantumRegister(2, 'q') cr = ClassicalRegister(2, 'c') qc = QuantumCircuit(qr, cr, name='hadamard') qc.h(qr) qc.measure(qr, cr) qobj = compile([self._qc, qc], backend) shots = qobj.config.shots job = backend.run(qobj) result = job.result() counts_qx1 = result.get_counts(0) counts_qx2 = result.get_counts(1) counts_ex1 = {'00': shots/2, '11': shots/2} counts_ex2 = {'00': shots/4, '11': shots/4, '10': shots/4, '01': shots/4} states1 = counts_qx1.keys() | counts_ex1.keys() states2 = counts_qx2.keys() | counts_ex2.keys() # contingency table ctable1 = numpy.array([[counts_qx1.get(key, 0) for key in states1], [counts_ex1.get(key, 0) for key in states1]]) ctable2 = numpy.array([[counts_qx2.get(key, 0) for key in states2], [counts_ex2.get(key, 0) for key in states2]]) self.log.info('states1: %s', str(states1)) self.log.info('states2: %s', str(states2)) self.log.info('ctable1: %s', str(ctable1)) self.log.info('ctable2: %s', str(ctable2)) contingency1 = chi2_contingency(ctable1) contingency2 = chi2_contingency(ctable2) self.log.info('chi2_contingency1: %s', str(contingency1)) self.log.info('chi2_contingency2: %s', str(contingency2)) self.assertGreater(contingency1[1], 0.01) self.assertGreater(contingency2[1], 0.01)
def test_job_id(self, qe_token, qe_url): IBMQ.enable_account(qe_token, qe_url) backend = IBMQ.get_backend('ibmq_qasm_simulator') qobj = compile(self._qc, backend) job = backend.run(qobj) self.log.info('job_id: %s', job.job_id()) self.assertTrue(job.job_id() is not None)
def get_backend(device): """Returns backend object for device specified by input string.""" try: backend = Aer.get_backend(device) except: print("You are using an IBMQ backend. The results for this are provided in accordance with the IBM Q Experience EULA.\nhttps://quantumexperience.ng.bluemix.net/qx/terms") # Legal stuff! Yay! backend = IBMQ.get_backend(device) return backend
def compile(circuits, backend, 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): """Compile a list of circuits into a qobj. Args: circuits (QuantumCircuit or list[QuantumCircuit]): circuits to compile backend (BaseBackend or str): a backend to compile for config (dict): dictionary of parameters (e.g. noise) used by runner basis_gates (str): comma-separated basis gate set to compile to coupling_map (list): coupling map (perhaps custom) to target in mapping initial_layout (list): initial layout of qubits in mapping shots (int): number of repetitions of each circuit, for sampling max_credits (int): maximum credits to use seed (int): random seed for simulators qobj_id (int): identifier for the generated qobj hpc (dict): HPC simulator parameters skip_transpiler (bool): skip most of the compile steps and produce qobj directly Returns: Qobj: the qobj to be run on the backends Raises: TranspilerError: in case of bad compile options, e.g. the hpc options. .. deprecated:: 0.6+ After 0.6, compile will only take a backend object. """ # pylint: disable=redefined-builtin if isinstance(backend, str): warnings.warn( 'compile() no longer takes backend string names.' 'Please pass backend objects, obtained via' 'IBMQ.get_backend() or Aer.get_backend().', DeprecationWarning) try: backend = Aer.get_backend(backend) except KeyError: backend = IBMQ.get_backend(backend) pass_manager = None # default pass manager which executes predetermined passes # TODO (jay) why do we need to pass skip and not pass manager directly if skip_transpiler: # empty pass manager which does nothing pass_manager = PassManager() qobj_standard = transpiler.compile(circuits, backend, config, basis_gates, coupling_map, initial_layout, shots, max_credits, seed, qobj_id, hpc, pass_manager) return qobj_standard
def solve_ibmqx_ising_qubo_nisq_ibmqx4(G, matrix_func, optimizer, p): backend = IBMQ.get_backend('ibmqx4') w = matrix_func(G) ops = get_qubitops(w) qaoa = QAOA(ops, optimizer, p, operator_mode='paulis') quantum_instance = QuantumInstance(backend) result = qaoa.run(quantum_instance) x = sample_most_likely(result['eigvecs'][0]) return x
def monitor(): q = QuantumRegister(1) c = ClassicalRegister(1) qc = QuantumCircuit(q, c) qc.x(q[0]) qc.measure(q, c) backend_sim = IBMQ.get_backend('ibmqx_hpc_qasm_simulator') result = execute(qc, backend_sim, shots=100).result()
def test_retrieve_job(self, qe_token, qe_url): IBMQ.enable_account(qe_token, qe_url) backend = IBMQ.get_backend('ibmq_qasm_simulator') qobj = compile(self._qc, backend) job = backend.run(qobj) rjob = backend.retrieve_job(job.job_id()) self.assertTrue(job.job_id() == rjob.job_id()) self.assertTrue(job.result().get_counts() == rjob.result().get_counts())
def ask_for_device (): d = input("Do you want to play on the real device? (y/n)\n").upper() if (d=="Y"): device = IBMQ.get_backend('ibmq_5_tenerife') # if real, we use ibmqx4 else: device = Aer.get_backend('qasm_simulator') # otherwise, we use a simulator return device
def test_aliases(self, qe_token, qe_url): """Test that display names of devices map the same backends as the regular names.""" IBMQ.enable_account(qe_token, qe_url) aliased_names = IBMQ.aliased_backend_names() for display_name, backend_name in aliased_names.items(): with self.subTest(display_name=display_name, backend_name=backend_name): try: backend_by_name = IBMQ.get_backend(backend_name) except KeyError: # The real name of the backend might not exist pass else: backend_by_display_name = IBMQ.get_backend(display_name) self.assertEqual(backend_by_name, backend_by_display_name) self.assertEqual(backend_by_display_name.name(), backend_name)
def test_ibmq_result_fields(self, qe_token, qe_url): """Test components of a result from a remote simulator.""" IBMQ.enable_account(qe_token, qe_url) remote_backend = IBMQ.get_backend(local=False, simulator=True) remote_result = execute(self._qc1, remote_backend).result() self.assertEqual(remote_result.backend_name, remote_backend.name()) self.assertIsInstance(remote_result.job_id, str) self.assertEqual(remote_result.status, 'COMPLETED') self.assertEqual(remote_result.results[0].status, 'DONE')
def get_single_job(self): backend = IBMQ.get_backend(self.backend_name) number_of_jobs_to_download = 1 downloaded_job = backend.jobs(limit=number_of_jobs_to_download, skip=self.jobs_to_skip, status='DONE') return downloaded_job[0]
def test_double_submit_fails(self, qe_token, qe_url): IBMQ.enable_account(qe_token, qe_url) backend = IBMQ.get_backend('ibmq_qasm_simulator') qobj = compile(self._qc, backend) # backend.run() will automatically call job.submit() job = backend.run(qobj) with self.assertRaises(JobError): job.submit()
def __init__(self, problem_description, backend_params=None, depth=3, var_form='RYRZ', APItoken=None, target_backend_name=None): self.check_and_load_accounts() if backend_params is None: self.depth = depth self.var_form_name = var_form else: self.depth=backend_params['depth'] self.var_form_name=backend_params['var_form'] try: self.num_qubits = problem_description['num_qubits'] except KeyError: self.num_qubits = problem_description['n_nodes'] self.coupling_map = None self.noise_model = None self.basis_gates = None if self.var_form_name == 'RYRZ': self.target_backend_name = target_backend_name if self.target_backend_name is not None: # load noise models target_backend = IBMQ.get_backend(self.target_backend_name) properties = target_backend.properties() self.coupling_map = target_backend.configuration().coupling_map # Generate an Aer noise model for target_backend # self.noise_model = noise.device.basic_device_noise_model(properties) # unreliable # self.basis_gates = self.noise_model.basis_gates self.var_form = RYRZ(self.num_qubits, self.depth, entanglement='linear') self.shift = 0 elif self.var_form_name == 'QAOA': if backend_params is not None and 'mixer_operator' in backend_params: mixerOp = backend_params['mixer_operator'] else: mixerOp = None if problem_description['name'] == 'modularity': B = problem_description['B'] if B is None: raise ValueError("If using var_form == QAOA, have to specify B") qubitOp = get_modularity_qubitops(B) self.shift = 0 elif problem_description['name'] == 'maxcut': A = problem_description['A'] qubitOp, shift = get_maxcut_qubitops(A) self.shift = shift elif problem_description['name'] == 'ising': B_matrix = problem_description['B_matrix'] B_bias = problem_description['B_bias'] qubitOp, shift = get_general_ising_qubitops(B_matrix, B_bias) self.shift = shift else: raise ValueError("Unsupported problem: {}".format(problem_description['name'])) self.var_form = QAOAVarForm(qubitOp, self.depth, mixer_operator=mixerOp) else: raise ValueError("Incorrect var_form {}".format(self.var_form_name)) self.num_parameters = self.var_form.num_parameters logging.info("Initialized IBMQXVarForm {} with num_qubits={}, depth={}".format(self.var_form_name, self.num_qubits, self.depth))
def test_run_async_simulator(self, qe_token, qe_url): IBMQJob._executor = futures.ThreadPoolExecutor(max_workers=2) IBMQ.enable_account(qe_token, qe_url) backend = IBMQ.get_backend('ibmq_qasm_simulator') self.log.info('submitting to backend %s', backend.name()) num_qubits = 16 qr = QuantumRegister(num_qubits, 'qr') cr = ClassicalRegister(num_qubits, 'cr') qc = QuantumCircuit(qr, cr) for i in range(num_qubits - 1): qc.cx(qr[i], qr[i + 1]) qc.measure(qr, cr) qobj = transpiler.compile([qc] * 10, backend) num_jobs = 5 job_array = [backend.run(qobj) for _ in range(num_jobs)] found_async_jobs = False timeout = 30 start_time = time.time() while not found_async_jobs: check = sum( [job.status() is JobStatus.RUNNING for job in job_array]) if check >= 2: self.log.info('found %d simultaneous jobs', check) break if all([job.status() is JobStatus.DONE for job in job_array]): # done too soon? don't generate error self.log.warning('all jobs completed before simultaneous jobs ' 'could be detected') break for job in job_array: self.log.info('%s %s %s %s', job.status(), job.status() is JobStatus.RUNNING, check, job.job_id()) self.log.info('-' * 20 + ' ' + str(time.time() - start_time)) if time.time() - start_time > timeout: raise TimeoutError('failed to see multiple running jobs after ' '{0} s'.format(timeout)) time.sleep(0.2) result_array = [job.result() for job in job_array] self.log.info('got back all job results') # Ensure all jobs have finished. self.assertTrue( all([job.status() is JobStatus.DONE for job in job_array])) self.assertTrue( all([ result.get_status() == 'COMPLETED' for result in result_array ])) # Ensure job ids are unique. job_ids = [job.job_id() for job in job_array] self.assertEqual(sorted(job_ids), sorted(list(set(job_ids))))
def generateQK(num_bits, theta1=0, theta2=0, securityThresh=1000, simulation=True, withHist=False): # Create the circuit cx_circ = parityCircuit(theta1, theta2) if simulation: # Execute the circuit print("Running on simulation...") job = execute(cx_circ, backend = Aer.get_backend('qasm_simulator'), shots=256*num_bits, memory=True) result = job.result() else: # Execute the circuit print("Running on real quantum computer...") job = execute(cx_circ, backend = IBMQ.get_backend('ibmqx2'), shots=256*num_bits, memory=True) result = job.result() # Print circuit. # print(cx_circ) # Print the result if withHist: counts = result.get_counts(cx_circ) plot.bar(counts.keys(), counts.values(), 1.0, color='g') plot.show() memory = result.get_memory() num_bits = int(num_bits) # memory = memory[len(memory)-num_bits: len(memory)] res = {'A': '', 'B': '', 'errorCounter':0, 'valid': True} counter = 0 i = len(memory)-1 while len(res["A"]) != num_bits: # print('Memory', memory[i], i) # Check if error in parity bit and discard if there is if memory[i][4] == '0': counter+=1 else: res["A"] = res["A"] + memory[i][1] res["B"] = res["B"] + memory[i][2] # SecurityThreshold from which we discard the key if counter >= securityThresh: res['valid'] = False res["errorCounter"] = counter return res i-=1 res["errorCounter"] = counter return res
def test_cancel(self, qe_token, qe_url): IBMQ.enable_account(qe_token, qe_url) backend_name = ('ibmq_20_tokyo' if self.using_ibmq_credentials else 'ibmqx4') backend = IBMQ.get_backend(backend_name) qobj = compile(self._qc, backend) job = backend.run(qobj) self.wait_for_initialization(job, timeout=5) can_cancel = job.cancel() self.assertTrue(can_cancel) self.assertTrue(job.status() is JobStatus.CANCELLED)
def setUp(self): super().setUp() self._testing_device = os.getenv('IBMQ_QOBJ_DEVICE', None) self._qe_token = os.getenv('IBMQ_TOKEN', None) self._qe_url = os.getenv('IBMQ_QOBJ_URL') if not self._testing_device or not self._qe_token or not self._qe_url: self.skipTest('No credentials or testing device available for ' 'testing Qobj capabilities.') IBMQ.enable_account(self._qe_token, self._qe_url) self._backend = IBMQ.get_backend(self._testing_device) self._qc = _bell_circuit()
def test_retrieve_job(self, qe_token, qe_url): IBMQ.enable_account(qe_token, qe_url) backend = IBMQ.get_backend('ibmq_qasm_simulator') qobj = compile(self._qc, backend) job = backend.run(qobj) rjob = backend.retrieve_job(job.job_id()) self.assertEqual(job.job_id(), rjob.job_id()) self.assertEqual(job.result().get_counts(), rjob.result().get_counts()) if getattr(backend.configuration(), 'allow_q_object'): self.assertEqual(job.qobj().as_dict(), qobj.as_dict()) else: self.assertEqual(job.qobj(), None)