def __init__(self, q_jobs, callback, max_workers=1):
"""
Args:
q_jobs (list(QuantumJob)): List of QuantumJob objects.
callback (fn(results)): The function that will be called when all
jobs finish. The signature of the function must be:
fn(results)
results: A list of Result objects.
max_workers (int): The maximum number of workers to use.
Raises:
QISKitError: if any of the job backends could not be found.
"""
self.q_jobs = q_jobs
self.max_workers = max_workers
# check whether any jobs are remote
self.online = any(qj.backend not in local_backends() for qj in q_jobs)
self.futures = {}
self.lock = Lock()
# Set a default dummy callback just in case the user doesn't want
# to pass any callback.
self.callback = (lambda rs: ()) if callback is None else callback
self.num_jobs = len(self.q_jobs)
self.jobs_results = []
if self.online:
# verify backends across all jobs
for q_job in q_jobs:
if q_job.backend not in remote_backends() + local_backends():
raise QISKitError("Backend %s not found!" % q_job.backend)
if self.online:
# I/O intensive -> use ThreadedPoolExecutor
self.executor_class = futures.ThreadPoolExecutor
else:
# CPU intensive -> use ProcessPoolExecutor
self.executor_class = futures.ProcessPoolExecutor
def test_local_backends(self):
available_backends = local_backends()
self.log.info(
'The discovered local devices are: {}'.format(available_backends))
# Some local backends should always be present.
self.assertIn('local_qasm_simulator', available_backends)
self.assertIn('local_unitary_simulator', available_backends)
def test_local_backends(self):
available_backends = local_backends()
self.log.info('The discovered local devices are: {}'.format(
available_backends))
# Some local backends should always be present.
self.assertIn('local_qasm_simulator', available_backends)
self.assertIn('local_unitary_simulator', available_backends)
def _create_qobj(self, circuits, circuit_config, backend, seed,
resources, shots, do_compile):
# local and remote backends currently need different
# compilied circuit formats
formatted_circuits = []
if do_compile:
for circuit in circuits:
formatted_circuits.append(None)
else:
if backend in backends.local_backends():
for circuit in self.circuits:
basis = ['u1', 'u2', 'u3', 'cx', 'id']
unroller = Unroller
# TODO: No instanceof here! Refactor this class
if isinstance(circuit, DAGCircuit):
unroller = DagUnroller
elif isinstance(circuit, QuantumCircuit):
# TODO: We should remove this code path (it's redundant and slow)
circuit = Qasm(data=circuit.qasm()).parse()
unroller_instance = unroller(circuit, JsonBackend(basis))
compiled_circuit = unroller_instance.execute()
formatted_circuits.append(compiled_circuit)
else:
for circuit in self.circuits:
formatted_circuits.append(circuit.qasm(qeflag=True))
# create circuit component of qobj
circuit_records = []
if circuit_config is None:
config = {'coupling_map': None,
'basis_gates': 'u1,u2,u3,cx,id',
'layout': None,
'seed': seed}
circuit_config = [config] * len(self.circuits)
for circuit, fcircuit, name, config in zip(self.circuits,
formatted_circuits,
self.names,
circuit_config):
record = {
'name': name,
'compiled_circuit': None if do_compile else fcircuit,
'compiled_circuit_qasm': None if do_compile else fcircuit,
'circuit': circuit,
'config': config
}
circuit_records.append(record)
return {'id': self._generate_job_id(length=10),
'config': {
'max_credits': resources['max_credits'],
'shots': shots,
'backend': backend
},
'circuits': circuit_records}
def __init__(self,
q_jobs,
callback,
max_workers=1,
token=None,
url=None,
api=None):
"""
Args:
q_jobs (list(QuantumJob)): List of QuantumJob objects.
callback (fn(results)): The function that will be called when all
jobs finish. The signature of the function must be:
fn(results)
results: A list of Result objects.
max_workers (int): The maximum number of workers to use.
token (str): Server API token
url (str): Server URL.
api (IBMQuantumExperience): API instance to use. If set,
/token/ and /url/ are ignored.
"""
self.q_jobs = q_jobs
self.max_workers = max_workers
# check whether any jobs are remote
self._local_backends = backends.local_backends()
self.online = any(qj.backend not in self._local_backends
for qj in q_jobs)
self.futures = {}
self.lock = Lock()
# Set a default dummy callback just in case the user doesn't want
# to pass any callback.
self.callback = (lambda rs: ()) if callback is None else callback
self.num_jobs = len(self.q_jobs)
self.jobs_results = []
if self.online:
self._api = api if api else IBMQuantumExperience(
token, {"url": url}, verify=True)
self._online_backends = remote_backends(self._api)
# Check for the existance of the backend
for q_job in q_jobs:
if q_job.backend not in self._online_backends + self._local_backends:
raise QISKitError("Backend %s not found!" % q_job.backend)
self._api_config = {}
self._api_config["token"] = token
self._api_config["url"] = {"url": url}
else:
self._api = None
self._online_backends = None
self._api_config = None
if self.online:
# I/O intensive -> use ThreadedPoolExecutor
self.executor_class = futures.ThreadPoolExecutor
else:
# CPU intensive -> use ProcessPoolExecutor
self.executor_class = futures.ProcessPoolExecutor
def _create_qobj(self, circuits, circuit_config, backend, seed, resources,
shots, do_compile):
# local and remote backends currently need different
# compilied circuit formats
formatted_circuits = []
if do_compile:
for circuit in circuits:
formatted_circuits.append(None)
else:
if backend in backends.local_backends():
for circuit in self.circuits:
formatted_circuits.append(
openquantumcompiler.dag2json(circuit))
else:
for circuit in self.circuits:
formatted_circuits.append(circuit.qasm(qeflag=True))
# create circuit component of qobj
circuit_records = []
if circuit_config is None:
config = {
'coupling_map': None,
'basis_gates': 'u1,u2,u3,cx,id',
'layout': None,
'seed': seed
}
circuit_config = [config] * len(self.circuits)
for circuit, fcircuit, name, config in zip(self.circuits,
formatted_circuits,
self.names, circuit_config):
record = {
'name': name,
'compiled_circuit': None if do_compile else fcircuit,
'compiled_circuit_qasm': None if do_compile else fcircuit,
'circuit': circuit,
'config': config
}
circuit_records.append(record)
return {
'id': self._generate_job_id(length=10),
'config': {
'max_credits': resources['max_credits'],
'shots': shots,
'backend': backend
},
'circuits': circuit_records
}
def _create_qobj(self, circuits, circuit_config, backend, seed,
resources, shots, do_compile):
# local and remote backends currently need different
# compilied circuit formats
formatted_circuits = []
if do_compile:
for circuit in circuits:
formatted_circuits.append(None)
else:
if backend in backends.local_backends():
for circuit in self.circuits:
formatted_circuits.append(openquantumcompiler.dag2json(circuit))
else:
for circuit in self.circuits:
formatted_circuits.append(circuit.qasm(qeflag=True))
# create circuit component of qobj
circuit_records = []
if circuit_config is None:
config = {'coupling_map': None,
'basis_gates': 'u1,u2,u3,cx,id',
'layout': None,
'seed': seed}
circuit_config = [config] * len(self.circuits)
for circuit, fcircuit, name, config in zip(self.circuits,
formatted_circuits,
self.names,
circuit_config):
record = {
'name': name,
'compiled_circuit': None if do_compile else fcircuit,
'compiled_circuit_qasm': None if do_compile else fcircuit,
'circuit': circuit,
'config': config
}
circuit_records.append(record)
return {'id': self._generate_job_id(length=10),
'config': {
'max_credits': resources['max_credits'],
'shots': shots,
'backend': backend
},
'circuits': circuit_records}
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)
from qiskit import QuantumProgram
import Qconfig
from qiskit.backends import local_backends
from pprint import pprint
local_backends()
backend = 'local_qasm_simulator'
qp = QuantumProgram()
qp.set_api(Qconfig.APItoken, Qconfig.config['url'])
qr = qp.create_quantum_register('qr', 2)
cr = qp.create_classical_register('cr', 2)
qc = qp.create_circuit('Bell', [qr], [cr])
qc.h(qr[0])
qc.cx(qr[0], qr[1])
qc.measure(qr[0], cr[0])
qc.measure(qr[1], cr[1])
source = qp.get_qasm('Bell')
print(source)
#result = qp.execute('Bell')
circuits = ['Bell']
qobj = qp.compile(circuits, backend)
result = qp.run(qobj, wait=2, timeout=240)
bv.x(tmp[0])
bv.h(q)
bv.h(tmp)
bv += oracle
bv.h(q)
bv.h(tmp)
bv.measure(q, res)
print(bv.qasm())
from qiskit.tools.visualization import circuit_drawer
circuit_drawer(bv)
from qiskit import QuantumProgram
qp = QuantumProgram()
qp.add_circuit(quantum_circuit=bv, name='bv')
from qiskit import backends
print(backends.local_backends())
print(backends.remote_backends())
import Qconfig
qp.set_api(Qconfig.APItoken, Qconfig.config['url'])
result = qp.execute('bv', backend='ibmqx4', timeout=3600)
counts = result.get_counts('bv')
print(counts)
from qiskit.tools.visualization import plot_histogram
plot_histogram(counts)
