seraplot 2.3.62__tar.gz → 2.3.68__tar.gz

{seraplot-2.3.62 → seraplot-2.3.68}/Cargo.lock

@@ -2107,6 +2107,15 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "inventory"
+version = "0.3.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4f0c30c76f2f4ccee3fe55a2435f691ca00c0e4bd87abe4f4a851b1d4dac39b"
+dependencies = [
+ "rustversion",
+]
+
 [[package]]
 name = "io-lifetimes"
 version = "1.0.11"
@@ -3048,6 +3057,7 @@ checksum = "a5e00b96a521718e08e03b1a622f01c8a8deb50719335de3f60b3b3950f069d8"
 dependencies = [
  "cfg-if",
  "indoc",
+ "inventory",
  "libc",
  "memoffset 0.9.1",
  "parking_lot",
@@ -3461,7 +3471,7 @@ checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
 
 [[package]]
 name = "seraplot"
-version = "2.3.62"
+version = "2.3.68"
 dependencies = [
  "base64 0.22.1",
  "criterion",

{seraplot-2.3.62 → seraplot-2.3.68}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "seraplot"
-version = "2.3.62"
+version = "2.3.68"
 edition = "2021"
 authors = ["feur25"]
 description = "Rust data visualization framework - The modern Plotly alternative"
@@ -17,7 +17,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 thiserror = "1.0"
 parking_lot = "0.12"
-pyo3 = { version = "0.21", features = ["extension-module"], optional = true }
+pyo3 = { version = "0.21", features = ["extension-module", "multiple-pymethods"], optional = true }
 csv = "1.3"
 egui = { version = "0.27", optional = true }
 eframe = { version = "0.27", optional = true }
@@ -43,14 +43,6 @@ js = ["dep:wasm-bindgen", "dep:js-sys", "dep:getrandom", "dep:egui"]
 all = ["python"]
 pyo3 = ["dep:pyo3"]
 
-[[example]]
-name = "csv_test"
-path = "examples/csv_test.rs"
-
-[[example]]
-name = "csv_viewer"
-path = "examples/csv_viewer.rs"
-
 [profile.release]
 lto = "thin"
 codegen-units = 1

{seraplot-2.3.62 → seraplot-2.3.68}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seraplot
-Version: 2.3.62
+Version: 2.3.68
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Win32 (MS Windows)
 Classifier: Intended Audience :: Developers

seraplot-2.3.68/bench_issues.json

@@ -0,0 +1,13 @@
+{
+  "score_bugs": [],
+  "speed_bugs": [
+    {
+      "algo": "LabelEncoder.fit_transform",
+      "sp_fit_s": 0.0131,
+      "sk_fit_s": 0.0079,
+      "speedup": 0.603
+    }
+  ],
+  "n": 50000,
+  "date": "2026-04-18"
+}

{seraplot-2.3.62 → seraplot-2.3.68}/bench_seraplot.py

@@ -3,6 +3,21 @@ import json
 import numpy as np
 import pandas as pd
 import seraplot as sp
+from sklearn.linear_model import (
+    LinearRegression as SkLR, Ridge as SkRidge, Lasso as SkLasso,
+    ElasticNet as SkEN, SGDRegressor as SkSGDR,
+    LogisticRegression as SkLogR, SGDClassifier as SkSGDC,
+)
+from sklearn.tree import DecisionTreeClassifier as SkDTC
+from sklearn.ensemble import (
+    RandomForestClassifier as SkRFC, GradientBoostingClassifier as SkGBC,
+    AdaBoostClassifier as SkABC,
+)
+from sklearn.neighbors import KNeighborsClassifier as SkKNN
+from sklearn.naive_bayes import GaussianNB as SkGNB, BernoulliNB as SkBNB
+from sklearn.svm import LinearSVC as SkSVC
+from sklearn.model_selection import StratifiedKFold, cross_val_score
+from sklearn.metrics import accuracy_score, r2_score as sk_r2
 
 DATA_PATH = r"C:\Users\Quentin\Desktop\SeraPlot\v2\en.openfoodfacts.org.products.csv.gz"
 N_MAX = 50_000
@@ -18,8 +33,9 @@ CLASS_COL  = "pnns_groups_1"
 
 print("Chargement des données…")
 df = pd.read_csv(
-    DATA_PATH, sep="\t", on_bad_lines="skip", engine="python",
+    DATA_PATH, sep="\t", on_bad_lines="skip",
     usecols=NUMERIC_COLS + [CLASS_COL],
+    engine="python", nrows=500_000, quoting=3,
 )
 NUMERIC_COLS = [c for c in NUMERIC_COLS if c in df.columns]
 FEATURE_COLS = [c for c in NUMERIC_COLS if c != TARGET_REG]
@@ -58,6 +74,7 @@ yc_tr, yc_te = y_cls[tr],  y_cls[te]
 ls_tr        = label_strings[tr]
 
 records = {}
+sk_records = {}
 
 def run(name, model, Xtr, ytr, Xte, yte, metric="acc"):
     t0 = time.perf_counter()
@@ -70,6 +87,16 @@ def run(name, model, Xtr, ytr, Xte, yte, metric="acc"):
     records[name] = {"fit_s": round(fit_s, 4), "pred_s": round(pred_s, 4), "metric": metric, "score": round(score, 4)}
     print(f"  {name:<40} fit={fit_s:8.4f}s  pred={pred_s:7.4f}s  {metric}={score:.4f}")
 
+def run_sk(name, model, Xtr, ytr, Xte, yte, metric="acc"):
+    t0 = time.perf_counter()
+    model.fit(Xtr, ytr)
+    fit_s = time.perf_counter() - t0
+    t0 = time.perf_counter()
+    pred = model.predict(Xte)
+    pred_s = time.perf_counter() - t0
+    score = float(accuracy_score(yte, pred) if metric == "acc" else sk_r2(yte, pred))
+    sk_records[name] = {"fit_s": round(fit_s, 4), "pred_s": round(pred_s, 4), "metric": metric, "score": round(score, 4)}
+
 def runt(name, fn, *args, **kw):
     t0 = time.perf_counter()
     fn(*args, **kw)
@@ -94,6 +121,12 @@ run("Lasso(α=0.1)",              sp.Lasso(alpha=0.1, max_iter=500),
 run("ElasticNet(α=0.1,l1=.5)",  sp.ElasticNet(alpha=0.1, l1_ratio=0.5, max_iter=500),                     Xs_tr, yr_tr, Xs_te, yr_te, "r2")
 run("SGDRegressor",              sp.SGDRegressor(loss="squared_error", alpha=1e-4, max_iter=200, eta0=0.01), Xs_tr, yr_tr, Xs_te, yr_te, "r2")
 
+run_sk("LinearRegression",       SkLR(),                                                     Xs_tr, yr_tr, Xs_te, yr_te, "r2")
+run_sk("Ridge(α=1.0)",           SkRidge(alpha=1.0),                                         Xs_tr, yr_tr, Xs_te, yr_te, "r2")
+run_sk("Lasso(α=0.1)",           SkLasso(alpha=0.1, max_iter=500),                            Xs_tr, yr_tr, Xs_te, yr_te, "r2")
+run_sk("ElasticNet(α=0.1,l1=.5)",SkEN(alpha=0.1, l1_ratio=0.5, max_iter=500),               Xs_tr, yr_tr, Xs_te, yr_te, "r2")
+run_sk("SGDRegressor",           SkSGDR(loss="squared_error", alpha=1e-4, max_iter=200, eta0=0.01), Xs_tr, yr_tr, Xs_te, yr_te, "r2")
+
 print()
 run("LogisticRegression(C=1)",   sp.LogisticRegression(c=1.0, max_iter=300),                               Xs_tr, yc_tr, Xs_te, yc_te)
 run("SGDClassifier(hinge)",      sp.SGDClassifier(loss="hinge", alpha=1e-4, max_iter=200),                 Xs_tr, yc_tr, Xs_te, yc_te)
@@ -106,28 +139,50 @@ run("GaussianNB",                sp.GaussianNB(),
 run("BernoulliNB",               sp.BernoulliNB(),                                                          Xb_tr, yc_tr, Xb_te, yc_te)
 run("LinearSVC(C=1)",            sp.LinearSVC(c=1.0, max_iter=500),                                         Xs_tr, yc_tr, Xs_te, yc_te)
 
+run_sk("LogisticRegression(C=1)",SkLogR(C=1.0, max_iter=300, solver="lbfgs"),                              Xs_tr, yc_tr, Xs_te, yc_te)
+run_sk("SGDClassifier(hinge)",   SkSGDC(loss="hinge", alpha=1e-4, max_iter=200),                           Xs_tr, yc_tr, Xs_te, yc_te)
+run_sk("DecisionTree(d=10)",     SkDTC(max_depth=10),                                                       X_tr,  yc_tr, X_te,  yc_te)
+run_sk("RandomForest(50,d=10)",  SkRFC(n_estimators=50, max_depth=10, n_jobs=-1),                           X_tr,  yc_tr, X_te,  yc_te)
+run_sk("GradientBoosting(50,d=3)",SkGBC(n_estimators=50, max_depth=3, learning_rate=0.1),                  X_tr, yc_tr, X_te, yc_te)
+run_sk("AdaBoost(50)",           SkABC(n_estimators=50),                                                    X_tr,  yc_tr, X_te,  yc_te)
+run_sk("KNeighbors(k=5)",        SkKNN(n_neighbors=5),                                                      Xs_tr, yc_tr, Xs_te, yc_te)
+run_sk("GaussianNB",             SkGNB(),                                                                   X_tr,  yc_tr, X_te,  yc_te)
+run_sk("BernoulliNB",            SkBNB(),                                                                   Xb_tr, yc_tr, Xb_te, yc_te)
+run_sk("LinearSVC(C=1)",         SkSVC(C=1.0, max_iter=500),                                                Xs_tr, yc_tr, Xs_te, yc_te)
+
 print()
 skf      = sp.StratifiedKFold(n_splits=5, shuffle=True, random_state=SEED)
-cv_acc   = []
+folds_data = list(skf.split(Xs_tr, yc_tr))
 t0 = time.perf_counter()
-for ti, vi in skf.split(Xs_tr, yc_tr):
-    m = sp.LogisticRegression(c=1.0, max_iter=200)
-    m.fit(Xs_tr[ti], yc_tr[ti])
-    cv_acc.append(float(sp.accuracy_score(yc_tr[vi], m.predict(Xs_tr[vi]))))
+cv_acc  = sp.parallel_cv_cls(Xs_tr, yc_tr, folds_data, c=1.0, max_iter=200)
 cv_s    = time.perf_counter() - t0
 cv_mean = float(np.mean(cv_acc))
 records["StratifiedKFold(5)×LR"] = {"fit_s": round(cv_s, 4), "pred_s": 0.0, "metric": "cv_acc", "score": round(cv_mean, 4)}
 print(f"  {'StratifiedKFold(5)×LR':<40} {cv_s:.4f}s  mean_acc={cv_mean:.4f}")
 
-with open("results_seraplot.json", "w") as f:
-    json.dump(records, f, indent=2)
+skf_sk = StratifiedKFold(n_splits=5, shuffle=True, random_state=SEED)
+t0 = time.perf_counter()
+sk_cv_scores = cross_val_score(SkLogR(C=1.0, max_iter=200, solver="lbfgs"), Xs_tr, yc_tr, cv=skf_sk, scoring="accuracy")
+sk_cv_s = time.perf_counter() - t0
+sk_records["StratifiedKFold(5)×LR"] = {"fit_s": round(sk_cv_s, 4), "pred_s": 0.0, "metric": "cv_acc", "score": round(float(np.mean(sk_cv_scores)), 4)}
 
-print(f"\n{'═'*76}")
-print(f"  {'Algorithme':<40} {'Fit (s)':>10} {'Pred (s)':>10} {'Score':>8}")
-print(f"{'═'*76}")
-for k, v in records.items():
-    pred_str  = f"{v['pred_s']:.4f}" if v["pred_s"] > 0 else "-"
-    score_str = f"{v['score']:.4f}"  if v["metric"] not in ("ms", "s") else "-"
-    print(f"  {k:<40} {v['fit_s']:>10.4f} {pred_str:>10} {score_str:>8}")
-print(f"{'═'*76}")
+with open("results_seraplot.json", "w") as f:
+    json.dump({"seraplot": records, "sklearn": sk_records}, f, indent=2)
+
+print(f"\n{'═'*100}")
+print(f"  {'Algorithme':<40} {'SP fit':>8} {'SK fit':>8} {'Speedup':>8} {'SP score':>10} {'SK score':>10} {'Δ score':>8}")
+print(f"{'═'*100}")
+all_keys = list(records.keys())
+for k in all_keys:
+    sp_r = records.get(k, {})
+    sk_r = sk_records.get(k, {})
+    sp_t = sp_r.get("fit_s", 0.0)
+    sk_t = sk_r.get("fit_s", 0.0)
+    sp_s = sp_r.get("score", 0.0)
+    sk_s = sk_r.get("score", 0.0)
+    ratio_str = f"{sk_t/sp_t:.1f}×" if sp_t > 0 and sk_t > 0 else "-"
+    delta     = abs(sp_s - sk_s) if sp_r.get("metric") not in ("s",) else 0.0
+    ok        = "✓" if delta < 0.01 else "✗" if sp_r.get("metric") not in ("s",) else ""
+    print(f"  {k:<40} {sp_t:>8.4f} {sk_t:>8.4f} {ratio_str:>8} {sp_s:>10.4f} {sk_s:>10.4f} {delta:>7.4f}{ok}")
+print(f"{'═'*100}")
 print(f"\nRésultats sauvegardés → results_seraplot.json")

{seraplot-2.3.62 → seraplot-2.3.68}/bench_sklearn.py

@@ -32,8 +32,9 @@ CLASS_COL  = "pnns_groups_1"
 
 print("Chargement des données…")
 df = pd.read_csv(
-    DATA_PATH, sep="\t", on_bad_lines="skip", engine="python",
+    DATA_PATH, sep="\t", on_bad_lines="skip",
     usecols=NUMERIC_COLS + [CLASS_COL],
+    engine="python",
 )
 NUMERIC_COLS = [c for c in NUMERIC_COLS if c in df.columns]
 FEATURE_COLS = [c for c in NUMERIC_COLS if c != TARGET_REG]

seraplot-2.3.68/benchmark_gridsearch.py

@@ -0,0 +1,201 @@
+"""
+Benchmark: SeraPlot GridSearchCV vs scikit-learn GridSearchCV
+Dataset: OpenFoodFacts (500k rows)
+"""
+import time
+import numpy as np
+import pandas as pd
+
+FEATURES = [
+    'energy-kcal_100g', 'fat_100g', 'saturated-fat_100g',
+    'carbohydrates_100g', 'sugars_100g', 'fiber_100g',
+    'proteins_100g', 'salt_100g',
+]
+
+def load_data(n_rows=500_000):
+    print(f"Loading OpenFoodFacts ({n_rows} rows)...")
+    t0 = time.perf_counter()
+    df = pd.read_csv(
+        r'C:\Users\Quentin\Desktop\SeraPlot\v2\en.openfoodfacts.org.products.csv.gz',
+        sep='\t', usecols=FEATURES + ['nutriscore_score', 'nutriscore_grade'],
+        nrows=n_rows * 3,  # load extra to handle NaN drops
+    )
+    df = df.dropna(subset=FEATURES + ['nutriscore_score']).head(n_rows)
+    X = df[FEATURES].values.astype(np.float64)
+    y_reg = df['nutriscore_score'].values.astype(np.float64)
+    # For classification: bin nutriscore into 5 classes (0-4)
+    y_cls = pd.qcut(y_reg, q=5, labels=False, duplicates='drop').astype(np.int32)
+    print(f"  Loaded {X.shape[0]} rows x {X.shape[1]} features in {time.perf_counter()-t0:.2f}s")
+    print(f"  Classes: {np.unique(y_cls)}")
+    return X, y_reg, y_cls
+
+
+def bench_sklearn_gridsearch_ridge(X, y):
+    from sklearn.linear_model import Ridge
+    from sklearn.model_selection import GridSearchCV
+    param_grid = {'alpha': [0.001, 0.01, 0.1, 1.0, 10.0, 100.0]}
+    gs = GridSearchCV(Ridge(), param_grid, cv=5, scoring='r2', n_jobs=-1)
+    t0 = time.perf_counter()
+    gs.fit(X, y)
+    elapsed = time.perf_counter() - t0
+    return elapsed, gs.best_score_, gs.best_params_
+
+
+def bench_seraplot_gridsearch_ridge(X, y):
+    from seraplot import GridSearchCV
+    param_grid = {'alpha': [0.001, 0.01, 0.1, 1.0, 10.0, 100.0]}
+    gs = GridSearchCV('Ridge', param_grid, cv=5)
+    t0 = time.perf_counter()
+    gs.fit(X, y)
+    elapsed = time.perf_counter() - t0
+    return elapsed, gs.best_score_, gs.best_params_
+
+
+def bench_sklearn_gridsearch_rf(X, y):
+    from sklearn.ensemble import RandomForestClassifier
+    from sklearn.model_selection import GridSearchCV
+    param_grid = {
+        'n_estimators': [50, 100],
+        'max_depth': [5, 10, 20],
+        'min_samples_split': [2, 5],
+        'min_samples_leaf': [1, 2],
+    }
+    gs = GridSearchCV(RandomForestClassifier(random_state=42), param_grid, cv=3, scoring='accuracy', n_jobs=-1)
+    t0 = time.perf_counter()
+    gs.fit(X, y)
+    elapsed = time.perf_counter() - t0
+    return elapsed, gs.best_score_, gs.best_params_
+
+
+def bench_seraplot_gridsearch_rf(X, y):
+    from seraplot import GridSearchCV
+    param_grid = {
+        'n_estimators': [50, 100],
+        'max_depth': [5, 10, 20],
+        'min_samples_split': [2, 5],
+        'min_samples_leaf': [1, 2],
+    }
+    gs = GridSearchCV('RandomForestClassifier', param_grid, cv=3)
+    t0 = time.perf_counter()
+    gs.fit(X, y)
+    elapsed = time.perf_counter() - t0
+    return elapsed, gs.best_score_, gs.best_params_
+
+
+def bench_sklearn_randomsearch_gb(X, y):
+    from sklearn.ensemble import GradientBoostingClassifier
+    from sklearn.model_selection import RandomizedSearchCV
+    param_dist = {
+        'n_estimators': [50, 100, 200],
+        'learning_rate': [0.01, 0.05, 0.1, 0.2],
+        'max_depth': [3, 5, 7, 10],
+        'min_samples_split': [2, 5, 10],
+        'min_samples_leaf': [1, 2, 4],
+    }
+    rs = RandomizedSearchCV(GradientBoostingClassifier(random_state=42), param_dist, n_iter=20, cv=3, scoring='accuracy', n_jobs=-1, random_state=42)
+    t0 = time.perf_counter()
+    rs.fit(X, y)
+    elapsed = time.perf_counter() - t0
+    return elapsed, rs.best_score_, rs.best_params_
+
+
+def bench_seraplot_randomsearch_gb(X, y):
+    from seraplot import RandomizedSearchCV
+    param_dist = {
+        'n_estimators': [50, 100, 200],
+        'learning_rate': [0.01, 0.05, 0.1, 0.2],
+        'max_depth': [3, 5, 7, 10],
+        'min_samples_split': [2, 5, 10],
+        'min_samples_leaf': [1, 2, 4],
+    }
+    rs = RandomizedSearchCV('GradientBoostingClassifier', param_dist, n_iter=20, cv=3)
+    t0 = time.perf_counter()
+    rs.fit(X, y)
+    elapsed = time.perf_counter() - t0
+    return elapsed, rs.best_score_, rs.best_params_
+
+
+def bench_sklearn_halving_rf(X, y):
+    from sklearn.ensemble import RandomForestClassifier
+    from sklearn.experimental import enable_halving_search_cv
+    from sklearn.model_selection import HalvingGridSearchCV
+    param_grid = {
+        'n_estimators': [50, 100, 200],
+        'max_depth': [3, 5, 10, 20],
+        'min_samples_split': [2, 5, 10],
+        'min_samples_leaf': [1, 2, 4],
+    }
+    hg = HalvingGridSearchCV(RandomForestClassifier(random_state=42), param_grid, cv=3, factor=3, scoring='accuracy', n_jobs=-1, random_state=42)
+    t0 = time.perf_counter()
+    hg.fit(X, y)
+    elapsed = time.perf_counter() - t0
+    return elapsed, hg.best_score_, hg.best_params_
+
+
+def bench_seraplot_halving_rf(X, y):
+    from seraplot import HalvingGridSearchCV
+    param_grid = {
+        'n_estimators': [50, 100, 200],
+        'max_depth': [3, 5, 10, 20],
+        'min_samples_split': [2, 5, 10],
+        'min_samples_leaf': [1, 2, 4],
+    }
+    hg = HalvingGridSearchCV('RandomForestClassifier', param_grid, cv=3, factor=3)
+    t0 = time.perf_counter()
+    hg.fit(X, y)
+    elapsed = time.perf_counter() - t0
+    return elapsed, hg.best_score_, hg.best_params_
+
+
+def print_result(name, t_sk, score_sk, params_sk, t_sp, score_sp, params_sp):
+    speedup = t_sk / t_sp if t_sp > 0 else float('inf')
+    print(f"\n{'='*70}")
+    print(f"  {name}")
+    print(f"{'='*70}")
+    print(f"  scikit-learn : {t_sk:8.2f}s  score={score_sk:.4f}  params={params_sk}")
+    print(f"  SeraPlot     : {t_sp:8.2f}s  score={score_sp:.4f}  params={params_sp}")
+    print(f"  Speedup      : {speedup:8.1f}x")
+
+
+def main():
+    X, y_reg, y_cls = load_data(500_000)
+
+    # Reduce data for slower benchmarks
+    X_small = X[:50_000]
+    y_cls_small = y_cls[:50_000]
+
+    print("\n" + "="*70)
+    print("  BENCHMARK: SeraPlot vs scikit-learn GridSearchCV")
+    print("="*70)
+
+    # 1. Ridge GridSearchCV (full 500k)
+    print("\n[1/4] Ridge GridSearchCV (500k rows, 6 alpha values, cv=5)...")
+    t_sk, s_sk, p_sk = bench_sklearn_gridsearch_ridge(X, y_reg)
+    t_sp, s_sp, p_sp = bench_seraplot_gridsearch_ridge(X, y_reg)
+    print_result("Ridge GridSearchCV (500k rows)", t_sk, s_sk, p_sk, t_sp, s_sp, p_sp)
+
+    # 2. RandomForest GridSearchCV (50k subset - RF is heavy)
+    print("\n[2/4] RandomForest GridSearchCV (50k rows, 24 combos, cv=3)...")
+    t_sk, s_sk, p_sk = bench_sklearn_gridsearch_rf(X_small, y_cls_small)
+    t_sp, s_sp, p_sp = bench_seraplot_gridsearch_rf(X_small, y_cls_small)
+    print_result("RandomForest GridSearchCV (50k rows)", t_sk, s_sk, p_sk, t_sp, s_sp, p_sp)
+
+    # 3. GradientBoosting RandomizedSearchCV (50k subset)
+    print("\n[3/4] GradientBoosting RandomizedSearchCV (50k rows, 20 iters, cv=3)...")
+    t_sk, s_sk, p_sk = bench_sklearn_randomsearch_gb(X_small, y_cls_small)
+    t_sp, s_sp, p_sp = bench_seraplot_randomsearch_gb(X_small, y_cls_small)
+    print_result("GradientBoosting RandomizedSearchCV (50k rows)", t_sk, s_sk, p_sk, t_sp, s_sp, p_sp)
+
+    # 4. HalvingGridSearchCV with RF (50k subset)
+    print("\n[4/4] HalvingGridSearchCV RF (50k rows, 108 combos, factor=3)...")
+    t_sk, s_sk, p_sk = bench_sklearn_halving_rf(X_small, y_cls_small)
+    t_sp, s_sp, p_sp = bench_seraplot_halving_rf(X_small, y_cls_small)
+    print_result("HalvingGridSearchCV RF (50k rows)", t_sk, s_sk, p_sk, t_sp, s_sp, p_sp)
+
+    print("\n" + "="*70)
+    print("  BENCHMARK COMPLETE")
+    print("="*70)
+
+
+if __name__ == '__main__':
+    main()

seraplot-2.3.68/benchmark_gridsearch2.py

@@ -0,0 +1,138 @@
+"""
+Benchmark #2: Large search spaces - SeraPlot vs scikit-learn
+Focus on where parallel Rust execution dominates.
+"""
+import time
+import numpy as np
+import pandas as pd
+
+
+def load_data():
+    print("Loading OpenFoodFacts...")
+    t0 = time.perf_counter()
+    cols = ['energy-kcal_100g', 'fat_100g', 'saturated-fat_100g',
+            'carbohydrates_100g', 'sugars_100g', 'proteins_100g',
+            'salt_100g', 'nutriscore_score']
+    df = pd.read_csv(
+        r'C:\Users\Quentin\Desktop\SeraPlot\v2\en.openfoodfacts.org.products.csv.gz',
+        sep='\t', nrows=500_000, low_memory=False, on_bad_lines='skip',
+    )
+    df = df[cols].dropna()
+    X = df[cols[:-1]].values.astype(np.float64)
+    y_reg = df['nutriscore_score'].values.astype(np.float64)
+    y_cls = pd.qcut(y_reg, q=3, labels=False, duplicates='drop').astype(np.int32)
+    print(f"  {X.shape[0]} rows x {X.shape[1]} features in {time.perf_counter()-t0:.2f}s")
+    return X, y_reg, y_cls
+
+
+def main():
+    X, y_reg, y_cls = load_data()
+
+    # Use subsets for different tests
+    X_100k, y_reg_100k = X[:100_000], y_reg[:100_000]
+    X_50k, y_cls_50k = X[:50_000], y_cls[:50_000]
+
+    print(f"\n{'='*70}")
+    print("  BENCHMARK 2: Large search spaces")
+    print(f"{'='*70}")
+
+    # 1. Lasso: 5 alphas x 3 max_iter x 3 tol = 45 combos, cv=5 = 225 fits, 100k rows
+    print("\n[1] Lasso GridSearchCV (100k rows, 45 combos, cv=5 = 225 fits)...")
+    from sklearn.linear_model import Lasso as SkLasso
+    from sklearn.model_selection import GridSearchCV as SkGS
+    pg = {'alpha': [0.0001, 0.001, 0.01, 0.1, 1.0], 'max_iter': [500, 1000, 2000], 'tol': [1e-4, 1e-3, 1e-2]}
+    t0 = time.perf_counter()
+    sk = SkGS(SkLasso(), pg, cv=5, scoring='r2', n_jobs=-1); sk.fit(X_100k, y_reg_100k)
+    t_sk = time.perf_counter() - t0
+
+    from seraplot import GridSearchCV as SpGS
+    t0 = time.perf_counter()
+    sp = SpGS('Lasso', pg, cv=5); sp.fit(X_100k, y_reg_100k)
+    t_sp = time.perf_counter() - t0
+    print(f"  sklearn: {t_sk:.2f}s  score={sk.best_score_:.4f}  params={sk.best_params_}")
+    print(f"  SeraPlot: {t_sp:.2f}s  score={sp.best_score_:.4f}  params={sp.best_params_}")
+    print(f"  Speedup: {t_sk/t_sp:.1f}x")
+
+    # 2. ElasticNet: 5 alpha x 5 l1_ratio x 3 max_iter = 75 combos, cv=5 = 375 fits, 100k rows
+    print("\n[2] ElasticNet GridSearchCV (100k rows, 75 combos, cv=5 = 375 fits)...")
+    from sklearn.linear_model import ElasticNet as SkEN
+    pg2 = {'alpha': [0.0001, 0.001, 0.01, 0.1, 1.0], 'l1_ratio': [0.1, 0.3, 0.5, 0.7, 0.9], 'max_iter': [500, 1000, 2000]}
+    t0 = time.perf_counter()
+    sk2 = SkGS(SkEN(), pg2, cv=5, scoring='r2', n_jobs=-1); sk2.fit(X_100k, y_reg_100k)
+    t_sk2 = time.perf_counter() - t0
+    t0 = time.perf_counter()
+    sp2 = SpGS('ElasticNet', pg2, cv=5); sp2.fit(X_100k, y_reg_100k)
+    t_sp2 = time.perf_counter() - t0
+    print(f"  sklearn: {t_sk2:.2f}s  score={sk2.best_score_:.4f}")
+    print(f"  SeraPlot: {t_sp2:.2f}s  score={sp2.best_score_:.4f}")
+    print(f"  Speedup: {t_sk2/t_sp2:.1f}x")
+
+    # 3. LogisticRegression GridSearchCV: 6C x 3 max_iter = 18 combos, cv=5, 50k rows
+    print("\n[3] LogisticRegression GridSearchCV (50k rows, 18 combos, cv=5 = 90 fits)...")
+    from sklearn.linear_model import LogisticRegression as SkLR
+    pg3 = {'C': [0.001, 0.01, 0.1, 1.0, 10.0, 100.0], 'max_iter': [100, 500, 1000]}
+    t0 = time.perf_counter()
+    sk3 = SkGS(SkLR(), pg3, cv=5, scoring='accuracy', n_jobs=-1); sk3.fit(X_50k, y_cls_50k)
+    t_sk3 = time.perf_counter() - t0
+    t0 = time.perf_counter()
+    sp3 = SpGS('LogisticRegression', pg3, cv=5); sp3.fit(X_50k, y_cls_50k)
+    t_sp3 = time.perf_counter() - t0
+    print(f"  sklearn: {t_sk3:.2f}s  score={sk3.best_score_:.4f}")
+    print(f"  SeraPlot: {t_sp3:.2f}s  score={sp3.best_score_:.4f}")
+    print(f"  Speedup: {t_sk3/t_sp3:.1f}x")
+
+    # 4. KNN GridSearchCV: 8 k-values x 2 weights = 16 combos, cv=5 = 80 fits, 50k
+    print("\n[4] KNN GridSearchCV (50k rows, 16 combos, cv=5 = 80 fits)...")
+    from sklearn.neighbors import KNeighborsClassifier as SkKNN
+    pg4 = {'n_neighbors': [3, 5, 7, 9, 11, 15, 21, 31], 'weights': ['uniform', 'distance']}
+    t0 = time.perf_counter()
+    sk4 = SkGS(SkKNN(), pg4, cv=5, scoring='accuracy', n_jobs=-1); sk4.fit(X_50k, y_cls_50k)
+    t_sk4 = time.perf_counter() - t0
+    t0 = time.perf_counter()
+    sp4 = SpGS('KNeighborsClassifier', pg4, cv=5); sp4.fit(X_50k, y_cls_50k)
+    t_sp4 = time.perf_counter() - t0
+    print(f"  sklearn: {t_sk4:.2f}s  score={sk4.best_score_:.4f}")
+    print(f"  SeraPlot: {t_sp4:.2f}s  score={sp4.best_score_:.4f}")
+    print(f"  Speedup: {t_sk4/t_sp4:.1f}x")
+
+    # 5. HalvingRandomSearchCV: Large space, 256 candidates, factor=3
+    print("\n[5] HalvingRandomSearchCV GradientBoosting (50k, 256 candidates)...")
+    from sklearn.ensemble import GradientBoostingClassifier as SkGB
+    from sklearn.experimental import enable_halving_search_cv
+    from sklearn.model_selection import HalvingRandomSearchCV as SkHRS
+    from seraplot import HalvingRandomSearchCV as SpHRS
+    pg5 = {
+        'n_estimators': [25, 50, 100, 200],
+        'learning_rate': [0.01, 0.05, 0.1, 0.2],
+        'max_depth': [3, 5, 7, 10],
+        'min_samples_split': [2, 5, 10],
+        'min_samples_leaf': [1, 2, 4],
+    }
+    t0 = time.perf_counter()
+    sk5 = SkHRS(SkGB(random_state=42), pg5, n_candidates=256, cv=3, factor=3, scoring='accuracy', n_jobs=-1, random_state=42); sk5.fit(X_50k, y_cls_50k)
+    t_sk5 = time.perf_counter() - t0
+    t0 = time.perf_counter()
+    sp5 = SpHRS('GradientBoostingClassifier', pg5, n_candidates=256, cv=3, factor=3); sp5.fit(X_50k, y_cls_50k)
+    t_sp5 = time.perf_counter() - t0
+    print(f"  sklearn: {t_sk5:.2f}s  score={sk5.best_score_:.4f}")
+    print(f"  SeraPlot: {t_sp5:.2f}s  score={sp5.best_score_:.4f}")
+    print(f"  Speedup: {t_sk5/t_sp5:.1f}x")
+
+    print(f"\n{'='*70}")
+    print(f"  SUMMARY")
+    print(f"{'='*70}")
+    results = [
+        ("Lasso GS 45x5", t_sk, t_sp),
+        ("ElasticNet GS 75x5", t_sk2, t_sp2),
+        ("LogisticReg GS 18x5", t_sk3, t_sp3),
+        ("KNN GS 16x5", t_sk4, t_sp4),
+        ("HalvingRandom GB 256", t_sk5, t_sp5),
+    ]
+    for name, ts, tp in results:
+        print(f"  {name:30s}  sklearn={ts:7.2f}s  seraplot={tp:7.2f}s  speedup={ts/tp:7.1f}x")
+    avg_speedup = sum(ts/tp for _, ts, tp in results) / len(results)
+    print(f"\n  Average speedup: {avg_speedup:.1f}x")
+
+
+if __name__ == '__main__':
+    main()

{seraplot-2.3.62 → seraplot-2.3.68}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["maturin>=0.15,<0.16"]
+requires = ["maturin>=1.0"]
 build-backend = "maturin"
 
 [project]
 name = "seraplot"
-version = "2.3.62"
+version = "2.3.68"
 description = "Rust data visualization framework - The modern Plotly alternative"
 readme = "README.md"
 readme-content-type = "text/markdown"

seraplot-2.3.68/python/seraplot/__init__.py

@@ -0,0 +1,29 @@
+from .seraplot import *
+from .seraplot import __version__, Chart
+import numpy as _np
+import pandas as _pd
+
+class LabelEncoder:
+    def __init__(self):
+        self.classes_ = None
+
+    def fit(self, y):
+        _, uniques = _pd.factorize(y, sort=True)
+        self.classes_ = _np.asarray(uniques)
+        return self
+
+    def transform(self, y):
+        y = _np.asarray(y)
+        idx = _np.searchsorted(self.classes_, y)
+        return idx.astype(_np.int32)
+
+    def fit_transform(self, y):
+        codes, uniques = _pd.factorize(y, sort=True)
+        self.classes_ = _np.asarray(uniques)
+        return codes.astype(_np.int32)
+
+    def inverse_transform(self, y):
+        return self.classes_[_np.asarray(y)]
+
+    def __repr__(self):
+        return "LabelEncoder()"