def test_run_simulator(self, qe_token, qe_url):
"""Test running in a simulator."""
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_online_qasm_simulator_two_registers(self, qe_token, qe_url):
"""Test online_qasm_simulator_two_registers."""
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, name="circuit1")
qcr2 = QuantumCircuit(qr1, qr2, cr1, cr2, name="circuit2")
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 = compile([qcr1, qcr2],
backend,
seed=8458,
shots=shots,
seed_mapper=88434)
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_disable_accounts(self):
"""Test disabling an account in a session."""
with custom_qiskitrc(), mock_ibmq_provider():
IBMQ.enable_account('QISKITRC_TOKEN')
IBMQ.disable_accounts(token='QISKITRC_TOKEN')
self.assertEqual(len(IBMQ._accounts), 0)
def test_run_device(self, qe_token, qe_url):
"""Test running in a real device."""
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 test_retrieve_job_uses_appropriate_backend(self, qe_token, qe_url):
"""Test that retrieved jobs come from their appropriate backend."""
IBMQ.enable_account(qe_token, qe_url)
simulator_backend = IBMQ.get_backend('ibmq_qasm_simulator')
backends = IBMQ.backends(simulator=False)
real_backend = least_busy(backends)
qobj_sim = compile(self._qc, simulator_backend)
job_sim = simulator_backend.run(qobj_sim)
qobj_real = compile(self._qc, real_backend)
job_real = real_backend.run(qobj_real)
# test a retrieved job's backend is the same as the queried backend
self.assertEqual(simulator_backend.retrieve_job(job_sim.job_id()).backend().name(),
simulator_backend.name())
self.assertEqual(real_backend.retrieve_job(job_real.job_id()).backend().name(),
real_backend.name())
# test retrieve requests for jobs that exist on other backends throw errors
with self.assertWarns(Warning) as context_manager:
self.assertRaises(IBMQBackendError,
simulator_backend.retrieve_job, job_real.job_id())
self.assertIn('belongs to', str(context_manager.warning))
with self.assertWarns(Warning) as context_manager:
self.assertRaises(IBMQBackendError,
real_backend.retrieve_job, job_sim.job_id())
self.assertIn('belongs to', str(context_manager.warning))
def test_filter_config_callable(self, qe_token, qe_url):
"""Test filtering by lambda function on configuration properties"""
IBMQ.enable_account(qe_token, qe_url)
filtered_backends = IBMQ.backends(
filters=lambda x: (not x.configuration().simulator and x.
configuration().n_qubits >= 5))
self.assertTrue(filtered_backends)
def test_retrieve_job_error(self, qe_token, qe_url):
"""Test retrieving an invalid job."""
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')
def test_filter_config_properties(self, qe_token, qe_url):
"""Test filtering by configuration properties"""
n_qubits = 20 if self.using_ibmq_credentials else 5
IBMQ.enable_account(qe_token, qe_url)
filtered_backends = IBMQ.backends(n_qubits=n_qubits, local=False)
self.assertTrue(filtered_backends)
def test_run_job_object_storage(self, qe_token, qe_url):
"""Test running a job against a simulator using object storage."""
IBMQ.enable_account(qe_token, qe_url)
# Create a Qobj.
backend_name = 'ibmq_qasm_simulator'
backend = IBMQ.get_backend(backend_name)
circuit = transpile(self.qc1, backend, seed_transpiler=self.seed)
qobj = assemble(circuit, backend, shots=1)
print('complied')
# Run the job through the IBMQClient directly using object storage.
api = backend._api
job = api.job_submit_object_storage(backend_name, qobj.as_dict())
job_id = job['id']
self.assertEqual(job['kind'], 'q-object-external-storage')
# Wait for completion.
api.job_final_status_websocket(job_id)
# Fetch results and qobj via object storage.
result = api.job_result_object_storage(job_id)
qobj_downloaded = api.job_download_qobj_object_storage(job_id)
self.assertEqual(qobj_downloaded, qobj.as_dict())
self.assertEqual(result['status'], 'COMPLETED')
def test_execute_several_circuits_simulator_online(self, qe_token, qe_url):
"""Test execute_several_circuits_simulator_online."""
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
qcr1 = QuantumCircuit(qr, cr, name='qc1')
qcr2 = QuantumCircuit(qr, cr, name='qc2')
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_get_jobs_filter_counts(self, qe_token, qe_url):
"""Test retrieving jobs from a backend filtered by counts."""
# 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')
with warnings.catch_warnings():
# Disable warnings from pre-qobj jobs.
warnings.filterwarnings('ignore',
category=DeprecationWarning,
module='qiskit.providers.ibmq.ibmqbackend')
job_list = backend.jobs(limit=5, skip=0, db_filter=my_filter)
for i, job in enumerate(job_list):
self.log.info('match #%d', i)
result = job.result()
self.assertTrue(any(cresult.data.counts.to_dict()['0x0'] < 500
for cresult in result.results))
def get_qiskit_noise_model(
device_name: str,
hub: str = "ibm-q",
group: str = "open",
project: str = "main",
api_token: Optional[str] = None,
) -> Tuple[NoiseModel, CircuitConnectivity]:
"""Get a qiskit noise model to use noisy simulations with a qiskit simulator
Args:
device_name: The name of the device trying to be emulated
hub: The ibmq hub (see qiskit documentation)
group: The ibmq group (see qiskit documentation)
project: The ibmq project (see qiskit documentation)
api_token: The ibmq api token (see qiskit documentation)
"""
if api_token is not None and api_token is not "None":
try:
IBMQ.enable_account(api_token)
except IBMQAccountError as e:
if (e.message !=
"An IBM Quantum Experience account is already in use for the session."
):
raise RuntimeError(e)
# Get qiskit noise model from qiskit
provider = IBMQ.get_provider(hub=hub, group=group, project=project)
noisy_device = provider.get_backend(device_name)
noise_model = AerNoise.NoiseModel.from_backend(noisy_device)
coupling_map = noisy_device.configuration().coupling_map
return noise_model, CircuitConnectivity(coupling_map)
def _wrapper(obj, *args, **kwargs):
qe_token = kwargs.pop('qe_token')
qe_url = kwargs.pop('qe_url')
if not IBMQ.active_account():
IBMQ.enable_account(qe_token, qe_url)
backend_name = os.getenv('QE_STAGING_DEVICE', None) if \
os.getenv('USE_STAGING_CREDENTIALS', '') else os.getenv('QE_DEVICE', None)
_backend = None
provider = _get_custom_provider(IBMQ) or list(
IBMQ._providers.values())[0]
if backend_name:
# Put desired provider as the first in the list.
providers = [provider] + IBMQ.providers()
for provider in providers:
backends = provider.backends(name=backend_name)
if backends:
_backend = backends[0]
break
else:
_backend = least_busy(
provider.backends(
simulator=False,
filters=lambda b: b.configuration().n_qubits >= 5))
if not _backend:
raise Exception('Unable to find a suitable backend.')
kwargs.update({'backend': _backend})
return func(obj, *args, **kwargs)
def test_running_job_properties(self, qe_token, qe_url):
"""Test fetching properties of a running job."""
IBMQ.enable_account(qe_token, qe_url)
backend = least_busy(IBMQ.backends(simulator=False))
qobj = assemble(transpile(self._qc, backend=backend), backend=backend)
job = backend.run(qobj)
_ = job.properties()
def _enable_account(qe_token: str, qe_url: str) -> None:
"""Enable the account if one is not already active.
:param qe_token: API token.
:param qe_url: API URL.
"""
if not IBMQ.active_account():
IBMQ.enable_account(qe_token, qe_url)
def login(cls, token: str = "", remember: bool = False, **kwargs) -> bool:
if not token:
return cls._try_login_saved_account()
else:
QiskitIBMQ.enable_account(token, **kwargs)
if remember:
QiskitIBMQ.save_account(token, **kwargs)
def test_remote_backend_properties(self, qe_token, qe_url):
"""Test backend properties."""
IBMQ.enable_account(qe_token, qe_url)
remotes = IBMQ.backends(simulator=False)
for backend in remotes:
properties = backend.properties()
if backend.configuration().simulator:
self.assertEqual(properties, None)
def test_backend_monitor(self, qe_token, qe_url):
"""Test backend_monitor"""
IBMQ.enable_account(qe_token, qe_url)
for back in IBMQ.backends():
if not back.configuration().simulator:
backend = back
break
backend_monitor(backend)
def test_get_backend_name(self, qe_token, qe_url):
"""Test getting a backend name."""
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 test_pass_bad_proxy(self):
"""Test proxy pass through."""
with self.assertRaises(RequestsApiError) as context_manager:
IBMQ.enable_account('dummy_token',
'https://dummy_url',
proxies=PROXIES)
self.assertIsInstance(context_manager.exception.original_exception,
ProxyError)
def test_disable_all_accounts(self):
"""Test disabling all accounts from session."""
with custom_qiskitrc(), mock_ibmq_provider():
IBMQ.enable_account('QISKITRC_TOKEN')
IBMQ.enable_account('QISKITRC_TOKEN',
url=IBMQ_TEMPLATE.format('a', 'b', 'c'))
IBMQ.disable_accounts()
self.assertEqual(len(IBMQ._accounts), 0)
def __init__(
self,
device_name: str,
n_samples: Optional[int] = None,
hub: Optional[str] = "ibm-q",
group: Optional[str] = "open",
project: Optional[str] = "main",
api_token: Optional[str] = None,
readout_correction: Optional[bool] = False,
optimization_level: Optional[int] = 0,
retry_delay_seconds: Optional[int] = 60,
retry_timeout_seconds: Optional[int] = 86400,
**kwargs,
):
"""Get a qiskit QPU that adheres to the
zquantum.core.interfaces.backend.QuantumBackend
Args:
device_name: the name of the device
n_samples: the number of samples to use when running the device
hub: IBMQ hub
group: IBMQ group
project: IBMQ project
api_token: IBMQ Api Token
readout_correction: flag of whether or not to use basic readout correction
optimization_level: optimization level for the default qiskit transpiler (0,
1, 2, or 3).
retry_delay_seconds: Number of seconds to wait to resubmit a job when backend
job limit is reached.
retry_timeout_seconds: Number of seconds to wait
"""
super().__init__(n_samples=n_samples)
self.device_name = device_name
if api_token is not None:
try:
IBMQ.enable_account(api_token)
except IBMQAccountError as e:
if e.message != (
"An IBM Quantum Experience account is already in use "
"for the session."
):
raise RuntimeError(e)
provider = IBMQ.get_provider(hub=hub, group=group, project=project)
self.device = provider.get_backend(name=self.device_name)
self.max_shots = self.device.configuration().max_shots
self.batch_size = self.device.configuration().max_experiments
self.supports_batching = True
self.readout_correction = readout_correction
self.readout_correction_filter = None
self.optimization_level = optimization_level
self.basis_gates = kwargs.get(
"basis_gates", self.device.configuration().basis_gates
)
self.retry_delay_seconds = retry_delay_seconds
self.retry_timeout_seconds = retry_timeout_seconds
def test_filter_status_dict(self, qe_token, qe_url):
"""Test filtering by dictionary of mixed status/configuration properties"""
IBMQ.enable_account(qe_token, qe_url)
filtered_backends = IBMQ.backends(
operational=True, # from status
local=False,
simulator=True) # from configuration
self.assertTrue(filtered_backends)
def test_job_id(self, qe_token, qe_url):
"""Test getting a job id."""
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 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 test_double_submit_fails(self, qe_token, qe_url):
"""Test submitting a job twice."""
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 _get_backends(self, qe_token, qe_url):
sim_backend = BasicAer.get_backend('qasm_simulator')
try:
IBMQ.enable_account(qe_token, qe_url)
real_backends = IBMQ.backends(simulator=False)
real_backend = least_busy(real_backends)
except QiskitError:
real_backend = None
return sim_backend, real_backend
def _wrapper(*args, **kwargs):
qe_token = kwargs.pop('qe_token')
qe_url = kwargs.pop('qe_url')
if not IBMQ.active_account():
IBMQ.enable_account(qe_token, qe_url)
provider = _get_custom_provider(IBMQ) or list(
IBMQ._providers.values())[0]
kwargs.update({'provider': provider})
return func(*args, **kwargs)
def test_get_jobs_filter_job_status(self, qe_token, qe_url):
"""Test retrieving jobs from a backend filtered by status."""
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 job in job_list:
self.assertTrue(job.status() is JobStatus.DONE)
def test_api_run_job_fail_backend(self, qe_token, qe_url):
"""Test running a job against an invalid backend."""
IBMQ.enable_account(qe_token, qe_url)
backend_name = 'ibmq_qasm_simulator'
backend = IBMQ.get_backend(backend_name)
qobj = compile(self.qc1, backend=backend, seed=self.seed, shots=1)
api = backend._api
self.assertRaises(BadBackendError, api.run_job, qobj.as_dict(),
'INVALID_BACKEND_NAME')