voly 0.0.184__tar.gz → 0.0.186__tar.gz

{voly-0.0.184/src/voly.egg-info → voly-0.0.186}/PKG-INFO

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

{voly-0.0.184 → voly-0.0.186}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "voly"
-version = "0.0.184"
+version = "0.0.186"
 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.184"
+python_version = "0.0.186"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true

{voly-0.0.184 → voly-0.0.186}/src/voly/core/fit.py

@@ -13,7 +13,9 @@ from voly.utils.logger import logger, catch_exception
 from voly.formulas import get_domain
 from voly.exceptions import VolyError
 from voly.models import SVIModel
+from concurrent.futures import ThreadPoolExecutor
 import warnings
+import time
 
 warnings.filterwarnings("ignore")
 
@@ -21,14 +23,17 @@ warnings.filterwarnings("ignore")
 @catch_exception
 def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
     """
-    Fit a volatility model to market data.
+    Fit a volatility model to market data with parallel processing.
 
     Parameters:
     - option_chain: DataFrame with market data
 
     Returns:
-    - DataFrame with all fit results and performance metrics as columns, maturity_names as index
+    - DataFrame with all fit results and performance metrics as columns, maturity_dates as index
     """
+    # Start overall timer
+    start_total = time.time()
+
     # Define column names and their data types
     column_dtypes = {
         's': float,
@@ -61,39 +66,48 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
         'n_points': int
     }
 
-    # Get unique maturities and sort them
-    groups = option_chain.groupby('maturity_date')
-    unique_ts = sorted(option_chain['t'].unique())
+    s = option_chain['index_price'].iloc[0]
     maturity_names = [option_chain[option_chain['t'] == t]['maturity_name'].iloc[0] for t in unique_ts]
-
-    # Store results in a dictionary first
+    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):
+        """Process single maturity for SVI calibration."""
+        group = group[group['option_type'] == 'C']
+        duplicated_iv = group[group.duplicated('mark_iv', keep=False)]
+
+        # For each duplicated IV, keep the row closest to log_moneyness=0
+        def keep_closest_to_zero(subgroup):
+            idx = (subgroup['log_moneyness'].abs()).idxmin()
+            return subgroup.loc[[idx]]
+
+        # Apply the function to each duplicated mark_iv group
+        cleaned_duplicated_iv = (
+            duplicated_iv.groupby('mark_iv', group_keys=False)
+            .apply(keep_closest_to_zero)
+        )
 
-    # ANSI color codes for terminal output
-    GREEN, RED, RESET = '\033[32m', '\033[31m', '\033[0m'
-
-    s = option_chain['index_price'].iloc[-1]
-
-    # Dictionary to track fit results by maturity for arbitrage checks
-    params_dict = {}
+        # Get rows with unique mark_iv (no duplicates)
+        unique_iv = group.drop_duplicates('mark_iv', keep=False)
 
-    # Calibrate and check arbitrage
-    for t in unique_ts:
-        # Get data for this maturity
-        maturity_data = option_chain[option_chain['t'] == t]
-        maturity_name = maturity_data['maturity_name'].iloc[0]
+        # Combine cleaned duplicates and unique rows
+        maturity_data = pd.concat([unique_iv, cleaned_duplicated_iv])
+        #maturity_name = maturity_data['maturity_name'].iloc[0]
         maturity_date = maturity_data['maturity_date'].iloc[0]
 
-        logger.info(f"Processing maturity {maturity_date}, t={t:.4f}")
-
-        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)
+        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)
         k = np.log(K / s)
         w = (iv ** 2) * t
         mask = ~np.isnan(w) & ~np.isnan(vega) & ~np.isnan(k) & (iv >= 0)
         k, w, vega, iv = k[mask], w[mask], vega[mask], iv[mask]
 
+        logger.info(f"Processing maturity {maturity}, points after filtering: {len(k)}")
+
         params = [np.nan] * 5
         loss = np.inf
         nu = psi = p = c = nu_tilde = np.nan
@@ -112,6 +126,7 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
                 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
@@ -128,7 +143,7 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
                 usd_min_strike = np.exp(log_min_strike) * s
 
                 # Butterfly arbitrage check
-                k_range = np.linspace(min(k), max(k), 200)
+                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)
@@ -143,10 +158,12 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
                         break
 
         # Log result
+        GREEN, RED, RESET = '\033[32m', '\033[31m', '\033[0m'
         status = f'{GREEN}SUCCESS{RESET}' if not np.isnan(params[0]) else f'{RED}FAILED{RESET}'
-        logger.info(f'Optimization for {maturity_name}: {status}')
+        logger.info(f'Optimization for {maturity}: {status}')
         logger.info("================================================")
 
+        # Store results
         results_data['s'].append(float(s))
         results_data['u'].append(float(u))
         results_data['t'].append(float(t))
@@ -176,6 +193,18 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
         results_data['loss'].append(float(loss))
         results_data['n_points'].append(int(len(k)))
 
+        return maturity
+
+    # Parallel processing of maturities with timer
+    start_parallel = time.time()
+    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")
+
     # Create results DataFrame
     results_df = pd.DataFrame(results_data, index=maturity_names)
 
@@ -187,12 +216,14 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
             except (ValueError, TypeError) as e:
                 logger.warning(f"Could not convert column {col} to {dtype}: {e}")
 
-    # Calendar arbitrage check (pre-correction)
+    # Sort by time to maturity
+    results_df = results_df.sort_values(by='t')
+
+    # Calendar arbitrage check (pre-correction) with timer
     logger.info("\nChecking calendar arbitrage (pre-correction)...")
-    k_grid = np.linspace(-2, 2, 200)
+    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
-
     for i in range(len(sorted_maturities) - 1):
         mat1, mat2 = sorted_maturities[i], sorted_maturities[i + 1]
         t1, params1 = params_dict[mat1]
@@ -205,33 +236,24 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
 
         group = groups.get_group(mat2)
         K = group['strikes'].values
-        s = group['index_price'].iloc[0]
         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]), 200)]))
+        k_check = np.unique(np.concatenate([k_market[mask], np.linspace(min(k_market[mask]), max(k_market[mask]), num_points)]))
 
         for k_val in k_check:
             w1 = SVIModel.svi(k_val, a1 * t1, b1 * t1, m1, rho1, sigma1)
             w2 = SVIModel.svi(k_val, a2 * t2, b2 * t2, m2, rho2, sigma2)
             if w2 < w1 - 1e-6:
-                logger.warning(f"Calendar arbitrage violation at t1={t1:.4f}, t2={t2:.4f}, k={k_val:.4f}: ")
-                logger.warning(f"w1={w1:.6f}, w2={w2:.6f}")
+                logger.warning(f"Calendar arbitrage violation at t1={t1:.4f}, t2={t2:.4f}, k={k_val:.4f}: w1={w1:.6f}, w2={w2:.6f}")
                 calendar_arbitrage_free = False
                 break
         if not calendar_arbitrage_free:
             break
 
     for mat in sorted_maturities:
-        idx = None
-        for i, maturity_name in enumerate(maturity_names):
-            if results_df.iloc[i]['maturity_date'] == mat:
-                idx = results_df.index[i]
-                break
-        if idx is not None:
-            results_df.at[idx, 'calendar_arbitrage_free'] = calendar_arbitrage_free
+        results_df.at[mat, 'calendar_arbitrage_free'] = calendar_arbitrage_free
 
-    # Calendar arbitrage correction
+    # Calendar arbitrage correction with timer
     logger.info("\nPerforming calendar arbitrage correction...")
     for i in range(1, len(sorted_maturities)):
         mat2 = sorted_maturities[i]
@@ -243,7 +265,6 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
             continue
 
         group = groups.get_group(mat2)
-        s = group['index_price'].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)
@@ -278,7 +299,7 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
 
         # Update butterfly arbitrage check
         butterfly_arbitrage_free = True
-        k_range = np.linspace(min(k), max(k), 200)
+        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)
@@ -292,35 +313,26 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
                 butterfly_arbitrage_free = False
                 break
 
-        # Find the correct index to update
-        idx = None
-        for j, maturity_name in enumerate(maturity_names):
-            if results_df.iloc[j]['maturity_date'] == mat2:
-                idx = results_df.index[j]
-                break
-
-        if idx is not None:
-            results_df.at[idx, 'a'] = float(a_scaled)
-            results_df.at[idx, 'b'] = float(b_scaled)
-            results_df.at[idx, 'm'] = float(m)
-            results_df.at[idx, 'rho'] = float(rho)
-            results_df.at[idx, 'sigma'] = float(sigma)
-            results_df.at[idx, 'nu'] = float(nu)
-            results_df.at[idx, 'psi'] = float(psi)
-            results_df.at[idx, 'p'] = float(p)
-            results_df.at[idx, 'c'] = float(c)
-            results_df.at[idx, 'nu_tilde'] = float(nu_tilde)
-            results_df.at[idx, 'rmse'] = float(rmse)
-            results_df.at[idx, 'mae'] = float(mae)
-            results_df.at[idx, 'r2'] = float(r2)
-            results_df.at[idx, 'max_error'] = float(max_error)
-            results_df.at[idx, 'log_min_strike'] = float(log_min_strike)
-            results_df.at[idx, 'usd_min_strike'] = float(usd_min_strike)
-            results_df.at[idx, 'butterfly_arbitrage_free'] = butterfly_arbitrage_free
-            results_df.at[idx, 'fit_success'] = bool(not np.isnan(a))
+        results_df.at[mat2, 'a'] = float(a_scaled)
+        results_df.at[mat2, 'b'] = float(b_scaled)
+        results_df.at[mat2, 'm'] = float(m)
+        results_df.at[mat2, 'rho'] = float(rho)
+        results_df.at[mat2, 'sigma'] = float(sigma)
+        results_df.at[mat2, 'nu'] = float(nu)
+        results_df.at[mat2, 'psi'] = float(psi)
+        results_df.at[mat2, 'p'] = float(p)
+        results_df.at[mat2, 'c'] = float(c)
+        results_df.at[mat2, 'nu_tilde'] = float(nu_tilde)
+        results_df.at[mat2, 'rmse'] = float(rmse)
+        results_df.at[mat2, 'mae'] = float(mae)
+        results_df.at[mat2, 'r2'] = float(r2)
+        results_df.at[mat2, 'max_error'] = float(max_error)
+        results_df.at[mat2, 'log_min_strike'] = float(log_min_strike)
+        results_df.at[mat2, 'usd_min_strike'] = float(usd_min_strike)
+        results_df.at[mat2, 'butterfly_arbitrage_free'] = butterfly_arbitrage_free
+        results_df.at[mat2, 'fit_success'] = bool(not np.isnan(a))
 
     # Calendar arbitrage check (post-correction)
-    logger.info("\nChecking calendar arbitrage (post-correction)...")
     calendar_arbitrage_free = True
     for i in range(len(sorted_maturities) - 1):
         mat1, mat2 = sorted_maturities[i], sorted_maturities[i + 1]
@@ -334,88 +346,27 @@ def fit_model(option_chain: pd.DataFrame) -> pd.DataFrame:
 
         group = groups.get_group(mat2)
         K = group['strikes'].values
-        s = group['index_price'].iloc[0]
         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]), 200)]))
+            [k_market[mask], np.linspace(min(k_market[mask]), max(k_market[mask]), num_points)]))
 
         for k_val in k_check:
             w1 = SVIModel.svi(k_val, a1 * t1, b1 * t1, m1, rho1, sigma1)
             w2 = SVIModel.svi(k_val, a2 * t2, b2 * t2, m2, rho2, sigma2)
             if w2 < w1 - 1e-6:
-                logger.warning(
-                    f"Calendar arbitrage violation at t1={t1:.4f}, t2={t2:.4f}, k={k_val:.4f}: w1={w1:.6f}, w2={w2:.6f}")
+                logger.warning(f"Calendar arbitrage violation at t1={t1:.4f}, t2={t2:.4f}, k={k_val:.4f}: w1={w1:.6f}, w2={w2:.6f}")
                 calendar_arbitrage_free = False
                 break
         if not calendar_arbitrage_free:
             break
 
     for mat in sorted_maturities:
-        idx = None
-        for j, maturity_name in enumerate(maturity_names):
-            if results_df.iloc[j]['maturity_date'] == mat:
-                idx = results_df.index[j]
-                break
-        if idx is not None:
-            results_df.at[idx, 'calendar_arbitrage_free'] = calendar_arbitrage_free
+        results_df.at[mat, 'calendar_arbitrage_free'] = calendar_arbitrage_free
+
+    # End overall timer and print total time
+    end_total = time.time()
+    logger.info(f"\nTotal execution time for SVI fit: {end_total - start_total:.4f} seconds")
 
     logger.info("Model fitting complete.")
     return results_df
-
-
-@catch_exception
-def get_iv_surface(model_results: pd.DataFrame,
-                   domain_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
-                   return_domain: str = 'log_moneyness') -> Tuple[Dict[str, np.ndarray], Dict[str, np.ndarray]]:
-    """
-    Generate implied volatility surface using optimized SVI parameters.
-
-    Works with both regular fit_results and interpolated_results dataframes.
-
-    Parameters:
-    - model_results: DataFrame from fit_model() or interpolate_model(). Maturity names or DTM as Index
-    - domain_params: Tuple of (min, max, num_points) for the log-moneyness array
-    - return_domain: Domain for x-axis values ('log_moneyness', 'moneyness', 'returns', 'strikes', 'delta')
-
-    Returns:
-    - Tuple of (iv_surface, x_surface)
-      iv_surface: Dictionary mapping maturity/dtm names to IV arrays
-      x_surface: Dictionary mapping maturity/dtm names to requested x domain arrays
-    """
-    # Check if required columns are present
-    required_columns = ['a', 'b', 'm', 'rho', 'sigma', 't']
-    missing_columns = [col for col in required_columns if col not in model_results.columns]
-    if missing_columns:
-        raise VolyError(f"Required columns missing in model_results: {missing_columns}")
-
-    # Generate implied volatility surface in log-moneyness domain
-    LM = np.linspace(domain_params[0], domain_params[1], domain_params[2])
-
-    iv_surface = {}
-    x_surface = {}
-
-    # Process each maturity/dtm
-    for i in model_results.index:
-        # Calculate SVI total implied variance and convert to IV
-        params = [
-            model_results.loc[i, 'a'],
-            model_results.loc[i, 'b'],
-            model_results.loc[i, 'm'],
-            model_results.loc[i, 'rho'],
-            model_results.loc[i, 'sigma']
-        ]
-        s = model_results.loc[i, 's']
-        r = model_results.loc[i, 'r']
-        t = model_results.loc[i, 't']
-
-        # Calculate implied volatility
-        w = np.array([SVIModel.svi(x, *params) for x in LM])
-        o = np.sqrt(w / t)
-        iv_surface[i] = o
-
-        # Calculate x domain for this maturity/dtm
-        x = get_domain(domain_params, s, r, o, t, return_domain)
-        x_surface[i] = x
-
-    return iv_surface, x_surface

{voly-0.0.184 → voly-0.0.186}/src/voly/models.py

@@ -5,6 +5,9 @@ Volatility models for the Voly package.
 import numpy as np
 from numpy.linalg import solve
 from typing import Tuple, Dict, List, Optional, Union
+from voly.utils.logger import logger
+from scipy.optimize import minimize
+from sklearn.metrics import mean_squared_error
 
 
 class SVIModel:
@@ -99,7 +102,7 @@ class SVIModel:
             return loss
 
         result = minimize(score, [sigma_init, m_init], bounds=[(0.001, None), (None, None)],
-                          tol=1e-16, method="Nelder-Mead", 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)
@@ -120,8 +123,6 @@ class SVIModel:
         if np.any(np.isnan(params)) or np.any(np.isnan(prev_params)):
             return params
 
-        from scipy.optimize import minimize
-
         a_init, b_init, m_init, rho_init, sigma_init = params
         a_prev, b_prev, m_prev, rho_prev, sigma_prev = prev_params
         k_constraint = np.unique(np.concatenate([k, np.linspace(min(k), max(k), len(k_grid))]))
@@ -129,7 +130,6 @@ class SVIModel:
         def objective(x):
             a, b, m, rho, sigma = x
             w_model = cls.svi(k, a * t, b * t, m, rho, sigma)
-            from sklearn.metrics import mean_squared_error
             fit_loss = mean_squared_error(tiv, w_model, sample_weight=vega)
             param_deviation = sum(((x[i] - x_init) / max(abs(x_init), 1e-6)) ** 2
                                   for i, x_init in enumerate([a_init, b_init, m_init, rho_init, sigma_init]))

{voly-0.0.184 → voly-0.0.186/src/voly.egg-info}/PKG-INFO

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