binboost 0.1.2__tar.gz → 0.2.1__tar.gz

{binboost-0.1.2 → binboost-0.2.1}/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.2 → binboost-0.2.1}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: binboost
-Version: 0.1.2
+Version: 0.2.1
 Summary: Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner
-Author: BinBoost Authors
+Author: Rangga Wahyu Pratama
 License: MIT
 Keywords: gradient boosting,logical rules,binary features,interpretable machine learning
 Classifier: Programming Language :: Python :: 3

binboost-0.2.1/binboost/__init__.py

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

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

@@ -59,6 +59,9 @@ class BinBoost:
     min_samples_rule : int or float, default=5
         Jumlah minimum sampel yang harus memenuhi sebuah aturan.
 
+    lambda0 : float, default=1.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'.
@@ -132,6 +135,7 @@ class BinBoost:
         beam_width=5,
         subsample=0.8,
         min_samples_rule=5,
+        lambda0=1.0, 
         binarize_strategy='gradient',
         n_thresholds='auto',
         n_iter_no_change=None,
@@ -154,6 +158,7 @@ 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
@@ -232,37 +237,38 @@ class BinBoost:
             ops.append('XOR')
         return ops
 
-    def _seleksi_fitur(self, X_bin, gradients):
-        # 1. Pilih fitur kandidat menggunakan kriteria gain yang sama dengan seleksi aturan
-        # a. Hitung gain setiap fitur: (Σgᵢfᵢ)² / Σfᵢ² konsisten dengan w_m* aturan
+    def _seleksi_fitur(self, X_bin, gradients, hessians):
         dot_gf = X_bin.T @ gradients
-        dot_ff = (X_bin * X_bin).sum(axis=0) + 1e-10
-        gains = (dot_gf ** 2) / dot_ff
+        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:
-            # b. Ambil semua fitur jika threshold 0.0
             return np.arange(X_bin.shape[1])
 
-        # c. Gunakan threshold sebagai persentil relatif dari distribusi gain iterasi ini
         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):
-        # 1. Hitung bobot optimal untuk dua region secara terpisah
-        # a. Region 1: sampel yang memenuhi aturan (h=1)
+    def _hitung_bobot_dua_sisi(self, h, gradients, hessians, rule_length):
         mask_1 = h.astype(bool)
         mask_0 = ~mask_1
-        # b. Bobot w1 untuk sampel yang memenuhi aturan
+
         sum_g1 = gradients[mask_1].sum() if mask_1.any() else 0.0
-        sum_h1 = float(mask_1.sum())
-        w1 = sum_g1 / (sum_h1 + 1e-10) if sum_h1 > 0 else 0.0
-        # c. Bobot w0 untuk sampel yang tidak memenuhi aturan
+        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 = float(mask_0.sum())
-        w0 = sum_g0 / (sum_h0 + 1e-10) if sum_h0 > 0 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):
@@ -331,17 +337,19 @@ 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. Seleksi fitur kandidat menggunakan kriteria gain yang konsisten
-            candidate_features = self._seleksi_fitur(X_bin, g_sub)
+            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
@@ -356,11 +364,12 @@ class BinBoost:
             # 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)
-            w1, w0 = self._hitung_bobot_dua_sisi(h_full, gradients)
-            # a. Update F menggunakan kontribusi dua sisi: w1 untuk yang memenuhi, w0 untuk yang tidak
+            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))
 
-            # 7. Simpan aturan dengan bobot dua sisi dan statistik iterasi ini
+            # 8. Simpan aturan dengan bobot dua sisi dan statistik iterasi ini
             self.estimators_.append(rule)
             self.rule_weights_.append(np.array([w0, w1]))
             for col, t in thresholds_full.items():
@@ -369,7 +378,7 @@ class BinBoost:
             current_score = loss_fn.loss(y, self._F)
             self.train_score_.append(current_score)
 
-            # 8. 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
@@ -562,6 +571,7 @@ 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,

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

@@ -1,15 +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)
@@ -19,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
@@ -51,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):
@@ -79,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.1.2 → binboost-0.2.1}/binboost.egg-info/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: binboost
-Version: 0.1.2
+Version: 0.2.1
 Summary: Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner
-Author: BinBoost Authors
+Author: Rangga Wahyu Pratama
 License: MIT
 Keywords: gradient boosting,logical rules,binary features,interpretable machine learning
 Classifier: Programming Language :: Python :: 3

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

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

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

@@ -2,8 +2,8 @@ from setuptools import setup, find_packages
 
 setup(
     name="binboost",
-    version="0.1.2",
-    author="BinBoost Authors",
+    version="0.2.1",
+    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",

binboost-0.1.2/binboost/__init__.py

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