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)