def run_local_simulator(qobj): """Run a program of compiled quantum circuits on the local machine. Args: qobj (dict): quantum object dictionary Returns: Dictionary of form, job_result = { "status": DATA, "result" : [ { "data": DATA, "status": DATA, }, ... ] "name": DATA, "backend": DATA } """ for circuit in qobj['circuits']: if circuit['compiled_circuit'] is None: compiled_circuit = openquantumcompiler.compile(circuit['circuit'], format='json') circuit['compiled_circuit'] = compiled_circuit local_simulator = simulators.LocalSimulator(qobj) local_simulator.run() return local_simulator.result()
def execute(self, circuit, **options): """ Execute sympy-circuit with classical simulator We use numpy simulator as default @param circuit sympy object to simulate """ qasm = self.to_qasm(circuit) if (not self.parallel): self.simulator = CythonSimulator() else: self.simulator = CythonOmpSimulator() try: basis_gates_str = (",".join(self.simulator.basis_gates)).lower() except: basis_gates_str = "cx,m0,m1" #print(basis_gates_str) # the following one-line compilation ignores basis_gates, and returnes "u2" for "h". #json = openquantumcompiler.compile(qasm,basis_gates=basis_gates_str,format="json") circuit_dag = openquantumcompiler.compile(qasm, basis_gates=basis_gates_str) json = openquantumcompiler.dag2json(circuit_dag, basis_gates=basis_gates_str) self.simulate(json) return self.simulator
def run_local_backend(qobj): """Run a program of compiled quantum circuits on the local machine. Args: qobj (dict): quantum object dictionary Returns: Dictionary of form, job_result = { "status": DATA, "result" : [ { "data": DATA, "status": DATA, }, ... ] "name": DATA, "backend": DATA } """ for circuit in qobj['circuits']: if circuit['compiled_circuit'] is None: compiled_circuit = openquantumcompiler.compile(circuit['circuit'], format='json') circuit['compiled_circuit'] = compiled_circuit backendclass = backends.get_backend_class(qobj['config']['backend']) backend = backendclass(qobj) return backend.run()
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. """ self._init_api(QE_TOKEN, QE_URL) njobs = 6 job_list = [] backend_type = ['local_qasm_simulator', 'ibmqx_qasm_simulator'] i = 0 for circuit in self.rqg.get_circuits(format_='QuantumCircuit')[:njobs]: compiled_circuit = openquantumcompiler.compile(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_run_job_processor_local_parallel(self): def job_done_callback(results): try: self.log.info(pprint.pformat(results)) for result in results: self.assertTrue(result.get_status() == 'COMPLETED') except Exception as e: self.job_processor_exception = e finally: self.job_processor_finished = True njobs = 20 job_list = [] for i in range(njobs): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) quantum_job = jobprocessor.QuantumJob( compiled_circuit, backend='local_qasm_simulator') job_list.append(quantum_job) self.job_processor_finished = False self.job_processor_exception = None jp = jobprocessor.JobProcessor(job_list, max_workers=None, callback=job_done_callback) jp.submit(silent=True) while not self.job_processor_finished: # Wait until the job_done_callback is invoked and completed. pass if self.job_processor_exception: raise self.job_processor_exception
def run_remote_backend(qobj, api, wait=5, timeout=60, silent=True): """ Args: qobj (dict): quantum object dictionary api (IBMQuantumExperience): IBMQuantumExperience API connection Raises: QISKitError: if "ERROR" string in server response. """ jobs = [] for job in qobj['circuits']: if (('compiled_circuit_qasm' not in job) or (job['compiled_circuit_qasm'] is None)): compiled_circuit = openquantumcompiler.compile(job['circuit'].qasm()) job['compiled_circuit_qasm'] = compiled_circuit.qasm(qeflag=True) if isinstance(job['compiled_circuit_qasm'], bytes): jobs.append({'qasm': job['compiled_circuit_qasm'].decode()}) else: jobs.append({'qasm': job['compiled_circuit_qasm']}) seed0 = qobj['circuits'][0]['config']['seed'] output = api.run_job(jobs, qobj['config']['backend'], shots=qobj['config']['shots'], max_credits=qobj['config']['max_credits'], seed=seed0) if 'ERROR' in output: raise QISKitError(output['ERROR']) job_result = _wait_for_job(output['id'], api, wait=wait, timeout=timeout, silent=silent) job_result['name'] = qobj['id'] job_result['backend'] = qobj['config']['backend'] return job_result
def test_run_local_simulator_unitary(self): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) quantum_job = jobprocessor.QuantumJob( compiled_circuit, doCompile=False, backend='local_unitary_simulator') jobprocessor.run_local_simulator(quantum_job.qobj)
def test_error_in_job(self): def job_done_callback(results): try: for result in results: self.log.info(pprint.pformat(result)) self.assertTrue(result.get_status() == 'ERROR') except Exception as e: self.job_processor_exception = e finally: self.job_processor_finished = True njobs = 5 job_list = [] for i in range(njobs): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) quantum_job = QuantumJob(compiled_circuit, backend='local_qasm_simulator') job_list.append(quantum_job) self.job_processor_finished = False self.job_processor_exception = None jp = jobprocessor.JobProcessor(job_list, max_workers=None, callback=job_done_callback) tmp = jobprocessor.run_backend jobprocessor.run_backend = mock_run_local_backend jp.submit() jobprocessor.run_backend = tmp while not self.job_processor_finished: # Wait until the job_done_callback is invoked and completed. pass if self.job_processor_exception: raise self.job_processor_exception
def test_run_remote_simulator(self): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) quantum_job = QuantumJob(compiled_circuit, do_compile=False, backend='ibmqx_qasm_simulator') api = IBMQuantumExperience(self.QE_TOKEN, {"url": self.QE_URL}, verify=True) jobprocessor.run_remote_backend(quantum_job.qobj, api)
def test_backend_not_found(self, QE_TOKEN, QE_URL): self._init_api(QE_TOKEN, QE_URL) compiled_circuit = openquantumcompiler.compile(self.qc) job = QuantumJob(compiled_circuit, backend='non_existing_backend') self.assertRaises(QISKitError, jobprocessor.JobProcessor, [job], callback=None)
def test_backend_not_found(self): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) job = QuantumJob(compiled_circuit, backend='non_existing_backend') self.assertRaises(QISKitError, jobprocessor.JobProcessor, [job], callback=None, token=self.QE_TOKEN, url=self.QE_URL)
def test_run_remote_simulator(self, QE_TOKEN, QE_URL): self._init_api(QE_TOKEN, QE_URL) compiled_circuit = openquantumcompiler.compile(self.qc) quantum_job = QuantumJob(compiled_circuit, do_compile=False, backend='ibmqx_qasm_simulator') jobprocessor.run_backend(quantum_job)
def test_run_remote_simulator(self): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) qjob = jobp.QuantumJob(compiled_circuit, doCompile=False, backend='ibmqx_qasm_simulator') api = IBMQuantumExperience(self.QE_TOKEN, {"url": self.QE_URL}, verify=True) jobp.run_remote_backend(qjob.qobj, api)
def setUp(self): self.seed = 88 self.qasm_filename = os.path.join(qiskit.__path__[0], '../test/python/qasm/example.qasm') with open(self.qasm_filename, 'r') as qasm_file: self.qasm_text = qasm_file.read() self.qasm_ast = qiskit.qasm.Qasm(data=self.qasm_text).parse() self.qasm_be = qiskit.unroll.CircuitBackend( ['u1', 'u2', 'u3', 'id', 'cx']) self.qasm_circ = qiskit.unroll.Unroller(self.qasm_ast, self.qasm_be).execute() qr = QuantumRegister('q', 2) cr = ClassicalRegister('c', 2) qc = QuantumCircuit(qr, cr) qc.h(qr[0]) qc.measure(qr[0], cr[0]) self.qc = qc # create qobj compiled_circuit1 = openquantumcompiler.compile(self.qc, format='json') compiled_circuit2 = openquantumcompiler.compile(self.qasm_circ, format='json') self.qobj = { 'id': 'test_qobj', 'config': { 'max_credits': 3, 'shots': 100, 'backend': 'local_qiskit_simulator', 'seed': 1111 }, 'circuits': [{ 'name': 'test_circuit1', 'compiled_circuit': compiled_circuit1, 'basis_gates': 'u1,u2,u3,cx,id', 'layout': None, }, { 'name': 'test_circuit2', 'compiled_circuit': compiled_circuit2, 'basis_gates': 'u1,u2,u3,cx,id', 'layout': None, }] } self.q_job = QuantumJob(self.qobj, backend='local_qiskit_simulator', preformatted=True)
def setUp(self): self.seed = 88 self.qasm_filename = self._get_resource_path('qasm/example.qasm') with open(self.qasm_filename, 'r') as qasm_file: self.qasm_text = qasm_file.read() self.qasm_ast = qiskit.qasm.Qasm(data=self.qasm_text).parse() self.qasm_be = qiskit.unroll.CircuitBackend( ['u1', 'u2', 'u3', 'id', 'cx']) self.qasm_circ = qiskit.unroll.Unroller(self.qasm_ast, self.qasm_be).execute() # create QuantumCircuit qr = QuantumRegister('q', 2) cr = ClassicalRegister('c', 2) qc = QuantumCircuit(qr, cr) qc.h(qr[0]) qc.measure(qr[0], cr[0]) self.qc = qc # create qobj compiled_circuit1 = openquantumcompiler.compile(self.qc) compiled_circuit2 = openquantumcompiler.compile(self.qasm_circ) self.qobj = { 'id': 'test_qobj', 'config': { 'max_credits': 3, 'shots': 100, 'backend': 'local_qasm_simulator', }, 'circuits': [{ 'name': 'test_circuit1', 'compiled_circuit': compiled_circuit1, 'basis_gates': 'u1,u2,u3,cx,id', 'layout': None, 'seed': None }, { 'name': 'test_circuit2', 'compiled_circuit': compiled_circuit2, 'basis_gates': 'u1,u2,u3,cx,id', 'layout': None, 'seed': None }] } self.job_processor_exception = Exception() self.job_processor_finished = False
def test_run_job_processor_online(self): njobs = 1 job_list = [] for _ in range(njobs): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) quantum_job = QuantumJob(compiled_circuit, backend='ibmqx_qasm_simulator') job_list.append(quantum_job) jp = jobprocessor.JobProcessor(job_list, callback=None) jp.submit()
def test_run_job_processor_online(self): njobs = 1 job_list = [] for i in range(njobs): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) quantum_job = QuantumJob(compiled_circuit, backend='ibmqx_qasm_simulator') job_list.append(quantum_job) jp = jobprocessor.JobProcessor(job_list, callback=None) jp.submit()
def setUp(self): self.seed = 88 self.qasmFileName = os.path.join(qiskit.__path__[0], '../test/python/qasm/example.qasm') with open(self.qasmFileName, 'r') as qasm_file: self.qasm_text = qasm_file.read() qr = QuantumRegister('q', 2) cr = ClassicalRegister('c', 2) qc = QuantumCircuit(qr, cr) qc.h(qr[0]) qc.measure(qr[0], cr[0]) self.qc = qc # create qobj compiled_circuit1 = openquantumcompiler.compile(self.qc.qasm(), format='json') compiled_circuit2 = openquantumcompiler.compile(self.qasm_text, format='json') self.qobj = {'id': 'test_qobj', 'config': { 'max_credits': 3, 'shots': 100, 'backend': 'local_qasm_simulator', 'seed': 1111 }, 'circuits': [ { 'name': 'test_circuit1', 'compiled_circuit': compiled_circuit1, 'basis_gates': 'u1,u2,u3,cx,id', 'layout': None, }, { 'name': 'test_circuit2', 'compiled_circuit': compiled_circuit2, 'basis_gates': 'u1,u2,u3,cx,id', 'layout': None, } ] } self.q_job = QuantumJob(self.qobj, backend='local_qasm_cpp_simulator', preformatted=True)
def test_run_job_processor_online(self): njobs = 1 job_list = [] for i in range(njobs): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) qjob = jobp.QuantumJob(compiled_circuit, backend='ibmqx_qasm_simulator') job_list.append(qjob) jp = jobp.JobProcessor(job_list, token=self.QE_TOKEN, url=self.QE_URL, callback=None) jp.submit(silent=True)
def test_random_local(self): """test randomly generated circuits on local_qasm_simulator""" njobs = 5 job_list = [] backend = 'local_qasm_simulator' for circuit in self.rqg.get_circuits(format_='QuantumCircuit')[:njobs]: compiled_circuit = openquantumcompiler.compile(circuit.qasm()) quantum_job = QuantumJob(compiled_circuit, backend=backend) job_list.append(quantum_job) jp = jobprocessor.JobProcessor(job_list, max_workers=1, callback=None) jp.submit()
def test_run_job_processor_local(self): njobs = 5 job_list = [] for i in range(njobs): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) quantum_job = QuantumJob(compiled_circuit, backend='local_qasm_simulator', do_compile=False) job_list.append(quantum_job) jp = jobprocessor.JobProcessor(job_list, callback=None) jp.submit(silent=True)
def test_run_job_processor_local(self): njobs = 5 job_list = [] for i in range(njobs): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) qjob = jobp.QuantumJob(compiled_circuit, backend='local_qasm_simulator', doCompile=False) job_list.append(qjob) jp = jobp.JobProcessor(job_list, callback=None) jp.submit(silent=True)
def test_random_local(self): """test randomly generated circuits on local_qasm_simulator""" njobs = 5 job_list = [] basis = 'u1,u2,u3,cx,id' backend = 'local_qasm_simulator' for circuit in self.rqg.get_circuits(format='QuantumCircuit')[:njobs]: compiled_circuit = openquantumcompiler.compile(circuit.qasm()) qjob = jobp.QuantumJob(compiled_circuit, backend=backend) job_list.append(qjob) jp = jobp.JobProcessor(job_list, max_workers=1, callback=None) jp.submit(silent=True)
def setUp(self): self.seed = 88 self.qasmFileName = os.path.join(qiskit.__path__[0], '../test/python/qasm/example.qasm') with open(self.qasmFileName, 'r') as qasm_file: self.qasm_text = qasm_file.read() qr = QuantumRegister('q', 2) cr = ClassicalRegister('c', 2) qc = QuantumCircuit(qr, cr) qc.h(qr[0]) qc.measure(qr[0], cr[0]) self.qc = qc # create qobj compiled_circuit1 = openquantumcompiler.compile(self.qc.qasm(), format='json') compiled_circuit2 = openquantumcompiler.compile(self.qasm_text, format='json') self.qobj = { 'id': 'test_qobj', 'config': { 'max_credits': 3, 'shots': 100, 'backend': 'local_qasm_simulator', }, 'circuits': [{ 'name': 'test_circuit1', 'compiled_circuit': compiled_circuit1, 'basis_gates': 'u1,u2,u3,cx,id', 'layout': None, 'seed': None }, { 'name': 'test_circuit2', 'compiled_circuit': compiled_circuit2, 'basis_gates': 'u1,u2,u3,cx,id', 'layout': None, 'seed': None }] }
def test_run_job_processor_online(self): njobs = 1 job_list = [] for i in range(njobs): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) qjob = jobp.QuantumJob(compiled_circuit, backend='ibmqx_qasm_simulator') job_list.append(qjob) jp = jobp.JobProcessor(job_list, token=self.QE_TOKEN, url=self.QE_URL, callback=None) jp.submit(silent=True)
def setUp(self): self.seed = 88 self.qasmFileName = self._get_resource_path('qasm/example.qasm') with open(self.qasmFileName, 'r') as qasm_file: self.qasm_text = qasm_file.read() # create QuantumCircuit qr = QuantumRegister('q', 2) cr = ClassicalRegister('c', 2) qc = QuantumCircuit(qr, cr) qc.h(qr[0]) qc.measure(qr[0], cr[0]) self.qc = qc # create qobj compiled_circuit1 = openquantumcompiler.compile(self.qc.qasm()) compiled_circuit2 = openquantumcompiler.compile(self.qasm_text) self.qobj = {'id': 'test_qobj', 'config': { 'max_credits': 3, 'shots': 100, 'backend': 'local_qasm_simulator', }, 'circuits': [ { 'name': 'test_circuit1', 'compiled_circuit': compiled_circuit1, 'basis_gates': 'u1,u2,u3,cx,id', 'layout': None, 'seed': None }, { 'name': 'test_circuit2', 'compiled_circuit': compiled_circuit2, 'basis_gates': 'u1,u2,u3,cx,id', 'layout': None, 'seed': None } ] }
def run(self, q_job): """Run jobs Args: q_job (QuantumJob): job to run Returns: Result object. Raises: ResultError: if the api put 'error' in its output """ qobj = q_job.qobj wait = q_job.wait timeout = q_job.timeout api_jobs = [] for circuit in qobj['circuits']: if (('compiled_circuit_qasm' not in circuit) or (circuit['compiled_circuit_qasm'] is None)): compiled_circuit = openquantumcompiler.compile( circuit['circuit'].qasm()) circuit['compiled_circuit_qasm'] = compiled_circuit.qasm( qeflag=True) if isinstance(circuit['compiled_circuit_qasm'], bytes): api_jobs.append( {'qasm': circuit['compiled_circuit_qasm'].decode()}) else: api_jobs.append({'qasm': circuit['compiled_circuit_qasm']}) seed0 = qobj['circuits'][0]['config']['seed'] output = self._api.run_job(api_jobs, qobj['config']['backend'], shots=qobj['config']['shots'], max_credits=qobj['config']['max_credits'], seed=seed0) if 'error' in output: raise ResultError(output['error']) logger.debug('Running on remote backend %s with job id: %s', qobj['config']['backend'], output['id']) job_result = _wait_for_job(output['id'], self._api, wait=wait, timeout=timeout) job_result['name'] = qobj['id'] job_result['backend'] = qobj['config']['backend'] this_result = Result(job_result, qobj) return this_result
def test_run_job_processor_local_parallel(self): njobs = 20 job_list = [] for i in range(njobs): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) qjob = jobp.QuantumJob(compiled_circuit, backend='local_qasm_simulator') job_list.append(qjob) def job_done_callback(results): self.log.info(pprint.pformat(results)) for result, _ in results: self.assertTrue(result['result'][0]['status'] == 'DONE') jp = jobp.JobProcessor(job_list, max_workers=None, callback=job_done_callback) jp.submit(silent=True)
def run_local_simulator(qobj): """Run a program of compiled quantum circuits on the local machine. Args: qobj (dict): quantum object dictionary Returns: Dictionary of form, job_result = { "status": DATA, "result" : [ { "data": DATA, "status": DATA, }, ... ] "name": DATA, "backend": DATA } """ job_result = { 'status': '', 'result': [], 'name': qobj['id'], 'backend': qobj['config']['backend'] } for job in qobj['circuits']: if job['compiled_circuit'] is None: compiled_circuit = openquantumcompiler.compile(job['circuit']) job['compiled_circuit'] = openquantumcompiler.dag2json( compiled_circuit) sim_job = { 'compiled_circuit': job['compiled_circuit'], 'config': { **job['config'], **qobj['config'] } } local_simulator = simulators.LocalSimulator(qobj['config']['backend'], sim_job) local_simulator.run() job_result['result'].append(local_simulator.result()) job_result['status'] = 'COMPLETED' job_result['name'] = qobj['id'] job_result['backend'] = qobj['config']['backend'] return job_result
def test_run_job_processor_local_parallel(self): njobs = 20 job_list = [] for i in range(njobs): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) qjob = jobp.QuantumJob(compiled_circuit, backend='local_qasm_simulator') job_list.append(qjob) def job_done_callback(results): self.log.info(pprint.pformat(results)) for result, _ in results: self.assertTrue(result['result'][0]['status'] == 'DONE') jp = jobp.JobProcessor(job_list, max_workers=None, callback=job_done_callback) jp.submit(silent=True)
def run(self, q_job): """Run jobs Args: q_job (QuantumJob): job to run Returns: Result object. Raises: ResultError: if the api put 'error' in its output """ qobj = q_job.qobj wait = q_job.wait timeout = q_job.timeout api_jobs = [] for circuit in qobj['circuits']: if (('compiled_circuit_qasm' not in circuit) or (circuit['compiled_circuit_qasm'] is None)): compiled_circuit = openquantumcompiler.compile( circuit['circuit'].qasm()) circuit['compiled_circuit_qasm'] = compiled_circuit.qasm(qeflag=True) if isinstance(circuit['compiled_circuit_qasm'], bytes): api_jobs.append({'qasm': circuit['compiled_circuit_qasm'].decode()}) else: api_jobs.append({'qasm': circuit['compiled_circuit_qasm']}) seed0 = qobj['circuits'][0]['config']['seed'] output = self._api.run_job(api_jobs, qobj['config']['backend'], shots=qobj['config']['shots'], max_credits=qobj['config']['max_credits'], seed=seed0) if 'error' in output: raise ResultError(output['error']) logger.debug('Running on remote backend %s with job id: %s', qobj['config']['backend'], output['id']) job_result = _wait_for_job(output['id'], self._api, wait=wait, timeout=timeout) job_result['name'] = qobj['id'] job_result['backend'] = qobj['config']['backend'] this_result = Result(job_result, qobj) return this_result
def run_backend(q_job): """Run a program of compiled quantum circuits on a backend. Args: q_job (QuantumJob): job object Returns: Result: Result object. """ backend_name = q_job.backend qobj = q_job.qobj if backend_name in local_backends(): # remove condition when api gets qobj for circuit in qobj['circuits']: if circuit['compiled_circuit'] is None: compiled_circuit = openquantumcompiler.compile( circuit['circuit'], format='json') circuit['compiled_circuit'] = compiled_circuit backend = qiskit.backends.get_backend_instance(backend_name) return backend.run(q_job)
def test_error_in_job(self): njobs = 5 job_list = [] for i in range(njobs): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) qjob = jobp.QuantumJob(compiled_circuit, backend='local_qasm_simulator') job_list.append(qjob) def job_done_callback(results): for result, _ in results: self.log.info(pprint.pformat(result)) self.assertTrue(result['status'] == 'ERROR') jp = jobp.JobProcessor(job_list, max_workers=None, callback=job_done_callback) tmp = jobp.run_local_simulator jobp.run_local_simulator = mock_run_local_simulator jp.submit(silent=True) jobp.run_local_simulator = tmp
def run_remote_backend(qobj, api, wait=5, timeout=60, silent=True): """ Args: qobj (dict): quantum object dictionary api (IBMQuantumExperience): IBMQuantumExperience API connection Raises: QISKitError: if "ERROR" string in server response. """ api_jobs = [] for circuit in qobj['circuits']: if (('compiled_circuit_qasm' not in circuit) or (circuit['compiled_circuit_qasm'] is None)): compiled_circuit = openquantumcompiler.compile( circuit['circuit'].qasm()) circuit['compiled_circuit_qasm'] = compiled_circuit.qasm( qeflag=True) if isinstance(circuit['compiled_circuit_qasm'], bytes): api_jobs.append( {'qasm': circuit['compiled_circuit_qasm'].decode()}) else: api_jobs.append({'qasm': circuit['compiled_circuit_qasm']}) seed0 = qobj['circuits'][0]['config']['seed'] output = api.run_job(api_jobs, qobj['config']['backend'], shots=qobj['config']['shots'], max_credits=qobj['config']['max_credits'], seed=seed0) if 'error' in output: raise ResultError(output['error']) job_result = _wait_for_job(output['id'], api, wait=wait, timeout=timeout, silent=silent) job_result['name'] = qobj['id'] job_result['backend'] = qobj['config']['backend'] this_result = Result(job_result, qobj) return this_result
def __init__(self, data=None, file=None, backendName="cpu", verbose=False, APIToken=None): backends = [ QasmBackendGpu, QasmBackendCpu, QasmBackendCython, QasmBackendCythonOmp, QasmBackendIbmqx ] backendNames = dict([(sim.name, sim) for sim in backends]) backendBasisGates = dict([(sim.name, sim.basisGates) for sim in backends]) if (data is None and file is None): raise Exception("data or file is required") if (data is not None and file is not None): raise Exception("data or file is required") if (data is not None): text = data else: try: text = open(file).read() except: raise Exception("file not found") if (backendName not in backendNames): raise Exception("unknown backends : choose among " + str(backendNames.keys())) basisGates = backendBasisGates[backendName] circuit_dag = openquantumcompiler.compile(text, basis_gates=basisGates) circuit_json = openquantumcompiler.dag2json(circuit_dag, basis_gates=basisGates) self.backendName = backendName self.qasmtxt = circuit_dag.qasm(qeflag=True) self.circuit = circuit_json self.backend = backendNames[backendName] self.verbose = verbose self.APIToken = APIToken
def run_local_simulator(qobj): """Run a program of compiled quantum circuits on the local machine. Args: qobj (dict): quantum object dictionary Returns: Dictionary of form, job_result = { "status": DATA, "result" : [ { "data": DATA, "status": DATA, }, ... ] "name": DATA, "backend": DATA } """ job_result = {'status': '', 'result': [], 'name': qobj['id'], 'backend': qobj['config']['backend']} for job in qobj['circuits']: if job['compiled_circuit'] is None: compiled_circuit = openquantumcompiler.compile(job['circuit']) job['compiled_circuit'] = openquantumcompiler.dag2json(compiled_circuit) sim_job = {'compiled_circuit': job['compiled_circuit'], 'config': {**job['config'], **qobj['config']}} local_simulator = simulators.LocalSimulator( qobj['config']['backend'], sim_job) local_simulator.run() job_result['result'].append(local_simulator.result()) job_result['status'] = 'COMPLETED' job_result['name'] = qobj['id'] job_result['backend'] = qobj['config']['backend'] return job_result
def test_error_in_job(self): njobs = 5 job_list = [] for i in range(njobs): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) qjob = jobp.QuantumJob(compiled_circuit, backend='local_qasm_simulator') job_list.append(qjob) def job_done_callback(results): for result, _ in results: self.log.info(pprint.pformat(result)) self.assertTrue(result['status'] == 'ERROR') jp = jobp.JobProcessor(job_list, max_workers=None, callback=job_done_callback) tmp = jobp.run_local_simulator jobp.run_local_simulator = mock_run_local_simulator jp.submit(silent=True) jobp.run_local_simulator = tmp
def test_random_circuits(self): local_simulator = qasm_simulator.QasmSimulator() for circuit in self.rqg.get_circuits(format_='QuantumCircuit'): self.log.info(circuit.qasm()) compiled_circuit = openquantumcompiler.compile(circuit) shots = 100 min_cnts = int(shots / 10) job_pq = QuantumJob(compiled_circuit, backend='local_projectq_simulator', seed=1, shots=shots) job_py = QuantumJob(compiled_circuit, backend='local_qasm_simulator', seed=1, shots=shots) result_pq = pq_simulator.run(job_pq) result_py = local_simulator.run(job_py) counts_pq = result_pq.get_counts(result_pq.get_names()[0]) counts_py = result_py.get_counts(result_py.get_names()[0]) # filter states with few counts counts_pq = { key: cnt for key, cnt in counts_pq.items() if cnt > min_cnts } counts_py = { key: cnt for key, cnt in counts_py.items() if cnt > min_cnts } self.log.info('local_projectq_simulator: %s', str(counts_pq)) self.log.info('local_qasm_simulator: %s', str(counts_py)) self.assertTrue(counts_pq.keys() == counts_py.keys()) states = counts_py.keys() # contingency table ctable = numpy.array([[counts_pq[key] for key in states], [counts_py[key] for key in states]]) result = chi2_contingency(ctable) self.log.info('chi2_contingency: %s', str(result)) with self.subTest(circuit=circuit): self.assertGreater(result[1], 0.01)
def test_mix_local_remote_jobs(self): """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. """ njobs = 6 job_list = [] basis = 'u1,u2,u3,cx' backend_type = ['local_qasm_simulator', 'ibmqx_qasm_simulator'] i = 0 for circuit in self.rqg.get_circuits(format='QuantumCircuit')[:njobs]: compiled_circuit = openquantumcompiler.compile(circuit.qasm()) backend = backend_type[i % len(backend_type)] self.log.info(backend) qjob = jobp.QuantumJob(compiled_circuit, backend=backend) job_list.append(qjob) i += 1 jp = jobp.JobProcessor(job_list, max_workers=None, token=self.QE_TOKEN, url=self.QE_URL, callback=None) jp.submit(silent=True)
def test_error_in_job(self): def job_done_callback(results): try: for result in results: self.log.info(pprint.pformat(result)) self.assertTrue(result.get_status() == 'ERROR') except Exception as e: self.job_processor_exception = e finally: self.job_processor_finished = True njobs = 5 job_list = [] for _ in range(njobs): compiled_circuit = openquantumcompiler.compile(self.qc) quantum_job = QuantumJob(compiled_circuit, backend='local_qasm_simulator') job_list.append(quantum_job) self.job_processor_finished = False self.job_processor_exception = None jp = jobprocessor.JobProcessor(job_list, max_workers=None, callback=job_done_callback) tmp = jobprocessor.run_backend jobprocessor.run_backend = mock_run_local_backend jp.submit() jobprocessor.run_backend = tmp while not self.job_processor_finished: # Wait until the job_done_callback is invoked and completed. pass if self.job_processor_exception: raise self.job_processor_exception
def test_run_remote_simulator(self): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) quantum_job = QuantumJob(compiled_circuit, do_compile=False, backend='ibmqx_qasm_simulator') jobprocessor.run_backend(quantum_job)
def testrun_local_simulator(self): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) qjob = jobp.QuantumJob(compiled_circuit, doCompile=False, backend='local_qasm_simulator') jobp.run_local_simulator(qjob.qobj)
def test_run_local_backend_qasm(self): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) quantum_job = QuantumJob(compiled_circuit, do_compile=False, backend='local_qasm_simulator') jobprocessor.run_local_backend(quantum_job.qobj)
def test_backend_not_found(self): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) job = QuantumJob(compiled_circuit, backend='non_existing_backend') self.assertRaises(QISKitError, jobprocessor.JobProcessor, [job], callback=None)
def test_run_local_backend_unitary(self): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) quantum_job = QuantumJob(compiled_circuit, do_compile=False, backend='local_unitary_simulator') jobprocessor.run_backend(quantum_job)
def test_run_remote_simulator(self): compiled_circuit = openquantumcompiler.compile(self.qc.qasm()) quantum_job = QuantumJob(compiled_circuit, do_compile=False, backend='ibmqx_qasm_simulator') jobprocessor.run_backend(quantum_job)
def setUpClass(cls): super(TestProjectQCppSimulator, cls).setUpClass() n_circuits = 20 min_depth = 1 max_depth = 10 min_qubits = 1 max_qubits = 4 random_circuits = RandomCircuitGenerator(min_qubits=min_qubits, max_qubits=max_qubits, min_depth=min_depth, max_depth=max_depth, seed=None) for _ in range(n_circuits): basis = list( random.sample(random_circuits.op_signature.keys(), random.randint(2, 7))) if 'reset' in basis: basis.remove('reset') random_circuits.add_circuits(1, basis=basis) cls.rqg = random_circuits cls.seed = 88 cls.qasm_filename = cls._get_resource_path('qasm/example.qasm') with open(cls.qasm_filename, 'r') as qasm_file: cls.qasm_text = qasm_file.read() qr1 = QuantumRegister('q1', 2) qr2 = QuantumRegister('q2', 3) cr = ClassicalRegister('c', 2) qcs = QuantumCircuit(qr1, qr2, cr) qcs.h(qr1[0]) qcs.h(qr2[2]) qcs.measure(qr1[0], cr[0]) cls.qcs = qcs # create qobj compiled_circuit1 = openquantumcompiler.compile(cls.qcs.qasm(), format='json') compiled_circuit2 = openquantumcompiler.compile(cls.qasm_text, format='json') cls.qobj = { 'id': 'test_qobj', 'config': { 'max_credits': 3, 'shots': 100, 'backend': 'local_projectq_simulator', 'seed': 1111 }, 'circuits': [{ 'name': 'test_circuit1', 'compiled_circuit': compiled_circuit1, 'basis_gates': 'u1,u2,u3,cx,id', 'layout': None, }, { 'name': 'test_circuit2', 'compiled_circuit': compiled_circuit2, 'basis_gates': 'u1,u2,u3,cx,id', 'layout': None, }] } cls.q_job = QuantumJob(cls.qobj, backend='local_projectq_simulator', preformatted=True)
def run(self, q_job): """Run jobs Args: q_job (QuantumJob): job to run Returns: Result object. Raises: ResultError: if the api put 'error' in its output """ qobj = q_job.qobj wait = q_job.wait timeout = q_job.timeout api_jobs = [] for circuit in qobj['circuits']: if (('compiled_circuit_qasm' not in circuit) or (circuit['compiled_circuit_qasm'] is None)): compiled_circuit = openquantumcompiler.compile( circuit['circuit'].qasm()) circuit['compiled_circuit_qasm'] = compiled_circuit.qasm( qeflag=True) if isinstance(circuit['compiled_circuit_qasm'], bytes): api_jobs.append( {'qasm': circuit['compiled_circuit_qasm'].decode()}) else: api_jobs.append({'qasm': circuit['compiled_circuit_qasm']}) seed0 = qobj['circuits'][0]['config']['seed'] hpc = None if (qobj['config']['backend'] == 'ibmqx_hpc_qasm_simulator' and 'hpc' in qobj['config']): try: # Use CamelCase when passing the hpc parameters to the API. hpc = { 'multiShotOptimization': qobj['config']['hpc']['multi_shot_optimization'], 'ompNumThreads': qobj['config']['hpc']['omp_num_threads'] } except: hpc = None output = self._api.run_job(api_jobs, qobj['config']['backend'], shots=qobj['config']['shots'], max_credits=qobj['config']['max_credits'], seed=seed0, hpc=hpc) if 'error' in output: raise ResultError(output['error']) logger.debug('Running on remote backend %s with job id: %s', qobj['config']['backend'], output['id']) job_result = _wait_for_job(output['id'], self._api, wait=wait, timeout=timeout) job_result['name'] = qobj['id'] job_result['backend'] = qobj['config']['backend'] this_result = Result(job_result, qobj) return this_result
def compile(self, name_of_circuits, backend="local_qasm_simulator", config=None, silent=True, basis_gates=None, coupling_map=None, initial_layout=None, shots=1024, max_credits=3, seed=None, qobj_id=None): """Compile the circuits into the exectution list. This builds the internal "to execute" list which is list of quantum circuits to run on different backends. Args: name_of_circuits (list[str]): circuit names to be compiled. backend (str): a string representing the backend to compile to config (dict): a dictionary of configurations parameters for the compiler silent (bool): is an option to print out the compiling information or not basis_gates (str): a comma seperated string and are the base gates, which by default are: u1,u2,u3,cx,id coupling_map (dict): A directed graph of coupling:: { control(int): [ target1(int), target2(int), , ... ], ... } eg. {0: [2], 1: [2], 3: [2]} initial_layout (dict): A mapping of qubit to qubit:: { ("q", strart(int)): ("q", final(int)), ... } eg. { ("q", 0): ("q", 0), ("q", 1): ("q", 1), ("q", 2): ("q", 2), ("q", 3): ("q", 3) } shots (int): the number of shots max_credits (int): the max credits to use 3, or 5 seed (int): the intial seed the simulatros use Returns: the job id and populates the qobj:: qobj = { id: --job id (string), config: -- dictionary of config settings (dict)--, { "max_credits" (online only): -- credits (int) --, "shots": -- number of shots (int) --. "backend": -- backend name (str) -- } circuits: [ { "name": --circuit name (string)--, "compiled_circuit": --compiled quantum circuit (JSON format)--, "compiled_circuit_qasm": --compiled quantum circuit (QASM format)--, "config": --dictionary of additional config settings (dict)--, { "coupling_map": --adjacency list (dict)--, "basis_gates": --comma separated gate names (string)--, "layout": --layout computed by mapper (dict)--, "seed": (simulator only)--initial seed for the simulator (int)--, } }, ... ] } """ # TODO: Jay: currently basis_gates, coupling_map, initial_layout, # shots, max_credits and seed are extra inputs but I would like # them to go into the config. qobj = {} if not qobj_id: qobj_id = "".join([random.choice(string.ascii_letters+string.digits) for n in range(30)]) qobj['id'] = qobj_id qobj["config"] = {"max_credits": max_credits, 'backend': backend, "shots": shots} qobj["circuits"] = [] if not name_of_circuits: raise ValueError('"name_of_circuits" must be specified') if isinstance(name_of_circuits, str): name_of_circuits = [name_of_circuits] for name in name_of_circuits: if name not in self.__quantum_program: raise QISKitError('circuit "{0}" not found in program'.format(name)) if not basis_gates: basis_gates = "u1,u2,u3,cx,id" # QE target basis # TODO: The circuit object going into this is to have .qasm() method (be careful) circuit = self.__quantum_program[name] dag_circuit, final_layout = openquantumcompiler.compile(circuit.qasm(), basis_gates=basis_gates, coupling_map=coupling_map, initial_layout=initial_layout, silent=silent, get_layout=True) # making the job to be added to qobj job = {} job["name"] = name # config parameters used by the runner if config is None: config = {} # default to empty config dict job["config"] = config # TODO: Jay: make config options optional for different backends job["config"]["coupling_map"] = mapper.coupling_dict2list(coupling_map) # Map the layout to a format that can be json encoded list_layout = None if final_layout: list_layout = [[k, v] for k, v in final_layout.items()] job["config"]["layout"] = list_layout job["config"]["basis_gates"] = basis_gates if seed is None: job["config"]["seed"] = None else: job["config"]["seed"] = seed # the compiled circuit to be run saved as a dag job["compiled_circuit"] = openquantumcompiler.dag2json(dag_circuit, basis_gates=basis_gates) job["compiled_circuit_qasm"] = dag_circuit.qasm(qeflag=True) # add job to the qobj qobj["circuits"].append(job) return qobj