def init_params(self, params, algo_input):
algo_params = params.get(QuantumAlgorithm.SECTION_KEY_ALGORITHM)
override_spsa_params = algo_params.get('override_SPSA_params')
# Set up optimizer
opt_params = params.get(QuantumAlgorithm.SECTION_KEY_OPTIMIZER)
optimizer = get_optimizer_instance(opt_params['name'])
# If SPSA then override SPSA params as reqd to our predetermined values
if opt_params['name'] == 'SPSA' and override_spsa_params:
opt_params['c0'] = 4.0
opt_params['c1'] = 0.1
opt_params['c2'] = 0.602
opt_params['c3'] = 0.101
opt_params['c4'] = 0.0
opt_params['skip_calibration'] = True
optimizer.init_params(opt_params)
# Set up variational form
fea_map_params = params.get(QuantumAlgorithm.SECTION_KEY_FEATURE_MAP)
num_qubits = get_feature_dimension(algo_input.training_dataset)
fea_map_params['num_qubits'] = num_qubits
feature_map = get_feature_map_instance(fea_map_params['name'])
feature_map.init_params(fea_map_params)
# Set up variational form
var_form_params = params.get(QuantumAlgorithm.SECTION_KEY_VAR_FORM)
var_form_params['num_qubits'] = num_qubits
var_form = get_variational_form_instance(var_form_params['name'])
var_form.init_params(var_form_params)
self.init_args(algo_input.training_dataset, algo_input.test_dataset,
algo_input.datapoints, optimizer, feature_map, var_form)
def test_exact_eval(self):
depth = 1
var_form = get_variational_form_instance('RYRZ')
var_form.init_args(self.qubitOp.num_qubits, depth)
circuit = var_form.construct_circuit(
np.array(np.random.randn(var_form.num_parameters)))
execute_config = {'shots': 1, 'skip_transpiler': False}
matrix_mode = self.qubitOp.eval('matrix', circuit,
'local_statevector_simulator',
execute_config)[0]
non_matrix_mode = self.qubitOp.eval('paulis', circuit,
'local_statevector_simulator',
execute_config)[0]
diff = abs(matrix_mode - non_matrix_mode)
self.assertLess(
diff, 0.01, "Values: ({} vs {})".format(matrix_mode,
non_matrix_mode))
execute_config = {'shots': 1, 'skip_transpiler': True}
non_matrix_mode = self.qubitOp.eval('paulis', circuit,
'local_statevector_simulator',
execute_config)[0]
diff = abs(matrix_mode - non_matrix_mode)
self.assertLess(
diff, 0.01, "With skip_transpiler on, Values: ({} vs {})".format(
matrix_mode, non_matrix_mode))
def test_create_from_matrix(self):
"""
test with matrix initialization
"""
for num_qubits in range(1, 6):
m_size = np.power(2, num_qubits)
matrix = np.random.rand(m_size, m_size)
op = Operator(matrix=matrix)
depth = 1
var_form = get_variational_form_instance('RYRZ')
var_form.init_args(op.num_qubits, depth)
circuit = var_form.construct_circuit(
np.array(np.random.randn(var_form.num_parameters)))
execute_config = {'shots': 1, 'skip_transpiler': False}
non_matrix_mode = op.eval('paulis', circuit,
'local_statevector_simulator',
execute_config)[0]
matrix_mode = op.eval('matrix', circuit,
'local_statevector_simulator',
execute_config)[0]
self.assertAlmostEqual(matrix_mode, non_matrix_mode, 6)
def test_create_from_paulis_0(self):
"""
test with single paulis
"""
num_qubits = 4
for pauli_label in itertools.product('IXYZ', repeat=num_qubits):
coeff = np.random.random(1)[0]
pauli_term = [coeff, label_to_pauli(pauli_label)]
op = Operator(paulis=[pauli_term])
op.convert('paulis', 'matrix')
op.convert('paulis', 'grouped_paulis')
depth = 1
var_form = get_variational_form_instance('RYRZ')
var_form.init_args(op.num_qubits, depth)
circuit = var_form.construct_circuit(
np.array(np.random.randn(var_form.num_parameters)))
execute_config = {'shots': 1, 'skip_transpiler': False}
matrix_mode = op.eval('matrix', circuit,
'local_statevector_simulator',
execute_config)[0]
non_matrix_mode = op.eval('paulis', circuit,
'local_statevector_simulator',
execute_config)[0]
def init_params(self, params, algo_input):
# Set up optimizer
opt_params = params.get(QuantumAlgorithm.SECTION_KEY_OPTIMIZER)
optimizer = get_optimizer_instance(opt_params['name'])
# hard-coded params if SPSA is used.
if opt_params['name'] == 'SPSA' and opt_params['parameters'] is None:
opt_params['parameters'] = np.asarray(
[4.0, 0.1, 0.602, 0.101, 0.0])
optimizer.init_params(opt_params)
# Set up variational form
fea_map_params = params.get(QuantumAlgorithm.SECTION_KEY_FEATURE_MAP)
num_qubits = self._auto_detect_qubitnum(algo_input.training_dataset)
fea_map_params['num_qubits'] = num_qubits
feature_map = get_feature_map_instance(fea_map_params['name'])
feature_map.init_params(fea_map_params)
# Set up variational form
var_form_params = params.get(QuantumAlgorithm.SECTION_KEY_VAR_FORM)
var_form_params['num_qubits'] = num_qubits
var_form = get_variational_form_instance(var_form_params['name'])
var_form.init_params(var_form_params)
self.init_args(algo_input.training_dataset, algo_input.test_dataset,
algo_input.datapoints, optimizer, feature_map, var_form)
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_real_eval(self):
depth = 1
var_form = get_variational_form_instance('RYRZ')
var_form.init_args(self.qubitOp.num_qubits, depth)
circuit = var_form.construct_circuit(
np.array(np.random.randn(var_form.num_parameters)))
# self.qubitOp.coloring = None
execute_config_ref = {'shots': 1, 'skip_transpiler': False}
execute_config = {'shots': 10000, 'skip_transpiler': False}
reference = self.qubitOp.eval('matrix', circuit,
'local_statevector_simulator',
execute_config_ref)[0]
reference = reference.real
paulis_mode = self.qubitOp.eval('paulis', circuit,
'local_qasm_simulator', execute_config)
grouped_paulis_mode = self.qubitOp.eval('grouped_paulis', circuit,
'local_qasm_simulator',
execute_config)
paulis_mode_p_3sigma = paulis_mode[0] + 3 * paulis_mode[1]
paulis_mode_m_3sigma = paulis_mode[0] - 3 * paulis_mode[1]
grouped_paulis_mode_p_3sigma = grouped_paulis_mode[
0] + 3 * grouped_paulis_mode[1]
grouped_paulis_mode_m_3sigma = grouped_paulis_mode[
0] - 3 * grouped_paulis_mode[1]
self.assertLessEqual(reference, paulis_mode_p_3sigma.real)
self.assertGreaterEqual(reference, paulis_mode_m_3sigma.real)
self.assertLessEqual(reference, grouped_paulis_mode_p_3sigma.real)
self.assertGreaterEqual(reference, grouped_paulis_mode_m_3sigma.real)
execute_config = {'shots': 10000, 'skip_transpiler': True}
paulis_mode = self.qubitOp.eval('paulis', circuit,
'local_qasm_simulator', execute_config)
grouped_paulis_mode = self.qubitOp.eval('grouped_paulis', circuit,
'local_qasm_simulator',
execute_config)
paulis_mode_p_3sigma = paulis_mode[0] + 3 * paulis_mode[1]
paulis_mode_m_3sigma = paulis_mode[0] - 3 * paulis_mode[1]
grouped_paulis_mode_p_3sigma = grouped_paulis_mode[
0] + 3 * grouped_paulis_mode[1]
grouped_paulis_mode_m_3sigma = grouped_paulis_mode[
0] - 3 * grouped_paulis_mode[1]
self.assertLessEqual(reference, paulis_mode_p_3sigma.real,
"With skip_transpiler on")
self.assertGreaterEqual(reference, paulis_mode_m_3sigma.real,
"With skip_transpiler on")
self.assertLessEqual(reference, grouped_paulis_mode_p_3sigma.real,
"With skip_transpiler on")
self.assertGreaterEqual(reference, grouped_paulis_mode_m_3sigma.real,
"With skip_transpiler on")
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 init_params(self, params, algo_input):
"""
Initialize via parameters dictionary and algorithm input instance
Args:
params (dict): parameters dictionary
algo_input (EnergyInput): EnergyInput instance
"""
if algo_input is None:
raise AlgorithmError("EnergyInput instance is required.")
operator = algo_input.qubit_op
vqe_params = params.get(QuantumAlgorithm.SECTION_KEY_ALGORITHM)
operator_mode = vqe_params.get('operator_mode')
initial_point = vqe_params.get('initial_point')
# Set up initial state, we need to add computed num qubits to params
init_state_params = params.get(
QuantumAlgorithm.SECTION_KEY_INITIAL_STATE)
init_state_params['num_qubits'] = operator.num_qubits
init_state = get_initial_state_instance(init_state_params['name'])
init_state.init_params(init_state_params)
# Set up variational form, we need to add computed num qubits, and initial state to params
var_form_params = params.get(QuantumAlgorithm.SECTION_KEY_VAR_FORM)
var_form_params['num_qubits'] = operator.num_qubits
var_form_params['initial_state'] = init_state
var_form = get_variational_form_instance(var_form_params['name'])
var_form.init_params(var_form_params)
# Set up optimizer
opt_params = params.get(QuantumAlgorithm.SECTION_KEY_OPTIMIZER)
optimizer = get_optimizer_instance(opt_params['name'])
optimizer.init_params(opt_params)
if 'statevector' not in self._backend and operator_mode == 'matrix':
logger.debug('Qasm simulation does not work on {} mode, changing \
the operator_mode to paulis'.format(operator_mode))
operator_mode = 'paulis'
self.init_args(operator,
operator_mode,
var_form,
optimizer,
opt_init_point=initial_point,
aux_operators=algo_input.aux_ops)
logger.info(self.print_setting())
def configurar_UCCSD(operadorqubit, configuracionaqua, propiedadesmolecula,
HF):
"""Esta función obtiene una instancia configurada del método numérico UCCSD"""
UCCSD = get_variational_form_instance('UCCSD')
UCCSD.init_args(
operadorqubit.num_qubits,
depth=configuracionaqua["UCCSD"]["profundidad"],
num_orbitals=propiedadesmolecula["numero_de_orbitales"],
num_particles=propiedadesmolecula["numero_de_particulas"],
active_occupied=configuracionaqua["UCCSD"]
["orbitales_activos_ocupados"],
active_unoccupied=configuracionaqua["UCCSD"]
["orbitales_activos_no_ocupados"],
initial_state=HF,
qubit_mapping=configuracionaqua["general"]["tipo_de_mapeo"],
two_qubit_reduction=__necesaria_reduccion(
configuracionaqua["general"]["tipo_de_mapeo"]),
num_time_slices=configuracionaqua["UCCSD"]["numero_de_slices"])
return UCCSD
def test_sumbit_multiple_circutis(self):
"""
test with single paulis
"""
num_qubits = 4
pauli_term = []
for pauli_label in itertools.product('IXYZ', repeat=num_qubits):
coeff = np.random.random(1)[0]
pauli_term.append([coeff, label_to_pauli(pauli_label)])
op = Operator(paulis=pauli_term)
depth = 1
var_form = get_variational_form_instance('RYRZ')
var_form.init_args(op.num_qubits, depth)
circuit = var_form.construct_circuit(np.array(np.random.randn(var_form.num_parameters)))
execute_config = {'shots': 1, 'skip_transpiler': False}
non_matrix_mode = op.eval('paulis', circuit, 'local_statevector_simulator', execute_config)[0]
matrix_mode = op.eval('matrix', circuit, 'local_statevector_simulator', execute_config)[0]
self.assertAlmostEqual(matrix_mode, non_matrix_mode, 6)
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)
