def setup(self): need_token = self.use_actual_hardware or not self.run_locally if need_token: if self.ibm_qe_api_token is None: self.ibm_qe_api_token = getpass.getpass( 'Please input your token and hit enter: ') self.qx_config = { 'APItoken': self.ibm_qe_api_token, 'url': 'https://quantumexperience.ng.bluemix.net/api' } try: print('registering API token...') register(self.qx_config['APItoken'], self.qx_config['url']) print('\nYou have access to great power!') print(available_backends({'local': False, 'simulator': False})) except: print('Something went wrong.\nDid you enter a correct token?') exit() # If no backend is requested, find the least busy one if self.qiskit_backend is None: self.qiskit_backend = least_busy( available_backends({ 'simulator': (not self.use_actual_hardware), 'local': self.run_locally })) print('available_backends: {}'.format(available_backends())) print('Using simulator backend: ' + self.qiskit_backend)
def test_compact_flag(self): """Test the compact flag for available_backends works""" compact_names = available_backends() expanded_names = available_backends(compact=False) self.assertIn('local_qasm_simulator', compact_names) self.assertIn('local_statevector_simulator', compact_names) self.assertIn('local_unitary_simulator', compact_names) self.assertIn('local_qasm_simulator_py', expanded_names) self.assertIn('local_statevector_simulator_py', expanded_names)
def backend_lists(): Experiment().IBMQ_register() remote_backends = available_backends({'local': False, 'simulator': False}) remote_simulator = available_backends({'local': False, 'simulator': True}) local_simulators = available_backends({'local': True}) print("Remote backends: {}".format(remote_backends)) print("Remote simulator: {}".format(remote_simulator)) print("Local backends: {}".format(local_simulators)) return (remote_backends, remote_simulator, local_simulators)
def test_api_calls_no_parameters(self): """Test calling some endpoints of the API with no hub parameters. Note: this tests does not make assertions, it is only intended to verify the endpoints. """ # Invoke with no hub, group or project parameters. _ = self._set_api(QE_TOKEN, {'url': QE_URL}) self.log.info(qiskit.available_backends(filters={'local': False})) all_backend_names = qiskit.available_backends() for backend_name in all_backend_names: backend = qiskit.get_backend(backend_name) self.log.info(backend.parameters) self.log.info(backend.calibration)
def test_api_calls_no_parameters(self): """Test calling some endpoints of the API with no hub parameters. Note: this tests does not make assertions, it is only intended to verify the endpoints. """ # Invoke with no hub, group or project parameters. _ = self._set_api(QE_TOKEN, {'url': QE_URL}) self.log.info(qiskit.available_backends(filters={'local': False})) all_backend_names = qiskit.available_backends() for backend_name in all_backend_names: backend = qiskit.get_backend(backend_name) self.log.info(backend.parameters) self.log.info(backend.calibration)
def register_and_get_operational_backends(*args, provider_class=IBMQProvider, **kwargs): try: for provider in q_registered_providers(): if isinstance(provider, provider_class): q_unregister(provider) logger.debug( "Provider '{}' unregistered with Qiskit successfully.". format(provider_class)) break except Exception as e: logger.debug( "Failed to unregister provider '{}' with Qiskit: {}".format( provider_class, str(e))) preferences = Preferences() if args or kwargs or preferences.get_token() is not None: try: q_register(*args, provider_class=provider_class, **kwargs) logger.debug( "Provider '{}' registered with Qiskit successfully.". format(provider_class)) except Exception as e: logger.debug( "Failed to register provider '{}' with Qiskit: {}".format( provider_class, str(e))) backends = available_backends() backends = [ x for x in backends if x not in QuantumAlgorithm.UNSUPPORTED_BACKENDS ] return backends
def main(): parser = argparse.ArgumentParser() parser.add_argument('--apiToken') parser.add_argument('--url', nargs='?', default='https://quantumexperience.ng.bluemix.net/api') parser.add_argument('--hub', nargs='?', default=None) parser.add_argument('--group', nargs='?', default=None) parser.add_argument('--project', nargs='?', default=None) args = vars(parser.parse_args()) if (args['url'] is None): args['url'] = 'https://quantumexperience.ng.bluemix.net/api' if (args['hub'] is None) or (args['group'] is None) or (args['project'] is None): api = IBMQuantumExperience(args['apiToken'], {'url': args['url']}) register(args['apiToken'], args['url']) else: api = IBMQuantumExperience(args['apiToken'], { 'url': args['url'], 'hub': args['hub'], 'group': args['group'], 'project': args['project']}) register(args['apiToken'], args['url'], args['hub'], args['group'], args['project']) backs = available_backends() for back in backs: try: back_status = api.backend_status(back) print(json.dumps(back_status, indent=2, sort_keys=True)) except: pass
def exec_circuits(jobs, backend): bad_backend = True runner = None while bad_backend: try: runner = get_backend(backend) bad_backend = False global BACKEND BACKEND = backend #remember new backend except Exception as e: print(available_backends()) backend = input( "chosen backend not available, choose one from the list above: " ) bad_backend = True job_num = 0 started_jobs = [] for qobj in jobs: try: job = runner.run(qobj) except Exception as e: print("job number " + str(job_num) + " failed...\nrunning next job...") job_num += 1 started_jobs.append(job) return started_jobs
def register_and_get_operational_backends(qconfig): try: for provider in q_registered_providers(): if isinstance(provider,IBMQProvider): q_unregister(provider) logger.debug("Provider 'IBMQProvider' unregistered with Qiskit successfully.") break except Exception as e: logger.debug("Failed to unregister provider 'IBMQProvider' with Qiskit: {}".format(str(e))) if qconfig is not None: hub = qconfig.config.get('hub', None) group = qconfig.config.get('group', None) project = qconfig.config.get('project', None) proxies = qconfig.config.get('proxies', None) verify = qconfig.config.get('verify', True) try: q_register(qconfig.APItoken, provider_class=IBMQProvider, url=qconfig.config["url"], hub=hub, group=group, project=project, proxies=proxies, verify=verify) logger.debug("Provider 'IBMQProvider' registered with Qiskit successfully.") except Exception as e: logger.debug("Failed to register provider 'IBMQProvider' with Qiskit: {}".format(str(e))) backends = available_backends() backends = [x for x in backends if x not in QuantumAlgorithm.UNSUPPORTED_BACKENDS] return backends
def listRemoteBackends(self, apiToken, url, hub=None, group=None, project=None): if (version.parse(__version__) > version.parse("0.5") and version.parse(__version__) < version.parse("0.6")): if (hub is None or group is None or project is None): register(apiToken, url) else: register(apiToken, url, hub, group, project) backs = available_backends({'local': False}) elif (version.parse(__version__) > version.parse("0.6")): if (hub is None or group is None or project is None): IBMQ.enable_account(apiToken, url) else: IBMQ.enable_account(apiToken, url=url, hub=hub, group=group, project=project) backs = [backend.name() for backend in IBMQ.backends()] else: raise QiskitUnsupportedVersion( 'Qiskit-terra version must be v0.5 or v0.6') return backs
def getBitString(sim): qbits = 9 qr = QuantumRegister(qbits) cr = ClassicalRegister(qbits) qc = QuantumCircuit(qr, cr) for i in range(qbits): qc.h(qr[i]) for i in range(qbits): qc.measure(qr[i], cr[i]) backends = available_backends() backend = present_backends(sim, backends) if backend.status["available"] is True: stats = go_job(backend, qc, False, 10000) max = 0 for bitString in stats: if (stats[bitString] > max): max = stats[bitString] for bitString in stats: if (stats[bitString] == max): return (bitString) else: print(color.FAIL, ' Backend', backend.name, 'is unavailable, try again later.', color.ENDC)
def bestBackend(): sim = int(input("\nAllow simulators [0/1]?")) list = available_backends({'local': False, 'simulator': sim}) bestatus = [get_backend(backend).status for backend in list] best = min([x for x in bestatus if x['available'] is True], key=lambda x: x['pending_jobs']) print("Using backend: " + best['name']) return best['name']
def lowest_pending_jobs(): """Returns the backend with lowest pending jobs.""" list_of_backends = available_backends( {'local': False, 'simulator': False}) device_status = [get_backend(backend).status for backend in list_of_backends] best = min([x for x in device_status if x['available'] is True], key=lambda x: x['pending_jobs']) return best['name']
def lowest_pending_jobs(): from qiskit import available_backends, get_backend list_of_backends = available_backends( {'local': False, 'simulator': False}) device_status = [get_backend(backend).status for backend in list_of_backends] best = min([ x for x in device_status if x['available'] is True], key = lambda x: x['pending_jobs']) return best['name']
def lowest_pending_jobs(): """Returns the backend with lowest pending jobs.""" list_of_backends = available_backends({'local': False, 'simulator': False}) device_status = [ get_backend(backend).status for backend in list_of_backends ] best = min([x for x in device_status if x['available'] is True], key=lambda x: x['pending_jobs']) return best['name']
def backends(qconsole=False): key = 'qconsole' if qconsole else 'qx' token = Qconfig.APItoken[key] config = Qconfig.config[key] url = config.get('url', None) hub = config.get('hub', None) group = config.get('group', None) project = config.get('project', None) register(token, url, hub, group, project) return available_backends()
def test_execute_invalid_api_parameters(self): """Test calling the API with invalid hub parameters.""" # Invoke with hub, group and project parameters. _ = self._set_api(QE_TOKEN, {'url': QE_URL, 'hub': 'FAKE_HUB', 'group': 'FAKE_GROUP', 'project': 'FAKE_PROJECT'}) # TODO: this assertion is brittle. If the hub/group/token parameters # are invalid, login will work, but all the API calls will be made # against invalid URLS that return 400, ie: # /api/Network/FAKE_HUB/Groups/FAKE_GROUP/Projects/FAKE_PROJECT/devices self.assertEqual([], qiskit.available_backends(filters={'local': False}))
def listLocalBackends(self): if (version.parse(__version__) > version.parse("0.5") and version.parse(__version__) < version.parse("0.6")): backs = available_backends({'local': True}) elif (version.parse(__version__) > version.parse("0.6")): backs = [backend.name() for backend in Aer.backends()] else: raise QiskitUnsupportedVersion( 'Qiskit-terra version must be v0.5 or v0.6') return backs
def get_runner(): bad_backend = True runner = None global BACKEND while bad_backend: try: runner = get_backend(BACKEND) bad_backend = False except Exception as e: print(available_backends()) BACKEND = input( "chosen backend not available, choose one from the list above: " ) bad_backend = True return runner
def test_execute_invalid_api_parameters(self): """Test calling the API with invalid hub parameters.""" # Invoke with hub, group and project parameters. _ = self._set_api( QE_TOKEN, { 'url': QE_URL, 'hub': 'FAKE_HUB', 'group': 'FAKE_GROUP', 'project': 'FAKE_PROJECT' }) # TODO: this assertion is brittle. If the hub/group/token parameters # are invalid, login will work, but all the API calls will be made # against invalid URLS that return 400, ie: # /api/Network/FAKE_HUB/Groups/FAKE_GROUP/Projects/FAKE_PROJECT/devices self.assertEqual([], qiskit.available_backends(filters={'local': False}))
def test_api_calls_parameters(self): """Test calling some endpoints of the API with hub parameters. Note: this tests does not make assertions, it is only intended to verify the endpoints. """ # Invoke with hub, group and project parameters. _ = self._set_api(QE_TOKEN, {'url': QE_URL, 'hub': QE_HUB, 'group': QE_GROUP, 'project': QE_PROJECT}) all_backend_names = qiskit.available_backends() for backend_name in all_backend_names: backend = qiskit.get_backend(backend_name) self.log.info(backend.parameters) self.log.info(backend.calibration)
def signIn(): try: import sys sys.path.append("../") import Qconfig qx_config = { "APItoken": Qconfig.APItoken, "url": Qconfig.config['url'] } register(qx_config['APItoken'], qx_config['url']) except Exception as e: print(e) APIToken = getpass.getpass('\nPlease enter your token and press enter') qx_config = { "APItoken": APIToken, "url": 'https://quantumexperience.ng.bluemix.net/api' } register(qx_config['APItoken'], qx_config['url']) print(available_backends())
def test_api_calls_parameters(self): """Test calling some endpoints of the API with hub parameters. Note: this tests does not make assertions, it is only intended to verify the endpoints. """ # Invoke with hub, group and project parameters. _ = self._set_api(QE_TOKEN, { 'url': QE_URL, 'hub': QE_HUB, 'group': QE_GROUP, 'project': QE_PROJECT }) all_backend_names = qiskit.available_backends() for backend_name in all_backend_names: backend = qiskit.get_backend(backend_name) self.log.info(backend.parameters) self.log.info(backend.calibration)
def run(shots, qc, cfg, backend=None): if 'url' in cfg.keys(): register(cfg['token'], cfg['url'], cfg['hub'], cfg['group'], cfg['project']) print(available_backends()) if backend is None: backend = cfg['backend'] backend_config = get_backend(backend).configuration backend_coupling = backend_config['coupling_map'] qc_compiled = compile([qc], backend=backend, coupling_map=backend_coupling, seed=0) qc_compiled_qasm = qc_compiled['circuits'][0]['compiled_circuit_qasm'] #print(qc_compiled_qasm) job = execute([qc], backend=backend, shots=shots) result = job.result() return result
def go_measure(qc, qr, cr, sim): for i in range(9): qc.measure(qr[i], cr[i]) backends = available_backends() backend = present_backends(sim, backends) if backend.status["available"] is True: stats = go_job(backend, qc, True, 1024) max = 0 res = [] # print('Stats :\n', stats) for bitString in stats: if (stats[bitString] > max): max = stats[bitString] for bitString in stats: if (stats[bitString] == max): res.append(bitString) print_map(res, max) return (1) else: print(color.FAIL, ' Backend', backend.name, 'is unavailable, try again later.', color.ENDC)
def main(): warnings.simplefilter('ignore') parser = argparse.ArgumentParser() parser.add_argument('--apiToken') parser.add_argument('--url', nargs='?', default='https://quantumexperience.ng.bluemix.net/api') parser.add_argument('--hub', nargs='?', default=None) parser.add_argument('--group', nargs='?', default=None) parser.add_argument('--project', nargs='?', default=None) parser.add_argument('--status', default=False) args = vars(parser.parse_args()) if (args['url'] is None): args['url'] = 'https://quantumexperience.ng.bluemix.net/api' if (args['hub'] is None) or (args['group'] is None) or (args['project'] is None): register(args['apiToken'], args['url']) else: register(args['apiToken'], args['url'], args['hub'], args['group'], args['project']) backs = available_backends({'local': False}) if str(args['status']) == "True": statusDevices = [] for back in backs: fullInfoBack = createDeviceStatus(back) statusDevices.append(fullInfoBack) print(json.dumps(statusDevices, indent=2, sort_keys=True)) else: print(json.dumps(backs, indent=2, sort_keys=True))
clbit_reg = ClassicalRegister(2, name='c') # Making first circuit: bell state qc1 = QuantumCircuit(qubit_reg, clbit_reg, name="bell") qc1.h(qubit_reg[0]) qc1.cx(qubit_reg[0], qubit_reg[1]) qc1.measure(qubit_reg, clbit_reg) # Making another circuit: superpositions qc2 = QuantumCircuit(qubit_reg, clbit_reg, name="superposition") qc2.h(qubit_reg) qc2.measure(qubit_reg, clbit_reg) # Setting up the backend print("(Local Backends)") for backend_name in available_backends({'local': True}): backend = get_backend(backend_name) print(backend.status) my_backend_name = 'local_qasm_simulator' my_backend = get_backend(my_backend_name) print("(Local QASM Simulator configuration) ") pprint.pprint(my_backend.configuration) print("(Local QASM Simulator calibration) ") pprint.pprint(my_backend.calibration) print("(Local QASM Simulator parameters) ") pprint.pprint(my_backend.parameters) # Compiling the job qobj = compile([qc1, qc2], my_backend) # Note: in the near future qobj will become an object
register(Qconfig.APItoken, Qconfig.config["url"], verify=False, hub=Qconfig.config["hub"], group=Qconfig.config["group"], project=Qconfig.config["project"]) except: offline = True print("""WARNING: There's no connection with IBMQuantumExperience servers. cannot test I/O intesive tasks, will only test CPU intensive tasks running the jobs in the local simulator""") # Running this block before registering quietly returns a list of local-only simulators # print("The backends available for use are:") backends = available_backends() pprint(backends) print("\n") if 'CK_IBM_BACKEND' in os.environ: backend = os.environ['CK_IBM_BACKEND'] if backend not in backends: print( "Your choice '%s' was not available, so picking a random one for you..." % backend) backend = backends[0] print("Picked '%s' backend!" % backend) try: # Create a QuantumProgram object instance. Q_program = QuantumProgram()
q = QuantumRegister(2) # Create a Classical Register with 2 bits. c = ClassicalRegister(2) # Create a Quantum Circuit qc = QuantumCircuit(q, c) # Add a H gate on qubit 0, putting this qubit in superposition. qc.h(q[0]) # Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting # the qubits in a Bell state. qc.cx(q[0], q[1]) # Add a Measure gate to see the state. qc.measure(q, c) # See a list of available local simulators print("Local backends: ", available_backends({'local': True})) # Compile and run the Quantum circuit on a simulator backend job_sim = execute(qc, "local_qasm_simulator") sim_result = job_sim.result() # Show the results print("simulation: ", sim_result) print(sim_result.get_counts(qc)) # see a list of available remote backends remote_backends = available_backends({'local': False, 'simulator': False}) print("Remote backends: ", remote_backends) # Compile and run the Quantum Program on a real device backend try:
clbit_reg = ClassicalRegister(2, name='c') # Making first circuit: bell state qc1 = QuantumCircuit(qubit_reg, clbit_reg, name="bell") qc1.h(qubit_reg[0]) qc1.cx(qubit_reg[0], qubit_reg[1]) qc1.measure(qubit_reg, clbit_reg) # Making another circuit: superpositions qc2 = QuantumCircuit(qubit_reg, clbit_reg, name="superposition") qc2.h(qubit_reg) qc2.measure(qubit_reg, clbit_reg) # Setting up the backend print("(Local Backends)") for backend_name in available_backends({'local': True}): backend = get_backend(backend_name) print(backend.status) my_backend_name = 'local_qasm_simulator' my_backend = get_backend(my_backend_name) print("(Local QASM Simulator configuration) ") pprint.pprint(my_backend.configuration) print("(Local QASM Simulator calibration) ") pprint.pprint(my_backend.calibration) print("(Local QASM Simulator parameters) ") pprint.pprint(my_backend.parameters) # Compiling the job qobj = compile([qc1, qc2], my_backend) # Note: in the near future qobj will become an object
def main(): print(json.dumps(available_backends( {'local': True}), indent=2, sort_keys=True))
clbit_reg = ClassicalRegister(2) # making first circuit: bell state qc1 = QuantumCircuit(qubit_reg, clbit_reg) qc1.h(qubit_reg[0]) qc1.cx(qubit_reg[0], qubit_reg[1]) qc1.measure(qubit_reg, clbit_reg) # making another circuit: superpositions qc2 = QuantumCircuit(qubit_reg, clbit_reg) qc2.h(qubit_reg) qc2.measure(qubit_reg, clbit_reg) # setting up the backend print("(Local Backends)") print(available_backends({'local': True})) # runing the job job_sim = execute([qc1, qc2], "local_qasm_simulator") sim_result = job_sim.result() # Show the results print("simulation: ", sim_result) print(sim_result.get_counts(qc1)) print(sim_result.get_counts(qc2)) # see a list of available remote backends print("\n(Remote Backends)") print(available_backends({'local': False})) # Compile and run on a real device backend
clbit_reg = ClassicalRegister(2) # making first circuit: bell state qc1 = QuantumCircuit(qubit_reg, clbit_reg) qc1.h(qubit_reg[0]) qc1.cx(qubit_reg[0], qubit_reg[1]) qc1.measure(qubit_reg, clbit_reg) # making another circuit: superpositions qc2 = QuantumCircuit(qubit_reg, clbit_reg) qc2.h(qubit_reg) qc2.measure(qubit_reg, clbit_reg) # setting up the backend print("(Local Backends)") print(available_backends({'local': True})) # runing the job job_sim = execute([qc1, qc2], "local_qasm_simulator") sim_result = job_sim.result() # Show the results print("simulation: ", sim_result) print(sim_result.get_counts(qc1)) print(sim_result.get_counts(qc2)) # see a list of available remote backends print("\n(Remote Backends)") print(available_backends({'local': False})) # Compile and run on a real device backend
q = QuantumRegister(2) # Create a Classical Register with 2 bits. c = ClassicalRegister(2) # Create a Quantum Circuit qc = QuantumCircuit(q, c) # Add a H gate on qubit 0, putting this qubit in superposition. qc.h(q[0]) # Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting # the qubits in a Bell state. qc.cx(q[0], q[1]) # Add a Measure gate to see the state. qc.measure(q, c) # See a list of available local simulators print("Local backends: ", available_backends({'local': True})) # Compile and run the Quantum circuit on a simulator backend job_sim = execute(qc, "local_qasm_simulator") sim_result = job_sim.result() # Show the results print("simulation: ", sim_result) print(sim_result.get_counts(qc)) # see a list of available remote backends remote_backends = available_backends({'local': False, 'simulator': False}) print("Remote backends: ", remote_backends) # Compile and run the Quantum Program on a real device backend try:
from qiskit import available_backends, execute # Initiate quantum registers for gate execution, and classical registers for measurements q = QuantumRegister(2) c = ClassicalRegister(2) qc = QuantumCircuit(q, c) print(q) # Preform a Hadamard on the qubit in the quantum register to create a superposition qc.h(q[0]) # Preform a controlled-not operation between the first and second qubits in the register qc.cx(q[0], q[1]) # Preform an X-pauli on the second qubit in the register qc.x(q[1]) # Measure the superposition qc.measure(q, c) # Check simulation backends print("Local backends: ", available_backends({'local': True})) # Submit the job to the Q QASM Simulator (Up to 32 Qubits) job_sim = execute(qc, "local_qasm_simulator") # Fetch result sim_result = job_sim.result() #Print out the simulation measuement basis and corresponding counts print("simulation: ", sim_result) print(sim_result.get_counts(qc)) print(qc.qasm())
""" Example on how to use: load_qasm_file If you want to use your local cloned repository intead of the one installed via pypi, you have to run like this: examples/python$ PYTHONPATH=$PYTHONPATH:../.. python load_qasm.py """ from qiskit.wrapper import load_qasm_file from qiskit import QISKitError, available_backends, execute try: qc = load_qasm_file("../qasm/entangled_registers.qasm") # See a list of available local simulators print("Local backends: ", available_backends({'local': True})) # Compile and run the Quantum circuit on a local simulator backend job_sim = execute(qc, "local_qasm_simulator") sim_result = job_sim.result() # Show the results print("simulation: ", sim_result) print(sim_result.get_counts(qc)) except QISKitError as ex: print('There was an internal QISKit error. Error = {}'.format(ex))
# qx_config = { # "APItoken": APItoken, # "url": "https://quantumexperience.ng.bluemix.net/api"} # print('Qconfig.py not found in qiskit-tutorial directory; Qconfig loaded using user input.') APItoken = getpass.getpass('Please input your token and hit enter: ') qx_config = { "APItoken": APItoken, "url": "https://quantumexperience.ng.bluemix.net/api" } try: register(qx_config['APItoken'], qx_config['url']) print('\nYou have access to great power!') print(available_backends({'local': False, 'simulator': False})) except: print('Something went wrong.\nDid you enter a correct token?') # backend = least_busy(available_backends({'simulator': False, 'local': False})) # print("The least busy backend is " + backend) ''' using load_random from Iris.py to obtain some training and test examples for example: sample_train array([[-0.99407732, -0.10867513, 0. ], [-0.30654501, 0.95185616, 0. ], [-0.92072409, -0.39021423, 1. ], [ 0.88418237, -0.46714188, 1. ]])
import os import qiskit if "QX_API_TOKEN" not in os.environ: print("Set environment variable QX_API_TOKEN") exit(1) QX_API_TOKEN = os.environ["QX_API_TOKEN"] qiskit.register(QX_API_TOKEN, "https://quantumexperience.ng.bluemix.net/api") print("Registered") print("Available backends:") print(qiskit.available_backends())