def generate_uccsd(molecule_data):
molecule, qubitOp, map_type, num_particles, num_spin_orbitals = load_qubitop_for_molecule(molecule_data)
nuclear_repulsion_energy = molecule.nuclear_repulsion_energy
print("# of electrons: {}".format(num_particles))
print("# of spin orbitals: {}".format(num_spin_orbitals))
qubit_reduction = False
HF_state = HartreeFock(num_spin_orbitals, num_particles, map_type, qubit_reduction)
uccsd_ansatz = UCCSD(reps=1,
num_orbitals=num_spin_orbitals, num_particles=num_particles,
initial_state=HF_state, qubit_mapping=map_type,
two_qubit_reduction=qubit_reduction)
circ = uccsd_ansatz.construct_circuit([0.4242] *
uccsd_ansatz.num_parameters)
circ.measure_all()
circ_transpiled = processor.transpile(circ)
q_layer = qiskit2tq(circ_transpiled)
for name, param in q_layer.named_parameters():
if not (param % (np.pi / 2)).detach().cpu().numpy().any():
param.requires_grad = False
#randlist = np.random.rand(uccsd_ansatz.num_parameters) # ansatz parameters
#uccsd_ansatz_circuit = uccsd_ansatz.construct_circuit(randlist)
return q_layer
def _build(self):
# wipe current state
self._data = []
self.qregs = []
self._qubits = []
self._parameter_table = ParameterTable()
print(self.parameters)
# get UCCSD circuit
uccsd = UCCSDVarForm(self._num_orbitals, self._num_particles,
self.reps)
params = ParameterVector('th', uccsd.num_parameters)
circuit = uccsd.construct_circuit(params)
# transpile to a basis gate set we can handle in the gradient calculation
transpiled = transpile(circuit, basis_gates=['sx', 'rz', 'cx'])
# add to self and store the parametervector for assigning
self._params = params
qreg = QuantumRegister(uccsd.num_qubits)
self.add_register(qreg)
self.compose(transpiled, inplace=True)
num_particles=core._molecule_info['num_particles'],
sq_list=sqlist)
circuit = init_state.construct_circuit()
outfile.write("\nHartree-Fock energy %f \n" % (molecule.hf_energy))
outfile.write("\nHartree-Fock circuit\n")
outfile.write(str(circuit.draw()) + "\n")
var_form = UCCSD(num_orbitals=core._molecule_info['num_orbitals'],
num_particles=core._molecule_info['num_particles'],
active_occupied=None,
active_unoccupied=None,
initial_state=init_state,
qubit_mapping=core._qubit_mapping,
two_qubit_reduction=core._two_qubit_reduction,
num_time_slices=1,
z2_symmetries=z2syms)
optimizer = L_BFGS_B(maxiter=1000)
algo = VQE(H_op, var_form, optimizer, aux_operators=A_op)
backend = Aer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend=backend)
algo_result = algo.run(quantum_instance)
get_results(H_op, A_op, molecule, core, algo_result, outfile)
print_UCCSD_parameters(molecule, core, var_form, algo_result, z2syms, sqlist,
orb_red, outfile)
print_circuit_requirements(
var_form.construct_circuit(algo_result['optimal_point']),
'ibmq_16_melbourne', 3, range(H_op.num_qubits), outfile)
# print(n_orbitals)
initial_hf = HartreeFock(num_qubits=n_qubits,
num_orbitals=n_orbitals,
qubit_mapping=core._qubit_mapping,
two_qubit_reduction=False,
num_particles=n_electrons)
var_form = UCCSD(num_qubits=n_qubits,
num_orbitals=n_orbitals,
num_particles=n_electrons,
depth=1,
initial_state=initial_hf,
qubit_mapping=core._qubit_mapping,
two_qubit_reduction=False)
number_amplitudes = len(var_form._single_excitations) + len(
var_form._double_excitations)
amplitudes = [1e-4] * number_amplitudes
circuit = var_form.construct_circuit(amplitudes)
dag = circuit_to_dag(circuit)
dag = Unroller(['cx', 'u1', 'u3']).run(dag)
circuit = dag_to_circuit(dag)
qasm = circuit.qasm()
filename = '{m}_{f}_{q}_{b}.qasm'.format(
m=mol_name,
f=('frz' if freeze_core else 'cmplt'),
q=qm_name,
b=basis)
with open(filename, 'w') as ofile:
ofile.write(qasm)
print(filename)
print(circuit.count_ops())
active_unoccupied=None,
initial_state=init_state,
qubit_mapping=core._qubit_mapping,
two_qubit_reduction=core._two_qubit_reduction,
num_time_slices=1,
z2_symmetries=z2syms)
optimizer = SPSA(max_trials=100)
algo = VQE(H_op, var_form, optimizer, aux_operators=A_op)
backend = Aer.get_backend('qasm_simulator')
provider = IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q-internal',
group='deployed',
project='default')
device = provider.get_backend('ibmq_athens')
quantum_instance = QuantumInstance(
backend=backend,
noise_model=NoiseModel.from_backend(device.properties()),
coupling_map=device.configuration().coupling_map,
measurement_error_mitigation_cls=CompleteMeasFitter,
shots=8092)
algo_result = algo.run(quantum_instance)
get_results(H_op, A_op, molecule, core, algo_result, outfile)
print_UCCSD_parameters(molecule, core, var_form, algo_result,
core._molecule_info['z2symmetries'], sqlist, orb_red,
outfile)
print_circuit_requirements(
var_form.construct_circuit(algo_result['optimal_point']), 'ibmq_athens', 3,
range(H_op.num_qubits), outfile)
