stochvolmodels 1.0.9__tar.gz → 1.0.11__tar.gz

{stochvolmodels-1.0.9 → stochvolmodels-1.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stochvolmodels
-Version: 1.0.9
+Version: 1.0.11
 Summary: Implementation of stochastic volatility models for option pricing
 Home-page: https://github.com/ArturSepp/StochVolModels
 License: LICENSE.txt

{stochvolmodels-1.0.9 → stochvolmodels-1.0.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "stochvolmodels"
-version = "1.0.9"
+version = "1.0.11"
 description = "Implementation of stochastic volatility models for option pricing"
 license = "LICENSE.txt"
 authors = ["Artur Sepp <artursepp@gmail.com>"]

{stochvolmodels-1.0.9 → stochvolmodels-1.0.11}/stochvolmodels/__init__.py

@@ -62,6 +62,11 @@ from stochvolmodels.pricers.logsv_pricer import (
 
 from stochvolmodels.data.option_chain import OptionChain, OptionSlice
 
+from stochvolmodels.data.fetch_option_chain import (generate_vol_chain_np,
+                                                    load_option_chain,
+                                                    sample_option_chain_at_times,
+                                                    load_price_data)
+
 from stochvolmodels.data.test_option_chain import (
     get_btc_test_chain_data,
     get_gld_test_chain_data,

stochvolmodels-1.0.11/stochvolmodels/data/fetch_option_chain.py

@@ -0,0 +1,176 @@
+"""
+this module is using option-chain-analytics package
+to fetch OptionChain data with options data
+see https://pypi.org/project/option-chain-analytics
+"""
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import qis
+from qis import TimePeriod
+from typing import Dict, Tuple, Optional, Literal
+from numba.typed import List
+from enum import Enum
+
+# chain
+from option_chain_analytics import OptionsDataDFs, create_chain_from_from_options_dfs
+from option_chain_analytics.option_chain import SliceColumn, SlicesChain
+
+# analytics
+from stochvolmodels.data.option_chain import OptionChain
+
+
+def generate_vol_chain_np(chain: SlicesChain,
+                          value_time: pd.Timestamp,
+                          days_map: Dict[str, int] = {'1w': 7, '1m': 21},
+                          delta_bounds: Tuple[Optional[float], Optional[float]] = (-0.1, 0.1),
+                          is_filtered: bool = True
+                          ) -> OptionChain:
+    """
+    given SlicesChain generate OptionChain for calibration inputs
+    """
+
+    ttms, future_prices, discfactors = List(), List(), List()
+    optiontypes_ttms, strikes_ttms = List(), List()
+    bid_ivs, ask_ivs = List(), List()
+    bid_prices, ask_prices = List(), List()
+    slice_ids = []
+    for label, day in days_map.items():
+        next_date = value_time + pd.DateOffset(days=day)  # if overlapping next date will be last avilable maturity
+        slice_date = chain.get_next_slice_after_date(mat_date=next_date)
+        slice_t = chain.expiry_slices[slice_date]
+        df = slice_t.get_joint_slice(delta_bounds=delta_bounds, is_filtered=is_filtered)
+        if not df.empty:
+            slice_ids.append(f"{label}: {slice_t.expiry_id}")
+            ttms.append(slice_t.get_ttm())
+            future_prices.append(slice_t.get_future_price())
+            discfactors.append(1.0)
+            strikes_ttms.append(df.index.to_numpy())
+            optiontypes_ttms.append(df[SliceColumn.OPTION_TYPE].to_numpy(dtype=str))
+            bid_ivs.append(df[SliceColumn.BID_IV].to_numpy())
+            ask_ivs.append(df[SliceColumn.ASK_IV].to_numpy())
+            bid_prices.append(df[SliceColumn.BID_PRICE].to_numpy())
+            ask_prices.append(df[SliceColumn.ASK_PRICE].to_numpy())
+
+    out = OptionChain(ttms=np.array(ttms),
+                      forwards=np.array(future_prices),
+                      discfactors=np.array(discfactors),
+                      ids=np.array(slice_ids),
+                      strikes_ttms=strikes_ttms,
+                      optiontypes_ttms=optiontypes_ttms,
+                      bid_ivs=bid_ivs,
+                      ask_ivs=ask_ivs,
+                      bid_prices=bid_prices,
+                      ask_prices=ask_prices)
+    return out
+
+
+def load_option_chain(options_data_dfs: OptionsDataDFs,
+                      value_time: pd.Timestamp = pd.Timestamp('2023-02-06 08:00:00+00:00'),
+                      days_map: Dict[str, int] = {'1w': 7, '1m': 21},
+                      delta_bounds: Tuple[Optional[float], Optional[float]] = (-0.1, 0.1),
+                      is_filtered: bool = True
+                      ) -> Optional[OptionChain]:
+    chain = create_chain_from_from_options_dfs(options_data_dfs=options_data_dfs, value_time=value_time)
+    if chain is not None:
+        option_chain = generate_vol_chain_np(chain=chain,
+                                             value_time=value_time,
+                                             days_map=days_map,
+                                             delta_bounds=delta_bounds,
+                                             is_filtered=is_filtered)
+    else:
+        option_chain = None
+
+    return option_chain
+
+
+def sample_option_chain_at_times(options_data_dfs: OptionsDataDFs,
+                                 time_period: TimePeriod,
+                                 freq: str = 'W-FRI',
+                                 days_map: Dict[str, int] = {'1w': 7, '1m': 21},
+                                 delta_bounds: Tuple[Optional[float], Optional[float]] = (-0.1, 0.1),
+                                 hour_offset: int = 8
+                                 ) -> Dict[pd.Timestamp, OptionChain]:
+    value_times = qis.generate_dates_schedule(time_period=time_period,
+                                              freq=freq,
+                                              hour_offset=hour_offset)
+    option_chains = {}
+    for value_time in value_times:
+        option_chains[value_time] = load_option_chain(options_data_dfs=options_data_dfs,
+                                                      value_time=value_time,
+                                                      days_map=days_map,
+                                                      delta_bounds=delta_bounds,
+                                                      is_filtered=True)
+    return option_chains
+
+
+def load_price_data(options_data_dfs: OptionsDataDFs,
+                    time_period: TimePeriod = None,
+                    data: Literal['spot', 'perp', 'funding_rate'] = 'spot',
+                    freq: Optional[str] = 'D'  # to do
+                    ) -> pd.Series:
+    #options_data_dfs = OptionsDataDFs(**ts_data_loader_wrapper(ticker=ticker, freq='D', hour_offset=8))
+    spot_price = options_data_dfs.get_spot_data()[data]
+    if freq is not None:
+        spot_price = spot_price.resample(freq).last()
+    if time_period is not None:
+        spot_price = time_period.locate(spot_price)
+    return spot_price
+
+
+class UnitTests(Enum):
+    PRINT_CHAIN_DATA = 1
+    GENERATE_VOL_CHAIN_NP = 2
+    SAMPLE_CHAIN_AT_TIMES = 3
+
+
+def run_unit_test(unit_test: UnitTests):
+
+    ticker = 'BTC'  # BTC, ETH
+    value_time = pd.Timestamp('2021-10-21 08:00:00+00:00')
+    value_time = pd.Timestamp('2023-10-06 08:00:00+00:00')
+
+    from option_chain_analytics.ts_loaders import ts_data_loader_wrapper
+    options_data_dfs = OptionsDataDFs(**ts_data_loader_wrapper(ticker=ticker))
+    options_data_dfs.get_start_end_date().print()
+    chain = create_chain_from_from_options_dfs(options_data_dfs=options_data_dfs, value_time=value_time)
+
+    if unit_test == UnitTests.PRINT_CHAIN_DATA:
+        for expiry, eslice in chain.expiry_slices.items():
+            eslice.print()
+
+    elif unit_test == UnitTests.GENERATE_VOL_CHAIN_NP:
+        option_chain = generate_vol_chain_np(chain=chain,
+                                             value_time=value_time,
+                                             days_map={'1w': 7},
+                                             delta_bounds=(-0.1, 0.1),
+                                             is_filtered=True)
+        option_chain.print()
+        skews = option_chain.get_chain_skews(delta=0.35)
+        print(skews)
+
+    elif unit_test == UnitTests.SAMPLE_CHAIN_AT_TIMES:
+        time_period = qis.TimePeriod('01Jan2023', '31Jan2023', tz='UTC')
+        option_chains = sample_option_chain_at_times(options_data_dfs=options_data_dfs,
+                                                     time_period=time_period,
+                                                     freq='W-FRI',
+                                                     hour_offset=9
+                                                     )
+        for key, chain in option_chains.items():
+            print(f"{key}")
+            print(chain)
+
+    plt.show()
+
+
+if __name__ == '__main__':
+
+    unit_test = UnitTests.SAMPLE_CHAIN_AT_TIMES
+
+    is_run_all_tests = False
+    if is_run_all_tests:
+        for unit_test in UnitTests:
+            run_unit_test(unit_test=unit_test)
+    else:
+        run_unit_test(unit_test=unit_test)

{stochvolmodels-1.0.9 → stochvolmodels-1.0.11}/stochvolmodels/data/option_chain.py

@@ -85,7 +85,9 @@ class OptionChain:
                     forwards=self.forwards,
                     strikes_ttms=self.strikes_ttms,
                     optiontypes_ttms=self.optiontypes_ttms,
-                    ids=self.ids)
+                    ids=self.ids,
+                    bid_ivs=self.bid_ivs,
+                    ask_ivs=self.ask_ivs)
         for k, v in this.items():
             print(f"{k}:\n{v}")
 

{stochvolmodels-1.0.9 → stochvolmodels-1.0.11}/stochvolmodels/data/test_option_chain.py

@@ -847,10 +847,10 @@ def get_qv_options_test_chain_data(num_strikes: int = 21) -> OptionChain:
     """
     BTC implied vols of 21Oct2021
     """
-    ids = array(['1m', '3m', '6m', '12m'])
-    ttms = array([0.083333333, 0.25, 0.5, 1.0])
-    forwards = array([1.0, 1.0, 1.0, 1.0])
-    discfactors = array([1.0, 1.0, 1.0, 1.0])
+    ids = array(['1w', '2w', '1m', '3m', '6m', '12m'])
+    ttms = array([7.0/365.0, 14.0/365.0, 0.083333333, 0.25, 0.5, 1.0])
+    forwards = array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
+    discfactors = array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
     strikes_ttm = np.linspace(0.75, 1.5, num_strikes)
     strikes_ttms = (strikes_ttm, strikes_ttm, strikes_ttm, strikes_ttm)
 

{stochvolmodels-1.0.9 → stochvolmodels-1.0.11}/stochvolmodels/pricers/core/mc_payoffs.py

@@ -9,7 +9,9 @@ from ...pricers.core.config import VariableType
 
 
 @njit(cache=False, fastmath=True)
-def compute_mc_vars_payoff(x0: np.ndarray, sigma0: np.ndarray, qvar0: np.ndarray,
+def compute_mc_vars_payoff(x0: np.ndarray,
+                           sigma0: np.ndarray,
+                           qvar0: np.ndarray,
                            ttm: float,
                            forward: float,
                            strikes_ttm: np.ndarray,

{stochvolmodels-1.0.9 → stochvolmodels-1.0.11}/stochvolmodels/pricers/core/mgf_pricer.py

@@ -39,8 +39,10 @@ def get_phi_grid(is_spot_measure: bool = True,
 def get_psi_grid() -> np.ndarray:
     """
     for I = QV variable
+    need a lot of step for short-dated options
+    todo: find a non-uniform grid for short dated options
     """
-    p = np.linspace(0, 200, 4000)
+    p = np.linspace(0, 4000, 40000)
     real_p = -0.5
     psi_grid = real_p + 1j * p
     return psi_grid
@@ -51,8 +53,8 @@ def get_theta_grid() -> np.ndarray:
     """
     for sigma
     """
-    p = np.linspace(0, 600, 4000)
-    real_p = -0.5
+    p = np.linspace(0, 600, 5000)
+    real_p = 0.0
     theta_grid = real_p + 1j * p
     return theta_grid
 
@@ -303,6 +305,7 @@ def pdf_with_mgf_grid(log_mgf_grid: np.ndarray,
                       transform_var_grid: np.ndarray,
                       space_grid: np.ndarray,
                       shift: float = 0.0,
+                      scale: float = 1.0,
                       is_simpson: bool = True
                       ) -> np.ndarray:
     """
@@ -313,8 +316,9 @@ def pdf_with_mgf_grid(log_mgf_grid: np.ndarray,
     """
     dp = compute_integration_weights(var_grid=transform_var_grid, is_simpson=is_simpson) / np.pi
     pdf = np.zeros_like(space_grid)
-    for idx, x in enumerate(space_grid):
-        pdf[idx] = np.nansum(np.real(dp * np.exp((x-shift) * transform_var_grid + log_mgf_grid)))
+    z = (space_grid - shift) / scale
+    for idx, x in enumerate(z):
+        pdf[idx] = np.nansum(np.real(dp * np.exp(x * transform_var_grid + log_mgf_grid)))
     dx = space_grid[1] - space_grid[0]
     pdf = dx * pdf
     return pdf

{stochvolmodels-1.0.9 → stochvolmodels-1.0.11}/stochvolmodels/pricers/logsv/affine_expansion.py

@@ -47,12 +47,12 @@ def func_a_ode_quadratic_terms(theta: float,
     qv2 = theta2 * vartheta2
     if is_spot_measure:
         lamda = 0
-        kappa_p = kappa1 + kappa2 * theta
         kappa2_p = kappa2
+        kappa_p = kappa1 + kappa2 * theta
     else:
         lamda = beta*theta2
-        kappa_p = kappa1 + kappa2 * theta - 2*beta*theta
         kappa2_p = kappa2-beta
+        kappa_p = kappa1 + kappa2 * theta - 2*beta*theta
 
     # fill Ms: M should be of same type as L and H for numba, eventhough they are real
     # utilize that M is symmetric

{stochvolmodels-1.0.9 → stochvolmodels-1.0.11}/stochvolmodels/pricers/logsv_pricer.py

@@ -62,6 +62,10 @@ class LogSvParams(ModelParams):
     def to_dict(self) -> Dict[str, Any]:
         return asdict(self)
 
+    def to_str(self) -> str:
+        return f"sigma0={self.sigma0:0.2f}, theta={self.theta:0.2f}, kappa1={self.kappa1:0.2f}, kappa2={self.kappa2:0.2f}, " \
+               f"beta={self.beta:0.2f}, volvol={self.volvol:0.2f}"
+
     @property
     def kappa(self) -> float:
         return self.kappa1+self.kappa2*self.theta
@@ -88,24 +92,35 @@ class LogSvParams(ModelParams):
         """
         return self.kappa1 * self.theta / self.vartheta2 - 1.0
 
-    def get_x_grid(self, ttm: float = 1.0, n_stdevs: int = 3, n: int = 200) -> np.ndarray:
+    def get_x_grid(self, ttm: float = 1.0, n_stdevs: float = 3.0, n: int = 200) -> np.ndarray:
+        """
+        spacial grid to compute density of x
+        """
         sigma_t = np.sqrt(ttm * 0.5 * (np.square(self.sigma0) + np.square(self.theta)))
         drift = - 0.5*sigma_t*sigma_t
         stdev = (n_stdevs+1)*sigma_t
         return np.linspace(-stdev+drift, stdev+drift, n)
 
-    def get_sigma_grid(self, ttm: float = 1.0, n_stdevs: int = 3, n: int = 200) -> np.ndarray:
-        sigma_t = np.sqrt(ttm * 0.5 * (np.square(self.sigma0) + np.square(self.theta)))
-        vvol = np.sqrt(self.vartheta2/np.abs(2.0*self.kappa1))
+    def get_sigma_grid(self, ttm: float = 1.0, n_stdevs: float = 3.0, n: int = 200) -> np.ndarray:
+        """
+        spacial grid to compute density of sigma
+        """
+        sigma_t = np.sqrt(0.5*(np.square(self.sigma0) + np.square(self.theta)))
+        vvol = 0.5*np.sqrt(self.vartheta2*ttm)
         return np.linspace(0.0, sigma_t+n_stdevs*vvol, n)
 
-    def get_qvar_grid(self, ttm: float = 1.0, n_stdevs: int = 3, n: int = 200) -> np.ndarray:
-        sigma_t = np.sqrt(ttm * 0.5 * (np.square(self.sigma0) + np.square(self.theta)))
-        vvol = np.sqrt(self.vartheta2/np.abs(2.0*self.kappa1))
+    def get_qvar_grid(self, ttm: float = 1.0, n_stdevs: float = 3.0, n: int = 200) -> np.ndarray:
+        """
+        spacial grid to compute density of i
+        """
+        sigma_t = np.sqrt(ttm * (np.square(self.sigma0) + np.square(self.theta)))
+        vvol = np.sqrt(self.vartheta2)*ttm
         return np.linspace(0.0, sigma_t+n_stdevs*vvol, n)
 
     def get_variable_space_grid(self, variable_type: VariableType = VariableType.LOG_RETURN,
-                                ttm: float = 1.0, n_stdevs: int = 3, n: int = 200
+                                ttm: float = 1.0,
+                                n_stdevs: float = 3,
+                                n: int = 200
                                 ) -> np.ndarray:
         if variable_type == VariableType.LOG_RETURN:
             return self.get_x_grid(ttm=ttm, n_stdevs=n_stdevs, n=n)
@@ -177,7 +192,7 @@ LOGSV_BTC_PARAMS = LogSvParams(sigma0=0.8376, theta=1.0413, kappa1=3.1844, kappa
 
 class LogSVPricer(ModelPricer):
 
-    @timer
+    # @timer
     def price_chain(self,
                     option_chain: OptionChain,
                     params: LogSvParams,
@@ -201,7 +216,10 @@ class LogSVPricer(ModelPricer):
     def model_mc_price_chain(self,
                              option_chain: OptionChain,
                              params: LogSvParams,
+                             is_spot_measure: bool = True,
+                             variable_type: VariableType = VariableType.LOG_RETURN,
                              nb_path: int = 100000,
+                             nb_steps: Optional[int] = None,
                              **kwargs
                              ) -> (List[np.ndarray], List[np.ndarray]):
         return logsv_mc_chain_pricer(v0=params.sigma0,
@@ -215,8 +233,18 @@ class LogSVPricer(ModelPricer):
                                      discfactors=option_chain.discfactors,
                                      strikes_ttms=option_chain.strikes_ttms,
                                      optiontypes_ttms=option_chain.optiontypes_ttms,
+                                     is_spot_measure=is_spot_measure,
+                                     variable_type=variable_type,
                                      nb_path=nb_path,
-                                     **kwargs)
+                                     nb_steps=nb_steps or int(360*np.max(option_chain.ttms))+1)
+
+    def set_vol_scaler(self, option_chain: OptionChain) -> float:
+        """
+        use chain vols to set the scaler
+        """
+        atm0 = option_chain.get_chain_atm_vols()[0]
+        ttm0 = option_chain.ttms[0]
+        return set_vol_scaler(sigma0=atm0, ttm=ttm0)
 
     @timer
     def calibrate_model_params_to_chain(self,
@@ -233,9 +261,7 @@ class LogSVPricer(ModelPricer):
         """
         implementation of model calibration interface with nonlinear constraints
         """
-        atm0 = option_chain.get_chain_atm_vols()[0]
-        ttm0 = option_chain.ttms[0]
-        vol_scaler = set_vol_scaler(sigma0=atm0, ttm=ttm0)
+        vol_scaler = self.set_vol_scaler(option_chain=option_chain)
 
         x, market_vols = option_chain.get_chain_data_as_xy()
         market_vols = to_flat_np_array(market_vols)  # market mid quotes
@@ -248,7 +274,46 @@ class LogSVPricer(ModelPricer):
         else:
             weights = np.ones_like(market_vols)
 
-        # implement different calibrato types
+        def parse_model_params(pars: np.ndarray) -> LogSvParams:
+            if model_calibration_type == LogsvModelCalibrationType.PARAMS4:
+                fit_params = LogSvParams(sigma0=pars[0],
+                                         theta=pars[1],
+                                         kappa1=params0.kappa1,
+                                         kappa2=params0.kappa2,
+                                         beta=pars[2],
+                                         volvol=pars[3])
+            elif model_calibration_type == LogsvModelCalibrationType.PARAMS5:
+                fit_params = LogSvParams(sigma0=pars[0],
+                                         theta=pars[1],
+                                         kappa1=pars[2],
+                                         kappa2=None,
+                                         beta=pars[3],
+                                         volvol=pars[4])
+            else:
+                raise NotImplementedError(f"{model_calibration_type}")
+            return fit_params
+
+        def objective(pars: np.ndarray, args: np.ndarray) -> float:
+            params = parse_model_params(pars=pars)
+            model_vols = self.compute_model_ivols_for_chain(option_chain=option_chain, params=params, vol_scaler=vol_scaler)
+            resid = np.nansum(weights * np.square(to_flat_np_array(model_vols) - market_vols))
+            return resid
+
+        # parametric constraints
+        def martingale_measure(pars: np.ndarray) -> float:
+            params = parse_model_params(pars=pars)
+            return params.kappa2 - params.beta
+
+        def inverse_measure(pars: np.ndarray) -> float:
+            params = parse_model_params(pars=pars)
+            return params.kappa2 - 2.0 * params.beta
+
+        def vol_4thmoment_finite(pars: np.ndarray) -> float:
+            params = parse_model_params(pars=pars)
+            kappa = params.kappa1 + params.kappa2 * params.theta
+            return kappa - 1.5 * params.vartheta2
+
+        # set initial params
         if model_calibration_type == LogsvModelCalibrationType.PARAMS4:
             # fit: v0, theta, beta, volvol; kappa1, kappa2 is given with params0
             p0 = np.array([params0.sigma0, params0.theta, params0.beta, params0.volvol])
@@ -257,29 +322,6 @@ class LogSVPricer(ModelPricer):
                       (params_min.beta, params_max.beta),
                       (params_min.volvol, params_max.volvol))
 
-            def objective(pars: np.ndarray, args: np.ndarray) -> float:
-                v0, theta, beta, volvol = pars[0], pars[1], pars[2], pars[3]
-                params = LogSvParams(sigma0=v0, theta=theta, kappa1=params0.kappa1,
-                                     kappa2=params0.kappa2, beta=beta, volvol=volvol)
-                model_vols = self.compute_model_ivols_for_chain(option_chain=option_chain, params=params,
-                                                                vol_scaler=vol_scaler)
-                resid = np.nansum(weights * np.square(to_flat_np_array(model_vols) - market_vols))
-                return resid
-
-            def martingale_measure(pars: np.ndarray) -> float:
-                v0, theta, beta, volvol = pars[0], pars[1], pars[2], pars[3]
-                return params0.kappa2 - beta
-
-            def inverse_measure(pars: np.ndarray) -> float:
-                v0, theta, beta, volvol = pars[0], pars[1], pars[2], pars[3]
-                return params0.kappa2 - 2.0 * beta
-
-            def vol_4thmoment_finite(pars: np.ndarray) -> float:
-                v0, theta, beta, volvol = pars[0], pars[1], pars[2], pars[3]
-                vartheta2 = beta * beta + volvol * volvol
-                kappa = params0.kappa1 + params0.kappa2 * theta
-                return kappa - 1.5 * vartheta2
-
         elif model_calibration_type == LogsvModelCalibrationType.PARAMS5:
             # fit: v0, theta, kappa1, beta, volvol; kappa2 is mapped as kappa1 / theta
             p0 = np.array([params0.sigma0, params0.theta, params0.kappa1, params0.beta, params0.volvol])
@@ -289,28 +331,6 @@ class LogSVPricer(ModelPricer):
                       (params_min.beta, params_max.beta),
                       (params_min.volvol, params_max.volvol))
 
-            def objective(pars: np.ndarray, args: np.ndarray) -> float:
-                v0, theta, kappa1, beta, volvol = pars[0], pars[1], pars[2], pars[3], pars[4]
-                params = LogSvParams(sigma0=v0, theta=theta, kappa1=kappa1, kappa2=None, beta=beta, volvol=volvol)
-                model_vols = self.compute_model_ivols_for_chain(option_chain=option_chain, params=params, vol_scaler=vol_scaler)
-                resid = np.nansum(weights * np.square(to_flat_np_array(model_vols) - market_vols))
-                return resid
-
-            def martingale_measure(pars: np.ndarray) -> float:
-                v0, theta, kappa1, beta, volvol = pars[0], pars[1], pars[2], pars[3], pars[4]
-                return kappa1 / theta - beta
-
-            def inverse_measure(pars: np.ndarray) -> float:
-                v0, theta, kappa1, beta, volvol = pars[0], pars[1], pars[2], pars[3], pars[4]
-                return kappa1 / theta - 2.0*beta
-
-            def vol_4thmoment_finite(pars: np.ndarray) -> float:
-                v0, theta, kappa1, beta, volvol = pars[0], pars[1], pars[2], pars[3], pars[4]
-                vartheta2 = beta*beta + volvol*volvol
-                kappa2 = kappa1 / theta
-                kappa = kappa1 + kappa2 * theta
-                return kappa - 1.5*vartheta2
-
         else:
             raise NotImplementedError(f"{model_calibration_type}")
 
@@ -349,26 +369,7 @@ class LogSVPricer(ModelPricer):
         else:
             res = minimize(objective, p0, args=None, method='SLSQP', bounds=bounds, options=options)
 
-        popt = res.x
-
-        if model_calibration_type == LogsvModelCalibrationType.PARAMS4:
-            fit_params = LogSvParams(sigma0=popt[0],
-                                     theta=popt[1],
-                                     kappa1=params0.kappa1,
-                                     kappa2=params0.kappa2,
-                                     beta=popt[2],
-                                     volvol=popt[3])
-
-        elif model_calibration_type == LogsvModelCalibrationType.PARAMS5:
-            fit_params = LogSvParams(sigma0=popt[0],
-                                     theta=popt[1],
-                                     kappa1=popt[2],
-                                     kappa2=None,
-                                     beta=popt[3],
-                                     volvol=popt[4])
-
-        else:
-            raise NotImplementedError(f"{model_calibration_type}")
+        fit_params = parse_model_params(pars=res.x)
 
         return fit_params
 
@@ -379,12 +380,14 @@ class LogSVPricer(ModelPricer):
                            ttm: float = 1.0,
                            nb_path: int = 100000,
                            is_spot_measure: bool = True,
-                           nb_steps: int = 360,
+                           nb_steps: int = None,
+                           year_days: int = 360,
                            **kwargs
                            ) -> Tuple[np.ndarray, np.ndarray]:
         """
         simulate vols in dt_path grid
         """
+        nb_steps = nb_steps or int(np.ceil(year_days * ttm))
         sigma_t, grid_t = simulate_vol_paths(ttm=ttm,
                                              v0=params.sigma0,
                                              theta=params.theta,
@@ -487,7 +490,8 @@ def logsv_chain_pricer(params: LogSvParams,
                        is_spot_measure: bool = True,
                        expansion_order: ExpansionOrder = ExpansionOrder.SECOND,
                        variable_type: VariableType = VariableType.LOG_RETURN,
-                       vol_scaler: float = None
+                       vol_scaler: float = None,
+                       **kwargs
                        ) -> List[np.ndarray]:
     """
     wrapper to price option chain on variable_type
@@ -590,19 +594,24 @@ def logsv_pdfs(params: LogSvParams,
     if variable_type == VariableType.LOG_RETURN:
         transform_var_grid = phi_grid
         shift = 0.0
-    elif variable_type == VariableType.Q_VAR:
+        scale = 1.0
+    elif variable_type == VariableType.Q_VAR:  # scaled by ttm
         transform_var_grid = psi_grid
         shift = 0.0
+        scale = 1.0 / ttm
     elif variable_type == VariableType.SIGMA:
         transform_var_grid = theta_grid
         shift = params.theta
+        scale = 1.0
     else:
         raise NotImplementedError
 
     pdf = mgfp.pdf_with_mgf_grid(log_mgf_grid=log_mgf_grid,
                                  transform_var_grid=transform_var_grid,
                                  space_grid=space_grid,
-                                 shift=shift)
+                                 shift=shift,
+                                 scale=scale)
+    pdf = pdf / scale
     return pdf
 
 
@@ -620,9 +629,9 @@ def logsv_mc_chain_pricer(ttms: np.ndarray,
                           volvol: float,
                           is_spot_measure: bool = True,
                           nb_path: int = 100000,
+                          nb_steps: int = 360,
                           variable_type: VariableType = VariableType.LOG_RETURN
                           ) -> Tuple[List[np.ndarray], List[np.ndarray]]:
-
     # starting values
     x0 = np.zeros(nb_path)
     qvar0 = np.zeros(nb_path)
@@ -643,6 +652,7 @@ def logsv_mc_chain_pricer(ttms: np.ndarray,
                                                           beta=beta,
                                                           volvol=volvol,
                                                           nb_path=nb_path,
+                                                          nb_steps=nb_steps,
                                                           is_spot_measure=is_spot_measure)
         ttm0 = ttm
         option_prices, option_std = compute_mc_vars_payoff(x0=x0, sigma0=sigma0, qvar0=qvar0,
@@ -714,7 +724,9 @@ def simulate_logsv_x_vol_terminal(ttm: float,
                                   nb_path: int = 100000,
                                   nb_steps: int = 360
                                   ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
-
+    """
+    mc simulator for terminal values of log-return, vol sigma0, and qvar for log sv model
+    """
     if x0.shape[0] == 1:  # initial value
         x0 = x0*np.zeros(nb_path)
     else:
@@ -744,9 +756,10 @@ def simulate_logsv_x_vol_terminal(ttm: float,
     for t_, (w0, w1) in enumerate(zip(W0, W1)):
         sigma0_2dt = sigma0 * sigma0 * dt
         x0 = x0 + alpha * 0.5 * sigma0_2dt + sigma0 * w0
-        qvar0 = qvar0 + sigma0_2dt
         vol_var = vol_var + ((kappa1 * theta / sigma0 - kappa1) + kappa2*(theta-sigma0) + adj*sigma0 - 0.5*vartheta2) * dt + beta*w0+volvol*w1
         sigma0 = np.exp(vol_var)
+        qvar0 = qvar0 + 0.5*(sigma0_2dt+sigma0 * sigma0 * dt)
+
 
     return x0, sigma0, qvar0
 

{stochvolmodels-1.0.9 → stochvolmodels-1.0.11}/stochvolmodels/pricers/model_pricer.py

@@ -9,6 +9,7 @@ market options data is passed using data container ChainData
 
 from __future__ import annotations
 
+import string
 import pandas as pd
 import numpy as np
 import matplotlib.pyplot as plt
@@ -18,6 +19,7 @@ from abc import ABC, abstractmethod
 from scipy import stats
 from dataclasses import dataclass, asdict
 from typing import Tuple, Optional, Dict
+import qis as qis
 
 from stochvolmodels.pricers.core.config import VariableType
 from stochvolmodels.data.option_chain import OptionChain, OptionSlice
@@ -58,12 +60,13 @@ class ModelPricer(ABC):
     def compute_chain_prices_with_vols(self,
                                        option_chain: OptionChain,
                                        params: ModelParams,
+                                       variable_type: VariableType = VariableType.LOG_RETURN,
                                        **kwargs
                                        ) -> Tuple[List[np.ndarray], List[np.ndarray]]:
         """
         price chain and compute model vols
         """
-        model_prices = self.price_chain(option_chain=option_chain, params=params, **kwargs)
+        model_prices = self.price_chain(option_chain=option_chain, params=params, variable_type=variable_type, **kwargs)
         model_ivols = option_chain.compute_model_ivols_from_chain_data(model_prices=model_prices)
         return model_prices, model_ivols
 
@@ -80,7 +83,10 @@ class ModelPricer(ABC):
                                                                         **kwargs)
         return model_ivols
 
-    def model_mc_price_chain(self, option_chain: OptionChain, params: ModelParams, **kwargs
+    def model_mc_price_chain(self,
+                             option_chain: OptionChain, params: ModelParams,
+                             variable_type: VariableType = VariableType.LOG_RETURN,
+                             **kwargs
                              ) -> Tuple[List[np.ndarray], List[np.ndarray]]:
         """
         abstract method for pricing chain data using simulation of model dynamics
@@ -161,6 +167,7 @@ class ModelPricer(ABC):
     def compute_mc_chain_implied_vols(self,
                                       option_chain: OptionChain,
                                       params: ModelParams,
+                                      variable_type: VariableType = VariableType.LOG_RETURN,
                                       nb_path: int = 100000,
                                       **kwargs
                                       ) -> Tuple[List[np.ndarray], ...]:
@@ -169,6 +176,7 @@ class ModelPricer(ABC):
         """
         model_prices_ttms, option_std_ttms = self.model_mc_price_chain(option_chain=option_chain,
                                                                        params=params,
+                                                                       variable_type=variable_type,
                                                                        nb_path=nb_path,
                                                                        **kwargs)
         std_factor = 1.96
@@ -307,6 +315,7 @@ class ModelPricer(ABC):
                                     is_log_strike_xaxis: bool = False,
                                     headers: Optional[List[str]] = None,
                                     xvar_format: str = None,
+                                    figsize: Tuple[float, float] = plot.FIGSIZE,
                                     **kwargs
                                     ) -> plt.Figure:
         """
@@ -316,19 +325,19 @@ class ModelPricer(ABC):
         model_ivols = self.compute_model_ivols_for_chain(option_chain=option_chain, params=params, **kwargs)
 
         num_slices = len(option_chain.ttms)
-        if num_slices == 1:
-            with sns.axes_style('darkgrid'):
-                fig, ax = plt.subplots(1, 1, figsize=plot.FIGSIZE, tight_layout=True)
-            axs = np.array([[ax, np.nan], [np.nan, np.nan]])
-        elif num_slices == 2:
-            with sns.axes_style('darkgrid'):
-                fig, axs = plt.subplots(2, 1, figsize=plot.FIGSIZE, tight_layout=True)
-            axs = np.array([[axs[0], np.nan], [axs[1], np.nan]])
-        elif num_slices in [3, 4]:
-            with sns.axes_style('darkgrid'):
-                fig, axs = plt.subplots(2, 2, figsize=plot.FIGSIZE, tight_layout=True)
-        else:
-            raise NotImplementedError
+        with sns.axes_style('darkgrid'):
+            if num_slices == 1:
+                fig, ax = plt.subplots(1, 1, figsize=figsize, tight_layout=True)
+                axs = [ax]
+            elif num_slices == 2:
+                fig, axs = plt.subplots(1, 2, figsize=figsize, tight_layout=True)
+            elif num_slices == 3:
+                fig, axs = plt.subplots(1, 3, figsize=figsize, tight_layout=True)
+            elif num_slices == 4:
+                fig, axs = plt.subplots(2, 2, figsize=figsize, tight_layout=True)
+                axs = qis.to_flat_list(axs)
+            else:
+                raise NotImplementedError
 
         atm_vols = option_chain.get_chain_atm_vols()
         for idx, ttm in enumerate(option_chain.ttms):
@@ -367,7 +376,7 @@ class ModelPricer(ABC):
                                strike_name=strike_name,
                                xvar_format=xvar_format,
                                x_rotation=0,
-                               ax=axs[idx % 2][idx // 2],
+                               ax=axs[idx],
                                **kwargs)
         return fig
 
@@ -377,8 +386,9 @@ class ModelPricer(ABC):
                                is_log_strike_xaxis: bool = False,
                                variable_type: VariableType = VariableType.LOG_RETURN,
                                nb_path: int = 100000,
+                               figsize: Tuple[float, float] = plot.FIGSIZE,
                                **kwargs
-                               ) -> None:
+                               ) -> plt.Figure:
         """
         comparision of model implied vols computed old_analytics vs mc pricer
         optimized for 2*2 figure
@@ -391,11 +401,20 @@ class ModelPricer(ABC):
             nb_path=nb_path,
             **kwargs)
 
+        num_slices = len(option_chain.ttms)
         with sns.axes_style('darkgrid'):
-            if len(option_chain.ttms) > 1:
-                fig, axs = plt.subplots(2, len(option_chain.ttms) // 2, figsize=plot.FIGSIZE, tight_layout=True)
+            if num_slices == 1:
+                fig, ax = plt.subplots(1, 1, figsize=figsize, tight_layout=True)
+                axs = [ax]
+            elif num_slices == 2:
+                fig, axs = plt.subplots(1, 2, figsize=figsize, tight_layout=True)
+            elif num_slices == 3:
+                fig, axs = plt.subplots(1, 3, figsize=figsize, tight_layout=True)
+            elif num_slices == 4:
+                fig, axs = plt.subplots(2, 2, figsize=figsize, tight_layout=True)
+                axs = qis.to_flat_list(axs)
             else:
-                fig, axs = plt.subplots(1, 1, figsize=plot.FIGSIZE, tight_layout=True)
+                raise NotImplementedError
 
         for idx, ttm in enumerate(option_chain.ttms):
             if is_log_strike_xaxis:
@@ -419,10 +438,6 @@ class ModelPricer(ABC):
             else:
                 title = f"{ttm=:0.2f}"
 
-            if len(option_chain.ttms) > 1:
-                ax = axs[idx % 2][idx // 2]
-            else:
-                ax = axs
             plot.vol_slice_fit(bid_vol=pd.Series(mc_ivols_down[idx], index=strikes),
                                ask_vol=pd.Series(mc_ivols_up[idx], index=strikes),
                                model_vols=model_vol_t,
@@ -432,18 +447,19 @@ class ModelPricer(ABC):
                                strike_name=strike_name,
                                xvar_format=xvar_format,
                                x_rotation=0,
-                               ax=ax,
+                               ax=axs[idx],
                                **kwargs)
+        return fig
 
     def plot_comp_mma_inverse_options_with_mc(self,
                                               option_chain: OptionChain,
                                               params: ModelParams,
                                               variable_type: VariableType = VariableType.LOG_RETURN,
                                               nb_path: int = 100000,
-                                              headers: Optional[List[str]] = ('(A)', '(B)', '(C)', '(D)'),  # optimized for 2*2 figure
                                               is_log_strike_xaxis: bool = False,
                                               is_plot_vols: bool = True,
                                               figsize: Tuple[float, float] = plot.FIGSIZE,
+                                              xvar_format: str = '{:0,.2f}',
                                               **kwargs
                                               ) -> plt.Figure:
         """
@@ -458,18 +474,19 @@ class ModelPricer(ABC):
                                                                                 variable_type=variable_type,
                                                                                 **kwargs)
 
-        model_prices_inv, model_ivols_inv= self.compute_chain_prices_with_vols(option_chain=option_chain, params=params,
-                                                                               is_spot_measure=False,
-                                                                               variable_type=variable_type,
-                                                                               **kwargs)
+        model_prices_inv, model_ivols_inv = self.compute_chain_prices_with_vols(option_chain=option_chain, params=params,
+                                                                                is_spot_measure=False,
+                                                                                variable_type=variable_type,
+                                                                                **kwargs)
 
         # we perform MC simulation in MMA measure
-        mc_kwargs = update_kwargs(kwargs, dict(is_spot_measure=True, variable_type=variable_type))
         model_prices_ttms, model_prices_ttms_ups, model_prices_ttms_downs, \
         mc_ivols, mc_ivols_up, mc_ivols_down, mc_stdev_ttms = self.compute_mc_chain_implied_vols(option_chain=option_chain,
                                                                                                  params=params,
                                                                                                  nb_path=nb_path,
-                                                                                                 **mc_kwargs)
+                                                                                                 variable_type=variable_type,
+                                                                                                 is_spot_measure=True,
+                                                                                                 **kwargs)
 
         if is_plot_vols:
             model_datas = {mma_label: model_ivols_mma, inverse_lable: model_ivols_inv}
@@ -480,27 +497,34 @@ class ModelPricer(ABC):
             mc_data = model_prices_ttms
             mc_data_lower, mc_data_upper = model_prices_ttms_downs, model_prices_ttms_ups
 
-        if option_chain.ttms.size < 4:
-            nrows, ncols = 1, option_chain.ttms.size
-        else:
-            nrows, ncols = 2, option_chain.ttms.size//2
-
+        num_slices = len(option_chain.ttms)
         with sns.axes_style('darkgrid'):
-            fig, axs = plt.subplots(nrows, ncols, figsize=figsize, tight_layout=True)
+            if num_slices == 1:
+                fig, ax = plt.subplots(1, 1, figsize=figsize, tight_layout=True)
+                axs = [ax]
+            elif num_slices == 2:
+                fig, axs = plt.subplots(1, 2, figsize=figsize, tight_layout=True)
+            elif num_slices == 3:
+                fig, axs = plt.subplots(1, 3, figsize=figsize, tight_layout=True)
+            elif num_slices == 4:
+                fig, axs = plt.subplots(2, 2, figsize=figsize, tight_layout=True)
+                axs = qis.to_flat_list(axs)
+            else:
+                raise NotImplementedError
 
         for idx, ttm in enumerate(option_chain.ttms):
             if is_log_strike_xaxis:
                 strikes = np.log(option_chain.strikes_ttms[idx] / option_chain.forwards[idx])
-                xvar_format = '{:0.2f}'
                 strike_name = 'log-strike'
             else:
                 strikes = option_chain.strikes_ttms[idx]
                 if variable_type == VariableType.LOG_RETURN:
-                    xvar_format = '{:0,.2f}'
                     strike_name = 'strike'
+                elif variable_type == VariableType.Q_VAR:
+                    strikes = option_chain.strikes_ttms[idx] / option_chain.forwards[idx]
+                    strike_name = 'QVAR strike %'
                 else:
-                    xvar_format = '{:0.2f}'
-                    strike_name = 'QVAR strike'
+                    raise NotImplementedError
 
             model_vols = {}
             for key, model_data in model_datas.items():
@@ -509,10 +533,8 @@ class ModelPricer(ABC):
             model_vols = pd.DataFrame.from_dict(model_vols, orient='columns')
 
             if option_chain.ids is not None:
-                if headers is not None:
-                    title = f"{headers[idx]} slice - {option_chain.ids[idx]}"
-                else:
-                    title = f"slice - {option_chain.ids[idx]}"
+                title = f"{string.ascii_uppercase[idx]}) slice - {option_chain.ids[idx]}"
+
             else:
                 title = f"{ttm=:0.2f}"
 
@@ -520,6 +542,8 @@ class ModelPricer(ABC):
                                 fp=0.5 * (mc_data_lower[idx] + mc_data_upper[idx]))
             if is_log_strike_xaxis:
                 atm_points = {'ATM': (0.0, atm_vol)}
+            elif variable_type == VariableType.Q_VAR:
+                atm_points = {'ATM': (1.0, atm_vol)}
             else:
                 atm_points = {'ATM': (option_chain.forwards[idx], atm_vol)}
 
@@ -535,6 +559,6 @@ class ModelPricer(ABC):
                                atm_points=atm_points,
                                ylabel='Implied vols' if is_plot_vols else 'Model prices',
                                yvar_format='{:.0%}' if is_plot_vols else '{:.2f}',
-                               ax=axs[idx] if axs.ndim == 1 else axs[idx % 2][idx // 2],
+                               ax=axs[idx],
                                **kwargs)
         return fig

{stochvolmodels-1.0.9 → stochvolmodels-1.0.11}/stochvolmodels/utils/plots.py

@@ -133,7 +133,7 @@ def vol_slice_fit(bid_vol: pd.Series,
                   x_rotation: int = 0,
                   ax: plt.Subplot = None,
                   **kwargs
-                  ) -> plt.Figure:
+                  ) -> Optional[plt.Figure]:
 
     if ax is None:
         fig, ax = plt.subplots(1, 1, figsize=(8, 8))