warpgbm 0.1.26__tar.gz → 1.0.0__tar.gz

{warpgbm-0.1.26/warpgbm.egg-info → warpgbm-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: warpgbm
-Version: 0.1.26
+Version: 1.0.0
 Summary: A fast GPU-accelerated Gradient Boosted Decision Tree library with PyTorch + CUDA
 License:                     GNU GENERAL PUBLIC LICENSE
                                Version 3, 29 June 2007
@@ -686,21 +686,46 @@ Requires-Dist: tqdm
 Requires-Dist: scikit-learn
 Dynamic: license-file
 
-![warpgbm](https://github.com/user-attachments/assets/dee9de16-091b-49c1-a8fa-2b4ab6891184)
-
+![raw](https://github.com/user-attachments/assets/924844ef-2536-4bde-a330-5e30f6b0762c)
 
 # WarpGBM
 
 WarpGBM is a high-performance, GPU-accelerated Gradient Boosted Decision Tree (GBDT) library built with PyTorch and CUDA. It offers blazing-fast histogram-based training and efficient prediction, with compatibility for research and production workflows.
 
+**New in v1.0.0:** WarpGBM introduces *Invariant Gradient Boosting* — a powerful approach to learning signals that remain stable across shifting environments (e.g., time, regimes, or datasets). Powered by a novel algorithm called **[Directional Era-Splitting (DES)](https://arxiv.org/abs/2309.14496)**, WarpGBM doesn't just train faster than other leading GBDT libraries — it trains smarter.
+
+If your data evolves over time, WarpGBM is the only GBDT library designed to *adapt and generalize*.
 ---
 
+## Contents
+
+- [Features](#features)
+- [Benchmarks](#benchmarks)
+- [Installation](#installation)
+- [Learning Invariant Signals Across Environments](#learning-invariant-signals-across-environments)
+  - [Why This Matters](#why-this-matters)
+  - [Visual Intuition](#visual-intuition)
+  - [Key References](#key-references)
+- [Examples](#examples)
+  - [Quick Comparison with LightGBM CPU version](#quick-comparison-with-lightgbm-cpu-version)
+  - [Pre-binned Data Example (Numerai)](#pre-binned-data-example-numerai)
+- [Documentation](#documentation)
+- [Acknowledgements](#acknowledgements)
+- [Version Notes](#version-notes)
+
+
 ## Features
 
-- GPU-accelerated training and histogram construction using custom CUDA kernels
-- Drop-in scikit-learn style interface
-- Supports pre-binned data or automatic quantile binning
-- Simple install with `pip`
+- **Blazing-fast GPU training** with custom CUDA kernels for binning, histogram building, split finding, and prediction
+- **Invariant signal learning** via [Directional Era-Splitting (DES)](https://arxiv.org/abs/2309.14496) — designed for datasets with shifting environments (e.g., time, regimes, experimental settings)
+- Drop-in **scikit-learn style interface** for easy adoption
+- Supports **pre-binned data** or **automatic quantile binning**
+- Works with `float32` or `int8` inputs
+- Built-in **validation and early stopping** support with MSE, RMSLE, or correlation metrics
+- Simple install with `pip`, no custom drivers required
+
+> 💡 **Note:** WarpGBM v1.0.0 is a *generalization* of the traditional GBDT algorithm.
+> To run standard GBM training at maximum speed, simply omit the `era_id` argument — WarpGBM will behave like a traditional booster but with industry-leading performance.
 
 ---
 
@@ -762,7 +787,62 @@ Before either method, make sure you’ve installed PyTorch with GPU support:\
 
 ---
 
-## Example
+## Learning Invariant Signals Across Environments
+
+Most supervised learning models rely on an assumption known as the **Empirical Risk Minimization (ERM)** principle. Under ERM, the data distribution connecting inputs \( X \) and targets \( Y \) is assumed to be **fixed** and **stationary** across training, validation, and test splits. That is:
+
+> The patterns you learn from the training set are expected to generalize out-of-sample — *as long as the test data follows the same distribution as the training data.*
+
+However, this assumption is often violated in real-world settings. Data frequently shifts across time, geography, experimental conditions, or other hidden factors. This phenomenon is known as **distribution shift**, and it leads to models that perform well in-sample but fail catastrophically out-of-sample.
+
+This challenge motivates the field of **Out-of-Distribution (OOD) Generalization**, which assumes your data is drawn from **distinct environments or eras** — e.g., time periods, customer segments, experimental trials. Some signals may appear predictive within specific environments but vanish or reverse in others. These are called **spurious signals**. On the other hand, signals that remain consistently predictive across all environments are called **invariant signals**.
+
+WarpGBM v1.0.0 introduces **Directional Era-Splitting (DES)**, a new algorithm designed to identify and learn from invariant signals — ignoring signals that fail to generalize across environments.
+
+---
+
+### Why This Matters
+
+- Standard models trained via ERM can learn to exploit **spurious correlations** that only hold in some parts of the data.
+- DES explicitly tests whether a feature's split is **directionally consistent** across all eras — only such *invariant splits* are kept.
+- This approach has been shown to reduce overfitting and improve out-of-sample generalization, particularly in financial and scientific datasets.
+
+---
+
+### Visual Intuition
+
+We contrast two views of the data:
+
+- **ERM Setting**: All data is assumed to come from the same source (single distribution).\
+  No awareness of environments — spurious signals can dominate.
+
+- **OOD Setting (Era-Splitting)**: Data is explicitly grouped by environment (era).\
+  The model checks whether a signal holds across all groups — enforcing **robustness**.
+
+*📷 [Placeholder for future visual illustration]*
+
+
+---
+
+### Key References
+
+- **Invariant Risk Minimization (IRM)**: [Arjovsky et al., 2019](https://arxiv.org/abs/1907.02893)
+- **Learning Explanations That Are Hard to Vary**: [Parascandolo et al., 2020](https://arxiv.org/abs/2009.00329)
+- **Era Splitting: Invariant Learning for Decision Trees**: [DeLise, 2023](https://arxiv.org/abs/2309.14496)
+
+---
+
+WarpGBM is the **first open-source GBDT framework to integrate this OOD-aware approach natively**, using efficient CUDA kernels to evaluate per-era consistency during tree growth. It’s not just faster — it’s smarter.
+
+---
+
+## Examples
+
+WarpGBM is easy to drop into any supervised learning workflow and comes with curated examples in the `examples/` folder.
+
+ - `Spiral Data.ipynb`: synthetic OOD benchmark from Learning Explanations That Are Hard to Vary
+
+### Quick Comparison with LightGBM CPU version
 
 ```python
 import numpy as np
@@ -804,7 +884,7 @@ WarpGBM:     corr = 0.8621, time = 5.40s
 
 ---
 
-## Pre-binned Data Example (Numerai)
+### Pre-binned Data Example (Numerai)
 
 WarpGBM can save additional training time if your dataset is already pre-binned. The Numerai tournament data is a great example:
 
@@ -854,16 +934,6 @@ WarpGBM:     corr = 0.0660, time = 49.16s
 
 ---
 
-### Run it live in Colab
-
-You can try WarpGBM in a live Colab notebook using real pre-binned Numerai tournament data:
-
-[Open in Colab](https://colab.research.google.com/drive/10mKSjs9UvmMgM5_lOXAylq5LUQAnNSi7?usp=sharing)
-
-No installation required — just press **"Open in Playground"**, then **Run All**!
-
----
-
 ## Documentation
 
 ### `WarpGBM` Parameters:
@@ -889,7 +959,7 @@ No installation required — just press **"Open in Playground"**, then **Run All
    y_eval=None,                   # numpy array (float or int) 1 dimension (eval_num_samples)
    eval_every_n_trees=None,       # const (int) >= 1 
    early_stopping_rounds=None,    # const (int) >= 1
-   eval_metric='mse'              # string, one of 'mse' or 'corr'. For corr, loss is 1 - correlation(y_true, preds)
+   eval_metric='mse'              # string, one of 'mse', 'rmsle' or 'corr'. For corr, loss is 1 - correlation(y_true, preds)
 )
 ```
 Train with optional validation set and early stopping.
@@ -927,3 +997,7 @@ WarpGBM builds on the shoulders of PyTorch, scikit-learn, LightGBM, and the CUDA
 ### v0.1.26
 
 - Fix Memory bugs in prediction and colsample bytree logic. Added "corr" eval metric. 
+
+### v1.0.0
+
+- Introduce invariant learning via directional era splitting (DES). Also streamline VRAM improvements over previous sub versions.

{warpgbm-0.1.26 → warpgbm-1.0.0}/README.md

@@ -1,18 +1,43 @@
-![warpgbm](https://github.com/user-attachments/assets/dee9de16-091b-49c1-a8fa-2b4ab6891184)
-
+![raw](https://github.com/user-attachments/assets/924844ef-2536-4bde-a330-5e30f6b0762c)
 
 # WarpGBM
 
 WarpGBM is a high-performance, GPU-accelerated Gradient Boosted Decision Tree (GBDT) library built with PyTorch and CUDA. It offers blazing-fast histogram-based training and efficient prediction, with compatibility for research and production workflows.
 
+**New in v1.0.0:** WarpGBM introduces *Invariant Gradient Boosting* — a powerful approach to learning signals that remain stable across shifting environments (e.g., time, regimes, or datasets). Powered by a novel algorithm called **[Directional Era-Splitting (DES)](https://arxiv.org/abs/2309.14496)**, WarpGBM doesn't just train faster than other leading GBDT libraries — it trains smarter.
+
+If your data evolves over time, WarpGBM is the only GBDT library designed to *adapt and generalize*.
 ---
 
+## Contents
+
+- [Features](#features)
+- [Benchmarks](#benchmarks)
+- [Installation](#installation)
+- [Learning Invariant Signals Across Environments](#learning-invariant-signals-across-environments)
+  - [Why This Matters](#why-this-matters)
+  - [Visual Intuition](#visual-intuition)
+  - [Key References](#key-references)
+- [Examples](#examples)
+  - [Quick Comparison with LightGBM CPU version](#quick-comparison-with-lightgbm-cpu-version)
+  - [Pre-binned Data Example (Numerai)](#pre-binned-data-example-numerai)
+- [Documentation](#documentation)
+- [Acknowledgements](#acknowledgements)
+- [Version Notes](#version-notes)
+
+
 ## Features
 
-- GPU-accelerated training and histogram construction using custom CUDA kernels
-- Drop-in scikit-learn style interface
-- Supports pre-binned data or automatic quantile binning
-- Simple install with `pip`
+- **Blazing-fast GPU training** with custom CUDA kernels for binning, histogram building, split finding, and prediction
+- **Invariant signal learning** via [Directional Era-Splitting (DES)](https://arxiv.org/abs/2309.14496) — designed for datasets with shifting environments (e.g., time, regimes, experimental settings)
+- Drop-in **scikit-learn style interface** for easy adoption
+- Supports **pre-binned data** or **automatic quantile binning**
+- Works with `float32` or `int8` inputs
+- Built-in **validation and early stopping** support with MSE, RMSLE, or correlation metrics
+- Simple install with `pip`, no custom drivers required
+
+> 💡 **Note:** WarpGBM v1.0.0 is a *generalization* of the traditional GBDT algorithm.
+> To run standard GBM training at maximum speed, simply omit the `era_id` argument — WarpGBM will behave like a traditional booster but with industry-leading performance.
 
 ---
 
@@ -74,7 +99,62 @@ Before either method, make sure you’ve installed PyTorch with GPU support:\
 
 ---
 
-## Example
+## Learning Invariant Signals Across Environments
+
+Most supervised learning models rely on an assumption known as the **Empirical Risk Minimization (ERM)** principle. Under ERM, the data distribution connecting inputs \( X \) and targets \( Y \) is assumed to be **fixed** and **stationary** across training, validation, and test splits. That is:
+
+> The patterns you learn from the training set are expected to generalize out-of-sample — *as long as the test data follows the same distribution as the training data.*
+
+However, this assumption is often violated in real-world settings. Data frequently shifts across time, geography, experimental conditions, or other hidden factors. This phenomenon is known as **distribution shift**, and it leads to models that perform well in-sample but fail catastrophically out-of-sample.
+
+This challenge motivates the field of **Out-of-Distribution (OOD) Generalization**, which assumes your data is drawn from **distinct environments or eras** — e.g., time periods, customer segments, experimental trials. Some signals may appear predictive within specific environments but vanish or reverse in others. These are called **spurious signals**. On the other hand, signals that remain consistently predictive across all environments are called **invariant signals**.
+
+WarpGBM v1.0.0 introduces **Directional Era-Splitting (DES)**, a new algorithm designed to identify and learn from invariant signals — ignoring signals that fail to generalize across environments.
+
+---
+
+### Why This Matters
+
+- Standard models trained via ERM can learn to exploit **spurious correlations** that only hold in some parts of the data.
+- DES explicitly tests whether a feature's split is **directionally consistent** across all eras — only such *invariant splits* are kept.
+- This approach has been shown to reduce overfitting and improve out-of-sample generalization, particularly in financial and scientific datasets.
+
+---
+
+### Visual Intuition
+
+We contrast two views of the data:
+
+- **ERM Setting**: All data is assumed to come from the same source (single distribution).\
+  No awareness of environments — spurious signals can dominate.
+
+- **OOD Setting (Era-Splitting)**: Data is explicitly grouped by environment (era).\
+  The model checks whether a signal holds across all groups — enforcing **robustness**.
+
+*📷 [Placeholder for future visual illustration]*
+
+
+---
+
+### Key References
+
+- **Invariant Risk Minimization (IRM)**: [Arjovsky et al., 2019](https://arxiv.org/abs/1907.02893)
+- **Learning Explanations That Are Hard to Vary**: [Parascandolo et al., 2020](https://arxiv.org/abs/2009.00329)
+- **Era Splitting: Invariant Learning for Decision Trees**: [DeLise, 2023](https://arxiv.org/abs/2309.14496)
+
+---
+
+WarpGBM is the **first open-source GBDT framework to integrate this OOD-aware approach natively**, using efficient CUDA kernels to evaluate per-era consistency during tree growth. It’s not just faster — it’s smarter.
+
+---
+
+## Examples
+
+WarpGBM is easy to drop into any supervised learning workflow and comes with curated examples in the `examples/` folder.
+
+ - `Spiral Data.ipynb`: synthetic OOD benchmark from Learning Explanations That Are Hard to Vary
+
+### Quick Comparison with LightGBM CPU version
 
 ```python
 import numpy as np
@@ -116,7 +196,7 @@ WarpGBM:     corr = 0.8621, time = 5.40s
 
 ---
 
-## Pre-binned Data Example (Numerai)
+### Pre-binned Data Example (Numerai)
 
 WarpGBM can save additional training time if your dataset is already pre-binned. The Numerai tournament data is a great example:
 
@@ -166,16 +246,6 @@ WarpGBM:     corr = 0.0660, time = 49.16s
 
 ---
 
-### Run it live in Colab
-
-You can try WarpGBM in a live Colab notebook using real pre-binned Numerai tournament data:
-
-[Open in Colab](https://colab.research.google.com/drive/10mKSjs9UvmMgM5_lOXAylq5LUQAnNSi7?usp=sharing)
-
-No installation required — just press **"Open in Playground"**, then **Run All**!
-
----
-
 ## Documentation
 
 ### `WarpGBM` Parameters:
@@ -201,7 +271,7 @@ No installation required — just press **"Open in Playground"**, then **Run All
    y_eval=None,                   # numpy array (float or int) 1 dimension (eval_num_samples)
    eval_every_n_trees=None,       # const (int) >= 1 
    early_stopping_rounds=None,    # const (int) >= 1
-   eval_metric='mse'              # string, one of 'mse' or 'corr'. For corr, loss is 1 - correlation(y_true, preds)
+   eval_metric='mse'              # string, one of 'mse', 'rmsle' or 'corr'. For corr, loss is 1 - correlation(y_true, preds)
 )
 ```
 Train with optional validation set and early stopping.
@@ -238,4 +308,8 @@ WarpGBM builds on the shoulders of PyTorch, scikit-learn, LightGBM, and the CUDA
 
 ### v0.1.26
 
-- Fix Memory bugs in prediction and colsample bytree logic. Added "corr" eval metric. 
+- Fix Memory bugs in prediction and colsample bytree logic. Added "corr" eval metric. 
+
+### v1.0.0
+
+- Introduce invariant learning via directional era splitting (DES). Also streamline VRAM improvements over previous sub versions.

{warpgbm-0.1.26 → warpgbm-1.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "warpgbm"
-version = "0.1.26"
+version = "1.0.0"
 description = "A fast GPU-accelerated Gradient Boosted Decision Tree library with PyTorch + CUDA"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -13,5 +13,5 @@ dependencies = [
     "torch",
     "numpy",
     "tqdm",
-    "scikit-learn"
+    "scikit-learn"              
 ]

warpgbm-1.0.0/tests/full_numerai_test.py

@@ -0,0 +1,67 @@
+from numerapi import NumerAPI
+import pandas as pd
+import numpy as np
+from warpgbm import WarpGBM
+import time
+from sklearn.metrics import mean_squared_error
+
+
+def predict_in_chunks(model, X, chunk_size=100_000):
+    preds = []
+    for i in range(0, X.shape[0], chunk_size):
+        X_chunk = X[i : i + chunk_size]
+        preds.append(model.predict(X_chunk))
+    return np.concatenate(preds)
+
+
+def test_numerai_data():
+    napi = NumerAPI()
+    napi.download_dataset("v5.0/train.parquet", "numerai_train.parquet")
+    napi.download_dataset("v5.0/validation.parquet", "numerai_validation.parquet")
+
+    data = pd.concat([
+        pd.read_parquet("numerai_train.parquet"),
+        pd.read_parquet("numerai_validation.parquet")
+    ])
+    features = [f for f in list(data) if "feature" in f]
+    target = "target"
+    data = data.loc[data[ target].isna() == False ]
+
+    X = data[features].astype("int8").values[:]
+    y = data[target].values
+
+    model = WarpGBM(
+        max_depth=3,
+        num_bins=5,
+        n_estimators=10,
+        learning_rate=1,
+        threads_per_block=64,
+        rows_per_thread=4,
+        colsample_bytree=0.8,
+    )
+
+    start_fit = time.time()
+    model.fit(
+        X,
+        y,
+        # era_id=era,
+        # X_eval=X,
+        # y_eval=y,
+        # eval_every_n_trees=10,
+        # early_stopping_rounds=1,
+    )
+    fit_time = time.time() - start_fit
+    print(f"  Fit time:     {fit_time:.3f} seconds")
+
+    start_pred = time.time()
+    preds = predict_in_chunks(model, X, chunk_size=500_000)
+    pred_time = time.time() - start_pred
+    print(f"  Predict time: {pred_time:.3f} seconds")
+
+    corr = np.corrcoef(preds, y)[0, 1]
+    mse = mean_squared_error(preds, y)
+    print(f"  Correlation:  {corr:.4f}")
+    print(f"  MSE:  {mse:.4f}")
+
+    # assert corr > 0.68, f"In-sample correlation too low: {corr}"
+    # assert mse < 0.03, f"In-sample mse too high: {mse}"

warpgbm-1.0.0/tests/test_fit_predict_corr.py

@@ -0,0 +1,52 @@
+import numpy as np
+from warpgbm import WarpGBM
+from sklearn.datasets import make_regression
+import time
+from sklearn.metrics import mean_squared_error
+
+
+def test_fit_predictpytee_correlation():
+    np.random.seed(42)
+    N = 100_000
+    F = 1000
+    X, y = make_regression(n_samples=N, n_features=F, noise=0.1, random_state=42)
+    era = np.zeros(N, dtype=np.int32)
+    corrs = []
+    mses = []
+
+    model = WarpGBM(
+        max_depth=10,
+        num_bins=10,
+        n_estimators=100,
+        learning_rate=1,
+        threads_per_block=64,
+        rows_per_thread=4,
+        colsample_bytree=1.0,
+    )
+
+    start_fit = time.time()
+    model.fit(
+        X,
+        y,
+        era_id=era,
+        X_eval=X,
+        y_eval=y,
+        eval_every_n_trees=10,
+        early_stopping_rounds=1,
+        eval_metric="corr",
+    )
+    fit_time = time.time() - start_fit
+    print(f"  Fit time:     {fit_time:.3f} seconds")
+
+    start_pred = time.time()
+    preds = model.predict(X)
+    pred_time = time.time() - start_pred
+    print(f"  Predict time: {pred_time:.3f} seconds")
+
+    corr = np.corrcoef(preds, y)[0, 1]
+    mse = mean_squared_error(preds, y)
+    print(f"  Correlation:  {corr:.4f}")
+    print(f"  MSE:  {mse:.4f}")
+
+    assert (corr > 0.9), f"In-sample correlation too low: {corrs}"
+    assert (mse < 2), f"In-sample mse too high: {mses}"

warpgbm-1.0.0/tests/test_invariant.py

@@ -0,0 +1,100 @@
+import numpy as np
+from warpgbm import WarpGBM
+import time
+
+import os
+import requests
+
+def download_file_if_missing(url, local_dir):
+    filename = os.path.basename(url)
+    local_path = os.path.join(local_dir, filename)
+
+    if os.path.exists(local_path):
+        print(f"✅ {filename} already exists, skipping download.")
+        return
+
+    # Convert GitHub blob URL to raw URL
+    raw_url = url.replace("github.com", "raw.githubusercontent.com").replace("/blob/", "/")
+
+    print(f"⬇️  Downloading {filename}...")
+    response = requests.get(raw_url)
+    response.raise_for_status()
+
+    os.makedirs(local_dir, exist_ok=True)
+    with open(local_path, "wb") as f:
+        f.write(response.content)
+    print(f"✅ Saved to {local_path}")
+
+# === Usage ===
+
+urls = [
+    "https://github.com/jefferythewind/era-splitting-notebook-examples/blob/main/Synthetic%20Memorization%20Data%20Set/X_train.npy",
+    "https://github.com/jefferythewind/era-splitting-notebook-examples/blob/main/Synthetic%20Memorization%20Data%20Set/y_train.npy",
+    "https://github.com/jefferythewind/era-splitting-notebook-examples/blob/main/Synthetic%20Memorization%20Data%20Set/X_test.npy",
+    "https://github.com/jefferythewind/era-splitting-notebook-examples/blob/main/Synthetic%20Memorization%20Data%20Set/y_test.npy",
+    "https://github.com/jefferythewind/era-splitting-notebook-examples/blob/main/Synthetic%20Memorization%20Data%20Set/X_eras.npy",
+]
+
+
+local_folder = "./synthetic_data"
+
+for url in urls:
+    download_file_if_missing(url, local_folder)
+
+def test_fit_predictpytee_correlation():
+    import numpy as np
+    import os
+    from warpgbm import WarpGBM
+    from sklearn.metrics import mean_squared_error
+    import time
+
+    # Load the real dataset from local .npy files
+    data_dir = "./synthetic_data"
+    X = np.load(os.path.join(data_dir, "X_train.npy"))
+    y = np.load(os.path.join(data_dir, "y_train.npy"))
+    # era = np.zeros(X.shape[0], dtype=np.int32)  # one era for default GBDT equivalence
+    era = np.load(os.path.join(data_dir, "X_eras.npy"))
+
+    X_test = np.load(os.path.join(data_dir, "X_test.npy"))
+    y_test = np.load(os.path.join(data_dir, "y_test.npy"))
+
+    print(f"X shape: {X.shape}, y shape: {y.shape}")
+
+    model = WarpGBM(
+        max_depth=10,
+        num_bins=127,
+        n_estimators=50,
+        learning_rate=1,
+        threads_per_block=128,
+        rows_per_thread=4,
+        colsample_bytree=0.9,
+        min_child_weight=4
+    )
+
+    start_fit = time.time()
+    model.fit(
+        X,
+        y,
+        era_id=era,
+        X_eval=X_test,
+        y_eval=y_test,
+        eval_every_n_trees=10,
+        early_stopping_rounds=100,
+        eval_metric="corr",
+    )
+    fit_time = time.time() - start_fit
+    print(f"  Fit time:     {fit_time:.3f} seconds")
+
+    start_pred = time.time()
+    preds = model.predict(X_test)
+    pred_time = time.time() - start_pred
+    print(f"  Predict time: {pred_time:.3f} seconds")
+
+    corr = np.corrcoef(preds, y_test)[0, 1]
+    mse = mean_squared_error(preds, y_test)
+    print(f"  Correlation:  {corr:.4f}")
+    print(f"  MSE:          {mse:.4f}")
+
+    assert corr > 0.95, f"Out-of-sample correlation too low: {corr:.4f}"
+    assert mse < 0.02, f"Out-of-sample MSE too high: {mse:.4f}"
+

warpgbm-1.0.0/version.txt

@@ -0,0 +1 @@
+1.0.0