voly 0.0.193__tar.gz → 0.0.195__tar.gz

{voly-0.0.193/src/voly.egg-info → voly-0.0.195}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voly
-Version: 0.0.193
+Version: 0.0.195
 Summary: Options & volatility research package
 Author-email: Manu de Cara <manu.de.cara@gmail.com>
 License: MIT

{voly-0.0.193 → voly-0.0.195}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "voly"
-version = "0.0.193"
+version = "0.0.195"
 description = "Options & volatility research package"
 readme = "README.md"
 authors = [
@@ -60,7 +60,7 @@ line_length = 100
 multi_line_output = 3
 
 [tool.mypy]
-python_version = "0.0.193"
+python_version = "0.0.195"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true

{voly-0.0.193 → voly-0.0.195}/src/voly/core/fit.py

@@ -29,7 +29,7 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
     - option_chain: DataFrame with market data
 
     Returns:
-    - DataFrame with all fit results and performance metrics as columns, maturity_dates as index
+    - DataFrame with all fit results and performance metrics as columns, maturity_names as index
     """
     # Start overall timer
     start_total = time.time()
@@ -66,15 +66,16 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
     s = option_chain['index_price'].iloc[0]
     unique_ts = sorted(option_chain['t'].unique())
     maturity_names = [option_chain[option_chain['t'] == t]['maturity_name'].iloc[0] for t in unique_ts]
-    groups = option_chain.groupby('maturity_date')
+    maturity_dates = [option_chain[option_chain['t'] == t]['maturity_date'].iloc[0] for t in unique_ts]
+    maturity_data_groups = option_chain.groupby('maturity_date')
     params_dict = {}
     results_data = {col: [] for col in column_dtypes.keys()}
     num_points = 2000  # Number of points for k_grid
 
-    def process_maturity(maturity, group):
+    def process_maturity(maturity, maturity_data):
         """Process single maturity for SVI calibration."""
-        group = group[group['option_type'] == 'C']
-        duplicated_iv = group[group.duplicated('mark_iv', keep=False)]
+        maturity_data = maturity_data[maturity_data['option_type'] == 'C']
+        duplicated_iv = maturity_data[maturity_data.duplicated('mark_iv', keep=False)]
 
         # For each duplicated IV, keep the row closest to log_moneyness=0
         def keep_closest_to_zero(subgroup):
@@ -88,17 +89,17 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
         )
 
         # Get rows with unique mark_iv (no duplicates)
-        unique_iv = group.drop_duplicates('mark_iv', keep=False)
+        unique_iv = maturity_data.drop_duplicates('mark_iv', keep=False)
 
         # Combine cleaned duplicates and unique rows
         maturity_data = pd.concat([unique_iv, cleaned_duplicated_iv])
         maturity_date = maturity_data['maturity_date'].iloc[0]
+        maturity_name = maturity_data['maturity_name'].iloc[0]
 
-
-        t = group['t'].iloc[0]
-        K = group['strikes'].values
-        iv = group['mark_iv'].values
-        vega = group['vega'].values if 'vega' in group.columns else np.ones_like(iv)
+        t = maturity_data['t'].iloc[0]
+        K = maturity_data['strikes'].values
+        iv = maturity_data['mark_iv'].values
+        vega = maturity_data['vega'].values if 'vega' in maturity_data.columns else np.ones_like(iv)
         k = np.log(K / s)
         w = (iv ** 2) * t
         mask = ~np.isnan(w) & ~np.isnan(vega) & ~np.isnan(k) & (iv >= 0)
@@ -107,48 +108,35 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
         params = [np.nan] * 5
         loss = np.inf
         nu = psi = p = c = nu_tilde = np.nan
-        rmse = mae = r2 = max_error = np.nan
         butterfly_arbitrage_free = True
         r = maturity_data['interest_rate'].iloc[0] if 'interest_rate' in maturity_data.columns else 0
         log_min_strike = usd_min_strike = np.nan
 
         if len(k) > 5:
             params, loss = SVIModel.fit(tiv=w, vega=vega, k=k, tau=t)
-            if not np.isnan(params[0]):
-                params_dict[maturity_date] = (t, params)
-                a, b, m, rho, sigma = params
-                a_scaled, b_scaled = a * t, b * t
-
-                # Transform to Jump-Wing parameters
-                nu, psi, p, c, nu_tilde = SVIModel.raw_to_jw_params(a_scaled, b_scaled, m, rho, sigma, t)
-
-                # Compute fit statistics
-                w_model = np.array([SVIModel.svi(x, a_scaled, b_scaled, m, rho, sigma) for x in k])
-                iv_model = np.sqrt(w_model / t)
-                iv_market = iv
-                rmse = np.sqrt(mean_squared_error(iv_market, iv_model))
-                mae = mean_absolute_error(iv_market, iv_model)
-                r2 = r2_score(iv_market, iv_model)
-                max_error = np.max(np.abs(iv_market - iv_model))
-
-                # Compute min strike
-                log_min_strike = SVIModel.svi_min_strike(sigma, rho, m)
-                usd_min_strike = np.exp(log_min_strike) * s
-
-                # Butterfly arbitrage check
-                k_range = np.linspace(min(k), max(k), num_points)
-                w_k = lambda k: SVIModel.svi(k, a_scaled, b_scaled, m, rho, sigma)
-                w_prime = lambda k: b_scaled * (rho + (k - m) / np.sqrt((k - m) ** 2 + sigma ** 2))
-                w_double_prime = lambda k: b_scaled * sigma ** 2 / ((k - m) ** 2 + sigma ** 2) ** (3 / 2)
-
-                for k_val in k_range:
-                    wk = w_k(k_val)
-                    wp = w_prime(k_val)
-                    wpp = w_double_prime(k_val)
-                    g = (1 - (k_val * wp) / (2 * wk)) ** 2 - (wp ** 2) / 4 * (1 / wk + 1 / 4) + wpp / 2
-                    if g < 0:
-                        butterfly_arbitrage_free = False
-                        break
+            a, b, m, rho, sigma = params
+            a_scaled, b_scaled = a * t, b * t
+            params_dict[maturity_date] = (t, params)
+            nu, psi, p, c, nu_tilde = SVIModel.raw_to_jw_params(a_scaled, b_scaled, m, rho, sigma, t)
+            log_min_strike = SVIModel.svi_min_strike(sigma, rho, m)
+            usd_min_strike = np.exp(log_min_strike) * s
+
+            # Butterfly arbitrage check
+            k_range = np.linspace(min(k), max(k), num_points)
+            w_k = lambda k: SVIModel.svi(k, a_scaled, b_scaled, m, rho, sigma)
+            w_prime = lambda k: b_scaled * (rho + (k - m) / np.sqrt((k - m) ** 2 + sigma ** 2))
+            w_double_prime = lambda k: b_scaled * sigma ** 2 / ((k - m) ** 2 + sigma ** 2) ** (3 / 2)
+            for k_val in k_range:
+                wk = w_k(k_val)
+                wp = w_prime(k_val)
+                wpp = w_double_prime(k_val)
+                g = (1 - (k_val * wp) / (2 * wk)) ** 2 - (wp ** 2) / 4 * (1 / wk + 1 / 4) + wpp / 2
+                if g < 0:
+                    butterfly_arbitrage_free = False
+                    break
+        else:
+            params = [np.nan] * 5
+            loss = np.inf
 
         # Log result
         GREEN, RED, RESET = '\033[32m', '\033[31m', '\033[0m'
@@ -175,24 +163,21 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
         results_data['fit_success'].append(bool(not np.isnan(params[0])))
         results_data['butterfly_arbitrage_free'].append(butterfly_arbitrage_free)
         results_data['calendar_arbitrage_free'].append(True)  # Updated after check
-        results_data['rmse'].append(float(rmse))
-        results_data['mae'].append(float(mae))
-        results_data['r2'].append(float(r2))
-        results_data['max_error'].append(float(max_error))
+        results_data['rmse'].append(np.nan)
+        results_data['mae'].append(np.nan)
+        results_data['r2'].append(np.nan)
+        results_data['max_error'].append(np.nan)
         results_data['loss'].append(float(loss))
         results_data['n_points'].append(int(len(k)))
 
-        return maturity
+        return maturity_name
 
-    # Parallel processing of maturities with timer
-    start_parallel = time.time()
+    # Parallel processing of maturities
+    logger.info("\nStarting parallel processing of maturities...")
     with ThreadPoolExecutor() as executor:
-        futures = [executor.submit(process_maturity, maturity, group)
-                   for maturity, group in groups]
-        for future in futures:
-            future.result()
-    end_parallel = time.time()
-    logger.info(f"Processing completed in {end_parallel - start_parallel:.4f} seconds")
+        futures = [executor.submit(process_maturity, maturity, maturity_data)
+                   for maturity, maturity_data in maturity_data_groups]
+        maturity_names = [future.result() for future in futures]
 
     # Create results DataFrame
     results_df = pd.DataFrame(results_data, index=maturity_names)
@@ -208,7 +193,8 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
     # Sort by time to maturity
     results_df = results_df.sort_values(by='t')
 
-    # Calendar arbitrage check (pre-correction) with timer
+    # Calendar arbitrage check (pre-correction)
+    logger.info("\nChecking calendar arbitrage (pre-correction)...")
     k_grid = np.linspace(-2, 2, num_points)
     sorted_maturities = sorted(params_dict.keys(), key=lambda x: params_dict[x][0])
     calendar_arbitrage_free = True
@@ -222,8 +208,8 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
         if np.isnan(a1) or np.isnan(a2):
             continue
 
-        group = groups.get_group(mat2)
-        K = group['strikes'].values
+        maturity_data = maturity_data_groups.get_group(mat2)
+        K = maturity_data['strikes'].values
         k_market = np.log(K / s)
         mask = ~np.isnan(k_market)
         k_check = np.unique(np.concatenate([k_market[mask], np.linspace(min(k_market[mask]), max(k_market[mask]), num_points)]))
@@ -241,7 +227,7 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
     for mat in results_df['maturity_date']:
         results_df.loc[results_df['maturity_date'] == mat, 'calendar_arbitrage_free'] = calendar_arbitrage_free
 
-    # Calendar arbitrage correction with timer
+    # Calendar arbitrage correction
     logger.info("Performing calendar arbitrage correction...")
     for i in range(1, len(sorted_maturities)):
         mat2 = sorted_maturities[i]
@@ -252,10 +238,10 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
         if np.any(np.isnan(params2)) or np.any(np.isnan(params1)):
             continue
 
-        group = groups.get_group(mat2)
-        K = group['strikes'].values
-        iv = group['mark_iv'].values
-        vega = group['vega'].values if 'vega' in group.columns else np.ones_like(iv)
+        maturity_data = maturity_data_groups.get_group(mat2)
+        K = maturity_data['strikes'].values
+        iv = maturity_data['mark_iv'].values
+        vega = maturity_data['vega'].values if 'vega' in maturity_data.columns else np.ones_like(iv)
         k = np.log(K / s)
         w = (iv ** 2) * t2
         mask = ~np.isnan(w) & ~np.isnan(vega) & ~np.isnan(k) & (iv >= 0)
@@ -266,13 +252,14 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
             prev_params=params1, prev_t=t1, k_grid=k_grid
         )
 
-        params_dict[mat2] = (t2, new_params)
-
         a, b, m, rho, sigma = new_params
         a_scaled, b_scaled = a * t2, b * t2
+        params_dict[mat2] = (t2, new_params)
         nu, psi, p, c, nu_tilde = SVIModel.raw_to_jw_params(a_scaled, b_scaled, m, rho, sigma, t2)
+        log_min_strike = SVIModel.svi_min_strike(sigma, rho, m)
+        usd_min_strike = np.exp(log_min_strike) * s
 
-        # Recompute fit statistics
+        # Compute fit statistics
         w_model = np.array([SVIModel.svi(x, a_scaled, b_scaled, m, rho, sigma) for x in k])
         iv_model = np.sqrt(w_model / t2)
         iv_market = iv
@@ -281,17 +268,12 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
         r2 = r2_score(iv_market, iv_model)
         max_error = np.max(np.abs(iv_market - iv_model))
 
-        # Recompute min strike
-        log_min_strike = SVIModel.svi_min_strike(sigma, rho, m)
-        usd_min_strike = np.exp(log_min_strike) * s
-
         # Update butterfly arbitrage check
         butterfly_arbitrage_free = True
         k_range = np.linspace(min(k), max(k), num_points)
         w_k = lambda k: SVIModel.svi(k, a_scaled, b_scaled, m, rho, sigma)
         w_prime = lambda k: b_scaled * (rho + (k - m) / np.sqrt((k - m) ** 2 + sigma ** 2))
         w_double_prime = lambda k: b_scaled * sigma ** 2 / ((k - m) ** 2 + sigma ** 2) ** (3 / 2)
-
         for k_val in k_range:
             wk = w_k(k_val)
             wp = w_prime(k_val)
@@ -302,7 +284,7 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
                 break
 
         # Update results_df using maturity_name
-        mat_name = group['maturity_name'].iloc[0]
+        mat_name = maturity_data['maturity_name'].iloc[0]
         results_df.loc[mat_name, 'a'] = float(a_scaled)
         results_df.loc[mat_name, 'b'] = float(b_scaled)
         results_df.loc[mat_name, 'm'] = float(m)
@@ -321,6 +303,10 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
         results_df.loc[mat_name, 'usd_min_strike'] = float(usd_min_strike)
         results_df.loc[mat_name, 'butterfly_arbitrage_free'] = butterfly_arbitrage_free
         results_df.loc[mat_name, 'fit_success'] = bool(not np.isnan(a))
+    else:
+        logger.warning(f"Skipping parameter update for maturity {mat2} due to invalid parameters")
+        mat_name = maturity_data['maturity_name'].iloc[0]
+        results_df.loc[mat_name, 'fit_success'] = False
 
     # Calendar arbitrage check (post-correction)
     calendar_arbitrage_free = True
@@ -334,8 +320,8 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
         if np.isnan(a1) or np.isnan(a2):
             continue
 
-        group = groups.get_group(mat2)
-        K = group['strikes'].values
+        maturity_data = maturity_data_groups.get_group(mat2)
+        K = maturity_data['strikes'].values
         k_market = np.log(K / s)
         mask = ~np.isnan(k_market)
         k_check = np.unique(np.concatenate(

{voly-0.0.193 → voly-0.0.195}/src/voly/models.py

@@ -90,8 +90,6 @@ class SVIModel:
         if len(k) <= 5:
             return [np.nan] * 5, np.inf
 
-        from scipy.optimize import minimize
-
         vega = vega / vega.max() if vega.max() > 0 else np.ones_like(vega)
         m_init = np.mean(k)
         sigma_init = max(0.1, np.std(k) * 0.1)
@@ -102,7 +100,7 @@ class SVIModel:
             return loss
 
         result = minimize(score, [sigma_init, m_init], bounds=[(0.001, None), (None, None)],
-                          tol=1e-16, method="SLSQP", options={'maxfun': 5000})
+                         tol=1e-16, method="SLSQP", options={'maxfun': 5000})
 
         sigma, m = result.x
         c, d, a_calib, loss = cls.calibration(tiv, vega, k, m, sigma)
@@ -116,7 +114,9 @@ class SVIModel:
             a_svi = a_calib / tau
             rho_svi = b_svi = 0
 
-        return [a_svi, b_svi, m, rho_svi, sigma], loss
+        # Validate parameters
+        params = [a_svi, b_svi, m, rho_svi, sigma]
+        return params, loss
 
     @classmethod
     def correct_calendar_arbitrage(cls, params, t, tiv, vega, k, prev_params, prev_t, k_grid):
@@ -162,11 +162,13 @@ class SVIModel:
 
         if result.success:
             new_params = result.x
-            w_current = cls.svi(k_constraint, new_params[0] * t, new_params[1] * t, *new_params[2:])
+            a, b, m, rho, sigma = new_params
+            a_scaled, b_scaled = a * t, b * t
+            w_current = cls.svi(k_constraint, a_scaled, b_scaled, m, rho, sigma)
             w_prev = cls.svi(k_constraint, a_prev * prev_t, b_prev * prev_t, m_prev, rho_prev, sigma_prev)
             violation = np.min(w_current - w_prev)
             logger.info(f"Calendar arbitrage correction {'successful' if violation >= -1e-6 else 'failed'} for t={t:.4f}, "
-                  f"min margin={violation:.6f}")
+                        f"min margin={violation:.6f}")
             return new_params
         logger.warning(f"Calendar arbitrage correction failed for t={t:.4f}")
         return params

{voly-0.0.193 → voly-0.0.195/src/voly.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voly
-Version: 0.0.193
+Version: 0.0.195
 Summary: Options & volatility research package
 Author-email: Manu de Cara <manu.de.cara@gmail.com>
 License: MIT