def run_ae_for_cdf(x_eval,
num_eval_qubits=3,
simulator='statevector_simulator'):
# run amplitude estimation
multivariate_var = get_cdf_operator_factory(x_eval)
ae_var = AmplitudeEstimation(num_eval_qubits, multivariate_var)
result_var = ae_var.run(BasicAer.get_backend(simulator))
return result_var['estimation']
def test_expected_value(self, simulator):
# number of qubits to represent the uncertainty
num_uncertainty_qubits = 3
# parameters for considered random distribution
S = 2.0 # initial spot price
vol = 0.4 # volatility of 40%
r = 0.05 # annual interest rate of 4%
T = 40 / 365 # 40 days to maturity
# resulting parameters for log-normal distribution
mu = ((r - 0.5 * vol**2) * T + np.log(S))
sigma = vol * np.sqrt(T)
mean = np.exp(mu + sigma**2 / 2)
variance = (np.exp(sigma**2) - 1) * np.exp(2 * mu + sigma**2)
stddev = np.sqrt(variance)
# lowest and highest value considered for the spot price; in between, an equidistant discretization is considered.
low = np.maximum(0, mean - 3 * stddev)
high = mean + 3 * stddev
# construct circuit factory for uncertainty model
uncertainty_model = LogNormalDistribution(num_uncertainty_qubits,
mu=mu,
sigma=sigma,
low=low,
high=high)
# set the strike price (should be within the low and the high value of the uncertainty)
strike_price = 2
# set the approximation scaling for the payoff function
c_approx = 0.5
# construct circuit factory for payoff function
european_call = EuropeanCallExpectedValue(uncertainty_model,
strike_price=strike_price,
c_approx=c_approx)
# set number of evaluation qubits (samples)
m = 3
# construct amplitude estimation
ae = AmplitudeEstimation(m, european_call)
# run simulation
quantum_instance = QuantumInstance(BasicAer.get_backend(simulator),
circuit_caching=False)
result = ae.run(quantum_instance=quantum_instance)
# compare to precomputed solution
self.assertEqual(
0.0, np.round(result['estimation'] - 0.045705353233, decimals=4))
def EstimatedVaR(x):
cdf_objective = FixedValueComparator(agg.num_sum_qubits, x + 1, geq=False)
multivariate_var = MultivariateProblem(u, agg, cdf_objective)
num_eval_qubits = 4
ae_var = AmplitudeEstimation(num_eval_qubits, multivariate_var)
result_var = ae_var.run(
quantum_instance=BasicAer.get_backend('statevector_simulator'))
#print("result_var['estimation']: ", result_var['estimation'])
return result_var['estimation']
def evaluate_expected_payoff(self):
# Set number of evaluation qubits (=log(samples))
m = 6
# Amplitude estimation
ae = AmplitudeEstimation(m, self.european_payoff)
self.result = ae.run(quantum_instance=BasicAer.get_backend('statevector_simulator'))
print('---------------------------')
print('Exact value: \t%.4f' % self.exact_value)
print('Estimated value:\t%.4f' % self.result['estimation'])
print('Probability: \t%.4f' % self.result['max_probability'])
print('---------------------------\n')
def test_ecev(self):
""" European Call Expected Value test """
bounds = np.array([0., 7.])
num_qubits = [3]
entangler_map = []
for i in range(sum(num_qubits)):
entangler_map.append([i, int(np.mod(i + 1, sum(num_qubits)))])
g_params = [
0.29399714, 0.38853322, 0.9557694, 0.07245791, 6.02626428,
0.13537225
]
# Set an initial state for the generator circuit
init_dist = NormalDistribution(int(sum(num_qubits)),
mu=1.,
sigma=1.,
low=bounds[0],
high=bounds[1])
init_distribution = np.sqrt(init_dist.probabilities)
init_distribution = Custom(num_qubits=sum(num_qubits),
state_vector=init_distribution)
var_form = TwoLocal(int(np.sum(num_qubits)),
'ry',
'cz',
reps=1,
initial_state=init_distribution,
entanglement=entangler_map)
uncertainty_model = UnivariateVariationalDistribution(int(
sum(num_qubits)),
var_form,
g_params,
low=bounds[0],
high=bounds[1])
strike_price = 2
c_approx = 0.25
european_call = EuropeanCallExpectedValue(uncertainty_model,
strike_price=strike_price,
c_approx=c_approx)
uncertainty_model.set_probabilities(
QuantumInstance(BasicAer.get_backend('statevector_simulator')))
algo = AmplitudeEstimation(5, european_call)
result = algo.run(
quantum_instance=BasicAer.get_backend('statevector_simulator'))
self.assertAlmostEqual(result['estimation'], 1.2580, places=4)
self.assertAlmostEqual(result['max_probability'], 0.8785, places=4)
def test_readme_sample(self):
""" readme sample test """
# pylint: disable=import-outside-toplevel,redefined-builtin
def print(*args):
""" overloads print to log values """
if args:
self.log.debug(args[0], *args[1:])
# --- Exact copy of sample code ----------------------------------------
import numpy as np
from qiskit import BasicAer
from qiskit.aqua.algorithms import AmplitudeEstimation
from qiskit.aqua.components.uncertainty_models import MultivariateNormalDistribution
from qiskit.finance.components.uncertainty_problems import FixedIncomeExpectedValue
# Create a suitable multivariate distribution
mvnd = MultivariateNormalDistribution(num_qubits=[2, 2],
low=[0, 0],
high=[0.12, 0.24],
mu=[0.12, 0.24],
sigma=0.01 * np.eye(2))
# Create fixed income component
fixed_income = FixedIncomeExpectedValue(mvnd,
np.eye(2),
np.zeros(2),
cash_flow=[1.0, 2.0],
c_approx=0.125)
# Set number of evaluation qubits (samples)
num_eval_qubits = 5
# Construct and run amplitude estimation
algo = AmplitudeEstimation(num_eval_qubits, fixed_income)
result = algo.run(BasicAer.get_backend('statevector_simulator'))
print('Estimated value:\t%.4f' % result['estimation'])
print('Probability: \t%.4f' % result['max_probability'])
# ----------------------------------------------------------------------
self.assertAlmostEqual(result['estimation'], 2.46, places=4)
self.assertAlmostEqual(result['max_probability'], 0.8487, places=4)
def evaluate_delta(self):
# Set number of evaluation qubits (=log(samples))
m = 6
# Amplitude estimation
ae_delta = AmplitudeEstimation(m, self.european_delta)
self.result_delta = ae_delta.run(quantum_instance=BasicAer.get_backend('statevector_simulator'))
print('---------------------------')
print('Exact delta: \t%.4f' % self.exact_delta)
if self.value == str("call"):
print('Estimated value:\t%.4f' % self.result_delta['estimation'])
else: print('Estimated value:\t%.4f' % -self.result_delta['estimation'])
print('Probability: \t%.4f' % self.result_delta['max_probability'])
print('---------------------------\n')
def test_expected_value(self, simulator):
# can be used in case a principal component analysis has been done to derive the uncertainty model, ignored in this example.
A = np.eye(2)
b = np.zeros(2)
# specify the number of qubits that are used to represent the different dimenions of the uncertainty model
num_qubits = [2, 2]
# specify the lower and upper bounds for the different dimension
low = [0, 0]
high = [0.12, 0.24]
mu = [0.12, 0.24]
sigma = 0.01 * np.eye(2)
# construct corresponding distribution
u = MultivariateNormalDistribution(num_qubits, low, high, mu, sigma)
# specify cash flow
cf = [1.0, 2.0]
# specify approximation factor
c_approx = 0.125
# get fixed income circuit appfactory
fixed_income = FixedIncomeExpectedValue(u, A, b, cf, c_approx)
# set number of evaluation qubits (samples)
m = 5
# construct amplitude estimation
ae = AmplitudeEstimation(m, fixed_income)
# run simulation
quantum_instance = QuantumInstance(
BasicAer.get_backend('statevector_simulator'),
circuit_caching=False)
result = ae.run(quantum_instance=quantum_instance)
# compare to precomputed solution
self.assertEqual(0.0,
np.round(result['estimation'] - 2.4600, decimals=4))
def test_deprecated_qft(self):
"""Test running QAE on the deprecated QFT."""
prob = 0.2
a_factory = BernoulliAFactory(prob)
q_factory = BernoulliQFactory(a_factory)
warnings.filterwarnings('ignore', category=DeprecationWarning)
iqft = Standard(2)
qae = AmplitudeEstimation(2,
a_factory=a_factory,
q_factory=q_factory,
iqft=iqft)
result = qae.run(self._statevector)
warnings.filterwarnings('always', category=DeprecationWarning)
expected = {'estimation': 0.5, 'mle': 0.2}
for key, value in expected.items():
self.assertAlmostEqual(value,
result[key],
places=3,
msg="estimate `{}` failed".format(key))
num_qubits = multivariate.num_target_qubits
#trouver le nombre de qubits auxilliaires pour notre problème
num_ancillas = multivariate.required_ancillas()
#construction des registres et du circuit
q = QuantumRegister(num_qubits, name='q')
q_a = QuantumRegister(num_ancillas, name='q_a')
qc = QuantumCircuit(q, q_a)
multivariate.build(qc, q, q_a)
# executer l'estimation
num_eval_qubits = 5
ae = AmplitudeEstimation(num_eval_qubits, multivariate)
#executer le QAE pour estimer la perte
result = ae.run(quantum_instance=BasicAer.get_backend('statevector_simulator'))
print('Exact Expected Loss E[L]: \t%.4f' % expected_loss)
print('Estimated Expected Loss E[L]: \t%.4f' % result['estimation'])
print('probability: \t%.4f' % result['max_probability'])
# # tracer les valeurs estimées pour "a".
# plt.bar(result['values'], result['probabilities'], width=0.5/len(result['probabilities']))
# plt.xticks([0, 0.25, 0.5, 0.75, 1], size=15)
# plt.yticks([0, 0.25, 0.5, 0.75, 1], size=15)
# plt.title('"a" Value', size=15)
# plt.ylabel('Probability', size=15)
# plt.ylim((0,1))
# plt.grid()
# plt.show()
def test_ecev(self, use_circuits):
""" European Call Expected Value test """
if not use_circuits:
# ignore deprecation warnings from the deprecation of VariationalForm as input for
# the univariate variational distribution
warnings.filterwarnings("ignore", category=DeprecationWarning)
bounds = np.array([0., 7.])
num_qubits = [3]
entangler_map = []
for i in range(sum(num_qubits)):
entangler_map.append([i, int(np.mod(i + 1, sum(num_qubits)))])
g_params = [
0.29399714, 0.38853322, 0.9557694, 0.07245791, 6.02626428,
0.13537225
]
# Set an initial state for the generator circuit
init_dist = NormalDistribution(int(sum(num_qubits)),
mu=1.,
sigma=1.,
low=bounds[0],
high=bounds[1])
init_distribution = np.sqrt(init_dist.probabilities)
init_distribution = Custom(num_qubits=sum(num_qubits),
state_vector=init_distribution)
var_form = RY(int(np.sum(num_qubits)),
depth=1,
initial_state=init_distribution,
entangler_map=entangler_map,
entanglement_gate='cz')
if use_circuits:
theta = ParameterVector('θ', var_form.num_parameters)
var_form = var_form.construct_circuit(theta)
uncertainty_model = UnivariateVariationalDistribution(int(
sum(num_qubits)),
var_form,
g_params,
low=bounds[0],
high=bounds[1])
if use_circuits:
uncertainty_model._var_form_params = theta
strike_price = 2
c_approx = 0.25
european_call = EuropeanCallExpectedValue(uncertainty_model,
strike_price=strike_price,
c_approx=c_approx)
uncertainty_model.set_probabilities(
QuantumInstance(BasicAer.get_backend('statevector_simulator')))
algo = AmplitudeEstimation(5, european_call)
result = algo.run(
quantum_instance=BasicAer.get_backend('statevector_simulator'))
self.assertAlmostEqual(result['estimation'], 1.2580, places=4)
self.assertAlmostEqual(result['max_probability'], 0.8785, places=4)
if not use_circuits:
warnings.filterwarnings(action="always",
category=DeprecationWarning)
