binboost 0.1.0__tar.gz → 0.2.2__tar.gz

{binboost-0.1.0 → binboost-0.2.2}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 BinBoost Authors
+Copyright (c) 2026 BinBoost Authors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{binboost-0.1.0 → binboost-0.2.2}/PKG-INFO

@@ -1,11 +1,9 @@
 Metadata-Version: 2.4
 Name: binboost
-Version: 0.1.0
+Version: 0.2.2
 Summary: Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner
-Home-page: https://github.com/username/binboost
-Author: BinBoost Authors
+Author: Rangga Wahyu Pratama
 License: MIT
-Project-URL: Homepage, https://github.com/username/binboost
 Keywords: gradient boosting,logical rules,binary features,interpretable machine learning
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
@@ -18,7 +16,6 @@ License-File: LICENSE
 Requires-Dist: numpy>=1.21.0
 Requires-Dist: pandas>=1.3.0
 Dynamic: author
-Dynamic: home-page
 Dynamic: license-file
 Dynamic: requires-python
 

binboost-0.2.2/binboost/__init__.py

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

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

@@ -1,3 +1,4 @@
+# Binarizer.py
 import numpy as np
 
 

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

@@ -9,7 +9,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 +18,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 +33,7 @@ class BinBoost:
     focal_alpha : float, default=0.25
         Parameter alpha pada Focal Loss. Hanya berlaku saat loss='focal'.
 
-    max_rule_length : int, default=2
+    max_rule_length : int, default=4
         Jumlah maksimum fitur dalam satu aturan.
 
     operators : list, default=['AND', 'OR']
@@ -45,8 +45,10 @@ class BinBoost:
     rule_complexity_penalty : float, default=0.0
         Penalti bobot proporsional dengan panjang aturan.
 
-    feature_selection_threshold : float, default=0.01
-        Ambang batas skor korelasi gradien minimum agar fitur masuk kandidat.
+    feature_selection_threshold : float, default=0.0
+        Ambang batas persentil gain fitur untuk seleksi kandidat per iterasi.
+        Nilai 0.0 berarti semua fitur diikutsertakan. Nilai 0.5 berarti hanya
+        fitur dengan gain di atas median yang masuk kandidat.
 
     beam_width : int, default=5
         Jumlah kandidat aturan terbaik yang dipertahankan per langkah beam search.
@@ -54,9 +56,12 @@ class BinBoost:
     subsample : float, default=0.8
         Fraksi data yang digunakan per iterasi boosting.
 
-    min_samples_rule : int or float, default=10
+    min_samples_rule : int or float, default=5
         Jumlah minimum sampel yang harus memenuhi sebuah aturan.
 
+    lambda0 : float, default=3.0
+        Konstanta regularisasi dasar untuk bobot Newton adaptif (λ_R = lambda0 · L / sqrt(n_R+1)).
+
     binarize_strategy : str, default='gradient'
         Strategi binarisasi fitur numerik. Pilihan: 'gradient', 'quantile',
         'uniform', 'kmeans'.
@@ -76,13 +81,18 @@ class BinBoost:
     warm_start : bool, default=False
         Jika True maka pelatihan dilanjutkan dari kondisi model sebelumnya.
 
+    threshold : float or 'auto', default='auto'
+        Threshold prediksi kelas. Nilai 'auto' menggunakan indeks Youden
+        untuk mencari threshold optimal pada data training.
+
     Atribut yang tersedia Setelah fit
     --------------------------------
     estimators_ : list of Rule
         Daftar aturan yang dipelajari.
 
-    rule_weights_ : ndarray of float
-        Bobot optimal setiap aturan.
+    rule_weights_ : ndarray of float shape (n_estimators_, 2)
+        Bobot dua sisi setiap aturan. Kolom 0 adalah w0 (tidak memenuhi aturan)
+        dan kolom 1 adalah w1 (memenuhi aturan).
 
     rules_ : list of str
         Representasi teks setiap aturan.
@@ -112,25 +122,27 @@ 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=2,
+        max_rule_length=4,
         operators=None,
         use_xor=False,
         rule_complexity_penalty=0.0,
-        feature_selection_threshold=0.01,
+        feature_selection_threshold=0.0,
         beam_width=5,
         subsample=0.8,
-        min_samples_rule=10,
+        min_samples_rule=5,
+        lambda0=3.0, 
         binarize_strategy='gradient',
         n_thresholds='auto',
         n_iter_no_change=None,
         tol=1e-4,
         random_state=None,
         warm_start=False,
+        threshold='auto',
     ):
         self.n_estimators = n_estimators
         self.learning_rate = learning_rate
@@ -146,12 +158,15 @@ class BinBoost:
         self.beam_width = beam_width
         self.subsample = subsample
         self.min_samples_rule = min_samples_rule
+        self.lambda0 = lambda0  
         self.binarize_strategy = binarize_strategy
         self.n_thresholds = n_thresholds
         self.n_iter_no_change = n_iter_no_change
         self.tol = tol
         self.random_state = random_state
         self.warm_start = warm_start
+        self.threshold = threshold
+        self._threshold_fitted = 0.5
 
     def _validate_input(self, X, y=None):
         # Ubah input ke numpy array dan pastikan dimensinya benar
@@ -195,10 +210,11 @@ class BinBoost:
                     continue
                 # a. Dua fitur bersifat mutually exclusive jika tidak pernah bernilai 1 bersamaan
                 both_one = np.sum((X[:, i] == 1) & (X[:, j] == 1))
+                # b. Batasi ukuran grup maksimum 20 agar tidak memblokir terlalu banyak fitur
                 if both_one == 0:
-                    # b. Pastikan keduanya memang fitur biner
-                    if np.all(np.isin(np.unique(X[:, i]), [0.0, 1.0])) and \
-                       np.all(np.isin(np.unique(X[:, j]), [0.0, 1.0])):
+                    if len(group) < 20 and \
+                        np.all(np.isin(np.unique(X[:, i]), [0.0, 1.0])) and \
+                        np.all(np.isin(np.unique(X[:, j]), [0.0, 1.0])):
                         group.append(j)
                         used.add(j)
             if len(group) > 1:
@@ -221,6 +237,40 @@ class BinBoost:
             ops.append('XOR')
         return ops
 
+    def _seleksi_fitur(self, X_bin, gradients, hessians):
+        dot_gf = X_bin.T @ gradients
+        H_f = X_bin.T @ hessians                          
+        n_f = X_bin.sum(axis=0)                            
+        lambda_f = self.lambda0 / np.sqrt(n_f + 1.0)      
+        gains = (dot_gf ** 2) / (H_f + lambda_f + 1e-10)
+
+        if self.feature_selection_threshold <= 0.0:
+            return np.arange(X_bin.shape[1])
+
+        nilai_persentil = np.percentile(gains, self.feature_selection_threshold * 100)
+        selected = np.where(gains >= nilai_persentil)[0]
+        if len(selected) == 0:
+            selected = np.array([np.argmax(gains)])
+        return selected
+
+    def _hitung_bobot_dua_sisi(self, h, gradients, hessians, rule_length):
+        mask_1 = h.astype(bool)
+        mask_0 = ~mask_1
+
+        sum_g1 = gradients[mask_1].sum() if mask_1.any() else 0.0
+        sum_H1 = hessians[mask_1].sum() if mask_1.any() else 0.0
+        n1 = float(mask_1.sum())
+        lambda_1 = self.lambda0 * rule_length / np.sqrt(n1 + 1.0)
+        w1 = sum_g1 / (sum_H1 + lambda_1 + 1e-10) if n1 > 0 else 0.0
+
+        sum_g0 = gradients[mask_0].sum() if mask_0.any() else 0.0
+        sum_H0 = hessians[mask_0].sum() if mask_0.any() else 0.0
+        n0 = float(mask_0.sum())
+        lambda_0 = self.lambda0 * rule_length / np.sqrt(n0 + 1.0)
+        w0 = sum_g0 / (sum_H0 + lambda_0 + 1e-10) if n0 > 0 else 0.0
+
+        return w1, w0
+
     def fit(self, X, y, sample_weight=None):
         """
         Latih BinBoost pada data X dan label y.
@@ -258,16 +308,17 @@ class BinBoost:
         numeric_cols = self._detect_numeric_cols(X)
         self.ohe_groups_ = self._detect_ohe_groups(X)
 
-        binarizer = GradientBinarizer(
+        self._binarizer = GradientBinarizer(
             strategy=self.binarize_strategy,
             n_thresholds=self.n_thresholds
         )
+        binarizer = self._binarizer
 
         rule_finder = BeamSearchRuleFinder(
             operators=ops,
             max_rule_length=self.max_rule_length,
             beam_width=self.beam_width,
-            feature_selection_threshold=self.feature_selection_threshold,
+            feature_selection_threshold=0.0,
             min_samples_rule=self.min_samples_rule,
             rule_complexity_penalty=self.rule_complexity_penalty,
             ohe_groups=self.ohe_groups_,
@@ -286,16 +337,22 @@ class BinBoost:
         for m in range(self.n_estimators):
             # 1. Hitung gradien dari fungsi loss yang dipilih
             gradients = loss_fn.gradient(y, self._F)
+            hessians = loss_fn.hessian(y, self._F)     
 
             # 2. Ambil subsample data untuk iterasi ini
             idx = self._subsample_indices(n_samples, rng)
             X_sub = X[idx]
             g_sub = gradients[idx]
+            h_sub = hessians[idx]      
 
             # 3. Binarisasi fitur numerik menggunakan strategi yang dipilih
             X_bin, thresholds_iter = binarizer.transform(X_sub, g_sub, numeric_cols)
 
-            # 4. Cari aturan terbaik menggunakan beam search
+            # 4. Seleksi fitur kandidat menggunakan kriteria gain yang konsisten
+            candidate_features = self._seleksi_fitur(X_bin, g_sub, h_sub)
+            rule_finder.forced_candidate_features = candidate_features
+
+            # 5. Cari aturan terbaik menggunakan beam search
             rule = rule_finder.find_best_rule(X_bin, g_sub)
             if rule is None:
                 break
@@ -304,21 +361,24 @@ class BinBoost:
                 list(self.feature_names_in_) if self.feature_names_in_ is not None else None
             )
 
-            # 5. Perbarui prediksi model untuk seluruh data
+            # 6. Perbarui prediksi model untuk seluruh data menggunakan update dua sisi
             X_bin_full, thresholds_full = binarizer.transform(X, gradients, numeric_cols)
             h_full = rule.evaluate(X_bin_full)
-            self._F = self._F + self.learning_rate * rule.weight * h_full
+            w1, w0 = self._hitung_bobot_dua_sisi(h_full, gradients, hessians, len(rule.features))
+            
+            # 7. Update F menggunakan kontribusi dua sisi: w1 untuk yang memenuhi, w0 untuk yang tidak
+            self._F = self._F + self.learning_rate * (w1 * h_full + w0 * (1.0 - h_full))
 
-            # 6. Simpan aturan dan statistik iterasi ini
+            # 8. Simpan aturan dengan bobot dua sisi dan statistik iterasi ini
             self.estimators_.append(rule)
-            self.rule_weights_.append(rule.weight)
+            self.rule_weights_.append(np.array([w0, w1]))
             for col, t in thresholds_full.items():
                 self.thresholds_[col].append(t)
 
             current_score = loss_fn.loss(y, self._F)
             self.train_score_.append(current_score)
 
-            # 7. Periksa kondisi early stopping jika diaktifkan
+            # 9. Periksa kondisi early stopping jika diaktifkan
             if self.n_iter_no_change is not None:
                 if current_score < best_score - self.tol:
                     best_score = current_score
@@ -334,13 +394,19 @@ class BinBoost:
         self.rules_ = [r.to_string(self.feature_names_in_) for r in self.estimators_]
         self._compute_feature_importances(n_features)
         self.is_fitted_ = True
+        # Tentukan threshold prediksi optimal setelah seluruh iterasi selesai
+        if self.threshold == 'auto':
+            self._threshold_fitted = self._cari_threshold_optimal(X, y)
+        else:
+            self._threshold_fitted = float(self.threshold)
         return self
 
     def _compute_feature_importances(self, n_features):
         # Hitung skor kepentingan fitur dari frekuensi kemunculan dikali rata-rata bobot absolut
         importances = np.zeros(n_features)
-        for rule in self.estimators_:
-            gain = np.abs(rule.weight)
+        for rule, weights in zip(self.estimators_, self.rule_weights_):
+            # Gunakan selisih absolut w1 dan w0 sebagai ukuran gain aturan
+            gain = np.abs(weights[1] - weights[0])
             for f in rule.features:
                 importances[f] += gain
         total = importances.sum()
@@ -350,21 +416,41 @@ class BinBoost:
         if not getattr(self, 'is_fitted_', False):
             raise RuntimeError("Model belum dilatih. Panggil fit terlebih dahulu.")
 
+    def _cari_threshold_optimal(self, X, y):
+        # Cari threshold prediksi optimal menggunakan indeks Youden pada data training
+        proba = self.predict_proba(X)[:, 1]
+        ambang_kandidat = np.sort(np.unique(proba))
+        skor_terbaik = -np.inf
+        threshold_terbaik = 0.5
+        pos = np.sum(y == 1)
+        neg = np.sum(y == 0)
+        if pos == 0 or neg == 0:
+            return 0.5
+        for t in ambang_kandidat:
+            pred = (proba >= t).astype(int)
+            tp = np.sum((pred == 1) & (y == 1))
+            tn = np.sum((pred == 0) & (y == 0))
+            sensitivity = tp / pos
+            specificity = tn / neg
+            # Indeks Youden memaksimalkan sensitivity tambah specificity dikurangi 1
+            youden = sensitivity + specificity - 1
+            if youden > skor_terbaik:
+                skor_terbaik = youden
+                threshold_terbaik = t
+        return float(threshold_terbaik)
+
     def _decision_function(self, X):
-        # Hitung nilai F akhir untuk seluruh sampel
+        # 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])
-        binarizer = GradientBinarizer(
-            strategy=self.binarize_strategy,
-            n_thresholds=self.n_thresholds
-        )
         numeric_cols = self._detect_numeric_cols(X)
         dummy_grad = np.ones(X.shape[0])
-        X_bin, _ = binarizer.transform(X, dummy_grad, numeric_cols)
-        for rule, w in zip(self.estimators_, self.rule_weights_):
+        X_bin, _ = self._binarizer.transform(X, dummy_grad, numeric_cols)
+        for rule, weights in zip(self.estimators_, self.rule_weights_):
             h = rule.evaluate(X_bin)
-            F += self.learning_rate * w * h
+            w0, w1 = weights[0], weights[1]
+            F += self.learning_rate * (w1 * h + w0 * (1.0 - h))
         return F
 
     def predict_proba(self, X):
@@ -398,7 +484,7 @@ class BinBoost:
         ndarray of shape (n_samples,)
         """
         proba = self.predict_proba(X)
-        return (proba[:, 1] >= 0.5).astype(int)
+        return (proba[:, 1] >= self._threshold_fitted).astype(int)
 
     def score(self, X, y):
         """
@@ -422,17 +508,14 @@ class BinBoost:
         """
         self._check_is_fitted()
         X, _ = self._validate_input(X)
-        binarizer = GradientBinarizer(
-            strategy=self.binarize_strategy,
-            n_thresholds=self.n_thresholds
-        )
         numeric_cols = self._detect_numeric_cols(X)
         dummy_grad = np.ones(X.shape[0])
-        X_bin, _ = binarizer.transform(X, dummy_grad, numeric_cols)
+        X_bin, _ = self._binarizer.transform(X, dummy_grad, numeric_cols)
         F = np.zeros(X.shape[0])
-        for rule, w in zip(self.estimators_, self.rule_weights_):
+        for rule, weights in zip(self.estimators_, self.rule_weights_):
             h = rule.evaluate(X_bin)
-            F += self.learning_rate * w * h
+            w0, w1 = weights[0], weights[1]
+            F += self.learning_rate * (w1 * h + w0 * (1.0 - h))
             p = sigmoid(F)
             yield np.column_stack([1 - p, p])
 
@@ -445,7 +528,7 @@ class BinBoost:
         ndarray of shape (n_samples,) per iterasi
         """
         for proba in self.staged_predict_proba(X):
-            yield (proba[:, 1] >= 0.5).astype(int)
+            yield (proba[:, 1] >= self._threshold_fitted).astype(int)
 
     def apply(self, X):
         """
@@ -457,13 +540,9 @@ class BinBoost:
         """
         self._check_is_fitted()
         X, _ = self._validate_input(X)
-        binarizer = GradientBinarizer(
-            strategy=self.binarize_strategy,
-            n_thresholds=self.n_thresholds
-        )
         numeric_cols = self._detect_numeric_cols(X)
         dummy_grad = np.ones(X.shape[0])
-        X_bin, _ = binarizer.transform(X, dummy_grad, numeric_cols)
+        X_bin, _ = self._binarizer.transform(X, dummy_grad, numeric_cols)
         results = []
         for rule in self.estimators_:
             results.append(rule.evaluate(X_bin))
@@ -492,12 +571,14 @@ class BinBoost:
             'beam_width': self.beam_width,
             'subsample': self.subsample,
             'min_samples_rule': self.min_samples_rule,
+            'lambda0': self.lambda0,          
             'binarize_strategy': self.binarize_strategy,
             'n_thresholds': self.n_thresholds,
             'n_iter_no_change': self.n_iter_no_change,
             'tol': self.tol,
             'random_state': self.random_state,
             'warm_start': self.warm_start,
+            'threshold': self.threshold,
         }
 
     def set_params(self, **params):
@@ -517,7 +598,7 @@ class BinBoost:
     @property
     def rule_summary_(self):
         """
-        Tabel ringkasan semua aturan beserta bobot, cakupan, dan dukungan.
+        Tabel ringkasan semua aturan beserta bobot dua sisi setiap aturan.
 
         Kembalian
         ----------
@@ -525,12 +606,14 @@ class BinBoost:
         """
         self._check_is_fitted()
         summary = []
-        for i, rule in enumerate(self.estimators_):
+        for i, (rule, weights) in enumerate(zip(self.estimators_, self.rule_weights_)):
             summary.append({
                 'iterasi': i + 1,
                 'aturan': self.rules_[i],
-                'bobot': round(float(self.rule_weights_[i]), 6),
+                'bobot_memenuhi': round(float(weights[1]), 6),
+                'bobot_tidak_memenuhi': round(float(weights[0]), 6),
                 'panjang_aturan': len(rule.features),
+                'threshold_prediksi': round(self._threshold_fitted, 6),
             })
         return summary
 
@@ -565,4 +648,4 @@ class BinBoost:
                     else f"X{f}"
                 )
                 usage[name] = usage.get(name, 0) + 1
-        return usage
+        return usage

{binboost-0.1.0 → binboost-0.2.2}/binboost/loss.py

@@ -1,14 +1,12 @@
+# loss.py
 import numpy as np
 
-
 def sigmoid(x):
     # Fungsi sigmoid dengan penjagaan numerik agar tidak overflow
     return np.where(x >= 0, 1 / (1 + np.exp(-x)), np.exp(x) / (1 + np.exp(x)))
 
-
 class LogisticLoss:
     # Loss biner standar berbasis log-likelihood
-
     def loss(self, y, F):
         p = sigmoid(F)
         p = np.clip(p, 1e-15, 1 - 1e-15)
@@ -18,16 +16,21 @@ class LogisticLoss:
         # 1. Gradien negatif sebagai arah penurunan loss
         p = sigmoid(F)
         return y - p
+    
+    def hessian(self, y, F):
+        # Turunan kedua logistic loss terhadap F
+        p = sigmoid(F)
+        p = np.clip(p, 1e-15, 1 - 1e-15)
+        h = p * (1 - p)
+        return np.maximum(h, 1e-10)
 
     def init_F(self, y):
         # Inisialisasi F0 dari proporsi kelas positif
         p = np.clip(np.mean(y), 1e-15, 1 - 1e-15)
         return np.full(len(y), np.log(p / (1 - p)))
 
-
 class FocalLoss:
     # Focal Loss untuk data tidak seimbang
-
     def __init__(self, gamma=2.0, alpha=0.25):
         self.gamma = gamma
         self.alpha = alpha
@@ -50,12 +53,20 @@ class FocalLoss:
         weight = alpha_t * (1 - pt) ** self.gamma
         grad = weight * (y - p) + self.gamma * weight * pt * np.log(pt) * np.where(y == 1, -(1 - p), p)
         return grad
+    
+    def hessian(self, y, F):
+        p = sigmoid(F)
+        p = np.clip(p, 1e-15, 1 - 1e-15)
+        pt = np.where(y == 1, p, 1 - p)
+        alpha_t = np.where(y == 1, self.alpha, 1 - self.alpha)
+        beta = alpha_t * (1 - pt) ** self.gamma
+        h = beta * p * (1 - p)
+        return np.maximum(h, 1e-10)
 
     def init_F(self, y):
         p = np.clip(np.mean(y), 1e-15, 1 - 1e-15)
         return np.full(len(y), np.log(p / (1 - p)))
 
-
 class PolyLoss:
     # PolyLoss yang berbasis ekspansi polinomial
     def __init__(self, epsilon=1.0):
@@ -78,12 +89,17 @@ class PolyLoss:
         # b. Suku koreksi dari ekspansi polinomial pertama
         grad_poly = self.epsilon * np.where(y == 1, p * (1 - p), -p * (1 - p))
         return grad_ce + grad_poly
+    
+    def hessian(self, y, F):
+        p = sigmoid(F)
+        p = np.clip(p, 1e-15, 1 - 1e-15)
+        h = p * (1 - p) * (1 + self.epsilon * (2 * y - 1) * (2 * p - 1))
+        return np.maximum(h, 1e-10)
 
     def init_F(self, y):
         p = np.clip(np.mean(y), 1e-15, 1 - 1e-15)
         return np.full(len(y), np.log(p / (1 - p)))
 
-
 def get_loss(name, **kwargs):
     # Kembalikan objek loss sesuai nama yang dipilih pengguna
     if name == 'logistic':

binboost-0.2.2/binboost/multiclass.py

@@ -0,0 +1,78 @@
+# multiclass.py
+import numpy as np
+from binboost import BinBoost
+
+
+class BinBoostOvR:
+    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':
+            # 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)
+        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':
+            # Tiap kelas pakai threshold Youden J miliknya sendiri
+            preds = np.column_stack([m.predict(X) for m in self.estimators_ovr_])
+            return preds
+        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)
+
+    @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.2/binboost/rule.py

@@ -0,0 +1,217 @@
+# rule.py
+import numpy as np
+
+class Rule:
+    # 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
+        self.operators = operators
+        self.weight = weight
+        # Daftar boolean sepanjang features: True berarti fitur itu dipakai dalam bentuk negasi (NOT)
+        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):
+        result = self._kolom(X_bin, 0)
+        for i, op in enumerate(self.operators):
+            next_col = self._kolom(X_bin, i + 1)
+            if op == 'AND':
+                result = result & next_col
+            elif op == 'OR':
+                result = result | next_col
+            elif op == 'XOR':
+                result = result ^ next_col
+        return result.astype(np.float64)
+
+    def to_string(self, feature_names=None):
+        names = feature_names if feature_names is not None else self.feature_names
+        if names is None:
+            base_parts = [f"X{f}" for f in self.features]
+        else:
+            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]
+        for i, op in enumerate(self.operators):
+            expr = f"({expr} {op} {parts[i + 1]})"
+        return expr
+
+    def __repr__(self):
+        return f"Rule({self.to_string()}, weight={self.weight:.4f})"
+
+
+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):
+        self.operators = operators
+        self.max_rule_length = max_rule_length
+        self.beam_width = beam_width
+        self.feature_selection_threshold = feature_selection_threshold
+        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._feature_to_group = {}
+        if ohe_groups is not None:
+            for gid, members in ohe_groups.items():
+                for f in members:
+                    self._feature_to_group[f] = gid
+
+    def _select_features(self, X_bin, gradients):
+        dot_products = np.abs(X_bin.T @ gradients)
+        col_sums = X_bin.sum(axis=0) + 1e-10
+        scores = dot_products / col_sums
+        selected = np.where(scores >= self.feature_selection_threshold)[0]
+        if len(selected) == 0:
+            selected = np.array([np.argmax(scores)])
+        return selected
+
+    def _compute_scores_batch(self, H_batch, gradients):
+        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)
+        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):
+        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):
+        n_samples, n_features = X_bin.shape
+        min_s = self._min_samples_int(n_samples)
+        if hasattr(self, 'forced_candidate_features') and self.forced_candidate_features is not None:
+            candidate_features = self.forced_candidate_features
+        else:
+            candidate_features = self._select_features(X_bin, gradients)
+
+        if len(candidate_features) == 0:
+            return None
+
+        X_bin_bool = X_bin.astype(bool)
+        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
+        if not valid_mask.any():
+            return None
+
+        candidates = []
+        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, [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_negs, best_h = beam[0]
+
+        # 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_negs, beam_h in beam:
+                beam_feat_set = set(beam_feats)
+
+                expandable = []
+                for cf in candidate_features:
+                    cf_int = int(cf)
+                    if cf_int in beam_feat_set:
+                        continue
+                    g_new = self._feature_to_group.get(cf_int)
+                    if g_new is not None:
+                        if any(self._feature_to_group.get(ef) == g_new for ef in beam_feats):
+                            continue
+                    expandable.append(cf_int)
+
+                if not expandable:
+                    continue
+
+                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
+
+                        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
+
+                        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
+
+            new_candidates.sort(key=lambda x: x[0])
+            new_candidates = new_candidates[:self.beam_width]
+
+            if new_candidates[0][0] < best_score:
+                best_score, best_feats, best_ops, best_negs, best_h = new_candidates[0]
+                beam = new_candidates
+            else:
+                break
+
+        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, negations=best_negs)

{binboost-0.1.0 → binboost-0.2.2}/binboost.egg-info/PKG-INFO

@@ -1,11 +1,9 @@
 Metadata-Version: 2.4
 Name: binboost
-Version: 0.1.0
+Version: 0.2.2
 Summary: Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner
-Home-page: https://github.com/username/binboost
-Author: BinBoost Authors
+Author: Rangga Wahyu Pratama
 License: MIT
-Project-URL: Homepage, https://github.com/username/binboost
 Keywords: gradient boosting,logical rules,binary features,interpretable machine learning
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
@@ -18,7 +16,6 @@ License-File: LICENSE
 Requires-Dist: numpy>=1.21.0
 Requires-Dist: pandas>=1.3.0
 Dynamic: author
-Dynamic: home-page
 Dynamic: license-file
 Dynamic: requires-python
 

{binboost-0.1.0 → binboost-0.2.2}/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.1.0 → binboost-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "binboost"
-version = "0.1.0"
+version = "0.2.2"
 description = "Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -21,6 +21,3 @@ classifiers = [
     "Intended Audience :: Science/Research",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
 ]
-
-[project.urls]
-Homepage = "https://github.com/username/binboost"

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

@@ -2,12 +2,11 @@ from setuptools import setup, find_packages
 
 setup(
     name="binboost",
-    version="0.1.0",
-    author="BinBoost Authors",
+    version="0.2.2",
+    author="Rangga Wahyu Pratama",
     description="Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner",
     long_description=open("README.md", encoding="utf-8").read(),
     long_description_content_type="text/markdown",
-    url="https://github.com/username/binboost",
     packages=find_packages(),
     python_requires=">=3.8",
     install_requires=[

binboost-0.1.0/binboost/__init__.py

@@ -1,5 +0,0 @@
-from .binboost import BinBoost
-
-__version__ = "0.1.0"
-__author__ = "BinBoost Authors"
-__all__ = ["BinBoost"]

binboost-0.1.0/binboost/rule.py

@@ -1,168 +0,0 @@
-import numpy as np
-from itertools import combinations
-
-
-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
-        self.features = features
-        # b. Daftar operator antar fitur
-        self.operators = operators
-        # c. Bobot optimal hasil perhitungan w_m*
-        self.weight = weight
-        self.feature_names = feature_names
-
-    def evaluate(self, X_bin):
-        # Hitung keluaran aturan untuk setiap sampel dan kembalikan larik biner
-        result = X_bin[:, self.features[0]].astype(bool)
-        for i, op in enumerate(self.operators):
-            next_col = X_bin[:, self.features[i + 1]].astype(bool)
-            if op == 'AND':
-                result = result & next_col
-            elif op == 'OR':
-                result = result | next_col
-            elif op == 'XOR':
-                result = result ^ next_col
-        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]
-        else:
-            parts = [names[f] for f in self.features]
-        if len(parts) == 1:
-            return parts[0]
-        expr = parts[0]
-        for i, op in enumerate(self.operators):
-            expr = f"({expr} {op} {parts[i + 1]})"
-        return expr
-
-    def __repr__(self):
-        return f"Rule({self.to_string()}, weight={self.weight:.4f})"
-
-
-class BeamSearchRuleFinder:
-    # Pencari aturan terbaik menggunakan beam search berbasis gradien
-
-    def __init__(self, operators, max_rule_length, beam_width,
-                 feature_selection_threshold, min_samples_rule,
-                 rule_complexity_penalty, ohe_groups=None):
-        self.operators = operators
-        self.max_rule_length = max_rule_length
-        self.beam_width = beam_width
-        self.feature_selection_threshold = feature_selection_threshold
-        self.min_samples_rule = min_samples_rule
-        self.rule_complexity_penalty = rule_complexity_penalty
-        self.ohe_groups = ohe_groups
-
-    def _select_features(self, X_bin, gradients):
-        # 1. Pilih fitur kandidat berdasarkan skor korelasi gradien
-        n_samples, n_features = X_bin.shape
-        scores = []
-        for f in range(n_features):
-            col = X_bin[:, f]
-            score = np.abs(np.dot(gradients, col)) / (np.sum(col) + 1e-10)
-            scores.append(score)
-        scores = np.array(scores)
-        selected = np.where(scores >= self.feature_selection_threshold)[0]
-        if len(selected) == 0:
-            selected = np.array([np.argmax(scores)])
-        return selected
-
-    def _same_ohe_group(self, f1, f2):
-        # Periksa apakah dua fitur berasal dari grup OneHotEncoding yang sama
-        if self.ohe_groups is None:
-            return False
-        for group in self.ohe_groups.values():
-            if f1 in group and f2 in group:
-                return True
-        return False
-
-    def _compute_score(self, h, gradients):
-        # 1. Hitung bobot optimal w_m* dan skor galat kuadrat terkecil
-        denom = np.dot(h, h)
-        if denom < 1e-10:
-            return None, np.inf
-        w = np.dot(gradients, h) / denom
-        penalty = self.rule_complexity_penalty
-        score = np.sum((gradients - w * h) ** 2)
-        return w, score
-
-    def _is_valid(self, h, n_samples):
-        # Periksa apakah jumlah sampel yang memenuhi aturan mencukupi min_samples_rule
-        support = int(np.sum(h))
-        if isinstance(self.min_samples_rule, float) and self.min_samples_rule < 1.0:
-            min_s = int(self.min_samples_rule * n_samples)
-        else:
-            min_s = int(self.min_samples_rule)
-        return support >= min_s
-
-    def find_best_rule(self, X_bin, gradients):
-        # 1. Jalankan beam search untuk menemukan aturan terbaik
-        n_samples = X_bin.shape[0]
-        candidate_features = self._select_features(X_bin, gradients)
-
-        # a. Inisialisasi beam dengan aturan panjang satu
-        beam = []
-        for f in candidate_features:
-            h = X_bin[:, f].astype(np.float64)
-            if not self._is_valid(h, n_samples):
-                continue
-            w, score = self._compute_score(h, gradients)
-            if w is not None:
-                beam.append(([f], [], w, score))
-
-        if not beam:
-            return None
-
-        beam.sort(key=lambda x: x[3])
-        beam = beam[:self.beam_width]
-        best_candidate = beam[0]
-
-        # b. Perluas aturan hingga panjang maksimum
-        for length in range(2, self.max_rule_length + 1):
-            new_beam = []
-            for (feats, ops, w_prev, score_prev) in beam:
-                for f in candidate_features:
-                    if f in feats:
-                        continue
-                    # c. Terapkan constraint mutual exclusivity OHE
-                    skip = False
-                    for existing_f in feats:
-                        if self._same_ohe_group(existing_f, f):
-                            skip = True
-                            break
-                    if skip:
-                        continue
-                    for op in self.operators:
-                        new_feats = feats + [f]
-                        new_ops = ops + [op]
-                        tmp_rule = Rule(new_feats, new_ops, 0.0)
-                        h = tmp_rule.evaluate(X_bin)
-                        if not self._is_valid(h, n_samples):
-                            continue
-                        w, score = self._compute_score(h, gradients)
-                        # d. Terapkan penalti kompleksitas berdasarkan panjang aturan
-                        penalized_score = score * (1 + self.rule_complexity_penalty * length)
-                        if w is not None:
-                            new_beam.append((new_feats, new_ops, w, penalized_score))
-
-            if not new_beam:
-                break
-
-            new_beam.sort(key=lambda x: x[3])
-            new_beam = new_beam[:self.beam_width]
-
-            if new_beam[0][3] < best_candidate[3]:
-                best_candidate = new_beam[0]
-                beam = new_beam
-            else:
-                break
-
-        feats, ops, w, score = best_candidate
-        return Rule(feats, ops, w)