Pricing Basket Options¶
소개¶
Suppose a basket option with strike price \(K\) and two underlying assets whose spot price at maturity \(S_T^1\), \(S_T^2\) follow given random distributions. The corresponding payoff function is defined as:
다음에서, 진폭 추정에 기초한 양자 알고리즘은 옵션에 대하여 예상되는 지불가격, 즉 할인 전에 적정 가격을 추정하는데 사용된다.
목표 함수의 근사치 및 양자 컴퓨터에 대한 옵션 가격 및 위험 분석에 대한 일반적인 소개는 다음과 같은 논문에서 제공된다.
양자 위험 분석. [Woerner, Egger. 2018]
양자컴퓨터를 이용한 옵션 가격 책정법 (Stamatopoulos et al. 2019.)
[1]:
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from scipy.interpolate import griddata
%matplotlib inline
import numpy as np
from qiskit import Aer, QuantumRegister, QuantumCircuit, execute, AncillaRegister, transpile
from qiskit.aqua.algorithms import IterativeAmplitudeEstimation
from qiskit.circuit.library import WeightedAdder, LogNormalDistribution, LinearAmplitudeFunction
불확실성 모델¶
We construct a circuit factory to load a multivariate log-normal random distribution into a quantum state on \(n\) qubits. For every dimension \(j = 1,\ldots,d\), the distribution is truncated to a given interval \([\text{low}_j, \text{high}_j]\) and discretized using \(2^{n_j}\) grid points, where \(n_j\) denotes the number of qubits used to represent dimension \(j\), i.e., \(n_1+\ldots+n_d = n\). The unitary operator corresponding to the circuit factory implements the following:
where \(p_{i_1\ldots i_d}\) denote the probabilities corresponding to the truncated and discretized distribution and where \(i_j\) is mapped to the right interval using the affine map:
단순하게 하기 위해, 우리는 두 주가가 독립적이고 동일하게 분배된다고 가정한다. 이러한 가정은 단지 파라미터화를 단순화하고, 더 복잡하게 완화될 수 있고 또한 다변량 분포를 상관시킬 수 있다. 현재 구현에 대한 유일한 중요한 가정은 상이한 치수의 분할 그리드가 동일한 스텝 크기를 갖는다는 것이다.
[2]:
# number of qubits per dimension to represent the uncertainty
num_uncertainty_qubits = 2
# 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
# map to higher dimensional distribution
# for simplicity assuming dimensions are independent and identically distributed)
dimension = 2
num_qubits=[num_uncertainty_qubits]*dimension
low=low*np.ones(dimension)
high=high*np.ones(dimension)
mu=mu*np.ones(dimension)
cov=sigma**2*np.eye(dimension)
# construct circuit factory
u = LogNormalDistribution(num_qubits=num_qubits, mu=mu, sigma=cov, bounds=list(zip(low, high)))
[3]:
# plot PDF of uncertainty model
x = [ v[0] for v in u.values ]
y = [ v[1] for v in u.values ]
z = u.probabilities
#z = map(float, z)
#z = list(map(float, z))
resolution = np.array([2**n for n in num_qubits])*1j
grid_x, grid_y = np.mgrid[min(x):max(x):resolution[0], min(y):max(y):resolution[1]]
grid_z = griddata((x, y), z, (grid_x, grid_y))
fig = plt.figure(figsize=(10, 8))
ax = fig.gca(projection='3d')
ax.plot_surface(grid_x, grid_y, grid_z, cmap=plt.cm.Spectral)
ax.set_xlabel('Spot Price $S_T^1$ (\$)', size=15)
ax.set_ylabel('Spot Price $S_T^2$ (\$)', size=15)
ax.set_zlabel('Probability (\%)', size=15)
plt.show()
페이오프 함수¶
만기시 현물 가격의 합 \((S_T^1 + S_T^2)\) 보다 적고 선형 적으로 증가하는 한 지불 함수는 0이다. 만약 \((S_T^1 + S_T^2) \geq K\) 라면, 구현에서는 먼저 가중치 합산 연산자를 사용하여 현물 가격의 합계를 ancilla 레지스터로 계산 한 다음 비교기를 사용하여 ancilla 큐 비트를 \(\big|0\rangle\)big|1rangle`로 뒤집는다.이 ancilla는 페이오프함수의 선형 부분을 제어하는 데 사용된다.
The linear part itself is approximated as follows. We exploit the fact that \(\sin^2(y + \pi/4) \approx y + 1/2\) for small \(|y|\). Thus, for a given approximation rescaling factor \(c_\text{approx} \in [0, 1]\) and \(x \in [0, 1]\) we consider
for small \(c_\text{approx}\).
다음과 같이 작동하는 연산자를 쉽게 구성할 수 있다.
제어된 Y 회전을 사용하였다.
Eventually, we are interested in the probability of measuring \(\big|1\rangle\) in the last qubit, which corresponds to \(\sin^2(a*x+b)\). Together with the approximation above, this allows to approximate the values of interest. The smaller we choose \(c_\text{approx}\), the better the approximation. However, since we are then estimating a property scaled by \(c_\text{approx}\), the number of evaluation qubits \(m\) needs to be adjusted accordingly.
For more details on the approximation, we refer to: Quantum Risk Analysis. Woerner, Egger. 2018.
Since the weighted sum operator (in its current implementation) can only sum up integers, we need to map from the original ranges to the representable range to estimate the result, and reverse this mapping before interpreting the result. The mapping essentially corresponds to the affine mapping described in the context of the uncertainty model above.
[4]:
# determine number of qubits required to represent total loss
weights = []
for n in num_qubits:
for i in range(n):
weights += [2**i]
# create aggregation circuit
agg = WeightedAdder(sum(num_qubits), weights)
n_s = agg.num_sum_qubits
n_aux = agg.num_qubits - n_s - agg.num_state_qubits # number of additional qubits
[5]:
# set the strike price (should be within the low and the high value of the uncertainty)
strike_price = 3.5
# map strike price from [low, high] to {0, ..., 2^n-1}
max_value = 2**n_s - 1
low_ = low[0]
high_ = high[0]
mapped_strike_price = (strike_price - dimension*low_) / (high_ - low_) * (2**num_uncertainty_qubits - 1)
# set the approximation scaling for the payoff function
c_approx = 0.25
# setup piecewise linear objective fcuntion
breakpoints = [0, mapped_strike_price]
slopes = [0, 1]
offsets = [0, 0]
f_min = 0
f_max = 2*(2**num_uncertainty_qubits - 1) - mapped_strike_price
basket_objective = LinearAmplitudeFunction(
n_s,
slopes,
offsets,
domain=(0, max_value),
image=(f_min, f_max),
rescaling_factor=c_approx,
breakpoints=breakpoints
)
┌───────┐┌────────┐
state_0: ┤0 ├┤0 ├──────
│ ││ │
state_1: ┤1 ├┤1 ├──────
│ P(X) ││ │
state_2: ┤2 ├┤2 ├──────
│ ││ │
state_3: ┤3 ├┤3 ├──────
└───────┘│ │┌────┐
obj_0: ─────────┤ ├┤3 ├
│ ││ │
sum_0: ─────────┤4 adder ├┤0 ├
│ ││ │
sum_1: ─────────┤5 ├┤1 ├
│ ││ │
sum_2: ─────────┤6 ├┤2 F ├
│ ││ │
work_0: ─────────┤7 ├┤4 ├
│ ││ │
work_1: ─────────┤8 ├┤5 ├
│ ││ │
work_2: ─────────┤9 ├┤6 ├
└────────┘└────┘
objective qubit index 4
[ ]:
# define overall multivariate problem
qr_state = QuantumRegister(u.num_qubits, 'state') # to load the probability distribution
qr_obj = QuantumRegister(1, 'obj') # to encode the function values
ar_sum = AncillaRegister(n_s, 'sum') # number of qubits used to encode the sum
ar = AncillaRegister(max(n_aux, basket_objective.num_ancillas), 'work') # additional qubits
objective_index = u.num_qubits
basket_option = QuantumCircuit(qr_state, qr_obj, ar_sum, ar)
basket_option.append(u, qr_state)
basket_option.append(agg, qr_state[:] + ar_sum[:] + ar[:n_aux])
basket_option.append(basket_objective, ar_sum[:] + qr_obj[:] + ar[:basket_objective.num_ancillas])
print(basket_option.draw())
print('objective qubit index', objective_index)
[6]:
# plot exact payoff function (evaluated on the grid of the uncertainty model)
x = np.linspace(sum(low), sum(high))
y = np.maximum(0, x - strike_price)
plt.plot(x, y, 'r-')
plt.grid()
plt.title('Payoff Function', size=15)
plt.xlabel('Sum of Spot Prices ($S_T^1 + S_T^2)$', size=15)
plt.ylabel('Payoff', size=15)
plt.xticks(size=15, rotation=90)
plt.yticks(size=15)
plt.show()
[7]:
# evaluate exact expected value
sum_values = np.sum(u.values, axis=1)
exact_value = np.dot(u.probabilities[sum_values>= strike_price], sum_values[sum_values>= strike_price]-strike_price)
print('exact expected value:\t%.4f' % exact_value)
exact expected value: 0.4870
기대수익 (Expected Payoff) 평가¶
We first verify the quantum circuit by simulating it and analyzing the resulting probability to measure the \(|1\rangle\) state in the objective qubit.
[8]:
num_state_qubits = basket_option.num_qubits - basket_option.num_ancillas
print('state qubits: ', num_state_qubits)
transpiled = transpile(basket_option, basis_gates=['u', 'cx'])
print('circuit width:', transpiled.width())
print('circuit depth:', transpiled.depth())
state qubits: 5
circuit width: 11
circuit depth: 529
[9]:
job = execute(basket_option, backend=Aer.get_backend('statevector_simulator'))
[10]:
# evaluate resulting statevector
value = 0
for i, a in enumerate(job.result().get_statevector()):
b = ('{0:0%sb}' % num_state_qubits).format(i)[-num_state_qubits:]
prob = np.abs(a)**2
if prob > 1e-4 and b[0] == '1':
value += prob
# map value to original range
mapped_value = basket_objective.post_processing(value) / (2**num_uncertainty_qubits - 1) * (high_ - low_)
print('Exact Operator Value: %.4f' % value)
print('Mapped Operator value: %.4f' % mapped_value)
print('Exact Expected Payoff: %.4f' % exact_value)
Exact Operator Value: 0.3954
Mapped Operator value: 0.4969
Exact Expected Payoff: 0.4870
다음에는 예상 급여를 추정하기 위해 진폭 추정을 사용합니다.
[11]:
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
# construct amplitude estimation
ae = IterativeAmplitudeEstimation(epsilon=epsilon, alpha=alpha, state_preparation=basket_option,
objective_qubits=[objective_index],
post_processing=basket_objective.post_processing)
[12]:
result = ae.run(quantum_instance=Aer.get_backend('qasm_simulator'), shots=100)
[13]:
conf_int = np.array(result['confidence_interval']) / (2**num_uncertainty_qubits - 1) * (high_ - low_)
print('Exact value: \t%.4f' % exact_value)
print('Estimated value: \t%.4f' % (result['estimation'] / (2**num_uncertainty_qubits - 1) * (high_ - low_)))
print('Confidence interval:\t[%.4f, %.4f]' % tuple(conf_int))
Exact value: 0.4870
Estimated value: 0.4726
Confidence interval: [0.4238, 0.5213]
[14]:
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
Version Information
| Qiskit Software | Version |
|---|---|
| Qiskit | None |
| Terra | 0.16.0.dev0+28d8c6a |
| Aer | 0.6.1 |
| Ignis | 0.5.0.dev0+470d8cc |
| Aqua | 0.8.0.dev0+ce81016 |
| IBM Q Provider | 0.8.0 |
| System information | |
| Python | 3.7.7 (default, May 6 2020, 04:59:01) [Clang 4.0.1 (tags/RELEASE_401/final)] |
| OS | Darwin |
| CPUs | 2 |
| Memory (Gb) | 16.0 |
| Fri Oct 16 11:48:53 2020 CEST | |
This code is a part of Qiskit
© Copyright IBM 2017, 2020.
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.
[ ]: