def least_busy(names):
"""
Return the least busy available backend for those that
have a `pending_jobs` in their `status`. Backends such as
local backends that do not have this are not considered.
Args:
names (list[str]): backend names to choose from
(e.g. output of ``available_backends()``)
Returns:
str: the name of the least busy backend
Raises:
QISKitError: if passing a list of backend names that is
either empty or none have attribute ``pending_jobs``
.. deprecated:: 0.6+
After 0.6, this function is deprecated. Please use the methods in
`qiskit.IBMQ` instead
(`backends()`).
"""
backends = [get_backend(name) for name in names]
warnings.warn(
'the global least_busy() will be deprecated after 0.6. Please '
'use least_busy() imported from qiskit.backends.ibmq',
DeprecationWarning)
return ibmq.least_busy(backends).name()
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 get_backend(local=False):
if local:
return Aer.get_backend('qasm_simulator_py')
IBMQ.load_accounts()
available_backends = IBMQ.backends(operational=True, simulator=False)
backend = least_busy(available_backends)
return backend
def test_run_device(self, qe_token, qe_url):
IBMQ.enable_account(qe_token, qe_url)
backends = IBMQ.backends(simulator=False)
self.log.info('devices: %s', [b.name() for b in backends])
backend = least_busy(backends)
self.log.info('using backend: %s', backend.name())
qobj = compile(self._qc, backend)
shots = qobj.config.shots
job = backend.run(qobj)
while not job.status() is JobStatus.DONE:
self.log.info(job.status())
time.sleep(4)
self.log.info(job.status)
result = job.result()
counts_qx = result.get_counts(0)
counts_ex = {'00': shots / 2, '11': shots / 2}
states = counts_qx.keys() | counts_ex.keys()
# contingency table
ctable = numpy.array([[counts_qx.get(key, 0) for key in states],
[counts_ex.get(key, 0) for key in states]])
self.log.info('states: %s', str(states))
self.log.info('ctable: %s', str(ctable))
contingency = chi2_contingency(ctable)
self.log.info('chi2_contingency: %s', str(contingency))
self.assertDictAlmostEqual(counts_qx, counts_ex, shots * 0.1)
def online_real(qc):
from qiskit import IBMQ
from qiskit.backends.ibmq import least_busy
IBMQ.load_accounts()
large_enough_devices = IBMQ.backends(filters=lambda x: x.configuration()[
'n_qubits'] > 2 and not x.configuration()['simulator'])
backend = least_busy(large_enough_devices)
return backend
def test_get_jobs_filter_job_status(self, qe_token, qe_url):
IBMQ.enable_account(qe_token, qe_url)
backends = IBMQ.backends(simulator=False)
backend = least_busy(backends)
job_list = backend.jobs(limit=5, skip=0, status=JobStatus.DONE)
self.log.info('found %s matching jobs', len(job_list))
for i, job in enumerate(job_list):
self.log.info('match #%d: %s', i, job.result().status)
self.assertTrue(job.status() is JobStatus.DONE)
def _get_backends(self, qe_token, qe_url):
sim_backend = qiskit.Aer.get_backend('qasm_simulator_py')
try:
qiskit.IBMQ.enable_account(qe_token, qe_url)
real_backends = qiskit.IBMQ.backends(simulator=False)
real_backend = least_busy(real_backends)
except Exception:
real_backend = None
return sim_backend, real_backend
def test_get_jobs_filter_date(self, qe_token, qe_url):
IBMQ.enable_account(qe_token, qe_url)
backends = IBMQ.backends(simulator=False)
backend = least_busy(backends)
my_filter = {'creationDate': {'lt': '2017-01-01T00:00:00.00'}}
job_list = backend.jobs(limit=5, 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: %s', i, job.creation_date)
self.assertTrue(job.creation_date < '2017-01-01T00:00:00.00')
def test_get_jobs_from_backend(self, qe_token, qe_url):
IBMQ.enable_account(qe_token, qe_url)
backend = least_busy(IBMQ.backends())
start_time = time.time()
job_list = backend.jobs(limit=5, skip=0)
self.log.info('time to get jobs: %0.3f s', time.time() - start_time)
self.log.info('found %s jobs on backend %s', len(job_list), backend.name())
for job in job_list:
self.log.info('status: %s', job.status())
self.assertTrue(isinstance(job.job_id(), str))
self.log.info('time to get job statuses: %0.3f s', time.time() - start_time)
def test_run_async_device(self, qe_token, qe_url):
IBMQ.enable_account(qe_token, qe_url)
backends = IBMQ.backends(simulator=False)
backend = least_busy(backends)
self.log.info('submitting to backend %s', backend.name())
num_qubits = 5
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, backend)
num_jobs = 3
job_array = [backend.run(qobj) for _ in range(num_jobs)]
time.sleep(3) # give time for jobs to start (better way?)
job_status = [job.status() for job in job_array]
num_init = sum(
[status is JobStatus.INITIALIZING for status in job_status])
num_queued = sum([status is JobStatus.QUEUED for status in job_status])
num_running = sum(
[status is JobStatus.RUNNING for status in job_status])
num_done = sum([status is JobStatus.DONE for status in job_status])
num_error = sum([status is JobStatus.ERROR for status in job_status])
self.log.info('number of currently initializing jobs: %d/%d', num_init,
num_jobs)
self.log.info('number of currently queued jobs: %d/%d', num_queued,
num_jobs)
self.log.info('number of currently running jobs: %d/%d', num_running,
num_jobs)
self.log.info('number of currently done jobs: %d/%d', num_done,
num_jobs)
self.log.info('number of errored jobs: %d/%d', num_error, num_jobs)
self.assertTrue(num_jobs - num_error - num_done > 0)
# Wait for all the results.
result_array = [job.result() for job in job_array]
# 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 GetIBMQDevice(useSimulator):
if not ibmq_login.login():
return
print("Getting the list of IBMQ backends (simulator=",
useSimulator,
")...",
sep="")
backends = IBMQ.backends(simulator=useSimulator)
print("IBMQ backends:", backends)
print("Obtaining the least busy device...")
least_busy_device = least_busy(backends)
print("Least busy device:", least_busy_device)
return least_busy_device
def test_compile_remote(self, qe_token, qe_url):
"""Test Compiler remote.
If all correct some should exists.
"""
qiskit.IBMQ.enable_account(qe_token, qe_url)
backend = least_busy(qiskit.IBMQ.backends())
qubit_reg = QuantumRegister(2, name='q')
clbit_reg = ClassicalRegister(2, name='c')
qc = QuantumCircuit(qubit_reg, clbit_reg, name="bell")
qc.h(qubit_reg[0])
qc.cx(qubit_reg[0], qubit_reg[1])
qc.measure(qubit_reg, clbit_reg)
dags = transpiler.transpile(qc, backend)
self.assertIsInstance(dags[0], DAGCircuit)
def least_busy(names):
"""
Return the least busy available backend for those that
have a `pending_jobs` in their `status`. Backends such as
local backends that do not have this are not considered.
Args:
names (list[str]): backend names to choose from
(e.g. output of ``available_backends()``)
Returns:
str: the name of the least busy backend
Raises:
QISKitError: if passing a list of backend names that is
either empty or none have attribute ``pending_jobs``
"""
backends = [get_backend(name) for name in names]
return ibmq.least_busy(backends).name()
def test_compile_remote(self, qe_token, qe_url):
"""Test Compiler remote.
If all correct some should exists.
"""
qiskit.IBMQ.use_account(qe_token, qe_url)
backend = least_busy(qiskit.IBMQ.backends())
qubit_reg = QuantumRegister(2, name='q')
clbit_reg = ClassicalRegister(2, name='c')
qc = QuantumCircuit(qubit_reg, clbit_reg, name="bell")
qc.h(qubit_reg[0])
qc.cx(qubit_reg[0], qubit_reg[1])
qc.measure(qubit_reg, clbit_reg)
qobj = transpiler.compile(qc, backend)
# FIXME should validate the Qobj when defined
self.assertIsInstance(qobj, Qobj)
# Compile and run the Quantum circuit on a simulator backend
job_sim = execute(qc, backend_sim)
result_sim = job_sim.result()
# Show the results
print("simulation: ", result_sim)
print(result_sim.get_counts(qc))
# see a list of available remote backends
ibmq_backends = IBMQ.backends()
print("Remote backends: ", ibmq_backends)
# Compile and run the Quantum Program on a real device backend
try:
least_busy_device = least_busy(IBMQ.backends(simulator=False))
print("Running on current least busy device: ", least_busy_device)
#running the job
job_exp = execute(qc, least_busy_device, shots=1024, max_credits=10)
result_exp = job_exp.result()
# Show the results
print("experiment: ", result_exp)
print(result_exp.get_counts(qc))
except:
print("All devices are currently unavailable.")
except QiskitError as ex:
print('There was an error in the circuit!. Error = {}'.format(ex))
cr = ClassicalRegister(12)
qc = QuantumCircuit(qr, cr)
qc.h(qr)
qc.measure(qr, cr)
# circuit_drawer(qc, filename="imgs/test_14_qubis.png")
if (len(sys.argv) > 1 and sys.argv[1] == 'c'): # c stands for cloud
IBMQ.load_accounts()
print("Account loaded")
if (sys.argv[2] == 'r'): # r stands for real
large_enough_devices = IBMQ.backends(
filters=
lambda x: x.configuration()['n_qubits'] >= 14 and not x.configuration()['simulator']
)
backend = least_busy(large_enough_devices)
shots = 1024
mx = 3
elif (sys.argv[2] == 's'): # shoud be a s for simulator
large_enough_devices = IBMQ.backends(
filters=
lambda x: x.configuration()['n_qubits'] >= 14 and x.configuration()['simulator']
)
backend = least_busy(large_enough_devices)
shots = 8192
mx = 10
else:
exit("s/r")
else:
print("Local simulator started")
print(Aer.backends())
state = key
print("The Quantum 8-ball says:")
if state == '000':
print('It is certain.')
elif state == '001':
print('Without a doubt.')
elif state == '010':
print('Yes - deinitely.')
elif state == '011':
print('Most likely.')
elif state == '100':
print("Don't count on it.")
elif state == '101':
print('My reply is no.')
elif state == '110':
print('Very doubtful.')
else:
print('Concentrate and ask again.')
# Execute the job on the simulator.
job = execute(qc, backend=Aer.get_backend('qasm_simulator'), shots=1)
result = job.result().get_counts(qc)
answer(result)
# Execute the program on a real quantum computer.
backend = least_busy(IBMQ.backends(simulator=False))
print("Running on", backend.name())
job = execute(qc, backend, shots=1)
result = job.result().get_counts(qc)
answer(result)
###############################################################
# Set up the API and execute the program.
###############################################################
try:
IBMQ.load_accounts()
except:
print("""WARNING: There's no connection with the API for remote backends.
Have you initialized a file with your personal token?
For now, there's only access to local simulator backends...""")
print('Qasm simulator')
sim_backend = Aer.get_backend('qasm_simulator')
job = execute([qft3, qft4, qft5], sim_backend, shots=1024)
result = job.result()
print(result)
print(result.get_counts(qft3))
print(result.get_counts(qft4))
print(result.get_counts(qft5))
# Second version: real device
least_busy_device = least_busy(
IBMQ.backends(simulator=False,
filters=lambda x: x.configuration()['n_qubits'] > 4))
print("Running on current least busy device: ", least_busy_device)
job = execute([qft3, qft4, qft5], least_busy_device, shots=1024)
result = job.result()
print(result)
print(result.get_counts(qft3))
print(result.get_counts(qft4))
print(result.get_counts(qft5))
def test_filter_least_busy(self, qe_token, qe_url):
"""Test filtering by least busy function"""
IBMQ.enable_account(qe_token, qe_url)
backends = IBMQ.backends()
filtered_backends = least_busy(backends)
self.assertTrue(filtered_backends)
def test_retrieve_job_error(self, qe_token, qe_url):
IBMQ.enable_account(qe_token, qe_url)
backends = IBMQ.backends(simulator=False)
backend = least_busy(backends)
self.assertRaises(IBMQBackendError, backend.retrieve_job, 'BAD_JOB_ID')
import Qconfig
# print(Qconfig.APItoken, Qconfig.config['url'])
import getpass
import time
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit
from qiskit import available_backends, execute, register
from qiskit.backends.ibmq import least_busy
# import basic plot tools
from qiskit.tools.visualization import plot_histogram, circuit_drawer
# APItoken = getpass.getpass('Please input your token and hit enter: ')
# qx_config = {
# "APItoken": APItoken,
# "url": "https://quantumexperience.ng.bluemix.net/api"}
try:
# qx_config['APItoken'], qx_config['url']
register(Qconfig.APItoken, Qconfig.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)
cr = ClassicalRegister(1)
circuit = QuantumCircuit(qr, cr)
circuit.h(qr[0])
circuit.h(qr[0])
circuit.measure(qr, cr)
circuit_drawer(circuit, filename="imgs/" + id_string + ".png")
shots = 4096
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(circuit, shots=shots, backend=backend_sim)
result_sim = job_sim.result()
# Show the results
print("simulation: ", result_sim)
print(result_sim.get_counts(circuit))
IBMQ.load_accounts()
large_enough_devices = IBMQ.backends(
filters=
lambda x: x.configuration()['n_qubits'] > 1 and not x.configuration()['simulator']
)
backend_real = least_busy(large_enough_devices)
print("The best backend is " + backend_real.name())
max_credits = 3
job_real = execute(
circuit, backend=backend_real, shots=shots, max_credits=max_credits)
result_real = (job_real.result())
print("real: ", result_real)
print(result_real.get_counts(circuit))
