def test_mix_local_remote_jobs(self, QE_TOKEN, QE_URL):
"""test mixing local and remote jobs
Internally local jobs execute in seperate processes since
they are CPU bound and remote jobs execute in seperate threads
since they are I/O bound. The module gets results from potentially
both kinds in one list. Test that this works.
"""
provider = IBMQProvider(QE_TOKEN, QE_URL)
remote_backend = provider.available_backends({'simulator': True})[0]
local_backend = get_backend('local_qasm_simulator')
njobs = 6
job_list = []
backend_type = [local_backend, remote_backend]
i = 0
for circuit in self.rqg.get_circuits(format_='QuantumCircuit')[:njobs]:
compiled_circuit = compile_circuit(circuit)
backend = backend_type[i % len(backend_type)]
self.log.info(backend)
quantum_job = QuantumJob(compiled_circuit, backend=backend)
job_list.append(quantum_job)
i += 1
jp = jobprocessor.JobProcessor(job_list,
max_workers=None,
callback=None)
jp.submit()
def test_compile_two_remote(self,
QE_TOKEN,
QE_URL,
hub=None,
group=None,
project=None):
"""Test Compiler remote on two circuits.
If all correct some should exists.
"""
provider = IBMQProvider(QE_TOKEN, QE_URL, hub, group, project)
backend = lowest_pending_jobs(
provider.available_backends({
'local': False,
'simulator': False
}))
qubit_reg = qiskit.QuantumRegister(2, name='q')
clbit_reg = qiskit.ClassicalRegister(2, name='c')
qc = qiskit.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)
qc_extra = qiskit.QuantumCircuit(qubit_reg, clbit_reg, name="extra")
qc_extra.measure(qubit_reg, clbit_reg)
qobj = transpiler.compile([qc, qc_extra], backend)
# FIXME should test against the qobj when defined
self.assertEqual(len(qobj), 3)
def test_run_device(self, qe_token, qe_url):
provider = IBMQProvider(qe_token, qe_url)
backends = [
backend for backend in provider.available_backends()
if not backend.configuration['simulator']
]
self.log.info('devices: %s', [b.name for b in backends])
backend = _least_busy(backends)
self.log.info('using backend: %s', backend.name)
qobj = transpiler.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(result.get_names()[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 test_compile_two_run_remote(self,
QE_TOKEN,
QE_URL,
hub=None,
group=None,
project=None):
"""Test Compiler and run two circuits.
If all correct some should exists.
"""
provider = IBMQProvider(QE_TOKEN, QE_URL, hub, group, project)
backend = provider.available_backends({'simulator': True})[0]
qubit_reg = qiskit.QuantumRegister(2, name='q')
clbit_reg = qiskit.ClassicalRegister(2, name='c')
qc = qiskit.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)
qc_extra = qiskit.QuantumCircuit(qubit_reg, clbit_reg, name="extra")
qc_extra.measure(qubit_reg, clbit_reg)
qobj = qiskit._compiler.compile([qc, qc_extra], backend)
job = backend.run(
qiskit.QuantumJob(qobj, backend=backend, preformatted=True))
result = job.result()
self.assertIsInstance(result, Result)
def test_retrieve_job_error(self, qe_token, qe_url):
provider = IBMQProvider(qe_token, qe_url)
backends = [
backend for backend in provider.available_backends()
if not backend.configuration['simulator']
]
backend = _least_busy(backends)
self.assertRaises(IBMQBackendError, backend.retrieve_job, 'BAD_JOB_ID')
def test_run_remote_simulator(self, QE_TOKEN, QE_URL):
provider = IBMQProvider(QE_TOKEN, QE_URL)
backend = provider.available_backends({'simulator': True})[0]
compiled_circuit = compile_circuit(self.qc)
quantum_job = QuantumJob(compiled_circuit,
do_compile=False,
backend=backend)
jobprocessor.run_backend(quantum_job)
def test_remote_backends_exist_real_device(self, QE_TOKEN, QE_URL):
"""Test if there are remote backends that are devices.
If all correct some should exists.
"""
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL)
remote = ibmq_provider.available_backends({'local': False, 'simulator': False})
self.log.info(remote)
self.assertTrue(remote)
def test_get_jobs_filter_job_status(self, qe_token, qe_url):
provider = IBMQProvider(qe_token, qe_url)
backends = provider.available_backends()
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()._result['status'])
self.assertTrue(job.status() is JobStatus.DONE)
def test_remote_backends_exist(self, QE_TOKEN, QE_URL):
"""Test if there are remote backends.
If all correct some should exists.
"""
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL)
remote = ibmq_provider.available_backends({'local': False})
self.log.info(remote)
self.assertTrue(len(remote) > 0)
def test_remote_backends_exist_simulator(self, QE_TOKEN, QE_URL,
hub=None, group=None, project=None):
"""Test if there are remote backends that are simulators.
If all correct some should exists.
"""
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL, hub, group, project)
remote = ibmq_provider.available_backends({'local': False, 'simulator': True})
self.log.info(remote)
self.assertTrue(remote)
def test_remote_backends_exist_simulator(self, QE_TOKEN, QE_URL,
hub=None, group=None, project=None):
"""Test if there are remote backends that are simulators.
If all correct some should exists.
"""
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL, hub, group, project)
remote = ibmq_provider.available_backends({'local': False, 'simulator': True})
self.log.info(remote)
self.assertTrue(remote)
def test_remote_backends_exist_real_device(self, qe_token, qe_url):
"""Test if there are remote backends that are devices.
If all correct some should exists.
"""
ibmq_provider = IBMQProvider(qe_token, qe_url)
remote = ibmq_provider.available_backends()
remote = [r for r in remote if not r.configuration()['simulator']]
self.log.info(remote)
self.assertTrue(remote)
def test_get_jobs_filter_date(self, qe_token, qe_url):
provider = IBMQProvider(qe_token, qe_url)
backends = provider.available_backends()
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_remote_backends_exist(self, QE_TOKEN, QE_URL):
"""Test if there are remote backends.
If all correct some should exists.
"""
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL)
remotes = ibmq_provider.available_backends()
remotes = remove_backends_from_list(remotes)
self.log.info(remotes)
self.assertTrue(len(remotes) > 0)
def test_remote_backends_exist_simulator(self, QE_TOKEN, QE_URL):
"""Test if there are remote backends that are simulators.
If all correct some should exists.
"""
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL)
remote = ibmq_provider.available_backends()
remote = [r for r in remote if r.configuration['simulator']]
self.log.info(remote)
self.assertTrue(remote)
def test_remote_backends_exist(self, QE_TOKEN, QE_URL,
hub=None, group=None, project=None):
"""Test if there are remote backends.
If all correct some should exists.
"""
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL, hub, group, project)
remotes = ibmq_provider.available_backends({'local': False})
remotes = remove_backends_from_list(remotes)
self.log.info(remotes)
self.assertTrue(len(remotes) > 0)
def test_remote_backends_exist(self, QE_TOKEN, QE_URL,
hub=None, group=None, project=None):
"""Test if there are remote backends.
If all correct some should exists.
"""
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL, hub, group, project)
remotes = ibmq_provider.available_backends({'local': False})
remotes = remove_backends_from_list(remotes)
self.log.info(remotes)
self.assertTrue(len(remotes) > 0)
def test_remote_backends_exist_real_device(self, QE_TOKEN, QE_URL,
hub=None, group=None, project=None):
"""Test if there are remote backends that are devices.
If all correct some should exists.
"""
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL, hub, group, project)
remote = ibmq_provider.available_backends()
remote = [r for r in remote if not r.configuration['simulator']]
self.log.info(remote)
self.assertTrue(remote)
def test_run_job_processor_online(self, QE_TOKEN, QE_URL):
provider = IBMQProvider(QE_TOKEN, QE_URL)
backend = provider.available_backends({'simulator': True})[0]
njobs = 1
job_list = []
for _ in range(njobs):
compiled_circuit = compile_circuit(self.qc)
quantum_job = QuantumJob(compiled_circuit, backend=backend)
job_list.append(quantum_job)
jp = jobprocessor.JobProcessor(job_list, callback=None)
jp.submit()
def test_run_async_device(self, qe_token, qe_url):
provider = IBMQProvider(qe_token, qe_url)
backends = [
backend for backend in provider.available_backends()
if not backend.configuration['simulator']
]
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.id() for job in job_array]
self.assertEqual(sorted(job_ids), sorted(list(set(job_ids))))
def test_get_jobs_from_backend(self, qe_token, qe_url):
provider = IBMQProvider(qe_token, qe_url)
backend = _least_busy(provider.available_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.id(), str))
self.log.info('time to get job statuses: %0.3f s',
time.time() - start_time)
def test_remote_backend_status(self, QE_TOKEN, QE_URL):
"""Test backend_status.
If all correct should pass the validation.
"""
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL)
remotes = ibmq_provider.available_backends({'local': False})
for backend in remotes:
status = backend.status
schema_path = self._get_resource_path(
'backends/backend_status_schema_py.json', path=Path.SCHEMAS)
with open(schema_path, 'r') as schema_file:
schema = json.load(schema_file)
jsonschema.validate(status, schema)
def test_remote_backend_configuration(self, QE_TOKEN, QE_URL):
"""Test backend configuration.
If all correct should pass the validation.
"""
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL)
remotes = ibmq_provider.available_backends()
remotes = remove_backends_from_list(remotes)
for backend in remotes:
configuration = backend.configuration
schema_path = self._get_resource_path(
'deprecated/backends/backend_configuration_schema_old_py.json', path=Path.SCHEMAS)
with open(schema_path, 'r') as schema_file:
schema = json.load(schema_file)
jsonschema.validate(configuration, schema)
def test_remote_backend_parameters(self, QE_TOKEN, QE_URL):
"""Test backend parameters.
If all correct should pass the validation.
"""
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL)
remotes = ibmq_provider.available_backends({'local': False})
for backend in remotes:
parameters = backend.parameters
# FIXME test against schema and decide what parameters
# is for a simulator
if backend.configuration['simulator']:
self.assertEqual(len(parameters), 0)
else:
self.assertEqual(len(parameters), 4)
def test_remote_backend_calibration(self, QE_TOKEN, QE_URL):
"""Test backend calibration.
If all correct should pass the validation.
"""
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL)
remotes = ibmq_provider.available_backends()
remotes = remove_backends_from_list(remotes)
for backend in remotes:
calibration = backend.calibration
# FIXME test against schema and decide what calibration
# is for a simulator
if backend.configuration['simulator']:
self.assertEqual(len(calibration), 0)
else:
self.assertEqual(len(calibration), 4)
def test_remote_backend_configuration(self, QE_TOKEN, QE_URL,
hub=None, group=None, project=None):
"""Test backend configuration.
If all correct should pass the validation.
"""
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL, hub, group, project)
remotes = ibmq_provider.available_backends({'local': False})
remotes = remove_backends_from_list(remotes)
for backend in remotes:
configuration = backend.configuration
schema_path = self._get_resource_path(
'deprecated/backends/backend_configuration_schema_old_py.json', path=Path.SCHEMAS)
with open(schema_path, 'r') as schema_file:
schema = json.load(schema_file)
jsonschema.validate(configuration, schema)
def test_remote_backend_calibration(self, QE_TOKEN, QE_URL,
hub=None, group=None, project=None):
"""Test backend calibration.
If all correct should pass the validation.
"""
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL, hub, group, project)
remotes = ibmq_provider.available_backends({'local': False})
remotes = remove_backends_from_list(remotes)
for backend in remotes:
calibration = backend.calibration
# FIXME test against schema and decide what calibration
# is for a simulator
if backend.configuration['simulator']:
self.assertEqual(len(calibration), 0)
else:
self.assertEqual(len(calibration), 4)
def test_remote_backend_status(self, QE_TOKEN, QE_URL,
hub=None, group=None, project=None):
"""Test backend_status.
If all correct should pass the validation.
"""
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL, hub, group, project)
remotes = ibmq_provider.available_backends({'local': False})
remotes = remove_backends_from_list(remotes)
for backend in remotes:
self.log.info(backend.status)
status = backend.status
schema_path = self._get_resource_path(
'deprecated/backends/backend_status_schema_py.json', path=Path.SCHEMAS)
with open(schema_path, 'r') as schema_file:
schema = json.load(schema_file)
jsonschema.validate(status, schema)
def test_execute_remote(self, QE_TOKEN, QE_URL):
"""Test Execute remote.
If all correct some should exists.
"""
provider = IBMQProvider(QE_TOKEN, QE_URL)
backend = provider.available_backends({'simulator': True})[0]
qubit_reg = qiskit.QuantumRegister(2)
clbit_reg = qiskit.ClassicalRegister(2)
qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg)
qc.h(qubit_reg[0])
qc.cx(qubit_reg[0], qubit_reg[1])
qc.measure(qubit_reg, clbit_reg)
job = execute(qc, backend)
results = job.result()
self.assertIsInstance(results, Result)
def test_compile_run_remote(self, QE_TOKEN, QE_URL):
"""Test Compiler and run remote.
If all correct some should exists.
"""
provider = IBMQProvider(QE_TOKEN, QE_URL)
backend = provider.available_backends({'simulator': True})[0]
qubit_reg = qiskit.QuantumRegister(2, name='q')
clbit_reg = qiskit.ClassicalRegister(2, name='c')
qc = qiskit.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 = qiskit._compiler.compile(qc, backend)
result = backend.run(
qiskit.QuantumJob(qobj, backend=backend,
preformatted=True)).result()
self.assertIsInstance(result, Result)
def test_remote_backend_parameters(self, qe_token, qe_url):
"""Test backend parameters.
If all correct should pass the validation.
"""
ibmq_provider = IBMQProvider(qe_token, qe_url)
remotes = ibmq_provider.available_backends()
remotes = remove_backends_from_list(remotes)
for backend in remotes:
self.log.info(backend.name())
parameters = backend.parameters()
# FIXME test against schema and decide what parameters
# is for a simulator
if backend.configuration()['simulator']:
self.assertEqual(len(parameters), 0)
else:
self.assertTrue(
all(key in parameters
for key in ('last_update_date', 'qubits', 'backend')))
def test_remote_backend_status(self, QE_TOKEN, QE_URL):
"""Test backend_status.
If all correct should pass the validation.
"""
# FIXME: reintroduce in 0.6
self.skipTest('Skipping due to available vs operational')
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL)
remotes = ibmq_provider.available_backends()
remotes = remove_backends_from_list(remotes)
for backend in remotes:
self.log.info(backend.status)
status = backend.status
schema_path = self._get_resource_path(
'deprecated/backends/backend_status_schema_py.json', path=Path.SCHEMAS)
with open(schema_path, 'r') as schema_file:
schema = json.load(schema_file)
jsonschema.validate(status, schema)
def test_compile_remote(self, QE_TOKEN, QE_URL):
"""Test Compiler remote.
If all correct some should exists.
"""
provider = IBMQProvider(QE_TOKEN, QE_URL)
my_backend = lowest_pending_jobs(
provider.available_backends({'local': False, 'simulator': False}))
qubit_reg = qiskit.QuantumRegister(2, name='q')
clbit_reg = qiskit.ClassicalRegister(2, name='c')
qc = qiskit.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 = qiskit._compiler.compile(qc, my_backend)
# FIXME should test against the qobj when defined
self.assertEqual(len(qobj), 3)
def test_remote_backend_parameters(self, QE_TOKEN, QE_URL,
hub=None, group=None, project=None):
"""Test backend parameters.
If all correct should pass the validation.
"""
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL, hub, group, project)
remotes = ibmq_provider.available_backends({'local': False})
remotes = remove_backends_from_list(remotes)
for backend in remotes:
self.log.info(backend.name)
parameters = backend.parameters
# FIXME test against schema and decide what parameters
# is for a simulator
if backend.configuration['simulator']:
self.assertEqual(len(parameters), 0)
else:
self.assertTrue(all(key in parameters for key in (
'last_update_date',
'qubits',
'backend')))
def test_remote_backend_parameters(self, QE_TOKEN, QE_URL,
hub=None, group=None, project=None):
"""Test backend parameters.
If all correct should pass the validation.
"""
ibmq_provider = IBMQProvider(QE_TOKEN, QE_URL, hub, group, project)
remotes = ibmq_provider.available_backends({'local': False})
remotes = remove_backends_from_list(remotes)
for backend in remotes:
self.log.info(backend.name)
parameters = backend.parameters
# FIXME test against schema and decide what parameters
# is for a simulator
if backend.configuration['simulator']:
self.assertEqual(len(parameters), 0)
else:
self.assertTrue(all(key in parameters for key in (
'last_update_date',
'qubits',
'backend')))
