>>>>>>> master:scripts/adapt_vqes/adapt_vqe.py
q_encoding = 'jw'
spin_complement = False # only for fermionic and qubit excitations (not for PWEs)
# <<<<<<<<<< TERMINATION PARAMETERS >>>>>>>>>>>>>>>>>
delta_e_threshold = 1e-12 # 1e-3 for chemical accuracy
max_ansatz_elements = 600
# <<<<<<<<<<<< DEFINE BACKEND >>>>>>>>>>>>>>>>>
backend = backends.MatrixCacheBackend
# <<<<<<<<<< DEFINE OPTIMIZER >>>>>>>>>>>>>>>>>
use_energy_vector_gradient = True # for optimizer
# create a vqe_runner object
vqe_runner = VQERunner(molecule, backend=backend, optimizer='BFGS', optimizer_options={'gtol': 1e-08},
use_ansatz_gradient=use_energy_vector_gradient)
# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
LogUtils.log_config()
logging.info('{}, r={} ,{}'.format(molecule.name, r, ansatz_element_type))
time_stamp = datetime.datetime.now().strftime("%d-%b-%Y (%H:%M:%S.%f)")
# create the pool of ansatz elements
if spin_complement:
ansatz_element_pool = SpinCompGSDExcitations(molecule.n_orbitals, molecule.n_electrons,
element_type=ansatz_element_type, encoding=q_encoding).get_all_elements()
else:
ansatz_element_pool = GSDExcitations(molecule.n_orbitals, molecule.n_electrons,
ansatz_element_type=ansatz_element_type).get_all_elements()
spin_complement = False # only for fermionic and qubit excitations (not for PWEs)
# <<<<<<<<<< TERMINATION PARAMETERS >>>>>>>>>>>>>>>>>
delta_e_threshold = 1e-12 # 1e-3 for chemical accuracy
max_ansatz_elements = 250
# <<<<<<<<<<<< DEFINE BACKEND >>>>>>>>>>>>>>>>>
backend = backends.MatrixCacheBackend
# <<<<<<<<<< DEFINE OPTIMIZER >>>>>>>>>>>>>>>>>
use_energy_vector_gradient = True # for optimizer
# create a vqe_runner object
vqe_runner = VQERunner(molecule,
backend=backend,
optimizer='BFGS',
optimizer_options={'gtol': 1e-08},
use_ansatz_gradient=use_energy_vector_gradient)
# create a vqe_runner for excited states, where the minimum may be away from the zero, which will make gradient
# descent optimizers useless
# vqe_runner_2 = VQERunner(molecule, backend=QiskitSim, optimizer='BFGS', optimizer_options={'gtol': 1e-08},
# use_ansatz_gradient=use_grad)
vqe_runner_2 = VQERunner(molecule,
backend=backend,
optimizer='Nelder-Mead',
optimizer_options=None)
# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
SQExc(*ast.literal_eval(element_qubits)))
elif element[0] == 'd' and element[2] == 'q':
init_ansatz_elements.append(
DQExc(*ast.literal_eval(element_qubits)))
else:
print(element, element_qubits)
raise Exception('Unrecognized ansatz element.')
ansatz_elements = init_ansatz_elements[:1]
optimizer = 'BFGS'
optimizer_options = {'gtol': 1e-8}
vqe_runner = VQERunner(molecule,
backend=QiskitSimBackend,
optimizer=optimizer,
optimizer_options=None,
print_var_parameters=True,
use_ansatz_gradient=True)
angles = (numpy.arange(40) - 20) * numpy.pi / 200 - 0.1
energies = []
for angle in angles:
energies.append(vqe_runner.get_energy([angle], ansatz_elements))
plt.plot(angles, energies)
plt.xlabel(r'Angle, [$\pi$]')
plt.ylabel('Energy, [Hartree]')
plt.title('Mol.: {}, ansatz_element: {}: {}'.format(
molecule.name, len(ansatz_elements), ansatz_elements[-1].element))
plt.show()
ansatz = state.ansatz_elements
var_parameters = state.parameters
ansatz = ansatz
# var_parameters = list(df['var_parameters'])[:49]
var_parameters = var_parameters
global_cache = GlobalCache(molecule)
global_cache.calculate_exc_gen_sparse_matrices_dict(ansatz)
global_cache.calculate_commutators_sparse_matrices_dict(ansatz)
optimizer = 'BFGS'
optimizer_options = {'gtol': 1e-8}
vqe_runner = VQERunner(molecule,
backend=QiskitSimBackend,
optimizer=optimizer,
optimizer_options=None,
print_var_parameters=False,
use_ansatz_gradient=True)
energy = vqe_runner.vqe_run(ansatz=ansatz,
init_guess_parameters=var_parameters,
init_state_qasm=None,
cache=global_cache)
# ansatz_grad = QiskitSimBackend.ansatz_gradient(var_parameters, ansatz, molecule, cache=global_cache)
print(energy)
# print(ansatz_grad)
n_largest_grads = 20
init_db = None #pandas.read_csv("../../results/adapt_vqe_results/vip/LiH_h_adapt_gsdqe_27-Jul-2020.csv")
# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
LogUtils.log_config()
logging.info('{}, r={} ,{}'.format(molecule.name, r, ansatz_element_type))
time_stamp = datetime.datetime.now().strftime("%d-%b-%Y (%H:%M:%S.%f)")
# create a vqe runner object
optimizer = 'BFGS'
optimizer_options = {'gtol': 1e-08}
vqe_runner = VQERunner(molecule,
backend=QiskitSimBackend,
optimizer=optimizer,
optimizer_options=optimizer_options,
use_ansatz_gradient=use_grad)
hf_energy = molecule.hf_energy
fci_energy = molecule.fci_energy
# dataFrame to collect the simulation data
df_data = pandas.DataFrame(columns=[
'n', 'E', 'dE', 'error', 'n_iters', 'cnot_count', 'u1_count',
'cnot_depth', 'u1_depth', 'element', 'element_qubits', 'var_parameters'
])
ansatz_element_pool = GSDExcitations(
molecule.n_orbitals,
molecule.n_electrons,
ansatz_element_type=ansatz_element_type).get_excitations()
LogUtils.log_config()
# Create a UCCSD ansatz for the specified molecule
ansatz = UCCSDExcitations(q_system.n_orbitals, q_system.n_electrons, 'f_exc').get_all_elements()
# choose a backend to calculate expectation values
backend = MatrixCacheBackend
# create a cache of precomputed values to accelerate the simulation (optional)
global_cache = GlobalCache(q_system)
global_cache.calculate_exc_gen_sparse_matrices_dict(ansatz)
# global_cache.calculate_commutators_sparse_matrices_dict(ansatz)
# Create a VQE runner, and specify the minimizer
optimizer = 'BFGS'
optimizer_options = {'gtol': 10e-8}
vqe_runner = VQERunner(q_system, backend=backend, print_var_parameters=False, use_ansatz_gradient=True,
optimizer=optimizer, optimizer_options=optimizer_options)
t0 = time.time()
result = vqe_runner.vqe_run(ansatz=ansatz, cache=global_cache) # initial_var_parameters=var_parameters)
t = time.time()
logging.critical(result)
print(result)
print('Time for running: ', t - t0)
print('Pizza')
e_system = ElectronicSystem(H, n_orbitals, n_electrons)
LogUtils.log_config()
ansatz = ansatz_1()
init_qasm = None
global_cache = GlobalCache(e_system, excited_state=0)
global_cache.calculate_exc_gen_sparse_matrices_dict(ansatz)
backend = MatrixCacheBackend
optimizer = 'BFGS'
optimizer_options = {'gtol': 10e-8, 'maxiter': 10}
vqe_runner = VQERunner(e_system, backend=backend, print_var_parameters=False, use_ansatz_gradient=True,
optimizer=optimizer, optimizer_options=optimizer_options)
result = vqe_runner.vqe_run(ansatz=ansatz, cache=global_cache, init_state_qasm=init_qasm)
parameters = result.x
statevector = global_cache.get_statevector(ansatz, parameters, init_state_qasm=init_qasm)
statevector = statevector.todense()
operator = 'elenaananana' # TODO: TOVA trqbva da e klas openfermion.FermionicOperator
operator = openfermion.jordan_wigner(operator)
operator = openfermion.get_sparse_operator(operator, n_orbitals)
expectation_value = statevector.dot(operator).dot(statevector.conj().transpose())
print(expectation_value)
import ray
if __name__ == "__main__":
molecule = HF
r = 0.995
max_n_iterations = 2000
threshold = 1e-6 # 1e-3 for chemical accuracy
t0 = time.time()
ansatz_elements_pool = UCCSD(molecule.n_orbitals,
molecule.n_electrons).get_excitations()
vqe_runner = VQERunner(molecule,
backend=QiskitSimBackend,
molecule_geometry_params={'distance': r})
ray.init(num_cpus=4)
result_ids = [[
i,
vqe_runner.vqe_run_multithread.remote(self=vqe_runner,
ansatz=[ansatz_element])
] for i, ansatz_element in enumerate(ansatz_elements_pool)]
results = [[result_id[0], ray.get(result_id[1])]
for result_id in result_ids]
print(len(results))
print(results)
var_parameters = list(numpy.zeros(len(ansatz)))
optimizer = 'BFGS'
optimizer_options = {'gtol': 10e-8}
energies = []
fci_energies = []
rs = [0.5, 0.75, 1, 1.25, 1.5, 1.75, 2, 2.25, 2.5, 2.75, 3]
df_count = 0
for r in rs:
molecule = H6(r=r)
vqe_runner = VQERunner(molecule,
backend=MatrixCacheBackend,
use_ansatz_gradient=True,
optimizer=optimizer,
optimizer_options=optimizer_options)
global_cache = GlobalCache(molecule)
global_cache.calculate_exc_gen_sparse_matrices_dict(ansatz)
# result = vqe_runner.vqe_run(ansatz, var_parameters, cache=global_cache)
result = vqe_runner.vqe_run(ansatz, cache=global_cache)
del global_cache
fci_E = molecule.fci_energy
fci_energies.append(fci_E)
# next var parameters
if len(ansatz) == 0:
n_largest_grads = 20
init_db = None #pandas.read_csv("../../results/adapt_vqe_results/vip/LiH_h_adapt_gsdqe_27-Jul-2020.csv")
# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
LogUtils.log_config()
logging.info('{}, r={} ,{}'.format(molecule.name, r, ansatz_element_type))
time_stamp = datetime.datetime.now().strftime("%d-%b-%Y (%H:%M:%S.%f)")
# create a vqe runner object
optimizer = 'BFGS'
optimizer_options = {'gtol': 1e-08}
vqe_runner = VQERunner(molecule,
backend=QiskitSimBackend,
optimizer=optimizer,
optimizer_options=optimizer_options,
use_ansatz_gradient=use_grad)
hf_energy = molecule.hf_energy
fci_energy = molecule.fci_energy
# dataFrame to collect the simulation data
df_data = pandas.DataFrame(columns=[
'n', 'E', 'dE', 'error', 'n_iters', 'cnot_count', 'u1_count',
'cnot_depth', 'u1_depth', 'element', 'element_qubits', 'var_parameters'
])
ansatz_element_pool = GSDExcitations(
molecule.n_orbitals,
molecule.n_electrons,
ansatz_element_type=ansatz_element_type).get_excitations()
# gs_dfs.append(pandas.read_csv('../results/iter_vqe_results/BeH2_iqeb_vqe_r=275_20-Nov-2020.csv'))
# gs_dfs.append(pandas.read_csv('../results/iter_vqe_results/BeH2_iqeb_eff_f_exc_n=1_r=3_22-Mar-2021.csv'))
df_count = 0
for j, r in enumerate(rs):
print('r= ', r)
molecule = LiH(r=r)
ground_state = DataUtils.ansatz_from_data_frame(gs_dfs[j], molecule)
molecule.H_lower_state_terms = [[
abs(molecule.hf_energy) * 2, ground_state
]]
vqe_runner = VQERunner(molecule,
backend=MatrixCacheBackend,
use_ansatz_gradient=True,
optimizer=optimizer,
optimizer_options=optimizer_options)
global_cache = GlobalCache(molecule, excited_state=excited_state)
global_cache.calculate_exc_gen_sparse_matrices_dict(ansatz)
result = vqe_runner.vqe_run(ansatz,
var_parameters,
cache=global_cache,
excited_state=excited_state)
del global_cache
exact_E = molecule.calculate_energy_eigenvalues(excited_state +
1)[excited_state]
exact_energies.append(exact_E)
spin_complement = False # only for fermionic and qubit excitations (not for PWEs)
# <<<<<<<<<< TERMINATION PARAMETERS >>>>>>>>>>>>>>>>>
delta_e_threshold = 1e-12 # 1e-3 for chemical accuracy
max_ansatz_elements = 250
# <<<<<<<<<<<< DEFINE BACKEND >>>>>>>>>>>>>>>>>
backend = backends.MatrixCacheBackend
# <<<<<<<<<< DEFINE OPTIMIZER >>>>>>>>>>>>>>>>>
use_energy_vector_gradient = True # for optimizer
# create a vqe_runner object
vqe_runner = VQERunner(molecule,
backend=backend,
optimizer='BFGS',
optimizer_options={'gtol': 1e-08},
use_ansatz_gradient=use_energy_vector_gradient)
# create a vqe_runner for excited states, where the minimum may be away from the zero, which will make gradient
# descent optimizers useless
# vqe_runner_2 = VQERunner(molecule, backend=backend, optimizer='BFGS', optimizer_options={'gtol': 1e-08},
# use_ansatz_gradient=use_grad)
vqe_runner_2 = VQERunner(molecule,
backend=backend,
optimizer='Nelder-Mead',
optimizer_options=None)
# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# ansatz_element_type = 'f_exc'
# ansatz_element_type = 'pauli_str_exc'
# <<<<<<<<<< IQEB-VQE PARAMETERS >>>>>>>>>>>>>>>>>
delta_e_threshold = 1e-12 # 1e-3 for chemical accuracy
max_ansatz_size = 250
n_largest_grads = 10
# <<<<<<<<<<<< DEFINE BACKEND >>>>>>>>>>>>>>>>>
backend = backends.MatrixCacheBackend
# <<<<<<<<<< DEFINE OPTIMIZER >>>>>>>>>>>>>>>>>
use_energy_vector_gradient = True # for optimizer
# create a vqe_runner object
vqe_runner = VQERunner(molecule, backend=backend, optimizer='BFGS', optimizer_options={'gtol': 1e-08},
use_ansatz_gradient=use_energy_vector_gradient)
# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
LogUtils.log_config()
logging.info('{}, r={} ,{}'.format(molecule.name, r, ansatz_element_type))
time_stamp = datetime.datetime.now().strftime("%d-%b-%Y (%H:%M:%S.%f)")
# create the pool of ansatz elements
ansatz_element_pool = SDExcitations(molecule.n_orbitals, molecule.n_electrons,
ansatz_element_type=ansatz_element_type).get_all_elements()
# create simulation cache
if backend == backends.MatrixCacheBackend:
# precompute commutator matrices, that are use in excitation gradient calculation
global_cache = GlobalCache(molecule)
