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)