consensus-fs 0.1.1__tar.gz

consensus_fs-0.1.1/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,378 @@
+# ConsensusFS
+
+> **Tek bir feature selection metoduna güvenme — hepsini çalıştır, en iyisini seç.**
+
+ConsensusFS, makine öğrenmesi projelerinde özellik seçimi (feature selection) için geliştirilmiş bir **ensemble / konsensüs kütüphanesidir**. SHAP, LOFO, Permutation Importance ve Korelasyon gibi farklı metodları **aynı anda paralel** olarak çalıştırır; ardından sonuçları akıllıca birleştirerek güvenilir bir **Meta-Importance skoru** üretir.
+
+Scikit-Learn uyumludur: `fit`, `transform`, `fit_transform` ve Pipeline desteği ile gelir.
+
+---
+
+## 📋 İçindekiler
+
+- [Neden ConsensusFS?](#neden-consensusfs)
+- [Kurulum](#kurulum)
+- [Hızlı Başlangıç](#hızlı-başlangıç)
+- [Nasıl Çalışır?](#nasıl-çalışır)
+- [API Referansı](#api-referansı)
+- [Desteklenen Metodlar](#desteklenen-metodlar)
+- [Aggregation Stratejileri](#aggregation-stratejileri)
+- [Gelişmiş Kullanım](#gelişmiş-kullanım)
+- [Sklearn Pipeline ile Kullanım](#sklearn-pipeline-ile-kullanım)
+- [Görselleştirme](#görselleştirme)
+- [Bağımlılıklar](#bağımlılıklar)
+- [Sık Sorulan Sorular](#sık-sorulan-sorular)
+
+---
+
+## Neden ConsensusFS?
+
+Her feature selection metodu farklı bir şeyi ölçer ve farklı zayıf noktaları vardır:
+
+| Metod | Gördüğü Şey | Kör Noktası |
+|-------|------------|------------|
+| Correlation | Lineer ilişkiler | Non-lineer ilişkileri kaçırır |
+| Permutation | Model performansına etkisi | Overfitting modelde yanıltıcı olabilir |
+| SHAP | Her özelliğin tahmine katkısı | Model bağımlıdır |
+| LOFO | CV skoru üzerindeki etkisi | Yavaştır, küçük veride gürültülüdür |
+
+**ConsensusFS** bu metodları bir araya getirerek:
+- Hiçbir metodun körü körüne güven açığına düşmez
+- Birden fazla metodun hemfikir olduğu özellikleri seçer
+- Bireysel metodlara göre daha **kararlı (stable)** ve **güvenilir** sonuçlar üretir
+
+---
+
+## Kurulum
+
+```bash
+# Repoyu klonlayın ve dizine girin
+git clone https://github.com/kullanici_adi/consensusfs.git
+cd consensusfs
+
+# Yerel olarak kurun
+pip install .
+```
+
+**Tüm bağımlılıkları ayrıca kurmak isterseniz:**
+
+```bash
+pip install scikit-learn>=1.0.0 pandas>=1.0.0 numpy>=1.18.0 shap>=0.40.0 lofo-importance>=0.3.0 joblib>=1.0.0 seaborn>=0.11.0 matplotlib>=3.3.0
+```
+
+> **Python Gereksinimi:** >= 3.8
+
+---
+
+## Hızlı Başlangıç
+
+```python
+import pandas as pd
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.datasets import make_classification
+from consensusfs import ConsensusSelector
+
+# Veri hazırla
+X, y = make_classification(n_samples=500, n_features=20, n_informative=5, random_state=42)
+X_df = pd.DataFrame(X, columns=[f"col_{i}" for i in range(20)])
+
+# Model ve selector tanımla
+model = RandomForestClassifier(n_estimators=100, random_state=42)
+
+selector = ConsensusSelector(
+    estimator=model,
+    methods=['correlation', 'permutation', 'shap'],  # kullanılacak metodlar
+    n_features_to_select=10,                          # kaç özellik seçilsin
+    n_jobs=-1                                         # tüm CPU çekirdeklerini kullan
+)
+
+# Eğit ve dönüştür
+X_selected = selector.fit_transform(X_df, y)
+
+print("Seçilen özellikler:", selector.best_features_)
+print("Yeni boyut:", X_selected.shape)
+
+# Sonuçları görselleştir
+selector.plot(top_n=10)
+```
+
+---
+
+## Nasıl Çalışır?
+
+```
+Veri (X, y)
+    │
+    ▼
+┌─────────────────────────────────────────────────┐
+│           Paralel Hesaplama (joblib)             │
+│                                                  │
+│  Correlation │ Permutation │  SHAP  │   LOFO    │
+│  (opsiyonel) │ (opsiyonel) │(opsy.) │ (opsy.)  │
+└──────┬───────┴──────┬──────┴───┬────┴─────┬─────┘
+       │              │          │           │
+       └──────────────┴────┬─────┘───────────┘
+                           ▼
+              Aggregation (rank_mean / minmax_mean)
+                      + Ağırlıklandırma
+                           │
+                           ▼
+                  Meta-Skor Tablosu (importance_df_)
+                           │
+                           ▼
+                  En İyi N Özellik (best_features_)
+```
+
+### Aggregation Detayı (`rank_mean`)
+
+1. Her metod kendi skorunu üretir (örn. SHAP değerleri, korelasyon katsayıları)
+2. Her metod için özellikler **sıralanır** (1 = en önemli, N = en önemsiz)
+3. Her özelliğin tüm sıraların **ağırlıklı ortalaması** alınır → `meta_score`
+4. En düşük `meta_score` → en iyi özellik
+
+---
+
+## API Referansı
+
+### `ConsensusSelector(estimator, methods, aggregation, n_features_to_select, weights, n_jobs, scoring)`
+
+| Parametre | Tip | Varsayılan | Açıklama |
+|-----------|-----|-----------|----------|
+| `estimator` | sklearn estimator | **Zorunlu** | Kullanılacak ML modeli. SHAP ve Permutation için eğitilir. |
+| `methods` | `list[str]` | `['correlation', 'permutation', 'shap']` | Kullanılacak özellik seçim metodlarının listesi. |
+| `aggregation` | `str` | `'rank_mean'` | Skor birleştirme stratejisi. `'rank_mean'` veya `'minmax_mean'`. |
+| `n_features_to_select` | `int` veya `None` | `None` | Seçilecek özellik sayısı. `None` ise tüm özellikler sıralanır. |
+| `weights` | `dict` veya `None` | `None` | Her metoda verilecek ağırlık. `{'shap': 2.0, 'correlation': 0.5}` gibi. |
+| `n_jobs` | `int` | `-1` | Joblib paralel iş sayısı. `-1` tüm CPU çekirdeklerini kullanır. |
+| `scoring` | `str` | `'roc_auc'` | LOFO metodu için skorlama metriği. |
+
+---
+
+### Metodlar
+
+#### `fit(X, y) → self`
+Tüm feature selection hesaplamalarını yapar, `importance_df_` ve `best_features_` atributlarını doldurur.
+
+- `X`: `pd.DataFrame` veya `np.ndarray` — girdi özellikleri
+- `y`: `pd.Series` veya `np.ndarray` — hedef değişken
+
+#### `transform(X) → pd.DataFrame veya np.ndarray`
+`fit()` ile seçilmiş özellikleri içeren veri setini döndürür.
+
+- `X`'in tipi korunur: DataFrame girerse DataFrame döner, ndarray girerse ndarray döner.
+
+#### `fit_transform(X, y) → pd.DataFrame veya np.ndarray`
+`fit(X, y)` ardından `transform(X)` çalıştırır.
+
+#### `plot(top_n=15, title="Consensus Feature Selection Heatmap")`
+En önemli `top_n` özelliği için her metodun verdiği önemi gösteren Isı Haritası çizer.
+
+---
+
+### Atributlar (fit() sonrası)
+
+| Atribut | Tip | Açıklama |
+|---------|-----|----------|
+| `importance_df_` | `pd.DataFrame` | Her metodun ve meta skorun sütun olduğu, özellik sıralı tablo |
+| `best_features_` | `list[str]` | Seçilen en iyi özellik isimleri (sıralanmış) |
+| `feature_names_` | `list[str]` | Eğitim sırasındaki tüm özellik isimleri |
+
+---
+
+## Desteklenen Metodlar
+
+### `'correlation'`
+Hedef değişken ile her özellik arasındaki **mutlak Pearson korelasyonu** hesaplar. Model gerektirmez, çok hızlıdır. Lineer olmayan ilişkileri kaçırabilir.
+
+### `'permutation'`
+Scikit-learn'in `permutation_importance` fonksiyonunu kullanır. Her özelliğin değerleri karıştırıldığında model skoru ne kadar düşüyor? Düşüş fazlaysa özellik önemlidir.
+
+### `'shap'`
+SHAP (SHapley Additive exPlanations) değerlerini hesaplar. Model tipine göre otomatik olarak doğru Explainer seçilir:
+1. Ağaç tabanlı modeller (XGBoost, LightGBM, RandomForest) → `TreeExplainer`
+2. Doğrusal modeller → `LinearExplainer`
+3. Diğer tüm modeller → `KernelExplainer` (100 örnek ile örnekleme yapılır)
+
+### `'lofo'`
+LOFO (Leave One Feature Out) Importance: Her özellik sırası ile veri setinden çıkarıldığında cross-validation skoru ne kadar değişiyor? En yorumlayıcı ama en yavaş metoddur.
+
+> ⚠️ LOFO büyük veri setlerinde uzun sürebilir. `scoring` parametresi ile metriği değiştirebilirsiniz.
+
+---
+
+## Aggregation Stratejileri
+
+### `rank_mean` (Önerilen)
+Her metodun sıra bilgisi kullanılır. Ölçek farklılıklarından etkilenmez.
+
+```
+meta_score = weighted_average(rank_per_method)
+```
+
+- **Düşük** `meta_score` → daha iyi özellik
+- Ağırlık verilirse `numpy.average()` ile uygulanır (sıralama bozulmaz)
+
+### `minmax_mean`
+Ham skorlar 0-1 arasına normalize edilip ortalaması alınır.
+
+```
+normalized = (score - min) / (max - min)
+meta_score = weighted_average(normalized)
+```
+
+- **Yüksek** `meta_score` → daha iyi özellik
+- Metodların orijinal skor büyüklükleri önemlidir, aşırı baskın metodlar riski vardır.
+
+---
+
+## Gelişmiş Kullanım
+
+### Özel Ağırlıklar
+
+```python
+# SHAP'a daha fazla güven, korelasyona daha az
+custom_weights = {
+    'shap': 2.0,
+    'lofo': 1.5,
+    'permutation': 1.0,
+    'correlation': 0.5
+}
+
+selector = ConsensusSelector(
+    estimator=model,
+    methods=['correlation', 'permutation', 'shap', 'lofo'],
+    weights=custom_weights,
+    n_features_to_select=10
+)
+```
+
+### Sadece Hızlı Metodlar (LOFO Olmadan)
+
+```python
+# Hızlı çalışma için sadece correlation + shap
+selector = ConsensusSelector(
+    estimator=model,
+    methods=['correlation', 'shap'],
+    aggregation='rank_mean',
+    n_features_to_select=15,
+    n_jobs=-1
+)
+```
+
+### Tüm Özellikleri Sıralı Almak
+
+```python
+# n_features_to_select=None ile tüm özellikler önem sırasıyla listelenir
+selector = ConsensusSelector(estimator=model)
+selector.fit(X, y)
+
+print(selector.importance_df_)         # Tam skor tablosu
+print(selector.best_features_)         # Tüm özellikler, en iyiden en kötüye
+```
+
+### Regresyon Problemleri için
+
+```python
+from sklearn.ensemble import GradientBoostingRegressor
+
+model = GradientBoostingRegressor(random_state=42)
+
+selector = ConsensusSelector(
+    estimator=model,
+    methods=['correlation', 'permutation', 'shap'],
+    scoring='r2',          # Regresyon için uygun metrik
+    n_features_to_select=8
+)
+selector.fit(X_train, y_train)
+```
+
+---
+
+## Sklearn Pipeline ile Kullanım
+
+`ConsensusSelector`, Scikit-Learn Pipeline ile tam uyumludur:
+
+```python
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler
+from sklearn.linear_model import LogisticRegression
+from consensusfs import ConsensusSelector
+
+# Not: Pipeline içinde estimator olarak basit bir model kullanın;
+# Pipeline'ın son adımında farklı bir model kullanabilirsiniz.
+inner_model = RandomForestClassifier(n_estimators=50, random_state=42)
+
+pipe = Pipeline([
+    ('scaler', StandardScaler()),
+    ('selector', ConsensusSelector(
+        estimator=inner_model,
+        methods=['correlation', 'shap'],
+        n_features_to_select=10
+    )),
+    ('classifier', LogisticRegression())
+])
+
+pipe.fit(X_train, y_train)
+print("Test Skoru:", pipe.score(X_test, y_test))
+```
+
+---
+
+## Görselleştirme
+
+```python
+# fit() çağrısından sonra kullanın
+selector.plot(top_n=15)
+
+# Özel başlıkla
+selector.plot(top_n=10, title="Proje X — Özellik Önem Haritası")
+```
+
+Isı haritası, her metodun her özelliğe verdiği önemi **0-1 arasında normalize ederek** gösterir. Koyu renk = daha önemli.
+
+---
+
+## Bağımlılıklar
+
+| Kütüphane | Minimum Sürüm | Kullanım Amacı |
+|-----------|--------------|----------------|
+| `scikit-learn` | ≥ 1.0.0 | BaseEstimator, permutation_importance |
+| `pandas` | ≥ 1.0.0 | DataFrame işlemleri |
+| `numpy` | ≥ 1.18.0 | Sayısal hesaplamalar |
+| `shap` | ≥ 0.40.0 | SHAP değerleri |
+| `lofo-importance` | ≥ 0.3.0 | LOFO hesaplaması |
+| `joblib` | ≥ 1.0.0 | Paralel hesaplama |
+| `matplotlib` | ≥ 3.3.0 | Görselleştirme |
+| `seaborn` | ≥ 0.11.0 | Isı haritası |
+
+---
+
+## Sık Sorulan Sorular
+
+**LOFO çok yavaş, ne yapmalıyım?**
+`methods` listesinden `'lofo'`'yu çıkarın. Diğer üç metod yeterince güçlüdür.
+
+**Model olarak ne kullanmalıyım?**
+SHAP için ağaç tabanlı modeller (RandomForest, XGBoost, LightGBM) hem en hızlı hem en doğru sonucu verir. Ancak herhangi bir Scikit-Learn uyumlu model çalışır.
+
+**`n_features_to_select` nasıl seçmeliyim?**
+Önce `None` bırakıp `importance_df_`'e bakın; `meta_score`'un belirgin şekilde arttığı nokta iyi bir kesme noktasıdır.
+
+**NumPy array kullanabilir miyim, DataFrame zorunlu mu?**
+Her ikisi de çalışır. NumPy array verildiğinde özellik isimleri otomatik olarak `feature_0`, `feature_1`, ... şeklinde atanır.
+
+**`weights` vermediğimde ne olur?**
+Tüm metodlar eşit ağırlıkla (1.0) değerlendirilir; `rank_mean` için basit ortalama sıra hesaplanır.
+
+**Pipeline'da `fit` edilmiş modeli tekrar eğitiyor mu?**
+Evet. `ConsensusSelector.fit()` her çağrıldığında estimatoru **yeniden eğitir**. Pipeline içinde bu beklenen davranıştır.
+
+---
+
+## Lisans
+
+MIT License — Dilediğiniz gibi kullanın, değiştirin ve dağıtın.
+
+---
+
+*Geliştirici: **Ulaş Taylan Met** — umet9711@gmail.com*

consensus_fs-0.1.1/consensus_fs.egg-info/PKG-INFO

@@ -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/consensus_fs.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+consensus_fs.egg-info/PKG-INFO
+consensus_fs.egg-info/SOURCES.txt
+consensus_fs.egg-info/dependency_links.txt
+consensus_fs.egg-info/requires.txt
+consensus_fs.egg-info/top_level.txt
+consensusfs/__init__.py
+consensusfs/aggregation.py
+consensusfs/calculators.py
+consensusfs/plotting.py
+consensusfs/selector.py
+tests/test_selector.py

consensus_fs-0.1.1/consensus_fs.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

consensus_fs-0.1.1/consensus_fs.egg-info/requires.txt

@@ -0,0 +1,8 @@
+scikit-learn>=1.0.0
+pandas>=1.0.0
+numpy>=1.18.0
+shap>=0.40.0
+lofo-importance>=0.3.0
+joblib>=1.0.0
+seaborn>=0.11.0
+matplotlib>=3.3.0

consensus_fs-0.1.1/consensus_fs.egg-info/top_level.txt

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

consensus_fs-0.1.1/consensusfs/__init__.py

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

consensus_fs-0.1.1/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.")

consensus_fs-0.1.1/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

consensus_fs-0.1.1/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()

consensus_fs-0.1.1/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)

consensus_fs-0.1.1/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

consensus_fs-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

consensus_fs-0.1.1/setup.py

@@ -0,0 +1,26 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='consensus-fs',
+    version='0.1.1',
+    description='Ensemble Feature Selection Library',
+    author='Ulaş Taylan Met',
+    author_email='umet9711@gmail.com',
+    packages=find_packages(),
+    install_requires=[
+        'scikit-learn>=1.0.0',
+        'pandas>=1.0.0',
+        'numpy>=1.18.0',
+        'shap>=0.40.0',
+        'lofo-importance>=0.3.0',
+        'joblib>=1.0.0',
+        'seaborn>=0.11.0',
+        'matplotlib>=3.3.0'
+    ],
+    python_requires='>=3.8',
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+)

consensus_fs-0.1.1/tests/test_selector.py

@@ -0,0 +1,120 @@
+import sys
+import os
+import pandas as pd
+import numpy as np
+from sklearn.datasets import make_classification
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.model_selection import train_test_split
+
+# Proje kök dizinini sisteme ekle (consensusfs klasörünün bulunduğu yer)
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if BASE_DIR not in sys.path:
+    sys.path.insert(0, BASE_DIR)
+
+try:
+    from consensusfs import ConsensusSelector
+    print(">>> ConsensusFS Kütüphanesi Başarıyla Yüklendi.\n")
+except ImportError as e:
+    print(f">>> Kütüphane Yükleme Hatası: {e}")
+    sys.exit(1)
+
+def run_comprehensive_test():
+    print("="*60)
+    print("CONSENSUS FS: KAPSAMLI SİSTEM TESTİ BAŞLIYOR")
+    print("="*60)
+
+    # 1. VERİ HAZIRLIĞI
+    # 20 özellikli bir veri seti (5'i anlamlı, 15'i gürültü/gereksiz)
+    X, y = make_classification(
+        n_samples=200, 
+        n_features=20, 
+        n_informative=5, 
+        n_redundant=2, 
+        random_state=42
+    )
+    feature_names = [f"Özellik_{i:02d}" for i in range(20)]
+    X_df = pd.DataFrame(X, columns=feature_names)
+    y_series = pd.Series(y)
+
+    X_train, X_test, y_train, y_test = train_test_split(X_df, y_series, test_size=0.2, random_state=42)
+
+    # 2. MODEL TANIMLAMA
+    model = RandomForestClassifier(n_estimators=50, random_state=42)
+
+    # 3. KÜTÜPHANE AYARLARI (Tüm Metotlar ve Ağırlıklandırma Testi)
+    # SHAP'a 2.0, Korelasyona 0.5 ağırlık veriyoruz.
+    # LOFO dahil edildiği için n_jobs=-1 ile paralel çalıştırıyoruz.
+    methods_to_test = ['correlation', 'permutation', 'shap', 'lofo']
+    custom_weights = {
+        'shap': 2.0, 
+        'lofo': 1.5, 
+        'permutation': 1.0, 
+        'correlation': 0.5
+    }
+
+    selector = ConsensusSelector(
+        estimator=model,
+        methods=methods_to_test,
+        aggregation='rank_mean',      # Sıralama tabanlı birleştirme
+        n_features_to_select=5,       # En iyi 5 özelliği seç
+        weights=custom_weights,       # Özel ağırlıklar
+        n_jobs=-1,                    # Tüm CPU çekirdeklerini kullan
+        scoring='roc_auc'             # Metrik tercihi
+    )
+
+    # 4. FIT İŞLEMİ (Eğitim ve Hesaplama)
+    print(f"[*] Hesaplamalar başlatıldı: {methods_to_test}")
+    print("[*] Paralel işlemci çekirdekleri kullanılıyor (n_jobs=-1)...")
+    
+    try:
+        selector.fit(X_train, y_train)
+        print("\n[+] Fit işlemi başarıyla tamamlandı.")
+    except Exception as e:
+        print(f"\n[!] Fit sırasında hata oluştu: {e}")
+        return
+
+    # 5. SONUÇLARIN ANALİZİ
+    print("\n" + "-"*30)
+    print("META-IMPORTANCE RAPORU (Top 10)")
+    print("-"*30)
+    print(selector.importance_df_.head(10))
+
+    print(f"\n[+] Seçilen En İyi 5 Özellik: {selector.best_features_}")
+
+    # 6. TRANSFORM TESTİ
+    print("\n[*] Veri seti dönüştürülüyor (Transform)...")
+    X_train_selected = selector.transform(X_train)
+    X_test_selected = selector.transform(X_test)
+
+    print(f"[+] Orijinal Boyut: {X_train.shape}")
+    print(f"[+] Yeni Boyut:      {X_train_selected.shape}")
+
+    assert X_train_selected.shape[1] == 5, "Hata: Seçilen özellik sayısı yanlış!"
+    assert list(X_train_selected.columns) == selector.best_features_, "Hata: Sütun isimleri eşleşmiyor!"
+
+    # 7. FARKLI BİR AGGREGATION TESTİ (MinMax Mean)
+    print("\n[*] Min-Max Toplulaştırma Testi Yapılıyor...")
+    selector_minmax = ConsensusSelector(
+        estimator=model,
+        methods=['correlation', 'shap'],
+        aggregation='minmax_mean'
+    )
+    selector_minmax.fit(X_train, y_train)
+    print("[+] Min-Max Meta Skorları (İlk 3):")
+    print(selector_minmax.importance_df_['meta_score'].head(3))
+
+    # 8. GÖRSELLEŞTİRME TESTİ
+    print("\n[*] Görselleştirme Heatmap hazırlanıyor...")
+    # Not: Bu satır ekranında bir grafik penceresi açacaktır.
+    try:
+        selector.plot(top_n=10)
+        print("[+] Görselleştirme başarılı.")
+    except Exception as e:
+        print(f"[!] Görselleştirme hatası (Display kaynaklı olabilir): {e}")
+
+    print("\n" + "="*60)
+    print("TÜM TESTLER BAŞARIYLA TAMAMLANDI!")
+    print("="*60)
+
+if __name__ == "__main__":
+    run_comprehensive_test()