voly 0.0.177__py3-none-any.whl → 0.0.178__py3-none-any.whl

voly/client.py

@@ -91,8 +91,9 @@ class VolyClient:
     # -------------------------------------------------------------------------
 
     @staticmethod
-    def svi(LM: float, a: float, b: float, sigma: float, rho: float, m: float) -> float:
-        return SVIModel.svi(LM, a, b, sigma, rho, m)
+    def svi_raw(k: float, a: float, b: float, m: float, rho: float, sigma: float) -> float:
+        """Calculate SVI total implied variance using raw parameterization."""
+        return SVIModel.svi_raw(k, a, b, m, rho, sigma)
 
     @staticmethod
     def d1(s: float, K: float, r: float, o: float, t: float,
@@ -165,19 +166,18 @@ class VolyClient:
 
     @staticmethod
     def fit_model(option_chain: pd.DataFrame,
-                  domain_params: Tuple[float, float, int] = (-2, 2, 500)
-                  ) -> Dict[str, Any]:
+                  domain_params: Tuple[float, float, int] = (-2, 2, 1000)) -> pd.DataFrame:
         """
-        Fit a volatility model to market data.
+        Fit a volatility model to market data using the improved SVI approach.
 
         Parameters:
         - option_chain: DataFrame with option market data
-        - domain_params: Tuple of (min, max, num_points) for the moneyness grid
+        - domain_params: Tuple of (min, max, num_points) for the log-moneyness grid
 
         Returns:
-        - Dataframe with fit_results
+        - DataFrame with fit results including arbitrage checks
         """
-        logger.info(f"Fitting model to market data.")
+        logger.info(f"Fitting SVI model to market data")
 
         # Fit the model
         fit_results = fit_model(

voly/core/fit.py

@@ -8,7 +8,6 @@ calculating fitting statistics.
 import numpy as np
 import pandas as pd
 from typing import List, Tuple, Dict, Optional, Union, Any
-from scipy.optimize import least_squares
 from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
 from voly.utils.logger import logger, catch_exception
 from voly.formulas import get_domain
@@ -21,24 +20,25 @@ warnings.filterwarnings("ignore")
 
 @catch_exception
 def fit_model(option_chain: pd.DataFrame,
-              domain_params: Tuple[float, float, int] = (-1.5, 1.5, 1000)) -> pd.DataFrame:
+              domain_params: Tuple[float, float, int] = (-2, 2, 1000)) -> pd.DataFrame:
     """
-    Fit Voly's volatility model to market data.
+    Fit a volatility model to market data.
 
     Parameters:
     - option_chain: DataFrame with market data
-    - domain_params : Tuple[float, float, int]
-        (min_log_moneyness, max_log_moneyness, num_points)
+    - domain_params: Tuple of (min, max, num_points) for the log-moneyness grid
 
     Returns:
     - DataFrame with all fit results and performance metrics as columns, maturity_names as index
     """
-
     # Define column names and their data types
     column_dtypes = {
         's': float,
+        'u': float,
         't': float,
         'r': float,
+        'oi': float,
+        'volume': float,
         'maturity_date': 'datetime64[ns]',
         'a': float,
         'b': float,
@@ -64,6 +64,7 @@ def fit_model(option_chain: pd.DataFrame,
     }
 
     # Get unique maturities and sort them
+    groups = option_chain.groupby('maturity_date')
     unique_ts = sorted(option_chain['t'].unique())
     maturity_names = [option_chain[option_chain['t'] == t]['maturity_name'].iloc[0] for t in unique_ts]
 
@@ -76,100 +77,95 @@ def fit_model(option_chain: pd.DataFrame,
     s = option_chain['index_price'].iloc[-1]
 
     # Dictionary to track fit results by maturity for arbitrage checks
-    fit_params_dict = {}
+    params_dict = {}
 
-    # First pass: Fit each maturity
+    # 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]
         maturity_date = maturity_data['maturity_date'].iloc[0]
 
-        logger.info(f"Optimizing for {maturity_name}...")
+        logger.info(f"Processing maturity {maturity_date}, t={t:.4f}")
 
-        # Extract data for fitting
-        k = maturity_data['log_moneyness'].values
+        K = maturity_data['strikes'].values
         iv = maturity_data['mark_iv'].values
-        vega = maturity_data['vega'].values if 'vega' in maturity_data else np.ones_like(iv)
-
-        # Apply mask to filter out invalid data
-        mask = ~np.isnan(iv) & ~np.isnan(k) & (iv > 0)
-        k_masked, iv_masked, vega_masked = k[mask], iv[mask], vega[mask]
-
-        # Check if we have enough valid points
-        if len(k_masked) <= 5:
-            logger.warning(f"Not enough valid data points for {maturity_name}, skipping.")
-            params = [np.nan] * 5
-            loss = np.inf
-        else:
-            # Calculate total implied variance (w = iv² * t)
-            w = (iv_masked ** 2) * t
-
-            # Fit using the improved SVI method
-            params, loss = SVIModel.fit(tiv=w, vega=vega_masked, k=k_masked, tau=t)
-
-        # Store the parameters for this maturity
-        fit_params_dict[maturity_date] = (t, params)
+        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)
+        k, w, vega, iv = k[mask], w[mask], vega[mask], iv[mask]
 
-        # Extract parameters (will be nan if fit failed)
-        a, b, m, rho, sigma = params
+        logger.info(f"Points after filtering: {len(k)}")
 
-        # Calculate statistics
-        fit_success = not np.isnan(a)
-        butterfly_arbitrage_free = True
-        calendar_arbitrage_free = True  # Will check later
-
-        # Initialize default metrics
-        rmse = mae = r2 = max_error = np.nan
+        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
+        u = s  # Assume underlying_price is index_price
+        r = maturity_data['interest_rate'].iloc[0] if 'interest_rate' in maturity_data.columns else 0
+        oi = maturity_data['open_interest'].sum() if 'open_interest' in maturity_data.columns else 0
+        volume = maturity_data['volume'].sum() if 'volume' in maturity_data.columns else 0
         log_min_strike = usd_min_strike = np.nan
-        a_scaled = b_scaled = np.nan
-
-        if fit_success:
-            # Scale a and b by t
-            a_scaled, b_scaled = a * t, b * t
-
-            # Calculate Jump-Wing parameters
-            nu, psi, p, c, nu_tilde = SVIModel.raw_to_jw_params(a_scaled, b_scaled, m, rho, sigma, t)
-
-            # Calculate model predictions for statistics
-            w_model = np.array([SVIModel.svi_raw(x, a_scaled, b_scaled, m, rho, sigma) for x in k_masked])
-            iv_model = np.sqrt(w_model / t)
-            iv_market = iv_masked
 
-            # Calculate statistics
-            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))
+        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
+
+                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_raw(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), domain_params[2])
+                w_k = lambda k: SVIModel.svi_raw(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
 
-            # Calculate minimum strike
-            log_min_strike = SVIModel.svi_min_strike(sigma, rho, m)
-            usd_min_strike = s * np.exp(-log_min_strike)  # Convert from log_moneyness to strike
-
-            # Check butterfly arbitrage
-            k_range = np.linspace(min(k_masked), max(k_masked), domain_params[2])
-            for k_val in k_range:
-                wk = SVIModel.svi_raw(k_val, a_scaled, b_scaled, m, rho, sigma)
-                wp = SVIModel.svi_d(k_val, a_scaled, b_scaled, m, rho, sigma)
-                wpp = SVIModel.svi_dd(k_val, a_scaled, b_scaled, m, rho, sigma)
-                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
-
-        r = maturity_data['interest_rate'].iloc[0] if 'interest_rate' in maturity_data.columns else 0
+        # Log result
+        status = f'{GREEN}SUCCESS{RESET}' if not np.isnan(params[0]) else f'{RED}FAILED{RESET}'
+        logger.info(f'Optimization for {maturity_name}: {status}')
+        if not np.isnan(params[0]):
+            logger.info(
+                f"Maturity {maturity_name}: a={a_scaled:.4f}, b={b_scaled:.4f}, m={m:.4f}, rho={rho:.4f}, sigma={sigma:.4f}")
+        logger.info("=================================================================")
 
-        # Store values in the results dictionary with proper types
         results_data['s'].append(float(s))
+        results_data['u'].append(float(u))
         results_data['t'].append(float(t))
         results_data['r'].append(float(r))
+        results_data['oi'].append(float(oi))
+        results_data['volume'].append(float(volume))
         results_data['maturity_date'].append(maturity_date)
-        results_data['a'].append(float(a_scaled) if fit_success else np.nan)
-        results_data['b'].append(float(b_scaled) if fit_success else np.nan)
-        results_data['sigma'].append(float(sigma) if fit_success else np.nan)
-        results_data['m'].append(float(m) if fit_success else np.nan)
-        results_data['rho'].append(float(rho) if fit_success else np.nan)
+        results_data['a'].append(float(a_scaled) if not np.isnan(params[0]) else np.nan)
+        results_data['b'].append(float(b_scaled) if not np.isnan(params[0]) else np.nan)
+        results_data['m'].append(float(m))
+        results_data['rho'].append(float(rho))
+        results_data['sigma'].append(float(sigma))
         results_data['nu'].append(float(nu))
         results_data['psi'].append(float(psi))
         results_data['p'].append(float(p))
@@ -177,22 +173,17 @@ def fit_model(option_chain: pd.DataFrame,
         results_data['nu_tilde'].append(float(nu_tilde))
         results_data['log_min_strike'].append(float(log_min_strike))
         results_data['usd_min_strike'].append(float(usd_min_strike))
-        results_data['fit_success'].append(bool(fit_success))
-        results_data['butterfly_arbitrage_free'].append(bool(butterfly_arbitrage_free))
-        results_data['calendar_arbitrage_free'].append(bool(True))  # Will update in second pass
-        results_data['loss'].append(float(loss))
+        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['n_points'].append(int(len(k_masked)))
-
-        # Log result
-        status = f'{GREEN}SUCCESS{RESET}' if fit_success else f'{RED}FAILED{RESET}'
-        logger.info(f'Optimization for {maturity_name}: {status}')
-        logger.info('-------------------------------------')
+        results_data['loss'].append(float(loss))
+        results_data['n_points'].append(int(len(k)))
 
-    # Create DataFrame with proper types
+    # Create results DataFrame
     results_df = pd.DataFrame(results_data, index=maturity_names)
 
     # Convert columns to appropriate types
@@ -203,168 +194,179 @@ def fit_model(option_chain: pd.DataFrame,
             except (ValueError, TypeError) as e:
                 logger.warning(f"Could not convert column {col} to {dtype}: {e}")
 
-    # Second pass: Check and correct for calendar arbitrage
-    logger.info("Checking for calendar arbitrage...")
-    sorted_maturities = sorted(fit_params_dict.keys())
-    k_grid = np.linspace(domain_params[0], domain_params[1], domain_params[2])  # Grid for arbitrage checking
-
-    # Check calendar arbitrage before correction
+    # Calendar arbitrage check (pre-correction)
+    logger.info("\nChecking calendar arbitrage (pre-correction)...")
+    k_grid = np.linspace(domain_params[0], domain_params[1], domain_params[2])
+    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 = fit_params_dict[mat1]
-        t2, params2 = fit_params_dict[mat2]
-        a1, b1, sigma1, rho1, m1 = params1
-        a2, b2, sigma2, rho2, m2 = params2
+        t1, params1 = params_dict[mat1]
+        t2, params2 = params_dict[mat2]
+        a1, b1, m1, rho1, sigma1 = params1
+        a2, b2, m2, rho2, sigma2 = params2
 
         if np.isnan(a1) or np.isnan(a2):
             continue
 
-        # Check arbitrage on a grid of points
-        for k_val in k_grid:
+        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]), domain_params[2])]))
+
+        for k_val in k_check:
             w1 = SVIModel.svi_raw(k_val, a1 * t1, b1 * t1, m1, rho1, sigma1)
             w2 = SVIModel.svi_raw(k_val, a2 * t2, b2 * t2, m2, rho2, sigma2)
             if w2 < w1 - 1e-6:
-                calendar_arbitrage_free = False
                 logger.warning(
-                    f"Calendar arbitrage detected between {sorted_maturities[i]} and {sorted_maturities[i + 1]}")
+                    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
 
-    # Update results with calendar arbitrage status
-    for i, maturity_name in enumerate(maturity_names):
-        idx = results_df.index[i]
-        results_df.at[idx, 'calendar_arbitrage_free'] = calendar_arbitrage_free
+    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
 
-    # Correct calendar arbitrage if needed
+    # Calendar arbitrage correction
     if not calendar_arbitrage_free:
-        logger.info("Correcting calendar arbitrage...")
+        logger.info("\nPerforming calendar arbitrage correction...")
         for i in range(1, len(sorted_maturities)):
-            mat1 = sorted_maturities[i - 1]
             mat2 = sorted_maturities[i]
-            t1, params1 = fit_params_dict[mat1]
-            t2, params2 = fit_params_dict[mat2]
-
-            if np.isnan(params1[0]) or np.isnan(params2[0]):
-                continue
-
-            # Find the index in maturity_names that corresponds to mat2
-            maturity_idx = None
-            for j, maturity_name in enumerate(maturity_names):
-                if results_df.iloc[j]['maturity_date'] == mat2:
-                    maturity_idx = j
-                    break
-
-            if maturity_idx is None:
-                continue
-
-            # Get data for correction
-            idx = results_df.index[maturity_idx]
-            maturity_data = option_chain[option_chain['maturity_name'] == idx]
-            k = maturity_data['log_moneyness'].values
-            iv = maturity_data['mark_iv'].values
-            vega = maturity_data['vega'].values if 'vega' in maturity_data else np.ones_like(iv)
-
-            # Apply mask to filter out invalid data
-            mask = ~np.isnan(iv) & ~np.isnan(k) & (iv > 0)
-            k_masked, iv_masked, vega_masked = k[mask], iv[mask], vega[mask]
+            mat1 = sorted_maturities[i - 1]
+            t2, params2 = params_dict[mat2]
+            t1, params1 = params_dict[mat1]
 
-            if len(k_masked) <= 5:
+            if np.any(np.isnan(params2)) or np.any(np.isnan(params1)):
                 continue
 
-            # Calculate total implied variance
-            w = (iv_masked ** 2) * t2
+            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)
+            k = np.log(K / s)
+            w = (iv ** 2) * t2
+            mask = ~np.isnan(w) & ~np.isnan(vega) & ~np.isnan(k) & (iv >= 0)
+            k, w, vega, iv = k[mask], w[mask], vega[mask], iv[mask]
 
-            # Apply calendar arbitrage correction
             new_params = SVIModel.correct_calendar_arbitrage(
-                params=params2, t=t2, tiv=w, vega=vega_masked, k=k_masked,
+                params=params2, t=t2, tiv=w, vega=vega, k=k,
                 prev_params=params1, prev_t=t1, k_grid=k_grid
             )
 
-            # Update the parameters dictionary
-            fit_params_dict[mat2] = (t2, new_params)
+            params_dict[mat2] = (t2, new_params)
 
-            # Extract corrected parameters
             a, b, m, rho, sigma = new_params
-
-            # Calculate scaled parameters and Jump-Wing parameters
             a_scaled, b_scaled = a * t2, b * t2
             nu, psi, p, c, nu_tilde = SVIModel.raw_to_jw_params(a_scaled, b_scaled, m, rho, sigma, t2)
 
-            # Calculate model predictions for statistics
-            w_model = np.array([SVIModel.svi_raw(x, a_scaled, b_scaled, m, rho, sigma) for x in k_masked])
+            # Recompute fit statistics
+            w_model = np.array([SVIModel.svi_raw(x, a_scaled, b_scaled, m, rho, sigma) for x in k])
             iv_model = np.sqrt(w_model / t2)
-            iv_market = iv_masked
-
-            # Calculate statistics
+            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))
 
-            # Calculate minimum strike
+            # Recompute min strike
             log_min_strike = SVIModel.svi_min_strike(sigma, rho, m)
-            usd_min_strike = s * np.exp(-log_min_strike)
+            usd_min_strike = np.exp(log_min_strike) * s
 
-            # Check butterfly arbitrage
+            # Update butterfly arbitrage check
             butterfly_arbitrage_free = True
-            k_range = np.linspace(min(k_masked), max(k_masked), domain_params[2])
+            k_range = np.linspace(min(k), max(k), domain_params[2])
+            w_k = lambda k: SVIModel.svi_raw(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 = SVIModel.svi_raw(k_val, a_scaled, b_scaled, m, rho, sigma)
-                wp = SVIModel.svi_d(k_val, a_scaled, b_scaled, m, rho, sigma)
-                wpp = SVIModel.svi_dd(k_val, a_scaled, b_scaled, m, rho, sigma)
+                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
 
-            # Update results in the DataFrame
-            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, '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'] = bool(butterfly_arbitrage_free)
-            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)
-
-            logger.info(
-                f"SVI parameters for {idx}: a={a_scaled:.4f}, b={b_scaled:.4f}, sigma={sigma:.4f}, rho={rho:.4f}, m={m:.4f}")
+            # 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
 
-        # Check calendar arbitrage after correction
+            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))
+
+        # 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]
-            t1, params1 = fit_params_dict[mat1]
-            t2, params2 = fit_params_dict[mat2]
-            a1, b1, sigma1, rho1, m1 = params1
-            a2, b2, sigma2, rho2, m2 = params2
+            t1, params1 = params_dict[mat1]
+            t2, params2 = params_dict[mat2]
+            a1, b1, m1, rho1, sigma1 = params1
+            a2, b2, m2, rho2, sigma2 = params2
 
             if np.isnan(a1) or np.isnan(a2):
                 continue
 
-            # Check arbitrage on a grid of points
-            for k_val in k_grid:
+            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]), domain_params[2])]))
+
+            for k_val in k_check:
                 w1 = SVIModel.svi_raw(k_val, a1 * t1, b1 * t1, m1, rho1, sigma1)
                 w2 = SVIModel.svi_raw(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}")
                     calendar_arbitrage_free = False
-                    logger.warning(f"Calendar arbitrage still detected between {mat1} and {mat2} after correction")
                     break
+            if not calendar_arbitrage_free:
+                break
 
-        # Update results with final calendar arbitrage status
-        for i, maturity_name in enumerate(maturity_names):
-            maturity_date = results_df.iloc[i]['maturity_date']
-            idx = results_df.index[i]
-            results_df.at[idx, 'calendar_arbitrage_free'] = calendar_arbitrage_free
+        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
 
     logger.info("Model fitting complete.")
     return results_df

voly/formulas.py

@@ -8,7 +8,6 @@ from scipy.stats import norm
 from py_vollib.black_scholes.implied_volatility import implied_volatility
 from typing import Tuple, Dict, Union, List, Optional
 from voly.utils.logger import catch_exception
-from voly.models import SVIModel
 from typing import Tuple
 
 

voly/models.py

@@ -4,16 +4,12 @@ Volatility models for the Voly package.
 
 import numpy as np
 from numpy.linalg import solve
-from scipy.optimize import minimize
 from typing import Tuple, Dict, List, Optional, Union
 
 
 class SVIModel:
     """
     Stochastic Volatility Inspired (SVI) model.
-
-    This class provides methods for calculating implied volatility using the
-    SVI parameterization, as well as its derivatives and related functions.
     """
 
     # Parameter names for reference
@@ -36,31 +32,9 @@ class SVIModel:
 
     @staticmethod
     def svi_raw(k, a, b, m, rho, sigma):
-        """
-        Calculate SVI total implied variance using raw parameterization.
-        This is the original function name from the user's code.
-        """
         assert b >= 0 and abs(rho) <= 1 and sigma >= 0 and a + b * sigma * np.sqrt(1 - rho ** 2) >= 0
         return a + b * (rho * (k - m) + np.sqrt((k - m) ** 2 + sigma ** 2))
 
-    @staticmethod
-    def svi(LM: float, a: float, b: float, m: float, rho: float, sigma: float) -> float:
-        """
-        Calculate SVI total implied variance at a given log-moneyness.
-        This version maintains compatibility with the original Voly package.
-        """
-        return a + b * (rho * (LM - m) + np.sqrt((LM - m) ** 2 + sigma ** 2))
-
-    @staticmethod
-    def svi_d(LM: float, a: float, b: float, m: float, rho: float, sigma: float) -> float:
-        """Calculate first derivative of SVI function with respect to log-moneyness."""
-        return b * (rho + ((LM - m) / np.sqrt((LM - m) ** 2 + sigma ** 2)))
-
-    @staticmethod
-    def svi_dd(LM: float, a: float, b: float, m: float, rho: float, sigma: float) -> float:
-        """Calculate second derivative of SVI function with respect to log-moneyness."""
-        return b * sigma ** 2 / ((LM - m) ** 2 + sigma ** 2) ** 1.5
-
     @staticmethod
     def svi_min_strike(sigma: float, rho: float, m: float) -> float:
         """Calculate the minimum valid log-strike for this SVI parameterization."""
@@ -69,6 +43,7 @@ class SVIModel:
     @staticmethod
     def raw_to_jw_params(a: float, b: float, m: float, rho: float, sigma: float, t: float) -> Tuple[
         float, float, float, float, float]:
+        """Convert raw SVI parameters to Jump-Wing parameters."""
         nu = (a + b * ((-rho) * m + np.sqrt(m ** 2 + sigma ** 2))) / t
         psi = (1 / np.sqrt(nu * t)) * (b / 2) * (rho - (m / np.sqrt(m ** 2 + sigma ** 2)))
         p = (1 / np.sqrt(nu * t)) * b * (1 - rho)
@@ -78,20 +53,6 @@ class SVIModel:
 
     @classmethod
     def calibration(cls, tiv, vega, k, m, sigma):
-        """
-        Calibrate SVI parameters using a more stable approach.
-
-        Parameters:
-        - tiv: Total implied variance values
-        - vega: Option vega values (for weighting)
-        - k: Log-moneyness values
-        - m: Horizontal shift parameter
-        - sigma: Convexity parameter
-
-        Returns:
-        - c, d, a: Calibrated parameters
-        - loss: Calibration loss value
-        """
         sigma = max(sigma, 0.001)
         vega = vega / vega.max() if vega.max() > 0 else np.ones_like(vega)
         y = (k - m) / sigma
@@ -118,28 +79,16 @@ class SVIModel:
 
     @staticmethod
     def loss(tiv, vega, y, c, d, a):
-        """Calculate weighted loss for SVI calibration."""
         diff = tiv - (a + d * y + c * np.sqrt(y * y + 1))
         return (vega * diff * diff).mean()
 
     @classmethod
     def fit(cls, tiv, vega, k, tau=1.0):
-        """
-        Fit SVI model to market data using a more stable two-step approach.
-
-        Parameters:
-        - tiv: Total implied variance values
-        - vega: Option vega values (for weighting)
-        - k: Log-moneyness values
-        - tau: Time to expiry in years
-
-        Returns:
-        - params: [a, b, m, rho, sigma] parameters
-        - loss: Fitting loss value
-        """
         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)
@@ -168,55 +117,41 @@ class SVIModel:
 
     @classmethod
     def correct_calendar_arbitrage(cls, params, t, tiv, vega, k, prev_params, prev_t, k_grid):
-        """
-        Correct calendar arbitrage by ensuring the current SVI surface stays above the previous one.
-
-        Parameters:
-        - params: Current SVI parameters [a, b, sigma, rho, m]
-        - t: Current time to expiry
-        - tiv: Current total implied variance values
-        - vega: Current vega values
-        - k: Current log-moneyness values
-        - prev_params: Previous SVI parameters
-        - prev_t: Previous time to expiry
-        - k_grid: Grid of log-moneyness values for arbitrage checking
-
-        Returns:
-        - New arbitrage-free parameters
-        """
-
         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))]))
 
         def objective(x):
             a, b, m, rho, sigma = x
-            w_model = cls.svi(k, a * t, b * t, m, rho, sigma)
-            fit_loss = ((w_model - tiv) ** 2 * vega).mean()
-            param_deviation = sum(((x[i] - params[i]) / max(abs(params[i]), 1e-6)) ** 2
-                                  for i in range(len(params)))
+            w_model = cls.svi_raw(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]))
             return fit_loss + 0.01 * param_deviation
 
         def calendar_constraint(x):
-            a, b, sigma, rho, m = x
-            w_current = cls.svi(k_constraint, a * t, b * t, sigma, rho, m)
-            w_prev = cls.svi(k_constraint, a_prev * prev_t, b_prev * prev_t, sigma_prev, rho_prev, m_prev)
+            a, b, m, rho, sigma = x
+            w_current = cls.svi_raw(k_constraint, a * t, b * t, m, rho, sigma)
+            w_prev = cls.svi_raw(k_constraint, a_prev * prev_t, b_prev * prev_t, m_prev, rho_prev, sigma_prev)
             return w_current - w_prev
 
         bounds = [
             (max(a_init * 0.8, 1e-6), a_init * 1.2),
             (max(b_init * 0.8, 0), b_init * 1.2),
-            (max(sigma_init * 0.8, 1e-6), sigma_init * 1.2),
+            (m_init - 0.05, m_init + 0.05),
             (max(rho_init - 0.05, -1), min(rho_init + 0.05, 1)),
-            (m_init - 0.05, m_init + 0.05)
+            (max(sigma_init * 0.8, 1e-6), sigma_init * 1.2)
         ]
 
         constraints = [
             {'type': 'ineq', 'fun': calendar_constraint},
-            {'type': 'ineq', 'fun': lambda x: x[0] + x[1] * x[2] * np.sqrt(1 - x[3] ** 2)}
+            {'type': 'ineq', 'fun': lambda x: x[0] + x[1] * x[4] * np.sqrt(1 - x[3] ** 2)}
         ]
 
         result = minimize(
@@ -226,8 +161,14 @@ class SVIModel:
         )
 
         if result.success:
-            return result.x
-
+            new_params = result.x
+            w_current = cls.svi_raw(k_constraint, new_params[0] * t, new_params[1] * t, *new_params[2:])
+            w_prev = cls.svi_raw(k_constraint, a_prev * prev_t, b_prev * prev_t, m_prev, rho_prev, sigma_prev)
+            violation = np.min(w_current - w_prev)
+            print(f"Calendar arbitrage correction {'successful' if violation >= -1e-6 else 'failed'} for t={t:.4f}, "
+                  f"min margin={violation:.6f}")
+            return new_params
+        print(f"Calendar arbitrage correction failed for t={t:.4f}")
         return params
 
 

{voly-0.0.177.dist-info → voly-0.0.178.dist-info}/METADATA

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

{voly-0.0.177.dist-info → voly-0.0.178.dist-info}/RECORD

@@ -1,20 +1,20 @@
 voly/__init__.py,sha256=8xyDk7rFCn_MOD5hxuv5cxxKZvBVRiSIM7TgaMPpwpw,211
-voly/client.py,sha256=6e9cX5JWeqoTIktKlT4yEN9FG5Cj8Icl7gHxhVayi24,14464
+voly/client.py,sha256=Ge0-aBvKd32aHqMCaA1xgxOS_Z-bi4neYYAGil89A6I,14595
 voly/exceptions.py,sha256=PBsbn1vNMvKcCJwwJ4lBO6glD85jo1h2qiEmD7ArAjs,92
-voly/formulas.py,sha256=eDPw32xa3dwCIrE-zeZzznfGaplGFoVcA167uQngZ70,11209
-voly/models.py,sha256=tg-u_6hnY9VQPIjoWfnJBIZRNAxNo1MRKHl0HcaaQQw,8908
+voly/formulas.py,sha256=JnEs6G0wlfRNH6X_YEJMe2RtLH-ryhzufjsim73Bj3c,11176
+voly/models.py,sha256=ydfhdCELDsoFJF9VKq8bnRiO2lRsmC3iQGo9Jx_jjVc,7018
 voly/core/__init__.py,sha256=bu6fS2I1Pj9fPPnl-zY3L7NqrZSY5Zy6NY2uMUvdhKs,183
 voly/core/charts.py,sha256=2S-BfCo30aj1_xlNLqF-za5rQWxF_mWKIdtdOe5bgbw,12735
 voly/core/data.py,sha256=9v9iuE2XdIIlzoRAB7q1ol7YghBzBsPGAiwZ11oDuis,13650
-voly/core/fit.py,sha256=Aafqzwdlq1wDh5BI-yT3nDI4e2Qegp0fROr4JtnwBeg,17739
+voly/core/fit.py,sha256=eYTXkoSZIdHYgjW1GQ-qD4Qe3DsZVfuMzmv1Gj_yJfY,18218
 voly/core/hd.py,sha256=UFAyLncNUHivpPAcko6IK1bC55mudVtdlRFfXp63HXE,14771
 voly/core/interpolate.py,sha256=JkK172-FXyhesW3hY4pEeuJWG3Bugq7QZXbeKoRpLuo,5305
 voly/core/rnd.py,sha256=GoC3m1Q46Wnk5tV_mstr-3_aktHeue6BBLh4DQTciW0,13307
 voly/utils/__init__.py,sha256=E05mWatyC-PDOsCxQV1p5Xi1IgpOomxrNURyCx_gB-w,200
 voly/utils/density.py,sha256=q0fX4im9TGwMCZ32Hzdv8CNh56KnJo8bmG5w0gVWZH8,5879
 voly/utils/logger.py,sha256=4-_2bVJmq17Q0d7Rd2mPg1AeR8gxv6EPvcmBDMFWcSM,1744
-voly-0.0.177.dist-info/licenses/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
-voly-0.0.177.dist-info/METADATA,sha256=1FxR4996NiRdwMgQAfjcb5yjBvvfR9Fw3XJXI9mmWNY,4115
-voly-0.0.177.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-voly-0.0.177.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
-voly-0.0.177.dist-info/RECORD,,
+voly-0.0.178.dist-info/licenses/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
+voly-0.0.178.dist-info/METADATA,sha256=_NfVcF39Ez-Ytgo5sP1fxpujPIUzhASwcRjmrNCY9S4,4115
+voly-0.0.178.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+voly-0.0.178.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
+voly-0.0.178.dist-info/RECORD,,