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.use_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_filter_config_properties(self, qe_token, qe_url): """Test filtering by configuration properties""" n_qubits = 20 if self.using_ibmq_credentials else 5 IBMQ.use_account(qe_token, qe_url) filtered_backends = IBMQ.backends(n_qubits=n_qubits, local=False) self.assertTrue(filtered_backends)
def test_get_backend_name(self, qe_token, qe_url): IBMQ.use_account(qe_token, qe_url) backend = IBMQ.get_backend('ibmq_qasm_simulator') qobj = transpiler.compile(self._qc, backend) job = backend.run(qobj) self.assertTrue(job.backend_name() == 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.use_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 = transpiler.compile([qcr1, qcr2], 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_run_device(self, qe_token, qe_url): IBMQ.use_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 = 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_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.use_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 test_filter_config_callable(self, qe_token, qe_url): """Test filtering by lambda function on configuration properties""" IBMQ.use_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_job_id(self, qe_token, qe_url): IBMQ.use_account(qe_token, qe_url) backend = IBMQ.get_backend('ibmq_qasm_simulator') qobj = transpiler.compile(self._qc, backend) job = backend.run(qobj) self.log.info('job_id: %s', job.id()) self.assertTrue(job.id() is not None)
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.use_account(qe_token, qe_url) remotes = IBMQ.backends(simulator=True) self.assertTrue(remotes)
def test_remote_backends_exist(self, qe_token, qe_url): """Test if there are remote backends. If all correct some should exists. """ IBMQ.use_account(qe_token, qe_url) remotes = IBMQ.backends() self.assertTrue(len(remotes) > 0)
def test_double_submit_fails(self, qe_token, qe_url): IBMQ.use_account(qe_token, qe_url) backend = IBMQ.get_backend('ibmq_qasm_simulator') qobj = transpiler.compile(self._qc, backend) # backend.run() will automatically call job.submit() job = backend.run(qobj) with self.assertRaises(JobError): job.submit()
def test_filter_status_dict(self, qe_token, qe_url): """Test filtering by dictionary of mixed status/configuration properties""" IBMQ.use_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_get_jobs_filter_job_status(self, qe_token, qe_url): IBMQ.use_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 test_retrieve_job(self, qe_token, qe_url): IBMQ.use_account(qe_token, qe_url) backend = IBMQ.get_backend('ibmq_qasm_simulator') qobj = transpiler.compile(self._qc, backend) job = backend.run(qobj) rjob = backend.retrieve_job(job.id()) self.assertTrue(job.id() == rjob.id()) self.assertTrue( job.result().get_counts() == rjob.result().get_counts())
def test_get_jobs_filter_date(self, qe_token, qe_url): IBMQ.use_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_run_async_simulator(self, qe_token, qe_url): IBMQJob._executor = futures.ThreadPoolExecutor(max_workers=2) IBMQ.use_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.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.id() for job in job_array] self.assertEqual(sorted(job_ids), sorted(list(set(job_ids))))
def test_cancel(self, qe_token, qe_url): IBMQ.use_account(qe_token, qe_url) backend_name = ('ibmq_20_tokyo' if self.using_ibmq_credentials else 'ibmqx4') backend = IBMQ.get_backend(backend_name) qobj = transpiler.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.use_account(self._qe_token, self._qe_url) self._backend = IBMQ.get_backend(self._testing_device) self._qc = _bell_circuit()
def test_run_async_device(self, qe_token, qe_url): IBMQ.use_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.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): IBMQ.use_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.id(), str)) self.log.info('time to get job statuses: %0.3f s', time.time() - start_time)
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.use_account(self._qe_token, self._qe_url) self._local_backend = Aer.get_backend('local_qasm_simulator') self._remote_backend = IBMQ.get_backend(self._testing_device) self.log.info('Remote backend: %s', self._remote_backend.name()) self.log.info('Local backend: %s', self._local_backend.name())
def test_remote_backend_configuration(self, qe_token, qe_url): """Test backend configuration. If all correct should pass the validation. """ IBMQ.use_account(qe_token, qe_url) remotes = IBMQ.backends(simulator=False) 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_properties(self, qe_token, qe_url): """Test backend properties. If all correct should pass the validation. """ IBMQ.use_account(qe_token, qe_url) remotes = IBMQ.backends(simulator=False) for backend in remotes: self.log.info(backend.name()) properties = backend.properties() # FIXME test against schema and decide what properties # is for a simulator if backend.configuration()['simulator']: self.assertEqual(len(properties), 0) else: self.assertTrue( all(key in properties for key in ('last_update_date', 'qubits', 'backend')))
def test_aliases(self, qe_token, qe_url): """Test that display names of devices map the same backends as the regular names.""" IBMQ.use_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_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.use_account(qe_token, qe_url) remotes = IBMQ.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_execute_one_circuit_simulator_online(self, qe_token, qe_url): """Test execute_one_circuit_simulator_online. If all correct should return correct counts. """ IBMQ.use_account(qe_token, qe_url) backend = IBMQ.get_backend('ibmq_qasm_simulator') qr = QuantumRegister(1) cr = ClassicalRegister(1) qc = QuantumCircuit(qr, cr) qc.h(qr[0]) qc.measure(qr[0], cr[0]) qobj = transpiler.compile(qc, backend, seed=73846087) shots = qobj.config.shots job = backend.run(qobj) result = job.result() counts = result.get_counts(qc) target = {'0': shots / 2, '1': shots / 2} threshold = 0.04 * shots self.assertDictAlmostEqual(counts, target, threshold)
def test_run_simulator(self, qe_token, qe_url): IBMQ.use_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 = transpiler.compile([self._qc, qc], backend) shots = qobj.config.shots job = backend.run(qobj) result = job.result() counts_qx1 = result.get_counts(result.get_names()[0]) counts_qx2 = result.get_counts('hadamard') 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 register(*args, provider_class=None, **kwargs): """ Authenticate against an online backend provider. This is a factory method that returns the provider that gets registered. Args: args (tuple): positional arguments passed to provider class initialization provider_class (BaseProvider): provider class kwargs (dict): keyword arguments passed to provider class initialization. For the IBMQSingleProvider default this can include things such as: * token (str): The token used to register on the online backend such as the quantum experience. * url (str): The url used for online backend such as the quantum experience. * hub (str): The hub used for online backend. * group (str): The group used for online backend. * project (str): The project used for online backend. * proxies (dict): Proxy configuration for the API, as a dict with 'urls' and credential keys. * verify (bool): If False, ignores SSL certificates errors. Returns: BaseProvider: the provider instance that was just registered. Raises: QISKitError: if the provider could not be registered .. deprecated:: 0.6+ After 0.6, this function is deprecated. Please use the methods in `qiskit.IBMQ` instead (`use_account()`) for using IBMQ accounts. For custom `Provider`s, please instantiate them directly. """ if provider_class: warnings.warn( 'The global registry of providers and register() is deprecated ' 'since 0.6. Please instantiate "{}()" directly.'.format( provider_class), DeprecationWarning) return provider_class(*args, **kwargs) else: warnings.warn( 'register() will be deprecated after 0.6. Please use the ' 'qiskit.IBMQ.use_account() method instead.', DeprecationWarning) try: provider = IBMQ.use_account(*args, **kwargs) except Exception as ex: raise QISKitError( "Couldn't instantiate provider! Error: {0}".format(ex)) return provider
def test_filter_least_busy(self, qe_token, qe_url): """Test filtering by least busy function""" IBMQ.use_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.use_account(qe_token, qe_url) backends = IBMQ.backends(simulator=False) backend = least_busy(backends) self.assertRaises(IBMQBackendError, backend.retrieve_job, 'BAD_JOB_ID')