binboost 0.2.1__tar.gz → 0.2.3__tar.gz

binboost-0.2.3/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: binboost
+Version: 0.2.3
+Summary: Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner
+Author: Rangga Wahyu Pratama
+License: MIT
+Keywords: gradient boosting,logical rules,binary features,interpretable machine learning
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: pandas>=1.3.0
+Dynamic: author
+Dynamic: license-file
+Dynamic: requires-python
+
+# BinBoost
+
+**Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner, dengan Regularisasi Newton-Hessian dan Dukungan Multi-Kelas**
+
+BinBoost adalah algoritma klasifikasi gradient boosting yang membangun ensemble aturan logika murni (AND, OR, XOR, termasuk negasi NOT) dengan binarisasi fitur numerik adaptif berbasis gradien pada setiap iterasi boosting. Bobot tiap aturan dihitung dengan pendekatan Newton (memakai Hessian per fungsi loss) dan regularisasi adaptif berbasis dukungan sampel & kompleksitas aturan. Setiap weak learner berupa aturan yang dapat dibaca langsung oleh manusia tanpa memerlukan alat bantu penjelasan pasca-pelatihan.
+
+## Kebaruan Utama
+- **Binarisasi adaptif berbasis gradien**: nilai ambang batas fitur numerik dicari per iterasi untuk memaksimalkan korelasi dengan gradien saat ini
+- **Ensemble aturan logika murni**: tidak ada pohon keputusan, setiap weak learner adalah aturan seperti: `(A AND B)`, `(C OR D)`, atau `(A AND NOT B)`
+- **Youden J**: Penggunaan indeks Youden J sebagai `threshold='auto'` bawaan untuk menentukan titik potong prediksi, bukan fixed di 0.5 serta mengoptimalkan sensitivity + specificity pada data training, cocok untuk kasus kelas tidak seimbang
+- **Fitur ternegasi (NOT)**: pencarian aturan otomatis mempertimbangkan dua polaritas (asli dan negasi) untuk tiap kandidat fitur 
+- **Bobot aturan berbasis Newton (Hessian)**: bobot dua sisi tiap aturan dihitung dengan `w = G/(H+λ)`, memakai turunan kedua (Hessian) yang sesuai dengan fungsi loss yang dipilih (logistic, focal, atau poly), bukan sekadar rata-rata gradien
+- **Regularisasi adaptif**: `λ` menyesuaikan otomatis terhadap jumlah sampel dan panjang aturan, sehingga aturan dengan cakupan kecil/kompleks ditahan bobotnya secara proporsional
+- **Minimum-gain pruning (`gamma`)**: aturan dengan kontribusi terlalu kecil bisa ditolak sebelum masuk ensemble, membantu mencegah overfitting pada aturan yang terlalu spesifik
+- **Dukungan multi-kelas**: lewat `binboost.multiclass.OneVsRestBinBoost`, BinBoost bisa dipakai untuk klasifikasi dengan lebih dari 2 kelas (strategi One-vs-Rest)
+
+## Instalasi
+```bash
+pip install binboost
+```
+
+## Penggunaan Dasar untuk Klasifikasi Biner
+```python
+import numpy as np
+from binboost import BinBoost
+
+X = np.array([[1, 0, 1], [0, 1, 0], [1, 1, 0], [0, 0, 1]], dtype=float)
+y = np.array([1, 0, 1, 0])
+
+model = BinBoost(n_estimators=100, learning_rate=0.2, max_rule_length=4)
+model.fit(X, y)
+
+print(model.predict(X))
+print(model.predict_proba(X))
+print(model.rules_)
+
+import pandas as pd
+print(pd.DataFrame(model.rule_summary_))
+```
+
+## Penggunaan Multi-Kelas (>2 kelas)
+Untuk label dengan lebih dari 2 kelas yang saling eksklusif, gunakan `OneVsRestBinBoost` — hyperparameter yang diteruskan persis sama dengan `BinBoost`:
+
+```python
+from binboost.multiclass import OneVsRestBinBoost
+
+model = OneVsRestBinBoost(
+    mode='multiclass',
+    n_estimators=100,
+    learning_rate=0.2,
+    max_rule_length=4,
+    lambda0=3.0,
+)
+model.fit(X, y)                          # y boleh berisi >2 kelas, mis. array string atau integer
+
+print(model.predict(X))
+print(model.predict_proba(X))            # dinormalisasi supaya tiap baris berjumlah 1
+print(pd.DataFrame(model.rule_summary_)) # aturan per kelas, kolom 'kelas' menandai sub-model asalnya
+```
+
+`mode='multilabel'` tersedia untuk kasus di mana satu sampel bisa punya lebih dari satu label positif sekaligus dimana probabilitas tidak dinormalisasi, tiap kelas diputuskan independen.
+
+## Hyperparameter Utama
+
+| Parameter | Bawaan | Keterangan |
+|---|---|---|
+| `n_estimators` | 100 | Jumlah iterasi boosting |
+| `learning_rate` | 0.2 | Faktor penyusutan tiap aturan |
+| `loss` | `'logistic'` | Fungsi loss: `'logistic'`, `'focal'`, `'poly'` |
+| `max_rule_length` | 4 | Jumlah maksimum fitur dalam satu aturan |
+| `operators` | `['AND','OR']` | Operator logika yang digunakan ubah `use_xor=True` untuk mengaktifkan XOR |
+| `beam_width` | 5 | Lebar beam search |
+| `binarize_strategy` | `'gradient'` | Strategi binarisasi: `'gradient'`, `'quantile'`, `'uniform'`, `'kmeans'` |
+| `subsample` | 0.8 | Fraksi data per iterasi |
+| `feature_selection_threshold` | 0.0 | Ambang batas persentil gain fitur untuk seleksi kandidat (0.0 = semua fitur) |
+| `min_samples_rule` | 5 | Jumlah/fraksi minimum sampel yang harus memenuhi sebuah aturan |
+| `lambda0` | 3.0 | Konstanta regularisasi Newton adaptif |
+| `gamma` | 0.0 | Ambang minimum gain untuk menerima sebuah aturan (0.0 = tanpa pruning, nonaktif secara bawaan) |
+
+Fitur negasi (NOT) aktif otomatis pada pencarian aturan dan bukan hyperparameter yang bisa diatur lewat `BinBoost()` — ini bagian tetap dari mekanisme beam search.
+
+## Fitur yang Didukung
+- Fitur biner (0/1): langsung diproses
+- Fitur numerik (int/float): dibinarisasi otomatis per iterasi
+- Fitur kategorikal 3+ kelas: wajib OneHotEncode terlebih dahulu
+
+```python
+from sklearn.preprocessing import OneHotEncoder
+enc = OneHotEncoder(sparse_output=False, drop='first')
+X_encoded = enc.fit_transform(X[['kolom_kategorikal']])
+```
+
+BinBoost secara otomatis mendeteksi kelompok fitur OneHotEncoding dan mencegah aturan yang tidak masuk akal seperti `(Warna_Merah AND Warna_Biru)`.
+
+## Atribut Setelah Pelatihan
+```python
+model.rules_               # daftar teks aturan termasuk NOT jika ada
+model.rule_weights_        # bobot dua sisi [w0, w1] tiap aturan (hasil Newton + regularisasi)
+model.feature_importances_ # skor kepentingan fitur
+model.train_score_         # loss per iterasi
+model.rule_summary_        # ringkasan lengkap atau konversi ke DataFrame
+model.n_rules_             # jumlah aturan aktif
+model.feature_usage_       # frekuensi penggunaan tiap fitur
+model.thresholds_          # riwayat threshold biner per fitur numerik, per iterasi
+```
+
+## Lisensi
+MIT

binboost-0.2.3/README.md

@@ -0,0 +1,108 @@
+# BinBoost
+
+**Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner, dengan Regularisasi Newton-Hessian dan Dukungan Multi-Kelas**
+
+BinBoost adalah algoritma klasifikasi gradient boosting yang membangun ensemble aturan logika murni (AND, OR, XOR, termasuk negasi NOT) dengan binarisasi fitur numerik adaptif berbasis gradien pada setiap iterasi boosting. Bobot tiap aturan dihitung dengan pendekatan Newton (memakai Hessian per fungsi loss) dan regularisasi adaptif berbasis dukungan sampel & kompleksitas aturan. Setiap weak learner berupa aturan yang dapat dibaca langsung oleh manusia tanpa memerlukan alat bantu penjelasan pasca-pelatihan.
+
+## Kebaruan Utama
+- **Binarisasi adaptif berbasis gradien**: nilai ambang batas fitur numerik dicari per iterasi untuk memaksimalkan korelasi dengan gradien saat ini
+- **Ensemble aturan logika murni**: tidak ada pohon keputusan, setiap weak learner adalah aturan seperti: `(A AND B)`, `(C OR D)`, atau `(A AND NOT B)`
+- **Youden J**: Penggunaan indeks Youden J sebagai `threshold='auto'` bawaan untuk menentukan titik potong prediksi, bukan fixed di 0.5 serta mengoptimalkan sensitivity + specificity pada data training, cocok untuk kasus kelas tidak seimbang
+- **Fitur ternegasi (NOT)**: pencarian aturan otomatis mempertimbangkan dua polaritas (asli dan negasi) untuk tiap kandidat fitur 
+- **Bobot aturan berbasis Newton (Hessian)**: bobot dua sisi tiap aturan dihitung dengan `w = G/(H+λ)`, memakai turunan kedua (Hessian) yang sesuai dengan fungsi loss yang dipilih (logistic, focal, atau poly), bukan sekadar rata-rata gradien
+- **Regularisasi adaptif**: `λ` menyesuaikan otomatis terhadap jumlah sampel dan panjang aturan, sehingga aturan dengan cakupan kecil/kompleks ditahan bobotnya secara proporsional
+- **Minimum-gain pruning (`gamma`)**: aturan dengan kontribusi terlalu kecil bisa ditolak sebelum masuk ensemble, membantu mencegah overfitting pada aturan yang terlalu spesifik
+- **Dukungan multi-kelas**: lewat `binboost.multiclass.OneVsRestBinBoost`, BinBoost bisa dipakai untuk klasifikasi dengan lebih dari 2 kelas (strategi One-vs-Rest)
+
+## Instalasi
+```bash
+pip install binboost
+```
+
+## Penggunaan Dasar untuk Klasifikasi Biner
+```python
+import numpy as np
+from binboost import BinBoost
+
+X = np.array([[1, 0, 1], [0, 1, 0], [1, 1, 0], [0, 0, 1]], dtype=float)
+y = np.array([1, 0, 1, 0])
+
+model = BinBoost(n_estimators=100, learning_rate=0.2, max_rule_length=4)
+model.fit(X, y)
+
+print(model.predict(X))
+print(model.predict_proba(X))
+print(model.rules_)
+
+import pandas as pd
+print(pd.DataFrame(model.rule_summary_))
+```
+
+## Penggunaan Multi-Kelas (>2 kelas)
+Untuk label dengan lebih dari 2 kelas yang saling eksklusif, gunakan `OneVsRestBinBoost` — hyperparameter yang diteruskan persis sama dengan `BinBoost`:
+
+```python
+from binboost.multiclass import OneVsRestBinBoost
+
+model = OneVsRestBinBoost(
+    mode='multiclass',
+    n_estimators=100,
+    learning_rate=0.2,
+    max_rule_length=4,
+    lambda0=3.0,
+)
+model.fit(X, y)                          # y boleh berisi >2 kelas, mis. array string atau integer
+
+print(model.predict(X))
+print(model.predict_proba(X))            # dinormalisasi supaya tiap baris berjumlah 1
+print(pd.DataFrame(model.rule_summary_)) # aturan per kelas, kolom 'kelas' menandai sub-model asalnya
+```
+
+`mode='multilabel'` tersedia untuk kasus di mana satu sampel bisa punya lebih dari satu label positif sekaligus dimana probabilitas tidak dinormalisasi, tiap kelas diputuskan independen.
+
+## Hyperparameter Utama
+
+| Parameter | Bawaan | Keterangan |
+|---|---|---|
+| `n_estimators` | 100 | Jumlah iterasi boosting |
+| `learning_rate` | 0.2 | Faktor penyusutan tiap aturan |
+| `loss` | `'logistic'` | Fungsi loss: `'logistic'`, `'focal'`, `'poly'` |
+| `max_rule_length` | 4 | Jumlah maksimum fitur dalam satu aturan |
+| `operators` | `['AND','OR']` | Operator logika yang digunakan ubah `use_xor=True` untuk mengaktifkan XOR |
+| `beam_width` | 5 | Lebar beam search |
+| `binarize_strategy` | `'gradient'` | Strategi binarisasi: `'gradient'`, `'quantile'`, `'uniform'`, `'kmeans'` |
+| `subsample` | 0.8 | Fraksi data per iterasi |
+| `feature_selection_threshold` | 0.0 | Ambang batas persentil gain fitur untuk seleksi kandidat (0.0 = semua fitur) |
+| `min_samples_rule` | 5 | Jumlah/fraksi minimum sampel yang harus memenuhi sebuah aturan |
+| `lambda0` | 3.0 | Konstanta regularisasi Newton adaptif |
+| `gamma` | 0.0 | Ambang minimum gain untuk menerima sebuah aturan (0.0 = tanpa pruning, nonaktif secara bawaan) |
+
+Fitur negasi (NOT) aktif otomatis pada pencarian aturan dan bukan hyperparameter yang bisa diatur lewat `BinBoost()` — ini bagian tetap dari mekanisme beam search.
+
+## Fitur yang Didukung
+- Fitur biner (0/1): langsung diproses
+- Fitur numerik (int/float): dibinarisasi otomatis per iterasi
+- Fitur kategorikal 3+ kelas: wajib OneHotEncode terlebih dahulu
+
+```python
+from sklearn.preprocessing import OneHotEncoder
+enc = OneHotEncoder(sparse_output=False, drop='first')
+X_encoded = enc.fit_transform(X[['kolom_kategorikal']])
+```
+
+BinBoost secara otomatis mendeteksi kelompok fitur OneHotEncoding dan mencegah aturan yang tidak masuk akal seperti `(Warna_Merah AND Warna_Biru)`.
+
+## Atribut Setelah Pelatihan
+```python
+model.rules_               # daftar teks aturan termasuk NOT jika ada
+model.rule_weights_        # bobot dua sisi [w0, w1] tiap aturan (hasil Newton + regularisasi)
+model.feature_importances_ # skor kepentingan fitur
+model.train_score_         # loss per iterasi
+model.rule_summary_        # ringkasan lengkap atau konversi ke DataFrame
+model.n_rules_             # jumlah aturan aktif
+model.feature_usage_       # frekuensi penggunaan tiap fitur
+model.thresholds_          # riwayat threshold biner per fitur numerik, per iterasi
+```
+
+## Lisensi
+MIT

{binboost-0.2.1 → binboost-0.2.3}/binboost/__init__.py

@@ -1,5 +1,6 @@
 from .binboost import BinBoost
+from .multiclass import OneVsRestBinBoost
 
-__version__ = "0.2.1"
+__version__ = "0.2.3"
 __author__ = "Rangga Wahyu Pratama"
 __all__ = ["BinBoost"]

{binboost-0.2.1 → binboost-0.2.3}/binboost/binarizer.py

@@ -1,4 +1,4 @@
-# Binarizer.py
+# binboost/binarizer.py
 import numpy as np
 
 

{binboost-0.2.1 → binboost-0.2.3}/binboost/binboost.py

@@ -1,3 +1,4 @@
+# binboost/binboost.py
 import numpy as np
 
 from .loss import get_loss, sigmoid
@@ -9,7 +10,7 @@ class BinBoost:
     """
     BinBoost: Gradient Boosting Berbasis Aturan Logika Adaptif.
 
-    Algoritma klasifikasi biner yang membangun ensemble aturan logika
+    Algoritma klasifikasi biner yang membangun ensemble aturan logika 
     murni (AND, OR, XOR) dengan binarisasi fitur numerik adaptif
     berbasis gradien pada setiap iterasi boosting.
 
@@ -18,7 +19,7 @@ class BinBoost:
     n_estimators : int, default=100
         Jumlah iterasi boosting.
 
-    learning_rate : float, default=0.1
+    learning_rate : float, default=0.2
         Faktor penyusutan kontribusi setiap aturan.
 
     loss : str, default='logistic'
@@ -33,7 +34,7 @@ class BinBoost:
     focal_alpha : float, default=0.25
         Parameter alpha pada Focal Loss. Hanya berlaku saat loss='focal'.
 
-    max_rule_length : int, default=3
+    max_rule_length : int, default=4
         Jumlah maksimum fitur dalam satu aturan.
 
     operators : list, default=['AND', 'OR']
@@ -59,7 +60,7 @@ class BinBoost:
     min_samples_rule : int or float, default=5
         Jumlah minimum sampel yang harus memenuhi sebuah aturan.
 
-    lambda0 : float, default=1.0
+    lambda0 : float, default=3.0
         Konstanta regularisasi dasar untuk bobot Newton adaptif (λ_R = lambda0 · L / sqrt(n_R+1)).
 
     binarize_strategy : str, default='gradient'
@@ -122,12 +123,12 @@ class BinBoost:
     def __init__(
         self,
         n_estimators=100,
-        learning_rate=0.1,
+        learning_rate=0.2,
         loss='logistic',
         poly_epsilon=1.0,
         focal_gamma=2.0,
         focal_alpha=0.25,
-        max_rule_length=3,
+        max_rule_length=4,
         operators=None,
         use_xor=False,
         rule_complexity_penalty=0.0,
@@ -135,7 +136,8 @@ class BinBoost:
         beam_width=5,
         subsample=0.8,
         min_samples_rule=5,
-        lambda0=1.0, 
+        lambda0=3.0, 
+        gamma=0.0,
         binarize_strategy='gradient',
         n_thresholds='auto',
         n_iter_no_change=None,
@@ -159,6 +161,7 @@ class BinBoost:
         self.subsample = subsample
         self.min_samples_rule = min_samples_rule
         self.lambda0 = lambda0  
+        self.gamma = gamma
         self.binarize_strategy = binarize_strategy
         self.n_thresholds = n_thresholds
         self.n_iter_no_change = n_iter_no_change
@@ -322,6 +325,7 @@ class BinBoost:
             min_samples_rule=self.min_samples_rule,
             rule_complexity_penalty=self.rule_complexity_penalty,
             ohe_groups=self.ohe_groups_,
+            gamma=self.gamma,
         )
 
         if not self.warm_start or not hasattr(self, 'estimators_'):
@@ -438,16 +442,25 @@ class BinBoost:
                 skor_terbaik = youden
                 threshold_terbaik = t
         return float(threshold_terbaik)
+    
+    def _binarize_untuk_iterasi(self, X, iterasi_idx, numeric_cols):
+        X_bin = X.copy().astype(np.float64)
+        for col in numeric_cols:
+            t = self.thresholds_[col][iterasi_idx]
+            X_bin[:, col] = (X[:, col] > t).astype(np.float64)
+        return X_bin
 
     def _decision_function(self, X):
-        # Hitung nilai F akhir untuk seluruh sampel menggunakan update dua sisi
         self._check_is_fitted()
         X, _ = self._validate_input(X)
         F = np.zeros(X.shape[0])
         numeric_cols = self._detect_numeric_cols(X)
-        dummy_grad = np.ones(X.shape[0])
-        X_bin, _ = self._binarizer.transform(X, dummy_grad, numeric_cols)
-        for rule, weights in zip(self.estimators_, self.rule_weights_):
+        for i, (rule, weights) in enumerate(zip(self.estimators_, self.rule_weights_)):
+            if self.binarize_strategy == 'gradient' and numeric_cols:
+                X_bin = self._binarize_untuk_iterasi(X, i, numeric_cols)
+            else:
+                dummy_grad = np.ones(X.shape[0])
+                X_bin, _ = self._binarizer.transform(X, dummy_grad, numeric_cols)
             h = rule.evaluate(X_bin)
             w0, w1 = weights[0], weights[1]
             F += self.learning_rate * (w1 * h + w0 * (1.0 - h))
@@ -509,10 +522,13 @@ class BinBoost:
         self._check_is_fitted()
         X, _ = self._validate_input(X)
         numeric_cols = self._detect_numeric_cols(X)
-        dummy_grad = np.ones(X.shape[0])
-        X_bin, _ = self._binarizer.transform(X, dummy_grad, numeric_cols)
         F = np.zeros(X.shape[0])
-        for rule, weights in zip(self.estimators_, self.rule_weights_):
+        for i, (rule, weights) in enumerate(zip(self.estimators_, self.rule_weights_)):
+            if self.binarize_strategy == 'gradient' and numeric_cols:
+                X_bin = self._binarize_untuk_iterasi(X, i, numeric_cols)
+            else:
+                dummy_grad = np.ones(X.shape[0])
+                X_bin, _ = self._binarizer.transform(X, dummy_grad, numeric_cols)
             h = rule.evaluate(X_bin)
             w0, w1 = weights[0], weights[1]
             F += self.learning_rate * (w1 * h + w0 * (1.0 - h))
@@ -533,7 +549,7 @@ class BinBoost:
     def apply(self, X):
         """
         Kembalikan nilai aktivasi setiap aturan untuk setiap sampel.
-
+    
         Kembalian
         ----------
         ndarray of shape (n_samples, n_estimators_)
@@ -541,11 +557,16 @@ class BinBoost:
         self._check_is_fitted()
         X, _ = self._validate_input(X)
         numeric_cols = self._detect_numeric_cols(X)
-        dummy_grad = np.ones(X.shape[0])
-        X_bin, _ = self._binarizer.transform(X, dummy_grad, numeric_cols)
         results = []
-        for rule in self.estimators_:
-            results.append(rule.evaluate(X_bin))
+        
+        for i, rule in enumerate(self.estimators_):
+            if self.binarize_strategy == 'gradient' and numeric_cols:
+                X_bin = self._binarize_untuk_iterasi(X, i, numeric_cols)
+            else:
+                dummy_grad = np.ones(X.shape[0])
+                X_bin, _ = self._binarizer.transform(X, dummy_grad, numeric_cols)
+                results.append(rule.evaluate(X_bin))
+                
         return np.column_stack(results)
 
     def get_params(self, deep=True):
@@ -571,7 +592,8 @@ class BinBoost:
             'beam_width': self.beam_width,
             'subsample': self.subsample,
             'min_samples_rule': self.min_samples_rule,
-            'lambda0': self.lambda0,          
+            'lambda0': self.lambda0,  
+            'gamma': self.gamma,       
             'binarize_strategy': self.binarize_strategy,
             'n_thresholds': self.n_thresholds,
             'n_iter_no_change': self.n_iter_no_change,

{binboost-0.2.1 → binboost-0.2.3}/binboost/loss.py

@@ -1,4 +1,4 @@
-# loss.py
+# binboost/loss.py
 import numpy as np
 
 def sigmoid(x):

binboost-0.2.3/binboost/multiclass.py

@@ -0,0 +1,78 @@
+# binboost/multiclass.py
+import numpy as np
+from .binboost import BinBoost
+
+
+class OneVsRestBinBoost:
+    """
+    Ekstensi BinBoost untuk klasifikasi multi-kelas (>2 kelas) lewat strategi
+    One-vs-Rest, mirip pola sklearn.multiclass.OneVsRestClassifier.
+    Untuk 2 kelas, gunakan langsung BinBoost.
+    """
+
+    def __init__(self, mode='multiclass', **binboost_params):
+        self.mode = mode
+        self.binboost_params = binboost_params
+
+    def fit(self, X, y):
+        X = np.asarray(X, dtype=np.float64)
+        y = np.asarray(y)
+        self.classes_ = np.unique(y)
+        self.n_classes_ = len(self.classes_)
+        if self.n_classes_ < 2:
+            raise ValueError("Minimal harus ada 2 kelas berbeda pada label y.")
+        self.estimators_ovr_ = []
+        for kelas in self.classes_:
+            y_bin = (y == kelas).astype(np.float64)
+            model_k = BinBoost(**self.binboost_params)
+            model_k.fit(X, y_bin)
+            self.estimators_ovr_.append(model_k)
+        return self
+
+    def _raw_scores(self, X):
+        return np.column_stack([m.predict_proba(X)[:, 1] for m in self.estimators_ovr_])
+
+    def predict_proba(self, X):
+        raw = self._raw_scores(X)
+        if self.mode == 'multilabel':
+            return raw
+        total = raw.sum(axis=1, keepdims=True)
+        semua_nol = (total.flatten() <= 1e-10)
+        total_aman = np.where(total <= 1e-10, 1.0, total)
+        probs = raw / total_aman
+        if semua_nol.any():
+            probs[semua_nol] = 1.0 / self.n_classes_
+        return probs
+
+    def predict(self, X):
+        if self.mode == 'multilabel':
+            return np.column_stack([m.predict(X) for m in self.estimators_ovr_])
+        probs = self.predict_proba(X)
+        idx = np.argmax(probs, axis=1)
+        return self.classes_[idx]
+
+    def score(self, X, y):
+        y = np.asarray(y)
+        return np.mean(self.predict(X) == y)
+
+    @property
+    def rule_summary_(self):
+        rows = []
+        for kelas, model_k in zip(self.classes_, self.estimators_ovr_):
+            for r in model_k.rule_summary_:
+                r = dict(r)
+                r['kelas'] = kelas
+                rows.append(r)
+        return rows
+
+    @property
+    def feature_usage_(self):
+        usage_total = {}
+        for model_k in self.estimators_ovr_:
+            for k, v in model_k.feature_usage_.items():
+                usage_total[k] = usage_total.get(k, 0) + v
+        return usage_total
+
+    @property
+    def n_rules_(self):
+        return sum(m.n_rules_ for m in self.estimators_ovr_)

{binboost-0.2.1 → binboost-0.2.3}/binboost/rule.py

@@ -1,23 +1,26 @@
-# rule.py
+# binboost/rule.py
 import numpy as np
 
 class Rule:
-    # Satu aturan logika dalam ensemble BinBoost
-    def __init__(self, features, operators, weight, feature_names=None):
-        # 1. Simpan komponen aturan
-        # a. Indeks fitur yang terlibat dalam aturan
+    # Satu aturan logika dalam ensemble BinBoost, dengan dukungan negasi (NOT) per fitur
+    def __init__(self, features, operators, weight, negations=None, feature_names=None):
         self.features = features
-        # b. Daftar operator logika antar fitur
         self.operators = operators
-        # c. Bobot optimal hasil perhitungan w_m*
-        self.weight = weight
+        self._search_weight = weight
+        self.negations = negations if negations is not None else [False] * len(features)
         self.feature_names = feature_names
 
+    def _kolom(self, X_bin, idx_dalam_features):
+        fitur_idx = self.features[idx_dalam_features]
+        kolom = X_bin[:, fitur_idx].astype(bool)
+        if self.negations[idx_dalam_features]:
+            kolom = ~kolom
+        return kolom
+
     def evaluate(self, X_bin):
-        # Hitung keluaran aturan untuk setiap sampel dan kembalikan larik biner
-        result = X_bin[:, self.features[0]].astype(bool)
+        result = self._kolom(X_bin, 0)
         for i, op in enumerate(self.operators):
-            next_col = X_bin[:, self.features[i + 1]].astype(bool)
+            next_col = self._kolom(X_bin, i + 1)
             if op == 'AND':
                 result = result & next_col
             elif op == 'OR':
@@ -27,12 +30,12 @@ class Rule:
         return result.astype(np.float64)
 
     def to_string(self, feature_names=None):
-        # Kembalikan representasi teks aturan yang dapat dibaca manusia
         names = feature_names if feature_names is not None else self.feature_names
         if names is None:
-            parts = [f"X{f}" for f in self.features]
+            base_parts = [f"X{f}" for f in self.features]
         else:
-            parts = [str(names[f]) for f in self.features]
+            base_parts = [str(names[f]) for f in self.features]
+        parts = [f"NOT {p}" if neg else p for p, neg in zip(base_parts, self.negations)]
         if len(parts) == 1:
             return parts[0]
         expr = parts[0]
@@ -41,15 +44,13 @@ class Rule:
         return expr
 
     def __repr__(self):
-        return f"Rule({self.to_string()}, weight={self.weight:.4f})"
+        return f"Rule({self.to_string()})"
 
 
 class BeamSearchRuleFinder:
-    # Pencari aturan terbaik menggunakan beam search tervektorisasi berbasis numpy
-
     def __init__(self, operators, max_rule_length, beam_width,
                  feature_selection_threshold, min_samples_rule,
-                 rule_complexity_penalty, ohe_groups=None):
+                 rule_complexity_penalty, ohe_groups=None, allow_negation=True, gamma=0.0):
         self.operators = operators
         self.max_rule_length = max_rule_length
         self.beam_width = beam_width
@@ -57,8 +58,9 @@ class BeamSearchRuleFinder:
         self.min_samples_rule = min_samples_rule
         self.rule_complexity_penalty = rule_complexity_penalty
         self.ohe_groups = ohe_groups
+        self.allow_negation = allow_negation
+        self.gamma = gamma
 
-        # Bangun peta indeks fitur ke grup OHE untuk pencarian constraint yang cepat
         self._feature_to_group = {}
         if ohe_groups is not None:
             for gid, members in ohe_groups.items():
@@ -66,8 +68,6 @@ class BeamSearchRuleFinder:
                     self._feature_to_group[f] = gid
 
     def _select_features(self, X_bin, gradients):
-        # 1. Pilih fitur kandidat berdasarkan skor korelasi gradien secara tervektorisasi
-        # a. Hitung dot product gradien dengan semua kolom sekaligus dalam satu operasi
         dot_products = np.abs(X_bin.T @ gradients)
         col_sums = X_bin.sum(axis=0) + 1e-10
         scores = dot_products / col_sums
@@ -77,29 +77,24 @@ class BeamSearchRuleFinder:
         return selected
 
     def _compute_scores_batch(self, H_batch, gradients):
-        # 1. Hitung bobot optimal dan skor untuk banyak kandidat aturan sekaligus
-        # a. H_batch berukuran (n_kandidat, n_sampel)
         dot_gh = H_batch @ gradients
         dot_hh = (H_batch * H_batch).sum(axis=1)
         valid = dot_hh > 1e-10
         w = np.where(valid, dot_gh / np.where(dot_hh > 1e-10, dot_hh, 1.0), 0.0)
-        # b. Kurangi gradien dengan prediksi berbobot untuk semua kandidat sekaligus
         residual = gradients[np.newaxis, :] - w[:, np.newaxis] * H_batch
         scores = (residual * residual).sum(axis=1)
         scores = np.where(valid, scores, np.inf)
         return w, scores, valid
 
     def _min_samples_int(self, n_samples):
-        # Kembalikan jumlah sampel minimum dalam bentuk bilangan bulat
         if isinstance(self.min_samples_rule, float) and self.min_samples_rule < 1.0:
             return max(1, int(self.min_samples_rule * n_samples))
         return int(self.min_samples_rule)
 
     def find_best_rule(self, X_bin, gradients):
-        # 1. Jalankan beam search tervektorisasi untuk menemukan aturan terbaik
         n_samples, n_features = X_bin.shape
         min_s = self._min_samples_int(n_samples)
-        # Gunakan candidate features yang dikirim dari luar jika tersedia
+        baseline = float(np.dot(gradients, gradients))
         if hasattr(self, 'forced_candidate_features') and self.forced_candidate_features is not None:
             candidate_features = self.forced_candidate_features
         else:
@@ -109,42 +104,49 @@ class BeamSearchRuleFinder:
             return None
 
         X_bin_bool = X_bin.astype(bool)
-
-        # 2. Inisialisasi beam dengan evaluasi semua aturan panjang satu secara batch
-        H_init = X_bin_bool[:, candidate_features].T.astype(np.float64)
+        polaritas_list = [False, True] if self.allow_negation else [False]
+
+        # 1. Inisialisasi beam panjang satu — coba dua polaritas (asli & negasi) per fitur
+        H_list, meta_list = [], []
+        for cf in candidate_features:
+            kolom_pos = X_bin_bool[:, int(cf)]
+            for neg in polaritas_list:
+                kolom = ~kolom_pos if neg else kolom_pos
+                H_list.append(kolom.astype(np.float64))
+                meta_list.append((int(cf), neg))
+
+        H_init = np.array(H_list)
         support_init = H_init.sum(axis=1)
         valid_init = support_init >= min_s
-
         if not valid_init.any():
             return None
 
         w_init, scores_init, w_valid = self._compute_scores_batch(H_init, gradients)
-        valid_mask = valid_init & w_valid
-
+        gain_init = baseline - scores_init
+        valid_mask = valid_init & w_valid & (gain_init >= self.gamma)
         if not valid_mask.any():
             return None
 
         candidates = []
-        for i, cf in enumerate(candidate_features):
+        for i, (cf, neg) in enumerate(meta_list):
             if valid_mask[i]:
                 pen = scores_init[i] * (1 + self.rule_complexity_penalty * 1)
-                candidates.append((pen, [int(cf)], [], X_bin_bool[:, int(cf)]))
+                candidates.append((pen, [cf], [], [neg], H_init[i].astype(bool)))
 
         if not candidates:
             return None
 
         candidates.sort(key=lambda x: x[0])
         beam = candidates[:self.beam_width]
-        best_score, best_feats, best_ops, best_h = beam[0]
+        best_score, best_feats, best_ops, best_negs, best_h = beam[0]
 
-        # 3. Perluas aturan hingga panjang maksimum menggunakan operasi numpy batch
+        # 2. Perluas aturan hingga panjang maksimum
         for length in range(2, self.max_rule_length + 1):
             new_candidates = []
 
-            for beam_score, beam_feats, beam_ops, beam_h in beam:
+            for beam_score, beam_feats, beam_ops, beam_negs, beam_h in beam:
                 beam_feat_set = set(beam_feats)
 
-                # a. Tentukan fitur yang dapat diperluas dengan mempertimbangkan constraint OHE
                 expandable = []
                 for cf in candidate_features:
                     cf_int = int(cf)
@@ -159,42 +161,43 @@ class BeamSearchRuleFinder:
                 if not expandable:
                     continue
 
-                # b. Ambil semua kolom yang bisa diperluas sekaligus
-                cols = X_bin_bool[:, expandable].T
-
-                for op in self.operators:
-                    # c. Terapkan operator ke semua fitur sekaligus dalam satu operasi numpy
-                    beam_h_2d = np.broadcast_to(beam_h, cols.shape)
-                    if op == 'AND':
-                        H_new = (beam_h_2d & cols).astype(np.float64)
-                    elif op == 'OR':
-                        H_new = (beam_h_2d | cols).astype(np.float64)
-                    elif op == 'XOR':
-                        H_new = (beam_h_2d ^ cols).astype(np.float64)
-                    else:
-                        continue
-
-                    support_new = H_new.sum(axis=1)
-                    valid_sup = support_new >= min_s
-
-                    if not valid_sup.any():
-                        continue
-
-                    w_new, scores_new, w_valid_new = self._compute_scores_batch(
-                        H_new, gradients
-                    )
-                    valid_combined = valid_sup & w_valid_new
+                cols_pos = X_bin_bool[:, expandable].T
+                kandidat_kolom = [(cols_pos, False)]
+                if self.allow_negation:
+                    kandidat_kolom.append((~cols_pos, True))
+
+                for cols, neg_flag in kandidat_kolom:
+                    for op in self.operators:
+                        beam_h_2d = np.broadcast_to(beam_h, cols.shape)
+                        if op == 'AND':
+                            H_new = (beam_h_2d & cols).astype(np.float64)
+                        elif op == 'OR':
+                            H_new = (beam_h_2d | cols).astype(np.float64)
+                        elif op == 'XOR':
+                            H_new = (beam_h_2d ^ cols).astype(np.float64)
+                        else:
+                            continue
 
-                    for j, cf_int in enumerate(expandable):
-                        if not valid_combined[j]:
+                        support_new = H_new.sum(axis=1)
+                        valid_sup = support_new >= min_s
+                        if not valid_sup.any():
                             continue
-                        pen = scores_new[j] * (1 + self.rule_complexity_penalty * length)
-                        new_candidates.append((
-                            pen,
-                            beam_feats + [cf_int],
-                            beam_ops + [op],
-                            H_new[j].astype(bool)
-                        ))
+
+                        w_new, scores_new, w_valid_new = self._compute_scores_batch(H_new, gradients)
+                        gain_new = baseline - scores_new
+                        valid_combined = valid_sup & w_valid_new & (gain_new >= self.gamma)
+
+                        for j, cf_int in enumerate(expandable):
+                            if not valid_combined[j]:
+                                continue
+                            pen = scores_new[j] * (1 + self.rule_complexity_penalty * length)
+                            new_candidates.append((
+                                pen,
+                                beam_feats + [cf_int],
+                                beam_ops + [op],
+                                beam_negs + [neg_flag],
+                                H_new[j].astype(bool)
+                            ))
 
             if not new_candidates:
                 break
@@ -203,16 +206,15 @@ class BeamSearchRuleFinder:
             new_candidates = new_candidates[:self.beam_width]
 
             if new_candidates[0][0] < best_score:
-                best_score, best_feats, best_ops, best_h = new_candidates[0]
+                best_score, best_feats, best_ops, best_negs, best_h = new_candidates[0]
                 beam = new_candidates
             else:
                 break
 
-        # 4. Hitung ulang bobot optimal untuk aturan terbaik yang dipilih
         h_final = best_h.astype(np.float64)
         denom = np.dot(h_final, h_final)
         if denom < 1e-10:
             return None
         w_final = np.dot(gradients, h_final) / denom
 
-        return Rule(best_feats, best_ops, w_final)
+        return Rule(best_feats, best_ops, w_final, negations=best_negs)

binboost-0.2.3/binboost.egg-info/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: binboost
+Version: 0.2.3
+Summary: Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner
+Author: Rangga Wahyu Pratama
+License: MIT
+Keywords: gradient boosting,logical rules,binary features,interpretable machine learning
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: pandas>=1.3.0
+Dynamic: author
+Dynamic: license-file
+Dynamic: requires-python
+
+# BinBoost
+
+**Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner, dengan Regularisasi Newton-Hessian dan Dukungan Multi-Kelas**
+
+BinBoost adalah algoritma klasifikasi gradient boosting yang membangun ensemble aturan logika murni (AND, OR, XOR, termasuk negasi NOT) dengan binarisasi fitur numerik adaptif berbasis gradien pada setiap iterasi boosting. Bobot tiap aturan dihitung dengan pendekatan Newton (memakai Hessian per fungsi loss) dan regularisasi adaptif berbasis dukungan sampel & kompleksitas aturan. Setiap weak learner berupa aturan yang dapat dibaca langsung oleh manusia tanpa memerlukan alat bantu penjelasan pasca-pelatihan.
+
+## Kebaruan Utama
+- **Binarisasi adaptif berbasis gradien**: nilai ambang batas fitur numerik dicari per iterasi untuk memaksimalkan korelasi dengan gradien saat ini
+- **Ensemble aturan logika murni**: tidak ada pohon keputusan, setiap weak learner adalah aturan seperti: `(A AND B)`, `(C OR D)`, atau `(A AND NOT B)`
+- **Youden J**: Penggunaan indeks Youden J sebagai `threshold='auto'` bawaan untuk menentukan titik potong prediksi, bukan fixed di 0.5 serta mengoptimalkan sensitivity + specificity pada data training, cocok untuk kasus kelas tidak seimbang
+- **Fitur ternegasi (NOT)**: pencarian aturan otomatis mempertimbangkan dua polaritas (asli dan negasi) untuk tiap kandidat fitur 
+- **Bobot aturan berbasis Newton (Hessian)**: bobot dua sisi tiap aturan dihitung dengan `w = G/(H+λ)`, memakai turunan kedua (Hessian) yang sesuai dengan fungsi loss yang dipilih (logistic, focal, atau poly), bukan sekadar rata-rata gradien
+- **Regularisasi adaptif**: `λ` menyesuaikan otomatis terhadap jumlah sampel dan panjang aturan, sehingga aturan dengan cakupan kecil/kompleks ditahan bobotnya secara proporsional
+- **Minimum-gain pruning (`gamma`)**: aturan dengan kontribusi terlalu kecil bisa ditolak sebelum masuk ensemble, membantu mencegah overfitting pada aturan yang terlalu spesifik
+- **Dukungan multi-kelas**: lewat `binboost.multiclass.OneVsRestBinBoost`, BinBoost bisa dipakai untuk klasifikasi dengan lebih dari 2 kelas (strategi One-vs-Rest)
+
+## Instalasi
+```bash
+pip install binboost
+```
+
+## Penggunaan Dasar untuk Klasifikasi Biner
+```python
+import numpy as np
+from binboost import BinBoost
+
+X = np.array([[1, 0, 1], [0, 1, 0], [1, 1, 0], [0, 0, 1]], dtype=float)
+y = np.array([1, 0, 1, 0])
+
+model = BinBoost(n_estimators=100, learning_rate=0.2, max_rule_length=4)
+model.fit(X, y)
+
+print(model.predict(X))
+print(model.predict_proba(X))
+print(model.rules_)
+
+import pandas as pd
+print(pd.DataFrame(model.rule_summary_))
+```
+
+## Penggunaan Multi-Kelas (>2 kelas)
+Untuk label dengan lebih dari 2 kelas yang saling eksklusif, gunakan `OneVsRestBinBoost` — hyperparameter yang diteruskan persis sama dengan `BinBoost`:
+
+```python
+from binboost.multiclass import OneVsRestBinBoost
+
+model = OneVsRestBinBoost(
+    mode='multiclass',
+    n_estimators=100,
+    learning_rate=0.2,
+    max_rule_length=4,
+    lambda0=3.0,
+)
+model.fit(X, y)                          # y boleh berisi >2 kelas, mis. array string atau integer
+
+print(model.predict(X))
+print(model.predict_proba(X))            # dinormalisasi supaya tiap baris berjumlah 1
+print(pd.DataFrame(model.rule_summary_)) # aturan per kelas, kolom 'kelas' menandai sub-model asalnya
+```
+
+`mode='multilabel'` tersedia untuk kasus di mana satu sampel bisa punya lebih dari satu label positif sekaligus dimana probabilitas tidak dinormalisasi, tiap kelas diputuskan independen.
+
+## Hyperparameter Utama
+
+| Parameter | Bawaan | Keterangan |
+|---|---|---|
+| `n_estimators` | 100 | Jumlah iterasi boosting |
+| `learning_rate` | 0.2 | Faktor penyusutan tiap aturan |
+| `loss` | `'logistic'` | Fungsi loss: `'logistic'`, `'focal'`, `'poly'` |
+| `max_rule_length` | 4 | Jumlah maksimum fitur dalam satu aturan |
+| `operators` | `['AND','OR']` | Operator logika yang digunakan ubah `use_xor=True` untuk mengaktifkan XOR |
+| `beam_width` | 5 | Lebar beam search |
+| `binarize_strategy` | `'gradient'` | Strategi binarisasi: `'gradient'`, `'quantile'`, `'uniform'`, `'kmeans'` |
+| `subsample` | 0.8 | Fraksi data per iterasi |
+| `feature_selection_threshold` | 0.0 | Ambang batas persentil gain fitur untuk seleksi kandidat (0.0 = semua fitur) |
+| `min_samples_rule` | 5 | Jumlah/fraksi minimum sampel yang harus memenuhi sebuah aturan |
+| `lambda0` | 3.0 | Konstanta regularisasi Newton adaptif |
+| `gamma` | 0.0 | Ambang minimum gain untuk menerima sebuah aturan (0.0 = tanpa pruning, nonaktif secara bawaan) |
+
+Fitur negasi (NOT) aktif otomatis pada pencarian aturan dan bukan hyperparameter yang bisa diatur lewat `BinBoost()` — ini bagian tetap dari mekanisme beam search.
+
+## Fitur yang Didukung
+- Fitur biner (0/1): langsung diproses
+- Fitur numerik (int/float): dibinarisasi otomatis per iterasi
+- Fitur kategorikal 3+ kelas: wajib OneHotEncode terlebih dahulu
+
+```python
+from sklearn.preprocessing import OneHotEncoder
+enc = OneHotEncoder(sparse_output=False, drop='first')
+X_encoded = enc.fit_transform(X[['kolom_kategorikal']])
+```
+
+BinBoost secara otomatis mendeteksi kelompok fitur OneHotEncoding dan mencegah aturan yang tidak masuk akal seperti `(Warna_Merah AND Warna_Biru)`.
+
+## Atribut Setelah Pelatihan
+```python
+model.rules_               # daftar teks aturan termasuk NOT jika ada
+model.rule_weights_        # bobot dua sisi [w0, w1] tiap aturan (hasil Newton + regularisasi)
+model.feature_importances_ # skor kepentingan fitur
+model.train_score_         # loss per iterasi
+model.rule_summary_        # ringkasan lengkap atau konversi ke DataFrame
+model.n_rules_             # jumlah aturan aktif
+model.feature_usage_       # frekuensi penggunaan tiap fitur
+model.thresholds_          # riwayat threshold biner per fitur numerik, per iterasi
+```
+
+## Lisensi
+MIT

{binboost-0.2.1 → binboost-0.2.3}/binboost.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ binboost/__init__.py
 binboost/binarizer.py
 binboost/binboost.py
 binboost/loss.py
+binboost/multiclass.py
 binboost/rule.py
 binboost.egg-info/PKG-INFO
 binboost.egg-info/SOURCES.txt

{binboost-0.2.1 → binboost-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "binboost"
-version = "0.2.1"
+version = "0.2.3"
 description = "Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner"
 readme = "README.md"
 requires-python = ">=3.8"

{binboost-0.2.1 → binboost-0.2.3}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="binboost",
-    version="0.2.1",
+    version="0.2.3",
     author="Rangga Wahyu Pratama",
     description="Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner",
     long_description=open("README.md", encoding="utf-8").read(),

binboost-0.2.1/PKG-INFO

@@ -1,101 +0,0 @@
-Metadata-Version: 2.4
-Name: binboost
-Version: 0.2.1
-Summary: Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner
-Author: Rangga Wahyu Pratama
-License: MIT
-Keywords: gradient boosting,logical rules,binary features,interpretable machine learning
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Intended Audience :: Science/Research
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy>=1.21.0
-Requires-Dist: pandas>=1.3.0
-Dynamic: author
-Dynamic: license-file
-Dynamic: requires-python
-
-# BinBoost
-
-**Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner**
-
-BinBoost adalah algoritma klasifikasi gradient boosting yang membangun ensemble aturan logika murni (AND, OR, XOR) dengan binarisasi fitur numerik adaptif berbasis gradien pada setiap iterasi boosting. Setiap weak learner berupa aturan yang dapat dibaca langsung oleh manusia tanpa memerlukan alat bantu penjelasan pasca-pelatihan.
-
-## Kebaruan Utama
-
-- **Binarisasi adaptif berbasis gradien**: nilai ambang batas fitur numerik dicari per iterasi untuk memaksimalkan korelasi dengan gradien saat ini
-- **Ensemble aturan logika murni**: tidak ada pohon keputusan, setiap weak learner adalah aturan seperti `(A AND B)` atau `(C OR D)`
-
-## Instalasi
-
-```bash
-pip install binboost
-```
-
-## Penggunaan Dasar
-
-```python
-import numpy as np
-from binboost import BinBoost
-
-X = np.array([[1, 0, 1], [0, 1, 0], [1, 1, 0], [0, 0, 1]], dtype=float)
-y = np.array([1, 0, 1, 0])
-
-model = BinBoost(n_estimators=50, learning_rate=0.1, max_rule_length=2)
-model.fit(X, y)
-
-print(model.predict(X))
-print(model.predict_proba(X))
-print(model.rules_)
-
-import pandas as pd
-print(pd.DataFrame(model.rule_summary_))
-```
-
-## Hyperparameter Utama
-
-| Parameter | Bawaan | Keterangan |
-|---|---|---|
-| `n_estimators` | 100 | Jumlah iterasi boosting |
-| `learning_rate` | 0.1 | Faktor penyusutan tiap aturan |
-| `loss` | `'logistic'` | Fungsi loss: `'logistic'`, `'focal'`, `'poly'` |
-| `max_rule_length` | 2 | Jumlah maksimum fitur dalam satu aturan |
-| `operators` | `['AND','OR']` | Operator logika yang digunakan |
-| `beam_width` | 5 | Lebar beam search |
-| `binarize_strategy` | `'gradient'` | Strategi binarisasi: `'gradient'`, `'quantile'`, `'uniform'`, `'kmeans'` |
-| `subsample` | 0.8 | Fraksi data per iterasi |
-| `feature_selection_threshold` | 0.01 | Ambang batas seleksi fitur berbasis gradien |
-
-## Fitur yang Didukung
-
-- Fitur biner (0/1): langsung diproses
-- Fitur numerik (int/float): dibinarisasi otomatis
-- Fitur kategorikal 3+ kelas: wajib OneHotEncode terlebih dahulu
-
-```python
-from sklearn.preprocessing import OneHotEncoder
-enc = OneHotEncoder(sparse_output=False, drop='first')
-X_encoded = enc.fit_transform(X[['kolom_kategorikal']])
-```
-
-BinBoost secara otomatis mendeteksi kelompok fitur OneHotEncoding dan mencegah aturan yang tidak masuk akal seperti `(Warna_Merah AND Warna_Biru)`.
-
-## Atribut Setelah Pelatihan
-
-```python
-model.rules_               # daftar teks aturan
-model.rule_weights_        # bobot setiap aturan
-model.feature_importances_ # skor kepentingan fitur
-model.train_score_         # loss per iterasi
-model.rule_summary_        # ringkasan lengkap atau konversi ke DataFrame
-model.n_rules_             # jumlah aturan aktif
-model.feature_usage_       # frekuensi penggunaan tiap fitur
-```
-
-## Lisensi
-
-MIT

binboost-0.2.1/README.md

@@ -1,80 +0,0 @@
-# BinBoost
-
-**Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner**
-
-BinBoost adalah algoritma klasifikasi gradient boosting yang membangun ensemble aturan logika murni (AND, OR, XOR) dengan binarisasi fitur numerik adaptif berbasis gradien pada setiap iterasi boosting. Setiap weak learner berupa aturan yang dapat dibaca langsung oleh manusia tanpa memerlukan alat bantu penjelasan pasca-pelatihan.
-
-## Kebaruan Utama
-
-- **Binarisasi adaptif berbasis gradien**: nilai ambang batas fitur numerik dicari per iterasi untuk memaksimalkan korelasi dengan gradien saat ini
-- **Ensemble aturan logika murni**: tidak ada pohon keputusan, setiap weak learner adalah aturan seperti `(A AND B)` atau `(C OR D)`
-
-## Instalasi
-
-```bash
-pip install binboost
-```
-
-## Penggunaan Dasar
-
-```python
-import numpy as np
-from binboost import BinBoost
-
-X = np.array([[1, 0, 1], [0, 1, 0], [1, 1, 0], [0, 0, 1]], dtype=float)
-y = np.array([1, 0, 1, 0])
-
-model = BinBoost(n_estimators=50, learning_rate=0.1, max_rule_length=2)
-model.fit(X, y)
-
-print(model.predict(X))
-print(model.predict_proba(X))
-print(model.rules_)
-
-import pandas as pd
-print(pd.DataFrame(model.rule_summary_))
-```
-
-## Hyperparameter Utama
-
-| Parameter | Bawaan | Keterangan |
-|---|---|---|
-| `n_estimators` | 100 | Jumlah iterasi boosting |
-| `learning_rate` | 0.1 | Faktor penyusutan tiap aturan |
-| `loss` | `'logistic'` | Fungsi loss: `'logistic'`, `'focal'`, `'poly'` |
-| `max_rule_length` | 2 | Jumlah maksimum fitur dalam satu aturan |
-| `operators` | `['AND','OR']` | Operator logika yang digunakan |
-| `beam_width` | 5 | Lebar beam search |
-| `binarize_strategy` | `'gradient'` | Strategi binarisasi: `'gradient'`, `'quantile'`, `'uniform'`, `'kmeans'` |
-| `subsample` | 0.8 | Fraksi data per iterasi |
-| `feature_selection_threshold` | 0.01 | Ambang batas seleksi fitur berbasis gradien |
-
-## Fitur yang Didukung
-
-- Fitur biner (0/1): langsung diproses
-- Fitur numerik (int/float): dibinarisasi otomatis
-- Fitur kategorikal 3+ kelas: wajib OneHotEncode terlebih dahulu
-
-```python
-from sklearn.preprocessing import OneHotEncoder
-enc = OneHotEncoder(sparse_output=False, drop='first')
-X_encoded = enc.fit_transform(X[['kolom_kategorikal']])
-```
-
-BinBoost secara otomatis mendeteksi kelompok fitur OneHotEncoding dan mencegah aturan yang tidak masuk akal seperti `(Warna_Merah AND Warna_Biru)`.
-
-## Atribut Setelah Pelatihan
-
-```python
-model.rules_               # daftar teks aturan
-model.rule_weights_        # bobot setiap aturan
-model.feature_importances_ # skor kepentingan fitur
-model.train_score_         # loss per iterasi
-model.rule_summary_        # ringkasan lengkap atau konversi ke DataFrame
-model.n_rules_             # jumlah aturan aktif
-model.feature_usage_       # frekuensi penggunaan tiap fitur
-```
-
-## Lisensi
-
-MIT

binboost-0.2.1/binboost.egg-info/PKG-INFO

@@ -1,101 +0,0 @@
-Metadata-Version: 2.4
-Name: binboost
-Version: 0.2.1
-Summary: Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner
-Author: Rangga Wahyu Pratama
-License: MIT
-Keywords: gradient boosting,logical rules,binary features,interpretable machine learning
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Intended Audience :: Science/Research
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy>=1.21.0
-Requires-Dist: pandas>=1.3.0
-Dynamic: author
-Dynamic: license-file
-Dynamic: requires-python
-
-# BinBoost
-
-**Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner**
-
-BinBoost adalah algoritma klasifikasi gradient boosting yang membangun ensemble aturan logika murni (AND, OR, XOR) dengan binarisasi fitur numerik adaptif berbasis gradien pada setiap iterasi boosting. Setiap weak learner berupa aturan yang dapat dibaca langsung oleh manusia tanpa memerlukan alat bantu penjelasan pasca-pelatihan.
-
-## Kebaruan Utama
-
-- **Binarisasi adaptif berbasis gradien**: nilai ambang batas fitur numerik dicari per iterasi untuk memaksimalkan korelasi dengan gradien saat ini
-- **Ensemble aturan logika murni**: tidak ada pohon keputusan, setiap weak learner adalah aturan seperti `(A AND B)` atau `(C OR D)`
-
-## Instalasi
-
-```bash
-pip install binboost
-```
-
-## Penggunaan Dasar
-
-```python
-import numpy as np
-from binboost import BinBoost
-
-X = np.array([[1, 0, 1], [0, 1, 0], [1, 1, 0], [0, 0, 1]], dtype=float)
-y = np.array([1, 0, 1, 0])
-
-model = BinBoost(n_estimators=50, learning_rate=0.1, max_rule_length=2)
-model.fit(X, y)
-
-print(model.predict(X))
-print(model.predict_proba(X))
-print(model.rules_)
-
-import pandas as pd
-print(pd.DataFrame(model.rule_summary_))
-```
-
-## Hyperparameter Utama
-
-| Parameter | Bawaan | Keterangan |
-|---|---|---|
-| `n_estimators` | 100 | Jumlah iterasi boosting |
-| `learning_rate` | 0.1 | Faktor penyusutan tiap aturan |
-| `loss` | `'logistic'` | Fungsi loss: `'logistic'`, `'focal'`, `'poly'` |
-| `max_rule_length` | 2 | Jumlah maksimum fitur dalam satu aturan |
-| `operators` | `['AND','OR']` | Operator logika yang digunakan |
-| `beam_width` | 5 | Lebar beam search |
-| `binarize_strategy` | `'gradient'` | Strategi binarisasi: `'gradient'`, `'quantile'`, `'uniform'`, `'kmeans'` |
-| `subsample` | 0.8 | Fraksi data per iterasi |
-| `feature_selection_threshold` | 0.01 | Ambang batas seleksi fitur berbasis gradien |
-
-## Fitur yang Didukung
-
-- Fitur biner (0/1): langsung diproses
-- Fitur numerik (int/float): dibinarisasi otomatis
-- Fitur kategorikal 3+ kelas: wajib OneHotEncode terlebih dahulu
-
-```python
-from sklearn.preprocessing import OneHotEncoder
-enc = OneHotEncoder(sparse_output=False, drop='first')
-X_encoded = enc.fit_transform(X[['kolom_kategorikal']])
-```
-
-BinBoost secara otomatis mendeteksi kelompok fitur OneHotEncoding dan mencegah aturan yang tidak masuk akal seperti `(Warna_Merah AND Warna_Biru)`.
-
-## Atribut Setelah Pelatihan
-
-```python
-model.rules_               # daftar teks aturan
-model.rule_weights_        # bobot setiap aturan
-model.feature_importances_ # skor kepentingan fitur
-model.train_score_         # loss per iterasi
-model.rule_summary_        # ringkasan lengkap atau konversi ke DataFrame
-model.n_rules_             # jumlah aturan aktif
-model.feature_usage_       # frekuensi penggunaan tiap fitur
-```
-
-## Lisensi
-
-MIT