Note

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

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

**Evaluation des actifs à revenu fixe ( Fixed-Income Assets ) **

Introduction

Nous cherchons à évaluer le prix d’un actif à revenu fixe en connaissant les distributions décrivant les taux d’intérêt inhérents. Les flux de trésorerie \(c_t\) de l’actif et les dates auxquelles ils se produisent sont connus. La valeur totale \(V\) de l’actif est donc la valeur attendue de :

\[V = \sum_{t=1}^T \frac{c_t}{(1+r_t)^t}\]

Chaque flux de trésorerie est traité comme une obligation zéro-coupon avec un taux d’intérêt correspondant :math:` r_t ` qui dépend de sa maturité. L’utilisateur doit spécifier la distribution modélisant l’incertitude pour chaque :math:` r_t ` (probablement corrélés) ainsi que le nombre de qubits qu’il souhaite utiliser pour échantillonner chaque distribution. Dans cet exemple, nous développons la valeur de l’actif au premier ordre par rapport aux taux d’intérêt :math:` r_t `. Cela correspond à l’étude de l’actif en fonction de sa duration. L’approximation de la fonction objectif suit le document suivant: Analyse des risques quantiques. Woerner, Egger. 2018.

import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from qiskit import Aer, QuantumCircuit
from qiskit.aqua.algorithms import IterativeAmplitudeEstimation
from qiskit.circuit.library import NormalDistribution

backend = Aer.get_backend('statevector_simulator')

Modèle d’Incertitude

Nous construisons un circuit afin de représenter une distribution aléatoire en dimension \(d\) sur un état quantique sur \(n\) qubits. La distribution est limitée à l’intervalle \(\otimes_{i=1}^d [low_i, high_i]\) et discrétisée en utilisant \(2^{n_i}\) points, où \(n_i\): correspond au nombre de qubits utilisés. L’opérateur unitaire correspondant à ce circuit est le suivant :

\[\big|0\rangle_{n_1}\ldots\big|0\rangle_{n_d} \mapsto \big|\psi\rangle = \sum_{i_1=0}^{2^n_-1}\ldots\sum_{i_d=0}^{2^n_-1} \sqrt{p_{i_1,...,i_d}}\big|i_1\rangle_{n_1}\ldots\big|i_d\rangle_{n_d},\]

où \(p_{i_1, ..., i_d}\) représentent les probabilités de chaque distribution tronquée et discrétisée et où \(i_j\) est mappé sur l’intervalle approprié \([low_j, high_j]\) en utilisant la relation affine suivante :

\[\{0, \ldots, 2^{n_{j}}-1\} \ni i_j \mapsto \frac{high_j - low_j}{2^{n_j} - 1} * i_j + low_j \in [low_j, high_j].\]

En plus du modèle d’incertitude, nous pouvons également appliquer une correspondance affine, résultant par exemple d’une analyse en composantes principales. Les taux d’intérêt utilisés sont alors donnés par:

\[\vec{r} = A * \vec{x} + b,\]

où :math:vec{x} in otimes_{i=1}^d [low_i, high_i]` suit une distribution aléatoire donnée.

# 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
bounds = list(zip(low, high))
u = NormalDistribution(num_qubits, mu, sigma, bounds)

# plot contour of probability density function
x = np.linspace(low[0], high[0], 2**num_qubits[0])
y = np.linspace(low[1], high[1], 2**num_qubits[1])
z = u.probabilities.reshape(2**num_qubits[0], 2**num_qubits[1])
plt.contourf(x, y, z)
plt.xticks(x, size=15)
plt.yticks(y, size=15)
plt.grid()
plt.xlabel('$r_1$ (%)', size=15)
plt.ylabel('$r_2$ (%)', size=15)
plt.colorbar()
plt.show()

Flux de trésorerie, fonction de paiement et valeur attendue

Dans ce qui suit, nous définissons le flux de trésorerie par période, la fonction de paiement qui en résulte et évaluons la valeur attendue.

Pour la fonction de paiement, nous utilisons d’abord une approximation de premier ordre, puis on applique la même technique d’approximation que pour la partie linéaire de la fonction de paiement de l’option d’achat Européenne « European Call Option <03_european_call_option_pricing.ipynb>`__.

# specify cash flow
cf = [1.0, 2.0]
periods = range(1, len(cf) + 1)

# plot cash flow
plt.bar(periods, cf)
plt.xticks(periods, size=15)
plt.yticks(size=15)
plt.grid()
plt.xlabel('periods', size=15)
plt.ylabel('cashflow ($)', size=15)
plt.show()

# estimate real value
cnt = 0
exact_value = 0.0
for x1 in np.linspace(low[0], high[0], pow(2, num_qubits[0])):
    for x2 in np.linspace(low[1], high[1], pow(2, num_qubits[1])):
        prob = u.probabilities[cnt]
        for t in range(len(cf)):
            # evaluate linear approximation of real value w.r.t. interest rates
            exact_value += prob * (cf[t]/pow(1 + b[t], t+1) - (t+1)*cf[t]*np.dot(A[:, t], np.asarray([x1, x2]))/pow(1 + b[t], t+2))
        cnt += 1
print('Exact value:    \t%.4f' % exact_value)

Exact value:            2.1942

# specify approximation factor
c_approx = 0.125

# get fixed income circuit appfactory
from qiskit.finance.applications import FixedIncomeExpectedValue
fixed_income = FixedIncomeExpectedValue(num_qubits, A, b, cf, c_approx, bounds)

fixed_income.draw()

q_0: ───────────────────■──────────────────────────────────────────────────
                        │
q_1: ───────────────────┼─────────────■────────────────────────────────────
                        │             │
q_2: ───────────────────┼─────────────┼─────────────■──────────────────────
                        │             │             │
q_3: ───────────────────┼─────────────┼─────────────┼─────────────■────────
     ┌───────────┐┌─────┴──────┐┌─────┴──────┐┌─────┴─────┐┌──────┴───────┐
q_4: ┤ RY(9π/16) ├┤ RY(-π/216) ├┤ RY(-π/108) ├┤ RY(-π/27) ├┤ RY(-0.23271) ├
     └───────────┘└────────────┘└────────────┘└───────────┘└──────────────┘

state_preparation = QuantumCircuit(fixed_income.num_qubits)

# load probability distribution
state_preparation.append(u, range(u.num_qubits))

# apply function
state_preparation.append(fixed_income, range(fixed_income.num_qubits))

state_preparation.draw()

     ┌───────┐┌────┐
q_0: ┤0      ├┤0   ├
     │       ││    │
q_1: ┤1      ├┤1   ├
     │  P(X) ││    │
q_2: ┤2      ├┤2 F ├
     │       ││    │
q_3: ┤3      ├┤3   ├
     └───────┘│    │
q_4: ─────────┤4   ├
              └────┘

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

# set objective qubit
objective = u.num_qubits

# construct amplitude estimation
ae = IterativeAmplitudeEstimation(epsilon=epsilon, alpha=alpha,
                                  state_preparation=state_preparation,
                                  objective_qubits=[objective],
                                  post_processing=fixed_income.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' % exact_value)
print('Estimated value:    \t%.4f' % (result['estimation']))
print('Confidence interval:\t[%.4f, %.4f]' % tuple(conf_int))

Exact value:            2.1942
Estimated value:        2.3404
Confidence interval:    [2.3094, 2.3714]

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.736370086669922
Thu Jan 28 13:33:57 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.