stochvolmodels 1.0.28__tar.gz → 1.0.30__tar.gz

{stochvolmodels-1.0.28 → stochvolmodels-1.0.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: stochvolmodels
-Version: 1.0.28
+Version: 1.0.30
 Summary: Implementation of stochastic volatility models for option pricing
 License: LICENSE.txt
 Keywords: volatility,options,Black-Scholes,Heston,Monte-Carlo

{stochvolmodels-1.0.28 → stochvolmodels-1.0.30}/pyproject.toml

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

{stochvolmodels-1.0.28 → stochvolmodels-1.0.30}/stochvolmodels/__init__.py

@@ -109,7 +109,9 @@ from stochvolmodels.pricers.logsv_pricer import (
     ConstraintsType,
     CalibrationEngine,
     get_randoms_for_chain_valuation,
-    logsv_mc_chain_pricer_fixed_randoms
+    get_randoms_for_rough_vol_chain_valuation,
+    logsv_mc_chain_pricer_fixed_randoms,
+    rough_logsv_mc_chain_pricer_fixed_randoms
 )
 from stochvolmodels.pricers.logsv.logsv_params import LogSvParams
 
@@ -159,5 +161,3 @@ from stochvolmodels.utils.plots import (
 
 
 from stochvolmodels.pricers.logsv.vol_moments_ode import compute_analytic_qvar
-
-from stochvolmodels.data.option_chain import generate_vol_chain_np

{stochvolmodels-1.0.28 → stochvolmodels-1.0.30}/stochvolmodels/data/fetch_option_chain.py

@@ -105,7 +105,7 @@ def sample_option_chain_at_times(options_data_dfs: OptionsDataDFs,
 
 def load_price_data(options_data_dfs: OptionsDataDFs,
                     time_period: TimePeriod = None,
-                    data: Literal['spot', 'perp', 'funding_rate'] = 'spot',
+                    data: Literal['close', 'perp', 'funding_rate'] = 'close',
                     freq: Optional[str] = 'D'  # to do
                     ) -> pd.Series:
     #options_data_dfs = OptionsDataDFs(**ts_data_loader_wrapper(ticker=ticker, freq='D', hour_offset=8))

{stochvolmodels-1.0.28 → stochvolmodels-1.0.30}/stochvolmodels/examples/run_lognormal_sv_pricer.py

@@ -5,7 +5,6 @@ run few unit test to illustrate implementation of log-normal sv model analytics
 import numpy as np
 import matplotlib.pyplot as plt
 from enum import Enum
-
 import stochvolmodels as sv
 from stochvolmodels import LogSVPricer, LogSvParams, OptionChain, LogsvModelCalibrationType
 
@@ -19,6 +18,8 @@ class UnitTests(Enum):
     CALIBRATE_MODEL_TO_BTC_OPTIONS = 6
     MC_WITH_FIXED_RANDOMS = 7
     CALIBRATE_MODEL_TO_BTC_OPTIONS_WITH_MC = 8
+    ROUGH_MC_WITH_FIXED_RANDOMS = 9
+    BENCHM_ROUGH_PRICER = 10
 
 
 def run_unit_test(unit_test: UnitTests):
@@ -124,9 +125,115 @@ def run_unit_test(unit_test: UnitTests):
         option_prices_ttm, option_std_ttm = sv.logsv_mc_chain_pricer_fixed_randoms(**args)
         print(option_prices_ttm)
 
-        option_prices_ttm, option_std_ttm = sv.logsv_mc_chain_pricer_fixed_randoms(**args)
+
+    elif unit_test == UnitTests.ROUGH_MC_WITH_FIXED_RANDOMS:
+        btc_option_chain = sv.get_btc_test_chain_data()
+        Z0, Z1, grid_ttms = sv.get_randoms_for_rough_vol_chain_valuation(ttms=btc_option_chain.ttms,
+                                                                             nb_path=10000,
+                                                                             nb_steps_per_year=360,
+                                                                             seed=10)
+        params0 = LogSvParams(sigma0=0.8, theta=1.0, kappa1=2.21, kappa2=0.0, beta=0.15, volvol=2.0)
+        params0.H = 0.3
+        params0.approximate_kernel(T=btc_option_chain.ttms[-1], N=3)
+
+        option_prices_ttm, option_std_ttm = sv.rough_logsv_mc_chain_pricer_fixed_randoms(ttms=btc_option_chain.ttms,
+                                                                                         forwards=btc_option_chain.forwards,
+                                                                                         discfactors=btc_option_chain.discfactors,
+                                                                                         strikes_ttms=btc_option_chain.strikes_ttms,
+                                                                                         optiontypes_ttms=btc_option_chain.optiontypes_ttms,
+                                                                                         Z0=Z0,
+                                                                                         Z1=Z1,
+                                                                                         sigma0=params0.sigma0,
+                                                                                         theta=params0.theta,
+                                                                                         kappa1=params0.kappa1,
+                                                                                         kappa2=params0.kappa2,
+                                                                                         beta=params0.beta,
+                                                                                         orthog_vol=params0.volvol,
+                                                                                         weights=params0.weights,
+                                                                                         nodes=params0.nodes,
+                                                                                         timegrids=grid_ttms)
         print(option_prices_ttm)
 
+    elif unit_test == UnitTests.BENCHM_ROUGH_PRICER:
+        btc_option_chain = OptionChain.get_uniform_chain(ttms=np.array([0.083, 0.25]),
+                                                     ids=np.array(['1m', '3m']),
+                                                     strikes=np.linspace(0.5, 1.5, 21))
+        params0 = LogSvParams(sigma0=0.8, theta=1.0, kappa1=2.21, kappa2=0.0, beta=0.15, volvol=2.0)
+        nb_path = 100000
+        H = 0.3
+        N = 3
+
+        def rough_vol():
+            params1 = LogSvParams.copy(params0)
+            params1.H = 0.3
+            params1.approximate_kernel(T=btc_option_chain.ttms[-1], N=N)
+
+            Z0, Z1, grid_ttms = sv.get_randoms_for_rough_vol_chain_valuation(ttms=btc_option_chain.ttms,
+                                                                             nb_path=nb_path,
+                                                                             nb_steps_per_year=360,
+                                                                             seed=10)
+
+
+            option_prices_ttm, option_std_ttm = sv.rough_logsv_mc_chain_pricer_fixed_randoms(ttms=btc_option_chain.ttms,
+                                                                                             forwards=btc_option_chain.forwards,
+                                                                                             discfactors=btc_option_chain.discfactors,
+                                                                                             strikes_ttms=btc_option_chain.strikes_ttms,
+                                                                                             optiontypes_ttms=btc_option_chain.optiontypes_ttms,
+                                                                                             Z0=Z0,
+                                                                                             Z1=Z1,
+                                                                                             sigma0=params0.sigma0,
+                                                                                             theta=params0.theta,
+                                                                                             kappa1=params0.kappa1,
+                                                                                             kappa2=params0.kappa2,
+                                                                                             beta=params0.beta,
+                                                                                             orthog_vol=params0.volvol,
+                                                                                             weights=params1.weights,
+                                                                                             nodes=params1.nodes,
+                                                                                             timegrids=grid_ttms)
+            model_ivols_ttms = btc_option_chain.compute_model_ivols_from_chain_data(option_prices_ttm)
+            return model_ivols_ttms
+
+        def regular_vol():
+            W0s, W1s, dts = sv.get_randoms_for_chain_valuation(ttms=btc_option_chain.ttms,
+                                                               nb_path=nb_path,
+                                                               nb_steps_per_year=360,
+                                                               seed=10)
+            vol_backbone_etas = params.get_vol_backbone_etas(ttms=btc_option_chain.ttms)
+            args = dict(ttms=btc_option_chain.ttms,
+                        forwards=btc_option_chain.forwards,
+                        discfactors=btc_option_chain.discfactors,
+                        strikes_ttms=btc_option_chain.strikes_ttms,
+                        optiontypes_ttms=btc_option_chain.optiontypes_ttms,
+                        W0s=W0s,
+                        W1s=W1s,
+                        dts=dts,
+                        v0=params0.sigma0,
+                        theta=params0.theta,
+                        kappa1=params0.kappa1,
+                        kappa2=params0.kappa2,
+                        beta=params0.beta,
+                        volvol=params0.volvol,
+                        vol_backbone_etas=vol_backbone_etas)
+            option_prices_ttm, option_std_ttm = sv.logsv_mc_chain_pricer_fixed_randoms(**args)
+            model_ivols_ttms = btc_option_chain.compute_model_ivols_from_chain_data(option_prices_ttm)
+
+            return model_ivols_ttms
+
+        ivols_rough_logsv = rough_vol()
+        ivols_logsv = regular_vol()
+
+        nb_slices = btc_option_chain.ttms.size
+        fig, axs = plt.subplots(1, nb_slices, figsize=(4*nb_slices, 3), tight_layout=True)
+
+        for i in range(nb_slices):
+            ax = axs[i] if nb_slices>1 else axs
+            ax.plot(btc_option_chain.strikes_ttms[i], ivols_logsv[i], label="LOG_SV", marker="*")
+            ax.plot(btc_option_chain.strikes_ttms[i], ivols_rough_logsv[i], label="ROUGH_LOG_SV", marker="o")
+            ax.set_title("Expiry: " + btc_option_chain.ids[i])
+            ax.legend()
+        fig.suptitle(f"Conventional LogSV model vs Rough LogSV, H={H:.2f} via {N}f Markovian approximation",
+                     color="darkblue")
+
     elif unit_test == UnitTests.CALIBRATE_MODEL_TO_BTC_OPTIONS:
         btc_option_chain = sv.get_btc_test_chain_data()
         params0 = LogSvParams(sigma0=0.8, theta=1.0, kappa1=2.21, kappa2=2.18, beta=0.15, volvol=2.0)
@@ -140,12 +247,14 @@ def run_unit_test(unit_test: UnitTests):
 
     elif unit_test == UnitTests.CALIBRATE_MODEL_TO_BTC_OPTIONS_WITH_MC:
         btc_option_chain = sv.get_btc_test_chain_data()
-        params0 = LogSvParams(sigma0=0.8, theta=1.0, kappa1=2.21, kappa2=2.18, beta=0.15, volvol=2.0)
+        params0 = LogSvParams(sigma0=0.8, theta=1.0, kappa1=2.21, kappa2=0.0, beta=0.15, volvol=2.0)
+        params0.H = 0.3
+        params0.approximate_kernel(T=btc_option_chain.ttms[-1], N=3)
         btc_calibrated_params = logsv_pricer.calibrate_model_params_to_chain(option_chain=btc_option_chain,
                                                                              params0=params0,
                                                                              model_calibration_type=LogsvModelCalibrationType.PARAMS4,
                                                                              constraints_type=sv.ConstraintsType.INVERSE_MARTINGALE,
-                                                                             calibration_engine=sv.CalibrationEngine.MC,
+                                                                             calibration_engine=sv.CalibrationEngine.ROUGH_MC,
                                                                              nb_path=100000,
                                                                              seed=7)
         print(btc_calibrated_params)
@@ -157,7 +266,7 @@ def run_unit_test(unit_test: UnitTests):
 
 if __name__ == '__main__':
 
-    unit_test = UnitTests.CALIBRATE_MODEL_TO_BTC_OPTIONS
+    unit_test = UnitTests.BENCHM_ROUGH_PRICER
 
     is_run_all_tests = False
     if is_run_all_tests:

{stochvolmodels-1.0.28 → stochvolmodels-1.0.30}/stochvolmodels/pricers/logsv/logsv_params.py

@@ -9,6 +9,7 @@ from typing import Optional, Dict, Any
 
 from stochvolmodels import VariableType, find_nearest
 from stochvolmodels.pricers.model_pricer import ModelParams
+from stochvolmodels.pricers.rough_logsv.RoughKernel import european_rule
 
 
 @dataclass
@@ -23,10 +24,23 @@ class LogSvParams(ModelParams):
     beta: float = -1.0
     volvol: float = 1.0
     vol_backbone: pd.Series = None
+    H: float = 0.5
+    weights: np.ndarray = None
+    nodes: np.ndarray = None
 
     def __post_init__(self):
         if self.kappa2 is None:
             self.kappa2 = self.kappa1 / self.theta
+        assert 1e-4 < self.H <= 0.5
+
+    def approximate_kernel(self, T: float, N: int):
+        assert 1 <= N <= 5  # not keen to use large N
+        if N > 1 and self.H<0.49:
+            self.nodes, self.weights = european_rule(self.H, N, T)
+        else:
+            self.weights = np.array([1.0])
+            self.nodes = np.array([1e-3])
+
 
     def to_dict(self) -> Dict[str, Any]:
         return asdict(self)

{stochvolmodels-1.0.28 → stochvolmodels-1.0.30}/stochvolmodels/pricers/logsv_pricer.py

@@ -23,6 +23,7 @@ import stochvolmodels.pricers.logsv.affine_expansion as afe
 from stochvolmodels.pricers.model_pricer import ModelPricer
 from stochvolmodels.pricers.logsv.affine_expansion import ExpansionOrder
 from stochvolmodels.pricers.logsv.vol_moments_ode import fit_model_vol_backbone_to_varswaps
+from stochvolmodels.pricers.rough_logsv.split_simulation import log_spot_full_combined
 
 # data
 from stochvolmodels.data.option_chain import OptionChain
@@ -47,6 +48,7 @@ class ConstraintsType(Enum):
 class CalibrationEngine(Enum):
     ANALYTIC = 1
     MC = 2
+    ROUGH_MC = 3
 
 
 LOGSV_BTC_PARAMS = LogSvParams(sigma0=0.8376, theta=1.0413, kappa1=3.1844, kappa2=3.058, beta=0.1514, volvol=1.8458)
@@ -154,21 +156,30 @@ class LogSVPricer(ModelPricer):
                                          kappa1=params0.kappa1,
                                          kappa2=params0.kappa2,
                                          beta=pars[2],
-                                         volvol=pars[3])
+                                         volvol=pars[3],
+                                         H=params0.H,
+                                         nodes=params0.nodes,
+                                         weights=params0.weights)
             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])
+                                         volvol=pars[4],
+                                         H=params0.H,
+                                         nodes=params0.nodes,
+                                         weights=params0.weights)
             elif model_calibration_type == LogsvModelCalibrationType.PARAMS_WITH_VARSWAP_FIT:
                 fit_params = LogSvParams(sigma0=params0.sigma0,
                                          theta=params0.theta,
                                          kappa1=params0.kappa1,
                                          kappa2=params0.kappa2,
                                          beta=pars[0],
-                                         volvol=pars[1])
+                                         volvol=pars[1],
+                                         H=params0.H,
+                                         nodes=params0.nodes,
+                                         weights=params0.weights)
                 # set model backbone
                 vol_backbone = fit_model_vol_backbone_to_varswaps(log_sv_params=fit_params,
                                                                   varswap_strikes=varswap_strikes)
@@ -180,7 +191,9 @@ class LogSVPricer(ModelPricer):
 
         if calibration_engine == CalibrationEngine.MC:
             W0s, W1s, dts = get_randoms_for_chain_valuation(ttms=option_chain.ttms, nb_path=nb_path, nb_steps_per_year=nb_steps, seed=seed)
-
+        if calibration_engine == CalibrationEngine.ROUGH_MC:
+            Z0, Z1, grid_ttms = get_randoms_for_rough_vol_chain_valuation(ttms=option_chain.ttms, nb_path=nb_path,
+                                                                          nb_steps_per_year=nb_steps, seed=seed)
         def objective(pars: np.ndarray, args: np.ndarray) -> float:
             params = parse_model_params(pars=pars)
 
@@ -207,6 +220,25 @@ class LogSVPricer(ModelPricer):
                 # print(f"option_prices_ttm\n{option_prices_ttm}")
                 # print(f"model_vols\n{model_vols}")
 
+            elif calibration_engine == CalibrationEngine.ROUGH_MC:
+                option_prices_ttm, option_std_ttm = rough_logsv_mc_chain_pricer_fixed_randoms(ttms=option_chain.ttms,
+                                                                                              forwards=option_chain.forwards,
+                                                                                              discfactors=option_chain.discfactors,
+                                                                                              strikes_ttms=option_chain.strikes_ttms,
+                                                                                              optiontypes_ttms=option_chain.optiontypes_ttms,
+                                                                                              Z0=Z0,
+                                                                                              Z1=Z1,
+                                                                                              sigma0=params.sigma0,
+                                                                                              theta=params.theta,
+                                                                                              kappa1=params.kappa1,
+                                                                                              kappa2=params.kappa2,
+                                                                                              beta=params.beta,
+                                                                                              orthog_vol=params.volvol,
+                                                                                              weights=params.weights,
+                                                                                              nodes=params.nodes,
+                                                                                              timegrids=grid_ttms)
+                model_vols = option_chain.compute_model_ivols_from_chain_data(model_prices=option_prices_ttm)
+
             else:
                 raise NotImplementedError(f"{calibration_engine}")
 
@@ -698,13 +730,14 @@ def simulate_logsv_x_vol_terminal(ttm: float,
     return x0, sigma0, qvar0
 
 
+
 def get_randoms_for_chain_valuation(ttms: np.ndarray,
                                     nb_path: int = 100000,
                                     nb_steps_per_year: int = 360,
                                     seed: int = 10
                                     ) -> Tuple[List[np.ndarray], List[np.ndarray], List[np.ndarray]]:
     """
-    we need to fix random normals for suesequent evaluation using mc slices
+    we need to fix random normals for subsequent evaluation using mc slices
     outputs as numpy lists
     """
     #
@@ -722,6 +755,23 @@ def get_randoms_for_chain_valuation(ttms: np.ndarray,
         ttm0 = ttm
     return W0s, W1s, dts
 
+def get_randoms_for_rough_vol_chain_valuation(ttms: np.ndarray,
+                                    nb_path: int = 100000,
+                                    nb_steps_per_year: int = 360,
+                                    seed: int = 10
+                                    ) -> Tuple[np.ndarray, np.ndarray, List[np.ndarray]]:
+    set_seed(seed)
+    grid_ttms = List()
+    nb_steps_ttms = np.zeros_like(ttms).astype(int)
+    for i, ttm in enumerate(ttms):
+        nb_steps, dt, grid_t = set_time_grid(ttm, nb_steps_per_year)
+        nb_steps_ttms[i] = nb_steps
+        grid_ttms.append(grid_t)
+    Z0 = np.random.normal(0, 1, size=(nb_steps_ttms[-1], nb_path))
+    Z1 = np.random.normal(0, 1, size=(nb_steps_ttms[-1], nb_path))
+
+    return Z0, Z1, grid_ttms
+
 
 @njit(cache=False, fastmath=True)
 def logsv_mc_chain_pricer_fixed_randoms(ttms: np.ndarray,
@@ -787,6 +837,68 @@ def logsv_mc_chain_pricer_fixed_randoms(ttms: np.ndarray,
 
     return option_prices_ttm, option_std_ttm
 
+def rough_logsv_mc_chain_pricer_fixed_randoms(ttms: np.ndarray,
+                                              forwards: np.ndarray,
+                                              discfactors: np.ndarray,
+                                              strikes_ttms: Tuple[np.ndarray, ...],
+                                              optiontypes_ttms: Tuple[np.ndarray, ...],
+                                              Z0: np.ndarray,
+                                              Z1: np.ndarray,
+                                              sigma0: float,
+                                              theta: float,
+                                              kappa1: float,
+                                              kappa2: float,
+                                              beta: float,
+                                              orthog_vol: float,
+                                              weights: np.ndarray,
+                                              nodes: np.ndarray,
+                                              timegrids: List[np.ndarray],
+                                              variable_type: VariableType = VariableType.LOG_RETURN
+                                              ) -> Tuple[List[np.ndarray], List[np.ndarray]]:
+    assert weights.shape == nodes.shape and weights.ndim == 1
+    assert kappa2 == 0.0
+    N = nodes.size
+    v0 = sigma0 / np.sum(weights) * np.ones((N,))
+
+    # need to redenote coefficients
+    lamda = kappa1
+    theta = kappa1 * theta
+    volvol = np.sqrt(beta ** 2 + orthog_vol ** 2)
+    rho = beta / volvol
+
+    nb_path = Z0.shape[1]
+    v0_vec = np.repeat(v0[:, None], nb_path, axis=1)
+    v_init = v0_vec.copy()
+    log_s0 = 0.0
+
+    # outputs as numpy lists
+    option_prices_ttm = List()
+    option_std_ttm = List()
+    for ttm, forward, discfactor, strikes_ttm, optiontypes_ttm, timegrid in zip(ttms, forwards,
+                                                                                discfactors,
+                                                                                strikes_ttms,
+                                                                                optiontypes_ttms,
+                                                                                timegrids):
+        nb_steps = timegrid.size - 1
+        Z0_ = Z0[:nb_steps]
+        Z1_ = Z1[:nb_steps]
+        log_spot_str, vol_str, qv_str = log_spot_full_combined(nodes, weights, v0_vec, theta, lamda, log_s0, v_init,
+                                                               rho, volvol, timegrid, nb_path, Z0_, Z1_)
+        print(f"Number of paths with negative vol: {np.sum(weights @ vol_str < 0.0)}")
+        print(f"Mean spot Strand: {np.mean(np.exp(log_spot_str))}")
+
+        option_prices, option_std = compute_mc_vars_payoff(x0=log_spot_str, sigma0=vol_str, qvar0=qv_str,
+                                                           ttm=ttm,
+                                                           forward=forward,
+                                                           strikes_ttm=strikes_ttm,
+                                                           optiontypes_ttm=optiontypes_ttm,
+                                                           discfactor=discfactor,
+                                                           variable_type=variable_type)
+        option_prices_ttm.append(option_prices)
+        option_std_ttm.append(option_std)
+
+    return option_prices_ttm, option_std_ttm
+
 
 class UnitTests(Enum):
     CHAIN_PRICER = 1
@@ -865,7 +977,7 @@ def run_unit_test(unit_test: UnitTests):
         fig = logsv_pricer.plot_model_ivols_vs_mc(option_chain=option_chain,
                                                   params=LOGSV_BTC_PARAMS,
                                                   variable_type=VariableType.Q_VAR)
-    
+
     elif unit_test == UnitTests.VOL_PATHS:
         logsv_pricer = LogSVPricer()
         nb_path = 10