def test_eoh(self):
SIZE = 2
temp = np.random.random((2**SIZE, 2**SIZE))
h1 = temp + temp.T
qubitOp = Operator(matrix=h1)
temp = np.random.random((2**SIZE, 2**SIZE))
h1 = temp + temp.T
evoOp = Operator(matrix=h1)
state_in = get_initial_state_instance('CUSTOM')
state_in.init_args(SIZE, state='random')
evo_time = 1
num_time_slices = 100
eoh = get_algorithm_instance('EOH')
eoh.setup_quantum_backend(skip_transpiler=True)
# self.log.debug('state_out:\n\n')
eoh.init_args(qubitOp, 'paulis', state_in, evoOp, evo_time,
num_time_slices)
ret = eoh.run()
self.log.debug('Evaluation result: {}'.format(ret))
def test_svm_qkernel_directly(self):
svm = get_algorithm_instance("QSVM.Kernel")
svm.setup_quantum_backend(backend='local_qasm_simulator_py', shots=1024)
svm.random_seed = self.random_seed
params = {
'problem': {'name': 'svm_classification', 'random_seed': self.random_seed},
'algorithm': {'name': 'QSVM.Kernel'},
'backend': {'name': 'local_qasm_simulator_py', 'shots': 1024},
'multiclass_extension': {'name': 'AllPairs', 'estimator': 'QKernalSVM_Estimator'},
}
svm.init_params(params, self.svm_input)
result = svm.run()
np.testing.assert_array_almost_equal(
result['kernel_matrix_training'], self.ref_kernel_matrix_training, decimal=4)
np.testing.assert_array_almost_equal(
result['kernel_matrix_testing'], self.ref_kernel_matrix_testing, decimal=4)
self.assertEqual(len(result['svm']['support_vectors']), 4)
np.testing.assert_array_almost_equal(
result['svm']['support_vectors'], self.ref_support_vectors, decimal=4)
np.testing.assert_array_almost_equal(result['svm']['alphas'], self.ref_alpha, decimal=4)
np.testing.assert_array_almost_equal(result['svm']['bias'], self.ref_bias, decimal=4)
self.assertEqual(result['test_success_ratio'], 0.0)
def test_svm_variational_directly(self):
np.random.seed(self.random_seed)
svm = get_algorithm_instance("QSVM.Variational")
svm.random_seed = self.random_seed
svm.setup_quantum_backend(backend='local_qasm_simulator', shots=1024)
optimizer = get_optimizer_instance('SPSA')
optimizer.init_args(max_trials=10, c0=4.0, skip_calibration=True)
optimizer.set_options(save_steps=1)
num_qubits = 2
feature_map = get_feature_map_instance('SecondOrderExpansion')
feature_map.init_args(num_qubits=num_qubits, depth=2)
var_form = get_variational_form_instance('RYRZ')
var_form.init_args(num_qubits=num_qubits, depth=3)
svm.init_args(self.training_data, self.testing_data, None, optimizer,
feature_map, var_form)
result = svm.run()
np.testing.assert_array_almost_equal(result['opt_params'],
self.ref_opt_params,
decimal=4)
np.testing.assert_array_almost_equal(result['training_loss'],
self.ref_train_loss,
decimal=8)
self.assertEqual(result['testing_accuracy'], 0.5)
def test_ee_direct(self):
algo = get_algorithm_instance('ExactEigensolver')
algo.init_args(self.algo_input.qubit_op, k=1, aux_operators=[])
result = algo.run()
self.assertAlmostEqual(result['energy'], -1.85727503)
np.testing.assert_array_almost_equal(result['energies'], [-1.85727503])
np.testing.assert_array_almost_equal(result['eigvals'], [-1.85727503+0j])
def test_svm_qkernel_binary_directly(self):
svm = get_algorithm_instance("QSVM.Kernel")
svm.random_seed = self.random_seed
svm.setup_quantum_backend(backend='local_qasm_simulator_py',
shots=self.shots)
num_qubits = 2
feature_map = get_feature_map_instance('SecondOrderExpansion')
feature_map.init_args(num_qubits=num_qubits,
depth=2,
entangler_map={0: [1]})
svm.init_args(self.training_data, self.testing_data, None, feature_map,
None)
result = svm.run()
np.testing.assert_array_almost_equal(result['kernel_matrix_training'],
self.ref_kernel_matrix_training,
decimal=4)
np.testing.assert_array_almost_equal(result['kernel_matrix_testing'],
self.ref_kernel_matrix_testing,
decimal=4)
self.assertEqual(len(result['svm']['support_vectors']), 4)
np.testing.assert_array_almost_equal(result['svm']['support_vectors'],
self.ref_support_vectors,
decimal=4)
np.testing.assert_array_almost_equal(result['svm']['alphas'],
self.ref_alpha,
decimal=4)
np.testing.assert_array_almost_equal(result['svm']['bias'],
self.ref_bias,
decimal=4)
self.assertEqual(result['testing_accuracy'], 0.5)
def test_ee_direct_k4(self):
algo = get_algorithm_instance('ExactEigensolver')
algo.init_args(self.algo_input.qubit_op, k=4, aux_operators=[])
result = algo.run()
self.assertAlmostEqual(result['energy'], -1.85727503)
self.assertEqual(len(result['eigvals']), 4)
self.assertEqual(len(result['eigvecs']), 4)
np.testing.assert_array_almost_equal(result['energies'], [-1.85727503, -1.24458455, -0.88272215, -0.22491125])
def test_cplex_ising_direct(self):
algo = get_algorithm_instance('CPLEX.Ising')
algo.init_args(self.algo_input.qubit_op, display=0)
result = algo.run()
self.assertEqual(result['energy'], -20.5)
x_dict = result['x_sol']
x = np.array([x_dict[i] for i in sorted(x_dict.keys())])
np.testing.assert_array_equal(maxcut.get_graph_solution(x),
[1, 0, 1, 1])
self.assertEqual(maxcut.maxcut_value(x, self.w), 24)
def test_vqe_direct(self):
num_qbits = self.algo_input.qubit_op.num_qubits
init_state = get_initial_state_instance('ZERO')
init_state.init_args(num_qbits)
var_form = get_variational_form_instance('RY')
var_form.init_args(num_qbits, 3, initial_state=init_state)
optimizer = get_optimizer_instance('L_BFGS_B')
optimizer.init_args()
algo = get_algorithm_instance('VQE')
algo.setup_quantum_backend(backend='local_statevector_simulator')
algo.init_args(self.algo_input.qubit_op, 'matrix', var_form, optimizer)
result = algo.run()
self.assertAlmostEqual(result['energy'], -1.85727503)
def test_grover(self, input_file, incremental=True, num_iterations=1):
input_file = self._get_resource_path(input_file)
# get ground-truth
with open(input_file) as f:
buf = f.read()
if incremental:
self.log.debug(
'Testing incremental Grover search on SAT problem instance: \n{}'
.format(buf, ))
else:
self.log.debug(
'Testing Grover search with {} iteration(s) on SAT problem instance: \n{}'
.format(
num_iterations,
buf,
))
header = buf.split('\n')[0]
self.assertGreaterEqual(header.find('solution'), 0,
'Ground-truth info missing.')
self.groundtruth = [
''.join([
'1' if i > 0 else '0' for i in sorted(
[int(v) for v in s.strip().split() if v != '0'], key=abs)
])[::-1] for s in header.split('solutions:' if header.find(
'solutions:') >= 0 else 'solution:')[-1].split(',')
]
sat_oracle = get_oracle_instance('SAT')
sat_oracle.init_args(buf)
grover = get_algorithm_instance('Grover')
grover.setup_quantum_backend(backend='qasm_simulator', shots=100)
grover.init_args(sat_oracle,
num_iterations=num_iterations,
incremental=incremental)
ret = grover.run()
self.log.debug('Ground-truth Solutions: {}.'.format(self.groundtruth))
self.log.debug('Measurement result: {}.'.format(
ret['measurements']))
top_measurement = max(ret['measurements'].items(),
key=operator.itemgetter(1))[0]
self.log.debug('Top measurement: {}.'.format(top_measurement))
if ret['oracle_evaluation']:
self.assertIn(top_measurement, self.groundtruth)
self.log.debug('Search Result: {}.'.format(ret['result']))
else:
self.assertEqual(self.groundtruth, [''])
self.log.debug('Nothing found.')
def test_svm_qkernel_directly(self):
svm = get_algorithm_instance("SVM_QKernel")
svm.setup_quantum_backend(backend='local_qasm_simulator', shots=1024)
svm.random_seed = self.random_seed
svm.init_args(self.training_data, self.testing_data, None, print_info=False)
result = svm.run()
np.testing.assert_array_almost_equal(
result['kernel_matrix_training'], self.ref_kernel_matrix_training, decimal=4)
np.testing.assert_array_almost_equal(
result['kernel_matrix_testing'], self.ref_kernel_matrix_testing, decimal=4)
self.assertEqual(len(result['svm']['support_vectors']), 4)
np.testing.assert_array_almost_equal(
result['svm']['support_vectors'], self.ref_support_vectors, decimal=4)
self.assertEqual(result['test_success_ratio'], 0.5)
def test_qaoa(self, w, p, solutions):
self.log.debug('Testing {}-step QAOA with MaxCut on graph\n{}'.format(p, w))
np.random.seed(0)
optimizer = get_optimizer_instance('COBYLA')
qubitOp, offset = maxcut.get_maxcut_qubitops(w)
qaoa = get_algorithm_instance('QAOA')
qaoa.init_args(qubitOp, 'matrix', p, optimizer)
qaoa.setup_quantum_backend(backend='local_statevector_simulator', shots=100)
result = qaoa.run()
x = maxcut.sample_most_likely(result['eigvecs'][0])
graph_solution = maxcut.get_graph_solution(x)
self.log.debug('energy: {}'.format(result['energy']))
self.log.debug('time: {}'.format(result['eval_time']))
self.log.debug('maxcut objective: {}'.format(result['energy'] + offset))
self.log.debug('solution: {}'.format(graph_solution))
self.log.debug('solution objective: {}'.format(maxcut.maxcut_value(x, w)))
self.assertIn(''.join([str(int(i)) for i in graph_solution]), solutions)
def calcular_energia_clasico(propiedadesmolecula,
operadorqubit,
energy_shift,
supervisorderesultados=None):
"""Esta función usa obtiene la energía de enlace menor mediante el cálculo del menor autovalor del sistema"""
exact_eigensolver = get_algorithm_instance('ExactEigensolver')
exact_eigensolver.init_args(operadorqubit, k=1)
ret = exact_eigensolver.run()
if supervisorderesultados:
eventoderesultados = Evento("evento de resultados")
eventoderesultados.registro(supervisorderesultados)
eventoderesultados.anunciarse({
"mensaje":
"The computed energy is: {:.12f}".format(ret["eigvals"][0].real)
})
eventoderesultados.anunciarse({
"mensaje":
"The total ground state energy is: {:.12f}".format(
ret["eigvals"][0].real + energy_shift +
propiedadesmolecula["energia_de_repulsion_nuclear"])
})
eventoderesultados.dar_de_baja_todos()
def test_grover(self, input_file, num_iterations=1):
self.log.debug(
'Testing Grover search with {} iteration(s) on SAT problem instance: \n{}'
.format(
num_iterations,
open(input_file).read(),
))
# get ground-truth
with open(input_file) as f:
header = f.readline()
self.assertGreaterEqual(header.find('solution'), 0,
'Ground-truth info missing.')
self.groundtruth = [
''.join([
'1' if i > 0 else '0' for i in sorted(
[int(v) for v in s.strip().split() if v != '0'], key=abs)
])[::-1] for s in header.split('solutions:' if header.find(
'solutions:') >= 0 else 'solution:')[-1].split(',')
]
sat_oracle = get_oracle_instance('SAT')
with open(input_file) as f:
sat_oracle.init_args(f.read())
grover = get_algorithm_instance('Grover')
grover.setup_quantum_backend(backend='local_qasm_simulator', shots=100)
grover.init_args(sat_oracle, num_iterations=num_iterations)
ret = grover.run()
self.log.debug('Ground-truth Solutions: {}.'.format(self.groundtruth))
self.log.debug('Measurement result: {}.'.format(
ret['measurements']))
top_measurement = max(ret['measurements'].items(),
key=operator.itemgetter(1))[0]
self.log.debug('Top measurement: {}.'.format(top_measurement))
self.log.debug('Search Result: {}.'.format(ret['result']))
self.assertIn(top_measurement, self.groundtruth)
def test_vqe_2_iqpe(self):
num_qbits = self.algo_input.qubit_op.num_qubits
var_form = get_variational_form_instance('RYRZ')
var_form.init_args(num_qbits, 3)
optimizer = get_optimizer_instance('SPSA')
optimizer.init_args(max_trials=10)
# optimizer.set_options(**{'max_trials': 500})
algo = get_algorithm_instance('VQE')
algo.setup_quantum_backend(backend='qasm_simulator')
algo.init_args(self.algo_input.qubit_op, 'paulis', var_form, optimizer)
result = algo.run()
self.log.debug('VQE result: {}.'.format(result))
self.ref_eigenval = -1.85727503
num_time_slices = 50
num_iterations = 11
state_in = VarFormBased()
state_in.init_args(var_form, result['opt_params'])
iqpe = get_algorithm_instance('IQPE')
iqpe.setup_quantum_backend(backend='qasm_simulator',
shots=100,
skip_transpiler=True)
iqpe.init_args(
self.algo_input.qubit_op,
state_in,
num_time_slices,
num_iterations,
paulis_grouping='random',
expansion_mode='suzuki',
expansion_order=2,
)
result = iqpe.run()
self.log.debug('top result str label: {}'.format(
result['top_measurement_label']))
self.log.debug('top result in decimal: {}'.format(
result['top_measurement_decimal']))
self.log.debug('stretch: {}'.format(
result['stretch']))
self.log.debug('translation: {}'.format(
result['translation']))
self.log.debug('final eigenvalue from QPE: {}'.format(
result['energy']))
self.log.debug('reference eigenvalue: {}'.format(
self.ref_eigenval))
self.log.debug('ref eigenvalue (transformed): {}'.format(
(self.ref_eigenval + result['translation']) * result['stretch']))
self.log.debug('reference binary str label: {}'.format(
decimal_to_binary((self.ref_eigenval + result['translation']) *
result['stretch'],
max_num_digits=num_iterations + 3,
fractional_part_only=True)))
np.testing.assert_approx_equal(self.ref_eigenval,
result['energy'],
significant=2)
n = 2 # dimension of each data point
training_dataset_size = 20
testing_dataset_size = 10
sample_Total, training_input, test_input, class_labels = datasets.userDefinedData(
file='bank1000.csv',
location='',
training_size=training_dataset_size,
test_size=testing_dataset_size,
class_labels=[0, 1],
n=n,
PLOT_DATA=False)
datapoints, class_to_label = split_dataset_to_data_and_labels(test_input)
svm = get_algorithm_instance("QSVM.Kernel")
svm.random_seed = 10598
svm.setup_quantum_backend(backend='statevector_simulator')
feature_map = get_feature_map_instance('SecondOrderExpansion')
feature_map.init_args(num_qubits=2, depth=2, entanglement='linear')
svm.init_args(training_input, test_input, datapoints[0], feature_map)
print("Running algo")
result = svm.run()
print("kernel matrix during the training:")
kernel_matrix = result['kernel_matrix_training']
img = plt.imshow(np.asmatrix(kernel_matrix),
interpolation='nearest',
def test_qpe(self, qubitOp):
self.algorithm = 'QPE'
self.log.debug('Testing QPE')
self.qubitOp = qubitOp
exact_eigensolver = get_algorithm_instance('ExactEigensolver')
exact_eigensolver.init_args(self.qubitOp, k=1)
results = exact_eigensolver.run()
w = results['eigvals']
v = results['eigvecs']
self.qubitOp._check_representation('matrix')
np.testing.assert_almost_equal(self.qubitOp.matrix @ v[0], w[0] * v[0])
np.testing.assert_almost_equal(
expm(-1.j * self.qubitOp.matrix) @ v[0],
np.exp(-1.j * w[0]) * v[0])
self.ref_eigenval = w[0]
self.ref_eigenvec = v[0]
self.log.debug('The exact eigenvalue is: {}'.format(
self.ref_eigenval))
self.log.debug('The corresponding eigenvector: {}'.format(
self.ref_eigenvec))
num_time_slices = 50
num_iterations = 12
iqpe = get_algorithm_instance('IQPE')
iqpe.setup_quantum_backend(backend='local_qasm_simulator',
shots=100,
skip_transpiler=True)
state_in = get_initial_state_instance('CUSTOM')
state_in.init_args(self.qubitOp.num_qubits,
state_vector=self.ref_eigenvec)
iqpe.init_args(
self.qubitOp,
state_in,
num_time_slices,
num_iterations,
paulis_grouping='random',
expansion_mode='suzuki',
expansion_order=2,
)
result = iqpe.run()
# self.log.debug('operator paulis:\n{}'.format(self.qubitOp.print_operators('paulis')))
# self.log.debug('qpe circuit:\n\n{}'.format(result['circuit']['complete'].qasm()))
self.log.debug('top result str label: {}'.format(
result['top_measurement_label']))
self.log.debug('top result in decimal: {}'.format(
result['top_measurement_decimal']))
self.log.debug('stretch: {}'.format(
result['stretch']))
self.log.debug('translation: {}'.format(
result['translation']))
self.log.debug('final eigenvalue from QPE: {}'.format(
result['energy']))
self.log.debug('reference eigenvalue: {}'.format(
self.ref_eigenval))
self.log.debug('ref eigenvalue (transformed): {}'.format(
(self.ref_eigenval + result['translation']) * result['stretch']))
self.log.debug('reference binary str label: {}'.format(
decimal_to_binary((self.ref_eigenval + result['translation']) *
result['stretch'],
max_num_digits=num_iterations + 3,
fractional_part_only=True)))
np.testing.assert_approx_equal(self.ref_eigenval,
result['energy'],
significant=2)
def configurar_VQE(operadorqubit, UCCSD, cobyla, backend):
"""Esta función obtiene una instancia configurada del algoritmo VQE"""
VQE = get_algorithm_instance('VQE')
VQE.setup_quantum_backend(backend)
VQE.init_args(operadorqubit, 'matrix', UCCSD, cobyla)
return VQE
def test_qpe(self, distance):
self.algorithm = 'QPE'
self.log.debug(
'Testing End-to-End with QPE on H2 with inter-atomic distance {}.'.
format(distance))
cfg_mgr = ConfigurationManager()
pyscf_cfg = OrderedDict([('atom',
'H .0 .0 .0; H .0 .0 {}'.format(distance)),
('unit', 'Angstrom'), ('charge', 0),
('spin', 0), ('basis', 'sto3g')])
section = {}
section['properties'] = pyscf_cfg
try:
driver = cfg_mgr.get_driver_instance('PYSCF')
except ModuleNotFoundError:
self.skipTest('PYSCF driver does not appear to be installed')
self.molecule = driver.run(section)
ferOp = FermionicOperator(h1=self.molecule._one_body_integrals,
h2=self.molecule._two_body_integrals)
self.qubitOp = ferOp.mapping(
map_type='PARITY', threshold=1e-10).two_qubit_reduced_operator(2)
exact_eigensolver = get_algorithm_instance('ExactEigensolver')
exact_eigensolver.init_args(self.qubitOp, k=1)
results = exact_eigensolver.run()
self.reference_energy = results['energy']
self.log.debug('The exact ground state energy is: {}'.format(
results['energy']))
num_particles = self.molecule._num_alpha + self.molecule._num_beta
two_qubit_reduction = True
num_orbitals = self.qubitOp.num_qubits + (2 if two_qubit_reduction else
0)
qubit_mapping = 'parity'
num_time_slices = 50
n_ancillae = 9
qpe = get_algorithm_instance('QPE')
qpe.setup_quantum_backend(backend='local_qasm_simulator',
shots=100,
skip_transpiler=True)
state_in = get_initial_state_instance('HartreeFock')
state_in.init_args(self.qubitOp.num_qubits, num_orbitals,
qubit_mapping, two_qubit_reduction, num_particles)
iqft = get_iqft_instance('STANDARD')
iqft.init_args(n_ancillae)
qpe.init_args(self.qubitOp,
state_in,
iqft,
num_time_slices,
n_ancillae,
paulis_grouping='random',
expansion_mode='suzuki',
expansion_order=2)
result = qpe.run()
self.log.debug('measurement results: {}'.format(
result['measurements']))
self.log.debug('top result str label: {}'.format(
result['top_measurement_label']))
self.log.debug('top result in decimal: {}'.format(
result['top_measurement_decimal']))
self.log.debug('stretch: {}'.format(
result['stretch']))
self.log.debug('translation: {}'.format(
result['translation']))
self.log.debug('final energy from QPE: {}'.format(result['energy']))
self.log.debug('reference energy: {}'.format(
self.reference_energy))
self.log.debug('ref energy (transformed): {}'.format(
(self.reference_energy + result['translation']) *
result['stretch']))
self.log.debug('ref binary str label: {}'.format(
decimal_to_binary((self.reference_energy + result['translation']) *
result['stretch'],
max_num_digits=n_ancillae + 3,
fractional_part_only=True)))
np.testing.assert_approx_equal(result['energy'],
self.reference_energy,
significant=2)
