def __call__(self, *args, **kwargs): super().__call__(*args, **kwargs) import numpy as np execParams = { 'accelerator': self.qpu, 'ansatz': self.compiledKernel, 'observable': self.kwargs["observable"] } if not isinstance(args[0], xacc.AcceleratorBuffer): raise RuntimeError( 'First argument of an xacc kernel must be the Accelerator Buffer to operate on.' ) buffer = args[0] ars = args[1:] if len(ars) > 0: execParams['parameters'] = list(ars) else: execParams['parameters'] = random.randrange(-np.pi, np.pi) vqe_energy = xacc.getAlgorithm('vqe-energy', execParams) vqe_energy.execute(buffer) return
def __call__(self, *args, **kwargs): super().__call__(*args, **kwargs) execParams = {'accelerator': self.qpu, 'ansatz': self.compiledKernel, 'observable': self.kwargs["observable"]} optParams = {} if not isinstance(args[0], xacc.AcceleratorBuffer): raise RuntimeError( 'First argument of an xacc kernel must be the Accelerator Buffer to operate on.') buffer = args[0] ars = args[1:] if len(ars) > 0: if isinstance(ars,list) or isinstance(ars,tuple): # print('ars is a list') optParams['initial-parameters'] = ars[0] else: optParams['initial-parameters'] = list(ars) # print(type(ars), optParams['initial-parameters']) if 'options' in self.kwargs: optParams = self.kwargs['options'] if 'optimizer' not in self.kwargs: self.kwargs['optimizer'] = 'nlopt' execParams['optimizer'] = xacc.getOptimizer(self.kwargs['optimizer'], optParams) vqe = xacc.getAlgorithm('vqe', execParams) vqe.execute(buffer) return
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, inputParams): """ Inherited method with algorithm-specific implementation Parameters: inputParams - a dictionary of input parameters obtained from .ini file - sets XACC VQE task to 'compute-energy' - executes a parameter-sweep """ super().execute(inputParams) pi = 3.141592653589793 self.vqe_options_dict['task'] = 'compute-energy' if inputParams['upper-bound'] == 'pi': up_bound = pi else: up_bound = ast.literal_eval(inputParams['upper-bound']) if inputParams['lower-bound'] == '-pi': low_bound = -pi else: low_bound = ast.literal_eval(inputParams['lower-bound']) num_params = ast.literal_eval(inputParams['num-params']) self.energies = [] self.angles = [] for param in self.linspace(low_bound, up_bound, num_params): print(param) self.vqe_options_dict['parameters'] = [param] vqe_energy = xacc.getAlgorithm('vqe-energy', self.vqe_options_dict) self.angles.append(param) # self.vqe_options_dict['vqe-params'] = str(param) vqe_energy.execute(self.buffer) energy = self.buffer.getInformation('opt-val') #xaccvqe.execute(self.op, self.buffer, **self.vqe_options_dict).energy # if 'rdm-purification' in self.qpu.name(): # p = self.buffer.getAllUnique('parameters') # ind = len(p) - 1 # children = self.buffer.getChildren('parameters', [param]) # print(children[0]) # energy = children[1].getInformation('purified-energy') self.energies.append(energy) self.buffer.addExtraInfo('vqe-energies', self.energies) self.buffer.addExtraInfo('vqe-angles', self.angles) self.buffer.addExtraInfo('vqe-energy', min(self.energies)) return self.buffer
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 execute(self, inputParams): """ Inherited method with algorithm-specific implementation Parameters: inputParams - a dictionary of input parameters obtained from .ini file """ super().execute(inputParams) if not isinstance(self.optimizer, xacc.Optimizer): self.optimizer.optimize(self.buffer, self.optimizer_options, self.vqe_options_dict) else: vqe = xacc.getAlgorithm('vqe', self.vqe_options_dict) vqe.execute(self.buffer) return self.buffer
def execute(self, inputParams): """ Inherited method with algorithm-specific implementation Parameters: inputParams - a dictionary of input parameters obtained from .ini file - sets XACC VQE task to 'compute-energy' """ super().execute(inputParams) algo = xacc.getAlgorithm("vqe-energy", self.vqe_options_dict) algo.execute(self.buffer) # if 'rdm-purification' in self.qpu.name(): # p = self.buffer.getAllUnique('parameters') # child = self.buffer.getChildren('parameters', p[0]) # energy = child[1].getInformation('purified-energy') # self.buffer.addExtraInfo('vqe-energy', energy) return self.buffer
def __call__(self, *args, **kwargs): super().__call__(*args, **kwargs) execParams = { 'accelerator': self.qpu, 'ansatz': self.compiledKernel, 'target_dist': self.kwargs['target_dist'], 'loss': self.kwargs['loss'] } if 'gradient' in self.kwargs: execParams['gradient'] = self.kwargs['gradient'] optParams = {} if not isinstance(args[0], xacc.AcceleratorBuffer): raise RuntimeError( 'First argument of an xacc kernel must be the Accelerator Buffer to operate on.' ) buffer = args[0] ars = args[1:] if len(ars) > 0: optParams['initial-parameters'] = list(ars) if 'options' in self.kwargs: optParams = self.kwargs['options'] if 'optimizer' not in self.kwargs: self.kwargs['optimizer'] = 'nlopt' if self.kwargs['optimizer'] in self.vqe_optimizers: optimizer = self.vqe_optimizers[self.kwargs['optimizer']] optimizer.optimize(buffer, optParams, execParams) else: execParams['optimizer'] = xacc.getOptimizer( self.kwargs['optimizer'], optParams) ddcl = xacc.getAlgorithm('ddcl', execParams) ddcl.execute(buffer) return
(-0.479677813134,-0) 1^ 1 + (-0.174072892497,-0) 3^ 1^ 3 1 + (0.0454063328691,0) 3^ 0^ 1 2 + (-0.165606823582,-0) 3^ 0^ 3 0 + (0.0454063328691,0) 0^ 3^ 2 1 + (-0.165606823582,-0) 2^ 1^ 2 1 + (-0.120200490713,-0) 0^ 1^ 0 1 + (-0.120200490713,-0) 1^ 0^ 1 0 + (0.7080240981,0) ''' H = xacc.getObservable('fermion', opstr) pool = xacc.quantum.getOperatorPool("singlet-adapted-uccsd") pool.optionalParameters({"n-electrons": 2}) pool.generate(buffer.size()) provider = xacc.getIRProvider('quantum') ansatz = provider.createComposite('initial-state') ansatz.addInstruction(provider.createInstruction('X', [0])) ansatz.addInstruction(provider.createInstruction('X', [2])) ansatz.addVariable("x0") for inst in pool.getOperatorInstructions(2, 0).getInstructions(): ansatz.addInstruction(inst) kernel = ansatz.eval([0.0808]) qeom = xacc.getAlgorithm( 'qeom', { 'accelerator': accelerator, 'observable': H, 'ansatz': kernel, 'n-electrons': 2 }) qeom.execute(buffer) spectrum = buffer.getInformation("excitation-energies") print(spectrum)
xacc.set_verbose(True) # Choose the QPU on which to # characterize the process matrix for a Hadamard qpu = xacc.getAccelerator('aer') # Create the CompositeInstruction containing a # single Hadamard instruction provider = xacc.getIRProvider('quantum') circuit = provider.createComposite('U') hadamard = provider.createInstruction('H', [0]) circuit.addInstruction(hadamard) # Create the Algorithm, give it the circuit # to characterize and the backend to target qpt = xacc.getAlgorithm('qpt', { 'circuit': circuit, 'accelerator': qpu }) # map logical 0 to physical 1 # Allocate a qubit, this will # store our tomography results buffer = xacc.qalloc(1) # Execute qpt.execute(buffer) # Compute the fidelity with respect to # the ideal hadamard process F = qpt.calculate( 'fidelity', buffer, { 'chi-theoretical-real': [0., 0., 0., 0., 0., 1., 0., 1., 0., 0., 0., 0., 0., 1., 0., 1.]
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") # Manual construction: # Triangular graph graph.addVertex({'name': 'v1'}) graph.addVertex({'name': 'v2'}) graph.addVertex({'name': 'v3'}) graph.addEdge(0, 1) graph.addEdge(0, 2) graph.addEdge(1, 2) print(graph) nbSteps = 1 buffer = xacc.qalloc(3) opt = xacc.getOptimizer('nlopt') # Create QAOA qaoa = xacc.getAlgorithm( 'maxcut-qaoa', { 'accelerator': qpu, 'graph': graph, 'optimizer': opt, 'steps': nbSteps, 'shuffle-terms': True }) result = qaoa.execute(buffer) print("Max-cut val:", buffer["opt-val"])
# we will get the correct answer of 1 deterministically. xacc.qasm('''.compiler xasm .circuit oracle .qbit q T(q[0]); ''') oracle = xacc.getCompiled('oracle') # We need to prepare the eigenstate |1> xacc.qasm('''.compiler xasm .circuit prep .qbit q X(q[0]); ''') statePrep = xacc.getCompiled('prep') # We need 4 qubits (3-bit precision) buffer = xacc.qalloc(4) # Create the QPE algorithm qpe = xacc.getAlgorithm('QPE', { 'accelerator': qpu, 'oracle': oracle, 'state-preparation': statePrep }) qpe.execute(buffer) # We should only get the bit string of |100> = 1 # i.e. phase value of 1/2^3 = 1/8. print(buffer)
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, 'observable': obs, 'optimizer': opt }) # Execute vqe.execute(qbits) # qbits buffer has all results, print(qbits) # to see it all print(qbits.getInformation('opt-val'))
import xacc accelerator = xacc.getAccelerator("qpp") H = xacc.getObservable( 'pauli', '0.2976 + 0.3593 Z0 - 0.4826 Z1 + 0.5818 Z0 Z1 + 0.0896 X0 X1 + 0.0896 Y0 Y1' ) expansion = 'Cioslowski' order = 2 provider = xacc.getIRProvider('quantum') ansatz = provider.createComposite('initial-state') ansatz.addInstruction(provider.createInstruction('X', [0])) buffer = xacc.qalloc(2) qcmx = xacc.getAlgorithm( 'qcmx', { 'accelerator': accelerator, 'observable': H, 'ansatz': ansatz, 'cmx-order': order, 'expansion-type': expansion }) qcmx.execute(buffer) print('Energy = ', buffer.getInformation('opt-val'))
import xacc qpu = xacc.getAccelerator('tnqvm') optimizer = xacc.getOptimizer('nlopt', {'nlopt-optimizer': 'l-bfgs'}) buffer = xacc.qalloc(4) geom = ''' H 0.000000 0.0 0.0 H 0.0 0.0 .7474 ''' H = xacc.getObservable('pyscf', {'basis': 'sto-3g', 'geometry': geom}) print(H.toString()) adapt = xacc.getAlgorithm( 'adapt-vqe', { 'accelerator': qpu, 'optimizer': optimizer, 'observable': H, 'nElectrons': 2, 'gradient-strategy': 'parameter-shift-gradient', 'print-operators': True, 'threshold': 1.0e-2, 'print-threshold': 1.0e-10, 'maxiter': 2, 'pool': "singlet-adapted-uccsd" }) # execute adapt.execute(buffer)
qpu = xacc.getAccelerator('tnqvm:exatn', { "exp-val-by-conjugate": True, "max-qubit": 2 }) print("QPU:", qpu.name()) buffer = xacc.qalloc(4) geom = ''' Na 0.000000 0.0 0.0 H 0.0 0.0 1.914388 ''' fo = [0, 1, 2, 3, 4, 10, 11, 12, 13, 14] ao = [5, 9, 15, 19] H = xacc.getObservable( 'pyscf', { 'basis': 'sto-3g', 'geometry': geom, 'frozen-spin-orbitals': fo, 'active-spin-orbitals': ao }) # print(H.toString()) opt = xacc.getOptimizer('nlopt') vqe = xacc.getAlgorithm('vqe', { 'ansatz': ansatz, 'accelerator': qpu, 'observable': H, 'optimizer': opt }) # # xacc.set_verbose(True) energy = vqe.execute(buffer, []) print('Energy = ', energy)
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"])
# Choose the QPU on which to # characterize the process matrix for a Hadamard qpu = xacc.getAccelerator('ibm:ibmq_poughkeepsie') # Create the CompositeInstruction containing a # single Hadamard instruction provider = xacc.getIRProvider('quantum') circuit = provider.createComposite('U') cnot = provider.createInstruction('CX', [0, 1]) circuit.addInstruction(cnot) # Create the Algorithm, give it the circuit # to characterize and the backend to target qpt = xacc.getAlgorithm('qpt', { 'circuit': circuit, 'accelerator': qpu, 'qubit-map': [1, 2] }) # Allocate a qubit, this will # store our tomography results buffer = xacc.qalloc(2) # Execute qpt.execute(buffer) theory_cx = [ 1., 0., 0., 1., 1., 0., 0., -1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 1., 1., 0., 0., -1., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 1., 1., 0., 0., -1., 0.,
# There are 7 gamma terms (non-identity) in the cost Hamiltonian # and 4 beta terms for mixer Hamiltonian nbParamsPerStep = 7 + 4 # The number of steps (often referred to as 'p' parameter): # alternating layers of mixer and cost Hamiltonian exponential. nbSteps = 4 # Total number of params nbTotalParams = nbParamsPerStep * nbSteps # Init params randomly: initParams = np.random.rand(nbTotalParams) # The optimizer: nlopt opt = xacc.getOptimizer('nlopt', {'initial-parameters': initParams}) # Create the QAOA algorithm qaoa = xacc.getAlgorithm('QAOA', { 'accelerator': qpu, 'observable': ham, 'optimizer': opt, 'steps': nbSteps }) result = qaoa.execute(buffer) # Expected result: ~ -11 # Ref: https://docs.entropicalabs.io/qaoa/notebooks/6_solvingqubowithqaoa print('Min QUBO value = ', buffer.getInformation('opt-val'))
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)
U(q[1], x[2], -pi/2, pi/2); U(q[1], 0, 0, x[3]); CNOT(q[0], q[1]); U(q[0], 0, 0, x[4]); U(q[0], x[5], -pi/2, pi/2); U(q[1], 0, 0, x[6]); U(q[1], x[7], -pi/2, pi/2); ''') f = xacc.getCompiled('qubit2_depth1') # Get the DDCL Algorithm, initialize it # with necessary parameters ddcl = xacc.getAlgorithm( 'ddcl', { 'ansatz': f, 'accelerator': qpu, 'target_dist': [0., 0., 0., 1.], 'persist-buffer': True, 'optimizer': optimizer, 'loss': 'js', 'gradient': 'js-parameter-shift' }) # execute ddcl.execute(qbits) # Note that the buffer file was persisted to # the hidden file with name # .ddcl_KERNELNAME_TIMESTAMP.ab, which in this case looks like # .ddcl_qubit2_depth1_2019-10-.....ab -> depends on time you ran this :)
.compiler xasm .circuit foo .parameters x,y,z .qbit q Ry(q[0], x); Ry(q[0], y); Ry(q[0], z); ''') f = xacc.getCompiled('foo') f.defaultPlacement(qpu, {'qubit-map': [0]}) print(f.toString()) # exit(0) # Get the DDCL Algorithm, initialize it # with necessary parameters ddcl = xacc.getAlgorithm( 'ddcl', { 'ansatz': f, 'accelerator': qpu, 'target_dist': [.5, .5], 'optimizer': optimizer, 'loss': 'js', 'gradient': 'js-parameter-shift' }) # execute ddcl.execute(qbits) print(qbits.keys()) print(qbits['opt-val']) print(qbits['opt-params'])
# Construct the Hamiltonian as an XACC PauliOperator ham = xacc.getObservable('pauli', '0.70710678118 X0 + 0.70710678118 Z0') # See Fig. 2 (e) of https://www.nature.com/articles/s41567-019-0704-4 # 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)
import xacc xacc.set_verbose(True) accelerator = xacc.getAccelerator("qpp") buffer = xacc.qalloc(4) optimizer = xacc.getOptimizer('nlopt', {'nlopt-optimizer': 'l-bfgs'}) pool = "multi-qubit-qaoa" nLayers = 2 subAlgo_qaoa = "QAOA" H = xacc.getObservable( 'pauli', '-5.0 - 0.5 Z0 - 1.0 Z2 + 0.5 Z3 + 1.0 Z0 Z1 + 2.0 Z0 Z2 + 0.5 Z1 Z2 + 2.5 Z2 Z3' ) adapt = xacc.getAlgorithm( 'adapt', { 'accelerator': accelerator, 'observable': H, 'optimizer': optimizer, 'pool': pool, 'maxiter': nLayers, 'sub-algorithm': subAlgo_qaoa }) adapt.execute(buffer)
(-0.174072892497,-0) 1^ 3^ 1 3 + (-0.0454063328691,-0) 0^ 2^ 1 3 + (0.120200490713,0) 0^ 1^ 1 0 + (0.0454063328691,0) 0^ 2^ 3 1 + (0.174072892497,0) 1^ 3^ 3 1 + (0.165606823582,0) 2^ 1^ 1 2 + (-0.0454063328691,-0) 2^ 1^ 3 0 + (-0.120200490713,-0) 2^ 3^ 2 3 + (0.120200490713,0) 2^ 3^ 3 2 + (-0.168335986252,-0) 0^ 2^ 0 2 + (0.120200490713,0) 3^ 2^ 2 3 + (-0.120200490713,-0) 3^ 2^ 3 2 + (0.0454063328691,0) 1^ 3^ 2 0 + (-1.2488468038,-0) 0^ 0 + (0.0454063328691,0) 3^ 1^ 0 2 + (-0.168335986252,-0) 2^ 0^ 2 0 + (0.165606823582,0) 3^ 0^ 0 3 + (-0.0454063328691,-0) 2^ 0^ 3 1 + (0.0454063328691,0) 2^ 0^ 1 3 + (-1.2488468038,-0) 2^ 2 + (0.0454063328691,0) 2^ 1^ 0 3 + (0.174072892497,0) 3^ 1^ 1 3 + (-0.479677813134,-0) 1^ 1 + (-0.174072892497,-0) 3^ 1^ 3 1 + (0.0454063328691,0) 3^ 0^ 1 2 + (-0.165606823582,-0) 3^ 0^ 3 0 + (0.0454063328691,0) 0^ 3^ 2 1 + (-0.165606823582,-0) 2^ 1^ 2 1 + (-0.120200490713,-0) 0^ 1^ 0 1 + (-0.120200490713,-0) 1^ 0^ 1 0 + (0.7080240981,0) ''' H = xacc.getObservable('fermion', opstr) adapt = xacc.getAlgorithm( 'adapt', { 'accelerator': qpu, 'optimizer': optimizer, 'observable': H, 'n-electrons': 2, 'maxiter': 2, 'sub-algorithm': 'vqe', 'pool': 'qubit-pool' }) # execute adapt.execute(buffer)
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
# alternating layers of mixer and cost Hamiltonian exponential. nbSteps = 4 # Total number of params nbTotalParams = nbParamsPerStep * nbSteps # Init params randomly: initParams = np.random.rand(nbTotalParams) # The optimizer: nlopt opt = xacc.getOptimizer('nlopt', { 'initial-parameters': initParams, 'nlopt-optimizer': 'l-bfgs' }) # Create the QAOA algorithm qaoa = xacc.getAlgorithm( 'QAOA', { 'accelerator': qpu, 'observable': ham, 'optimizer': opt, 'steps': nbSteps, 'gradient_strategy': 'parameter-shift-gradient' }) result = qaoa.execute(buffer) # Expected result: ~ -11 # Ref: https://docs.entropicalabs.io/qaoa/notebooks/6_solvingqubowithqaoa print('Min QUBO value = ', buffer.getInformation('opt-val'))
# We need 2 qubits for this case (H2) buffer = xacc.qalloc(2) # Horizontal axis: 0 -> 0.3 (step = 0.05) # The number of Trotter steps nbSteps = 6 # The Trotter step size stepSize = 0.05 # Create the QITE algorithm qite = xacc.getAlgorithm( 'qite', { 'accelerator': qpu, 'observable': ham, 'step-size': stepSize, 'steps': nbSteps, 'ansatz': prep_circuit }) result = qite.execute(buffer) # Expected result: ~ -1.74886 print('Min energy value = ', buffer.getInformation('opt-val')) E = buffer.getInformation('exp-vals') # Reproduce Fig. 3(a) of https://arxiv.org/pdf/1912.06226.pdf plt.plot(np.arange(0, nbSteps + 1) * stepSize, E, 'ro-', label='XACC QITE') plt.ylim((-2.0, -0.25)) plt.yticks(np.arange(-2.0, -0.25, step=0.25)) plt.grid() plt.show()