perpetual 0.9.1__cp39-cp39-win_amd64.whl

perpetual/data.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from typing import Iterable, Optional, Union
+
+
+@dataclass
+class Node:
+    """Dataclass representation of a node, this represents all of the fields present in a tree node."""
+
+    num: int
+    weight_value: float
+    hessian_sum: float
+    depth: int
+    split_value: float
+    split_feature: Union[str, int]
+    split_gain: float
+    missing_node: int
+    left_child: int
+    right_child: int
+    is_leaf: bool
+    node_type: str
+    parent_node: int
+    generalization: Optional[float]
+    left_cats: Optional[Iterable]
+    right_cats: Optional[Iterable]
+    count: int

perpetual/serialize.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import json
+from abc import ABC, abstractmethod
+from ast import literal_eval
+from dataclasses import dataclass
+from typing import Dict, Generic, List, Tuple, TypeVar, Union
+
+import numpy as np
+import numpy.typing as npt
+
+T = TypeVar("T")
+
+
+class BaseSerializer(ABC, Generic[T]):
+    @abstractmethod
+    def serialize(self, obj: T) -> str:
+        """serialize method - should take an object and return a string"""
+
+    @abstractmethod
+    def deserialize(self, obj_repr: str) -> T:
+        """deserialize method - should take a string and return original object"""
+
+
+Scaler = Union[int, float, str]
+
+
+class ScalerSerializer(BaseSerializer[Scaler]):
+    def serialize(self, obj: Scaler) -> str:
+        if isinstance(obj, str):
+            obj_ = f"'{obj}'"
+        else:
+            obj_ = str(obj)
+        return obj_
+
+    def deserialize(self, obj_repr: str) -> Scaler:
+        return literal_eval(node_or_string=obj_repr)
+
+
+ObjectItem = Union[
+    List[Scaler],
+    Dict[str, Scaler],
+    Scaler,
+]
+
+
+class ObjectSerializer(BaseSerializer[ObjectItem]):
+    def serialize(self, obj: ObjectItem) -> str:
+        return json.dumps(obj)
+
+    def deserialize(self, obj_repr: str) -> ObjectItem:
+        return json.loads(obj_repr)
+
+
+@dataclass
+class NumpyData:
+    array: Union[List[float], List[int]]
+    dtype: str
+    shape: Tuple[int, ...]
+
+
+class NumpySerializer(BaseSerializer[npt.NDArray]):
+    def serialize(self, obj: npt.NDArray) -> str:
+        return json.dumps(
+            {"array": obj.tolist(), "dtype": str(obj.dtype), "shape": obj.shape}
+        )
+
+    def deserialize(self, obj_repr: str) -> npt.NDArray:
+        data = NumpyData(**json.loads(obj_repr))
+        a = np.array(data.array, dtype=data.dtype)  # type: ignore
+        if len(data.shape) == 1:
+            return a
+        else:
+            return a.reshape(data.shape)

perpetual/types.py

@@ -0,0 +1,150 @@
+import numpy as np
+from typing_extensions import Self
+from typing import Any, Dict, Iterable, Protocol, Set
+
+
+class BoosterType(Protocol):
+    monotone_constraints: Dict[int, int]
+    terminate_missing_features: Set[int]
+    number_of_trees: int
+    base_score: float
+
+    def fit(
+        self,
+        flat_data: np.ndarray,
+        rows: int,
+        cols: int,
+        y: np.ndarray,
+        budget: float,
+        sample_weight: np.ndarray,
+        parallel: bool = False,
+    ):
+        """Fit method"""
+
+    def predict(
+        self,
+        flat_data: np.ndarray,
+        rows: int,
+        cols: int,
+        parallel: bool = True,
+    ) -> np.ndarray:
+        """predict method"""
+
+    def predict_proba(
+        self,
+        flat_data: np.ndarray,
+        rows: int,
+        cols: int,
+        parallel: bool = True,
+    ) -> np.ndarray:
+        """predict probabilities method"""
+
+    def predict_contributions(
+        self,
+        flat_data: np.ndarray,
+        rows: int,
+        cols: int,
+        method: str,
+        parallel: bool = True,
+    ) -> np.ndarray:
+        """method"""
+
+    def value_partial_dependence(
+        self,
+        feature: int,
+        value: float,
+    ) -> float:
+        """pass"""
+
+    def calculate_feature_importance(
+        self,
+        method: str,
+        normalize: bool,
+    ) -> Dict[int, float]:
+        """pass"""
+
+    def text_dump(self) -> Iterable[str]:
+        """pass"""
+
+    @classmethod
+    def load_booster(cls, path: str) -> Self:
+        """pass"""
+
+    def save_booster(self, path: str):
+        """pass"""
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """pass"""
+
+    def json_dump(self) -> str:
+        """pass"""
+
+    def get_params(self) -> Dict[str, Any]:
+        """pass"""
+
+    def insert_metadata(self, key: str, value: str) -> None:
+        """pass"""
+
+    def get_metadata(self, key: str) -> str:
+        """pass"""
+
+
+class MultiOutputBoosterType(Protocol):
+    monotone_constraints: Dict[int, int]
+    terminate_missing_features: Set[int]
+    number_of_trees: Iterable[int]
+    base_score: Iterable[float]
+
+    def fit(
+        self,
+        flat_data: np.ndarray,
+        rows: int,
+        cols: int,
+        y: np.ndarray,
+        budget: float,
+        sample_weight: np.ndarray,
+        parallel: bool = False,
+    ):
+        """Fit method"""
+
+    def predict(
+        self,
+        flat_data: np.ndarray,
+        rows: int,
+        cols: int,
+        parallel: bool = True,
+    ) -> np.ndarray:
+        """predict method"""
+
+    def predict_proba(
+        self,
+        flat_data: np.ndarray,
+        rows: int,
+        cols: int,
+        parallel: bool = True,
+    ) -> np.ndarray:
+        """predict probabilities method"""
+
+    @classmethod
+    def load_booster(cls, path: str) -> Self:
+        """pass"""
+
+    def save_booster(self, path: str):
+        """pass"""
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """pass"""
+
+    def json_dump(self) -> str:
+        """pass"""
+
+    def get_params(self) -> Dict[str, Any]:
+        """pass"""
+
+    def insert_metadata(self, key: str, value: str) -> None:
+        """pass"""
+
+    def get_metadata(self, key: str) -> str:
+        """pass"""

perpetual/utils.py

@@ -0,0 +1,217 @@
+import logging
+import numpy as np
+from typing import Dict, Iterable, List, Optional, Tuple
+
+
+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) -> 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 objective == "LogLoss" and len(x_.shape) == 1:
+        classes_ = np.unique(x_)
+        x_index = np.array([np.where(classes_ == i) for i in x_])
+        if len(classes_) > 2:
+            x_ = np.squeeze(np.eye(len(classes_))[x_index])
+
+    if 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) == "polars_df":
+        import polars.selectors as cs
+
+        try:
+            X_ = X.to_numpy(allow_copy=False)
+        except RuntimeError:
+            X_ = X.to_numpy(allow_copy=True)
+
+        features_ = X.columns
+        if categorical_features == "auto":
+            categorical_columns = X.select(cs.categorical()).columns
+            categorical_features_ = [
+                features_.index(c) for c in categorical_columns
+            ] or None
+    else:
+        # Assume it's a numpy array.
+        X_ = X
+        features_ = list(map(str, range(X_.shape[1])))
+
+    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 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) == "polars_df":
+        try:
+            X_ = X.to_numpy(allow_copy=False)
+        except RuntimeError:
+            X_ = X.to_numpy(allow_copy=True)
+        features_ = X.columns
+    else:
+        # Assume it's a numpy array.
+        X_ = X
+        features_ = list(map(str, range(X_.shape[1])))
+
+    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
+
+
+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-0.9.1.dist-info/METADATA

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: perpetual
+Version: 0.9.1
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: numpy
+Requires-Dist: typing-extensions
+Requires-Dist: black ; extra == 'dev'
+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'
+Provides-Extra: dev
+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: Mutlu Simsek
+Author-email: Mutlu Simsek <msimsek@perpetual-ml.com>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Source Code, https://github.com/perpetual-ml/perpetual
+
+<p align="center">
+  <img  height="120" src="https://github.com/perpetual-ml/perpetual/raw/main/resources/perp_logo.png">
+</p>
+
+<div align="center">
+
+[![Python Versions](https://img.shields.io/pypi/pyversions/perpetual.svg?logo=python&logoColor=white)](https://pypi.org/project/perpetual)
+[![PyPI Version](https://img.shields.io/pypi/v/perpetual.svg?logo=pypi&logoColor=white)](https://pypi.org/project/perpetual)
+[![Crates.io Version](https://img.shields.io/crates/v/perpetual?logo=rust&logoColor=white)](https://crates.io/crates/perpetual)
+[![Static Badge](https://img.shields.io/badge/join-discord-blue?logo=discord)](https://discord.gg/AyUK7rr6wy)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/perpetual)
+
+</div>
+
+# Perpetual
+
+PerpetualBooster is a gradient boosting machine (GBM) algorithm that doesn't need hyperparameter optimization unlike other GBM algorithms. 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.
+
+## 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)
+```
+
+## Documentation
+
+Documentation for the Python API can be found [here](https://perpetual-ml.github.io/perpetual) and for the Rust API [here](https://docs.rs/perpetual/latest/perpetual/).
+
+
+## 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 [California Housing](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.fetch_california_housing.html) dataset (regression):
+
+| Perpetual budget | LightGBM n_estimators | Perpetual mse | LightGBM mse | Speed-up wall time | Speed-up cpu time |
+| ---------------- | --------------------- | ------------- | ------------ | ------------------ | ----------------- |
+| 1.0              | 100                   | 0.192         | 0.192        | 54x                | 56x               |
+| 1.5              | 300                   | 0.188         | 0.188        | 59x                | 58x               |
+| 2.1              | 1000                  | 0.185         | 0.186        | 42x                | 41x               |
+
+The following table summarizes the results for the [Cover Types](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.fetch_covtype.html) dataset (classification):
+
+| Perpetual budget | LightGBM n_estimators | Perpetual log loss | LightGBM log loss | Speed-up wall time | Speed-up cpu time |
+| ---------------- | --------------------- | ------------------ | ----------------- | ------------------ | ----------------- |
+| 0.9              | 100                   | 0.091              | 0.084             | 72x                | 78x               |
+
+The results can be reproduced using the scripts in the [examples](./python-package/examples) 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 [AutoML benchmark](https://automlbenchmark.streamlit.app/cd_diagram). Top 10 datasets with the most number of rows are selected from [OpenML datasets](https://www.openml.org/) 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 |
+| -------------------------------------------------------- | ----- | ----- | ------------------- | -------- | ------ | ------------------ |
+| [Airlines_DepDelay_10M](https://www.openml.org/t/359929) | 518   | 11.3  | 29.0                | 520      | 30.9   | <ins> 28.8 </ins>  |
+| [bates_regr_100](https://www.openml.org/t/361940)        | 3421  | 15.1  | <ins> 1.084 </ins>  | OOM      | OOM    | OOM                |
+| [BNG(libras_move)](https://www.openml.org/t/7327)        | 1956  | 4.2   | <ins> 2.51 </ins>   | 1922     | 97.6   | 2.53               |
+| [BNG(satellite_image)](https://www.openml.org/t/7326)    | 334   | 1.6   | 0.731               | 337      | 10.0   | <ins> 0.721 </ins> |
+| [COMET_MC](https://www.openml.org/t/14949)               | 44    | 1.0   | <ins> 0.0615 </ins> | 47       | 5.0    | 0.0662             |
+| [friedman1](https://www.openml.org/t/361939)             | 275   | 4.2   | <ins> 1.047 </ins>  | 278      | 5.1    | 1.487              |
+| [poker](https://www.openml.org/t/10102)                  | 38    | 0.6   | <ins> 0.256 </ins>  | 41       | 1.2    | 0.722              |
+| [subset_higgs](https://www.openml.org/t/361955)          | 868   | 10.6  | <ins> 0.420 </ins>  | 870      | 24.5   | 0.421              |
+| [BNG(autoHorse)](https://www.openml.org/t/7319)          | 107   | 1.1   | <ins> 19.0 </ins>   | 107      | 3.2    | 20.5               |
+| [BNG(pbc)](https://www.openml.org/t/7318)                | 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 |
+| -------------------------------------------------------- | ------- | ------ | ------------------- | -------- | ------ | ------------------ |
+| [BNG(spambase)](https://www.openml.org/t/146163)         | 70.1    | 2.1   | <ins> 0.671 </ins> | 73.1     | 3.7    | 0.669              |
+| [BNG(trains)](https://www.openml.org/t/208)              | 89.5    | 1.7   | <ins> 0.996 </ins> | 106.4    | 2.4    | 0.994              |
+| [breast](https://www.openml.org/t/361942)                | 13699.3 | 97.7  | <ins> 0.991 </ins> | 13330.7  | 79.7   | 0.949              |
+| [Click_prediction_small](https://www.openml.org/t/7291)  | 89.1    | 1.0   | <ins> 0.749 </ins> | 101.0    | 2.8    | 0.703              |
+| [colon](https://www.openml.org/t/361938)                 | 12435.2 | 126.7 | <ins> 0.997 </ins> | 12356.2  | 152.3  | 0.997              |
+| [Higgs](https://www.openml.org/t/362113)                 | 3485.3  | 40.9  | <ins> 0.843 </ins> | 3501.4   | 67.9   | 0.816              |
+| [SEA(50000)](https://www.openml.org/t/230)               | 21.9    | 0.2   | <ins> 0.936 </ins> | 25.6     | 0.5    | 0.935              |
+| [sf-police-incidents](https://www.openml.org/t/359994)   | 85.8    | 1.5   | <ins> 0.687 </ins> | 99.4     | 2.8    | 0.659              |
+| [bates_classif_100](https://www.openml.org/t/361941)     | 11152.8 | 50.0  | <ins> 0.864 </ins> | OOM      | OOM    | OOM                |
+| [prostate](https://www.openml.org/t/361945)              | 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 automlbenchmark fork [here](https://github.com/deadsoul44/automlbenchmark).
+
+
+
+## Installation
+
+The package can be installed directly from [pypi](https://pypi.org/project/perpetual):
+
+```shell
+pip install perpetual
+```
+
+Using [conda-forge](https://anaconda.org/conda-forge/perpetual):
+
+```shell
+conda install conda-forge::perpetual
+```
+
+To use in a Rust project and to get the package from [crates.io](https://crates.io/crates/perpetual):
+
+```shell
+cargo add perpetual
+```
+
+## Contribution
+
+Contributions are welcome. Check CONTRIBUTING.md 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 [blog post](https://perpetual-ml.com/blog/how-perpetual-works) for a high level introduction to the algorithm.
+

perpetual-0.9.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+perpetual-0.9.1.dist-info/METADATA,sha256=CVBQY3JrR_yM4_gNV4rmUmwlC2TLdZRUZZ5DR0uQV3g,10722
+perpetual-0.9.1.dist-info/WHEEL,sha256=mDFV3bKFgwlxLHvOsPqpR9up9dUKYzsUQNKBdkW5c08,94
+perpetual-0.9.1.dist-info/licenses/LICENSE,sha256=gcuuhKKc5-dwvyvHsXjlC9oM6N5gZ6umYbC8ewW1Yvg,35821
+perpetual/booster.py,sha256=QvKEz-tZmhrRwh39quy1WNbeBF7IWtitquW_8Q8LkII,50750
+perpetual/data.py,sha256=vhjWEc_ESYWoaczz0GkUPtfS0iRSKdVZSrCkQn8yLPw,630
+perpetual/serialize.py,sha256=FeW4JsUFVsrft9N7gz-ebn5mXvDv4LiJC2sgBEeGxYo,1957
+perpetual/types.py,sha256=idZNsDErNTur_rJ_5Co8Pb6fik-AUn9lkrXmjbQJVX0,3381
+perpetual/utils.py,sha256=nqwO6GFHi7I5iltuvgLT3NFaPm1h9cHlnomjFcdSfHY,7455
+perpetual/__init__.py,sha256=V0RhghaG0CuKxKrzYUBYqrf7Drb-gjmznsbz9KT12lk,122
+perpetual/perpetual.cp39-win_amd64.pyd,sha256=xA-4ubUas4061qgWqCdZTUcV8E56O4h4tz6Ag7UnrYo,1698304
+perpetual-0.9.1.dist-info/RECORD,,

perpetual-0.9.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.8.3)
+Root-Is-Purelib: false
+Tag: cp39-cp39-win_amd64