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')))