def test_simple_bell(self): try: q = xacc.qalloc(2) self.qpu.execute(q, self.bell) print(q) except: print('Failure in bell test - shutting down the server') requests.post("http://localhost:64574/shutdown") time.sleep(2)
def test_simple_hadamard(self): try: q = xacc.qalloc(1) self.qpu.execute(q, self.super) print(q) except: print('Failure in hadamard test - shutting down the server') requests.post("http://localhost:64574/shutdown") time.sleep(2)
def runVqeGradientDescent(gradientStrategy): # Get access to the desired QPU and # allocate some qubits to run on qpu = xacc.getAccelerator('qpp') # Construct the Hamiltonian as an XACC PauliOperator ham = xacc.getObservable('pauli', '1.0 Y0') # Ansatz circuit: xacc.qasm('''.compiler xasm .circuit ansatz .qbit q .parameters t0, t1, t2, t3 // State-prep Ry(q[0], pi/4); Ry(q[1], pi/3); Ry(q[2], pi/7); // Parametrized gates (layer 1) Rz(q[0], t0); Rz(q[1], t1); CX(q[0], q[1]); CX(q[1], q[2]); // Parametrized gates (layer 2) Ry(q[1], t2); Rx(q[2], t3); CX(q[0], q[1]); CX(q[1], q[2]); ''') # We need 4 qubits buffer = xacc.qalloc(4) ansatz_circuit = xacc.getCompiled('ansatz') initParams = [0.432, -0.123, 0.543, 0.233] opt = xacc.getOptimizer( 'mlpack', { # Using gradient descent: 'mlpack-optimizer': 'gd', 'initial-parameters': initParams, 'mlpack-step-size': 0.01, 'mlpack-max-iter': 200 }) # Create the VQE algorithm with the requested gradient strategy vqe = xacc.getAlgorithm( 'vqe', { 'ansatz': ansatz_circuit, 'accelerator': qpu, 'observable': ham, 'optimizer': opt, 'gradient_strategy': gradientStrategy }) vqe.execute(buffer) energies = buffer.getInformation('params-energy') return energies
def execute(self, buffer, programs): if isinstance(programs, list) and len(programs) > 1: for p in programs: tmpBuffer = xacc.qalloc(buffer.size()) tmpBuffer.setName(p.name()) self.execute_one_qasm(tmpBuffer, p) buffer.appendChild(p.name(),tmpBuffer) else: if isinstance(programs, list): programs = programs[0] self.execute_one_qasm(buffer, programs)
def execute(self, buffer, programs): # Translate IR to a Qobj Json String if isinstance(programs, list) and len(programs) > 1: for p in programs: tmpBuffer = xacc.qalloc(buffer.size()) tmpBuffer.setName(p.name()) self.execute_single(tmpBuffer, p) buffer.appendChild(p.name(), tmpBuffer) else: if isinstance(programs, list): programs = programs[0] self.execute_single(buffer, programs)
def execute(self, inputParams): xacc_opts = inputParams['XACC'] acc_name = xacc_opts['accelerator'] if 'verbose' in xacc_opts and xacc_opts['verbose']: xacc.set_verbose(True) if 'Benchmark' not in inputParams: xacc.error( 'Invalid benchmark input - must have Benchmark description') if 'Circuit' not in inputParams: xacc.error( 'Invalid benchmark input - must have circuit description') self.qpu = xacc.getAccelerator(acc_name, xacc_opts) if 'Decorators' in inputParams: if 'readout_error' in inputParams['Decorators']: qpu = xacc.getAcceleratorDecorator('ro-error', qpu) provider = xacc.getIRProvider('quantum') if 'source' in inputParams['Circuit']: # here assume this is xasm always src = inputParams['Circuit']['source'] xacc.qasm(src) # get the name of the circuit circuit_name = None for l in src.split('\n'): if '.circuit' in l: circuit_name = l.split(' ')[1] self.circuit_name = circuit_name ansatz = xacc.getCompiled(circuit_name) opts = {'circuit': ansatz, 'accelerator': self.qpu} if 'qubit-map' in inputParams['Circuit']: raw_qbit_map = inputParams['Circuit']['qubit-map'] if not isinstance(raw_qbit_map, list): raw_qbit_map = ast.literal_eval(raw_qbit_map) self.qubit_map = raw_qbit_map opts['qubit-map'] = self.qubit_map self.qpt = xacc.getAlgorithm('qpt', opts) self.nq = ansatz.nLogicalBits() buffer = xacc.qalloc(ansatz.nLogicalBits()) self.qpt.execute(buffer) return buffer
def noisy_sim(circ: QuantumCircuit): # Convert circ to a CompositeInstruction out_src = circ.qasm() # print('hello src:\n', out_src) out_prog = self.openqasm_compiler.compile( out_src).getComposites()[0] # print('after compile:\n', out_prog.toString()) # Execute on a tmp buffer tmp_buffer = xacc.qalloc(buffer.size()) self.decoratedAccelerator.execute(tmp_buffer, out_prog) # record the noisy exp val buffer.addExtraInfo('noisy-exp-val-z', tmp_buffer.getExpectationValueZ()) buffer.appendChild('mitiq-noisy-exec-' + buffer.name(), tmp_buffer) return tmp_buffer.getExpectationValueZ()
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"
.circuit teleport .qbit q X(q[0]); // Bell channel setup H(q[1]); CX(q[1], q[2]); // Alice Bell measurement CX(q[0], q[1]); H(q[0]); Measure(q[0]); Measure(q[1]); // Correction if (q[0]) { Z(q[2]); } if (q[1]) { X(q[2]); } // Measure teleported qubit Measure(q[2]); ''') teleport = xacc.getCompiled('teleport') q = xacc.qalloc(3) qq = xacc.qalloc() qpu.execute(q, teleport) print(q)
import xacc # Noise model string for a simple depolarizing noise. depol_json = """{"gate_noise": [{"gate_name": "X", "register_location": ["0"], "noise_channels": [{"matrix": [[[[0.99498743710662, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.99498743710662, 0.0]]], [[[0.0, 0.0], [0.05773502691896258, 0.0]], [[0.05773502691896258, 0.0], [0.0, 0.0]]], [[[0.0, 0.0], [0.0, -0.05773502691896258]], [[0.0, 0.05773502691896258], [0.0, 0.0]]], [[[0.05773502691896258, 0.0], [0.0, 0.0]], [[0.0, 0.0], [-0.05773502691896258, 0.0]]]]}]}], "bit_order": "MSB"}""" noise_model = xacc.getNoiseModel("json", {"noise-model": depol_json}) # Using Aer simulator in density matrix mode. # Note: toJson() will convert the noise_model to IBM format to use w/ Aer qpu = xacc.getAccelerator('aer', { "noise-model": noise_model.toJson(), "sim-type": "density_matrix" }) # Define the quantum kernel in standard Python @xacc.qpu(accelerator=qpu) def test(q): X(q[0]) q = xacc.qalloc(1) # run the circuit test(q) # print the density matrix (flattened) print(q["density_matrix"])
# Demonstrate mid-circuit measurement support # GHZ to Bell conversion # Adapted from: # https://quantum-computing.ibm.com/docs/manage/systems/midcircuit-measurement/#GHZ-to-Bell-State import xacc # Mid-circuit measurement is supportted by: # - Simulator: qpp, qsim, aer # - Selected IBM backends. # qpu = xacc.getAccelerator('aer', {"shots": 1024}) qpu = xacc.getAccelerator('qpp', {"shots": 1024}) q = xacc.qalloc(3) xacc.qasm(''' .compiler xasm .circuit ghz_to_bell .qbit q H(q[2]); CX(q[2], q[1]); CX(q[1], q[0]); // Z -> X basis H(q[0]); // Mid-circuit measurement => Bell state Measure(q[0]); CX(q[2], q[1]); H(q[2]); X(q[0]); Measure(q[0]); Measure(q[1]); Measure(q[2]);
# Horizontal axis: 0 -> 2.5 # The number of Trotter steps nbSteps = 25 # The Trotter step size stepSize = 0.1 # Create the QITE algorithm qite = xacc.getAlgorithm('qite', { 'accelerator': qpu, 'observable': ham, 'step-size': stepSize, 'steps': nbSteps }) # We just need 1 qubit qiteBuffer = xacc.qalloc(1) qiteResult = qite.execute(qiteBuffer) # Create the QLanczos algorithm qLanczos = xacc.getAlgorithm('QLanczos', { 'accelerator': qpu, 'observable': ham, 'step-size': stepSize, 'steps': nbSteps }) qLanczosBuffer = xacc.qalloc(1) qLanczosResult = qLanczos.execute(qLanczosBuffer) # Plot the energies qiteEnergies = qiteBuffer.getInformation('exp-vals') qLanczosEnergies = qLanczosBuffer.getInformation('exp-vals')
import xacc # Get reference to the desired QPU qpu = xacc.getAccelerator('tnqvm') # Allocate some qubits qbits = xacc.qalloc(4) # Create the H2 4 qubit hamiltonian # note, first run 'python3 -m xacc --benchmark-install chemistry' hamiltonianService = xacc.serviceRegistry.get_service('hamiltonian_generator', 'xaccKernelH2') obs = hamiltonianService.generate({}) # Create the UCC-1 ansatz ansatzService = xacc.serviceRegistry.get_service('ansatz_generator', 'ucc1') ucc1 = ansatzService.generate({'x-gates': [0, 1]}, 4) # Create the RDM Purification decorator error mitigation strategy # and give it the fermionic representation qpu_decorator = xacc.getAcceleratorDecorator('rdm-purification', qpu) qpu_decorator.initialize({'fermion-observable': obs}) # Let's use the NLOpt optimizer opt = xacc.getOptimizer('nlopt') # Create the VQE algorithm vqe = xacc.getAlgorithm( 'vqe', { 'ansatz': ucc1, 'accelerator': qpu_decorator,
Rz(q[0], -pi/2); } H(q[0]); Measure(q[0], c[2]); Reset(q[0]); H(q[0]); CPhase(q[0], q[1], -5*pi/8); if(c[0]) { Rz(q[0], -pi/8); } if(c[1]) { Rz(q[0], -pi/4); } if(c[2]) { Rz(q[0], -pi/2); } H(q[0]); Measure(q[0], c[3]); ''') f = xacc.getCompiled('iterative_qpe') print(f.toString()) # qpu = xacc.getAccelerator('qpp', {'shots':1024}) qpu = xacc.getAccelerator('aer', {'shots': 1024}) # With noise # Note: IBMQ doesn't support bfunc (conditional) instruction atm, # hence, we can only do simulation of the QObj. # qpu = xacc.getAccelerator('aer:ibmq_manhattan', {'shots':1024}) q = xacc.qalloc(2) qpu.execute(q, f) print(q)
from pyquil.gates import CNOT, H, MEASURE from pyquil import get_qc, Program import xacc import qiskit circ = qiskit.QuantumCircuit(2, 2) circ.h(0) circ.cx(0, 1) circ.measure([0, 1], [0, 1]) qpu = xacc.getAccelerator('qpp', {'shots': 1024}) q = xacc.qalloc(2) qpu.execute(q, circ) print(q) p = Program() p += H(0) p += CNOT(0, 1) ro = p.declare('ro', 'BIT', 2) p += MEASURE(0, ro[0]) p += MEASURE(1, ro[1]) r = xacc.qalloc(2) qpu.execute(r, p) print(r) provider = xacc.getIRProvider('quantum')
def execute(self, inputParams): xacc_opts = inputParams['XACC'] acc_name = xacc_opts['accelerator'] qpu = xacc.getAccelerator(acc_name, xacc_opts) if 'verbose' in xacc_opts and xacc_opts['verbose']: xacc.set_verbose(True) if 'Benchmark' not in inputParams: xacc.error('Invalid benchmark input - must have Benchmark description') if 'Observable' not in inputParams: xacc.error('Invalid benchmark input - must have Observable description') if 'Ansatz' not in inputParams: xacc.error('Invalid benchmark input - must have Ansatz circuit description') if 'Decorators' in inputParams: if 'readout_error' in inputParams['Decorators']: qpu = xacc.getAcceleratorDecorator('ro-error', qpu) H = None if inputParams['Observable']['name'] == 'pauli': obs_str = inputParams['Observable']['obs_str'] H = xacc.getObservable('pauli', obs_str) elif inputParams['Observable']['name'] == 'fermion': obs_str = inputParams['Observable']['obs_str'] H = xacc.getObservable('fermion', obs_str) elif inputParams['Observable']['name'] == 'psi4': opts = {'basis':inputParams['Observable']['basis'], 'geometry':inputParams['Observable']['geometry']} if 'fo' in inputParams['Observable'] and 'ao' in inputParams['Observable']: opts['frozen-spin-orbitals'] = ast.literal_eval(inputParams['Observable']['fo']) opts['active-spin-orbitals'] = ast.literal_eval(inputParams['Observable']['ao']) H = xacc.getObservable('psi4', opts) #print('Ham: ', H.toString()) buffer = xacc.qalloc(H.nBits()) optimizer = None if 'Optimizer' in inputParams: # check that values that can be ints/floats are opts = inputParams['Optimizer'] for k,v in inputParams['Optimizer'].items(): try: i = int(v) opts[k] = i continue except: pass try: f = float(v) opts[k] = f continue except: pass optimizer = xacc.getOptimizer(inputParams['Optimizer']['name'] if 'Optimizer' in inputParams else 'nlopt', opts) else: optimizer = xacc.getOptimizer('nlopt') provider = xacc.getIRProvider('quantum') if 'source' in inputParams['Ansatz']: # here assume this is xasm always src = inputParams['Ansatz']['source'] xacc.qasm(src) # get the name of the circuit circuit_name = None for l in src.split('\n'): if '.circuit' in l: circuit_name = l.split(' ')[1] ansatz = xacc.getCompiled(circuit_name) else: ansatz = provider.createInstruction(inputParams['Ansatz']['ansatz']) ansatz = xacc.asComposite(ansatz) alg = xacc.getAlgorithm(inputParams['Benchmark']['algorithm'], { 'ansatz': ansatz, 'accelerator': qpu, 'observable': H, 'optimizer': optimizer, }) alg.execute(buffer) return buffer
def execute(self, global_buffer, features, W, bv, bh, options): import numpy as np import tensorflow as tf def set_dwave_couplings(w, bh, bv): n_visible = len(bv) n_hidden = len(bh) # Set Qubo Q = {} for i in range(n_visible): Q[(i, i)] = -1 * bv[i] for i in range(n_hidden): Q[(i + n_visible, i + n_visible)] = -1 * bh[i] for i in range(n_visible): for j in range(n_hidden): Q[(i, n_visible + j)] = -1 * w[i][j] return Q def gibbs_sample(k, x, h, W, bh, bv): """ run sampling k times and return the visible and hidden outputs """ import tensorflow as tf def gibbs_step(xk): """ single gibbs step """ # visible values -> hidden values xk = tf.cast(xk, tf.float32) hk = sample(tf.sigmoid(tf.matmul(xk, W) + bh)) # hidden values -> visible values xk = sample(tf.sigmoid(tf.matmul(hk, tf.transpose(W)) + bv)) return xk, hk for _ in range(k): x, h = gibbs_step(x) return x, h beta = 1. w = W.numpy() hidden_bias = bh.numpy()[0] visible_bias = bv.numpy()[0] n_hidden = len(hidden_bias) n_visible = len(visible_bias) backend = options['backend'] if 'backend' in options else 'dwave-neal' save_embed = options['save_embed'] if 'save_embed' in options else False load_embed = options['load_embed'] if 'load_embed' in options else None n_samples = options['n-samples'] if 'n-samples' in options else 100 num_gibbs_steps = options[ 'n-gibbs-steps'] if 'n-gibbs-steps' in options else 0 j = w / beta hh = hidden_bias / beta hv = visible_bias / beta # Set Qubo Q = set_dwave_couplings(j, hh, hv) QIR = xacc.annealing.create_composite_from_qubo(Q) QIR.setTag("qubo") qpu = xacc.getAccelerator(backend, { 'shots': n_samples, 'mode': 'qubo' }) qbits = xacc.qalloc() if options['embedding'] is not None: qbits.addExtraInfo('embedding', options['embedding']) qpu.execute(qbits, QIR) global_buffer.appendChild(qbits.name(), qbits) # convert observed bit strings to # samples array s = [] measurements = qbits.getMeasurementCounts() for k, v in measurements.items(): arr = np.array(list(map(int, k))) for i in range(v): s.append(arr) samples = np.stack(s, axis=0) num_occurrences = np.ones(n_samples, dtype=int) visibles = samples[:, :n_visible] hidden = samples[:, n_visible:n_visible + n_hidden] visibles = np.repeat(visibles, num_occurrences, axis=0) hidden = np.repeat(hidden, num_occurrences, axis=0) visibles, hidden = gibbs_sample(num_gibbs_steps, visibles, hidden, w, bh, bv) sum_v = np.sum(visibles, axis=0) sum_h = np.sum(hidden, axis=0) sum_vh = np.matmul(np.transpose(visibles), hidden) sum_v = tf.reshape(tf.Variable(sum_v, dtype=tf.float32), (1, n_visible)) sum_h = tf.reshape(tf.Variable(sum_h, dtype=tf.float32), (1, n_hidden)) sum_vh = tf.Variable(sum_vh, dtype=tf.float32) expectation_W = sum_vh / float(n_samples) expectation_v = sum_v / float(n_samples) expectation_h = sum_h / float(n_samples) return expectation_W, expectation_v, expectation_h
optimizer = xacc.getIRTransformation('quantum-control') optimizer.apply( program, qpu, { # Using the Python-contributed pulse optimizer # This will propagate to setOptions() then optimize() # calls on the optimizer implementation. # Note: this is currently doing nothing 'method': 'krotov', 'max-time': T }) # Verify the result # Run the simulation of the optimized pulse program qubitReg = xacc.qalloc(1) qpu.execute(qubitReg, program) print(qubitReg) # Retrieve time-stepping raw data csvFile = qubitReg['csvFile'] data = np.genfromtxt(csvFile, delimiter=',', dtype=float, names=True) fig, ax = plt.subplots(2, 1, sharex=True, figsize=(8, 5)) plt.tight_layout() ax[0].plot(data['Time'], data['Channel0'], 'b', label='$D_0(t)$') ax[1].plot(data['Time'], data['X0'], 'b', label='$\\langle X \\rangle$') ax[1].plot(data['Time'], data['Y0'], 'g', label='$\\langle Y \\rangle$') ax[1].plot(data['Time'], data['Z0'], 'r', label='$\\langle Z \\rangle$') ax[1].plot(data['Time'], data['Population0'], 'k', label='$Prob(1)$') # ax[0].set_xlim([0, 5]) # ax[0].set_ylim([-0.1, 2.0])
import xacc import numpy as np qpu = xacc.getAccelerator('qpp') ham = xacc.getObservable('pauli', '-5.0 - 0.5 Z0 + 1.0 Z0Z1') nbQubits = 2 steps = 1 buffer = xacc.qalloc(nbQubits) nbTotalParams = 4 # The optimizer: nlopt opt = xacc.getOptimizer('nlopt', { 'initial-parameters': np.random.rand(nbTotalParams)} ) # Create the QAOA algorithm qaoa = xacc.getAlgorithm('QAOA', { 'accelerator': qpu, 'observable': ham, 'optimizer': opt, 'steps': steps, 'parameter-scheme': 'Extend'}) # Run result = qaoa.execute(buffer) print('Min value = ', buffer.getInformation('opt-val')) print('Opt-params = ', buffer.getInformation('opt-params')) # Get the circuit qaoa_ansatz_std = xacc.createComposite('qaoa') qaoa_ansatz_std.expand({'nbQubits': nbQubits, 'nbSteps': steps, 'cost-ham': ham, 'parameter-scheme':'Extend'}) print('Extend parameterized QAOA circuit:') print(qaoa_ansatz_std)
def qv_circuits(qubit_lists=None, ntrials=1, qr=None, cr=None): """ Return a list of square quantum volume circuits (depth=width) The qubit_lists is specified as a list of qubit lists. For each set of qubits, circuits the depth as the number of qubits in the list are generated Args: qubit_lists (list): list of list of qubits to apply qv circuits to. Assume the list is ordered in increasing number of qubits ntrials (int): number of random iterations qr (QuantumRegister): quantum register to act on (if None one is created) cr (ClassicalRegister): classical register to measure to (if None one is created) Returns: tuple: A tuple of the type (``circuits``, ``circuits_nomeas``) wheere: ``circuits`` is a list of lists of circuits for the qv sequences (separate list for each trial) and `` circuitss_nomeas`` is the same circuits but with no measurements for the ideal simulation """ circuits = [[] for e in range(ntrials)] circuits_nomeas = [[] for e in range(ntrials)] # get the largest qubit number out of all the lists (for setting the # register) depth_list = [len(qubit_list) for qubit_list in qubit_lists] # go through for each trial for trial in range(ntrials): # go through for each depth in the depth list for depthidx, depth in enumerate(depth_list): n_q_max = np.max(qubit_lists[depthidx]) provider = xacc.getIRProvider('quantum') qr = xacc.qalloc(int(n_q_max + 1)) qr2 = xacc.qalloc(int(depth)) #cr = qiskit.ClassicalRegister(int(depth), 'cr') qc = provider.createComposite('qv_depth_%d_trial_%d' % (depth, trial)) qc2 = provider.createComposite('qv_depth_%d_trial_%d' % (depth, trial)) # build the circuit for _ in range(depth): # Generate uniformly random permutation Pj of [0...n-1] perm = np.random.permutation(depth) # For each pair p in Pj, generate Haar random SU(4) for k in range(int(np.floor(depth / 2))): unitary = random_unitary(4) pair = int(perm[2 * k]), int(perm[2 * k + 1]) haar = provider.createInstruction(unitary, [ qr[qubit_lists[depthidx][pair[0]]], qr[qubit_lists[depthidx][pair[1]]] ]) qc.addInstructions([haar]) qc2.addInstructions([haar]) # append an id to all the qubits in the ideal circuits # to prevent a truncation error in the statevector # simulators #qc2.u1(0, qr2) circuits_nomeas[trial].append(qc2) # add measurement for qind, qubit in enumerate(qubit_lists[depthidx]): qc.measure(qr[qubit], cr[qind]) circuits[trial].append(qc) return circuits, circuits_nomeas
import xacc,sys, numpy as np xacc.set_verbose(True) # Get access to the desired QPU and # allocate some qubits to run on qpu = xacc.getAccelerator('qsim') graph = xacc.getGraph("boost-digraph") nbNodes = 3 random_graph = graph.gen_random_graph(nbNodes, 3.0 / nbNodes) print(random_graph) nbSteps = 1 buffer = xacc.qalloc(nbNodes) opt = xacc.getOptimizer('nlopt') # Create QAOA qaoa = xacc.getAlgorithm('QAOA', { 'accelerator': qpu, 'graph': random_graph, 'optimizer': opt, 'steps': nbSteps, 'parameter-scheme': 'Standard' }) result = qaoa.execute(buffer) print("Max-cut val:", buffer["opt-val"])
import xacc qpu = xacc.getAccelerator('aer') qbits = xacc.qalloc(2) # Create a bell state program with too many cnots xacc.qasm(''' .compiler xasm .circuit foo .parameters x,y,z .qbit q H(q[0]); CX(q[0], q[1]); CX(q[0], q[1]); CX(q[0], q[1]); Measure(q[0]); Measure(q[1]); ''') f = xacc.getCompiled('foo') # Run the python contributed IRTransformation that uses qiskit optimizer = xacc.getIRTransformation('qiskit-cx-cancellation') optimizer.apply(f, None, {}) # should have 4 instructions, not 6 assert (4 == f.nInstructions()) print(f.toString()) qbits = xacc.qalloc(2) qpu.execute(qbits, f)
import xacc, numpy as np nAngles = 10 # Get the local-ibm and tnqvm accelerators # and allocate some qubits for execution on each qpu = xacc.getAccelerator('aer', { 'shots': 1024, 'backend': 'ibmq_johannesburg', 'readout_error': True }) tnqvm = xacc.getAccelerator('tnqvm') buffer = xacc.qalloc(2) tnqvmBuffer = xacc.qalloc(2) # Turn on readout error correction by decorating # the local-ibm accelerator qpu = xacc.getAcceleratorDecorator('ro-error', qpu) # Construct the Hamiltonian ham = xacc.getObservable( 'pauli', '5.907 - 2.1433 X0X1 - 2.1433 Y0Y1 + .21829 Z0 - 6.125 Z1') # Define the ansatz and decorate it to indicate # you'd like to run VQE @xacc.qpu(algo='energy', accelerator=qpu, observable=ham) def ansatz(buffer, t0): X(buffer[0]) Ry(buffer[1], t0) CNOT(buffer[1], buffer[0])
program.addInstruction(gaussian) # Measure instructions (to be lowered to pulses) m0 = provider.createInstruction("Measure", [0]) m1 = provider.createInstruction("Measure", [1]) m2 = provider.createInstruction("Measure", [2]) m3 = provider.createInstruction("Measure", [3]) m4 = provider.createInstruction("Measure", [4]) program.addInstruction(m0) program.addInstruction(m1) program.addInstruction(m2) program.addInstruction(m3) program.addInstruction(m4) # Execute on the Aer simulator (bogota 5-qubit device) qpu = xacc.getAccelerator("aer:ibmq_bogota", {"sim-type": "pulse"}) buffer = xacc.qalloc(5) qpu.execute(buffer, program) # print(buffer) # Aer simulator will also return the state vector: # Note: it looks like the state-vector is in the qutrit space... # and the leaked state |2> is measured as 0. state_vec = buffer.getInformation("state") print(len(state_vec))
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)