binboost 0.2.1__tar.gz → 0.2.2__tar.gz

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

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

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

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

{binboost-0.2.1 → 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=3
+    max_rule_length : int, default=4
         Jumlah maksimum fitur dalam satu aturan.
 
     operators : list, default=['AND', 'OR']
@@ -59,7 +59,7 @@ class BinBoost:
     min_samples_rule : int or float, default=5
         Jumlah minimum sampel yang harus memenuhi sebuah aturan.
 
-    lambda0 : float, default=1.0
+    lambda0 : float, default=3.0
         Konstanta regularisasi dasar untuk bobot Newton adaptif (λ_R = lambda0 · L / sqrt(n_R+1)).
 
     binarize_strategy : str, default='gradient'
@@ -122,12 +122,12 @@ class BinBoost:
     def __init__(
         self,
         n_estimators=100,
-        learning_rate=0.1,
+        learning_rate=0.2,
         loss='logistic',
         poly_epsilon=1.0,
         focal_gamma=2.0,
         focal_alpha=0.25,
-        max_rule_length=3,
+        max_rule_length=4,
         operators=None,
         use_xor=False,
         rule_complexity_penalty=0.0,
@@ -135,7 +135,7 @@ class BinBoost:
         beam_width=5,
         subsample=0.8,
         min_samples_rule=5,
-        lambda0=1.0, 
+        lambda0=3.0, 
         binarize_strategy='gradient',
         n_thresholds='auto',
         n_iter_no_change=None,

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.1 → binboost-0.2.2}/binboost/rule.py

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

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

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

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

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

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

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