lambda-guard-boosting 0.2.2__tar.gz → 0.2.4__tar.gz

{lambda_guard_boosting-0.2.2 → lambda_guard_boosting-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda-guard-boosting
-Version: 0.2.2
+Version: 0.2.4
 Summary: Overfitting detection for Gradient Boosting models using λ-Guard methodology.
 Author-email: "Fabrizio Di Sciorio, PhD" <fabriziodisciorio91@gmail.com>
 License: MIT
@@ -42,7 +42,7 @@ Dynamic: license-file
   <a href="https://coveralls.io/github/faberBI/lambdaguard">
     <img src="https://img.shields.io/coveralls/github/faberBI/lambdaguard/main.svg" alt="Coverage Status">
   </a>
-  <a href="https://pypi.org/project/lambdaguard/">
+  <a href="https://pypi.org/project/lambda-guard-boosting/">
     <img src="https://img.shields.io/pypi/v/lambdaguard?logo=python" alt="PyPI Version">
   </a>
   <a href="https://opensource.org/licenses/MIT">
@@ -194,17 +194,18 @@ Install via GitHub:
 pip install git+https://github.com/faberBI/lambdaguard.git
 
 from sklearn.ensemble import GradientBoostingRegressor
-from lambdaguard.ofi import overfitting_index
+from lambdaguard.ofi import generalization_index, instability_index, 
 from lambdaguard.lambda_guard import lambda_guard_test, interpret
-from lambdaguard.cusum import detect_structural_overfitting_cusum_robust
+from lambdaguard.cusum import lambda_detect
 import pandas as pd
 
 # Fit a model
 model = GradientBoostingRegressor(n_estimators=50, max_depth=3)
 model.fit(X_train, y_train)
 
-# Compute Overfitting Index
-ofi_res = overfitting_index(model, X_train, y_train)
+# Generalization index
+GI, A, C = overfitting_index(model, X_train, y_train)
+print('Generalization index: ", GI)
 
 # Lambda-guard test
 lg_res = lambda_guard_test(model, X_train)
@@ -215,7 +216,16 @@ df = pd.DataFrame([
     {"model": "GBR", "n_estimators": 50, "max_depth": 3, "A": 0.8, "OFI_norm": 0.2},
     {"model": "GBR", "n_estimators": 100, "max_depth": 5, "A": 0.85, "OFI_norm": 0.3},
 ])
-cusum_res = detect_structural_overfitting_cusum_robust(df, model_name="GBR")
+cusum_res = lambda_detect(
+    df,
+    model_name,
+    complexity_metric="combined",
+    lambda_col="OFI_norm",
+    alignment_col="A",
+    smooth_window=3,
+    cusum_threshold_factor=1.5,
+    baseline_points=10
+)
 
 ```
 

{lambda_guard_boosting-0.2.2 → lambda_guard_boosting-0.2.4}/README.md

@@ -14,7 +14,7 @@
   <a href="https://coveralls.io/github/faberBI/lambdaguard">
     <img src="https://img.shields.io/coveralls/github/faberBI/lambdaguard/main.svg" alt="Coverage Status">
   </a>
-  <a href="https://pypi.org/project/lambdaguard/">
+  <a href="https://pypi.org/project/lambda-guard-boosting/">
     <img src="https://img.shields.io/pypi/v/lambdaguard?logo=python" alt="PyPI Version">
   </a>
   <a href="https://opensource.org/licenses/MIT">
@@ -166,17 +166,18 @@ Install via GitHub:
 pip install git+https://github.com/faberBI/lambdaguard.git
 
 from sklearn.ensemble import GradientBoostingRegressor
-from lambdaguard.ofi import overfitting_index
+from lambdaguard.ofi import generalization_index, instability_index, 
 from lambdaguard.lambda_guard import lambda_guard_test, interpret
-from lambdaguard.cusum import detect_structural_overfitting_cusum_robust
+from lambdaguard.cusum import lambda_detect
 import pandas as pd
 
 # Fit a model
 model = GradientBoostingRegressor(n_estimators=50, max_depth=3)
 model.fit(X_train, y_train)
 
-# Compute Overfitting Index
-ofi_res = overfitting_index(model, X_train, y_train)
+# Generalization index
+GI, A, C = overfitting_index(model, X_train, y_train)
+print('Generalization index: ", GI)
 
 # Lambda-guard test
 lg_res = lambda_guard_test(model, X_train)
@@ -187,7 +188,16 @@ df = pd.DataFrame([
     {"model": "GBR", "n_estimators": 50, "max_depth": 3, "A": 0.8, "OFI_norm": 0.2},
     {"model": "GBR", "n_estimators": 100, "max_depth": 5, "A": 0.85, "OFI_norm": 0.3},
 ])
-cusum_res = detect_structural_overfitting_cusum_robust(df, model_name="GBR")
+cusum_res = lambda_detect(
+    df,
+    model_name,
+    complexity_metric="combined",
+    lambda_col="OFI_norm",
+    alignment_col="A",
+    smooth_window=3,
+    cusum_threshold_factor=1.5,
+    baseline_points=10
+)
 
 ```
 

{lambda_guard_boosting-0.2.2 → lambda_guard_boosting-0.2.4}/lambda_guard_boosting.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda-guard-boosting
-Version: 0.2.2
+Version: 0.2.4
 Summary: Overfitting detection for Gradient Boosting models using λ-Guard methodology.
 Author-email: "Fabrizio Di Sciorio, PhD" <fabriziodisciorio91@gmail.com>
 License: MIT
@@ -42,7 +42,7 @@ Dynamic: license-file
   <a href="https://coveralls.io/github/faberBI/lambdaguard">
     <img src="https://img.shields.io/coveralls/github/faberBI/lambdaguard/main.svg" alt="Coverage Status">
   </a>
-  <a href="https://pypi.org/project/lambdaguard/">
+  <a href="https://pypi.org/project/lambda-guard-boosting/">
     <img src="https://img.shields.io/pypi/v/lambdaguard?logo=python" alt="PyPI Version">
   </a>
   <a href="https://opensource.org/licenses/MIT">
@@ -194,17 +194,18 @@ Install via GitHub:
 pip install git+https://github.com/faberBI/lambdaguard.git
 
 from sklearn.ensemble import GradientBoostingRegressor
-from lambdaguard.ofi import overfitting_index
+from lambdaguard.ofi import generalization_index, instability_index, 
 from lambdaguard.lambda_guard import lambda_guard_test, interpret
-from lambdaguard.cusum import detect_structural_overfitting_cusum_robust
+from lambdaguard.cusum import lambda_detect
 import pandas as pd
 
 # Fit a model
 model = GradientBoostingRegressor(n_estimators=50, max_depth=3)
 model.fit(X_train, y_train)
 
-# Compute Overfitting Index
-ofi_res = overfitting_index(model, X_train, y_train)
+# Generalization index
+GI, A, C = overfitting_index(model, X_train, y_train)
+print('Generalization index: ", GI)
 
 # Lambda-guard test
 lg_res = lambda_guard_test(model, X_train)
@@ -215,7 +216,16 @@ df = pd.DataFrame([
     {"model": "GBR", "n_estimators": 50, "max_depth": 3, "A": 0.8, "OFI_norm": 0.2},
     {"model": "GBR", "n_estimators": 100, "max_depth": 5, "A": 0.85, "OFI_norm": 0.3},
 ])
-cusum_res = detect_structural_overfitting_cusum_robust(df, model_name="GBR")
+cusum_res = lambda_detect(
+    df,
+    model_name,
+    complexity_metric="combined",
+    lambda_col="OFI_norm",
+    alignment_col="A",
+    smooth_window=3,
+    cusum_threshold_factor=1.5,
+    baseline_points=10
+)
 
 ```
 

{lambda_guard_boosting-0.2.2 → lambda_guard_boosting-0.2.4}/lambdaguard/__init__.py

@@ -1,7 +1,7 @@
-__version__ = "0.2.2"
+__version__ = "0.2.3"
 
 from .ofi import generalization_index, instability_index, create_model, run_experiment_multi_model, plot_all_multi_model, regression_test
-from .lambda_guard import lambda_guard_test, boosting_leverage, interpret
+from .lambdaguard import lambda_guard_test, boosting_leverage, interpret
 from .cusum import lambda_detect
 
 __all__ = [

{lambda_guard_boosting-0.2.2 → lambda_guard_boosting-0.2.4}/lambdaguard/lambdaguard.py

@@ -50,9 +50,9 @@ def lambda_guard_test(model, X, B=300, alpha=0.05, plot=True):
 
 def interpret(res):
     if not res["reject_H0"]:
-        return "✔ REGIME STABILE / GENERALIZZANTE"
+        return "✔ STABLE REGIME"
     if res["p_df_ratio"] < 0.05 and res["p_peak_ratio"] < 0.05:
-        return "✖ REGIME INTERPOLANTE (OVERFITTING FORTE)"
+        return "✖ OVERFITTING"
     if res["p_df_ratio"] < 0.05:
-        return "✖ COMPLESSITÀ GLOBALE ECCESSIVA"
+        return "✖ HIGH COMPLEXITY"
     return "✖ (LEVERAGE SPIKES)"

{lambda_guard_boosting-0.2.2 → lambda_guard_boosting-0.2.4}/lambdaguard/ofi.py

@@ -7,6 +7,7 @@ import pandas as pd
 import seaborn as sns
 import matplotlib.pyplot as plt
 from itertools import product
+import statsmodels.api as sm
 
 from sklearn.model_selection import train_test_split
 from sklearn.metrics import mean_squared_error
@@ -21,10 +22,113 @@ from catboost import CatBoostRegressor
 # GENERALIZATION COMPONENTS
 # -----------------------------
 def generalization_index(model, X, y):
-    preds = model.predict(X)
+    """
+    Generalization Index (GI) universale per:
+    - XGBoost (Booster e sklearn API)
+    - LightGBM
+    - CatBoost
+    - sklearn GradientBoosting
+    
+    Returns:
+        GI, A (alignment), C (capacity)
+    """
+    
+    # --------------------------------------------------
+    # 1️⃣ OTTENIAMO MATRICE FOGLIE (leaf_matrix)
+    # --------------------------------------------------
+    
+    leaf_matrix = None
+    preds = None
+    
+    # ----------------------------
+    # XGBOOST - Booster nativo
+    # ----------------------------
+    if hasattr(model, "predict") and hasattr(model, "get_booster") is False and "xgboost" in str(type(model)).lower():
+        try:
+            import xgboost as xgb
+            dmatrix = xgb.DMatrix(X)
+            leaf_matrix = model.predict(dmatrix, pred_leaf=True)
+            preds = model.predict(dmatrix)
+        except:
+            pass
+
+    # ----------------------------
+    # XGBOOST - sklearn API
+    # ----------------------------
+    if leaf_matrix is None and hasattr(model, "get_booster"):
+        leaf_matrix = model.apply(X)
+        preds = model.predict(X)
+
+    # ----------------------------
+    # LIGHTGBM
+    # ----------------------------
+    if leaf_matrix is None and "lightgbm" in str(type(model)).lower():
+        leaf_matrix = model.predict(X, pred_leaf=True)
+        preds = model.predict(X)
+
+    # ----------------------------
+    # CATBOOST
+    # ----------------------------
+    if leaf_matrix is None and "catboost" in str(type(model)).lower():
+        leaf_matrix = model.calc_leaf_indexes(X)
+        preds = model.predict(X)
+
+    # ----------------------------
+    # SKLEARN GradientBoosting
+    # ----------------------------
+    if leaf_matrix is None and hasattr(model, "estimators_"):
+        leaf_list = []
+        for est in model.estimators_.ravel():
+            leaf_list.append(est.apply(X))
+        leaf_matrix = np.column_stack(leaf_list)
+        preds = model.predict(X)
+
+    # Se ancora None → errore
+    if leaf_matrix is None:
+        raise ValueError("Modello non supportato per GI computation")
+
+    # --------------------------------------------------
+    # 2️⃣ GARANTIAMO MATRICE 2D
+    # --------------------------------------------------
+    leaf_matrix = np.array(leaf_matrix)
+    if leaf_matrix.ndim == 1:
+        leaf_matrix = leaf_matrix.reshape(-1, 1)
+
+    # --------------------------------------------------
+    # 3️⃣ COSTRUZIONE MATRICE Z
+    # --------------------------------------------------
+    Z_cols = []
+
+    for t in range(leaf_matrix.shape[1]):
+        leaf_ids = leaf_matrix[:, t]
+        unique_leaves = np.unique(leaf_ids)
+
+        for leaf in unique_leaves:
+            Z_cols.append((leaf_ids == leaf).astype(float))
+
+    if len(Z_cols) == 0:
+        return 0, 0, 0
+
+    Z = np.column_stack(Z_cols)
+
+    # --------------------------------------------------
+    # 4️⃣ CAPACITY
+    # --------------------------------------------------
+    C = np.var(Z)
+
+    # --------------------------------------------------
+    # 5️⃣ ALIGNMENT
+    # --------------------------------------------------
+    if preds is None:
+        preds = model.predict(X)
+
     A = np.corrcoef(preds, y)[0, 1] if np.std(preds) > 0 else 0
-    C = np.var(preds)
+
+    # --------------------------------------------------
+    # 6️⃣ GENERALIZATION INDEX
+    # --------------------------------------------------
     GI = A / C if C > 0 else 0
+
     return GI, A, C
 
 def instability_index(model, X, noise_std=1e-3, seed=42):

{lambda_guard_boosting-0.2.2 → lambda_guard_boosting-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lambda-guard-boosting"
-version = "0.2.2"
+version = "0.2.4"
 description = "Overfitting detection for Gradient Boosting models using λ-Guard methodology."
 readme = "README.md"
 license = {text = "MIT"}