diff --git a/QQuantLib/finance/classical_finance.py b/QQuantLib/finance/classical_finance.py index 1300d6e..9b5278c 100644 --- a/QQuantLib/finance/classical_finance.py +++ b/QQuantLib/finance/classical_finance.py @@ -558,35 +558,28 @@ def bs_tree( s_0: float, risk_free_rate: float, volatility: float, - maturity: float, - number_samples: int, - time_steps: int, + times: np.ndarray, discretization: int, bounds: float, **kwargs ): r""" Computes the probabilities of all possible pahts from the - approximated solution of the Black-Scholes SDE using the - Euler-Maruyama discretization for a given discretization of the + approximated solution of the Black-Scholes SDE using + exact simulation for a given discretization of the Brownian motion. Parameters ---------- + s_0 : float current price of the underlying risk_free_rate : float risk free rate volatility : float the volatility - maturity : float - the maturity - strike : float - the strike - number_samples : int - number of samples - time steps : int - number of time steps + times : np.ndarray + the times of the tree discretization : float number of points to build the discrete version of the gaussian density @@ -595,10 +588,13 @@ def bs_tree( Returns ------- - s_t : numpy array of floats - array of samples from the SDE. + s_t : list of numpy arrays + Each element of the list is an array with all the posible asset + values discretization + p_t : numpy array of floats + array with the probabilities for all the paths """ - dt = maturity / time_steps + time_steps = len(times) - 1 x_ = np.linspace(-bounds, bounds, discretization) p_x = norm.pdf(x_) p_x = p_x / np.sum(p_x) @@ -607,27 +603,91 @@ def bs_tree( p_t = [] s_t.append(np.array([s_0])) p_t.append(np.array([1.0])) + for i in range(time_steps): + dt = times[i+1] - times[i] all_possible_paths = np.array(np.zeros(discretization ** (i + 1))) - all_possible_probabilities = np.array(np.zeros(discretization ** (i + 1))) + all_possible_probabilities = np.array( + np.zeros(discretization ** (i + 1))) + for j in range(len(s_t[i])): single_possible_paths = ( - s_t[i][j] - + risk_free_rate * s_t[i][j] * dt - + volatility * s_t[i][j] * x_ * np.sqrt(dt) + s_t[i][j] * np.exp((risk_free_rate - 0.5 * volatility**2) *\ + dt + volatility * np.sqrt(dt) * x_) ) single_possible_probabilities = p_t[i][j] * p_x index = j * discretization - all_possible_paths[index : index + discretization] = single_possible_paths - all_possible_probabilities[ - index : index + discretization - ] = single_possible_probabilities + all_possible_paths[index : index + discretization] =\ + single_possible_paths + all_possible_probabilities[index : index + discretization] =\ + single_possible_probabilities s_t.append(all_possible_paths) p_t.append(all_possible_probabilities) + return s_t, p_t +def tree_to_paths(tree): + """ + Convert a tree structure from bs_tree to a path format (table form) + + Parameters + ---------- + + tree : list + list of lists with the tree structure from bs_tree + + Returns + ------- + + paths : list of lists + table conversions of the tree structure input + """ + number_times = len(tree) + number_paths = len(tree[number_times - 1]) + + paths = np.zeros((number_times, number_paths)) + + for i in range(number_times - 1): + repeat = len(tree[-1]) / len(tree[i]) + paths[i, :] = np.repeat(tree[i], repeat) + paths[-1, :] = tree[-1] + + return paths + +def cliquet_cashflows(local_cap, local_floor, global_cap, global_floor, paths): + """ + Calculate the cashflows for the Cliquet option. + + Parameters + ---------- + + local_cap : float + local cap for cliquet options + local_floor : float + local floor for cliqet options + global_cap : float + global cap for cliquet options + global_floor : float + global floor for cliqet options + paths : list + input paths for the cliquet option + + Return + ------ + final_return : numpy array + The cashflows of the option for the input paths + """ + + # Calculate period returns + period_returns = (paths[1:] / paths[:-1]) - 1. + # Apply local caps and floors + capped_floored_returns = np.clip(period_returns, local_floor, local_cap) + # Sum returns and apply global caps/floors + total_return = np.sum(capped_floored_returns, axis=0) + final_return = np.clip(total_return, global_floor, global_cap) + return final_return def geometric_sum(base: float, exponent: int, coeficient: float = 1.0, **kwargs): r""" diff --git a/QQuantLib/finance/cliquet_return_estimation.py b/QQuantLib/finance/cliquet_return_estimation.py new file mode 100644 index 0000000..a815f1a --- /dev/null +++ b/QQuantLib/finance/cliquet_return_estimation.py @@ -0,0 +1,152 @@ +""" +This module implements the *ae_clique_return_estimation* function +that allows to the user configure a cliquet option, encode the expected +value integral to compute in a quantum state and estimate it using the +different **AE** algorithms implemented in the **QQuantLib.AE** package. + + +The function deals with all the mandatory normalisations for returning +the desired price estimation. + +Authors: Alberto Pedro Manzano Herrero & Gonzalo Ferro Costas +""" +import numpy as np +import pandas as pd +from QQuantLib.finance.classical_finance import bs_tree +from QQuantLib.finance.classical_finance import tree_to_paths +from QQuantLib.finance.classical_finance import cliquet_cashflows +from QQuantLib.utils.utils import text_is_none +from QQuantLib.finance.quantum_integration import q_solve_integral + +def ae_cliquet_estimation(**kwargs): + """ + Configures a cliquet option return estimation problem and solving it + using AE integration techniques + """ + + ae_problem = kwargs + + n_qbits = ae_problem.get("n_qbits", None) + s_0 = ae_problem.get("s_0", None) + text_is_none(s_0, "s_0", variable_type=float) + risk_free_rate = ae_problem.get("risk_free_rate", None) + text_is_none(risk_free_rate, "risk_free_rate", variable_type=float) + volatility = ae_problem.get("volatility", None) + text_is_none(volatility, "volatility", variable_type=float) + reset_dates = ae_problem.get("reset_dates", None) + text_is_none(reset_dates, "reset_dates", variable_type=list) + reset_dates = np.array(reset_dates) + bounds = ae_problem.get("bounds", None) + text_is_none(bounds, "bounds", variable_type=float) + + # Built paths and probabilities + tree_s, bs_path_prob = bs_tree( + s_0=s_0, + risk_free_rate=risk_free_rate, + volatility=volatility, + times=reset_dates, + discretization=2**n_qbits, + bounds=bounds + ) + #probability definition + p_x = bs_path_prob[-1] + #probability normalisation + p_x_normalisation = np.sum(p_x) + norm_p_x = p_x / p_x_normalisation + + # Build Cliquet PayOffs for paths + local_cap = ae_problem.get("local_cap", None) + text_is_none(local_cap, "local_cap", variable_type=float) + local_floor = ae_problem.get("local_floor", None) + text_is_none(local_floor, "local_floor", variable_type=float) + global_cap = ae_problem.get("global_cap", None) + text_is_none(global_cap, "global_cap", variable_type=float) + global_floor = ae_problem.get("global_floor", None) + text_is_none(global_floor, "global_floor", variable_type=float) + + # Table format paths + paths_s = tree_to_paths(tree_s) + # Build payoff for each possible path + cliqet_payoffs = cliquet_cashflows( + local_cap=local_cap, + local_floor=local_floor, + global_cap=global_cap, + global_floor=global_floor, + paths=paths_s + ) + #Function definition + f_x = cliqet_payoffs + #Function normalisation + f_x_normalisation = np.max(np.abs(f_x)) + norm_f_x = f_x / f_x_normalisation + + #Now we update the input dictionary with the probability and the + #function arrays + ae_problem.update({ + "array_function" : norm_f_x, + "array_probability" : norm_p_x, + }) + #EXECUTE COMPUTATION + solution, solver_object = q_solve_integral(**ae_problem) + + #For generating the output DataFrame we delete the arrays + del ae_problem["array_function"] + del ae_problem["array_probability"] + + #Undoing the normalisations + ae_expectation = solution * p_x_normalisation * f_x_normalisation + + #Creating the output DataFrame with the complete information + + #The basis will be the input python dictionary for traceability + pdf = pd.DataFrame([ae_problem]) + #Added normalisation constants + pdf["payoff_normalisation"] = f_x_normalisation + pdf["p_x_normalisation"] = p_x_normalisation + + #Expectation calculation using Riemann sum + pdf["riemann_expectation"] = np.sum(p_x * f_x) + #Expectation calculation using AE integration techniques + pdf[ + [col + "_expectation" for col in ae_expectation.columns] + ] = ae_expectation + # Pure integration Absolute Error + pdf["absolute_error"] = np.abs( + pdf["ae_expectation"] - pdf["riemann_expectation"]) + pdf["measured_epsilon"] = np.abs( + pdf["ae_u_expectation"] - pdf["ae_l_expectation"]) / 2.0 + # Finance Info + #Exact option price under the Black-Scholes model + pdf["finance_exact_price"] = None + #Option price estimation using expectation computed as Riemann sum + pdf["finance_riemann_price"] = pdf["riemann_expectation"] * np.exp( + -pdf["risk_free_rate"] * reset_dates[-1] + ) + #Option price estimation using expectation computed by AE integration + pdf["finance_price_estimation"] = pdf["ae_expectation"] * \ + np.exp(-pdf["risk_free_rate"] * reset_dates[-1]).iloc[0] + #Computing Absolute with discount: Rieman vs AE techniques + pdf["finance_error_riemann"] = np.abs( + pdf["finance_price_estimation"] - pdf["finance_riemann_price"] + ) + + #Computing Absolute error: Exact BS price vs AE techniques + pdf["finance_error_exact"] = None + + #Other interesting staff + if solver_object is None: + #Computation Fails Encoding 0 and RQAE + pdf["schedule_pdf"] = [None] + pdf["oracle_calls"] = [None] + pdf["max_oracle_depth"] = [None] + pdf["run_time"] = [None] + else: + if solver_object.schedule_pdf is None: + pdf["schedule_pdf"] = [None] + else: + pdf["schedule_pdf"] = [solver_object.schedule_pdf.to_dict()] + pdf["oracle_calls"] = solver_object.oracle_calls + pdf["max_oracle_depth"] = solver_object.max_oracle_depth + pdf["run_time"] = solver_object.solver_ae.run_time + + return pdf diff --git a/QQuantLib/finance/cliquet_return_estimation_step_payoff.py b/QQuantLib/finance/cliquet_return_estimation_step_payoff.py new file mode 100644 index 0000000..1d827fd --- /dev/null +++ b/QQuantLib/finance/cliquet_return_estimation_step_payoff.py @@ -0,0 +1,158 @@ +""" +This module implements the *ae_clique_return_estimation* function +that allows to the user configure a cliquet option, encode the expected +value integral to compute in a quantum state and estimate it using the +different **AE** algorithms implemented in the **QQuantLib.AE** package. + + +The function deals with all the mandatory normalisations for returning +the desired price estimation. + +Authors: Alberto Pedro Manzano Herrero & Gonzalo Ferro Costas +""" +import numpy as np +import pandas as pd +from QQuantLib.finance.classical_finance import bs_tree +from QQuantLib.finance.classical_finance import tree_to_paths +from QQuantLib.finance.classical_finance import cliquet_cashflows +from QQuantLib.utils.utils import text_is_none +from QQuantLib.finance.quantum_integration import q_solve_integral + +def ae_cliquet_estimation_step_po(**kwargs): + """ + Configures a cliquet option return estimation problem and solving it + using AE integration techniques + """ + + ae_problem = kwargs + + n_qbits = ae_problem.get("n_qbits", None) + s_0 = ae_problem.get("s_0", None) + text_is_none(s_0, "s_0", variable_type=float) + risk_free_rate = ae_problem.get("risk_free_rate", None) + text_is_none(risk_free_rate, "risk_free_rate", variable_type=float) + volatility = ae_problem.get("volatility", None) + text_is_none(volatility, "volatility", variable_type=float) + reset_dates = ae_problem.get("reset_dates", None) + text_is_none(reset_dates, "reset_dates", variable_type=list) + reset_dates = np.array(reset_dates) + bounds = ae_problem.get("bounds", None) + text_is_none(bounds, "bounds", variable_type=float) + + # Built paths and probabilities + tree_s, bs_path_prob = bs_tree( + s_0=s_0, + risk_free_rate=risk_free_rate, + volatility=volatility, + times=reset_dates, + discretization=2**n_qbits, + bounds=bounds + ) + #probability definition + p_x = bs_path_prob[-1] + #probability normalisation + p_x_normalisation = np.sum(p_x) + norm_p_x = p_x / p_x_normalisation + + # Build Cliquet PayOffs for paths + local_cap = ae_problem.get("local_cap", None) + text_is_none(local_cap, "local_cap", variable_type=float) + local_floor = ae_problem.get("local_floor", None) + text_is_none(local_floor, "local_floor", variable_type=float) + global_cap = ae_problem.get("global_cap", None) + text_is_none(global_cap, "global_cap", variable_type=float) + global_floor = ae_problem.get("global_floor", None) + text_is_none(global_floor, "global_floor", variable_type=float) + + # Table format paths + paths_s = tree_to_paths(tree_s) + # Build payoff for each possible path + cliqet_payoffs = cliquet_cashflows( + local_cap=local_cap, + local_floor=local_floor, + global_cap=global_cap, + global_floor=global_floor, + paths=paths_s + ) + #Function definition + f_x = cliqet_payoffs + #Function normalisation + f_x_normalisation = np.max(np.abs(f_x)) + norm_f_x = f_x / f_x_normalisation + + #### Positive Pay Off part execution #### + npo_positive = np.where(norm_f_x < 0, 0.0, norm_f_x) + ae_problem.update({ + "array_function" : npo_positive, + "array_probability" : norm_p_x, + }) + solution_p, solver_object_p = q_solve_integral(**ae_problem) + + #### Negative Pay Off part execution #### + npo_neagtive = np.abs(np.where(norm_f_x >= 0, 0.0, norm_f_x)) + ae_problem.update({ + "array_function" : npo_neagtive, + "array_probability" : norm_p_x, + }) + solution_n, solver_object_n = q_solve_integral(**ae_problem) + ###### Combine Solutions ########## + + # First compute errors of both contributions + epsilon_p = (solution_p["ae_u"] - solution_p["ae_l"]) / 2.0 + epsilon_n = (solution_n["ae_u"] - solution_n["ae_l"]) / 2.0 + #epsilon_final = np.sqrt(epsilon_p ** 2 + epsilon_n ** 2) + epsilon_final = epsilon_p + epsilon_n + # Second compute the expected value + solution = solution_p["ae"] - solution_n["ae"] + # Compute the expected value to compute + ae_expectation = solution * f_x_normalisation * p_x_normalisation + # Compute the associated error + measured_epsilon = epsilon_final * p_x_normalisation * p_x_normalisation + ###### Creation of the output ########## + #The basis will be the input python dictionary for traceability + pdf = pd.DataFrame([ae_problem]) + pdf.drop(["array_function", "array_probability"], axis=1, inplace=True) + #Added normalisation constants + pdf["payoff_normalisation"] = f_x_normalisation + pdf["p_x_normalisation"] = p_x_normalisation + #Expectation calculation using Riemann sum + pdf["riemann_expectation"] = np.sum(p_x * f_x) + # Positive Part estimation + pdf[[col + "_positive_part" for col in solution_p.columns]] = solution_p + # Negative part estimation + pdf[[col + "_negative_part" for col in solution_p.columns]] = solution_n + #Expectation calculation using AE integration techniques + pdf["ae_expectation"] = ae_expectation + # Pure integration Absolute Error + pdf["absolute_error"] = np.abs( + pdf["ae_expectation"] - pdf["riemann_expectation"]) + pdf["measured_epsilon"] = measured_epsilon + # Finance Info + #Exact option price under the Black-Scholes model + pdf["finance_exact_price"] = None + #Option price estimation using expectation computed as Riemann sum + pdf["finance_riemann_price"] = pdf["riemann_expectation"] * np.exp( + -pdf["risk_free_rate"] * reset_dates[-1] + ) + #Option price estimation using expectation computed by AE integration + pdf["finance_price_estimation"] = pdf["ae_expectation"] * \ + np.exp(-pdf["risk_free_rate"] * reset_dates[-1]).iloc[0] + # Associated error of the price estimation + pdf["finance_price_epsilon"] = pdf["measured_epsilon"] * \ + np.exp(-pdf["risk_free_rate"] * reset_dates[-1]).iloc[0] + #Computing Absolute with discount: Rieman vs AE techniques + pdf["finance_error_riemann"] = np.abs( + pdf["finance_price_estimation"] - pdf["finance_riemann_price"] + ) + #Computing Absolute error: Exact BS price vs AE techniques + pdf["finance_error_exact"] = None + + # We have two objects. It is not interesting have the schedules + pdf["schedule_pdf"] = [None] + pdf["oracle_calls"] = solver_object_p.oracle_calls + solver_object_n.oracle_calls + pdf["max_oracle_depth"] = max( + solver_object_p.max_oracle_depth, solver_object_n.max_oracle_depth) + pdf["circuit_stasts"] = [None] + pdf["run_time"] = solver_object_p.solver_ae.run_time + solver_object_n.solver_ae.run_time + return pdf + diff --git a/benchmark/README.md b/benchmark/README.md index 22f7a40..2a08ea0 100644 --- a/benchmark/README.md +++ b/benchmark/README.md @@ -1,6 +1,6 @@ # Benchmark utilities -This folder contains four different packages which allow to the user execute benchmarks for testing the more important parts of the *QQuantLib*: +This folder contains five different packages which allow to the user execute benchmarks for testing the more important parts of the *QQuantLib*: * **compare_ae_probability**: this package allows the user to test and compare the different quantum **AE** algorithms, from *QQuantLib*, easily. This can be done using the *probabiliy_estimation* module from the command line. How to use, results and more information can be found in the notebook *CompareAEalgorithmsOnPureProbability.ipynb* (located inside the folder). @@ -8,10 +8,19 @@ This folder contains four different packages which allow to the user execute ben * *benchmark_ae_option_price.py*: allows the user compute the option price using **AE** algorithms for an user defined option problem (python benchmark_ae_option_price.py -h for help) - * benchmark_ae_option_price_step_po.py: allows the user the compute the price of a derivative using different **AE** algorithms when the payoff function can take positive and negative values. In this case, the positive and negative parts of the payoff are loaded separately and two different estimations, using quantum **AE** algorithms, are obtained. These values should be post-processed to obtain the final desired value. + * *benchmark_ae_option_price_step_po.py*: allows the user the compute the price of a derivative using different **AE** algorithms when the payoff function can take positive and negative values. In this case, the positive and negative parts of the payoff are loaded separately and two different estimations, using quantum **AE** algorithms, are obtained. These values should be post-processed to obtain the final desired value. * **sine_integral**: this package allows the user to test the *QQuantLib.finance.quantum\_integration* module by estimating the defined integral of a sine function in two different domains. How to use, results and more information can be found in the notebook: *QAE_SineIntegration_WindowQPE.ipynb* (located inside the folder). +* **q_ae_cliquet**: this package allows the user to test and compare the different quantum **AE** algorithms, from *QQuantLib*, for pricing a type of exotic options: the *Cliquet Options* (under stock evolution using the *Black-Scholes* model). How to use, summary of results and more information can be found in the notebook *QAE_CliquetOptions.ipynb* (located inside of the folder). Two different modules can be found in the package: + + * *benchmark_cliquet.py*: computes the return of the configured Cliquet option using a properly configured *AE* algorithm (python benchmark_cliquet.py -h for help) + + * *benchmark_cliquet_step_po.py*: computes the return of the configured Cliquet option using a properly configured *AE* algorithm when the payoff function can take positive and negative values. In this case, the positive and negative parts of the payoff are loaded separately and two different estimations, using quantum **AE** algorithms, are obtained. These values should be post-processed to obtain the final desired value. + + +easily. This can be done using the *probabiliy_estimation* module from the command line. How to use, results and more information can be found in the notebook *CompareAEalgorithmsOnPureProbability.ipynb* (located inside the folder). + * **qml4var**: this package allows the user to test the *QQuantLib.qml4var* package. The following different modules (that can be executed from the command line) can be found: * *data_sets*: this module allows to the user build datasets for training a **PQC**. The user can select between a random or a properly configured **Black-Scholes** (a.k.a. log-normal) distribution function. The module builds and stores the train and test datasets. diff --git a/benchmark/q_ae_cliquet/QAE_CliquetOptions.ipynb b/benchmark/q_ae_cliquet/QAE_CliquetOptions.ipynb new file mode 100644 index 0000000..e665209 --- /dev/null +++ b/benchmark/q_ae_cliquet/QAE_CliquetOptions.ipynb @@ -0,0 +1,1169 @@ +{ + "cells": [ + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "437c6cf9", + "metadata": {}, + "source": [ + "# Floored cliquet options\n", + "\n", + "Let $T$ be a future point in time, and divide the interval $\\left[0, T\\right]$ into $N$ subintervals, called reset periods, of length $\\Delta_n = T_n − T_{n−1}$, where $\\{ T_n \\}^ N_{n=0}$, $T_0 = 0$, $T_N = T$ are referred to as the reset days. \n", + "\n", + "The return of an asset with price process $S_t$ over a reset period $\\left[T_{n−1}, T_n\\right)$ is then defined as\n", + "\n", + "$$R_n = \\frac{S_{T_n}}{S_{T_{n-1}}} - 1$$\n", + "\n", + "Additionally the *truncated returns* is defined as:\n", + "\n", + "$$\\bar{R_n} = \\max \\left( \\min \\left(R_n, C\\right), F\\right)$$\n", + "\n", + "where $F$ and $C$ are the floor and cap levels respectively (the absence of floor and caps corresponds to $F=-1$ and $C=+\\infty$).\n", + "\n", + "The *truncated returns* is represented by:\n", + "\n", + "![image.png](attachment:image.png)\n", + "\n", + "\n", + "An option with this configuration is called a **Cliquet Option**. A general Cliquet option has a payoff $Y$ at time $T$ of:\n", + "\n", + "$$Y = \\min\\left( \\max \\left(\\sum_{n=1}^N \\bar{R_n}, F_g\\right), C_g \\right)$$\n", + "\n", + "where $F_g$ and $C_g$ are the global floor and global cap, representing the minimum and maximum returns, respectively.\n", + "\n", + "We can use the **QQuantLib** library for obtaining the payoff of a **Cliquet Option** using various **Quantum Amplitude Estimation** algorithms." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "492b1972", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append(\"../../\")\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import qat.lang.AQASM as qlm\n", + "from copy import deepcopy\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fafa419d", + "metadata": {}, + "outputs": [], + "source": [ + "#This cell loads the QLM solver. See notebook: 00_AboutTheNotebooksAndQPUs.ipynb\n", + "from QQuantLib.qpu.get_qpu import get_qpu\n", + "# myqlm qpus: python, c\n", + "# QLM qpus accessed using Qaptiva Access library: qlmass_linalg, qlmass_mps\n", + "# QLM qpus: Only in local Quantum Learning Machine: linalg, mps\n", + "my_qpus = [\"python\", \"c\", \"qlmass_linalg\", \"qlmass_mps\", \"linalg\", \"mps\"]\n", + "\n", + "linalg_qpu = get_qpu(my_qpus[1])" + ] + }, + { + "cell_type": "markdown", + "id": "06a1543a", + "metadata": {}, + "source": [ + "## 1. Getting the Paths\n", + "\n", + "To evaluate the final payoff of a Cliquet option, the first step is to build the possible paths the asset can follow from one reset day to the next (for all reset days under evaluation). These paths will be constructed using the **Black-Scholes** model.\n", + "\n", + "For each possible reset day, we define a domain discretization of the asset as follows:\n", + "\n", + "* **Initial reset date**: We only need the initial value of the asset.\n", + "* **Second reset date**: We compute $N$ possible paths starting from the initial reset day.\n", + "* **Third reset date**: We generate $N$ possible paths for each asset value at the second reset day, resulting in $N^2$ possible paths at this point.\n", + "\n", + "For each subsequent reset day, $N$ new paths are generated for each possible value from the preceding reset day. If there are $m$ reset days, then at the final reset day, we will have $N^m$ possible paths.\n", + "\n", + "To implement this scheme, the *bs_tree* function from the **QQuantLib.finance.classical_finance** module is used. The function takes the following inputs:\n", + "\n", + "\n", + "* s_0: Initial value of the asset\n", + "* risk_free_rate: Risk-free required to model the **Black-Scholes** evolution of the asset.\n", + "* volatility: Volatility of the asset required to model the **Black-Scholes** evolution.\n", + "* times: A list of reset days to evaluate\n", + "* discretization: Number of points for domain discretization.\n", + "* bounds: Bounds for truncating the probability density.\n", + "\n", + "\n", + "The *bs_tree* returns two objects:\n", + "\n", + "* s_t: A list containing all possible discretized values of the asset for each reset day (in tree format).\n", + "* p_t: A list containing the probabilities of all the distinct paths generated between the initial and final reset days.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "80e8425f", + "metadata": {}, + "outputs": [], + "source": [ + "from QQuantLib.finance.classical_finance import bs_tree" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b43f6725", + "metadata": {}, + "outputs": [], + "source": [ + "#Initial value for the asset\n", + "s_0 = 1.0\n", + "risk_free_rate = 0.03\n", + "volatility = 0.4\n", + "reset_dates = np.array([0.0, 1.0, 2.0])\n", + "\n", + "#Discretization: 2^n_qbits\n", + "n_qbits = 5\n", + "\n", + "tree_s, bs_path_prob = bs_tree(\n", + " s_0=s_0,\n", + " risk_free_rate=risk_free_rate, \n", + " volatility=volatility,\n", + " times=reset_dates,\n", + " discretization= 2**n_qbits,\n", + " bounds = 7\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "379292f9", + "metadata": {}, + "source": [ + "The first output of *bs_tree* (stored in the variable *tree_s*) contains the possible values of the asset for each reset day.\n", + "\n", + "* The first element of *tree_s* represents the initial value of the asset.\n", + "* The second element contains the possible asset values at the second reset day.\n", + "* The third element has the values of the asset at the third reset day for each posible value of the second reset day. So it has $2^{n\\_qbits}$ * $2^{n\\_qbits}$ values" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1e5594e", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# First reset day \n", + "tree_s[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "83884ca6", + "metadata": {}, + "outputs": [], + "source": [ + "# Second reset day: MUST have 2^n_qbits values\n", + "print(len(tree_s[1]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cfab3bf1", + "metadata": {}, + "outputs": [], + "source": [ + "# Third reset day: MUST have 2^n_qbits * 2^n_qbits values\n", + "print(len(tree_s[2]))" + ] + }, + { + "cell_type": "markdown", + "id": "7c5b02a6", + "metadata": {}, + "source": [ + "The first $2^n$ values of the third element of the *tree_s* contains the posible asset values corresponding to the first asset value of the second reset day, and so on." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "551f8d9f", + "metadata": {}, + "outputs": [], + "source": [ + "print(\"Possible asset values in third reset day: \\n{}\".format(\n", + " tree_s[2][:2**n_qbits]))\n", + "print(\"for first asset value {} in second reset day: \".format(tree_s[1][0]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a3fb7029", + "metadata": {}, + "outputs": [], + "source": [ + "print(\"Possible asset values in third reset day: \\n{}\".format(\n", + " tree_s[2][2**n_qbits: 2*2**n_qbits]))\n", + "print(\"for second asset value {} in second reset day: \".format(tree_s[1][1]))" + ] + }, + { + "cell_type": "markdown", + "id": "654c98d6", + "metadata": {}, + "source": [ + "The *tree_to_paths* function from **QQuantLib.finance.classical_finance** module transforms the *tree_s* variable into a table format, where all the possible paths of the asset are stored for each reset day.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "53043dd2", + "metadata": {}, + "outputs": [], + "source": [ + "from QQuantLib.finance.classical_finance import tree_to_paths" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93bb2c4f", + "metadata": {}, + "outputs": [], + "source": [ + "# Posible path of the assets along the three reset days\n", + "paths_s = tree_to_paths(tree_s)\n", + "pdf = pd.DataFrame(paths_s, index=[\"reset_day0\", \"reset_day1\", \"reset_day2\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6aecc85b", + "metadata": {}, + "outputs": [], + "source": [ + "pdf" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6992dc40", + "metadata": {}, + "outputs": [], + "source": [ + "# Possible paths for the asset\n", + "for i in range(len(pdf.columns)):\n", + " plt.plot(pdf[i], 'o-')" + ] + }, + { + "cell_type": "markdown", + "id": "93c4b194", + "metadata": {}, + "source": [ + "The variable *bs_path_prob* (the second output of the *bs_tree*) is a list where each element contains the probability of the built paths for each reset day. The last element contains the probability of all the built paths from the initial reset day to the final one." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "67facfdf", + "metadata": {}, + "outputs": [], + "source": [ + "bs_path_prob" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d454798", + "metadata": {}, + "outputs": [], + "source": [ + "# Probabilities for all the built paths from initial to last reset day\n", + "plt.plot(bs_path_prob[-1])\n", + "plt.xlabel(\"Paths\")\n", + "plt.ylabel(\"Probability\")" + ] + }, + { + "cell_type": "markdown", + "id": "c950e841", + "metadata": {}, + "source": [ + "## 2. Getting the Cliquet Option payoff\n", + "\n", + "For each built path, we need to compute the associated payoff of the Cliquet option. This can be done using the *cliquet_cashflows* function from **QQuantLib.finance.classical_finance**. The inputs are:\n", + "\n", + "* local_cap: $C$\n", + "* local_floor: $F$\n", + "* global_cap: $C_g$\n", + "* global_floor: $F_g$\n", + "* paths: The built paths from *tree_to_paths* function\n", + "\n", + "The output is the Cliquet payoff for each possible path from the initial reset day to the final one.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "70a5089a", + "metadata": {}, + "outputs": [], + "source": [ + "from QQuantLib.finance.classical_finance import cliquet_cashflows" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c7dd39f", + "metadata": {}, + "outputs": [], + "source": [ + "local_cap = 0.1\n", + "local_floor = -0.1\n", + "global_cap = 0.2\n", + "global_floor = -0.2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1fbd2398", + "metadata": {}, + "outputs": [], + "source": [ + "cliqet_payoffs = cliquet_cashflows(\n", + " local_cap = local_cap,\n", + " local_floor = local_floor,\n", + " global_cap = global_cap,\n", + " global_floor = global_floor,\n", + " paths=paths_s\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4f8e11f3", + "metadata": {}, + "outputs": [], + "source": [ + "# Cliquet Pay Off for each built path\n", + "plt.plot(cliqet_payoffs)\n", + "plt.xlabel(\"Paths\")\n", + "plt.ylabel(\"Cliquet PayOffs\")" + ] + }, + { + "cell_type": "markdown", + "id": "fc7eb274", + "metadata": {}, + "source": [ + "## 3. The return of the Cliquet option\n", + "\n", + "\n", + "Now, we can compute the return of the Cliquet option by calculating the expected value of the probability of all the paths and their corresponding payoff." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e829c6b8", + "metadata": {}, + "outputs": [], + "source": [ + "cliquet_return = np.dot(bs_path_prob[-1], cliqet_payoffs)\n", + "\n", + "print(\"Expected return of the cliquet at the last reset day: {}\".format(\n", + " cliquet_return\n", + "))" + ] + }, + { + "cell_type": "markdown", + "id": "924819db", + "metadata": {}, + "source": [ + "We need to discount the risk-free rate, as usual, to determine the return at the initial day." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0d1d7f0", + "metadata": {}, + "outputs": [], + "source": [ + "final_return = np.exp(-risk_free_rate * reset_dates[-1]) * cliquet_return\n", + "\n", + "print(\"Final Return: {}\".format(final_return))" + ] + }, + { + "cell_type": "markdown", + "id": "82168401", + "metadata": {}, + "source": [ + "## 4. Cliquet Option using *q_solve_integral*\n", + "\n", + "The *Cliquet* option return can be computed easily using the *q_solve_integral* function from **QQuantLib.finance.quantum_integration** (see *misc/notebooks/10_ApplicationTo_Finance_01_IntegralComputing.ipynb*).\n", + "\n", + "We only need to provide the probability and payoff arrays and properly configure the **AE** algorithm." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fccbb797", + "metadata": {}, + "outputs": [], + "source": [ + "from QQuantLib.finance.quantum_integration import q_solve_integral" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db5bc920", + "metadata": {}, + "outputs": [], + "source": [ + "#probability definition\n", + "p_x = bs_path_prob[-1]\n", + "#probability normalisation\n", + "p_x_normalisation = np.sum(p_x)\n", + "norm_p_x = p_x / p_x_normalisation\n", + "\n", + "#Function definition\n", + "f_x = cliqet_payoffs\n", + "f_x_normalisation = np.max(np.abs(f_x))\n", + "norm_f_x = f_x / f_x_normalisation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9e79d9f4", + "metadata": {}, + "outputs": [], + "source": [ + "ae_dict = {\n", + " #QPU\n", + " 'qpu': linalg_qpu,\n", + " #Multi controlled decomposition\n", + " 'mcz_qlm': False, \n", + " \n", + " #shots\n", + " 'shots': None,\n", + " \n", + " #MLAE\n", + " 'schedule': None,\n", + " 'delta' : None,\n", + " 'ns' : None,\n", + " \n", + " #CQPEAE\n", + " 'auxiliar_qbits_number': None,\n", + " \"window\" : None, \n", + " \"kaiser_alpha\" : None,\n", + " #IQPEAE\n", + " 'cbits_number': None,\n", + " #IQAE & RQAQE\n", + " 'epsilon': None,\n", + " #IQAE\n", + " 'alpha': None,\n", + " #RQAE\n", + " 'gamma': None,\n", + " 'q': None,\n", + " #For encoding class\n", + " \"multiplexor\": True\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c91fc07e", + "metadata": {}, + "outputs": [], + "source": [ + "ae_dict.update({\n", + " \"array_function\":norm_f_x,\n", + " \"array_probability\": norm_p_x,\n", + "})\n", + "\n", + "# PayOff can be positive and negative so better use encoding 2\n", + "ae_dict.update({\"encoding\" : 2})" + ] + }, + { + "cell_type": "markdown", + "id": "4404c11a", + "metadata": {}, + "source": [ + "### 4.1 IQAE" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "68e5e612", + "metadata": {}, + "outputs": [], + "source": [ + "ae_dict.update({\n", + " \"ae_type\" : \"IQAE\",\n", + " \"epsilon\" : 0.01,\n", + " \"alpha\" : 0.05,\n", + " \"shots\" : 100\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a6f210d0", + "metadata": {}, + "outputs": [], + "source": [ + "%%time\n", + "iqae_solution, iqae_object = q_solve_integral(**ae_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f571313b", + "metadata": {}, + "outputs": [], + "source": [ + "iqae_cliquet_return = iqae_solution * f_x_normalisation * p_x_normalisation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8533d5c8", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "print(\"Cliquet Return computed using IQAE: {}\".format(iqae_cliquet_return[\"ae\"].iloc[0]))\n", + "print(\"True Cliquet return: {}\".format(cliquet_return))" + ] + }, + { + "cell_type": "markdown", + "id": "04141d57", + "metadata": {}, + "source": [ + "As can be seen, **IQAE** algorithm only returns positive values, so it can not be use for this *Cliquet option* configuration" + ] + }, + { + "cell_type": "markdown", + "id": "be1c46f5", + "metadata": {}, + "source": [ + "### 4.2 RQAE" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5c1c1168", + "metadata": {}, + "outputs": [], + "source": [ + "%%time\n", + "ae_dict.update({\n", + " \"ae_type\" : \"RQAE\",\n", + " \"epsilon\" : 0.01,\n", + " \"gamma\" : 0.05,\n", + " \"q\" : 1.2\n", + "})\n", + "rqae_solution, rqae_object = q_solve_integral(**ae_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "655cae38", + "metadata": {}, + "outputs": [], + "source": [ + "q_cliquet_return = rqae_solution * f_x_normalisation * p_x_normalisation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "517b4143", + "metadata": {}, + "outputs": [], + "source": [ + "q_cliquet_return" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2eced7b3", + "metadata": {}, + "outputs": [], + "source": [ + "(cliquet_return < q_cliquet_return[\"ae_u\"]) & (cliquet_return > q_cliquet_return[\"ae_l\"])" + ] + }, + { + "cell_type": "markdown", + "id": "207ca5e5", + "metadata": {}, + "source": [ + "**RQAE** algorithm can return both positive and negative values, so it can be used for this *Cliquet option* configuration." + ] + }, + { + "cell_type": "markdown", + "id": "9c42ba7c", + "metadata": {}, + "source": [ + "## 5. ae_cliquet_estimation\n", + "\n", + "The *ae_cliquet_estimation* function allows the user to compute a Cliquet option by configuring an input dictionary:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c9379aec", + "metadata": {}, + "outputs": [], + "source": [ + "from QQuantLib.finance.cliquet_return_estimation import ae_cliquet_estimation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d2617d9f", + "metadata": {}, + "outputs": [], + "source": [ + "#Base AE configuration dictionary\n", + "ae_dict = {\n", + " #QPU\n", + " 'qpu': linalg_qpu,\n", + " #Multi controlled decomposition\n", + " 'mcz_qlm': False, \n", + " \n", + " #shots\n", + " 'shots': None,\n", + " \n", + " #MLAE\n", + " 'schedule': None,\n", + " 'delta' : None,\n", + " 'ns' : None,\n", + " \n", + " #CQPEAE\n", + " 'auxiliar_qbits_number': None,\n", + " \"window\" : None, \n", + " \"kaiser_alpha\" : None,\n", + " #IQPEAE\n", + " 'cbits_number': None,\n", + " #IQAE & RQAQE\n", + " 'epsilon': None,\n", + " #IQAE\n", + " 'alpha': None,\n", + " #RQAE\n", + " 'gamma': None,\n", + " 'q': None,\n", + " #For encoding class\n", + " \"multiplexor\": True\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "37e40095", + "metadata": {}, + "outputs": [], + "source": [ + "# Asset configuration\n", + "asset_config = {\n", + " \"n_qbits\" : n_qbits,\n", + " \"s_0\": s_0,\n", + " \"risk_free_rate\" : risk_free_rate,\n", + " \"volatility\" : volatility,\n", + " \"reset_dates\" : [0.0, 1.0, 2.0],\n", + " \"bounds\": 7\n", + "}\n", + "\n", + "#Cliquet option configuration\n", + "option_config = {\n", + " \"local_cap\" : local_cap,\n", + " \"local_floor\" : local_floor,\n", + " \"global_cap\" : global_cap,\n", + " \"global_floor\": global_floor\n", + "}\n", + "\n", + "other_configuration = {\n", + " 'qpu': linalg_qpu,\n", + " \"save\": False,\n", + " \"file_name\": \"./ae_problem.csv\",\n", + " \"number_of_tests\": 1\n", + "}\n", + "\n", + "ae_dict.update(asset_config)\n", + "ae_dict.update(option_config)\n", + "ae_dict.update(other_configuration)\n", + "ae_dict.update({\"encoding\" : 2})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3e50d2d0", + "metadata": {}, + "outputs": [], + "source": [ + "ae_dict.update({\n", + " \"ae_type\" : \"IQAE\",\n", + " \"epsilon\" : 0.01,\n", + " \"alpha\" : 0.05,\n", + " \"shots\" : 100\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f39d4280", + "metadata": {}, + "outputs": [], + "source": [ + "pdf = ae_cliquet_estimation(**ae_dict)" + ] + }, + { + "cell_type": "markdown", + "id": "161db166", + "metadata": {}, + "source": [ + "The output of the *ae_cliquet_estimation* function is a pandas DataFrame containing various information, including:\n", + "\n", + "* Asset configuration\n", + "* AE algorithm configuration\n", + "* Normalization of payoff and probability\n", + "* AE estimation of the integral (including Riemman integral and absolute error)\n", + "* Financial results (including the discount of the risk-free rate)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ac3ff3af", + "metadata": {}, + "outputs": [], + "source": [ + "# Asset configuration\n", + "pdf[[\n", + " \"n_qbits\", \"s_0\", \"risk_free_rate\", \"volatility\",\"bounds\",\n", + " \"reset_dates\", \"local_cap\", \"local_floor\", \"global_cap\", \"global_floor\"\n", + "]]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9497d4a2", + "metadata": {}, + "outputs": [], + "source": [ + "# AE algorithm configuration\n", + "pdf[[\n", + " 'ae_type','schedule', 'delta', 'ns', \n", + " 'auxiliar_qbits_number', 'cbits_number',\n", + " 'epsilon', 'alpha', 'gamma', 'q', 'shots',\n", + " 'mcz_qlm', 'encoding','multiplexor',\n", + "]]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "af495818", + "metadata": {}, + "outputs": [], + "source": [ + "# Normalisation of payoff and probability\n", + "pdf[['payoff_normalisation', 'p_x_normalisation']]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b988a875", + "metadata": {}, + "outputs": [], + "source": [ + "# AE estimation of the integral Including Riemman expectations and absolute error\n", + "pdf[[\n", + " \"ae_l_expectation\", \"ae_expectation\", \n", + " \"ae_u_expectation\", \"riemann_expectation\", \"absolute_error\", \"measured_epsilon\"\n", + "]]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9e0cab85", + "metadata": {}, + "outputs": [], + "source": [ + "# Financial results (including the discount of the risk-free rate)\n", + "pdf[['finance_exact_price', 'finance_riemann_price', \n", + " 'finance_price_estimation', 'finance_error_riemann', 'finance_error_exact'\n", + "]]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1397a146", + "metadata": {}, + "outputs": [], + "source": [ + "ae_dict.update({\n", + " \"ae_type\" : \"RQAE\",\n", + " \"epsilon\" : 0.001,\n", + " \"gamma\" : 0.05,\n", + " \"q\" : 1.2\n", + "})\n", + "pdf = ae_cliquet_estimation(**ae_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2b79069f", + "metadata": {}, + "outputs": [], + "source": [ + "pdf[[\n", + " \"ae_l_expectation\", \"ae_expectation\", \n", + " \"ae_u_expectation\", \"riemann_expectation\", \"absolute_error\"\n", + "]]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "82d245a2", + "metadata": {}, + "outputs": [], + "source": [ + "pdf[\"riemann_expectation\"] > pdf[\"ae_l_expectation\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "58979dcf", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "pdf[\"riemann_expectation\"] < pdf[\"ae_u_expectation\"]" + ] + }, + { + "cell_type": "markdown", + "id": "eef51689", + "metadata": {}, + "source": [ + "## 6. cliquet_return_estimation_step_payoff \n", + "\n", + "\n", + "Cliquet options can have both positive and negative returns, so only **RQAE-like** algorithm can provide the correct estimation if the sign is unknown. Other **AE** algorithms can also be used for providing the correct estimation, but the following workaround should be applied:\n", + "\n", + "* The payoff should be split into two parts: a positive and a negative part.\n", + "* The *q_solve_integral function* should be executed over both parts.\n", + "* The results should be post-processed to return the correct evaluation.\n", + "\n", + "This can be done straightforwardly using the *ae_cliquet_estimation_step_payoff* function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "16da3f08", + "metadata": {}, + "outputs": [], + "source": [ + "from QQuantLib.finance.cliquet_return_estimation_step_payoff import ae_cliquet_estimation_step_po" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f0ef85a7", + "metadata": {}, + "outputs": [], + "source": [ + "ae_dict.update({\"encoding\" : 0})\n", + "ae_dict.update({\n", + " \"ae_type\" : \"IQAE\",\n", + " \"epsilon\" : 0.01,\n", + " \"alpha\" : 0.05,\n", + " \"shots\" : 100\n", + "})\n", + "\n", + "pdf_parts = ae_cliquet_estimation_step_po(**ae_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "30d820d7", + "metadata": {}, + "outputs": [], + "source": [ + "pdf_parts[[\n", + " \"ae_expectation\", \n", + " \"riemann_expectation\", \"absolute_error\", \"measured_epsilon\"\n", + "]]" + ] + }, + { + "cell_type": "markdown", + "id": "2e4a2494", + "metadata": {}, + "source": [ + "With this workaround, the typical **AE** algorithms return the correct estimation!" + ] + }, + { + "cell_type": "markdown", + "id": "d8276e7f", + "metadata": {}, + "source": [ + "## 7. Command Line Utilities\n", + "\n", + "Inside the **benchmark/q_ae_cliquet/** folder, the following scripts allow the user to compute the return of a *Cliquet option* from the command line using an AE algorithm:\n", + "\n", + "* benchmark_cliquet.py\n", + "* benchmark_cliquet_step_po.py (in this case, the splitting payoff workaround is used)\n", + "\n", + "To get a list of the arguments, the following commands should be used:\n", + "\n", + "* python benchmark_cliquet.py -h\n", + "* python benchmark_cliquet_step_po.py -h\n", + "\n", + "The output is (for both commands):\n", + "\n", + " usage: benchmark_cliquet.py [-h] [--count] [--print] [--all] [--exe] [--save] [-folder FOLDER_PATH] [-name FILE_NAME] [-id ID] [-repetitions REPETITIONS]\n", + " [-json_asset JSON_ASSET] [-json_cliquet JSON_CLIQUET] [-json_ae JSON_AE] [-json_qpu JSON_QPU]\n", + "\n", + " optional arguments:\n", + " -h, --help show this help message and exit\n", + " --count For counting elements on the list\n", + " --print For printing\n", + " --all For executing complete list\n", + " --exe For executing program\n", + " --save For saving results\n", + " -folder FOLDER_PATH Path for storing folder\n", + " -name FILE_NAME Name for storing csv. Only applies for --all\n", + " -id ID For executing only one element of the list\n", + " -repetitions REPETITIONS\n", + " Number of repetitions the integral will be computed.Default: 1\n", + " -json_asset JSON_ASSET\n", + " JSON with the asset configuration\n", + " -json_cliquet JSON_CLIQUET\n", + " JSON with the payoff configuration\n", + " -json_ae JSON_AE JSON AE algorithm configuration\n", + " -json_qpu JSON_QPU JSON with the qpu configuration\n", + " \n", + "\n", + "\n", + "The complete configuration for the computations should be provided using *JSON* files:\n", + "\n", + "#### -json_asset JSON_ASSET\n", + "\n", + "Here, the asset configuration is provided using a JSON file. The *asset_configuration.json* presents an example of a valid asset configuration for a *Cliquet Option*.\n", + "\n", + "#### -json_cliquet JSON_CLIQUET\n", + "\n", + "Here, the configuration of the *Cliquet Option* is provided as a JSON file (this includes the different caps and floors of the option). The *cliquet_configuration.json* presents an example of a valid Cliquet option configuration.\n", + "\n", + "#### -json_ae JSON_AE\n", + "\n", + "Here, the configuration of the *AE* algorithm to use is provided as a JSON file. The *miqae_configuration.json* and *mrqae_configuration.json* present examples of valid AE configurations.\n", + "\n", + "#### -json_qpu JSON_QPU\n", + "\n", + "Here, the configuration of the QPU is provided as a JSON file. The *qpu_ideal.json* presents an example of a QPU configuration file. Noisy simulation can be used by properly modifying the JSON file." + ] + }, + { + "cell_type": "markdown", + "id": "b0ba2a8e", + "metadata": {}, + "source": [ + "### 7.1 Getting the number of cases to execute.\n", + "\n", + "Providing to the command line execution the argument **--count**, the scripts will return the total number of executions it should be done for complete execution of the configured problem using the different **JSON** files.\n", + "\n", + "So for example:\n", + "\n", + " python benchmark_cliquet_step_po.py -json_asset asset_configuration.json -json_cliquet cliquet_configuration.json -json_ae miqae_configuration.json -json_qpu qpu_ideal.json --count\n", + "\n", + "should provide: 8\n" + ] + }, + { + "cell_type": "markdown", + "id": "2fdd03b3", + "metadata": {}, + "source": [ + "### 7.2 Print the info for the case\n", + "\n", + "The **--print** argument allows the user to print the configuration of the problem to solve. It can be used with two additional commands:\n", + "\n", + "* --all: In this case, the complete list of dictionaries is printed.\n", + "* -id 5: In this case, the complete configuration of the 5th price estimation problem (with the corresponding **AE** algorithm configuration) will be printed. \n" + ] + }, + { + "cell_type": "markdown", + "id": "8af600b1", + "metadata": {}, + "source": [ + "### 7.5 Execution of the case\n", + "\n", + "For executing a selected case the **--exe** argument should be provided in combination with the element of the list of dictionaries to be executed. \n", + "\n", + "The following command will execute the number 3 estimation Cliquet problem.\n", + "\n", + " python benchmark_cliquet_step_po.py -json_asset asset_configuration.json -json_cliquet cliquet_configuration.json -json_ae miqae_configuration.json -json_qpu qpu_ideal.json -id 3 --print --exe" + ] + }, + { + "cell_type": "markdown", + "id": "a2482f9d", + "metadata": {}, + "source": [ + "### 7.6 Other arguments\n", + "\n", + "Other arguments that can be provided are:\n", + "\n", + "* -repetitions REPETITIONS: for executing one case REPETITIONS times\n", + "* -folder: Path with folder where the Pandas DataFrames will be saved\n", + "* -name: for providing an additional name to the saved pdf\n", + "* --save: For saving the obtained Pandas DataFrame" + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "bf3c61cc", + "metadata": {}, + "source": [ + "## 8. Results\n", + "\n", + "\n", + "Here, we provide the performance results of different **AE** algorithms for a Cliquet option. These results were obtained by executing the *benchmark_cliquet_step_po.py* and *benchmark_cliquet.py* scripts from the command line and providing properly configured JSON files.\n", + "\n", + "### Asset Configuration\n", + "\n", + "The asset configuration for the *Cliquet Option* is presented in the following table:\n", + "\n", + "
n_qbits s_0 risk_free_rate volatility bounds reset_dates
6 1 0.05 0.5 7.0 [0.0, 1.0, 2.0]
\n", + "\n", + "### Cliquet Option Configuration\n", + "\n", + "The configuration of the *Cliquet option* is presented in the following table:\n", + "\n", + "
reset_dates local_cap local_floor global_cap global_floor
[0.0, 1.0, 2.0] 0.1 -0.1 0.2 -0.2
\n", + "\n", + "\n", + "### AE algorithms\n", + "\n", + "We have used the 2 following **AE** algorithm configurations:\n", + "\n", + "* **mRQAE**:\n", + " * $\\epsilon = 10^{-2}, 10^{-3}, 10^{-4}, 10^{-5}$\n", + " * $q$: 2\n", + " * $\\gamma$: 0.05\n", + " * Encoding Pay Off: Direct.\n", + " * Script used: *benchmark_cliquet.py*\n", + " * QPU: c or LinAlg\n", + "* **mIQAE**:\n", + " * $\\epsilon = 10^{-2}, 10^{-3}, 10^{-4}, 10^{-5}$\n", + " * $\\alpha$: 0.05\n", + " * Encoding Pay Off: Direct and Square.\n", + " * Script used: *benchmark_cliquet_step_po.py*\n", + " * QPU: c or LinAlg \n", + " \n", + "\n", + "The return of the configured *Cliquet Option* for the asset configuration, calculated using the Riemann integral, is **-0.021686**. Meanwhile, the discounted value is **-0.019622**.\n", + "\n", + "The performance comparison is presented in the following figure, where the *Number of Oracle Calls* is plotted against the *Absolute Error* (in this case, the error is computed relative to the pure Riemann integral value: **-0.021686**):\n", + "\n", + "![image.png](attachment:image.png)\n", + "\n", + "\n", + "\n", + "As can be seen, the performance of *mRQAE* is comparable to that of *mIQAE* for both types of payoff encodings (direct and square).\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/benchmark/q_ae_cliquet/asset_configuration.json b/benchmark/q_ae_cliquet/asset_configuration.json new file mode 100644 index 0000000..eb01c71 --- /dev/null +++ b/benchmark/q_ae_cliquet/asset_configuration.json @@ -0,0 +1,10 @@ +[ + { + "n_qbits" : [6], + "s_0": [1], + "risk_free_rate": [0.05], + "volatility": [0.5], + "bounds" : [7.0], + "reset_dates" : [[0.0, 1.0, 2.0]] + } +] diff --git a/benchmark/q_ae_cliquet/benchmark_cliquet.py b/benchmark/q_ae_cliquet/benchmark_cliquet.py new file mode 100644 index 0000000..db199d4 --- /dev/null +++ b/benchmark/q_ae_cliquet/benchmark_cliquet.py @@ -0,0 +1,260 @@ +""" +This module contains a class for selecting data encoding protocols + +Authors: Alberto Pedro Manzano Herrero & Gonzalo Ferro + +""" + +import sys +import os +import json +import pandas as pd +import itertools as it +from collections import ChainMap +sys.path.append("../../") +from QQuantLib.utils.benchmark_utils import create_ae_pe_solution,\ +combination_for_list +from QQuantLib.finance.cliquet_return_estimation import ae_cliquet_estimation +from QQuantLib.qpu.select_qpu import select_qpu + + +def save(save, save_name, input_pdf, save_mode): + """ + For saving panda DataFrames to csvs + + Parameters + ---------- + + save: bool + For saving or not + save_nam: str + name for file + input_pdf: pandas DataFrame + save_mode: str + saving mode: overwrite (w) or append (a) + """ + if save: + with open(save_name, save_mode) as f_pointer: + input_pdf.to_csv( + f_pointer, + mode=save_mode, + header=f_pointer.tell() == 0, + sep=';' + ) + +def run_id( + solve_ae_pe, + id_name, + repetitions, + file_name="", + folder_name="", + #qpu=None, + save_=False +): + """ + This function configure the mandatory dictionary needed for solving + an option price estimation problem using the ae_price_estimation + function. + + Parameters + ---------- + + solve_ae_pe : python dictionary + The dictionary should have all the mandatory keys for creating + a price estimation problem and solving it using a properly configured + AE integrations technique. + id_name: string + name for giving to the estimation problem for saving purpouses + repetitions : int + number of times for executing the estimation problem + file_name: string + name for the file where results will be stored. If not given will + be created using id_name and ae_type string. + folder_name: string + folder name for saving the results of the solution of the + price estimation problem + qlmaas: bool + For usign a QLM as a Service for solving the price estimation + problem + save_: bool + For saving the results of the the price estimation problem as a + csv + + Return + ---------- + + pdf : Pandas DataFrame + DataFrame with all the information of the price estimation + problem, the configuration of the ae and the obtained results + """ + + qpu = select_qpu(solve_ae_pe) + if save_: + if folder_name is None: + raise ValueError("folder_name is None!") + if not os.path.exists(folder_name): + os.mkdir(folder_name) + save_name = folder_name + str(id_name) + "_" + \ + solve_ae_pe["file"] + str(file_name) + ".csv" + solve_ae_pe.update({"qpu": qpu}) + final = [] + for i in range(repetitions): + step_pdf = ae_cliquet_estimation(**solve_ae_pe) + final.append(step_pdf) + save(save_, save_name, step_pdf, "a") + final = pd.concat(final).reset_index(drop=True) + print(final) + return final + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument( + "--count", + dest="count", + default=False, + action="store_true", + help="For counting elements on the list", + ) + parser.add_argument( + "--print", + dest="print", + default=False, + action="store_true", + help="For printing " + ) + parser.add_argument( + "--all", + dest="all", + default=False, + action="store_true", + help="For executing complete list", + ) + parser.add_argument( + "--exe", + dest="execution", + default=False, + action="store_true", + help="For executing program", + ) + parser.add_argument( + "--save", + dest="save", + default=False, + action="store_true", + help="For saving results", + ) + parser.add_argument( + "-folder", + dest="folder_path", + type=str, + help="Path for storing folder", + default="./", + ) + parser.add_argument( + "-name", + dest="file_name", + type=str, + help="Name for storing csv. Only applies for --all", + default="", + ) + # parser.add_argument( + # "-qpu", + # dest="qpu", + # type=str, + # default="python", + # help="QPU for simulation: [qlmass, python, c]", + # ) + parser.add_argument( + "-id", + dest="id", + type=int, + help="For executing only one element of the list", + default=None, + ) + parser.add_argument( + "-repetitions", + dest="repetitions", + type=int, + help="Number of repetitions the integral will be computed."+ + "Default: 1", + default=1, + ) + parser.add_argument( + "-json_asset", + dest="json_asset", + type=str, + default="asset_configuration.json", + help="JSON with the asset configuration", + ) + parser.add_argument( + "-json_cliquet", + dest="json_cliquet", + type=str, + default="cliquet_configuration.json", + help="JSON with the payoff configuration", + ) + parser.add_argument( + "-json_ae", + dest="json_ae", + type=str, + default=None, + help="JSON AE algorithm configuration", + ) + parser.add_argument( + "-json_qpu", + dest="json_qpu", + type=str, + default="jsons/qpu_ideal.json", + help="JSON with the qpu configuration", + ) + args = parser.parse_args() + print(args) + + #First we need to load the dictionaries for the price estimation problems + + with open(args.json_asset) as json_file: + asset_cfg = json.load(json_file) + with open(args.json_cliquet) as json_file: + cliquet_cfg = json.load(json_file) + #list wiht all the complete price estimation problems + cliquet_pe = create_ae_pe_solution( + combination_for_list(asset_cfg), + combination_for_list(cliquet_cfg) + ) + if args.json_ae is None: + raise ValueError("AE algorithm configuration NOT provided!") + + with open(args.json_ae) as json_file: + ae_cfg = json.load(json_file) + # Creates the complete configuration for AE solvers + ae_solver = combination_for_list(ae_cfg) + final_list = create_ae_pe_solution(ae_solver, cliquet_pe) + with open(args.json_qpu) as json_file: + noisy_cfg = json.load(json_file) + qpu_list = combination_for_list(noisy_cfg) + final_list = create_ae_pe_solution(final_list, qpu_list) + + + if args.count: + print(len(final_list)) + if args.print: + if args.id is not None: + print(final_list[args.id]) + else: + print(final_list) + + + if args.execution: + if args.id is not None: + run_id( + final_list[args.id], + args.id, + args.repetitions, + file_name=args.file_name, + folder_name=args.folder_path, + #qpu=args.qpu, + save_=args.save, + ) diff --git a/benchmark/q_ae_cliquet/benchmark_cliquet_step_po.py b/benchmark/q_ae_cliquet/benchmark_cliquet_step_po.py new file mode 100644 index 0000000..a22872b --- /dev/null +++ b/benchmark/q_ae_cliquet/benchmark_cliquet_step_po.py @@ -0,0 +1,263 @@ +""" +This module contains a class for selecting data encoding protocols + +Authors: Alberto Pedro Manzano Herrero & Gonzalo Ferro + +""" + +import sys +import os +import json +import pandas as pd +import itertools as it +from collections import ChainMap +sys.path.append("../../") +from QQuantLib.utils.benchmark_utils import create_ae_pe_solution,\ +combination_for_list +from QQuantLib.finance.cliquet_return_estimation_step_payoff import ae_cliquet_estimation_step_po +from QQuantLib.qpu.select_qpu import select_qpu + + + + + +def save(save, save_name, input_pdf, save_mode): + """ + For saving panda DataFrames to csvs + + Parameters + ---------- + + save: bool + For saving or not + save_nam: str + name for file + input_pdf: pandas DataFrame + save_mode: str + saving mode: overwrite (w) or append (a) + """ + if save: + with open(save_name, save_mode) as f_pointer: + input_pdf.to_csv( + f_pointer, + mode=save_mode, + header=f_pointer.tell() == 0, + sep=';' + ) + +def run_id( + solve_ae_pe, + id_name, + repetitions, + file_name="", + folder_name="", + #qpu=None, + save_=False +): + """ + This function configure the mandatory dictionary needed for solving + an option price estimation problem using the ae_price_estimation + function. + + Parameters + ---------- + + solve_ae_pe : python dictionary + The dictionary should have all the mandatory keys for creating + a price estimation problem and solving it using a properly configured + AE integrations technique. + id_name: string + name for giving to the estimation problem for saving purpouses + repetitions : int + number of times for executing the estimation problem + file_name: string + name for the file where results will be stored. If not given will + be created using id_name and ae_type string. + folder_name: string + folder name for saving the results of the solution of the + price estimation problem + qlmaas: bool + For usign a QLM as a Service for solving the price estimation + problem + save_: bool + For saving the results of the the price estimation problem as a + csv + + Return + ---------- + + pdf : Pandas DataFrame + DataFrame with all the information of the price estimation + problem, the configuration of the ae and the obtained results + """ + + qpu = select_qpu(solve_ae_pe) + if save_: + if folder_name is None: + raise ValueError("folder_name is None!") + if not os.path.exists(folder_name): + os.mkdir(folder_name) + save_name = folder_name + str(id_name) + "_" + \ + solve_ae_pe["file"] + str(file_name) + "_po_parts.csv" + solve_ae_pe.update({"qpu": qpu}) + final = [] + for i in range(repetitions): + step_pdf = ae_cliquet_estimation_step_po(**solve_ae_pe) + final.append(step_pdf) + save(save_, save_name, step_pdf, "a") + final = pd.concat(final).reset_index(drop=True) + print(final) + return final + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument( + "--count", + dest="count", + default=False, + action="store_true", + help="For counting elements on the list", + ) + parser.add_argument( + "--print", + dest="print", + default=False, + action="store_true", + help="For printing " + ) + parser.add_argument( + "--all", + dest="all", + default=False, + action="store_true", + help="For executing complete list", + ) + parser.add_argument( + "--exe", + dest="execution", + default=False, + action="store_true", + help="For executing program", + ) + parser.add_argument( + "--save", + dest="save", + default=False, + action="store_true", + help="For saving results", + ) + parser.add_argument( + "-folder", + dest="folder_path", + type=str, + help="Path for storing folder", + default="./", + ) + parser.add_argument( + "-name", + dest="file_name", + type=str, + help="Name for storing csv. Only applies for --all", + default="", + ) + # parser.add_argument( + # "-qpu", + # dest="qpu", + # type=str, + # default="python", + # help="QPU for simulation: [qlmass, python, c]", + # ) + parser.add_argument( + "-id", + dest="id", + type=int, + help="For executing only one element of the list", + default=None, + ) + parser.add_argument( + "-repetitions", + dest="repetitions", + type=int, + help="Number of repetitions the integral will be computed."+ + "Default: 1", + default=1, + ) + parser.add_argument( + "-json_asset", + dest="json_asset", + type=str, + default="asset_configuration.json", + help="JSON with the asset configuration", + ) + parser.add_argument( + "-json_cliquet", + dest="json_cliquet", + type=str, + default="cliquet_configuration.json", + help="JSON with the payoff configuration", + ) + parser.add_argument( + "-json_ae", + dest="json_ae", + type=str, + default=None, + help="JSON AE algorithm configuration", + ) + parser.add_argument( + "-json_qpu", + dest="json_qpu", + type=str, + default="jsons/qpu_ideal.json", + help="JSON with the qpu configuration", + ) + args = parser.parse_args() + print(args) + + #First we need to load the dictionaries for the price estimation problems + + with open(args.json_asset) as json_file: + asset_cfg = json.load(json_file) + with open(args.json_cliquet) as json_file: + cliquet_cfg = json.load(json_file) + #list wiht all the complete price estimation problems + cliquet_pe = create_ae_pe_solution( + combination_for_list(asset_cfg), + combination_for_list(cliquet_cfg) + ) + if args.json_ae is None: + raise ValueError("AE algorithm configuration NOT provided!") + + with open(args.json_ae) as json_file: + ae_cfg = json.load(json_file) + # Creates the complete configuration for AE solvers + ae_solver = combination_for_list(ae_cfg) + final_list = create_ae_pe_solution(ae_solver, cliquet_pe) + with open(args.json_qpu) as json_file: + noisy_cfg = json.load(json_file) + qpu_list = combination_for_list(noisy_cfg) + final_list = create_ae_pe_solution(final_list, qpu_list) + + + if args.count: + print(len(final_list)) + if args.print: + if args.id is not None: + print(final_list[args.id]) + else: + print(final_list) + + + if args.execution: + if args.id is not None: + run_id( + final_list[args.id], + args.id, + args.repetitions, + file_name=args.file_name, + folder_name=args.folder_path, + #qpu=args.qpu, + save_=args.save, + ) diff --git a/benchmark/q_ae_cliquet/cliquet_configuration.json b/benchmark/q_ae_cliquet/cliquet_configuration.json new file mode 100644 index 0000000..ab1f636 --- /dev/null +++ b/benchmark/q_ae_cliquet/cliquet_configuration.json @@ -0,0 +1,8 @@ +[ + { + "local_cap" : [0.1], + "local_floor" : [-0.1], + "global_cap" : [0.2], + "global_floor": [-0.2] + } +] diff --git a/benchmark/q_ae_cliquet/miqae_configuration.json b/benchmark/q_ae_cliquet/miqae_configuration.json new file mode 100644 index 0000000..adbe395 --- /dev/null +++ b/benchmark/q_ae_cliquet/miqae_configuration.json @@ -0,0 +1,31 @@ +[ + { + "ae_type": ["mIQAE"], + "file": ["mIQAE"], + + "schedule": [null], + "delta": [null], + "ns": [null], + + "auxiliar_qbits_number": [null], + "window" : [null], + "kaiser_alpha" : [null], + + "cbits_number": [null], + + "epsilon": [1.0e-2, 1.0e-3, 1.0e-4, 1.0e-5], + + "alpha": [0.05], + + "gamma": [null], + "q": [null], + + "erqae_schedule" :[null], + + "encoding" : [0, 2], + "multiplexor": [true], + + "mcz_qlm": [false], + "shots": [100] + } +] diff --git a/benchmark/q_ae_cliquet/mrqae_configuration.json b/benchmark/q_ae_cliquet/mrqae_configuration.json new file mode 100644 index 0000000..f61c570 --- /dev/null +++ b/benchmark/q_ae_cliquet/mrqae_configuration.json @@ -0,0 +1,31 @@ +[ + { + "ae_type": ["mRQAE"], + "file": ["mRQAE"], + + "schedule": [null], + "delta": [null], + "ns": [null], + + "auxiliar_qbits_number": [null], + "window" : [null], + "kaiser_alpha" : [null], + + "cbits_number": [null], + + "epsilon": [1.0e-2, 1.0e-3, 1.0e-4, 1.0e-5], + + "alpha": [null], + + "gamma": [0.05], + "q": [2], + + "erqae_schedule" :[null], + + "encoding" : [2], + "multiplexor": [true], + + "mcz_qlm": [false], + "shots": [null] + } +] diff --git a/benchmark/q_ae_cliquet/qpu_ideal.json b/benchmark/q_ae_cliquet/qpu_ideal.json new file mode 100644 index 0000000..f92cef2 --- /dev/null +++ b/benchmark/q_ae_cliquet/qpu_ideal.json @@ -0,0 +1,24 @@ + +[ + { + "qpu_type": ["c"], + "t_gate_1qb" : [null], + "t_gate_2qbs" : [null], + "t_readout": [null], + "depol_channel" : [{ + "active": false, + "error_gate_1qb" : null, + "error_gate_2qbs" : null + }], + "idle" : [{ + "amplitude_damping": false, + "dephasing_channel": false, + "t1" : null, + "t2" : null + }], + "meas": [{ + "active":false, + "readout_error": null + }] + } +] diff --git a/benchmark/sine_integral/qae_sine_integral.py b/benchmark/sine_integral/qae_sine_integral.py index 945049e..480a0b5 100644 --- a/benchmark/sine_integral/qae_sine_integral.py +++ b/benchmark/sine_integral/qae_sine_integral.py @@ -185,7 +185,8 @@ def run_id( qpu=None, save_=False, folder_path=None, - id_=None + id_=None, + file_add="" ): ae_config.update({"qpu":select_qpu(ae_config)}) @@ -198,7 +199,7 @@ def run_id( ae_type = ae_config["ae_type"] base_name = ae_type + "_n_qbits_" + str(n_qbits) + \ - "_interval_" + str(interval) + "_id_" + str(id_) + ".csv" + "_interval_" + str(interval) + "_id_" + str(id_) + file_add + ".csv" file_name = folder_path + "/" + base_name list_of_pdfs = [] @@ -269,6 +270,13 @@ def run_id( default="qpu/qpu.json", help="JSON with the qpu configuration", ) + parser.add_argument( + "-file_add", + dest="file_add", + type=str, + default="", + help="Add a string to the file name to save.", + ) parser.add_argument( "-folder", dest="folder_path", @@ -337,5 +345,6 @@ def run_id( folder_path=args.folder_path, #qpu=args.qpu, save_=args.save, - id_=args.id + id_=args.id, + file_add=args.file_add ))