def from_qasm(self, qasm_str):
xacc_ir = xacc.getCompiler('staq').compile(qasm_str).getComposites()[0]
pyxasm = xacc.getCompiler('pyxasm').translate(xacc_ir)
pyxasm = pyxasm.replace('__translate_qrg__', self.qreg_name)
pyxasm = '\n'.join(self.TAB+line for line in pyxasm.split('\n'))
processed_str = pyxasm
self.qjit_str += processed_str
def initialize(self, options):
self.qobj_compiler = xacc.getCompiler('qobj')
if 'shots' in options:
self.shots = options['shots']
if 'backend' in options:
self.backend = options['backend']
import json
from qiskit.providers.models.backendproperties import BackendProperties
from qiskit.providers.aer import noise
self.modeled_qpu = xacc.getAccelerator('ibm:' + self.backend)
props = self.modeled_qpu.getProperties()
jsonStr = props['total-json']
# print("jsonStr: \n", jsonStr)
properties = BackendProperties.from_dict(json.loads(jsonStr))
ro_error = True if 'readout_error' in options and options[
'readout_error'] else False
rel = True if 'thermal_relaxation' in options and options[
'thermal_relaxation'] else False
ge = True if 'gate_error' in options and options[
'gate_error'] else False
self.noise_model = noise.NoiseModel.from_backend(
backend,
readout_error=ro_error,
thermal_relaxation=rel,
gate_error=ge)
def apply(self, program, accelerator, options):
# Import qiskit modules here so that users
# who don't have qiskit can still use rest of xacc
from qiskit import QuantumCircuit, transpile
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import CXCancellation
# Map CompositeInstruction program to OpenQasm string
openqasm_compiler = xacc.getCompiler('openqasm')
src = openqasm_compiler.translate(program).replace('\\', '')
# Create a QuantumCircuit
circuit = QuantumCircuit.from_qasm_str(src)
# Create the PassManager and run the pass
pass_manager = PassManager()
pass_manager.append(CXCancellation())
out_circuit = transpile(circuit, pass_manager=pass_manager)
# Map the output to OpenQasm and map to XACC IR
out_src = out_circuit.qasm()
out_src = '__qpu__ void ' + program.name(
) + '(qbit q) {\n' + out_src + "\n}"
out_prog = openqasm_compiler.compile(out_src,
accelerator).getComposites()[0]
# update the given program CompositeInstruction reference
program.clear()
for inst in out_prog.getInstructions():
program.addInstruction(inst)
return
def openqasm(self, *args):
"""
Return an OpenQasm string representation of this
quantum kernel.
"""
kernel = self.extract_composite(*args)
staq = xacc.getCompiler('staq')
return staq.translate(kernel)
def apply(self, program, accelerator, options):
# Import qiskit modules here so that users
# who don't have qiskit can still use rest of xacc
from pyzx.circuit import Circuit
from pyzx import simplify, extract, optimize
# Map CompositeInstruction program to OpenQasm string
openqasm_compiler = xacc.getCompiler('staq')
src = openqasm_compiler.translate(program).replace('\\','')
measures = []
lines = src.split('\n')
for l in lines:
if 'measure' in l or 'creg' in l:
measures.append(l)
c = Circuit.from_qasm(src)
g = c.to_graph()
simplify.full_reduce(g,quiet=True)
c2 = extract.extract_circuit(g)
c3 = optimize.basic_optimization(c2.to_basic_gates())
c3 = c3.to_basic_gates()
c3 = c3.split_phase_gates()
output = c3.to_qasm()
for measure in measures:
output += '\n' + measure
# Map the output to OpenQasm and map to XACC IR
out_prog = openqasm_compiler.compile(output, accelerator).getComposites()[0]
# update the given program CompositeInstruction reference
program.clear()
for inst in out_prog.getInstructions():
program.addInstruction(inst)
return
async def execute_qpu_request(*args, **kwargs):
fin = open('.tmp_quil_code', 'r')
lines = fin.readlines()
fin.close()
seen_quil_code = '__qpu__ void test(qreg q) {\n'
for l in lines:
if 'num_shots' in l:
shots = int(l.split('=')[1])
elif 'DECLARE' in l:
continue
else:
seen_quil_code += l
seen_quil_code += '}'
os.remove('.tmp_quil_code')
program = xacc.getCompiler('quil').compile(
seen_quil_code).getComposites()[0]
b = xacc.qalloc(program.nLogicalBits())
xacc.getAccelerator('qpp', {'shots': shots}).execute(b, program)
print(b)
fout = open('.tmp_results', 'w')
fout.write(str(b))
fout.close()
return "JOBIDHERE"
def execute_one_qasm(self, buffer, program):
import cirq
staq = xacc.getCompiler('staq')
cirq_code = staq.translate(program, {'lang-type':'cirq'})
cirq_code = cirq_code[0:len(cirq_code)-15]
exec(cirq_code, globals(), globals())
# Now we have a circuit variable for execution with Cirq
simulator = cirq.Simulator()
result = simulator.run(circuit, repetitions=self.shots)
import re
qbit2keys = {}
for qq in q:
m = re.search(r"\[([0-9_]+)\]", str(qq))
qbit2keys[int(m.group(1))] = str(qq).replace('[', '_c[')
bs = []
for i in range(self.shots):
b = [0 for i in range(buffer.size())]
for k,v in qbit2keys.items():
b[k] = result._measurements[v][i][0]
bs.append(''.join([str(bb) for bb in b]))
[buffer.appendMeasurement(bb) for bb in bs]
def initialize(self, options):
self.openqasm_compiler = xacc.getCompiler('staq')
self.openqasm_compiler.setExtraOptions({'no-optimize': True})
return
def execute(self, inputParams):
"""
This method is intended to be inherited by vqe and vqe_energy subclasses to allow algorithm-specific implementation.
This superclass method adds extra information to the buffer and allows XACC settings options to be set before executing VQE.
Parameters:
inputParams : dictionary
a dictionary of input parameters obtained from .ini file
return QPU Accelerator buffer
Options used (obtained from inputParams):
'qubit-map': map of logical qubits to physical qubits
'n-execs': number of sampler executions of measurements
'initial-parameters': list of initial parameters for the VQE algorithm
'restart-from-file': AcceleratorDecorator option to allow restart of VQE algorithm
'readout-error': AcceleratorDecorator option for readout-error mitigation
"""
m = xacc.HeterogeneousMap()
if 'shots' in inputParams:
m.insert('shots', int(inputParams['shots']))
if 'backend' in inputParams:
m.insert('backend', inputParams['backend'])
self.qpu = xacc.getAccelerator(inputParams['accelerator'], m)
xaccOp = self.hamiltonian_generators[
inputParams['hamiltonian-generator']].generate(inputParams)
self.ansatz = self.ansatz_generators[inputParams['name']].generate(
inputParams, xaccOp.nBits())
if 'qubit-map' in inputParams:
qubit_map = ast.literal_eval(inputParams['qubit-map'])
xaccOp, self.ansatz, n_qubits = xaccvqe.mapToPhysicalQubits(
xaccOp, self.ansatz, qubit_map)
else:
n_qubits = xaccOp.nBits()
self.op = xaccOp
self.n_qubits = n_qubits
# create buffer, add some extra info (hamiltonian, ansatz-qasm, python-ansatz-qasm)
self.buffer = xacc.qalloc(n_qubits)
self.buffer.addExtraInfo('hamiltonian', self.op.toString())
self.buffer.addExtraInfo(
'ansatz-qasm',
self.ansatz.toString().replace('\\n', '\\\\n'))
pycompiler = xacc.getCompiler('pyxasm')
# self.buffer.addExtraInfo('ansatz-qasm-py', '\n'.join(pycompiler.translate(self.ansatz).split('\n')[1:]))
# heres where we can set up the algorithm Parameters
# all versions of vqe require: Accelerator, Ansatz, Observable
# pure-vqe requires Optimizer
# energy calculation has optional Parameters - can be random
self.vqe_options_dict = {
'accelerator': self.qpu,
'ansatz': self.ansatz,
'observable': self.op
}
# get optimizers for VQE
# needs to check if optimizer is a python plugin
# if not, use nlopt (with options)
# so we pull 'optimizer-options' out if available
# Optimizer-options needs to be passed to BOTH XACC Core optimizers and to python plugins
# vqe_options_dict is used to initialize the algorithms
self.optimizer = None
self.optimizer_options = {}
if 'optimizer-options' in inputParams:
self.optimizer_options = ast.literal_eval(
inputParams['optimizer-options'])
# initial-parameters for optimizer (vqe)
# parameters for vqe-energy
if 'initial-parameters' in inputParams:
self.optimizer_options['initial-parameters'] = ast.literal_eval(
inputParams['initial-parameters'])
if 'parameters' in inputParams:
self.optimizer_options['parameters'] = ast.literal_eval(
inputParams['parameters'])
if 'nlopt-maxeval' in inputParams:
self.optimizer_options['nlopt-maxeval'] = int(
inputParams['nlopt-maxeval'])
# check to see if optimizer is a python plugin
# if it is, we do not put it in self.vqe_options_dict
# if it is not, it is put there
if 'optimizer' in inputParams:
if inputParams['optimizer'] in self.vqe_optimizers:
self.optimizer = self.vqe_optimizers[inputParams['optimizer']]
else:
self.optimizer = xacc.getOptimizer(inputParams['optimizer'],
self.optimizer_options)
else:
self.optimizer = xacc.getOptimizer('nlopt', self.optimizer_options)
# vqe.py then will check vqe_options_dict for optimizer; if it isn't there, run python optimizer
# and of course if it is, we run with XACC
self.buffer.addExtraInfo('accelerator', inputParams['accelerator'])
# need to make sure the AcceleratorDecorators work correctly
if 'n-execs' in inputParams:
xacc.setOption('sampler-n-execs', inputParams['n-execs'])
self.qpu = xacc.getAcceleratorDecorator('improved-sampling',
self.qpu)
if 'restart-from-file' in inputParams:
xacc.setOption('vqe-restart-file',
inputParams['restart-from-file'])
self.qpu = xacc.getAcceleratorDecorator('vqe-restart', self.qpu)
self.qpu.initialize()
if 'readout-error' in inputParams and inputParams['readout-error']:
self.qpu = xacc.getAcceleratorDecorator('ro-error', self.qpu)
if 'rdm-purification' in inputParams and inputParams[
'rdm-purification']:
print("setting RDM Purification")
self.qpu = xacc.getAcceleratorDecorator('rdm-purification',
self.qpu)
m = xacc.HeterogeneousMap()
m.insert('fermion-observable', self.op)
self.qpu.initialize(m)
self.vqe_options_dict = {
'optimizer': self.optimizer,
'accelerator': self.qpu,
'ansatz': self.ansatz,
'observable': self.op
}
xacc.setOptions(inputParams)
def execute(self, inputParams):
"""
This method is intended to be inherited by vqe and vqe_energy subclasses to allow algorithm-specific implementation.
This superclass method adds extra information to the buffer and allows XACC settings options to be set before executing VQE.
Parameters:
inputParams : dictionary
a dictionary of input parameters obtained from .ini file
return QPU Accelerator buffer
Options used (obtained from inputParams):
'qubit-map': map of logical qubits to physical qubits
'n-execs': number of sampler executions of measurements
'initial-parameters': list of initial parameters for the VQE algorithm
'restart-from-file': AcceleratorDecorator option to allow restart of VQE algorithm
'readout-error': AcceleratorDecorator option for readout-error mitigation
"""
self.qpu = xacc.getAccelerator(inputParams['accelerator'])
xaccOp = self.hamiltonian_generators[
inputParams['hamiltonian-generator']].generate(inputParams)
self.ansatz = self.ansatz_generators[inputParams['name']].generate(
inputParams, xaccOp.nQubits())
if 'qubit-map' in inputParams:
qubit_map = ast.literal_eval(inputParams['qubit-map'])
xaccOp, self.ansatz, n_qubits = xaccvqe.mapToPhysicalQubits(
xaccOp, self.ansatz, qubit_map)
else:
n_qubits = xaccOp.nQubits()
self.op = xaccOp
self.n_qubits = n_qubits
self.buffer = self.qpu.createBuffer('q', n_qubits)
self.buffer.addExtraInfo('hamiltonian', str(xaccOp))
self.buffer.addExtraInfo(
'ansatz-qasm',
self.ansatz.toString('q').replace('\\n', '\\\\n'))
pycompiler = xacc.getCompiler('xacc-py')
self.buffer.addExtraInfo(
'ansatz-qasm-py',
'\n'.join(pycompiler.translate('q', self.ansatz).split('\n')[1:]))
self.optimizer = None
self.optimizer_options = {}
if 'optimizer' in inputParams:
if inputParams['optimizer'] in self.vqe_optimizers:
self.optimizer = self.vqe_optimizers[inputParams['optimizer']]
if 'method' in inputParams:
self.optimizer_options['method'] = inputParams['method']
if 'options' in inputParams:
self.optimizer_options['options'] = ast.literal_eval(
inputParams['options'])
if 'user-params' in inputParams:
self.optimizer_options['options'][
'user_params'] = ast.literal_eval(
inputParams['user-params'])
else:
xacc.setOption('vqe-backend', inputParams['optimizer'])
else:
xacc.info(
"No classical optimizer specified. Setting to default XACC optimizer."
)
self.buffer.addExtraInfo('accelerator', inputParams['accelerator'])
if 'n-execs' in inputParams:
xacc.setOption('sampler-n-execs', inputParams['n-execs'])
self.qpu = xacc.getAcceleratorDecorator('improved-sampling',
self.qpu)
if 'restart-from-file' in inputParams:
xacc.setOption('vqe-restart-file',
inputParams['restart-from-file'])
self.qpu = xacc.getAcceleratorDecorator('vqe-restart', self.qpu)
self.qpu.initialize()
if 'readout-error' in inputParams and inputParams['readout-error']:
self.qpu = xacc.getAcceleratorDecorator('ro-error', self.qpu)
if 'rdm-purification' in inputParams and inputParams[
'rdm-purification']:
self.qpu = xacc.getAcceleratorDecorator('rdm-purification',
self.qpu)
self.vqe_options_dict = {
'accelerator': self.qpu,
'ansatz': self.ansatz
}
if 'initial-parameters' in inputParams:
self.vqe_options_dict['vqe-params'] = ','.join([
str(x)
for x in ast.literal_eval(inputParams['initial-parameters'])
])
xacc.setOptions(inputParams)
if loadResult is True:
qpu = xacc.getAccelerator('QuaC', {
'system-model': model.name(),
'logging-period': 0.1
})
channelConfigs = xacc.BackendChannelConfigs()
T = 5.0
channelConfigs.dt = 0.01
# Krotov will be able to compute things even without resonance
# i.e. it will figure out how to modulate things into resonance (if needed)
channelConfigs.loFregs_dChannels = [0.0]
model.setChannelConfigs(channelConfigs)
# Get the XASM compiler
xasmCompiler = xacc.getCompiler('xasm')
# Composite to be transform to pulse: X gate = H-Z-H
ir = xasmCompiler.compile(
'''__qpu__ void f(qbit q) {
Ry(q[0], pi/2);
X(q[0]);
}''', qpu)
program = ir.getComposites()[0]
# Run the pulse IRTransformation
optimizer = xacc.getIRTransformation('quantum-control')
optimizer.apply(
program,
qpu,
{
# Using the Python-contributed pulse optimizer
