perpetual 1.1.1__cp312-cp312-macosx_10_12_x86_64.whl

perpetual/utils.py

@@ -0,0 +1,463 @@
+import logging
+from typing import Dict, Iterable, List, Optional, Tuple
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+def type_df(df):
+    library_name = type(df).__module__.split(".")[0]
+    if type(df).__name__ == "DataFrame":
+        if library_name == "pandas":
+            return "pandas_df"
+        elif library_name == "polars":
+            return "polars_df"
+    elif library_name == "numpy":
+        return "numpy"
+    else:
+        return ""
+
+
+def type_series(y):
+    library_name = type(y).__module__.split(".")[0]
+    if type(y).__name__ == "Series":
+        if library_name == "pandas":
+            return "pandas_series"
+        elif library_name == "polars":
+            return "polars_series"
+    elif library_name == "numpy":
+        return "numpy"
+    else:
+        return ""
+
+
+def convert_input_array(x, objective, is_target=False, is_int=False) -> np.ndarray:
+    classes_ = []
+
+    if type(x).__module__.split(".")[0] == "numpy":
+        if len(x.shape) == 2:
+            classes_, x_, *_ = convert_input_frame(x, None, 1000)
+        else:
+            x_ = x
+    elif type_series(x) == "pandas_series":
+        x_ = x.to_numpy()
+    elif type_series(x) == "polars_series":
+        x_ = x.to_numpy(allow_copy=False)
+    elif type_df(x) == "polars_df" or type_df(x) == "pandas_df":
+        classes_, x_, *_ = convert_input_frame(x, None, 1000)
+    else:
+        x_ = x.to_numpy()
+
+    if is_target and objective == "LogLoss" and len(x_.shape) == 1:
+        classes_, x_index = np.unique(x_, return_inverse=True)
+        if len(classes_) > 2:
+            x_ = np.eye(len(classes_))[x_index]
+        else:
+            x_ = x_index.astype("float64")
+
+    if is_int and not np.issubdtype(x_.dtype, "uint64"):
+        x_ = x_.astype(dtype="uint64", copy=False)
+
+    if not is_int and not np.issubdtype(x_.dtype, "float64"):
+        x_ = x_.astype(dtype="float64", copy=False)
+
+    if len(x_.shape) == 2:
+        x_ = x_.ravel(order="F")
+
+    return x_, classes_
+
+
+def convert_input_frame(
+    X,
+    categorical_features,
+    max_cat,
+) -> Tuple[List[str], np.ndarray, int, int, Optional[Iterable[int]], Optional[Dict]]:
+    """Convert data to format needed by booster.
+
+    Returns:
+        Tuple[List[str], np.ndarray, int, int, Optional[Iterable[int]], Optional[Dict]]: Return column names, the flat data, number of rows, the number of columns, cat_index, cat_mapping
+    """
+    categorical_features_ = None
+    if type_df(X) == "pandas_df":
+        X_ = X.to_numpy()
+        features_ = X.columns.to_list()
+        if categorical_features == "auto":
+            categorical_columns = X.select_dtypes(include=["category"]).columns.tolist()
+            categorical_features_ = [
+                features_.index(c) for c in categorical_columns
+            ] or None
+    elif type_df(X) == "numpy":
+        X_ = X
+        features_ = list(map(str, range(X_.shape[1])))
+    else:
+        raise ValueError(f"Object type {type(X)} is not supported.")
+
+    if (
+        categorical_features
+        and all(isinstance(s, int) for s in categorical_features)
+        and isinstance(categorical_features, list)
+    ):
+        categorical_features_ = categorical_features
+    elif (
+        categorical_features
+        and all(isinstance(s, str) for s in categorical_features)
+        and isinstance(categorical_features, list)
+    ):
+        categorical_features_ = [features_.index(c) for c in categorical_features]
+
+    cat_mapping = {}  # key: feature_name, value: ordered category names
+    cat_to_num = []
+    if categorical_features_:
+        for i in categorical_features_:
+            categories, inversed = np.unique(X_[:, i].astype(str), return_inverse=True)
+
+            categories = list(categories)
+            if "nan" in categories:
+                categories.remove("nan")
+            categories.insert(0, "nan")
+
+            inversed = inversed + 1.0
+
+            if len(categories) > max_cat:
+                cat_to_num.append(i)
+                logger.warning(
+                    f"Feature {features_[i]} will be treated as numerical since the number of categories ({len(categories)}) exceeds max_cat ({max_cat}) threshold."
+                )
+
+            feature_name = features_[i]
+            cat_mapping[feature_name] = categories
+            ind_nan = len(categories)
+            inversed[inversed == ind_nan] = np.nan
+            X_[:, i] = inversed
+
+        categorical_features_ = [
+            x for x in categorical_features_ if x not in cat_to_num
+        ]
+
+        logger.info(f"Categorical features: {categorical_features_}")
+        logger.info(f"Mapping of categories: {cat_mapping}")
+
+    if not np.issubdtype(X_.dtype, "float64"):
+        X_ = X_.astype(dtype="float64", copy=False)
+    flat_data = X_.ravel(order="F")
+    rows, cols = X_.shape
+
+    if isinstance(categorical_features_, list):
+        categorical_features_ = set(categorical_features_)
+
+    return features_, flat_data, rows, cols, categorical_features_, cat_mapping
+
+
+def convert_input_frame_columnar(
+    X, categorical_features, max_cat
+) -> Tuple[
+    List[str],
+    List[np.ndarray],
+    List[Optional[np.ndarray]],
+    int,
+    int,
+    Optional[set],
+    dict,
+]:
+    """Convert Polars DataFrame to columnar format for zero-copy transfer.
+
+    Returns list of column arrays and list of validity masks.
+    """
+    import polars.selectors as cs
+
+    features_ = list(X.columns)
+    rows, cols = X.shape
+
+    # Determine categorical features
+    categorical_features_ = None
+    if categorical_features == "auto":
+        categorical_columns = X.select(cs.categorical()).columns
+        categorical_features_ = [
+            features_.index(c) for c in categorical_columns
+        ] or None
+    elif (
+        categorical_features
+        and all(isinstance(s, int) for s in categorical_features)
+        and isinstance(categorical_features, list)
+    ):
+        categorical_features_ = categorical_features
+    elif (
+        categorical_features
+        and all(isinstance(s, str) for s in categorical_features)
+        and isinstance(categorical_features, list)
+    ):
+        categorical_features_ = [features_.index(c) for c in categorical_features]
+
+    cat_mapping = {}
+    cat_to_num = []
+    categorical_set = set(categorical_features_) if categorical_features_ else set()
+
+    # Convert each column to numpy array
+    columns = []
+    masks = []
+    import pyarrow as pa
+
+    for i, col_name in enumerate(features_):
+        if i in categorical_set:
+            # For categorical columns, we need to encode them
+            # Use Arrow to get codes and categories without forcing numpy object conversion
+            arr = X[col_name].to_arrow()
+            if isinstance(arr, pa.ChunkedArray):
+                arr = arr.combine_chunks()
+
+            if not isinstance(arr, pa.DictionaryArray):
+                arr = arr.dictionary_encode()
+
+            # Extract categories (dictionary)
+            # Arrow dictionary is usually StringArray
+            cats = arr.dictionary.to_pylist()
+
+            # Extract codes (indices)
+            # Cast to float64 for Perpetual
+            indices = arr.indices.to_numpy(zero_copy_only=False)
+            out_values = indices.astype(np.float64)
+            out_values += 1.0  # Shift: 0 in Perpetual is "nan"
+
+            # Handle Nulls (masked values in Arrow)
+            # Set them to NaN
+            if arr.null_count > 0:
+                # Simpler: convert validity bitmap to byte array using numpy unpacking
+                row_count = len(out_values)
+                if arr.buffers()[0]:
+                    valid_bits = np.frombuffer(arr.buffers()[0], dtype=np.uint8)
+                    valid_mask = np.unpackbits(valid_bits, bitorder="little")[
+                        :row_count
+                    ].astype(bool)
+                    # mask is 1 where valid, 0 where null.
+                    # We want to set nulls (0) to NaN.
+                    out_values[~valid_mask] = np.nan
+
+            # Handle "nan" string in categories
+            if "nan" in cats:
+                nan_idx = cats.index("nan")
+                # Indices pointing to this "nan" string should become NaN
+                # Current logic: cats["nan"] is at `nan_idx`.
+                # `out_values` has `nan_idx + 1`.
+                out_values[out_values == (nan_idx + 1.0)] = np.nan
+                cats.remove("nan")
+
+            cats.insert(0, "nan")
+
+            if len(cats) > max_cat:
+                cat_to_num.append(i)
+                logger.warning(
+                    f"Feature {col_name} will be treated as numerical since the number of categories ({len(cats)}) exceeds max_cat ({max_cat}) threshold."
+                )
+
+            cat_mapping[col_name] = cats
+            columns.append(out_values)
+            masks.append(None)  # Categorical encoding handles NaNs
+        else:
+            # For non-categorical columns, use zero-copy via Arrow
+            series = X[col_name]
+            # Use Arrow to get validity bitmap and values zero-copy
+            arr = series.to_arrow()
+            if isinstance(arr, pa.ChunkedArray):
+                if arr.num_chunks > 1:
+                    arr = arr.combine_chunks()
+                else:
+                    arr = arr.chunk(0)
+
+            # Check buffers
+            buffers = arr.buffers()
+            # buffers[0] is validity bitmap
+            # buffers[1] is values
+            if buffers[0] is None:
+                masks.append(None)
+            else:
+                masks.append(np.frombuffer(buffers[0], dtype=np.uint8))
+
+            # values
+            col_array = np.frombuffer(buffers[1], dtype=np.float64)
+            columns.append(col_array)
+
+    if categorical_features_:
+        categorical_features_ = [
+            x for x in categorical_features_ if x not in cat_to_num
+        ]
+        logger.info(f"Categorical features: {categorical_features_}")
+        logger.info(f"Mapping of categories: {cat_mapping}")
+
+    if isinstance(categorical_features_, list):
+        categorical_features_ = set(categorical_features_)
+
+    return features_, columns, masks, rows, cols, categorical_features_, cat_mapping
+
+
+def transform_input_frame(X, cat_mapping) -> Tuple[List[str], np.ndarray, int, int]:
+    """Convert data to format needed by booster.
+
+    Returns:
+        Tuple[List[str], np.ndarray, int, int]: Return column names, the flat data, number of rows, the number of columns
+    """
+    if type_df(X) == "pandas_df":
+        X_ = X.to_numpy()
+        features_ = X.columns.to_list()
+    elif type_df(X) == "numpy":
+        X_ = X
+        features_ = list(map(str, range(X_.shape[1])))
+    else:
+        raise ValueError(f"Object type {type(X)} is not supported.")
+
+    if cat_mapping:
+        for feature_name, categories in cat_mapping.items():
+            feature_index = features_.index(feature_name)
+            cats = categories.copy()
+            cats.remove("nan")
+            x_enc = np.searchsorted(cats, X_[:, feature_index].astype(str))
+            x_enc = x_enc + 1.0
+            ind_nan = len(categories)
+            x_enc[x_enc == ind_nan] = np.nan
+            X_[:, feature_index] = x_enc
+
+    if not np.issubdtype(X_.dtype, "float64"):
+        X_ = X_.astype(dtype="float64", copy=False)
+    flat_data = X_.ravel(order="F")
+    rows, cols = X_.shape
+
+    return features_, flat_data, rows, cols
+
+
+def transform_input_frame_columnar(
+    X, cat_mapping
+) -> Tuple[List[str], List[np.ndarray], List[Optional[np.ndarray]], int, int]:
+    """Convert Polars DataFrame to columnar format for zero-copy prediction.
+
+    Returns list of column arrays and masks instead of flattened data, avoiding copies.
+    """
+    features_ = list(X.columns)
+    rows, cols = X.shape
+
+    columns = []
+    masks = []
+    import pyarrow as pa
+
+    for i, col_name in enumerate(features_):
+        if cat_mapping and col_name in cat_mapping:
+            # For categorical columns, we need to encode them using the existing cat_mapping
+            categories = cat_mapping[col_name]
+
+            # Use Arrow for zero-copy extraction
+            arr = X[col_name].to_arrow()
+            if isinstance(arr, pa.ChunkedArray):
+                arr = arr.combine_chunks()
+            if not isinstance(arr, pa.DictionaryArray):
+                arr = arr.dictionary_encode()
+
+            # Input categories
+            new_cats = arr.dictionary.to_pylist()
+
+            # Extract codes (indices)
+            # We need integers for indexing `lookup`.
+            # If indices has nulls, to_numpy() might return floats.
+            # We fill nulls with 0 to ensure we get integers, then mask result later.
+            filled_indices_arr = arr.indices.fill_null(0)
+            new_indices = filled_indices_arr.to_numpy()
+
+            # Build mapping from new_cats indices to old_cats indices
+            # old_cats = categories. "nan" is at index 0.
+            # We want to map new_cat_idx -> old_cat_idx.
+            # If new_cat is "nan", map to 0?
+            # Perpetual encoding: "nan" -> NaN (in float), Cat1 -> 1.0, Cat2 -> 2.0.
+            # categories list has "nan" at 0.
+            # So "A" is at index 1.
+
+            # We need to map `new_indices` to `out_values`.
+
+            # Create a lookup table (array)
+            # lookup[new_code] = old_float_code
+
+            lookup = np.full(len(new_cats), np.nan, dtype=np.float64)
+
+            # optimization: map strings to indices for old categories
+            old_cat_map = {c: i for i, c in enumerate(categories)}
+            # categories[0] is "nan"
+
+            for i, cat in enumerate(new_cats):
+                if cat in old_cat_map:
+                    idx = old_cat_map[cat]
+                    # If idx is 0 ("nan"), we want result to be np.nan?
+                    # Previous logic: `inversed[inversed == ind_nan] = np.nan`.
+                    # Wait, `inversed` from `searchsorted` was 0-based index into `cats` (without "nan" inside `searchsorted` call?).
+                    # Previous logic:
+                    # `cats.remove("nan")`
+                    # `searchsorted(cats, ...)` -> index into cats (0 to N-1).
+                    # `+ 1.0`. So 1 to N.
+                    # `categories` has "nan" inserted at 0.
+                    # So index 1 corresponds to `categories[1]`.
+                    # Logic holds.
+
+                    if categories[idx] == "nan":
+                        lookup[i] = np.nan
+                    else:
+                        lookup[i] = float(idx)
+                        # Note: categories has "nan" at 0. "A" at 1.
+                        # If `cat` is "A", `idx` is 1. We want 1.0. Correct.
+                else:
+                    # Unknown category -> NaN?
+                    lookup[i] = np.nan
+
+            # Apply lookup
+            # Handle out of bounds indices just in case? Arrow indices should be valid.
+            # `new_indices` are codes into `new_cats`.
+
+            # Check for nulls in `new_indices` (masked)
+            # If null, they map to NaN.
+
+            # `take` style mapping
+            # `lookup` has NaN for unknown/nan cats.
+            x_enc = lookup[new_indices]
+
+            # Handle array-level nulls
+            if arr.null_count > 0:
+                if arr.buffers()[0]:
+                    valid_bits = np.frombuffer(arr.buffers()[0], dtype=np.uint8)
+                    valid_mask = np.unpackbits(valid_bits, bitorder="little")[
+                        : len(x_enc)
+                    ].astype(bool)
+                    x_enc[~valid_mask] = np.nan
+
+            columns.append(x_enc)
+            masks.append(None)
+        else:
+            series = X[col_name]
+            arr = series.to_arrow()
+            if isinstance(arr, pa.ChunkedArray):
+                if arr.num_chunks > 1:
+                    arr = arr.combine_chunks()  # Fallback for chunked
+                else:
+                    arr = arr.chunk(0)
+            buffers = arr.buffers()
+            if buffers[0] is None:
+                masks.append(None)
+            else:
+                masks.append(np.frombuffer(buffers[0], dtype=np.uint8))
+            columns.append(np.frombuffer(buffers[1], dtype=np.float64))
+
+    return features_, columns, masks, rows, cols
+
+
+CONTRIBUTION_METHODS = {
+    "weight": "Weight",
+    "Weight": "Weight",
+    "average": "Average",
+    "Average": "Average",
+    "branch-difference": "BranchDifference",
+    "branchdifference": "BranchDifference",
+    "BranchDifference": "BranchDifference",
+    "midpoint-difference": "MidpointDifference",
+    "midpointdifference": "MidpointDifference",
+    "MidpointDifference": "MidpointDifference",
+    "mode-difference": "ModeDifference",
+    "modedifference": "ModeDifference",
+    "ModeDifference": "ModeDifference",
+    "ProbabilityChange": "ProbabilityChange",
+    "probabilitychange": "ProbabilityChange",
+    "probability-change": "ProbabilityChange",
+}

perpetual-1.1.1.dist-info/METADATA

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: perpetual
+Version: 1.1.1
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: numpy
+Requires-Dist: typing-extensions
+Requires-Dist: pandas ; extra == 'dev'
+Requires-Dist: polars ; extra == 'dev'
+Requires-Dist: pyarrow ; extra == 'dev'
+Requires-Dist: maturin ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: seaborn ; extra == 'dev'
+Requires-Dist: scikit-learn ; extra == 'dev'
+Requires-Dist: mkdocs-material ; extra == 'dev'
+Requires-Dist: mkdocstrings[python] ; extra == 'dev'
+Requires-Dist: mkdocs-autorefs ; extra == 'dev'
+Requires-Dist: ruff ; extra == 'dev'
+Requires-Dist: xgboost ; extra == 'dev'
+Requires-Dist: onnxmltools ; extra == 'dev'
+Requires-Dist: onnx ; extra == 'dev'
+Requires-Dist: onnxruntime ; python_full_version < '3.14' and extra == 'dev'
+Requires-Dist: nbsphinx ; extra == 'dev'
+Requires-Dist: onnxmltools ; extra == 'onnx'
+Requires-Dist: onnx ; extra == 'onnx'
+Requires-Dist: onnxruntime ; extra == 'onnx'
+Requires-Dist: xgboost ; extra == 'xgboost'
+Provides-Extra: dev
+Provides-Extra: onnx
+Provides-Extra: xgboost
+License-File: LICENSE
+Summary: A self-generalizing gradient boosting machine that doesn't need hyperparameter optimization
+Keywords: rust,perpetual,machine learning,tree model,decision tree,gradient boosted decision tree,gradient boosting machine
+Home-Page: https://perpetual-ml.com
+Author-email: Mutlu Simsek <mutlusims3k@gmail.com>, Serkan Korkmaz <serkor1@duck.com>, Pieter Pel <pelpieter@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+<!-- markdownlint-disable MD033 -->
+# Perpetual
+
+<p align="center">
+  <img  height="120" src="https://github.com/perpetual-ml/perpetual/raw/main/resources/perp_logo.png" alt="Perpetual Logo">
+</p>
+
+<div align="center">
+
+<a href="https://pypi.org/project/perpetual" target="_blank"><img src="https://img.shields.io/pypi/pyversions/perpetual.svg?logo=python&logoColor=white" alt="Python Versions"></a>
+<a href="https://pypi.org/project/perpetual" target="_blank"><img src="https://img.shields.io/pypi/v/perpetual.svg?logo=pypi&logoColor=white" alt="PyPI Version"></a>
+<a href="https://crates.io/crates/perpetual" target="_blank"><img src="https://img.shields.io/crates/v/perpetual?logo=rust&logoColor=white" alt="Crates.io Version"></a>
+<a href="https://perpetual-ml.r-universe.dev/perpetual" target="_blank"><img src="https://img.shields.io/badge/dynamic/json?url=https://perpetual-ml.r-universe.dev/api/packages/perpetual&query=$.Version&label=r-universe&logo=R&logoColor=white&color=brightgreen" alt="R-Universe status"></a>
+<a href="https://discord.gg/AyUK7rr6wy" target="_blank"><img src="https://img.shields.io/badge/join-discord-blue?logo=discord" alt="Static Badge"></a>
+![PyPI - Downloads](https://img.shields.io/pypi/dm/perpetual)
+
+</div>
+
+PerpetualBooster is a gradient boosting machine (GBM) that doesn't need hyperparameter optimization unlike other GBMs. Similar to AutoML libraries, it has a `budget` parameter. Increasing the `budget` parameter increases the predictive power of the algorithm and gives better results on unseen data. Start with a small budget (e.g. 0.5) and increase it (e.g. 1.0) once you are confident with your features. If you don't see any improvement with further increasing the `budget`, it means that you are already extracting the most predictive power out of your data.
+
+## Supported Languages
+
+Perpetual is built in Rust and provides high-performance bindings for Python and R.
+
+<!-- markdownlint-disable MD060 -->
+| Language   | Installation                                                            | Documentation                                                                       | Source                                                        | Package                                                                                                                                                             |
+| :--------- | :---------------------------------------------------------------------- | :---------------------------------------------------------------------------------- | :------------------------------------------------------------ | :---------------------------------------------------------------------------------------------------------------------------------- |
+| **Python** | `pip install perpetual`<br><br>`conda install -c conda-forge perpetual` | <a href="https://perpetual-ml.github.io/perpetual" target="_blank">Python API</a>   | <a href="./package-python" target="_blank">`package-python`</a> | <a href="https://pypi.org/project/perpetual" target="_blank">PyPI</a><br><br><a href="https://anaconda.org/conda-forge/perpetual" target="_blank">Conda Forge</a>   |
+| **Rust**   | `cargo add perpetual`                                                   | <a href="https://docs.rs/perpetual" target="_blank">docs.rs</a>                     | <a href="./src" target="_blank">`src`</a>                     | <a href="https://crates.io/crates/perpetual" target="_blank">crates.io</a>                                                          |
+| **R**      | `install.packages("perpetual")`                                         | <a href="https://perpetual-ml.github.io/perpetual/r" target="_blank">pkgdown Site</a> | <a href="./package-r" target="_blank">`package-r`</a>         | <a href="https://perpetual-ml.r-universe.dev/perpetual" target="_blank">R-universe</a>                                              |
+
+### Optional Dependencies
+
+* `pandas`: Enables support for training directly on Pandas DataFrames.
+* `polars`: Enables zero-copy training support for Polars DataFrames.
+* `scikit-learn`: Provides a scikit-learn compatible wrapper interface.
+* `xgboost`: Enables saving and loading models in XGBoost format for interoperability.
+* `onnxruntime`: Enables exporting and loading models in ONNX standard format.
+
+## Usage
+
+You can use the algorithm like in the example below. Check examples folders for both Rust and Python.
+
+```python
+from perpetual import PerpetualBooster
+
+model = PerpetualBooster(objective="SquaredLoss", budget=0.5)
+model.fit(X, y)
+```
+
+## Benchmark
+
+### PerpetualBooster vs. Optuna + LightGBM
+
+Hyperparameter optimization usually takes 100 iterations with plain GBM algorithms. PerpetualBooster achieves the same accuracy in a single run. Thus, it achieves up to 100x speed-up at the same accuracy with different `budget` levels and with different datasets.
+
+The following table summarizes the results for the <a href="https://scikit-learn.org/stable/modules/generated/sklearn.datasets.fetch_california_housing.html" target="_blank">California Housing</a> dataset (regression):
+
+| Perpetual budget | LightGBM n_estimators | Perpetual mse | LightGBM mse | Speed-up wall time | Speed-up cpu time |
+| :--------------- | :-------------------- | :------------ | :----------- | :----------------- | :---------------- |
+| 0.76             | 50                    | 0.201         | 0.201        | 39x                | 57x               |
+| 0.85             | 100                   | 0.196         | 0.196        | 60x                | 87x               |
+| 1.15             | 200                   | 0.190         | 0.190        | 230x               | 259x              |
+
+The following table summarizes the results for the <a href="https://scikit-learn.org/stable/modules/generated/sklearn.datasets.fetch_covtype.html" target="_blank">Cover Types</a> dataset (classification):
+
+| Perpetual budget | LightGBM n_estimators | Perpetual ROC AUC  | LightGBM ROC AUC  | Speed-up wall time | Speed-up cpu time |
+| :--------------- | :-------------------- | :----------------- | :---------------- | :----------------- | :---------------- |
+| 1.0              | 100                   | 0.944              | 0.945             | 39x                | 130x              |
+
+The results can be reproduced using the scripts in the <a href="./package-python/examples" target="_blank">examples</a> folder.
+
+### PerpetualBooster vs. AutoGluon
+
+PerpetualBooster is a GBM but behaves like AutoML so it is benchmarked also against AutoGluon (v1.2, best quality preset), the current leader in <a href="https://automlbenchmark.streamlit.app/cd_diagram" target="_blank">AutoML benchmark</a>. Top 10 datasets with the most number of rows are selected from <a href="https://www.openml.org/" target="_blank">OpenML datasets</a> for both regression and classification tasks.
+
+The results are summarized in the following table for regression tasks:
+
+| OpenML Task                                                                         | Perpetual Training Duration | Perpetual Inference Duration | Perpetual RMSE      | AutoGluon Training Duration | AutoGluon Inference Duration | AutoGluon RMSE     |
+| :---------------------------------------------------------------------------------- | :-------------------------- | :--------------------------- | :------------------ | :-------------------------- | :--------------------------- | :----------------- |
+| <a href="https://www.openml.org/t/359929" target="_blank">Airlines_DepDelay_10M</a> | 518                         | 11.3                         | 29.0                | 520                         | 30.9                         | <ins> 28.8 </ins>  |
+| <a href="https://www.openml.org/t/361940" target="_blank">bates_regr_100</a>        | 3421                        | 15.1                         | <ins> 1.084 </ins>  | OOM                         | OOM                          | OOM                |
+| <a href="https://www.openml.org/t/7327" target="_blank">BNG(libras_move)</a>        | 1956                        | 4.2                          | <ins> 2.51 </ins>   | 1922                        | 97.6                         | 2.53               |
+| <a href="https://www.openml.org/t/7326" target="_blank">BNG(satellite_image)</a>    | 334                         | 1.6                          | 0.731               | 337                         | 10.0                         | <ins> 0.721 </ins> |
+| <a href="https://www.openml.org/t/14949" target="_blank">COMET_MC</a>               | 44                          | 1.0                          | <ins> 0.0615 </ins> | 47                          | 5.0                          | 0.0662             |
+| <a href="https://www.openml.org/t/361939" target="_blank">friedman1</a>             | 275                         | 4.2                          | <ins> 1.047 </ins>  | 278                         | 5.1                          | 1.487              |
+| <a href="https://www.openml.org/t/10102" target="_blank">poker</a>                  | 38                          | 0.6                          | <ins> 0.256 </ins>  | 41                          | 1.2                          | 0.722              |
+| <a href="https://www.openml.org/t/361955" target="_blank">subset_higgs</a>          | 868                         | 10.6                         | <ins> 0.420 </ins>  | 870                         | 24.5                         | 0.421              |
+| <a href="https://www.openml.org/t/7319" target="_blank">BNG(autoHorse)</a>          | 107                         | 1.1                          | <ins> 19.0 </ins>   | 107                         | 3.2                          | 20.5               |
+| <a href="https://www.openml.org/t/7318" target="_blank">BNG(pbc)</a>                | 48                          | 0.6                          | <ins> 836.5 </ins>  | 51                          | 0.2                          | 957.1              |
+| average                                                                             | 465                         | 3.9                          | -                   | 464                         | 19.7                         | -                  |
+
+PerpetualBooster outperformed AutoGluon on 8 out of 10 regression tasks, training equally fast and inferring 5.1x faster.
+
+The results are summarized in the following table for classification tasks:
+
+| OpenML Task                                                                        | Perpetual Training Duration | Perpetual Inference Duration | Perpetual AUC      | AutoGluon Training Duration | AutoGluon Inference Duration | AutoGluon AUC |
+| :--------------------------------------------------------------------------------- | :-------------------------- | :--------------------------- | :----------------- | :-------------------------- | :--------------------------- | :------------ |
+| <a href="https://www.openml.org/t/146163" target="_blank">BNG(spambase)</a>        | 70.1                        | 2.1                          | <ins> 0.671 </ins> | 73.1                        | 3.7                          | 0.669         |
+| <a href="https://www.openml.org/t/208" target="_blank">BNG(trains)</a>             | 89.5                        | 1.7                          | <ins> 0.996 </ins> | 106.4                       | 2.4                          | 0.994         |
+| <a href="https://www.openml.org/t/361942" target="_blank">breast</a>               | 13699.3                     | 97.7                         | <ins> 0.991 </ins> | 13330.7                     | 79.7                         | 0.949         |
+| <a href="https://www.openml.org/t/7291" target="_blank">Click_prediction_small</a> | 89.1                        | 1.0                          | <ins> 0.749 </ins> | 101.0                       | 2.8                          | 0.703         |
+| <a href="https://www.openml.org/t/361938" target="_blank">colon</a>                | 12435.2                     | 126.7                        | <ins> 0.997 </ins> | 12356.2                     | 152.3                        | 0.997         |
+| <a href="https://www.openml.org/t/362113" target="_blank">Higgs</a>                | 3485.3                      | 40.9                         | <ins> 0.843 </ins> | 3501.4                      | 67.9                         | 0.816         |
+| <a href="https://www.openml.org/t/230" target="_blank">SEA(50000)</a>              | 21.9                        | 0.2                          | <ins> 0.936 </ins> | 25.6                        | 0.5                          | 0.935         |
+| <a href="https://www.openml.org/t/359994" target="_blank">sf-police-incidents</a>  | 85.8                        | 1.5                          | <ins> 0.687 </ins> | 99.4                        | 2.8                          | 0.659         |
+| <a href="https://www.openml.org/t/361941" target="_blank">bates_classif_100</a>    | 11152.8                     | 50.0                         | <ins> 0.864 </ins> | OOM                         | OOM                          | OOM           |
+| <a href="https://www.openml.org/t/361945" target="_blank">prostate</a>             | 13699.9                     | 79.8                         | <ins> 0.987 </ins> | OOM                         | OOM                          | OOM           |
+| average                                                                            | 3747.0                      | 34.0                         | -                  | 3699.2                      | 39.0                         | -             |
+
+PerpetualBooster outperformed AutoGluon on 10 out of 10 classification tasks, training equally fast and inferring 1.1x faster.
+
+PerpetualBooster demonstrates greater robustness compared to AutoGluon, successfully training on all 20 tasks, whereas AutoGluon encountered out-of-memory errors on 3 of those tasks.
+
+The results can be reproduced using the <a href="https://github.com/deadsoul44/automlbenchmark" target="_blank">automlbenchmark fork</a>.
+
+## Contribution
+
+Contributions are welcome. Check <a href="./CONTRIBUTING.md" target="_blank">CONTRIBUTING.md</a> for the guideline.
+
+## Paper
+
+PerpetualBooster prevents overfitting with a generalization algorithm. The paper is work-in-progress to explain how the algorithm works. Check our <a href="https://perpetual-ml.com/blog/how-perpetual-works" target="_blank">blog post</a> for a high level introduction to the algorithm.
+
+## Perpetual ML Suite
+
+The **Perpetual ML Suite** is a comprehensive, batteries-included ML platform designed to deliver maximum predictive power with minimal effort. It allows you to track experiments, monitor metrics, and manage model drift through an intuitive interface.
+
+For a fully managed, **serverless ML experience**, visit <a href="https://app.perpetual-ml.com" target="_blank">app.perpetual-ml.com</a>.
+
+* **Serverless Marimo Notebooks**: Run interactive, reactive notebooks without managing any infrastructure.
+* **Serverless ML Endpoints**: One-click deployment of models as production-ready endpoints for real-time inference.
+
+Perpetual is also designed to live where your data lives. It is available as a native application on the <a href="https://app.snowflake.com/marketplace/listing/GZSYZX0EMJ/perpetual-ml-perpetual-ml-suite" target="_blank">Snowflake Marketplace</a>, with support for Databricks and other major data warehouses coming soon.
+

perpetual-1.1.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+perpetual/__init__.py,sha256=TVNxt-DXYxEb1BfC6vY5xfH4kSSgPJdhOL84Z35GifQ,285
+perpetual/booster.py,sha256=lhXoBq7tMwd9Upa7WMdnjr0FRRcMaqPWxLbmcJLfK6U,73005
+perpetual/data.py,sha256=e2xF5xVq3KYotj5fpIhSfnF3B4qLQpdHYDSaP5NpcxA,768
+perpetual/perpetual.cpython-312-darwin.so,sha256=SuCSELp5j9m3QikyZWgxhBWR1De7nA5Kmqi4bpUZn4c,1463904
+perpetual/serialize.py,sha256=Tg2BbuA1jKQ5-ITuVhwtj6hgBaRAbZ66eHctR7fcVk4,1883
+perpetual/sklearn.py,sha256=kYDDy0ODW6ZYZEKBTLDpy_cVsCae6cZ3ARYZj01gjj4,17122
+perpetual/types.py,sha256=T0KJu8bK8xiYHaPt8b6RmUR1xP3f5N1FV7qaZTy1rtM,3232
+perpetual/utils.py,sha256=j3iuvJcSf6sYp1D5ATW4QAyjyOou6MkY4biNrU8TzRg,16903
+perpetual-1.1.1.dist-info/METADATA,sha256=698cRCoIrH429APmhvPl00LVTfCRnmd7f8Kx03otnIs,17304
+perpetual-1.1.1.dist-info/WHEEL,sha256=5PbULt6DKUkIiubOjwQPyn-vzBuHJr28QRlczaBjcdg,107
+perpetual-1.1.1.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+perpetual-1.1.1.dist-info/RECORD,,

perpetual-1.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp312-cp312-macosx_10_12_x86_64