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)
