def __init__(self,
operator,
var_form,
optimizer,
initial_point=None,
max_evals_grouped=1,
aux_operators=None,
callback=None,
auto_conversion=True):
"""
Args:
operator (BaseOperator): Qubit operator
var_form (VariationalForm): parametrized variational form.
optimizer (Optimizer): the classical optimization algorithm.
initial_point (numpy.ndarray): optimizer initial point.
max_evals_grouped (int): max number of evaluations performed simultaneously
aux_operators (list[BaseOperator]): Auxiliary operators to be evaluated
at each eigenvalue
callback (Callable): a callback that can access the intermediate
data during the optimization.
Internally, four arguments are provided as follows
the index of evaluation, parameters of variational form,
evaluated mean, evaluated standard deviation.
auto_conversion (bool): an automatic conversion for operator and aux_operators
into the type which is most suitable for the backend.
- for *non-Aer statevector simulator:*
:class:`~qiskit.aqua.operators.MatrixOperator`
- for *Aer statevector simulator:*
:class:`~qiskit.aqua.operators.WeightedPauliOperator`
- for *qasm simulator or real backend:*
:class:`~qiskit.aqua.operators.TPBGroupedWeightedPauliOperator`
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__(var_form=var_form,
optimizer=optimizer,
cost_fn=self._energy_evaluation,
initial_point=initial_point)
self._use_simulator_snapshot_mode = None
self._ret = None
self._eval_time = None
self._optimizer.set_max_evals_grouped(max_evals_grouped)
self._callback = callback
if initial_point is None:
self._initial_point = var_form.preferred_init_points
self._operator = operator
self._eval_count = 0
self._aux_operators = []
if aux_operators is not None:
aux_operators = \
[aux_operators] if not isinstance(aux_operators, list) else aux_operators
for aux_op in aux_operators:
self._aux_operators.append(aux_op)
self._auto_conversion = auto_conversion
logger.info(self.print_settings())
self._var_form_params = ParameterVector('θ',
self._var_form.num_parameters)
self._parameterized_circuits = None
def __init__(self, maxfun=1000, factr=10, iprint=-1, max_processes=None):
r"""
Args:
maxfun (int): Maximum number of function evaluations.
factr (float): The iteration stops when (f\^k - f\^{k+1})/max{\|f\^k\|,
\|f\^{k+1}|,1} <= factr * eps, where eps is the machine precision,
which is automatically generated by the code. Typical values for
factr are: 1e12 for low accuracy; 1e7 for moderate accuracy;
10.0 for extremely high accuracy. See Notes for relationship to ftol,
which is exposed (instead of factr) by the scipy.optimize.minimize
interface to L-BFGS-B.
iprint (int): Controls the frequency of output. iprint < 0 means no output;
iprint = 0 print only one line at the last iteration; 0 < iprint < 99
print also f and \|proj g\| every iprint iterations; iprint = 99 print
details of every iteration except n-vectors; iprint = 100 print also the
changes of active set and final x; iprint > 100 print details of
every iteration including x and g.
max_processes (int): maximum number of processes allowed.
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
for k, v in locals().items():
if k in self._OPTIONS:
self._options[k] = v
self._max_processes = max_processes
def __init__(self, operator, k=1, aux_operators=None):
"""Constructor.
Args:
operator (MatrixOperator): instance
k (int): How many eigenvalues are to be computed
aux_operators (list[MatrixOperator]): Auxiliary operators
to be evaluated at each eigenvalue
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
self._operator = op_converter.to_matrix_operator(operator)
if aux_operators is None:
self._aux_operators = []
else:
aux_operators = \
[aux_operators] if not isinstance(aux_operators, list) else aux_operators
self._aux_operators = \
[op_converter.to_matrix_operator(aux_op) for aux_op in aux_operators]
self._k = k
if self._k > self._operator.matrix.shape[0]:
self._k = self._operator.matrix.shape[0]
logger.debug(
"WARNING: Asked for %s eigenvalues but max possible is %s.", k,
self._k)
self._ret = {}
def __init__(self,
maxiter=100,
disp=False,
ftol=1e-06,
tol=None,
eps=1.4901161193847656e-08):
"""
Constructor.
For details, please refer to
https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html.
Args:
maxiter (int): Maximum number of iterations.
disp (bool): Set to True to print convergence messages.
ftol (float): Precision goal for the value of f in the stopping criterion.
tol (float or None): Tolerance for termination.
eps (float): Step size used for numerical approximation of the Jacobian.
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
for k, v in locals().items():
if k in self._OPTIONS:
self._options[k] = v
self._tol = tol
def __init__(self, num_qubits, low=None, high=None, mu=None, sigma=None):
"""
Circuit Factory to build a circuit that represents a multivariate normal distribution.
Args:
num_qubits (Union(list, numpy.ndarray)): representing number of qubits per dimension
low (Union(list, numpy.ndarray)): representing lower bounds per dimension
high (Union(list, numpy.ndarray)): representing upper bounds per dimension
mu (Union(list, numpy.ndarray)): representing expected values
sigma (Union(list, numpy.ndarray)): representing co-variance matrix
"""
validate(locals(), self._INPUT_SCHEMA)
if not isinstance(sigma, np.ndarray):
sigma = np.asarray(sigma)
dimension = len(num_qubits)
if mu is None:
mu = np.zeros(dimension)
if sigma is None:
sigma = np.eye(dimension)
if low is None:
low = -np.ones(dimension)
if high is None:
high = np.ones(dimension)
self.mu = mu
self.sigma = sigma
probs = self._compute_probabilities([], num_qubits, low, high)
probs = np.asarray(probs) / np.sum(probs)
super().__init__(num_qubits, probs, low, high)
def __init__(self,
maxiter=1000,
eta=3.0,
tol=1e-6,
disp=False,
momentum=0.25):
"""
Constructor.
Performs Analytical Quantum Gradient Descent (AQGD).
Args:
maxiter (int): Maximum number of iterations, each iteration evaluation gradient.
eta (float): The coefficient of the gradient update. Increasing this value
results in larger step sizes: param = previous_param - eta * deriv
tol (float): The convergence criteria that must be reached before stopping.
Optimization stops when: absolute(loss - previous_loss) < tol
disp (bool): Set to true to display convergence messages.
momentum (float): Bias towards the previous gradient momentum in current update.
Must be within the bounds: [0,1)
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
self._eta = eta
self._maxiter = maxiter
self._tol = tol if tol is not None else 1e-6
self._disp = disp
self._momentum_coeff = momentum
self._previous_loss = None
def __init__(self,
maxfun=1000,
maxiter=15000,
factr=10,
iprint=-1,
epsilon=1e-08):
r"""
Uses scipy.optimize.fmin_l_bfgs_b
https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.fmin_l_bfgs_b.html
Args:
maxfun (int): Maximum number of function evaluations.
maxiter (int): Maximum number of iterations.
factr (float): The iteration stops when (f\^k - f\^{k+1})/max{\|f\^k\|,
\|f\^{k+1}\|,1} <= factr * eps, where eps is the machine precision,
which is automatically generated by the code. Typical values for
factr are: 1e12 for low accuracy; 1e7 for moderate accuracy;
10.0 for extremely high accuracy. See Notes for relationship to ftol,
which is exposed (instead of factr) by the scipy.optimize.minimize
interface to L-BFGS-B.
iprint (int): Controls the frequency of output. iprint < 0 means no output;
iprint = 0 print only one line at the last iteration; 0 < iprint < 99
print also f and \|proj g\| every iprint iterations; iprint = 99 print
details of every iteration except n-vectors; iprint = 100 print also the
changes of active set and final x; iprint > 100 print details of
every iteration including x and g.
epsilon (float): Step size used when approx_grad is True, for numerically
calculating the gradient
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
for k, v in locals().items():
if k in self._OPTIONS:
self._options[k] = v
def __init__(self, N=15, a=2):
"""
Constructor.
Args:
N (int): The integer to be factored.
a (int): A random integer a that satisfies a < N and gcd(a, N) = 1
Raises:
AquaError: invalid input
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
self._n = None
self._up_qreg = None
self._down_qreg = None
self._aux_qreg = None
# check the input integer
if N < 1 or N % 2 == 0:
raise AquaError('The input needs to be an odd integer greater than 1.')
self._N = N
if a >= N or math.gcd(a, self._N) != 1:
raise AquaError('The integer a needs to satisfy a < N and gcd(a, N) = 1.')
self._a = a
self._ret = {'factors': []}
# check if the input integer is a power
tf, b, p = is_power(N, return_decomposition=True)
if tf:
logger.info('The input integer is a power: %s=%s^%s.', N, b, p)
self._ret['factors'].append(b)
def __init__(self, operator, num_orbitals, num_particles, qubit_mapping='parity',
two_qubit_reduction=True, active_occupied=None, active_unoccupied=None,
is_eom_matrix_symmetric=True, se_list=None, de_list=None,
z2_symmetries=None, untapered_op=None, aux_operators=None):
"""
Args:
operator (BaseOperator): qubit operator
num_orbitals (int): total number of spin orbitals
num_particles (Union(list, int)): number of particles, if it is a list,
the first number is alpha and the second
number if beta.
qubit_mapping (str): qubit mapping type
two_qubit_reduction (bool): two qubit reduction is applied or not
active_occupied (list): list of occupied orbitals to include, indices are
0 to n where n is num particles // 2
active_unoccupied (list): list of unoccupied orbitals to include, indices are
0 to m where m is (num_orbitals - num particles) // 2
is_eom_matrix_symmetric (bool): is EoM matrix symmetric
se_list (list[list]): single excitation list, overwrite the setting in active space
de_list (list[list]): double excitation list, overwrite the setting in active space
z2_symmetries (Z2Symmetries): represent the Z2 symmetries
untapered_op (BaseOperator): if the operator is tapered, we need untapered operator
to build element of EoM matrix
aux_operators (list[BaseOperator]): Auxiliary operators to be evaluated at
each eigenvalue
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__(operator, 1, aux_operators)
self.qeom = QEquationOfMotion(operator, num_orbitals, num_particles, qubit_mapping,
two_qubit_reduction, active_occupied, active_unoccupied,
is_eom_matrix_symmetric, se_list, de_list,
z2_symmetries, untapered_op)
def __init__(self,
operator,
state_in,
iqft,
num_time_slices=1,
num_ancillae=1,
expansion_mode='trotter',
expansion_order=1,
shallow_circuit_concat=False):
"""
Args:
operator (BaseOperator): the hamiltonian Operator object
state_in (InitialState): the InitialState component
representing the initial quantum state
iqft (IQFT): the Inverse Quantum Fourier Transform component
num_time_slices (int): the number of time slices
num_ancillae (int): the number of ancillary qubits to use for the measurement
expansion_mode (str): the expansion mode (trotter|suzuki)
expansion_order (int): the suzuki expansion order
shallow_circuit_concat (bool): indicate whether to use shallow
(cheap) mode for circuit concatenation
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
self._operator = op_converter.to_weighted_pauli_operator(
operator.copy())
self._num_ancillae = num_ancillae
self._ret = {}
self._ret['translation'] = sum(
[abs(p[0]) for p in self._operator.reorder_paulis()])
self._ret['stretch'] = 0.5 / self._ret['translation']
# translate the operator
self._operator.simplify()
translation_op = WeightedPauliOperator([[
self._ret['translation'],
Pauli(np.zeros(self._operator.num_qubits),
np.zeros(self._operator.num_qubits))
]])
translation_op.simplify()
self._operator += translation_op
self._pauli_list = self._operator.reorder_paulis()
# stretch the operator
for p in self._pauli_list:
p[0] = p[0] * self._ret['stretch']
self._phase_estimation_circuit = PhaseEstimationCircuit(
operator=self._operator,
state_in=state_in,
iqft=iqft,
num_time_slices=num_time_slices,
num_ancillae=num_ancillae,
expansion_mode=expansion_mode,
expansion_order=expansion_order,
shallow_circuit_concat=shallow_circuit_concat,
pauli_list=self._pauli_list)
self._binary_fractions = [1 / 2**p for p in range(1, num_ancillae + 1)]
def __init__(self,
maxiter=None,
maxfev=1000,
disp=False,
xtol=0.0001,
tol=None):
"""
Constructor.
For details, please refer to
https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html.
Args:
maxiter (int): Maximum allowed number of iterations. If both maxiter and maxfev
are set, minimization will stop at the first reached.
maxfev (int): Maximum allowed number of function evaluations. If both maxiter and
maxfev are set, minimization will stop at the first reached.
disp (bool): Set to True to print convergence messages.
xtol (float): Relative error in solution xopt acceptable for convergence.
tol (float or None): Tolerance for termination.
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
for k, v in locals().items():
if k in self._OPTIONS:
self._options[k] = v
self._tol = tol
def __init__(self,
num_eval_qubits,
a_factory=None,
i_objective=None,
q_factory=None,
iqft=None):
"""
Args:
num_eval_qubits (int): number of evaluation qubits
a_factory (CircuitFactory): the CircuitFactory subclass object representing
the problem unitary
i_objective (int): i objective
q_factory (CircuitFactory): the CircuitFactory subclass object representing an
amplitude estimation sample (based on a_factory)
iqft (IQFT): the Inverse Quantum Fourier Transform component,
defaults to using a standard iqft when None
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__(a_factory, q_factory, i_objective)
# get parameters
self._m = num_eval_qubits
self._M = 2**num_eval_qubits
if iqft is None:
iqft = Standard(self._m)
self._iqft = iqft
self._circuit = None
self._ret = {}
def __init__(self,
feature_dimension,
depth=2,
entangler_map=None,
entanglement='full',
data_map_func=self_product):
"""Constructor.
Args:
feature_dimension (int): number of features
depth (int): the number of repeated circuits
entangler_map (list[list]): describe the connectivity of qubits, each list describes
[source, target], or None for full entanglement.
Note that the order is the list is the order of
applying the two-qubit gate.
entanglement (str): ['full', 'linear'], generate the qubit connectivity by predefined
topology
data_map_func (Callable): a mapping function for data x
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__(feature_dimension,
depth,
entangler_map,
entanglement,
z_order=2,
data_map_func=data_map_func)
def __init__(self, oracle):
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
self._oracle = oracle
self._circuit = None
self._ret = {}
def __init__(self,
matrix=None,
vector=None,
truncate_powerdim=False,
truncate_hermitian=False,
eigs=None,
init_state=None,
reciprocal=None,
num_q=0,
num_a=0,
orig_size=None):
"""
Constructor.
Args:
matrix (np.array): the input matrix of linear system of equations
vector (np.array): the input vector of linear system of equations
truncate_powerdim (bool): flag indicating expansion to 2**n matrix to be truncated
truncate_hermitian (bool): flag indicating expansion to hermitian matrix to be truncated
eigs (Eigenvalues): the eigenvalue estimation instance
init_state (InitialState): the initial quantum state preparation
reciprocal (Reciprocal): the eigenvalue reciprocal and controlled rotation instance
num_q (int): number of qubits required for the matrix Operator instance
num_a (int): number of ancillary qubits for Eigenvalues instance
orig_size (int): The original dimension of the problem (if truncate_powerdim)
Raises:
ValueError: invalid input
"""
super().__init__()
validate(locals(), self._INPUT_SCHEMA)
if matrix.shape[0] != matrix.shape[1]:
raise ValueError("Input matrix must be square!")
if matrix.shape[0] != len(vector):
raise ValueError("Input vector dimension does not match input "
"matrix dimension!")
if not np.allclose(matrix, matrix.conj().T):
raise ValueError("Input matrix must be hermitian!")
if np.log2(matrix.shape[0]) % 1 != 0:
raise ValueError("Input matrix dimension must be 2**n!")
if truncate_powerdim and orig_size is None:
raise ValueError("Truncation to {} dimensions is not "
"possible!".format(orig_size))
self._matrix = matrix
self._vector = vector
self._truncate_powerdim = truncate_powerdim
self._truncate_hermitian = truncate_hermitian
self._eigs = eigs
self._init_state = init_state
self._reciprocal = reciprocal
self._num_q = num_q
self._num_a = num_a
self._circuit = None
self._io_register = None
self._eigenvalue_register = None
self._ancilla_register = None
self._success_bit = None
self._original_dimension = orig_size
self._ret = {}
def __init__(self,
uncertainty_model,
strike_price,
c_approx,
i_state=None,
i_compare=None,
i_objective=None):
"""
Constructor.
Args:
uncertainty_model (UnivariateDistribution): uncertainty model for spot price
strike_price (float): strike price of the European option
c_approx (float): approximation factor for linear payoff
i_state (Optional(Union(list, numpy.ndarray))): indices of qubits
representing the uncertainty
i_compare (Optional(int)): index of qubit for comparing spot price to strike price
(enabling payoff or not)
i_objective (Optional(int)): index of qubit for objective function
"""
super().__init__(uncertainty_model.num_target_qubits + 2)
self._uncertainty_model = uncertainty_model
self._strike_price = strike_price
self._c_approx = c_approx
if i_state is None:
i_state = list(range(uncertainty_model.num_target_qubits))
self.i_state = i_state
if i_compare is None:
i_compare = uncertainty_model.num_target_qubits
self.i_compare = i_compare
if i_objective is None:
i_objective = uncertainty_model.num_target_qubits + 1
self.i_objective = i_objective
validate(locals(), self._INPUT_SCHEMA)
# map strike price to {0, ..., 2^n-1}
lb = uncertainty_model.low
ub = uncertainty_model.high
self._mapped_strike_price = int(
np.round((strike_price - lb) / (ub - lb) *
(uncertainty_model.num_values - 1)))
# create comparator
self._comparator = FixedValueComparator(
uncertainty_model.num_target_qubits, self._mapped_strike_price)
self.offset_angle_zero = np.pi / 4 * (1 - self._c_approx)
if self._mapped_strike_price < uncertainty_model.num_values - 1:
self.offset_angle = -1 * np.pi / 2 * self._c_approx * self._mapped_strike_price / \
(uncertainty_model.num_values - self._mapped_strike_price - 1)
self.slope_angle = np.pi / 2 * self._c_approx / \
(uncertainty_model.num_values - self._mapped_strike_price - 1)
else:
self.offset_angle = 0
self.slope_angle = 0
def __init__(self,
num_qubits,
state="zero",
state_vector=None,
circuit=None):
"""Constructor.
Args:
num_qubits (int): number of qubits
state (str): `zero`, `uniform` or `random`
state_vector (numpy.ndarray): customized vector
circuit (QuantumCircuit): the actual custom circuit for the desired initial state
Raises:
AquaError: invalid input
"""
# pylint: disable=comparison-with-callable
loc = locals().copy()
# since state_vector is a numpy array of complex numbers which aren't json valid,
# remove it from validation
del loc['state_vector']
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
self._num_qubits = num_qubits
self._state = state
size = np.power(2, self._num_qubits)
self._circuit = None
if circuit is not None:
if circuit.width() != num_qubits:
logger.warning('The specified num_qubits and '
'the provided custom circuit do not match.')
self._circuit = convert_to_basis_gates(circuit)
if state_vector is not None:
self._state = None
self._state_vector = None
logger.warning(
'The provided state_vector is ignored in favor of '
'the provided custom circuit.')
else:
if state_vector is None:
if self._state == 'zero':
self._state_vector = np.array([1.0] + [0.0] * (size - 1))
elif self._state == 'uniform':
self._state_vector = np.array([1.0 / np.sqrt(size)] * size)
elif self._state == 'random':
self._state_vector = normalize_vector(
aqua_globals.random.rand(size))
else:
raise AquaError('Unknown state {}'.format(self._state))
else:
if len(state_vector) != np.power(2, self._num_qubits):
raise AquaError(
'The state vector length {} is incompatible with '
'the number of qubits {}'.format(
len(state_vector), self._num_qubits))
self._state_vector = normalize_vector(state_vector)
self._state = None
def __init__(self, estimator_cls, params=None, code_size=4):
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
self.estimator_cls = estimator_cls
self.params = params if params is not None else []
self.code_size = code_size
self.rand = aqua_globals.random
self.estimators = None
self.classes = None
self.codebook = None
def __init__(self, feature_dimension=2):
"""Constructor.
Args:
feature_dimension (int): The feature dimension
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
self._feature_dimension = feature_dimension
self._num_qubits = next_power_of_2_base(feature_dimension)
def __init__(self, max_evals=1000): # pylint: disable=unused-argument
"""
Args:
max_evals (int): Maximum allowed number of function evaluations.
"""
validate(locals(), self._INPUT_SCHEMA)
check_nlopt_valid('CRS')
super().__init__()
for k, v in locals().items():
if k in self._OPTIONS:
self._options[k] = v
def __init__(self,
maxiter=10000,
tol=1e-6,
lr=1e-3,
beta_1=0.9,
beta_2=0.99,
noise_factor=1e-8,
eps=1e-10,
amsgrad=False,
snapshot_dir=None):
"""
Args:
maxiter (int): Maximum number of iterations
tol (float): Tolerance for termination
lr (float): Value >= 0, Learning rate.
beta_1 (float): Value in range 0 to 1, Generally close to 1.
beta_2 (float): Value in range 0 to 1, Generally close to 1.
noise_factor (float): Value >= 0, Noise factor
eps (float): Value >=0, Epsilon to be used for finite differences if no analytic
gradient method is given.
amsgrad (bool): True to use AMSGRAD, False if not
snapshot_dir (Optional(str)): If not None save the optimizer's parameter
after every step to the given directory
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
for k, v in locals().items():
if k in self._OPTIONS:
self._options[k] = v
self._maxiter = maxiter
self._snapshot_dir = snapshot_dir
self._tol = tol
self._lr = lr
self._beta_1 = beta_1
self._beta_2 = beta_2
self._noise_factor = noise_factor
self._eps = eps
self._amsgrad = amsgrad
self._t = 0 # time steps
self._m = np.zeros(1)
self._v = np.zeros(1)
if self._amsgrad:
self._v_eff = np.zeros(1)
if self._snapshot_dir:
with open(os.path.join(self._snapshot_dir, 'adam_params.csv'),
mode='w') as csv_file:
if self._amsgrad:
fieldnames = ['v', 'v_eff', 'm', 't']
else:
fieldnames = ['v', 'm', 't']
writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
writer.writeheader()
def __init__(self, matrix=None, vector=None):
"""Constructor.
Args:
matrix (array): the input matrix of linear system of equations
vector (array): the input vector of linear system of equations
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
self._matrix = matrix
self._vector = vector
self._ret = {}
def __init__(self, num_qubits, num_orbitals, num_particles,
qubit_mapping='parity', two_qubit_reduction=True, sq_list=None):
"""Constructor.
Args:
num_qubits (int): number of qubits
num_orbitals (int): number of spin orbitals
num_particles (Union(list, int)): number of particles, if it is a list, the first number
is alpha and the second number if beta.
qubit_mapping (str): mapping type for qubit operator
two_qubit_reduction (bool): flag indicating whether or not two qubit is reduced
sq_list (list[int]): position of the single-qubit operators that
anticommute with the cliffords
Raises:
ValueError: wrong setting in num_particles and num_orbitals.
ValueError: wrong setting for computed num_qubits and supplied num_qubits.
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
self._sq_list = sq_list
self._qubit_tapering = bool(self._sq_list)
self._qubit_mapping = qubit_mapping.lower()
self._two_qubit_reduction = two_qubit_reduction
if self._qubit_mapping != 'parity':
if self._two_qubit_reduction:
logger.warning("two_qubit_reduction only works with parity qubit mapping "
"but you have %s. We switch two_qubit_reduction "
"to False.", self._qubit_mapping)
self._two_qubit_reduction = False
self._num_orbitals = num_orbitals
if isinstance(num_particles, list):
self._num_alpha = num_particles[0]
self._num_beta = num_particles[1]
else:
logger.info("We assume that the number of alphas and betas are the same.")
self._num_alpha = num_particles // 2
self._num_beta = num_particles // 2
self._num_particles = self._num_alpha + self._num_beta
if self._num_particles > self._num_orbitals:
raise ValueError("# of particles must be less than or equal to # of orbitals.")
self._num_qubits = num_orbitals - 2 if self._two_qubit_reduction else self._num_orbitals
self._num_qubits = self._num_qubits \
if not self._qubit_tapering else self._num_qubits - len(sq_list)
if self._num_qubits != num_qubits:
raise ValueError("Computed num qubits {} does not match "
"actual {}".format(self._num_qubits, num_qubits))
self._bitstr = None
def __init__(self,
atom,
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g',
hf_method=HFMethodType.RHF,
conv_tol=1e-9,
max_cycle=50,
init_guess=InitialGuess.MINAO,
max_memory=None):
"""
Initializer
Args:
atom (str or list): atom list or string separated by semicolons or line breaks
unit (UnitsType): angstrom or bohr
charge (int): charge
spin (int): spin
basis (str): basis set
hf_method (HFMethodType): Hartree-Fock Method type
conv_tol (float): Convergence tolerance see PySCF docs and pyscf/scf/hf.py
max_cycle (int): Max convergence cycles see PySCF docs and pyscf/scf/hf.py
init_guess (InitialGuess): See PySCF pyscf/scf/hf.py init_guess_by_minao/1e/atom methods
max_memory (int): maximum memory
Raises:
QiskitChemistryError: Invalid Input
"""
self._check_valid()
if not isinstance(atom, list) and not isinstance(atom, str):
raise QiskitChemistryError(
"Invalid atom input for PYSCF Driver '{}'".format(atom))
if isinstance(atom, list):
atom = ';'.join(atom)
else:
atom = atom.replace('\n', ';')
unit = unit.value
hf_method = hf_method.value
init_guess = init_guess.value
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
self._atom = atom
self._unit = unit
self._charge = charge
self._spin = spin
self._basis = basis
self._hf_method = hf_method
self._conv_tol = conv_tol
self._max_cycle = max_cycle
self._init_guess = init_guess
self._max_memory = max_memory
def __init__(self,
oracle,
init_state=None,
incremental=False,
num_iterations=1,
mct_mode='basic'):
"""
Constructor.
Args:
oracle (Oracle): the oracle component
init_state (InitialState): the initial quantum state preparation
incremental (bool): boolean flag for whether to use incremental search mode or not
num_iterations (int): the number of iterations to use for amplitude amplification
mct_mode (str): mct mode
Raises:
AquaError: evaluate_classically() missing from the input oracle
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
if not callable(getattr(oracle, "evaluate_classically", None)):
raise AquaError(
'Missing the evaluate_classically() method from the provided oracle instance.'
)
self._oracle = oracle
self._mct_mode = mct_mode
self._init_state = \
init_state if init_state else Custom(len(oracle.variable_register), state='uniform')
self._init_state_circuit = \
self._init_state.construct_circuit(mode='circuit', register=oracle.variable_register)
self._init_state_circuit_inverse = self._init_state_circuit.inverse()
self._diffusion_circuit = self._construct_diffusion_circuit()
self._max_num_iterations = np.ceil(2**(len(oracle.variable_register) /
2))
self._incremental = incremental
self._num_iterations = num_iterations if not incremental else 1
validate(locals(), self._INPUT_SCHEMA)
if incremental:
logger.debug(
'Incremental mode specified, ignoring "num_iterations".')
else:
if num_iterations > self._max_num_iterations:
logger.warning(
'The specified value %s for "num_iterations" '
'might be too high.', num_iterations)
self._ret = {}
self._qc_aa_iteration = None
self._qc_amplitude_amplification = None
self._qc_measurement = None
def __init__(self, feature_dimension, depth=2, data_map_func=self_product):
"""Constructor.
Args:
feature_dimension (int): number of features
depth (int): the number of repeated circuits
data_map_func (Callable): a mapping function for data x
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__(feature_dimension,
depth,
z_order=1,
data_map_func=data_map_func)
def __init__(self,
training_dataset,
test_dataset=None,
datapoints=None,
gamma=None,
multiclass_extension=None):
# pylint: disable=line-too-long
"""
Args:
training_dataset (dict, optional): training dataset.
test_dataset (dict, optional): testing dataset.
datapoints (numpy.ndarray, optional): prediction dataset.
gamma (int, optional): Used as input for sklearn rbf_kernel internally. See
`sklearn.metrics.pairwise.rbf_kernel
<https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise.rbf_kernel.html>`_
for more information about gamma.
multiclass_extension (MultiExtension, optional): if number of classes > 2 then
a multiclass scheme is needed.
Raises:
AquaError: If using binary classifier where num classes >= 3
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
if training_dataset is None:
raise AquaError('Training dataset must be provided.')
is_multiclass = get_num_classes(training_dataset) > 2
if is_multiclass:
if multiclass_extension is None:
raise AquaError('Dataset has more than two classes. '
'A multiclass extension must be provided.')
else:
if multiclass_extension is not None:
logger.warning(
"Dataset has just two classes. Supplied multiclass "
"extension will be ignored")
if multiclass_extension is None:
svm_instance = _SVM_Classical_Binary(training_dataset,
test_dataset, datapoints,
gamma)
else:
svm_instance = _SVM_Classical_Multiclass(training_dataset,
test_dataset, datapoints,
gamma,
multiclass_extension)
self.instance = svm_instance
def __init__(self,
operator,
optimizer,
p=1,
initial_state=None,
mixer=None,
initial_point=None,
max_evals_grouped=1,
aux_operators=None,
callback=None,
auto_conversion=True):
"""
Args:
operator (BaseOperator): Qubit operator
p (int): the integer parameter p as specified in https://arxiv.org/abs/1411.4028
initial_state (InitialState): the initial state to prepend the QAOA circuit with
mixer (BaseOperator): the mixer Hamiltonian to evolve with. Allows support of
optimizations in constrained subspaces
as per https://arxiv.org/abs/1709.03489
optimizer (Optimizer): the classical optimization algorithm.
initial_point (numpy.ndarray): optimizer initial point.
max_evals_grouped (int): max number of evaluations to be performed simultaneously.
aux_operators (list): aux operators
callback (Callable): a callback that can access the intermediate
data during the optimization.
Internally, four arguments are provided as follows
the index of evaluation, parameters of variational form,
evaluated mean, evaluated standard deviation.
auto_conversion (bool): an automatic conversion for operator and aux_operators
into the type which is most suitable for the backend.
- for *non-Aer statevector simulator:*
:class:`~qiskit.aqua.operators.MatrixOperator`
- for *Aer statevector simulator:*
:class:`~qiskit.aqua.operators.WeightedPauliOperator`
- for *qasm simulator or real backend:*
:class:`~qiskit.aqua.operators.TPBGroupedWeightedPauliOperator`
"""
validate(locals(), self._INPUT_SCHEMA)
var_form = QAOAVarForm(operator.copy(),
p,
initial_state=initial_state,
mixer_operator=mixer)
super().__init__(operator,
var_form,
optimizer,
initial_point=initial_point,
max_evals_grouped=max_evals_grouped,
aux_operators=aux_operators,
callback=callback,
auto_conversion=auto_conversion)
def __init__(self, bitmaps, optimization=False, mct_mode='basic'):
"""
Constructor for Truth Table-based Oracle
Args:
bitmaps (Union(str, [str])): A single binary string or a list of binary strings
representing the desired single- and multi-value truth table.
optimization (bool): Boolean flag for attempting circuit optimization.
When set, the Quine-McCluskey algorithm is used to compute the prime
implicants of the truth table,
and then its exact cover is computed to try to reduce the circuit.
mct_mode (str): The mode to use when constructing multiple-control Toffoli.
Raises:
AquaError: invalid input
"""
if isinstance(bitmaps, str):
bitmaps = [bitmaps]
validate(locals(), self._INPUT_SCHEMA)
super().__init__()
self._mct_mode = mct_mode.strip().lower()
self._optimization = optimization
self._bitmaps = bitmaps
# check that the input bitmaps length is a power of 2
if not is_power_of_2(len(bitmaps[0])):
raise AquaError('Length of any bitmap must be a power of 2.')
for bitmap in bitmaps[1:]:
if not len(bitmap) == len(bitmaps[0]):
raise AquaError('Length of all bitmaps must be the same.')
self._nbits = int(math.log(len(bitmaps[0]), 2))
self._num_outputs = len(bitmaps)
self._lit_to_var = None
self._var_to_lit = None
esop_exprs = []
for bitmap in bitmaps:
esop_expr = self._get_esop_ast(bitmap)
esop_exprs.append(esop_expr)
self._esops = [
ESOP(esop_expr, num_vars=self._nbits) for esop_expr in esop_exprs
] if esop_exprs else None
self.construct_circuit()
def __init__(self, num_target_qubits, mu=0, sigma=1, low=-1, high=1):
r"""
Args:
num_target_qubits (int): number of qubits it acts on
mu (float): expected value of considered normal distribution
sigma (float): standard deviation of considered normal distribution
low (float): lower bound, i.e., the value corresponding to \|0...0>
(assuming an equidistant grid)
high (float): upper bound, i.e., the value corresponding to \|1...1>
(assuming an equidistant grid)
"""
validate(locals(), self._INPUT_SCHEMA)
probabilities, _ = UnivariateDistribution.\
pdf_to_probabilities(
lambda x: norm.pdf(x, mu, sigma), low, high, 2 ** num_target_qubits)
super().__init__(num_target_qubits, probabilities, low, high)