def init_params(cls, params, algo_input): """ """ num_qubits = get_feature_dimension(algo_input.training_dataset) fea_map_params = params.get(QuantumAlgorithm.SECTION_KEY_FEATURE_MAP) fea_map_params['num_qubits'] = num_qubits feature_map = get_pluggable_class( PluggableType.FEATURE_MAP, fea_map_params['name']).init_params(fea_map_params) multiclass_extension = None multiclass_extension_params = params.get( QuantumAlgorithm.SECTION_KEY_MULTICLASS_EXTENSION, None) if multiclass_extension_params is not None: multiclass_extension_params['params'] = [feature_map] multiclass_extension_params[ 'estimator_cls'] = _QSVM_Kernel_Estimator multiclass_extension = get_pluggable_class( PluggableType.MULTICLASS_EXTENSION, multiclass_extension_params['name']).init_params( multiclass_extension_params) logger.info("Multiclass classifier based on {}".format( multiclass_extension_params['name'])) return cls(feature_map, algo_input.training_dataset, algo_input.test_dataset, algo_input.datapoints, multiclass_extension)
def init_params(cls, params, algo_input): algo_params = params.get(QuantumAlgorithm.SECTION_KEY_ALGORITHM) override_spsa_params = algo_params.get('override_SPSA_params') batch_mode = algo_params.get('batch_mode') # Set up optimizer opt_params = params.get(QuantumAlgorithm.SECTION_KEY_OPTIMIZER) # 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 = get_pluggable_class(PluggableType.OPTIMIZER, opt_params['name']).init_params(opt_params) # Set up feature map 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_pluggable_class(PluggableType.FEATURE_MAP, fea_map_params['name']).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_pluggable_class(PluggableType.VARIATIONAL_FORM, var_form_params['name']).init_params(var_form_params) return cls(optimizer, feature_map, var_form, algo_input.training_dataset, algo_input.test_dataset, algo_input.datapoints, batch_mode)
def init_params(cls, params, algo_input): """ Initialize via parameters dictionary and algorithm input instance. Args: params (dict): parameters dictionary algo_input (EnergyInput): EnergyInput instance Returns: VQE: vqe object """ if algo_input is None: raise AquaError("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') batch_mode = vqe_params.get('batch_mode') # 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_pluggable_class( PluggableType.INITIAL_STATE, init_state_params['name']).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_pluggable_class( PluggableType.VARIATIONAL_FORM, var_form_params['name']).init_params(var_form_params) # Set up optimizer opt_params = params.get(QuantumAlgorithm.SECTION_KEY_OPTIMIZER) optimizer = get_pluggable_class( PluggableType.OPTIMIZER, opt_params['name']).init_params(opt_params) return cls(operator, var_form, optimizer, operator_mode=operator_mode, initial_point=initial_point, batch_mode=batch_mode, aux_operators=algo_input.aux_ops)
def init_params(cls, params, algo_input): """ Initialize via parameters dictionary and algorithm input instance Args: params: parameters dictionary algo_input: EnergyInput instance """ if algo_input is None: raise AquaError("EnergyInput instance is required.") operator = algo_input.qubit_op iqpe_params = params.get(QuantumAlgorithm.SECTION_KEY_ALGORITHM) num_time_slices = iqpe_params.get(IQPE.PROP_NUM_TIME_SLICES) paulis_grouping = iqpe_params.get(IQPE.PROP_PAULIS_GROUPING) expansion_mode = iqpe_params.get(IQPE.PROP_EXPANSION_MODE) expansion_order = iqpe_params.get(IQPE.PROP_EXPANSION_ORDER) num_iterations = iqpe_params.get(IQPE.PROP_NUM_ITERATIONS) # 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_pluggable_class( PluggableType.INITIAL_STATE, init_state_params['name']).init_params(init_state_params) return cls(operator, init_state, num_time_slices=num_time_slices, num_iterations=num_iterations, paulis_grouping=paulis_grouping, expansion_mode=expansion_mode, expansion_order=expansion_order)
def init_params(cls, 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 AquaError("EnergyInput instance is required.") operator = algo_input.qubit_op qaoa_params = params.get(QuantumAlgorithm.SECTION_KEY_ALGORITHM) operator_mode = qaoa_params.get('operator_mode') p = qaoa_params.get('p') initial_point = qaoa_params.get('initial_point') batch_mode = qaoa_params.get('batch_mode') # Set up optimizer opt_params = params.get(QuantumAlgorithm.SECTION_KEY_OPTIMIZER) optimizer = get_pluggable_class( PluggableType.OPTIMIZER, opt_params['name']).init_params(opt_params) return cls(operator, optimizer, p=p, operator_mode=operator_mode, initial_point=initial_point, batch_mode=batch_mode, aux_operators=algo_input.aux_ops)
def init_params(cls, params, algo_input): """ Initialize via parameters dictionary and algorithm input instance. Args: params: parameters dictionary algo_input: EnergyInput instance """ if algo_input is None: raise AquaError("EnergyInput instance is required.") operator = algo_input.qubit_op evolution_fidelity_params = params.get( QuantumAlgorithm.SECTION_KEY_ALGORITHM) expansion_order = evolution_fidelity_params.get( EvolutionFidelity.PROP_EXPANSION_ORDER) # Set up initial state, we need to add computed num qubits to params initial_state_params = params.get( QuantumAlgorithm.SECTION_KEY_INITIAL_STATE) initial_state_params['num_qubits'] = operator.num_qubits initial_state = get_pluggable_class( PluggableType.INITIAL_STATE, initial_state_params['name']).init_params(initial_state_params) return cls(operator, initial_state, expansion_order)
def init_params(cls, params, algo_input): if algo_input is not None: raise AquaError("Unexpected Input instance.") bv_params = params.get(QuantumAlgorithm.SECTION_KEY_ALGORITHM) oracle_params = params.get(QuantumAlgorithm.SECTION_KEY_ORACLE) oracle = get_pluggable_class( PluggableType.ORACLE, oracle_params['name']).init_params(oracle_params) return cls(oracle)
def init_params(cls, params, algo_input): """ Initialize via parameters dictionary and algorithm input instance Args: params: parameters dictionary algo_input: EnergyInput instance """ if algo_input is None: raise AquaError("EnergyInput instance is required.") # For getting the extra operator, caller has to do something like: algo_input.add_aux_op(evo_op) operator = algo_input.qubit_op aux_ops = algo_input.aux_ops if aux_ops is None or len(aux_ops) != 1: raise AquaError( "EnergyInput, a single aux op is required for evaluation.") evo_operator = aux_ops[0] if evo_operator is None: raise AquaError("EnergyInput, invalid aux op.") dynamics_params = params.get(QuantumAlgorithm.SECTION_KEY_ALGORITHM) operator_mode = dynamics_params.get(EOH.PROP_OPERATOR_MODE) evo_time = dynamics_params.get(EOH.PROP_EVO_TIME) num_time_slices = dynamics_params.get(EOH.PROP_NUM_TIME_SLICES) paulis_grouping = dynamics_params.get(EOH.PROP_PAULIS_GROUPING) expansion_mode = dynamics_params.get(EOH.PROP_EXPANSION_MODE) expansion_order = dynamics_params.get(EOH.PROP_EXPANSION_ORDER) # Set up initial state, we need to add computed num qubits to params initial_state_params = params.get( QuantumAlgorithm.SECTION_KEY_INITIAL_STATE) initial_state_params['num_qubits'] = operator.num_qubits initial_state = get_pluggable_class( PluggableType.INITIAL_STATE, initial_state_params['name']).init_params(initial_state_params) return cls(operator, initial_state, evo_operator, operator_mode, evo_time, num_time_slices, paulis_grouping=paulis_grouping, expansion_mode=expansion_mode, expansion_order=expansion_order)
def init_params(cls, params, algo_input): svm_params = params.get(QuantumAlgorithm.SECTION_KEY_ALGORITHM) gamma = svm_params.get('gamma', None) multiclass_extension = None multiclass_extension_params = params.get( QuantumAlgorithm.SECTION_KEY_MULTICLASS_EXTENSION) if multiclass_extension_params is not None: multiclass_extension_params['estimator_cls'] = _RBF_SVC_Estimator multiclass_extension = get_pluggable_class( PluggableType.MULTICLASS_EXTENSION, multiclass_extension_params['name']).init_params( multiclass_extension_params) logger.info("Multiclass dataset with extension: {}".format( multiclass_extension_params['name'])) return cls(algo_input.training_dataset, algo_input.test_dataset, algo_input.datapoints, gamma, multiclass_extension)
def init_params(cls, params, algo_input): """ Initialize via parameters dictionary and algorithm input instance Args: params: parameters dictionary algo_input: input instance """ if algo_input is not None: raise AquaError("Unexpected Input instance.") grover_params = params.get(QuantumAlgorithm.SECTION_KEY_ALGORITHM) incremental = grover_params.get(Grover.PROP_INCREMENTAL) num_iterations = grover_params.get(Grover.PROP_NUM_ITERATIONS) cnx_mode = grover_params.get(Grover.PROP_CNX_MODE) oracle_params = params.get(QuantumAlgorithm.SECTION_KEY_ORACLE) oracle = get_pluggable_class(PluggableType.ORACLE, oracle_params['name']).init_params(oracle_params) return cls(oracle, incremental=incremental, num_iterations=num_iterations, cnx_mode=cnx_mode)
def init_params(cls, params, algo_input): """ Initialize via parameters dictionary and algorithm input instance. Args: params: parameters dictionary algo_input: EnergyInput instance """ if algo_input is None: raise AquaError("EnergyInput instance is required.") operator = algo_input.qubit_op evolution_fidelity_params = params.get(QuantumAlgorithm.SECTION_KEY_ALGORITHM) expansion_order = evolution_fidelity_params.get(EvolutionFidelity.PROP_EXPANSION_ORDER) # Set up initial state, we need to add computed num qubits to params initial_state_params = params.get(QuantumAlgorithm.SECTION_KEY_INITIAL_STATE) initial_state_params['num_qubits'] = operator.num_qubits initial_state = get_pluggable_class(PluggableType.INITIAL_STATE, initial_state_params['name']).init_params(initial_state_params) return cls(operator, initial_state, expansion_order)
def test_nlopt(self, name): optimizer = get_pluggable_class(PluggableType.OPTIMIZER, name)() optimizer.set_options(**{'max_evals': 50000}) res = self._optimize(optimizer) self.assertLessEqual(res[2], 50000)
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_pluggable_class( PluggableType.ALGORITHM, 'ExactEigensolver')(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 state_in = HartreeFock(self.qubitOp.num_qubits, num_orbitals, num_particles, qubit_mapping, two_qubit_reduction) iqft = get_pluggable_class(PluggableType.IQFT, 'STANDARD')(n_ancillae) qpe = get_pluggable_class(PluggableType.ALGORITHM, 'QPE')( self.qubitOp, state_in, iqft, num_time_slices, n_ancillae, paulis_grouping='random', expansion_mode='suzuki', expansion_order=2 ) qpe.setup_quantum_backend(backend='qasm_simulator', shots=100, skip_transpiler=True) 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)