binboost 0.2.2__tar.gz → 0.2.4__tar.gz

binboost-0.2.4/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: binboost
+Version: 0.2.4
+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.4/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.4/binboost/__init__.py

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

{binboost-0.2.2 → binboost-0.2.4}/binboost/binarizer.py

@@ -1,10 +1,9 @@
-# Binarizer.py
+# binboost/binarizer.py
 import numpy as np
 
 
 class GradientBinarizer:
     # Binarisasi fitur numerik berbasis korelasi dengan gradien saat ini
-
     def __init__(self, strategy='gradient', n_thresholds='auto'):
         self.strategy = strategy
         self.n_thresholds = n_thresholds

{binboost-0.2.2 → binboost-0.2.4}/binboost/binboost.py

@@ -1,3 +1,4 @@
+# binboost/binboost.py
 import numpy as np
 
 from .loss import get_loss, sigmoid
@@ -136,6 +137,7 @@ class BinBoost:
         subsample=0.8,
         min_samples_rule=5,
         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
@@ -306,6 +309,7 @@ class BinBoost:
         )
 
         numeric_cols = self._detect_numeric_cols(X)
+        self.numeric_cols_ = numeric_cols
         self.ohe_groups_ = self._detect_ohe_groups(X)
 
         self._binarizer = GradientBinarizer(
@@ -322,6 +326,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 +443,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_):
+        numeric_cols = self.numeric_cols_
+        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))
@@ -508,11 +522,14 @@ 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)
+        numeric_cols = self.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,19 +550,24 @@ class BinBoost:
     def apply(self, X):
         """
         Kembalikan nilai aktivasi setiap aturan untuk setiap sampel.
-
+    
         Kembalian
         ----------
         ndarray of shape (n_samples, n_estimators_)
         """
         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)
+        numeric_cols = self.numeric_cols_
         results = []
-        for rule in self.estimators_:
+        
+        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 +593,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.2 → binboost-0.2.4}/binboost/loss.py

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

{binboost-0.2.2 → binboost-0.2.4}/binboost/multiclass.py

@@ -1,9 +1,9 @@
-# multiclass.py
+# binboost/multiclass.py
 import numpy as np
-from binboost import BinBoost
+from .binboost import BinBoost
 
 
-class BinBoostOvR:
+class OneVsRestBinBoost:
     def __init__(self, mode='multiclass', **binboost_params):
         self.mode = mode
         self.binboost_params = binboost_params
@@ -15,7 +15,6 @@ class BinBoostOvR:
         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)
@@ -30,9 +29,7 @@ class BinBoostOvR:
     def predict_proba(self, X):
         raw = self._raw_scores(X)
         if self.mode == 'multilabel':
-            # Tidak dinormalisasi — tiap kelas independen
             return raw
-        # mode='multiclass' — normalisasi supaya tiap baris berjumlah 1
         total = raw.sum(axis=1, keepdims=True)
         semua_nol = (total.flatten() <= 1e-10)
         total_aman = np.where(total <= 1e-10, 1.0, total)
@@ -43,17 +40,14 @@ class BinBoostOvR:
 
     def predict(self, X):
         if self.mode == 'multilabel':
-            # Tiap kelas pakai threshold Youden J miliknya sendiri
-            preds = np.column_stack([m.predict(X) for m in self.estimators_ovr_])
-            return preds
+            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)
-        preds = self.predict(X)
-        return np.mean(preds == y)
+        return np.mean(self.predict(X) == y)
 
     @property
     def rule_summary_(self):

{binboost-0.2.2 → binboost-0.2.4}/binboost/rule.py

@@ -1,4 +1,4 @@
-# rule.py
+# binboost/rule.py
 import numpy as np
 
 class Rule:
@@ -6,8 +6,7 @@ class Rule:
     def __init__(self, features, operators, weight, negations=None, feature_names=None):
         self.features = features
         self.operators = operators
-        self.weight = weight
-        # Daftar boolean sepanjang features: True berarti fitur itu dipakai dalam bentuk negasi (NOT)
+        self._search_weight = weight
         self.negations = negations if negations is not None else [False] * len(features)
         self.feature_names = feature_names
 
@@ -45,13 +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:
     def __init__(self, operators, max_rule_length, beam_width,
                  feature_selection_threshold, min_samples_rule,
-                 rule_complexity_penalty, ohe_groups=None, allow_negation=True):
+                 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
@@ -59,7 +58,8 @@ 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  # False -> perilaku identik versi sebelum ini
+        self.allow_negation = allow_negation
+        self.gamma = gamma
 
         self._feature_to_group = {}
         if ohe_groups is not None:
@@ -94,6 +94,7 @@ class BeamSearchRuleFinder:
     def find_best_rule(self, X_bin, gradients):
         n_samples, n_features = X_bin.shape
         min_s = self._min_samples_int(n_samples)
+        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:
@@ -121,7 +122,8 @@ class BeamSearchRuleFinder:
             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
 
@@ -182,7 +184,8 @@ class BeamSearchRuleFinder:
                             continue
 
                         w_new, scores_new, w_valid_new = self._compute_scores_batch(H_new, gradients)
-                        valid_combined = valid_sup & w_valid_new
+                        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]:

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

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: binboost
+Version: 0.2.4
+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.2 → binboost-0.2.4}/pyproject.toml

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

{binboost-0.2.2 → binboost-0.2.4}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="binboost",
-    version="0.2.2",
+    version="0.2.4",
     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.2/PKG-INFO

@@ -1,101 +0,0 @@
-Metadata-Version: 2.4
-Name: binboost
-Version: 0.2.2
-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.2/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.2/binboost/__init__.py

@@ -1,5 +0,0 @@
-from .binboost import BinBoost
-
-__version__ = "0.2.2"
-__author__ = "Rangga Wahyu Pratama"
-__all__ = ["BinBoost"]

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

@@ -1,101 +0,0 @@
-Metadata-Version: 2.4
-Name: binboost
-Version: 0.2.2
-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