Note

Cette page a été générée à partir de tutorials/finance/10_qgan_option_pricing.ipynb.

Exécuter en mode interactif dans le IBM Quantum lab.

** Tarification des options avec qGANs**

Introduction

Dans ce bloc-notes, nous discutons de la façon dont un algorithme d’apprentissage Quantum Machine Learning Algorithm, à savoir un Qgan (quantum Generative Adversarial Network), peut faciliter la tarification d’une option d’appel européen. Plus précisément, un qGAN peut être entrainé de telle sorte qu’un circuit quantique puisse représenter un modèle de prix au comptant d’un actif sous-jacent à une option d’appel européen. Le modèle qui en résulte peut ensuite être intégré à un algorithme basé sur l’estimation de l’amplitude quantique pour évaluer le paiement anticipé-voir « Prix de l’option d’appel européen » <03_european_call_option_pricing.ipynb>`__. Pour plus de détails sur l’apprentissage et le chargement des distributions aléatoires, veuillez vous référer à Quantum Generative Adversarial Networks for Learning and Loading Random Distributions. Zoufal, Lucchi, Woerner.

import matplotlib.pyplot as plt
import numpy as np

from qiskit import Aer, QuantumRegister, QuantumCircuit
from qiskit.circuit import ParameterVector
from qiskit.circuit.library import TwoLocal, NormalDistribution
from qiskit.quantum_info import Statevector

from qiskit.aqua import aqua_globals, QuantumInstance
from qiskit.aqua.algorithms import IterativeAmplitudeEstimation
from qiskit.finance.applications import EuropeanCallExpectedValue

Modèle d’incertitude

Le modèle Black-Scholes suppose que le prix au comptant à l’échéance :math:` S_T ` pour une option d’appel européen suite un loi de distribution log-normale. Ainsi, nous pouvons former un qGAN sur des échantillons à partir d’une distribution log-normale et utiliser le résultat comme un modèle d’incertitude sous-jacent à l’option. Dans ce qui suit, nous construisons un circuit quantique qui charge le modèle d’incertitude. La sortie du circuit représente

\[\big| g_{\theta}\rangle = \sum_{j=0}^{2^n-1}\sqrt{p_{\theta}^{j}} \big| j \rangle ,\]

où les probabilités :math:` p_ {theta } ^{j}`, pour :math:` jin left{0, ldots, { 2 ^ n-1 } right} `, représentent un modèle de la distribution cible.

# Set upper and lower data values
bounds = np.array([0.,7.])
# Set number of qubits used in the uncertainty model
num_qubits = 3

# Load the trained circuit parameters
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(num_qubits, mu=1., sigma=1., bounds=bounds)

# construct the variational form
var_form = TwoLocal(num_qubits, 'ry', 'cz', entanglement='circular', reps=1)

# keep a list of the parameters so we can associate them to the list of numerical values
# (otherwise we need a dictionary)
theta = var_form.ordered_parameters

# compose the generator circuit, this is the circuit loading the uncertainty model
g_circuit = init_dist.compose(var_form)

Evaluer le paiement attendu

Maintenant, le modèle d’incertitude ainsi entrainé peut être utilisé pour évaluer l’espérance de la fonction de paiement de l’option grâce à l’estimation d’amplitude quantique.

# 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.25

# construct circuit for payoff function
european_call_objective = EuropeanCallExpectedValue(
    num_qubits,
    strike_price=strike_price,
    rescaling_factor=c_approx,
    bounds=bounds
)

Traçage de la distribution des probabilités

Ensuite, nous traçons la distribution de probabilité entrainée, ainsi que la distribution de probabilité cible, pour des raisons de comparaison.

# Evaluate trained probability distribution
values = [bounds[0] + (bounds[1] - bounds[0]) * x / (2 ** num_qubits - 1) for x in range(2**num_qubits)]
uncertainty_model = g_circuit.assign_parameters(dict(zip(theta, g_params)))
amplitudes = Statevector.from_instruction(uncertainty_model).data

x = np.array(values)
y = np.abs(amplitudes) ** 2

# Sample from target probability distribution
N = 100000
log_normal = np.random.lognormal(mean=1, sigma=1, size=N)
log_normal = np.round(log_normal)
log_normal = log_normal[log_normal <= 7]
log_normal_samples = []
for i in range(8):
    log_normal_samples += [np.sum(log_normal==i)]
log_normal_samples = np.array(log_normal_samples / sum(log_normal_samples))

# Plot distributions
plt.bar(x, y, width=0.2, label='trained distribution', color='royalblue')
plt.xticks(x, size=15, rotation=90)
plt.yticks(size=15)
plt.grid()
plt.xlabel('Spot Price at Maturity $S_T$ (\$)', size=15)
plt.ylabel('Probability ($\%$)', size=15)
plt.plot(log_normal_samples,'-o', color ='deepskyblue', label='target distribution', linewidth=4, markersize=12)
plt.legend(loc='best')
plt.show()

Evaluer le paiement attendu

Maintenant, le modèle d’incertitude ainsi entrainé peut être utilisé pour évaluer l’espérance de la fonction de paiement de l’option grâce à l’estimation d’amplitude quantique.

# Evaluate payoff for different distributions
payoff = np.array([0,0,0,1,2,3,4,5])
ep = np.dot(log_normal_samples, payoff)
print("Analytically calculated expected payoff w.r.t. the target distribution:  %.4f" % ep)
ep_trained = np.dot(y, payoff)
print("Analytically calculated expected payoff w.r.t. the trained distribution: %.4f" % ep_trained)

# Plot exact payoff function (evaluated on the grid of the trained uncertainty model)
x = np.array(values)
y_strike = np.maximum(0, x - strike_price)
plt.plot(x, y_strike, 'ro-')
plt.grid()
plt.title('Payoff Function', size=15)
plt.xlabel('Spot Price', size=15)
plt.ylabel('Payoff', size=15)
plt.xticks(x, size=15, rotation=90)
plt.yticks(size=15)
plt.show()

Analytically calculated expected payoff w.r.t. the target distribution:  1.0591
Analytically calculated expected payoff w.r.t. the trained distribution: 0.9805

# construct A operator for QAE
european_call = european_call_objective.compose(uncertainty_model, front=True)

# set target precision and confidence level
epsilon = 0.01
alpha = 0.05

# construct amplitude estimation
ae = IterativeAmplitudeEstimation(epsilon=epsilon, alpha=alpha,
                                  state_preparation=european_call,
                                  objective_qubits=[num_qubits],
                                  post_processing=european_call_objective.post_processing)

result = ae.run(quantum_instance=Aer.get_backend('qasm_simulator'), shots=100)

conf_int = np.array(result['confidence_interval'])
print('Exact value:        \t%.4f' % ep_trained)
print('Estimated value:    \t%.4f' % (result['estimation']))
print('Confidence interval:\t[%.4f, %.4f]' % tuple(conf_int))

Exact value:            0.9805
Estimated value:        1.0070
Confidence interval:    [0.9806, 1.0334]

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	0.23.3
Terra	0.16.2
Aer	0.7.3
Ignis	0.5.1
Aqua	0.8.1
IBM Q Provider	0.11.1
System information
Python	3.8.5 (default, Sep 4 2020, 07:30:14) [GCC 7.3.0]
OS	Linux
CPUs	2
Memory (Gb)	3.7363624572753906
Thu Jan 28 21:29:04 2021 IST

This code is a part of Qiskit

© Copyright IBM 2017, 2021.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.