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
