binboost 0.2.4__tar.gz → 0.2.5__tar.gz

{binboost-0.2.4 → binboost-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: binboost
-Version: 0.2.4
+Version: 0.2.5
 Summary: Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner
 Author: Rangga Wahyu Pratama
 License: MIT

{binboost-0.2.4 → binboost-0.2.5}/binboost/__init__.py

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

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

@@ -1,18 +1,16 @@
-# binboost/binarizer.py
 import numpy as np
 
 
 class GradientBinarizer:
-    # Binarisasi fitur numerik berbasis korelasi dengan gradien saat ini
+    # 1. Binarisasi Fitur Numerik Berdasarkan Korelasi Dengan Gradient Saat Ini
     def __init__(self, strategy='gradient', n_thresholds='auto'):
         self.strategy = strategy
         self.n_thresholds = n_thresholds
-        # Ambang batas tetap per fitur disimpan setelah fit pertama untuk strategi non-gradien
+        # 1. Simpan Threshold Tetap Per Fitur Buat Strategi Selain Gradient
         self._fixed_thresholds = {}
 
-    def _get_candidates(self, values):
-        # Kembalikan daftar kandidat ambang batas untuk satu fitur
-        unique = np.unique(values)
+    def _candidates_from_unique(self, unique):
+        # 1. Kembalikan Kandidat Threshold Dari Nilai Unik Yang Udah Terurut
         if len(unique) <= 1:
             return np.array([])
         if self.n_thresholds == 'auto':
@@ -24,23 +22,28 @@ class GradientBinarizer:
         idx = np.linspace(0, len(unique) - 2, max_t, dtype=int)
         return (unique[idx] + unique[idx + 1]) / 2
 
+    def _get_candidates(self, values):
+        # 1. Kembalikan Kandidat Threshold Buat Satu Fitur
+        return self._candidates_from_unique(np.unique(values))
+
     def _best_threshold_gradient(self, values, gradients):
-        # 1. Cari ambang batas t* yang memaksimalkan korelasi dengan gradien
-        candidates = self._get_candidates(values)
+        # 1. Cari Threshold Yang Bikin Nilai Mutlak Jumlah Gradient Sampel Di Atasnya Paling Besar
+        unique, inverse = np.unique(values, return_inverse=True)
+        candidates = self._candidates_from_unique(unique)
         if len(candidates) == 0:
             return 0.0, np.zeros(len(values), dtype=np.float64)
-        best_t = candidates[0]
-        best_score = -np.inf
-        for t in candidates:
-            binary = (values > t).astype(np.float64)
-            score = np.abs(np.dot(gradients, binary))
-            if score > best_score:
-                best_score = score
-                best_t = t
+        # a. Hitung Jumlah Gradient Per Nilai Unik Lalu Jumlahkan Kumulatif Dari Kanan
+        g_per_unique = np.bincount(inverse.ravel(), weights=gradients, minlength=len(unique))
+        suffix = np.concatenate([np.cumsum(g_per_unique[::-1])[::-1], [0.0]])
+        # b. Hitung Jumlah Gradient Sampel Yang Nilainya Lebih Besar Dari Tiap Kandidat
+        k = np.searchsorted(unique, candidates, side='right')
+        scores = np.abs(suffix[k])
+        # c. Ambil Kandidat Pertama Yang Skornya Paling Tinggi
+        best_t = candidates[int(np.argmax(scores))]
         return best_t, (values > best_t).astype(np.float64)
 
     def _best_threshold_quantile(self, col_idx, values):
-        # 1. Gunakan ambang batas tetap dari kuantil distribusi data
+        # 1. Pakai Threshold Tetap Dari Kuantil Distribusi Data
         if col_idx not in self._fixed_thresholds:
             candidates = self._get_candidates(values)
             if len(candidates) == 0:
@@ -51,16 +54,15 @@ class GradientBinarizer:
         return t, (values > t).astype(np.float64)
 
     def _best_threshold_uniform(self, col_idx, values):
-        # 1. Gunakan ambang batas tengah dari rentang nilai fitur
+        # 1. Pakai Threshold Di Tengah Rentang Nilai Fitur
         if col_idx not in self._fixed_thresholds:
             self._fixed_thresholds[col_idx] = (values.min() + values.max()) / 2
         t = self._fixed_thresholds[col_idx]
         return t, (values > t).astype(np.float64)
 
     def _best_threshold_kmeans(self, col_idx, values):
-        # 1. Gunakan titik tengah dua centroid K-Means satu dimensi sebagai ambang batas
+        # 1. Pakai Titik Tengah Dua Centroid KMeans Satu Dimensi Sebagai Threshold
         if col_idx not in self._fixed_thresholds:
-            v = values.reshape(-1, 1)
             c1 = np.percentile(values, 25)
             c2 = np.percentile(values, 75)
             for _ in range(100):
@@ -75,8 +77,8 @@ class GradientBinarizer:
         return t, (values > t).astype(np.float64)
 
     def transform(self, X, gradients, numeric_cols):
-        # Binarisasi semua fitur numerik dan kembalikan matriks biner serta ambang batas iterasi ini
-        X_bin = X.copy().astype(np.float64)
+        # 1. Binarisasi Semua Fitur Numerik Lalu Kembalikan Matriks Biner Dan Threshold Iterasi Ini
+        X_bin = X.astype(np.float64, copy=True)
         thresholds_this_iter = {}
         for col_idx in numeric_cols:
             values = X[:, col_idx].astype(np.float64)
@@ -93,3 +95,10 @@ class GradientBinarizer:
             X_bin[:, col_idx] = binary
             thresholds_this_iter[col_idx] = t
         return X_bin, thresholds_this_iter
+
+    def apply_thresholds(self, X, thresholds, numeric_cols):
+        # 1. Binarisasi Data Pakai Threshold Yang Udah Ditentukan Tanpa Nyari Ulang
+        X_bin = X.astype(np.float64, copy=True)
+        for col_idx in numeric_cols:
+            X_bin[:, col_idx] = (X[:, col_idx] > thresholds[col_idx]).astype(np.float64)
+        return X_bin

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

@@ -1,4 +1,3 @@
-# binboost/binboost.py
 import numpy as np
 
 from .loss import get_loss, sigmoid
@@ -63,6 +62,12 @@ class BinBoost:
     lambda0 : float, default=3.0
         Konstanta regularisasi dasar untuk bobot Newton adaptif (λ_R = lambda0 · L / sqrt(n_R+1)).
 
+    gamma : float, default=0.001
+        Ambang penurunan galat minimum yang sifatnya relatif. Aturan baru cuma diterima kalau
+        penurunan galat kuadratnya minimal gamma kali energi gradient saat itu. Kalau gak ada
+        aturan yang lolos training berhenti lebih awal. Nilai 0.0 mematikan pemangkasan ini.
+        Karena relatif satu nilai bisa dipakai buat berbagai dataset dan loss.
+
     binarize_strategy : str, default='gradient'
         Strategi binarisasi fitur numerik. Pilihan: 'gradient', 'quantile',
         'uniform', 'kmeans'.
@@ -86,11 +91,28 @@ class BinBoost:
         Threshold prediksi kelas. Nilai 'auto' menggunakan indeks Youden
         untuk mencari threshold optimal pada data training.
 
+    ohe_policy : str, default='block'
+        Perlakuan kelompok fitur hasil one hot encoding. Nilai block melarang dua kategori dari
+        fitur yang sama masuk satu aturan. Nilai allow membolehkannya. Kelompok dikenali kalau
+        kolom biner saling eksklusif dan jumlahnya pas satu di tiap baris.
+
+    Bobot sampel pada training:
+        Bobot tidak negatif per sampel lewat argumen sample_weight di fit. Bobot dinormalisasi
+        ke rata-rata satu jadi cuma rasio antarbobot yang berpengaruh. Bobot dipakai di skor awal.
+        Bobot dipakai di gradient dan hessian. Bobot dipakai di pencarian aturan pakai kuadrat
+        terkecil berbobot. Bobot dipakai di bobot Newton aturan. Bobot dipakai di loss training
+        dan threshold Youden. min_samples_rule menghitung sampel yang bobotnya positif.
+        Subsample per iterasi tetap seragam. Bobot yang semuanya sama hasilnya identik dengan
+        tanpa bobot.
+
     Atribut yang tersedia Setelah fit
     --------------------------------
     estimators_ : list of Rule
         Daftar aturan yang dipelajari.
 
+    F0_ : float
+        Skor awal berupa log-odds dari proporsi kelas positif yang ditambahkan ke semua prediksi.
+
     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).
@@ -136,8 +158,8 @@ class BinBoost:
         beam_width=5,
         subsample=0.8,
         min_samples_rule=5,
-        lambda0=3.0, 
-        gamma=0.0,
+        lambda0=3.0,
+        gamma=0.001,
         binarize_strategy='gradient',
         n_thresholds='auto',
         n_iter_no_change=None,
@@ -145,6 +167,7 @@ class BinBoost:
         random_state=None,
         warm_start=False,
         threshold='auto',
+        ohe_policy='block',
     ):
         self.n_estimators = n_estimators
         self.learning_rate = learning_rate
@@ -160,7 +183,7 @@ class BinBoost:
         self.beam_width = beam_width
         self.subsample = subsample
         self.min_samples_rule = min_samples_rule
-        self.lambda0 = lambda0  
+        self.lambda0 = lambda0
         self.gamma = gamma
         self.binarize_strategy = binarize_strategy
         self.n_thresholds = n_thresholds
@@ -169,10 +192,11 @@ class BinBoost:
         self.random_state = random_state
         self.warm_start = warm_start
         self.threshold = threshold
+        self.ohe_policy = ohe_policy
         self._threshold_fitted = 0.5
 
     def _validate_input(self, X, y=None):
-        # Ubah input ke numpy array dan pastikan dimensinya benar
+        # 1. Ubah Input Jadi Array Dan Pastikan Dimensinya Bener
         if hasattr(X, 'values'):
             if hasattr(X, 'columns'):
                 self._input_feature_names = list(X.columns)
@@ -190,66 +214,85 @@ class BinBoost:
         return X, y
 
     def _detect_numeric_cols(self, X):
-        # Identifikasi kolom fitur yang bukan biner murni sebagai fitur numerik
-        numeric = []
-        for col in range(X.shape[1]):
-            unique_vals = np.unique(X[:, col])
-            if not np.all(np.isin(unique_vals, [0.0, 1.0])):
-                numeric.append(col)
-        return numeric
+        # 1. Cari Kolom Yang Bukan Biner Murni Buat Dianggap Fitur Numerik
+        is_biner = ((X == 0.0) | (X == 1.0)).all(axis=0)
+        return [int(c) for c in np.where(~is_biner)[0]]
 
     def _detect_ohe_groups(self, X):
-        # 1. Deteksi kelompok fitur OneHotEncoding berdasarkan sifat mutually exclusive
-        n_features = X.shape[1]
+        # 1. Cari Kelompok Kolom One Hot Encoding Yang Saling Eksklusif Dan Jumlahnya Pas Satu Per Baris
+        is_biner = ((X == 0.0) | (X == 1.0)).all(axis=0)
+        aktif = np.where(is_biner & (X.sum(axis=0) > 0))[0]
+        m = len(aktif)
+        if m < 2:
+            return None
+        Xb = X[:, aktif].astype(np.float32)
+        # a. Dua Kolom Eksklusif Kalau Gak Pernah Bernilai Satu Barengan
+        eksklusif = (Xb.T @ Xb) == 0
+        terpakai = np.zeros(m, dtype=bool)
         groups = {}
-        used = set()
         group_id = 0
-        for i in range(n_features):
-            if i in used:
+        for i in range(m):
+            if terpakai[i]:
                 continue
-            group = [i]
-            for j in range(i + 1, n_features):
-                if j in used:
-                    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:
-                    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:
-                groups[group_id] = group
+            anggota = [i]
+            jumlah = Xb[:, i].copy()
+            kandidat = np.where(eksklusif[i] & ~terpakai)[0]
+            for j in kandidat[kandidat > i]:
+                # b. Anggota Baru Harus Eksklusif Ke Semua Anggota Kelompok
+                if eksklusif[j, anggota].all():
+                    anggota.append(int(j))
+                    jumlah += Xb[:, j]
+                    # c. Berhenti Kalau Kelompok Udah Nutup Semua Baris
+                    if np.all(jumlah == 1.0):
+                        break
+            if len(anggota) > 1 and np.all(jumlah == 1.0):
+                groups[group_id] = [int(aktif[a]) for a in anggota]
+                terpakai[anggota] = True
                 group_id += 1
-            used.add(i)
         return groups if groups else None
 
+    def _validate_sample_weight(self, sample_weight, n_samples):
+        # 1. Kembalikan None Kalau Gak Ada Bobot Atau Bobot Yang Udah Dinormalisasi Ke Rata-Rata Satu
+        if sample_weight is None:
+            return None
+        s = np.asarray(sample_weight, dtype=np.float64).ravel()
+        if len(s) != n_samples:
+            raise ValueError("Panjang bobot sampel harus sama dengan jumlah baris X.")
+        if not np.all(np.isfinite(s)) or np.any(s < 0):
+            raise ValueError("Bobot sampel harus berhingga dan tidak negatif.")
+        total = s.sum()
+        if total <= 0:
+            raise ValueError("Jumlah bobot sampel harus positif.")
+        s = s * (n_samples / total)
+        # 2. Bobot Yang Semuanya Sama Dianggap Sama Dengan Tanpa Bobot
+        if np.ptp(s) <= 1e-12:
+            return None
+        return s
+
     def _subsample_indices(self, n_samples, rng):
-        # Kembalikan indeks subsample acak tanpa pengembalian
+        # 1. Kembalikan Indeks Subsample Acak Tanpa Pengembalian
         if self.subsample >= 1.0:
             return np.arange(n_samples)
         n_sub = max(1, int(n_samples * self.subsample))
         return rng.choice(n_samples, size=n_sub, replace=False)
 
     def _build_operators(self):
-        # Gabungkan daftar operator dan tambahkan XOR jika use_xor aktif
+        # 1. Gabungin Daftar Operator Terus Tambahin XOR Kalau Diaktifin
         ops = list(self.operators)
         if self.use_xor and 'XOR' not in ops:
             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])
 
+        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)
+
         nilai_persentil = np.percentile(gains, self.feature_selection_threshold * 100)
         selected = np.where(gains >= nilai_persentil)[0]
         if len(selected) == 0:
@@ -283,14 +326,19 @@ class BinBoost:
         X : array-like of shape (n_samples, n_features)
         y : array-like of shape (n_samples,), nilai 0 atau 1
         sample_weight : array-like of shape (n_samples,), opsional
+            Bobot tidak negatif per sampel. Penjelasan lengkap ada di docstring kelas.
 
         Kembalian
         ----------
         self
         """
+        if self.ohe_policy not in ('block', 'allow'):
+            raise ValueError("Parameter ohe_policy harus 'block' atau 'allow'.")
+
         self._input_feature_names = None
         X, y = self._validate_input(X, y)
         n_samples, n_features = X.shape
+        s = self._validate_sample_weight(sample_weight, n_samples)
 
         self.n_features_in_ = n_features
         self.feature_names_in_ = (
@@ -325,7 +373,7 @@ class BinBoost:
             feature_selection_threshold=0.0,
             min_samples_rule=self.min_samples_rule,
             rule_complexity_penalty=self.rule_complexity_penalty,
-            ohe_groups=self.ohe_groups_,
+            ohe_groups=self.ohe_groups_ if self.ohe_policy == 'block' else None,
             gamma=self.gamma,
         )
 
@@ -334,31 +382,41 @@ class BinBoost:
             self.rule_weights_ = []
             self.thresholds_ = {col: [] for col in numeric_cols}
             self.train_score_ = []
-            self._F = loss_fn.init_F(y)
+            self._F = loss_fn.init_F(y, sample_weight=s)
+            # 1. Simpan Skor Awal Biar Prediksi Sama Dengan Waktu Training
+            self.F0_ = float(self._F[0])
+        else:
+            # 2. Ubah Atribut Array Balik Jadi List Biar Bisa Ditambah
+            self.rule_weights_ = [np.asarray(w) for w in self.rule_weights_]
+            self.train_score_ = list(self.train_score_)
 
         no_improve_count = 0
         best_score = np.inf
 
         for m in range(self.n_estimators):
-            # 1. Hitung gradien dari fungsi loss yang dipilih
+            # 3. Hitung Gradient Dari Loss Yang Dipilih
             gradients = loss_fn.gradient(y, self._F)
-            hessians = loss_fn.hessian(y, self._F)     
+            hessians = loss_fn.hessian(y, self._F)
 
-            # 2. Ambil subsample data untuk iterasi ini
+            # 4. Ambil Subsample Buat Iterasi Ini
             idx = self._subsample_indices(n_samples, rng)
             X_sub = X[idx]
             g_sub = gradients[idx]
-            h_sub = hessians[idx]      
+            h_sub = hessians[idx]
+            s_sub = s[idx] if s is not None else None
+            # a. Kalikan Gradient Dan Hessian Dengan Bobot Buat Binarisasi Dan Seleksi Fitur
+            gw_sub = g_sub * s_sub if s_sub is not None else g_sub
+            hw_sub = h_sub * s_sub if s_sub is not None else h_sub
 
-            # 3. Binarisasi fitur numerik menggunakan strategi yang dipilih
-            X_bin, thresholds_iter = binarizer.transform(X_sub, g_sub, numeric_cols)
+            # 5. Binarisasi Fitur Numerik Pakai Strategi Yang Dipilih
+            X_bin, thresholds_iter = binarizer.transform(X_sub, gw_sub, numeric_cols)
 
-            # 4. Seleksi fitur kandidat menggunakan kriteria gain yang konsisten
-            candidate_features = self._seleksi_fitur(X_bin, g_sub, h_sub)
+            # 6. Pilih Fitur Kandidat Pakai Kriteria Penurunan Galat Yang Konsisten
+            candidate_features = self._seleksi_fitur(X_bin, gw_sub, hw_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)
+            # 7. Cari Aturan Terbaik Pakai Beam Search
+            rule = rule_finder.find_best_rule(X_bin, g_sub, s_sub)
             if rule is None:
                 break
 
@@ -366,24 +424,26 @@ class BinBoost:
                 list(self.feature_names_in_) if self.feature_names_in_ is not None else None
             )
 
-            # 6. Perbarui prediksi model untuk seluruh data menggunakan update dua sisi
-            X_bin_full, thresholds_full = binarizer.transform(X, gradients, numeric_cols)
+            # 8. Pakai Threshold Yang Sama Ke Seluruh Data Terus Evaluasi Aturannya
+            X_bin_full = binarizer.apply_thresholds(X, thresholds_iter, numeric_cols)
             h_full = rule.evaluate(X_bin_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
+            gw = gradients * s if s is not None else gradients
+            hw = hessians * s if s is not None else hessians
+            w1, w0 = self._hitung_bobot_dua_sisi(h_full, gw, hw, len(rule.features))
+
+            # 9. Update Skor Pakai Kontribusi Dua Sisi
             self._F = self._F + self.learning_rate * (w1 * h_full + w0 * (1.0 - h_full))
 
-            # 8. Simpan aturan dengan bobot dua sisi dan statistik iterasi ini
+            # 10. Simpan Aturan Beserta Bobot Dua Sisi Dan Thresholdnya
             self.estimators_.append(rule)
             self.rule_weights_.append(np.array([w0, w1]))
-            for col, t in thresholds_full.items():
+            for col, t in thresholds_iter.items():
                 self.thresholds_[col].append(t)
 
-            current_score = loss_fn.loss(y, self._F)
+            current_score = loss_fn.loss(y, self._F, sample_weight=s)
             self.train_score_.append(current_score)
 
-            # 9. Periksa kondisi early stopping jika diaktifkan
+            # 11. Cek Syarat Early Stopping Kalau Diaktifin
             if self.n_iter_no_change is not None:
                 if current_score < best_score - self.tol:
                     best_score = current_score
@@ -395,22 +455,22 @@ class BinBoost:
 
         self.n_estimators_ = len(self.estimators_)
         self.train_score_ = np.array(self.train_score_)
-        self.rule_weights_ = np.array(self.rule_weights_)
+        self.rule_weights_ = np.array(self.rule_weights_).reshape(-1, 2)
         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
+        # 12. Tentuin Threshold Prediksi Terbaik Setelah Semua Iterasi Kelar
         if self.threshold == 'auto':
-            self._threshold_fitted = self._cari_threshold_optimal(X, y)
+            self._threshold_fitted = self._cari_threshold_optimal(X, y, sample_weight=s)
         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
+        # 1. Hitung Feature Importance Dari Selisih Bobot Dua Sisi Tiap Aturan
         importances = np.zeros(n_features)
         for rule, weights in zip(self.estimators_, self.rule_weights_):
-            # Gunakan selisih absolut w1 dan w0 sebagai ukuran gain aturan
+            # a. Pakai Selisih Mutlak Bobot Memenuhi Dan Tidak Memenuhi Sebagai Ukuran Pengaruh
             gain = np.abs(weights[1] - weights[0])
             for f in rule.features:
                 importances[f] += gain
@@ -421,48 +481,60 @@ 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
+    def _cari_threshold_optimal(self, X, y, sample_weight=None):
+        # 1. Cari Threshold Prediksi Terbaik Pakai Indeks Youden Di 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:
+        bobot = np.ones(len(y)) if sample_weight is None else np.asarray(sample_weight, dtype=np.float64)
+        is_pos = (y == 1)
+        pos = bobot[is_pos].sum()
+        neg = bobot[~is_pos].sum()
+        if pos <= 0 or neg <= 0:
+            return 0.5
+        ambang = np.unique(proba)
+        # 2. Lewati Pencarian Kalau Semua Probabilitas Sama
+        if len(ambang) < 2:
             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 bobot_di_atas(p, w):
+            # 3. Hitung Jumlah Bobot Di Atas Tiap Threshold Lewat Sorting
+            urut = np.argsort(p, kind='stable')
+            kum = np.concatenate([[0.0], np.cumsum(w[urut])])
+            idx = np.searchsorted(p[urut], ambang, side='left')
+            return kum[-1] - kum[idx]
+
+        tp = bobot_di_atas(proba[is_pos], bobot[is_pos])
+        fp = bobot_di_atas(proba[~is_pos], bobot[~is_pos])
+        tn = neg - fp
+        sensitivity = tp / pos
+        specificity = tn / neg
+        # 4. Hitung Indeks Youden Dari Sensitivity Plus Specificity Dikurangi Satu
+        youden = sensitivity + specificity - 1
+        # 5. Ambil Threshold Terkecil Yang Indeks Youdennya Paling Tinggi
+        return float(ambang[int(np.argmax(youden))])
+
     def _binarize_untuk_iterasi(self, X, iterasi_idx, numeric_cols):
-        X_bin = X.copy().astype(np.float64)
+        # 1. Binarisasi Pakai Threshold Yang Disimpan Di Iterasi Itu
+        if not numeric_cols:
+            return X
+        X_bin = X.copy()
         for col in numeric_cols:
             t = self.thresholds_[col][iterasi_idx]
             X_bin[:, col] = (X[:, col] > t).astype(np.float64)
         return X_bin
 
+    def _aktivasi_per_aturan(self, X):
+        # 1. Hasilkan Tiap Aturan Beserta Bobot Dan Aktivasinya Di Data
+        numeric_cols = self.numeric_cols_
+        for i, (rule, weights) in enumerate(zip(self.estimators_, self.rule_weights_)):
+            X_bin = self._binarize_untuk_iterasi(X, i, numeric_cols)
+            yield i, rule, weights, rule.evaluate(X_bin)
+
     def _decision_function(self, X):
         self._check_is_fitted()
         X, _ = self._validate_input(X)
-        F = np.zeros(X.shape[0])
-        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)
+        # 1. Mulai Dari Skor Awal Yang Sama Kayak Waktu Training
+        F = np.full(X.shape[0], getattr(self, 'F0_', 0.0))
+        for _, _, weights, h in self._aktivasi_per_aturan(X):
             w0, w1 = weights[0], weights[1]
             F += self.learning_rate * (w1 * h + w0 * (1.0 - h))
         return F
@@ -522,15 +594,8 @@ class BinBoost:
         """
         self._check_is_fitted()
         X, _ = self._validate_input(X)
-        numeric_cols = self.numeric_cols_
-        F = np.zeros(X.shape[0])
-        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)
+        F = np.full(X.shape[0], getattr(self, 'F0_', 0.0))
+        for _, _, weights, h in self._aktivasi_per_aturan(X):
             w0, w1 = weights[0], weights[1]
             F += self.learning_rate * (w1 * h + w0 * (1.0 - h))
             p = sigmoid(F)
@@ -550,24 +615,16 @@ 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.numeric_cols_
-        results = []
-        
-        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))
-            
+        results = [h for _, _, _, h in self._aktivasi_per_aturan(X)]
+        if not results:
+            return np.zeros((X.shape[0], 0))
         return np.column_stack(results)
 
     def get_params(self, deep=True):
@@ -593,8 +650,8 @@ class BinBoost:
             'beam_width': self.beam_width,
             'subsample': self.subsample,
             'min_samples_rule': self.min_samples_rule,
-            'lambda0': self.lambda0,  
-            'gamma': self.gamma,       
+            '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,
@@ -602,6 +659,7 @@ class BinBoost:
             'random_state': self.random_state,
             'warm_start': self.warm_start,
             'threshold': self.threshold,
+            'ohe_policy': self.ohe_policy,
         }
 
     def set_params(self, **params):
@@ -671,4 +729,4 @@ class BinBoost:
                     else f"X{f}"
                 )
                 usage[name] = usage.get(name, 0) + 1
-        return usage
+        return usage