stochvolmodels 1.0.7__tar.gz → 1.0.8__tar.gz

{stochvolmodels-1.0.7 → stochvolmodels-1.0.8}/PKG-INFO

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

{stochvolmodels-1.0.7 → stochvolmodels-1.0.8}/pyproject.toml

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

{stochvolmodels-1.0.7 → stochvolmodels-1.0.8}/stochvolmodels/__init__.py

@@ -56,7 +56,7 @@ from stochvolmodels.pricers.logsv_pricer import (
     LOGSV_BTC_PARAMS,
     LogSVPricer,
     LogSvParams,
-    ModelCalibrationType,
+    LogsvModelCalibrationType,
     ConstraintsType
 )
 

{stochvolmodels-1.0.7 → stochvolmodels-1.0.8}/stochvolmodels/data/option_chain.py

@@ -272,4 +272,4 @@ class OptionChain:
                    strikes_ttms=List([strikes for _ in ttms]),
                    bid_ivs=List([flat_vol*np.ones_like(strikes) for _ in ttms]),
                    ask_ivs=List([flat_vol*np.ones_like(strikes) for _ in ttms]),
-                   optiontypes_ttms=List([np.where(strikes >= forward, 'C', 'P') for forward in forwards]))
+                   optiontypes_ttms=List([np.where(strikes >= forward, 'C', 'P') for forward in forwards]))

{stochvolmodels-1.0.7 → stochvolmodels-1.0.8}/stochvolmodels/pricers/logsv_pricer.py

@@ -29,9 +29,10 @@ from stochvolmodels.data.option_chain import OptionChain
 from stochvolmodels.data.test_option_chain import get_btc_test_chain_data
 
 
-class ModelCalibrationType(Enum):
-    PARAMS5 = 1  # v0, theta, kappa1, beta, volvol
-    PARAMS6 = 2  # v0, theta, kappa1, kappa2, beta, volvol
+class LogsvModelCalibrationType(Enum):
+    PARAMS4 = 1  # v0, theta, beta, volvol; kappa1, kappa2 are set externally
+    PARAMS5 = 2  # v0, theta, kappa1, beta, volvol
+    PARAMS6 = 3  # v0, theta, kappa1, kappa2, beta, volvol
 
 
 class ConstraintsType(Enum):
@@ -59,8 +60,8 @@ class LogSvParams(ModelParams):
             self.kappa2 = self.kappa1 / self.theta
 
     def to_dict(self) -> Dict[str, Any]:
-        #         return dict(sigma0=self.sigma0, theta=self.theta, kappa1=self.kappa1, kappa2=self.kappa2, beta=self.beta, volvol=self.volvol)
         return asdict(self)
+
     @property
     def kappa(self) -> float:
         return self.kappa1+self.kappa2*self.theta
@@ -220,10 +221,10 @@ class LogSVPricer(ModelPricer):
     @timer
     def calibrate_model_params_to_chain(self,
                                         option_chain: OptionChain,
-                                        params0: LogSvParams = None,
+                                        params0: LogSvParams,
                                         is_vega_weighted: bool = True,
                                         is_unit_ttm_vega: bool = False,
-                                        model_calibration_type: ModelCalibrationType = ModelCalibrationType.PARAMS5,
+                                        model_calibration_type: LogsvModelCalibrationType = LogsvModelCalibrationType.PARAMS5,
                                         constraints_type: ConstraintsType = ConstraintsType.UNCONSTRAINT,
                                         **kwargs
                                         ) -> LogSvParams:
@@ -245,7 +246,39 @@ class LogSVPricer(ModelPricer):
         else:
             weights = np.ones_like(market_vols)
 
-        if model_calibration_type == ModelCalibrationType.PARAMS5:
+        # implement different calibrato types
+        if model_calibration_type == LogsvModelCalibrationType.PARAMS4:
+            # fit: v0, theta, beta, volvol; kappa1, kappa2 is given with params0
+            if params0 is not None:
+                p0 = np.array([params0.sigma0, params0.theta, params0.beta, params0.volvol])
+            else:
+                p0 = np.array([0.8, 0.8, -0.2, 2.0])
+            bounds = ((0.01, 2.0), (0.01, 2.0), (-5.0, 3.0), (0.1, 10.0))
+
+            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
             if params0 is not None:
                 p0 = np.array([params0.sigma0, params0.theta, params0.kappa1, params0.beta, params0.volvol])
@@ -275,11 +308,6 @@ class LogSVPricer(ModelPricer):
                 kappa = kappa1 + kappa2 * theta
                 return kappa - 1.5*vartheta2
 
-            def kurtosis_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
-                return kappa1 - 1.5*vartheta2
-
         else:
             raise NotImplementedError(f"{model_calibration_type}")
 
@@ -320,7 +348,15 @@ class LogSVPricer(ModelPricer):
 
         popt = res.x
 
-        if model_calibration_type == ModelCalibrationType.PARAMS5:
+        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],