smallgbm 1.0.0__tar.gz

smallgbm-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Emelyanov Ilya
+
+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.

smallgbm-1.0.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include LICENSE

smallgbm-1.0.0/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: smallgbm
+Version: 1.0.0
+Summary: Gradient boosting optimized for small datasets (n < 1000)
+Home-page: https://github.com/nsdmlk/SmallGBM
+Author: Emelyanov Ilya
+Author-email: Nsdmlk@yandex.ru
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: scikit-learn>=1.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+# SmallGBM
+
+<p align="center">
+  <b>Gradient boosting that actually works on small data.</b>
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/version-1.0.0-blue" alt="version">
+  <img src="https://img.shields.io/badge/python-3.8+-green" alt="python">
+  <img src="https://img.shields.io/badge/license-MIT-brightgreen" alt="license">
+  <img src="https://img.shields.io/badge/pip%20install-smallgbm-orange" alt="pip">
+</p>
+
+---
+
+## Why SmallGBM?
+
+XGBoost and LightGBM are built for scale. They shine on thousands of rows. But when you only have **50, 100, or 500 samples**, their default hyperparameters fail — overfitting, instability, unpredictable results.
+
+**SmallGBM** is designed from the ground up for datasets with fewer than 1000 samples.
+
+| Feature                      | SmallGBM | XGBoost | LightGBM |
+| ---------------------------- | -------- | ------- | -------- |
+| Bayesian leaf weights        | ✅       | ❌      | ❌       |
+| Adaptive regularization      | ✅       | ❌      | ❌       |
+| No bootstrap (uses all data) | ✅       | ❌      | ❌       |
+| Stable under label noise     | ✅       | ❌      | ❌       |
+| scikit-learn compatible      | ✅       | ✅      | ✅       |
+
+---
+
+## Noise Stability
+
+SmallGBM degrades gracefully when labels are noisy — unlike XGBoost and LightGBM which drop sharply.
+
+<p align="center">
+  <img src="docs/noise_comparison.png" width="600" alt="Noise stability comparison">
+</p>
+
+*At 20% label noise, SmallGBM is the best performer. Bayesian regularization keeps it stable when others collapse.*
+
+---
+
+## Learning Curve
+
+Clear, predictable improvement as data grows. Reliable performance starts at **n ≈ 40**.
+
+<p align="center">
+  <img src="docs/learning_curve.png" width="600" alt="Learning curve">
+</p>
+
+*No sudden jumps, no catastrophic failures. A safe choice when data is limited.*
+
+---
+
+## Installation
+
+```bash
+pip install smallgbm
+```
+
+## Quickstart
+
+```python
+from smallgbm import SmallGBMClassifier
+
+model = SmallGBMClassifier()
+model.fit(X_train, y_train)
+proba = model.predict_proba(X_test)
+```
+
+## API
+
+### SmallGBMClassifier
+
+| Parameter            | Default | Description               |
+| -------------------- | ------- | ------------------------- |
+| `n_estimators`     | 50      | Number of boosting rounds |
+| `max_depth`        | 3       | Maximum tree depth        |
+| `min_samples_leaf` | 3       | Minimum samples per leaf  |
+| `learning_rate`    | 0.1     | Shrinkage factor          |
+| `sigma_prior`      | 0.5     | Bayesian prior strength   |
+
+### SmallGBMRegressor
+
+Same parameters, for regression tasks.
+
+```python
+from smallgbm import SmallGBMRegressor
+
+model = SmallGBMRegressor()
+model.fit(X_train, y_train)
+preds = model.predict(X_test)
+```
+
+---
+
+## Research
+
+Full characterisation notebook with 5 experiments: `benchmark_final.ipynb`
+
+- Noise stability analysis
+- Prior sensitivity
+- Sample size curve
+- Regression performance
+- Class imbalance tolerance
+
+---
+
+## License
+
+MIT © [Emelyanov Ilya](https://github.com/nsdmlk) 2026
+
+---
+
+<p align="center">
+  <sub>Built with ❤️ for the small data community</sub>
+</p>

smallgbm-1.0.0/README.md

@@ -0,0 +1,119 @@
+
+# SmallGBM
+
+<p align="center">
+  <b>Gradient boosting that actually works on small data.</b>
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/version-1.0.0-blue" alt="version">
+  <img src="https://img.shields.io/badge/python-3.8+-green" alt="python">
+  <img src="https://img.shields.io/badge/license-MIT-brightgreen" alt="license">
+  <img src="https://img.shields.io/badge/pip%20install-smallgbm-orange" alt="pip">
+</p>
+
+---
+
+## Why SmallGBM?
+
+XGBoost and LightGBM are built for scale. They shine on thousands of rows. But when you only have **50, 100, or 500 samples**, their default hyperparameters fail — overfitting, instability, unpredictable results.
+
+**SmallGBM** is designed from the ground up for datasets with fewer than 1000 samples.
+
+| Feature                      | SmallGBM | XGBoost | LightGBM |
+| ---------------------------- | -------- | ------- | -------- |
+| Bayesian leaf weights        | ✅       | ❌      | ❌       |
+| Adaptive regularization      | ✅       | ❌      | ❌       |
+| No bootstrap (uses all data) | ✅       | ❌      | ❌       |
+| Stable under label noise     | ✅       | ❌      | ❌       |
+| scikit-learn compatible      | ✅       | ✅      | ✅       |
+
+---
+
+## Noise Stability
+
+SmallGBM degrades gracefully when labels are noisy — unlike XGBoost and LightGBM which drop sharply.
+
+<p align="center">
+  <img src="docs/noise_comparison.png" width="600" alt="Noise stability comparison">
+</p>
+
+*At 20% label noise, SmallGBM is the best performer. Bayesian regularization keeps it stable when others collapse.*
+
+---
+
+## Learning Curve
+
+Clear, predictable improvement as data grows. Reliable performance starts at **n ≈ 40**.
+
+<p align="center">
+  <img src="docs/learning_curve.png" width="600" alt="Learning curve">
+</p>
+
+*No sudden jumps, no catastrophic failures. A safe choice when data is limited.*
+
+---
+
+## Installation
+
+```bash
+pip install smallgbm
+```
+
+## Quickstart
+
+```python
+from smallgbm import SmallGBMClassifier
+
+model = SmallGBMClassifier()
+model.fit(X_train, y_train)
+proba = model.predict_proba(X_test)
+```
+
+## API
+
+### SmallGBMClassifier
+
+| Parameter            | Default | Description               |
+| -------------------- | ------- | ------------------------- |
+| `n_estimators`     | 50      | Number of boosting rounds |
+| `max_depth`        | 3       | Maximum tree depth        |
+| `min_samples_leaf` | 3       | Minimum samples per leaf  |
+| `learning_rate`    | 0.1     | Shrinkage factor          |
+| `sigma_prior`      | 0.5     | Bayesian prior strength   |
+
+### SmallGBMRegressor
+
+Same parameters, for regression tasks.
+
+```python
+from smallgbm import SmallGBMRegressor
+
+model = SmallGBMRegressor()
+model.fit(X_train, y_train)
+preds = model.predict(X_test)
+```
+
+---
+
+## Research
+
+Full characterisation notebook with 5 experiments: `benchmark_final.ipynb`
+
+- Noise stability analysis
+- Prior sensitivity
+- Sample size curve
+- Regression performance
+- Class imbalance tolerance
+
+---
+
+## License
+
+MIT © [Emelyanov Ilya](https://github.com/nsdmlk) 2026
+
+---
+
+<p align="center">
+  <sub>Built with ❤️ for the small data community</sub>
+</p>

smallgbm-1.0.0/setup.cfg

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

smallgbm-1.0.0/setup.py

@@ -0,0 +1,28 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="smallgbm",
+    version="1.0.0",
+    author="Emelyanov Ilya",
+    author_email="Nsdmlk@yandex.ru",
+    description="Gradient boosting optimized for small datasets (n < 1000)",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/nsdmlk/SmallGBM",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+        "Intended Audience :: Science/Research",
+    ],
+    python_requires=">=3.8",
+    install_requires=[
+        "numpy>=1.20.0",
+        "scikit-learn>=1.0.0",
+    ],
+)

smallgbm-1.0.0/smallgbm/__init__.py

@@ -0,0 +1,2 @@
+# smallgbm/__init__.py
+from .smallgbm import SmallGBMClassifier, SmallGBMRegressor

smallgbm-1.0.0/smallgbm/smallgbm.py

@@ -0,0 +1,170 @@
+import numpy as np
+from sklearn.base import BaseEstimator, ClassifierMixin, RegressorMixin
+from .tree import BayesianDecisionTree
+
+
+class SmallGBMClassifier(BaseEstimator, ClassifierMixin):
+    def __init__(self, n_estimators=50, max_depth=3, min_samples_leaf=3,
+             learning_rate=0.1, sigma_prior=0.5, adaptive_prior=False,
+             dynamic_depth=False, weighted_residuals=False, soft_bootstrap=False):
+        self.n_estimators = n_estimators
+        self.max_depth = max_depth
+        self.min_samples_leaf = min_samples_leaf
+        self.learning_rate = learning_rate
+        self.sigma_prior = sigma_prior
+        self.adaptive_prior = adaptive_prior
+        self.dynamic_depth = dynamic_depth
+        self.weighted_residuals = weighted_residuals
+        self.soft_bootstrap = soft_bootstrap
+
+    def _log_odds(self, y):
+        pos = np.sum(y == 1)
+        neg = np.sum(y == 0)
+        return np.log((pos + 1e-10) / (neg + 1e-10))
+
+    def _sigmoid(self, x):
+        return 1 / (1 + np.exp(-x))
+
+    def fit(self, X, y):
+        X = np.array(X)
+        y = np.array(y)
+        n_samples = len(y)
+
+        init = self._log_odds(y)
+        self.base_score_ = init
+        self._trees = []
+
+        current_pred = np.full(y.shape, init)
+
+        for i in range(self.n_estimators):
+            proba = self._sigmoid(current_pred)
+            residuals = y - proba
+
+            # 2. Weighted residuals: weight = proba * (1 - proba)
+            if self.weighted_residuals:
+                confidence = proba * (1 - proba)
+                confidence = np.clip(confidence, 1e-10, None)
+                sample_weights = confidence / confidence.sum() * n_samples
+            else:
+                sample_weights = np.ones(n_samples)
+
+            # 4. Soft bootstrap: weighted sampling without replacement bias
+            if self.soft_bootstrap:
+                # Use all data but weight the residuals by sample_weights
+                weighted_residuals = residuals * sample_weights
+            else:
+                weighted_residuals = residuals
+
+            # 3. Dynamic depth: deeper early, shallower later
+            if self.dynamic_depth:
+                progress = i / self.n_estimators
+                current_max_depth = max(1, int(self.max_depth * (1 - progress * 0.5)))
+            else:
+                current_max_depth = self.max_depth
+
+            # 1. Adaptive sigma_prior: 1 / sqrt(n) if not specified
+            if self.adaptive_prior and self.sigma_prior is None:
+                sigma_prior = 1.0 / np.sqrt(n_samples)
+            elif self.sigma_prior is not None:
+                sigma_prior = self.sigma_prior
+            else:
+                sigma_prior = 1.0
+
+            tree = BayesianDecisionTree(
+                max_depth=current_max_depth,
+                min_samples_leaf=self.min_samples_leaf,
+                sigma_prior=sigma_prior,
+                n_splits=20
+            )
+            tree.fit(X, weighted_residuals)
+
+            update = tree.predict(X)
+            current_pred += self.learning_rate * update
+            self._trees.append(tree)
+
+        return self
+
+    def predict_proba(self, X):
+        X = np.array(X)
+        current_pred = np.full(X.shape[0], self.base_score_)
+        for tree in self._trees:
+            current_pred += self.learning_rate * tree.predict(X)
+        proba_pos = self._sigmoid(current_pred)
+        return np.column_stack([1 - proba_pos, proba_pos])
+
+    def predict(self, X):
+        proba = self.predict_proba(X)[:, 1]
+        return (proba > 0.5).astype(int)
+    
+class SmallGBMRegressor(BaseEstimator, RegressorMixin):
+    def __init__(self, n_estimators=50, max_depth=3, min_samples_leaf=3,
+                 learning_rate=0.1, sigma_prior=0.5, adaptive_prior=False,
+                 dynamic_depth=False, weighted_residuals=False, soft_bootstrap=False):
+        self.n_estimators = n_estimators
+        self.max_depth = max_depth
+        self.min_samples_leaf = min_samples_leaf
+        self.learning_rate = learning_rate
+        self.sigma_prior = sigma_prior
+        self.adaptive_prior = adaptive_prior
+        self.dynamic_depth = dynamic_depth
+        self.weighted_residuals = weighted_residuals
+        self.soft_bootstrap = soft_bootstrap
+
+    def fit(self, X, y):
+        X = np.array(X)
+        y = np.array(y).astype(float)
+        n_samples = len(y)
+
+        # Initial prediction: mean of y
+        init = np.mean(y)
+        self.base_score_ = init
+        self._trees = []
+
+        current_pred = np.full(y.shape, init)
+
+        for i in range(self.n_estimators):
+            residuals = y - current_pred  # MSE residuals
+
+            if self.weighted_residuals:
+                confidence = np.abs(residuals)
+                confidence = np.clip(confidence, 1e-10, None)
+                sample_weights = confidence / confidence.sum() * n_samples
+            else:
+                sample_weights = np.ones(n_samples)
+
+            if self.soft_bootstrap:
+                weighted_residuals = residuals * sample_weights
+            else:
+                weighted_residuals = residuals
+
+            if self.dynamic_depth:
+                progress = i / self.n_estimators
+                current_max_depth = max(1, int(self.max_depth * (1 - progress * 0.5)))
+            else:
+                current_max_depth = self.max_depth
+
+            if self.adaptive_prior and self.sigma_prior is None:
+                sigma_prior = 1.0 / np.sqrt(n_samples)
+            elif self.sigma_prior is not None:
+                sigma_prior = self.sigma_prior
+            else:
+                sigma_prior = 1.0
+
+            tree = BayesianDecisionTree(
+                max_depth=current_max_depth,
+                min_samples_leaf=self.min_samples_leaf,
+                sigma_prior=sigma_prior)
+            tree.fit(X, weighted_residuals)
+
+            update = tree.predict(X)
+            current_pred += self.learning_rate * update
+            self._trees.append(tree)
+
+        return self
+
+    def predict(self, X):
+        X = np.array(X)
+        current_pred = np.full(X.shape[0], self.base_score_)
+        for tree in self._trees:
+            current_pred += self.learning_rate * tree.predict(X)
+        return current_pred

smallgbm-1.0.0/smallgbm/tree.py

@@ -0,0 +1,116 @@
+import numpy as np
+
+class BayesianDecisionTree:
+    """Optimized decision tree with Bayesian leaf weight estimation."""
+    
+    def __init__(self, max_depth=2, min_samples_leaf=5, sigma_prior=1.0, n_splits=10):
+        self.max_depth = max_depth
+        self.min_samples_leaf = min_samples_leaf
+        self.sigma_prior = sigma_prior
+        self.n_splits = n_splits
+        self.tree_ = None
+    
+    def _variance(self, y):
+        if len(y) <= 1:
+            return 0.0
+        return np.var(y)
+    
+    def _bayesian_weight(self, residuals):
+        n = len(residuals)
+        sum_r = np.sum(residuals)
+        sigma_noise = self._variance(residuals)
+        if sigma_noise == 0:
+            return sum_r / n if n > 0 else 0.0
+        shrinkage = sigma_noise / (self.sigma_prior ** 2)
+        return sum_r / (n + shrinkage)
+    
+    def _best_split(self, X, residuals):
+        best_gain = -np.inf
+        best_feature = None
+        best_threshold = None
+        
+        n_features = X.shape[1]
+        n = len(residuals)
+        
+        for feature in range(n_features):
+            values = X[:, feature]
+            sort_idx = np.argsort(values)
+            sorted_values = values[sort_idx]
+            sorted_residuals = residuals[sort_idx]
+            
+            # Prefix sums for O(1) variance computation
+            cumsum = np.cumsum(sorted_residuals)
+            cumsum2 = np.cumsum(sorted_residuals ** 2)
+            total_sum = cumsum[-1]
+            total_sum2 = cumsum2[-1]
+            parent_var = (total_sum2 - total_sum**2 / n) / n if n > 1 else 0
+            
+            # Full search over all valid split positions
+            for pos in range(self.min_samples_leaf, n - self.min_samples_leaf + 1):
+                left_n = pos
+                right_n = n - pos
+                
+                left_sum = cumsum[pos - 1]
+                left_sum2 = cumsum2[pos - 1]
+                left_var = (left_sum2 - left_sum**2 / left_n) / left_n if left_n > 1 else 0
+                
+                right_sum = total_sum - left_sum
+                right_sum2 = total_sum2 - left_sum2
+                right_var = (right_sum2 - right_sum**2 / right_n) / right_n if right_n > 1 else 0
+                
+                gain = parent_var - (left_n / n * left_var + right_n / n * right_var)
+                
+                if gain > best_gain:
+                    best_gain = gain
+                    best_feature = feature
+                    best_threshold = (sorted_values[pos - 1] + sorted_values[pos]) / 2
+        
+        return best_feature, best_threshold, best_gain
+    
+    def _build_tree(self, X, residuals, depth=0):
+        n = len(residuals)
+        
+        if (depth >= self.max_depth or 
+            n < self.min_samples_leaf * 2 or 
+            len(np.unique(residuals)) == 1):
+            return {
+                'type': 'leaf',
+                'weight': self._bayesian_weight(residuals),
+                'n_samples': n
+            }
+        
+        feature, threshold, gain = self._best_split(X, residuals)
+        
+        if feature is None or gain <= 0:
+            return {
+                'type': 'leaf',
+                'weight': self._bayesian_weight(residuals),
+                'n_samples': n
+            }
+        
+        left_mask = X[:, feature] <= threshold
+        right_mask = ~left_mask
+        
+        return {
+            'type': 'node',
+            'feature': feature,
+            'threshold': threshold,
+            'n_samples': n,
+            'left': self._build_tree(X[left_mask], residuals[left_mask], depth + 1),
+            'right': self._build_tree(X[right_mask], residuals[right_mask], depth + 1)
+        }
+    
+    def fit(self, X, residuals):
+        self.tree_ = self._build_tree(np.array(X), np.array(residuals))
+        return self
+    
+    def _predict_one(self, x, node):
+        if node['type'] == 'leaf':
+            return node['weight']
+        if x[node['feature']] <= node['threshold']:
+            return self._predict_one(x, node['left'])
+        else:
+            return self._predict_one(x, node['right'])
+    
+    def predict(self, X):
+        return np.array([self._predict_one(x, self.tree_) for x in np.array(X)])

smallgbm-1.0.0/smallgbm.egg-info/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: smallgbm
+Version: 1.0.0
+Summary: Gradient boosting optimized for small datasets (n < 1000)
+Home-page: https://github.com/nsdmlk/SmallGBM
+Author: Emelyanov Ilya
+Author-email: Nsdmlk@yandex.ru
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: scikit-learn>=1.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+# SmallGBM
+
+<p align="center">
+  <b>Gradient boosting that actually works on small data.</b>
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/version-1.0.0-blue" alt="version">
+  <img src="https://img.shields.io/badge/python-3.8+-green" alt="python">
+  <img src="https://img.shields.io/badge/license-MIT-brightgreen" alt="license">
+  <img src="https://img.shields.io/badge/pip%20install-smallgbm-orange" alt="pip">
+</p>
+
+---
+
+## Why SmallGBM?
+
+XGBoost and LightGBM are built for scale. They shine on thousands of rows. But when you only have **50, 100, or 500 samples**, their default hyperparameters fail — overfitting, instability, unpredictable results.
+
+**SmallGBM** is designed from the ground up for datasets with fewer than 1000 samples.
+
+| Feature                      | SmallGBM | XGBoost | LightGBM |
+| ---------------------------- | -------- | ------- | -------- |
+| Bayesian leaf weights        | ✅       | ❌      | ❌       |
+| Adaptive regularization      | ✅       | ❌      | ❌       |
+| No bootstrap (uses all data) | ✅       | ❌      | ❌       |
+| Stable under label noise     | ✅       | ❌      | ❌       |
+| scikit-learn compatible      | ✅       | ✅      | ✅       |
+
+---
+
+## Noise Stability
+
+SmallGBM degrades gracefully when labels are noisy — unlike XGBoost and LightGBM which drop sharply.
+
+<p align="center">
+  <img src="docs/noise_comparison.png" width="600" alt="Noise stability comparison">
+</p>
+
+*At 20% label noise, SmallGBM is the best performer. Bayesian regularization keeps it stable when others collapse.*
+
+---
+
+## Learning Curve
+
+Clear, predictable improvement as data grows. Reliable performance starts at **n ≈ 40**.
+
+<p align="center">
+  <img src="docs/learning_curve.png" width="600" alt="Learning curve">
+</p>
+
+*No sudden jumps, no catastrophic failures. A safe choice when data is limited.*
+
+---
+
+## Installation
+
+```bash
+pip install smallgbm
+```
+
+## Quickstart
+
+```python
+from smallgbm import SmallGBMClassifier
+
+model = SmallGBMClassifier()
+model.fit(X_train, y_train)
+proba = model.predict_proba(X_test)
+```
+
+## API
+
+### SmallGBMClassifier
+
+| Parameter            | Default | Description               |
+| -------------------- | ------- | ------------------------- |
+| `n_estimators`     | 50      | Number of boosting rounds |
+| `max_depth`        | 3       | Maximum tree depth        |
+| `min_samples_leaf` | 3       | Minimum samples per leaf  |
+| `learning_rate`    | 0.1     | Shrinkage factor          |
+| `sigma_prior`      | 0.5     | Bayesian prior strength   |
+
+### SmallGBMRegressor
+
+Same parameters, for regression tasks.
+
+```python
+from smallgbm import SmallGBMRegressor
+
+model = SmallGBMRegressor()
+model.fit(X_train, y_train)
+preds = model.predict(X_test)
+```
+
+---
+
+## Research
+
+Full characterisation notebook with 5 experiments: `benchmark_final.ipynb`
+
+- Noise stability analysis
+- Prior sensitivity
+- Sample size curve
+- Regression performance
+- Class imbalance tolerance
+
+---
+
+## License
+
+MIT © [Emelyanov Ilya](https://github.com/nsdmlk) 2026
+
+---
+
+<p align="center">
+  <sub>Built with ❤️ for the small data community</sub>
+</p>

smallgbm-1.0.0/smallgbm.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+smallgbm/__init__.py
+smallgbm/smallgbm.py
+smallgbm/tree.py
+smallgbm.egg-info/PKG-INFO
+smallgbm.egg-info/SOURCES.txt
+smallgbm.egg-info/dependency_links.txt
+smallgbm.egg-info/requires.txt
+smallgbm.egg-info/top_level.txt

smallgbm-1.0.0/smallgbm.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

smallgbm-1.0.0/smallgbm.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy>=1.20.0
+scikit-learn>=1.0.0

smallgbm-1.0.0/smallgbm.egg-info/top_level.txt

@@ -0,0 +1 @@
+smallgbm