wrapshap 0.1.1__tar.gz → 0.1.2__tar.gz

{wrapshap-0.1.1/wrapshap.egg-info → wrapshap-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wrapshap
-Version: 0.1.1
+Version: 0.1.2
 Summary: SHAP-based feature selection and exploration for high-dimensional data
 Home-page: https://github.com/fefurger/wrapshap
 Author: Félix Furger
@@ -22,7 +22,7 @@ Requires-Dist: lightgbm>=4.6.0
 Requires-Dist: seaborn>=0.13.2
 Requires-Dist: matplotlib>=3.8.4
 Provides-Extra: gpu
-Requires-Dist: tensorflow>=2.16.1; extra == "gpu"
+Requires-Dist: tensorflow<=2.20,>=2.16.1; extra == "gpu"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{wrapshap-0.1.1 → wrapshap-0.1.2}/setup.py

@@ -6,7 +6,7 @@ README = Path(__file__).parent / "README_PyPI.md"
 
 setup(
     name='wrapshap',
-    version='0.1.1',
+    version='0.1.2',
     author='Félix Furger',
     author_email='fefurger@hotmail.com',
     description='SHAP-based feature selection and exploration for high-dimensional data',
@@ -27,7 +27,7 @@ setup(
     ],
     extras_require={
         'gpu': [
-            'tensorflow>=2.16.1'
+            'tensorflow>=2.16.1, <=2.20'
         ]
     },
     license="Apache-2.0",

{wrapshap-0.1.1 → wrapshap-0.1.2}/wrapshap/_internal/_already_wrapped.py

@@ -132,7 +132,7 @@ class WrappedXGB(ABC):
         self.shap_test = self.model.predict(xgb.DMatrix(self.X_test, self.y_test), pred_contribs=True)[:,:-1]
 
     @wrapshap_required('wrapshap')
-    def shapRFE(self, surrogate_metrics: bool = False, top: int = None):
+    def shapRFE(self, surrogate_metrics: bool = False, top: int = None, plot:bool = True,time_info:bool = False):
         """
         Simply calls Wrapshap implementation of Recursive Feature Elimination (RFE). 
 
@@ -149,11 +149,13 @@ class WrappedXGB(ABC):
         return self.wrapshap.shapRFE(
             surrogate_metrics=surrogate_metrics,
             top=top,
+            plot = plot,
+            time_info=time_info
         )
     
     
     @wrapshap_required('wrapshap')
-    def shapFFS(self, surrogate_metrics: bool = False, top: int = None):
+    def shapFFS(self, surrogate_metrics: bool = False, top: int = None, plot:bool = True,time_info:bool = True):
         """
         Simply calls Wrapshap implementation of Forward Feature Selection (FFS). 
 
@@ -170,11 +172,13 @@ class WrappedXGB(ABC):
         return self.wrapshap.shapFFS(
             surrogate_metrics=surrogate_metrics,
             top=top,
+            plot = plot,
+            time_info=time_info
         )
     
 
     @wrapshap_required('wrapshap')
-    def shapBFE(self, surrogate_metrics: bool = False, top: int = None):
+    def shapBFE(self, surrogate_metrics: bool = False, top: int = None, plot:bool = True, time_info:bool=False):
         """
         Simply calls Wrapshap implementation of Forward Feature Selection (BFE). 
 
@@ -191,6 +195,8 @@ class WrappedXGB(ABC):
         return self.wrapshap.shapBFE(
             surrogate_metrics=surrogate_metrics,
             top=top,
+            plot = plot,
+            time_info = time_info
         )
     
 

{wrapshap-0.1.1 → wrapshap-0.1.2}/wrapshap/_internal/_already_wrapped_LGB.py

@@ -146,7 +146,7 @@ class WrappedLGB(ABC):
         self.shap_test = shap_test
         
     @wrapshap_required('wrapshap')
-    def shapRFE(self, surrogate_metrics: bool = False, top: int = None):
+    def shapRFE(self, surrogate_metrics: bool = False, top: int = None, plot:bool = True, time_info:bool = False):
         """
         Simply calls Wrapshap implementation of Recursive Feature Elimination (RFE). 
 
@@ -163,11 +163,13 @@ class WrappedLGB(ABC):
         return self.wrapshap.shapRFE(
             surrogate_metrics=surrogate_metrics,
             top=top,
+            plot = plot,
+            time_info = time_info
         )
     
     
     @wrapshap_required('wrapshap')
-    def shapFFS(self, surrogate_metrics: bool = False, top: int = None):
+    def shapFFS(self, surrogate_metrics: bool = False, top: int = None, plot:bool = True, time_info:bool = True):
         """
         Simply calls Wrapshap implementation of Forward Feature Selection (FFS). 
 
@@ -184,11 +186,13 @@ class WrappedLGB(ABC):
         return self.wrapshap.shapFFS(
             surrogate_metrics=surrogate_metrics,
             top=top,
+            plot = plot,
+            time_info=time_info
         )
     
 
     @wrapshap_required('wrapshap')
-    def shapBFE(self, surrogate_metrics: bool = False, top: int = None):
+    def shapBFE(self, surrogate_metrics: bool = False, top: int = None, plot:bool = True,time_info:bool = False):
         """
         Simply calls Wrapshap implementation of Forward Feature Selection (BFE). 
 
@@ -205,6 +209,8 @@ class WrappedLGB(ABC):
         return self.wrapshap.shapBFE(
             surrogate_metrics=surrogate_metrics,
             top=top,
+            plot=plot,
+            time_info=time_info
         )
     
 
@@ -565,4 +571,4 @@ def _plot_regression_metrics(y_train, y_test, y_train_pred, y_test_pred):
     ax[1].set_ylabel('Predictions')
     ax[1].set_title(f'Test Set: R2 = {test_r2:.2f}, MAE = {test_mae:.2f}')
 
-    plt.show()
+    plt.show()

{wrapshap-0.1.1 → wrapshap-0.1.2}/wrapshap/_internal/_wrapshap.py

@@ -14,6 +14,8 @@ from sklearn.preprocessing import StandardScaler
 from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score
 from sklearn.metrics import r2_score, mean_absolute_error
 from scipy.special import expit
+import matplotlib.pyplot as plt
+from time import time
 
 # ----------------------------------------------------------------------------------------------------------------------
 # Public API - These utilities are used by other modules and re-exported.
@@ -26,7 +28,9 @@ def shapRFE(
         feature_names: list,
         surrogate_metrics: bool = False,
         top: int = None,
-        task_type: str = 'classification'
+        task_type: str = 'classification',
+        plot : bool = True,
+        time_info : bool = False
 ) -> tuple:
     """
     Wrapshap implementation of Recursive Feature Elimination (RFE). 
@@ -62,7 +66,7 @@ def shapRFE(
     shap_test_normalized = scaler.transform(shap_test)
 
     _progress_bar(0, len(feature_names), mode='ascending')
-
+    start_time = time()
     while remaining_features:
 
         model = LinearRegression()
@@ -85,6 +89,8 @@ def shapRFE(
             results[len(remaining_features)][f'test_{key}'] = metrics_test[key]
         for key in metrics_train:
             results[len(remaining_features)][f'train_{key}'] = metrics_train[key]
+            
+        results[len(remaining_features)]['time']=time() - start_time
 
         min_importance_index = np.argmin(np.abs(model.coef_))
         removed_feature = remaining_features.pop(min_importance_index)
@@ -93,6 +99,9 @@ def shapRFE(
         _progress_bar(len(removed_features), len(feature_names), mode='ascending')
 
     removed_features.reverse()
+    
+    if plot :
+        _plot_performance(results, time_info)
     return removed_features, results
 
 
@@ -102,7 +111,9 @@ def shapFFS(
         feature_names: list,
         surrogate_metrics: bool = False,
         top: int = None,
-        task_type: str = 'classification'
+        task_type: str = 'classification',
+        plot: bool = True,
+        time_info: bool = True
 ) -> tuple:
     """
     Wrapshap implementation of Forward Feature Selection (FFS). 
@@ -133,6 +144,7 @@ def shapFFS(
     results = {}
 
     _progress_bar(0, len(feature_names), mode='ascending')
+    start_time = time()
 
     while len(selected_features) < n_features:
         best_score = float('-inf')
@@ -164,6 +176,7 @@ def shapFFS(
                         best_metrics[f'test_{key}'] = metrics_test[key]
                     for key in metrics_train:
                         best_metrics[f'train_{key}'] = metrics_train[key]
+                    best_metrics['time']=time() - start_time
 
 
         selected_features.append(best_feature)
@@ -181,6 +194,8 @@ def shapFFS(
             top=top,
             task_type=task_type
         )
+    if plot :
+        _plot_performance(results, time_info)
 
     return selected_features, results
 
@@ -191,7 +206,9 @@ def shapBFE(
         feature_names: list,
         surrogate_metrics: bool = False,
         top: int = None,
-        task_type: str = 'classification'
+        task_type: str = 'classification',
+        plot: bool = True,
+        time_info: bool = False
 ) -> tuple:
     """
     Wrapshap implementation of Backward Feature Elimination (BFE). 
@@ -222,10 +239,11 @@ def shapBFE(
     results = {}
 
     _progress_bar(0, len(feature_names), mode='ascending')
+    start_time = time()
 
     model = LinearRegression()
     model.fit(shap_train, y_pred_train)
-
+    
     lnr_predictions_train = model.predict(shap_train)
     lnr_predictions_test = model.predict(shap_test)
 
@@ -237,9 +255,9 @@ def shapBFE(
         results[len(selected_features)][f'test_{key}'] = metrics_test[key]
     for key in metrics_train:
         results[len(selected_features)][f'train_{key}'] = metrics_train[key]
-    
-    _progress_bar(1, len(feature_names), mode='ascending')
+    results[len(selected_features)]['time'] = time() - start_time
 
+    _progress_bar(1, len(feature_names), mode='ascending')
     while len(selected_features) > 1:
         worst_score = float('-inf')
         worst_feature = None
@@ -267,6 +285,8 @@ def shapBFE(
                     worst_metrics[f'test_{key}'] = metrics_test[key]
                 for key in metrics_train:
                     worst_metrics[f'train_{key}'] = metrics_train[key]
+                worst_metrics['time'] = time() - start_time
+
 
         selected_features.remove(worst_feature)
         removed_features.append(worst_feature)
@@ -287,6 +307,8 @@ def shapBFE(
             top=top,
             task_type=task_type
         )
+    if plot :
+        _plot_performance(results, time_info)
 
     return removed_features, results
 
@@ -318,6 +340,7 @@ def get_surrogate_metrics(
     """
     
     _progress_bar(0, len(feature_ranking), mode='ascending', suffix='Complete (surrogate metrics computation)')
+    start_time = time()
     for i in range(1, len(feature_ranking)+1):
 
         model = LinearRegression()
@@ -339,6 +362,8 @@ def get_surrogate_metrics(
             metrics_dict[i][f'test_{key}'] = metrics_test[key]
         for key in metrics_train:
             metrics_dict[i][f'train_{key}'] = metrics_train[key]
+            metrics_dict[i]['time'] = time() - start_time
+
         _progress_bar(i, len(feature_ranking), mode='ascending', suffix='Complete (surrogate metrics computation)')
     
     return metrics_dict
@@ -404,4 +429,97 @@ def _calculate_metrics(y_true, lnr_predictions, model_predictions, task_type, su
     if surrogate:
         metrics = _surrogate_metrics(y_true, lnr_predictions, task_type, metrics)
     
-    return metrics
+    return metrics
+
+def _plot_performance(perfs, time_info = True):
+    n_features_list = []
+    r2_list         = []
+    time_list       = []
+    
+    alpha = 1
+    beta= 0.2
+    
+    
+    for n_feat, values in perfs.items():
+        n_features_list.append(int(n_feat))
+        for metric, value in values.items():
+            if metric == 'test_pred_r2':
+                r2_list.append(value)
+            if metric == 'time':
+                time_list.append(value)
+    
+    # Trier par nombre de features
+    order        = np.argsort(n_features_list)
+    n_features   = np.array(n_features_list)[order]
+    r2_scores    = np.array(r2_list)[order]
+    time_scores  = np.array(time_list)[order]
+        
+    def normalize(x):
+        x = np.array(x, dtype=float)
+        return (x - x.min()) / (x.max() - x.min() + 1e-9)
+    
+    #r2_norm = normalize(r2_scores)          # on veut maximiser -> reste tel quel
+    nf_norm = normalize(n_features)         # on veut minimiser
+    time_norm = normalize(time_scores)      # on veut minimiser
+    
+    fig, ax = plt.subplots(figsize=(8, 4))
+    fs_scores = []
+    for nf, r2, t in zip(nf_norm, r2_scores, time_norm):
+        fs_scores.append((r2*alpha - beta*nf))
+    
+    fs_scores = np.array(fs_scores)
+    # -------------------------------------------------------
+    # AXE 1 — R²
+    # -------------------------------------------------------
+    
+    ax.plot(n_features, r2_scores,
+            color='steelblue', linewidth=2,
+            marker='o', markersize=5, zorder=3, label='Test R²', )
+    ax.fill_between(n_features, r2_scores, alpha=0.08, color='steelblue')
+    
+    best_idx = np.argmax(fs_scores)
+    ax.scatter(n_features[best_idx], r2_scores[best_idx],
+               color='steelblue', zorder=4, s=60, marker='D',
+               label=f'FS_score={fs_scores[best_idx]:.3f} ({n_features[best_idx]} features)')
+    
+    ax.set_xlabel('Number of selected features', fontsize=12)
+    ax.set_ylabel('Test R²', fontsize=12, color='black')
+    ax.tick_params(axis='y', labelcolor='black', labelsize = 8)
+    ax.spines['top'].set_visible(False)
+    
+    # -------------------------------------------------------
+    # AXE 2 — Computation time
+    # -------------------------------------------------------
+    if time_info :
+        ax2 = ax.twinx()  # partage le même axe x
+        ax2.plot(n_features, time_scores,
+                 color='coral', linewidth=2, linestyle='--',
+                 marker='s', markersize=4, zorder=2, label='Cumulative computation time')
+        
+        ax2.set_ylabel('Cumulative computation time (s)', fontsize=12, color='black')
+        ax2.tick_params(axis='y', labelcolor='black', labelsize = 8)
+        ax2.spines['top'].set_visible(False)
+    
+    # -------------------------------------------------------
+    # LÉGENDE COMBINÉE
+    # -------------------------------------------------------
+    
+    lines1, labels1 = ax.get_legend_handles_labels()
+    if time_info == True :
+        lines2, labels2 = ax2.get_legend_handles_labels()
+        ax.legend(lines1 + lines2, labels1 + labels2, fontsize = 10, framealpha=0.5, loc ='lower right' )
+    else :
+        ax.legend(lines1, labels1, fontsize = 10, framealpha=0.5, loc ='lower right' )
+    
+    ax.set_title('Feature selection — performance vs. parsimony trade-off',
+                 fontsize=12)
+    if len(n_features) > 25:
+        ax.set_xticks(n_features[::2])
+        ax.set_xticklabels(n_features[::2], rotation=45, fontsize=10)
+    if len(n_features) <= 25:
+        ax.set_xticks(n_features)
+        ax.set_xticklabels(n_features, rotation=45, fontsize=10)
+    ax.tick_params(labelsize=10)
+    
+    plt.tight_layout()
+    plt.show()

{wrapshap-0.1.1 → wrapshap-0.1.2}/wrapshap/already_wrapped.py

@@ -1,2 +1,2 @@
 from ._internal._already_wrapped import WrappedBinaryClassifierXGB, WrappedRegressorXGB
-from ._internal._already_wrapped_LGB import WrappedBinaryClassifierLGB, WrappedRegressorLGB
+from ._internal._already_wrapped_LGB import WrappedBinaryClassifierLGB, WrappedRegressorLGB

wrapshap-0.1.2/wrapshap/gpu_implementation/__init__.py

@@ -0,0 +1 @@
+from .wrapshap_gpu import WrapshapGPU, print_XFFS_tree, plot_XFFS_tree

{wrapshap-0.1.1 → wrapshap-0.1.2}/wrapshap/gpu_implementation/_internal/_already_wrapped_gpu.py

@@ -40,7 +40,7 @@ class WrappedBinaryClassifierXGB_GPU(WrappedBinaryClassifierXGB):
         )
 
     @wrapshap_required('wrapshap')
-    def shapFFS(self, surrogate_metrics: bool = False, top: int = None):
+    def shapFFS(self, surrogate_metrics: bool = False, top: int = None, plot:bool = True, time_info:bool = True):
         """
         Simply calls Wrapshap GPU implementation of Forward Feature Selection (FFS). 
 
@@ -54,11 +54,11 @@ class WrappedBinaryClassifierXGB_GPU(WrappedBinaryClassifierXGB):
                             dictionary with the corresponding performance metrics.
         """
 
-        return self.wrapshap.shapFFS(surrogate_metrics=surrogate_metrics, top=top)
+        return self.wrapshap.shapFFS(surrogate_metrics=surrogate_metrics, top=top,plot=plot, time_info = time_info)
     
 
     @wrapshap_required('wrapshap')
-    def shapBFE(self, surrogate_metrics: bool = False, top: int = None):
+    def shapBFE(self, surrogate_metrics: bool = False, top: int = None, plot:bool = True,time_info:bool = False):
         """
         Simply calls Wrapshap implementation of Backward Feature Elimination (BFE). 
 
@@ -72,7 +72,7 @@ class WrappedBinaryClassifierXGB_GPU(WrappedBinaryClassifierXGB):
                             dictionary with the corresponding performance metrics.
         """
 
-        return self.wrapshap.shapBFE(surrogate_metrics=surrogate_metrics, top=top)
+        return self.wrapshap.shapBFE(surrogate_metrics=surrogate_metrics, top=top,plot=plot, time_info=time_info)
     
     @wrapshap_required('wrapshap')
     def shapNCK(self, k: int = 2, batch_size: int = 500, selected_features: list = [], top: int = None):
@@ -138,7 +138,7 @@ class WrappedRegressorXGB_GPU(WrappedRegressorXGB):
         )
 
     @wrapshap_required('wrapshap')
-    def shapFFS(self, surrogate_metrics: bool = False, top: int = None):
+    def shapFFS(self, surrogate_metrics: bool = False, top: int = None, plot:bool=True, time_info:bool=True):
         """
         Simply calls Wrapshap implementation of Forward Feature Selection (FFS). 
 
@@ -152,11 +152,11 @@ class WrappedRegressorXGB_GPU(WrappedRegressorXGB):
                             dictionary with the corresponding performance metrics.
         """
 
-        return self.wrapshap.shapFFS(surrogate_metrics=surrogate_metrics, top=top)
+        return self.wrapshap.shapFFS(surrogate_metrics=surrogate_metrics, top=top, plot=plot, time_info=time_info)
     
 
     @wrapshap_required('wrapshap')
-    def shapBFE(self, surrogate_metrics: bool = False, top: int = None):
+    def shapBFE(self, surrogate_metrics: bool = False, top: int = None, plot=True, time_info:bool= False):
         """
         Simply calls Wrapshap implementation of Backward Feature Elimination (BFE). 
 
@@ -170,7 +170,7 @@ class WrappedRegressorXGB_GPU(WrappedRegressorXGB):
                             dictionary with the corresponding performance metrics.
         """
 
-        return self.wrapshap.shapBFE(surrogate_metrics=surrogate_metrics, top=top)
+        return self.wrapshap.shapBFE(surrogate_metrics=surrogate_metrics, top=top, plot=plot, time_info = time_info)
     
     
     @wrapshap_required('wrapshap')

{wrapshap-0.1.1 → wrapshap-0.1.2}/wrapshap/gpu_implementation/_internal/_already_wrapped_lgb_gpu.py

@@ -46,7 +46,7 @@ class WrappedBinaryClassifierLGB_GPU(WrappedBinaryClassifierLGB):
         )
 
     @wrapshap_required('wrapshap')
-    def shapFFS(self, surrogate_metrics: bool = False, top: int = None):
+    def shapFFS(self, surrogate_metrics: bool = False, top: int = None,  plot:bool = True, time_info:bool = True):
         """
         Simply calls Wrapshap GPU implementation of Forward Feature Selection (FFS). 
 
@@ -60,11 +60,11 @@ class WrappedBinaryClassifierLGB_GPU(WrappedBinaryClassifierLGB):
                             dictionary with the corresponding performance metrics.
         """
 
-        return self.wrapshap.shapFFS(surrogate_metrics=surrogate_metrics, top=top)
+        return self.wrapshap.shapFFS(surrogate_metrics=surrogate_metrics, top=top, plot= plot, time_info=time_info)
     
 
     @wrapshap_required('wrapshap')
-    def shapBFE(self, surrogate_metrics: bool = False, top: int = None):
+    def shapBFE(self, surrogate_metrics: bool = False, top: int = None,  plot:bool = True, time_info:bool = False):
         """
         Simply calls Wrapshap implementation of Backward Feature Elimination (BFE). 
 
@@ -78,7 +78,7 @@ class WrappedBinaryClassifierLGB_GPU(WrappedBinaryClassifierLGB):
                             dictionary with the corresponding performance metrics.
         """
 
-        return self.wrapshap.shapBFE(surrogate_metrics=surrogate_metrics, top=top)
+        return self.wrapshap.shapBFE(surrogate_metrics=surrogate_metrics, top=top, plot= plot)
     
     @wrapshap_required('wrapshap')
     def shapNCK(self, k: int = 2, batch_size: int = 500, selected_features: list = [], top: int = None):
@@ -142,7 +142,7 @@ class WrappedRegressorLGB_GPU(WrappedRegressorLGB):
         )
 
     @wrapshap_required('wrapshap')
-    def shapFFS(self, surrogate_metrics: bool = False, top: int = None):
+    def shapFFS(self, surrogate_metrics: bool = False, top: int = None, plot:bool = True, time_info:bool=True):
         """
         Simply calls Wrapshap implementation of Forward Feature Selection (FFS). 
 
@@ -156,11 +156,11 @@ class WrappedRegressorLGB_GPU(WrappedRegressorLGB):
                             dictionary with the corresponding performance metrics.
         """
 
-        return self.wrapshap.shapFFS(surrogate_metrics=surrogate_metrics, top=top)
+        return self.wrapshap.shapFFS(surrogate_metrics=surrogate_metrics, top=top, plot=plot, time_info = time_info)
     
 
     @wrapshap_required('wrapshap')
-    def shapBFE(self, surrogate_metrics: bool = False, top: int = None):
+    def shapBFE(self, surrogate_metrics: bool = False, top: int = None, plot: bool = True, time_info:bool=False):
         """
         Simply calls Wrapshap implementation of Backward Feature Elimination (BFE). 
 
@@ -174,7 +174,7 @@ class WrappedRegressorLGB_GPU(WrappedRegressorLGB):
                             dictionary with the corresponding performance metrics.
         """
 
-        return self.wrapshap.shapBFE(surrogate_metrics=surrogate_metrics, top=top)
+        return self.wrapshap.shapBFE(surrogate_metrics=surrogate_metrics, top=top, plot=plot, time_info = time_info)
     
     
     @wrapshap_required('wrapshap')