consensus-fs 0.1.1__py3-none-any.whl

consensus_fs-0.1.1.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: consensus-fs
+Version: 0.1.1
+Summary: Ensemble Feature Selection Library
+Author: Ulaş Taylan Met
+Author-email: umet9711@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: scikit-learn>=1.0.0
+Requires-Dist: pandas>=1.0.0
+Requires-Dist: numpy>=1.18.0
+Requires-Dist: shap>=0.40.0
+Requires-Dist: lofo-importance>=0.3.0
+Requires-Dist: joblib>=1.0.0
+Requires-Dist: seaborn>=0.11.0
+Requires-Dist: matplotlib>=3.3.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

consensus_fs-0.1.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+consensus_fs-0.1.1.dist-info/licenses/LICENSE,sha256=k4bUnpzMBYBEmyhece9y1ALZG8DC41s4OgEGUx7q_FU,1059
+consensusfs/__init__.py,sha256=_lQWcMFbQo8zbpuRtRDsaBFT068unHIiYOntdIgauIQ,39
+consensusfs/aggregation.py,sha256=qXJ1NTqf-14LnRA4v0Ht5MFL2N9F9XNKSxMwDZgOJgo,1956
+consensusfs/calculators.py,sha256=uTMq1-KCUjT4wCvG2xyhsVrGguaNarHrt8LVPZgwMiw,3177
+consensusfs/plotting.py,sha256=KsVTg6Sya1Jc1Ga2cMPup9BHPktAHa1J57RAsfSo1d0,1184
+consensusfs/selector.py,sha256=9KzOwIKKq8ANOj7GsT7QpKBObTGicp_uyOF7GZ5cl6M,4973
+consensus_fs-0.1.1.dist-info/METADATA,sha256=hgzQcakGdt_wPB83XKylAOm8vOSMxDgapS6IYKZ_w7E,746
+consensus_fs-0.1.1.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+consensus_fs-0.1.1.dist-info/top_level.txt,sha256=Uu5ZIetxqJDxO_eFVWZyW7yTyR5m9pGmF2C7qsfNx6c,12
+consensus_fs-0.1.1.dist-info/RECORD,,

consensus_fs-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

consensus_fs-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2026 Ulaş Taylan Met
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

consensus_fs-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+consensusfs

consensusfs/__init__.py

@@ -0,0 +1 @@
+from .selector import ConsensusSelector

consensusfs/aggregation.py

@@ -0,0 +1,42 @@
+import pandas as pd
+import numpy as np
+
+def aggregate_scores(results_dict, feature_names, method='rank_mean', weights=None):
+    """
+    Farklı algoritmalardan gelen skorları birleştirir.
+    Dönen DataFrame EN İYİ özellikten EN KÖTÜ özelliğe doğru sıralanmış olur.
+    """
+    # NaN / Inf değerlere karşı koruma (#9)
+    df = pd.DataFrame(results_dict, index=feature_names)
+    df = df.fillna(0).replace([np.inf, -np.inf], 0)
+    
+    if method == 'rank_mean':
+        # Her algoritma için en yüksek skoru alan özelliği 1. sıraya koy (ascending=False)
+        rank_df = df.rank(ascending=False, method='min')
+        
+        # Ağırlıklandırma — np.average ile uygun ölçek korunarak uygulanır (#8)
+        if weights:
+            weight_values = [weights.get(col, 1.0) for col in rank_df.columns]
+            df['meta_score'] = np.average(rank_df.values, axis=1, weights=weight_values)
+        else:
+            df['meta_score'] = rank_df.mean(axis=1)
+        
+        # En düşük puana (en iyi sıraya) göre küçükten büyüğe sırala
+        return df.sort_values('meta_score', ascending=True)
+        
+    elif method == 'minmax_mean':
+        # (x - min) / (max - min) formülü ile tüm değerleri 0-1 arasına çek
+        minmax_df = (df - df.min()) / (df.max() - df.min() + 1e-9)
+        
+        # Ağırlıklandırma — np.average ile uygun ölçek korunarak uygulanır (#8)
+        if weights:
+            weight_values = [weights.get(col, 1.0) for col in minmax_df.columns]
+            df['meta_score'] = np.average(minmax_df.values, axis=1, weights=weight_values)
+        else:
+            df['meta_score'] = minmax_df.mean(axis=1)
+            
+        # En yüksek puana göre büyükten küçüğe sırala
+        return df.sort_values('meta_score', ascending=False)
+        
+    else:
+        raise ValueError("Desteklenmeyen birleştirme yöntemi. Lütfen 'rank_mean' veya 'minmax_mean' kullanın.")

consensusfs/calculators.py

@@ -0,0 +1,71 @@
+import numpy as np
+import pandas as pd
+import shap
+import uuid
+import warnings
+from sklearn.inspection import permutation_importance
+from lofo import Dataset, LOFOImportance
+
+def calc_correlation(X, y, **kwargs):
+    """Hedef değişken ile özellikler arasındaki mutlak Pearson korelasyonunu hesaplar."""
+    corr = X.apply(lambda col: col.corr(y)).abs()
+    corr = corr.fillna(0)
+    return corr.values
+
+def calc_permutation(estimator, X, y, **kwargs):
+    """Scikit-Learn tabanlı Permutation Importance hesaplar."""
+    # joblib çakışmalarını önlemek için n_jobs=1 kullanıyoruz
+    result = permutation_importance(estimator, X, y, n_repeats=5, random_state=42, n_jobs=1)
+    return result.importances_mean
+
+def calc_shap(estimator, X, y, **kwargs):
+    """SHAP değerlerini hesaplar. Modeline göre otomatik Explainer seçer."""
+    
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")  # Sadece bu blok için SHAP uyarılarını gizle
+        
+        try:
+            # Ağaç tabanlı modeller için (XGBoost, RandomForest, LightGBM vb.)
+            explainer = shap.TreeExplainer(estimator)
+            shap_values = explainer.shap_values(X)
+        except Exception:
+            try:
+                # Doğrusal modeller için
+                explainer = shap.LinearExplainer(estimator, X)
+                shap_values = explainer.shap_values(X)
+            except Exception:
+                # Diğer tüm modeller için (KernelExplainer yavaş olduğu için sample alıyoruz)
+                sample_X = shap.sample(X, 100) if len(X) > 100 else X
+                explainer = shap.KernelExplainer(estimator.predict, sample_X)
+                shap_values = explainer.shap_values(X)
+            
+    # Eğer çok sınıflı sınıflandırma (multi-class) ise shap_values bir liste döner
+    if isinstance(shap_values, list):
+        # Tüm sınıfların ortalama mutlak etkisini al
+        mean_abs_shap = np.mean([np.abs(sv).mean(axis=0) for sv in shap_values], axis=0)
+    else:
+        # Tekil çıktı (regresyon veya binary)
+        if len(shap_values.shape) == 3: # Yeni SHAP versiyonları için
+             mean_abs_shap = np.abs(shap_values).mean(axis=(0, 2))
+        else:
+             mean_abs_shap = np.abs(shap_values).mean(axis=0)
+        
+    return mean_abs_shap
+
+def calc_lofo(estimator, X, y, feature_names, scoring="roc_auc", **kwargs):
+    """LOFO (Leave One Feature Out) Importance hesaplar."""
+    df = X.copy()
+    # UUID ile benzersiz geçici sütun adı oluştur (X'teki sütunlarla çakışmayı önler)
+    target_name = f'__lofo_target_{uuid.uuid4().hex}__'
+    df[target_name] = y.values
+    
+    dataset = Dataset(df=df, target=target_name, features=feature_names)
+    
+    # LOFO hesaplama (n_jobs=1 nested paralel çakışmasını önler)
+    lofo_imp = LOFOImportance(dataset, model=estimator, scoring=scoring, cv=3, n_jobs=1)
+    importance_df = lofo_imp.get_importance()
+    
+    # Skorları orijinal özellik sırasına göre eşleştir ve array olarak dön
+    importance_df = importance_df.set_index('feature')
+    scores = importance_df.loc[feature_names, 'importance_mean'].values
+    return scores

consensusfs/plotting.py

@@ -0,0 +1,28 @@
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+def plot_consensus_heatmap(importance_df, top_n=15, title="Consensus Feature Selection Heatmap"):
+    """
+    Farklı metriklerin özelliklere verdiği önem derecelerini Isı Haritası olarak çizer.
+    """
+    # İstenen sayıda en iyi özelliği seç
+    plot_df = importance_df.head(top_n).copy()
+    
+    # Sadece algoritma skorlarını görselleştir (meta_score sütununu çıkar)
+    if 'meta_score' in plot_df.columns:
+        plot_df = plot_df.drop(columns=['meta_score'])
+        
+    # Her sütunu (algoritmayı) kendi içinde 0-1 arasına sıkıştır ki renkler düzgün görünsün
+    plot_df_scaled = (plot_df - plot_df.min()) / (plot_df.max() - plot_df.min() + 1e-9)
+    
+    plt.figure(figsize=(10, max(6, top_n * 0.4))) # Özellik sayısına göre dinamik yükseklik
+    ax = sns.heatmap(plot_df_scaled, annot=False, cmap='viridis', linewidths=.5)
+    
+    plt.title(title, fontsize=14, pad=20)
+    plt.ylabel("Özellikler (En İyiden En Kötüye)", fontsize=12)
+    plt.xlabel("Metrikler", fontsize=12)
+    
+    # Eksen etiketlerini döndür
+    plt.xticks(rotation=45)
+    plt.tight_layout()
+    plt.show()

consensusfs/selector.py

@@ -0,0 +1,105 @@
+import pandas as pd
+import numpy as np
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.utils.validation import check_is_fitted
+from joblib import Parallel, delayed
+
+# Kendi modüllerimizi içe aktarıyoruz
+from consensusfs.calculators import calc_correlation, calc_permutation, calc_shap, calc_lofo
+from consensusfs.aggregation import aggregate_scores
+from consensusfs.plotting import plot_consensus_heatmap
+
+class ConsensusSelector(BaseEstimator, TransformerMixin):
+    """
+    Consensus Feature Selection Kütüphanesi Ana Sınıfı.
+    Scikit-Learn uyumlu (fit, transform) çalışır.
+    """
+    def __init__(self, estimator, methods=None, aggregation='rank_mean', 
+                 n_features_to_select=None, weights=None, n_jobs=-1, scoring="roc_auc"):
+        self.estimator = estimator
+        # Varsayılan metodlar (LOFO yavaş olduğu için varsayılanlara eklemedik, istenirse yazılır)
+        self.methods = methods if methods is not None else['correlation', 'permutation', 'shap']
+        self.aggregation = aggregation
+        self.n_features_to_select = n_features_to_select
+        self.weights = weights
+        self.n_jobs = n_jobs
+        self.scoring = scoring
+        
+    def fit(self, X, y):
+        """Özellik önemlerini hesaplar ve meta skor üretir."""
+        # 1. Veri Doğrulama ve DataFrame formatına dönüştürme
+        if not isinstance(X, pd.DataFrame):
+            X = pd.DataFrame(X, columns=[f"feature_{i}" for i in range(X.shape[1])])
+        if not isinstance(y, (pd.Series, pd.DataFrame)):
+            y = pd.Series(y, name='target')
+            
+        self.feature_names_ = X.columns.tolist()
+        
+        # 2. Modeli eğit (SHAP ve Permutation için eğitilmiş model şarttır)
+        self.estimator.fit(X, y)
+        
+        # 3. Hesaplanacak görevleri belirle ve Paralel Çalıştır (standart generator pattern)
+        method_names = []
+        delayed_tasks = []
+        for method in self.methods:
+            if method == 'correlation':
+                method_names.append(method)
+                delayed_tasks.append(delayed(calc_correlation)(X, y))
+            elif method == 'permutation':
+                method_names.append(method)
+                delayed_tasks.append(delayed(calc_permutation)(self.estimator, X, y))
+            elif method == 'shap':
+                method_names.append(method)
+                delayed_tasks.append(delayed(calc_shap)(self.estimator, X, y))
+            elif method == 'lofo':
+                method_names.append(method)
+                delayed_tasks.append(delayed(calc_lofo)(self.estimator, X, y, self.feature_names_, scoring=self.scoring))
+            else:
+                raise ValueError(f"Geçersiz metod: {method}. Desteklenenler: correlation, permutation, shap, lofo")
+
+        # 4. Paralel Hesaplama (Joblib) — generator pattern ile doğru kullanım
+        results_list = Parallel(n_jobs=self.n_jobs)(t for t in delayed_tasks)
+
+        # Sonuçları sözlüğe çevir
+        results_dict = dict(zip(method_names, results_list))
+        
+        # 5. Skorları Toplulaştırma (Aggregation)
+        self.importance_df_ = aggregate_scores(
+            results_dict=results_dict,
+            feature_names=self.feature_names_,
+            method=self.aggregation,
+            weights=self.weights
+        )
+        
+        # 6. Seçilecek en iyi özelliklerin listesini kaydet
+        n_select = self.n_features_to_select if self.n_features_to_select else len(self.feature_names_)
+        self.best_features_ = self.importance_df_.head(n_select).index.tolist()
+        
+        # Estimator'ın fit edildiğini işaretlemek için sklearn standartı
+        self.is_fitted_ = True
+        return self
+
+    def transform(self, X):
+        """Sadece en iyi özellikleri içeren veri setini filtreler ve döndürür."""
+        check_is_fitted(self, 'is_fitted_')
+        
+        if isinstance(X, pd.DataFrame):
+            # Eğer DataFrame verildiyse sütun isimlerinden filtrele
+            missing_cols = set(self.best_features_) - set(X.columns)
+            if missing_cols:
+                raise ValueError(f"Transform işlemindeki veride eksik sütunlar var: {missing_cols}")
+            return X[self.best_features_]
+        else:
+            # NumPy array ise, eğitimdeki sütun indekslerini bul ve filtrele
+            indices =[self.feature_names_.index(f) for f in self.best_features_]
+            return X[:, indices]
+            
+    def fit_transform(self, X, y=None, **fit_params):
+        """Önce fit() sonra transform() çalıştırır."""
+        return self.fit(X, y).transform(X)
+        
+    def plot(self, top_n=15, title="Consensus Feature Selection Heatmap"):
+        """Sonuçları ısı haritası olarak gösterir."""
+        check_is_fitted(self, 'is_fitted_')
+        actual_top_n = min(top_n, len(self.feature_names_))
+        plot_consensus_heatmap(self.importance_df_, top_n=actual_top_n, title=title)