binboost 0.1.0__tar.gz

binboost-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

binboost-0.1.0/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: binboost
+Version: 0.1.0
+Summary: Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner
+Home-page: https://github.com/username/binboost
+Author: BinBoost Authors
+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
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: pandas>=1.3.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# BinBoost
+
+**Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner**
+
+BinBoost adalah algoritma klasifikasi gradient boosting yang membangun ensemble aturan logika murni (AND, OR, XOR) dengan binarisasi fitur numerik adaptif berbasis gradien pada setiap iterasi boosting. Setiap weak learner berupa aturan yang dapat dibaca langsung oleh manusia tanpa memerlukan alat bantu penjelasan pasca-pelatihan.
+
+## Kebaruan Utama
+
+- **Binarisasi adaptif berbasis gradien**: nilai ambang batas fitur numerik dicari per iterasi untuk memaksimalkan korelasi dengan gradien saat ini
+- **Ensemble aturan logika murni**: tidak ada pohon keputusan, setiap weak learner adalah aturan seperti `(A AND B)` atau `(C OR D)`
+
+## Instalasi
+
+```bash
+pip install binboost
+```
+
+## Penggunaan Dasar
+
+```python
+import numpy as np
+from binboost import BinBoost
+
+X = np.array([[1, 0, 1], [0, 1, 0], [1, 1, 0], [0, 0, 1]], dtype=float)
+y = np.array([1, 0, 1, 0])
+
+model = BinBoost(n_estimators=50, learning_rate=0.1, max_rule_length=2)
+model.fit(X, y)
+
+print(model.predict(X))
+print(model.predict_proba(X))
+print(model.rules_)
+
+import pandas as pd
+print(pd.DataFrame(model.rule_summary_))
+```
+
+## Hyperparameter Utama
+
+| Parameter | Bawaan | Keterangan |
+|---|---|---|
+| `n_estimators` | 100 | Jumlah iterasi boosting |
+| `learning_rate` | 0.1 | Faktor penyusutan tiap aturan |
+| `loss` | `'logistic'` | Fungsi loss: `'logistic'`, `'focal'`, `'poly'` |
+| `max_rule_length` | 2 | Jumlah maksimum fitur dalam satu aturan |
+| `operators` | `['AND','OR']` | Operator logika yang digunakan |
+| `beam_width` | 5 | Lebar beam search |
+| `binarize_strategy` | `'gradient'` | Strategi binarisasi: `'gradient'`, `'quantile'`, `'uniform'`, `'kmeans'` |
+| `subsample` | 0.8 | Fraksi data per iterasi |
+| `feature_selection_threshold` | 0.01 | Ambang batas seleksi fitur berbasis gradien |
+
+## Fitur yang Didukung
+
+- Fitur biner (0/1): langsung diproses
+- Fitur numerik (int/float): dibinarisasi otomatis
+- Fitur kategorikal 3+ kelas: wajib OneHotEncode terlebih dahulu
+
+```python
+from sklearn.preprocessing import OneHotEncoder
+enc = OneHotEncoder(sparse_output=False, drop='first')
+X_encoded = enc.fit_transform(X[['kolom_kategorikal']])
+```
+
+BinBoost secara otomatis mendeteksi kelompok fitur OneHotEncoding dan mencegah aturan yang tidak masuk akal seperti `(Warna_Merah AND Warna_Biru)`.
+
+## Atribut Setelah Pelatihan
+
+```python
+model.rules_               # daftar teks aturan
+model.rule_weights_        # bobot setiap aturan
+model.feature_importances_ # skor kepentingan fitur
+model.train_score_         # loss per iterasi
+model.rule_summary_        # ringkasan lengkap atau konversi ke DataFrame
+model.n_rules_             # jumlah aturan aktif
+model.feature_usage_       # frekuensi penggunaan tiap fitur
+```
+
+## Lisensi
+
+MIT

binboost-0.1.0/README.md

@@ -0,0 +1,80 @@
+# BinBoost
+
+**Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner**
+
+BinBoost adalah algoritma klasifikasi gradient boosting yang membangun ensemble aturan logika murni (AND, OR, XOR) dengan binarisasi fitur numerik adaptif berbasis gradien pada setiap iterasi boosting. Setiap weak learner berupa aturan yang dapat dibaca langsung oleh manusia tanpa memerlukan alat bantu penjelasan pasca-pelatihan.
+
+## Kebaruan Utama
+
+- **Binarisasi adaptif berbasis gradien**: nilai ambang batas fitur numerik dicari per iterasi untuk memaksimalkan korelasi dengan gradien saat ini
+- **Ensemble aturan logika murni**: tidak ada pohon keputusan, setiap weak learner adalah aturan seperti `(A AND B)` atau `(C OR D)`
+
+## Instalasi
+
+```bash
+pip install binboost
+```
+
+## Penggunaan Dasar
+
+```python
+import numpy as np
+from binboost import BinBoost
+
+X = np.array([[1, 0, 1], [0, 1, 0], [1, 1, 0], [0, 0, 1]], dtype=float)
+y = np.array([1, 0, 1, 0])
+
+model = BinBoost(n_estimators=50, learning_rate=0.1, max_rule_length=2)
+model.fit(X, y)
+
+print(model.predict(X))
+print(model.predict_proba(X))
+print(model.rules_)
+
+import pandas as pd
+print(pd.DataFrame(model.rule_summary_))
+```
+
+## Hyperparameter Utama
+
+| Parameter | Bawaan | Keterangan |
+|---|---|---|
+| `n_estimators` | 100 | Jumlah iterasi boosting |
+| `learning_rate` | 0.1 | Faktor penyusutan tiap aturan |
+| `loss` | `'logistic'` | Fungsi loss: `'logistic'`, `'focal'`, `'poly'` |
+| `max_rule_length` | 2 | Jumlah maksimum fitur dalam satu aturan |
+| `operators` | `['AND','OR']` | Operator logika yang digunakan |
+| `beam_width` | 5 | Lebar beam search |
+| `binarize_strategy` | `'gradient'` | Strategi binarisasi: `'gradient'`, `'quantile'`, `'uniform'`, `'kmeans'` |
+| `subsample` | 0.8 | Fraksi data per iterasi |
+| `feature_selection_threshold` | 0.01 | Ambang batas seleksi fitur berbasis gradien |
+
+## Fitur yang Didukung
+
+- Fitur biner (0/1): langsung diproses
+- Fitur numerik (int/float): dibinarisasi otomatis
+- Fitur kategorikal 3+ kelas: wajib OneHotEncode terlebih dahulu
+
+```python
+from sklearn.preprocessing import OneHotEncoder
+enc = OneHotEncoder(sparse_output=False, drop='first')
+X_encoded = enc.fit_transform(X[['kolom_kategorikal']])
+```
+
+BinBoost secara otomatis mendeteksi kelompok fitur OneHotEncoding dan mencegah aturan yang tidak masuk akal seperti `(Warna_Merah AND Warna_Biru)`.
+
+## Atribut Setelah Pelatihan
+
+```python
+model.rules_               # daftar teks aturan
+model.rule_weights_        # bobot setiap aturan
+model.feature_importances_ # skor kepentingan fitur
+model.train_score_         # loss per iterasi
+model.rule_summary_        # ringkasan lengkap atau konversi ke DataFrame
+model.n_rules_             # jumlah aturan aktif
+model.feature_usage_       # frekuensi penggunaan tiap fitur
+```
+
+## Lisensi
+
+MIT

binboost-0.1.0/binboost/__init__.py

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

binboost-0.1.0/binboost/binarizer.py

@@ -0,0 +1,95 @@
+import numpy as np
+
+
+class GradientBinarizer:
+    # Binarisasi fitur numerik berbasis korelasi dengan gradien saat ini
+
+    def __init__(self, strategy='gradient', n_thresholds='auto'):
+        self.strategy = strategy
+        self.n_thresholds = n_thresholds
+        # Ambang batas tetap per fitur disimpan setelah fit pertama untuk strategi non-gradien
+        self._fixed_thresholds = {}
+
+    def _get_candidates(self, values):
+        # Kembalikan daftar kandidat ambang batas untuk satu fitur
+        unique = np.unique(values)
+        if len(unique) <= 1:
+            return np.array([])
+        if self.n_thresholds == 'auto':
+            max_t = 256
+        else:
+            max_t = int(self.n_thresholds)
+        if len(unique) - 1 <= max_t:
+            return (unique[:-1] + unique[1:]) / 2
+        idx = np.linspace(0, len(unique) - 2, max_t, dtype=int)
+        return (unique[idx] + unique[idx + 1]) / 2
+
+    def _best_threshold_gradient(self, values, gradients):
+        # 1. Cari ambang batas t* yang memaksimalkan korelasi dengan gradien
+        candidates = self._get_candidates(values)
+        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
+        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
+        if col_idx not in self._fixed_thresholds:
+            candidates = self._get_candidates(values)
+            if len(candidates) == 0:
+                self._fixed_thresholds[col_idx] = 0.0
+            else:
+                self._fixed_thresholds[col_idx] = np.median(candidates)
+        t = self._fixed_thresholds[col_idx]
+        return t, (values > t).astype(np.float64)
+
+    def _best_threshold_uniform(self, col_idx, values):
+        # 1. Gunakan ambang batas tengah dari 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
+        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):
+                labels = (np.abs(values - c1) > np.abs(values - c2)).astype(int)
+                new_c1 = values[labels == 0].mean() if (labels == 0).any() else c1
+                new_c2 = values[labels == 1].mean() if (labels == 1).any() else c2
+                if np.abs(new_c1 - c1) < 1e-8 and np.abs(new_c2 - c2) < 1e-8:
+                    break
+                c1, c2 = new_c1, new_c2
+            self._fixed_thresholds[col_idx] = (c1 + c2) / 2
+        t = self._fixed_thresholds[col_idx]
+        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)
+        thresholds_this_iter = {}
+        for col_idx in numeric_cols:
+            values = X[:, col_idx].astype(np.float64)
+            if self.strategy == 'gradient':
+                t, binary = self._best_threshold_gradient(values, gradients)
+            elif self.strategy == 'quantile':
+                t, binary = self._best_threshold_quantile(col_idx, values)
+            elif self.strategy == 'uniform':
+                t, binary = self._best_threshold_uniform(col_idx, values)
+            elif self.strategy == 'kmeans':
+                t, binary = self._best_threshold_kmeans(col_idx, values)
+            else:
+                raise ValueError(f"Strategi '{self.strategy}' tidak dikenali.")
+            X_bin[:, col_idx] = binary
+            thresholds_this_iter[col_idx] = t
+        return X_bin, thresholds_this_iter

binboost-0.1.0/binboost/binboost.py

@@ -0,0 +1,568 @@
+import numpy as np
+
+from .loss import get_loss, sigmoid
+from .binarizer import GradientBinarizer
+from .rule import Rule, BeamSearchRuleFinder
+
+
+class BinBoost:
+    """
+    BinBoost: Gradient Boosting Berbasis Aturan Logika Adaptif.
+
+    Algoritma klasifikasi biner yang membangun ensemble aturan logika
+    murni (AND, OR, XOR) dengan binarisasi fitur numerik adaptif
+    berbasis gradien pada setiap iterasi boosting.
+
+    Parameter
+    ----------
+    n_estimators : int, default=100
+        Jumlah iterasi boosting.
+
+    learning_rate : float, default=0.1
+        Faktor penyusutan kontribusi setiap aturan.
+
+    loss : str, default='logistic'
+        Fungsi loss. Pilihan: 'logistic', 'focal', 'poly'.
+
+    poly_epsilon : float, default=1.0
+        Koefisien epsilon pada PolyLoss. Hanya berlaku saat loss='poly'.
+
+    focal_gamma : float, default=2.0
+        Parameter gamma pada Focal Loss. Hanya berlaku saat loss='focal'.
+
+    focal_alpha : float, default=0.25
+        Parameter alpha pada Focal Loss. Hanya berlaku saat loss='focal'.
+
+    max_rule_length : int, default=2
+        Jumlah maksimum fitur dalam satu aturan.
+
+    operators : list, default=['AND', 'OR']
+        Daftar operator logika yang digunakan.
+
+    use_xor : bool, default=False
+        Jika True maka XOR ditambahkan ke daftar operators.
+
+    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.
+
+    beam_width : int, default=5
+        Jumlah kandidat aturan terbaik yang dipertahankan per langkah beam search.
+
+    subsample : float, default=0.8
+        Fraksi data yang digunakan per iterasi boosting.
+
+    min_samples_rule : int or float, default=10
+        Jumlah minimum sampel yang harus memenuhi sebuah aturan.
+
+    binarize_strategy : str, default='gradient'
+        Strategi binarisasi fitur numerik. Pilihan: 'gradient', 'quantile',
+        'uniform', 'kmeans'.
+
+    n_thresholds : int or str, default='auto'
+        Jumlah kandidat ambang batas per fitur numerik.
+
+    n_iter_no_change : int or None, default=None
+        Jumlah iterasi tanpa peningkatan sebelum pelatihan dihentikan lebih awal.
+
+    tol : float, default=1e-4
+        Ambang batas peningkatan minimum untuk early stopping.
+
+    random_state : int or None, default=None
+        Nilai acak untuk reprodusibilitas.
+
+    warm_start : bool, default=False
+        Jika True maka pelatihan dilanjutkan dari kondisi model sebelumnya.
+
+    Atribut yang tersedia Setelah fit
+    --------------------------------
+    estimators_ : list of Rule
+        Daftar aturan yang dipelajari.
+
+    rule_weights_ : ndarray of float
+        Bobot optimal setiap aturan.
+
+    rules_ : list of str
+        Representasi teks setiap aturan.
+
+    feature_importances_ : ndarray of float
+        Skor kepentingan setiap fitur.
+
+    thresholds_ : dict
+        Ambang batas optimal per fitur numerik per iterasi.
+
+    train_score_ : ndarray of float
+        Nilai loss per iterasi selama pelatihan.
+
+    n_features_in_ : int
+        Jumlah fitur saat fit dipanggil.
+
+    feature_names_in_ : ndarray of str or None
+        Nama fitur jika input berupa DataFrame.
+
+    n_estimators_ : int
+        Jumlah iterasi aktual setelah pelatihan.
+
+    ohe_groups_ : dict or None
+        Pemetaan kelompok fitur hasil OneHotEncoding.
+    """
+
+    def __init__(
+        self,
+        n_estimators=100,
+        learning_rate=0.1,
+        loss='logistic',
+        poly_epsilon=1.0,
+        focal_gamma=2.0,
+        focal_alpha=0.25,
+        max_rule_length=2,
+        operators=None,
+        use_xor=False,
+        rule_complexity_penalty=0.0,
+        feature_selection_threshold=0.01,
+        beam_width=5,
+        subsample=0.8,
+        min_samples_rule=10,
+        binarize_strategy='gradient',
+        n_thresholds='auto',
+        n_iter_no_change=None,
+        tol=1e-4,
+        random_state=None,
+        warm_start=False,
+    ):
+        self.n_estimators = n_estimators
+        self.learning_rate = learning_rate
+        self.loss = loss
+        self.poly_epsilon = poly_epsilon
+        self.focal_gamma = focal_gamma
+        self.focal_alpha = focal_alpha
+        self.max_rule_length = max_rule_length
+        self.operators = operators if operators is not None else ['AND', 'OR']
+        self.use_xor = use_xor
+        self.rule_complexity_penalty = rule_complexity_penalty
+        self.feature_selection_threshold = feature_selection_threshold
+        self.beam_width = beam_width
+        self.subsample = subsample
+        self.min_samples_rule = min_samples_rule
+        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
+
+    def _validate_input(self, X, y=None):
+        # Ubah input ke numpy array dan pastikan dimensinya benar
+        if hasattr(X, 'values'):
+            if hasattr(X, 'columns'):
+                self._input_feature_names = list(X.columns)
+            X = X.values
+        X = np.array(X, dtype=np.float64)
+        if X.ndim != 2:
+            raise ValueError("X harus berupa matriks dua dimensi.")
+        if y is not None:
+            y = np.array(y, dtype=np.float64)
+            unique_y = np.unique(y)
+            if not np.all(np.isin(unique_y, [0, 1])):
+                raise ValueError("Label y harus bernilai 0 atau 1.")
+            if len(y) != X.shape[0]:
+                raise ValueError("Jumlah baris X dan y harus sama.")
+        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
+
+    def _detect_ohe_groups(self, X):
+        # 1. Deteksi kelompok fitur OneHotEncoding berdasarkan sifat mutually exclusive
+        n_features = X.shape[1]
+        groups = {}
+        used = set()
+        group_id = 0
+        for i in range(n_features):
+            if i in used:
+                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))
+                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])):
+                        group.append(j)
+                        used.add(j)
+            if len(group) > 1:
+                groups[group_id] = group
+                group_id += 1
+            used.add(i)
+        return groups if groups else None
+
+    def _subsample_indices(self, n_samples, rng):
+        # 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
+        ops = list(self.operators)
+        if self.use_xor and 'XOR' not in ops:
+            ops.append('XOR')
+        return ops
+
+    def fit(self, X, y, sample_weight=None):
+        """
+        Latih BinBoost pada data X dan label y.
+
+        Parameter
+        ----------
+        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
+
+        Kembalian
+        ----------
+        self
+        """
+        self._input_feature_names = None
+        X, y = self._validate_input(X, y)
+        n_samples, n_features = X.shape
+
+        self.n_features_in_ = n_features
+        self.feature_names_in_ = (
+            np.array(self._input_feature_names)
+            if self._input_feature_names is not None else None
+        )
+
+        rng = np.random.RandomState(self.random_state)
+        ops = self._build_operators()
+
+        loss_fn = get_loss(
+            self.loss,
+            poly_epsilon=self.poly_epsilon,
+            focal_gamma=self.focal_gamma,
+            focal_alpha=self.focal_alpha,
+        )
+
+        numeric_cols = self._detect_numeric_cols(X)
+        self.ohe_groups_ = self._detect_ohe_groups(X)
+
+        binarizer = GradientBinarizer(
+            strategy=self.binarize_strategy,
+            n_thresholds=self.n_thresholds
+        )
+
+        rule_finder = BeamSearchRuleFinder(
+            operators=ops,
+            max_rule_length=self.max_rule_length,
+            beam_width=self.beam_width,
+            feature_selection_threshold=self.feature_selection_threshold,
+            min_samples_rule=self.min_samples_rule,
+            rule_complexity_penalty=self.rule_complexity_penalty,
+            ohe_groups=self.ohe_groups_,
+        )
+
+        if not self.warm_start or not hasattr(self, 'estimators_'):
+            self.estimators_ = []
+            self.rule_weights_ = []
+            self.thresholds_ = {col: [] for col in numeric_cols}
+            self.train_score_ = []
+            self._F = loss_fn.init_F(y)
+
+        no_improve_count = 0
+        best_score = np.inf
+
+        for m in range(self.n_estimators):
+            # 1. Hitung gradien dari fungsi loss yang dipilih
+            gradients = loss_fn.gradient(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]
+
+            # 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
+            rule = rule_finder.find_best_rule(X_bin, g_sub)
+            if rule is None:
+                break
+
+            rule.feature_names = (
+                list(self.feature_names_in_) if self.feature_names_in_ is not None else None
+            )
+
+            # 5. Perbarui prediksi model untuk seluruh data
+            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
+
+            # 6. Simpan aturan dan statistik iterasi ini
+            self.estimators_.append(rule)
+            self.rule_weights_.append(rule.weight)
+            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
+            if self.n_iter_no_change is not None:
+                if current_score < best_score - self.tol:
+                    best_score = current_score
+                    no_improve_count = 0
+                else:
+                    no_improve_count += 1
+                if no_improve_count >= self.n_iter_no_change:
+                    break
+
+        self.n_estimators_ = len(self.estimators_)
+        self.train_score_ = np.array(self.train_score_)
+        self.rule_weights_ = np.array(self.rule_weights_)
+        self.rules_ = [r.to_string(self.feature_names_in_) for r in self.estimators_]
+        self._compute_feature_importances(n_features)
+        self.is_fitted_ = True
+        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 f in rule.features:
+                importances[f] += gain
+        total = importances.sum()
+        self.feature_importances_ = importances / total if total > 0 else importances
+
+    def _check_is_fitted(self):
+        if not getattr(self, 'is_fitted_', False):
+            raise RuntimeError("Model belum dilatih. Panggil fit terlebih dahulu.")
+
+    def _decision_function(self, X):
+        # Hitung nilai F akhir untuk seluruh sampel
+        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_):
+            h = rule.evaluate(X_bin)
+            F += self.learning_rate * w * h
+        return F
+
+    def predict_proba(self, X):
+        """
+        Kembalikan probabilitas kelas untuk setiap sampel.
+
+        Kembalian
+        ----------
+        ndarray of shape (n_samples, 2)
+        """
+        F = self._decision_function(X)
+        p = sigmoid(F)
+        return np.column_stack([1 - p, p])
+
+    def predict_log_proba(self, X):
+        """
+        Kembalikan logaritma probabilitas kelas untuk setiap sampel.
+
+        Kembalian
+        ----------
+        ndarray of shape (n_samples, 2)
+        """
+        return np.log(np.clip(self.predict_proba(X), 1e-15, None))
+
+    def predict(self, X):
+        """
+        Prediksi label kelas (0 atau 1) untuk setiap sampel.
+
+        Kembalian
+        ----------
+        ndarray of shape (n_samples,)
+        """
+        proba = self.predict_proba(X)
+        return (proba[:, 1] >= 0.5).astype(int)
+
+    def score(self, X, y):
+        """
+        Hitung akurasi klasifikasi pada data X dan label y.
+
+        Kembalian
+        ----------
+        float
+        """
+        _, y = self._validate_input(X, y)
+        preds = self.predict(X)
+        return np.mean(preds == y)
+
+    def staged_predict_proba(self, X):
+        """
+        Generator probabilitas per iterasi boosting.
+
+        Hasil
+        ----------
+        ndarray of shape (n_samples, 2) per iterasi
+        """
+        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)
+        F = np.zeros(X.shape[0])
+        for rule, w in zip(self.estimators_, self.rule_weights_):
+            h = rule.evaluate(X_bin)
+            F += self.learning_rate * w * h
+            p = sigmoid(F)
+            yield np.column_stack([1 - p, p])
+
+    def staged_predict(self, X):
+        """
+        Generator prediksi kelas per iterasi boosting.
+
+        Hasil
+        ----------
+        ndarray of shape (n_samples,) per iterasi
+        """
+        for proba in self.staged_predict_proba(X):
+            yield (proba[:, 1] >= 0.5).astype(int)
+
+    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)
+        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)
+        results = []
+        for rule in self.estimators_:
+            results.append(rule.evaluate(X_bin))
+        return np.column_stack(results)
+
+    def get_params(self, deep=True):
+        """
+        Kembalikan semua hyperparameter sebagai kamus.
+
+        Kembalian
+        ----------
+        dict
+        """
+        return {
+            'n_estimators': self.n_estimators,
+            'learning_rate': self.learning_rate,
+            'loss': self.loss,
+            'poly_epsilon': self.poly_epsilon,
+            'focal_gamma': self.focal_gamma,
+            'focal_alpha': self.focal_alpha,
+            'max_rule_length': self.max_rule_length,
+            'operators': self.operators,
+            'use_xor': self.use_xor,
+            'rule_complexity_penalty': self.rule_complexity_penalty,
+            'feature_selection_threshold': self.feature_selection_threshold,
+            'beam_width': self.beam_width,
+            'subsample': self.subsample,
+            'min_samples_rule': self.min_samples_rule,
+            '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,
+        }
+
+    def set_params(self, **params):
+        """
+        Tetapkan nilai hyperparameter.
+
+        Kembalian
+        ----------
+        self
+        """
+        for key, val in params.items():
+            if not hasattr(self, key):
+                raise ValueError(f"Parameter '{key}' tidak dikenali.")
+            setattr(self, key, val)
+        return self
+
+    @property
+    def rule_summary_(self):
+        """
+        Tabel ringkasan semua aturan beserta bobot, cakupan, dan dukungan.
+
+        Kembalian
+        ----------
+        list of dict yang dapat dikonversi ke DataFrame
+        """
+        self._check_is_fitted()
+        summary = []
+        for i, rule in enumerate(self.estimators_):
+            summary.append({
+                'iterasi': i + 1,
+                'aturan': self.rules_[i],
+                'bobot': round(float(self.rule_weights_[i]), 6),
+                'panjang_aturan': len(rule.features),
+            })
+        return summary
+
+    @property
+    def n_rules_(self):
+        """
+        Jumlah aturan aktif dalam model.
+
+        Kembalian
+        ----------
+        int
+        """
+        self._check_is_fitted()
+        return self.n_estimators_
+
+    @property
+    def feature_usage_(self):
+        """
+        Frekuensi kemunculan setiap fitur di dalam aturan.
+
+        Kembalian
+        ----------
+        dict
+        """
+        self._check_is_fitted()
+        usage = {}
+        for rule in self.estimators_:
+            for f in rule.features:
+                name = (
+                    self.feature_names_in_[f]
+                    if self.feature_names_in_ is not None
+                    else f"X{f}"
+                )
+                usage[name] = usage.get(name, 0) + 1
+        return usage

binboost-0.1.0/binboost/loss.py

@@ -0,0 +1,99 @@
+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)
+        return -np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))
+
+    def gradient(self, y, F):
+        # 1. Gradien negatif sebagai arah penurunan loss
+        p = sigmoid(F)
+        return y - p
+
+    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
+
+    def loss(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)
+        return -np.mean(alpha_t * ((1 - pt) ** self.gamma) * np.log(pt))
+
+    def gradient(self, y, F):
+        # 1. Gradien Focal Loss mengikuti turunan dari Lin et al. 2017
+        # a. Hitung probabilitas dan faktor modulasi
+        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)
+        # b. Gradien lengkap dengan faktor fokus
+        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 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):
+        self.epsilon = epsilon
+
+    def loss(self, y, F):
+        p = sigmoid(F)
+        p = np.clip(p, 1e-15, 1 - 1e-15)
+        pt = np.where(y == 1, p, 1 - p)
+        ce = -np.log(pt)
+        return np.mean(ce + self.epsilon * (1 - pt))
+
+    def gradient(self, y, F):
+        # 1. Gradien PolyLoss adalah gradien CE ditambah suku koreksi polinomial
+        p = sigmoid(F)
+        p = np.clip(p, 1e-15, 1 - 1e-15)
+        pt = np.where(y == 1, p, 1 - p)
+        # a. Gradien cross-entropy standar
+        grad_ce = y - p
+        # 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 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':
+        return LogisticLoss()
+    elif name == 'focal':
+        return FocalLoss(
+            gamma=kwargs.get('focal_gamma', 2.0),
+            alpha=kwargs.get('focal_alpha', 0.25)
+        )
+    elif name == 'poly':
+        return PolyLoss(epsilon=kwargs.get('poly_epsilon', 1.0))
+    else:
+        raise ValueError(f"Loss '{name}' tidak dikenali. Pilihan: 'logistic', 'focal', 'poly'.")

binboost-0.1.0/binboost/rule.py

@@ -0,0 +1,168 @@
+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)

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

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: binboost
+Version: 0.1.0
+Summary: Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner
+Home-page: https://github.com/username/binboost
+Author: BinBoost Authors
+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
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: pandas>=1.3.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# BinBoost
+
+**Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner**
+
+BinBoost adalah algoritma klasifikasi gradient boosting yang membangun ensemble aturan logika murni (AND, OR, XOR) dengan binarisasi fitur numerik adaptif berbasis gradien pada setiap iterasi boosting. Setiap weak learner berupa aturan yang dapat dibaca langsung oleh manusia tanpa memerlukan alat bantu penjelasan pasca-pelatihan.
+
+## Kebaruan Utama
+
+- **Binarisasi adaptif berbasis gradien**: nilai ambang batas fitur numerik dicari per iterasi untuk memaksimalkan korelasi dengan gradien saat ini
+- **Ensemble aturan logika murni**: tidak ada pohon keputusan, setiap weak learner adalah aturan seperti `(A AND B)` atau `(C OR D)`
+
+## Instalasi
+
+```bash
+pip install binboost
+```
+
+## Penggunaan Dasar
+
+```python
+import numpy as np
+from binboost import BinBoost
+
+X = np.array([[1, 0, 1], [0, 1, 0], [1, 1, 0], [0, 0, 1]], dtype=float)
+y = np.array([1, 0, 1, 0])
+
+model = BinBoost(n_estimators=50, learning_rate=0.1, max_rule_length=2)
+model.fit(X, y)
+
+print(model.predict(X))
+print(model.predict_proba(X))
+print(model.rules_)
+
+import pandas as pd
+print(pd.DataFrame(model.rule_summary_))
+```
+
+## Hyperparameter Utama
+
+| Parameter | Bawaan | Keterangan |
+|---|---|---|
+| `n_estimators` | 100 | Jumlah iterasi boosting |
+| `learning_rate` | 0.1 | Faktor penyusutan tiap aturan |
+| `loss` | `'logistic'` | Fungsi loss: `'logistic'`, `'focal'`, `'poly'` |
+| `max_rule_length` | 2 | Jumlah maksimum fitur dalam satu aturan |
+| `operators` | `['AND','OR']` | Operator logika yang digunakan |
+| `beam_width` | 5 | Lebar beam search |
+| `binarize_strategy` | `'gradient'` | Strategi binarisasi: `'gradient'`, `'quantile'`, `'uniform'`, `'kmeans'` |
+| `subsample` | 0.8 | Fraksi data per iterasi |
+| `feature_selection_threshold` | 0.01 | Ambang batas seleksi fitur berbasis gradien |
+
+## Fitur yang Didukung
+
+- Fitur biner (0/1): langsung diproses
+- Fitur numerik (int/float): dibinarisasi otomatis
+- Fitur kategorikal 3+ kelas: wajib OneHotEncode terlebih dahulu
+
+```python
+from sklearn.preprocessing import OneHotEncoder
+enc = OneHotEncoder(sparse_output=False, drop='first')
+X_encoded = enc.fit_transform(X[['kolom_kategorikal']])
+```
+
+BinBoost secara otomatis mendeteksi kelompok fitur OneHotEncoding dan mencegah aturan yang tidak masuk akal seperti `(Warna_Merah AND Warna_Biru)`.
+
+## Atribut Setelah Pelatihan
+
+```python
+model.rules_               # daftar teks aturan
+model.rule_weights_        # bobot setiap aturan
+model.feature_importances_ # skor kepentingan fitur
+model.train_score_         # loss per iterasi
+model.rule_summary_        # ringkasan lengkap atau konversi ke DataFrame
+model.n_rules_             # jumlah aturan aktif
+model.feature_usage_       # frekuensi penggunaan tiap fitur
+```
+
+## Lisensi
+
+MIT

binboost-0.1.0/binboost.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+binboost/__init__.py
+binboost/binarizer.py
+binboost/binboost.py
+binboost/loss.py
+binboost/rule.py
+binboost.egg-info/PKG-INFO
+binboost.egg-info/SOURCES.txt
+binboost.egg-info/dependency_links.txt
+binboost.egg-info/requires.txt
+binboost.egg-info/top_level.txt

binboost-0.1.0/binboost.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

binboost-0.1.0/binboost.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy>=1.21.0
+pandas>=1.3.0

binboost-0.1.0/binboost.egg-info/top_level.txt

@@ -0,0 +1 @@
+binboost

binboost-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "binboost"
+version = "0.1.0"
+description = "Gradient Boosting Berbasis Aturan Logika Adaptif untuk Fitur Biner"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+dependencies = [
+    "numpy>=1.21.0",
+    "pandas>=1.3.0",
+]
+keywords = ["gradient boosting", "logical rules", "binary features", "interpretable machine learning"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.urls]
+Homepage = "https://github.com/username/binboost"

binboost-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

binboost-0.1.0/setup.py

@@ -0,0 +1,25 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="binboost",
+    version="0.1.0",
+    author="BinBoost Authors",
+    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=[
+        "numpy>=1.21.0",
+        "pandas>=1.3.0",
+    ],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Intended Audience :: Science/Research",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    ],
+    keywords="gradient boosting, logical rules, binary features, interpretable machine learning",
+)