seraplot 2.3.89__tar.gz → 2.4.1__tar.gz

{seraplot-2.3.89 → seraplot-2.4.1}/Cargo.lock

@@ -3471,7 +3471,7 @@ checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
 
 [[package]]
 name = "seraplot"
-version = "2.3.89"
+version = "2.4.1"
 dependencies = [
  "base64 0.22.1",
  "criterion",

{seraplot-2.3.89 → seraplot-2.4.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "seraplot"
-version = "2.3.89"
+version = "2.4.1"
 edition = "2021"
 authors = ["feur25"]
 description = "Rust data visualization framework - The modern Plotly alternative"
@@ -44,6 +44,14 @@ ffi = ["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.89 → seraplot-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seraplot
-Version: 2.3.89
+Version: 2.4.1
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Win32 (MS Windows)
 Classifier: Intended Audience :: Developers
@@ -30,42 +30,47 @@ License: MIT
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 
-SeraPlot - Rust-Powered Data Visualization Framework
+SeraPlot — High-Performance Data Visualization & ML Framework
 
-SeraPlot is a framework developed in Rust, meticulously crafted with care. It is a modern 
-alternative to Plotly, designed specifically for data visualization. This library is distributed 
-across multiple programming languages (Python, C#, C++, JavaScript), regularly maintained and 
-updated, offering superior speed and significantly lower memory consumption compared to competitors.
+**SeraPlot v2.4.0+** is a production-grade framework written in **Rust**, delivering blazing-fast interactive charts and built-in machine learning pipelines. Designed as a modern alternative to Plotly + scikit-learn, it combines visualization and ML preprocessing in a single Rust binary — no dependencies, no bloat.
 
-documentation : https://feur25.github.io/seraplot/introduction.html
+📖 **Documentation:** https://feur25.github.io/seraplot/introduction.html
 
 ---
 
-### Why Choose SeraPlot
+## Why Choose SeraPlot?
 
-• More fast than plotly; generation across all dataset sizes  
-• Minimal memory footprint - ideal for resource-constrained environments  
-• Production-ready with enterprise-grade stability  
-• Multi-language support (Python, C#, C++, JavaScript, and more if necessary send me a message)  
-• Regularly updated with new plots - new features and improvements  
-• Perfect for real-time dashboards and batch processing  
+**100–8000× faster** than Plotly & Matplotlib on chart generation  
+**Minimal memory footprint** — runs on edge devices, embedded systems, low-power servers  
+**Production-ready** — enterprise-grade stability, zero fluff, maximum efficiency  
+**Multi-language** — Python, JavaScript/WebAssembly, C/C++, C#  
+**60+ chart types** — 2D, 3D, maps, statistical plots, all GPU-accelerated  
+**ML preprocessing & metrics** — StandardScaler with Welford `partial_fit` (online learning), Pipeline with `score`/`predict_proba`/`decision_function`, OneHotEncoder/OrdinalEncoder with incremental category union  
+**WebAssembly** — npm package `@seraplot/wasm` for browser visualization & ML inference  
+**Streaming data** — online scalers and encoders for incremental model training  
 
 ---
-### Install Command
-Seraplot may be installed using pip
+
+## Installation
+
+**Python** (PyPI — wheel for CPython 3.11+)
 
 ```bash
 pip install seraplot
 ```
 
-or you can also install in conda or uv
-
+Alternative package managers:
 ```bash
 conda install -c conda-forge seraplot
+uv pip install seraplot
 ```
+
+**JavaScript/WebAssembly** (npm)
+
 ```bash
-uv pip install seraplot
+npm install seraplot
 ```
+
 ---
 
 ### Gallery — Chart Types
@@ -91,20 +96,4 @@ uv pip install seraplot
 | ![Bench-1](https://raw.githubusercontent.com/feur25/seraplot-documentation/main/benchmark/1.png) | ![Bench-2](https://raw.githubusercontent.com/feur25/seraplot-documentation/main/benchmark/2.png) | ![Bench-3](https://raw.githubusercontent.com/feur25/seraplot-documentation/main/benchmark/3.png) |
 
 **SeraPlot outperforms Plotly and Matplotlib by 100–8000× on chart generation speed.**
-
----
-
-### Quick Start
-
-```python
-from seraplot import build_bar_chart
-
-# Create a simple bar chart
-build_bar_chart(
-    'Sales by Region',
-    ['North', 'South', 'East', 'West'],
-    [120, 95, 150, 110],
-    width=900, height=500
-)
-```
 

{seraplot-2.3.89 → seraplot-2.4.1}/README.md

@@ -1,39 +1,44 @@
-SeraPlot - Rust-Powered Data Visualization Framework
+SeraPlot — High-Performance Data Visualization & ML Framework
 
-SeraPlot is a framework developed in Rust, meticulously crafted with care. It is a modern 
-alternative to Plotly, designed specifically for data visualization. This library is distributed 
-across multiple programming languages (Python, C#, C++, JavaScript), regularly maintained and 
-updated, offering superior speed and significantly lower memory consumption compared to competitors.
+**SeraPlot v2.4.0+** is a production-grade framework written in **Rust**, delivering blazing-fast interactive charts and built-in machine learning pipelines. Designed as a modern alternative to Plotly + scikit-learn, it combines visualization and ML preprocessing in a single Rust binary — no dependencies, no bloat.
 
-documentation : https://feur25.github.io/seraplot/introduction.html
+📖 **Documentation:** https://feur25.github.io/seraplot/introduction.html
 
 ---
 
-### Why Choose SeraPlot
+## Why Choose SeraPlot?
 
-• More fast than plotly; generation across all dataset sizes  
-• Minimal memory footprint - ideal for resource-constrained environments  
-• Production-ready with enterprise-grade stability  
-• Multi-language support (Python, C#, C++, JavaScript, and more if necessary send me a message)  
-• Regularly updated with new plots - new features and improvements  
-• Perfect for real-time dashboards and batch processing  
+**100–8000× faster** than Plotly & Matplotlib on chart generation  
+**Minimal memory footprint** — runs on edge devices, embedded systems, low-power servers  
+**Production-ready** — enterprise-grade stability, zero fluff, maximum efficiency  
+**Multi-language** — Python, JavaScript/WebAssembly, C/C++, C#  
+**60+ chart types** — 2D, 3D, maps, statistical plots, all GPU-accelerated  
+**ML preprocessing & metrics** — StandardScaler with Welford `partial_fit` (online learning), Pipeline with `score`/`predict_proba`/`decision_function`, OneHotEncoder/OrdinalEncoder with incremental category union  
+**WebAssembly** — npm package `@seraplot/wasm` for browser visualization & ML inference  
+**Streaming data** — online scalers and encoders for incremental model training  
 
 ---
-### Install Command
-Seraplot may be installed using pip
+
+## Installation
+
+**Python** (PyPI — wheel for CPython 3.11+)
 
 ```bash
 pip install seraplot
 ```
 
-or you can also install in conda or uv
-
+Alternative package managers:
 ```bash
 conda install -c conda-forge seraplot
+uv pip install seraplot
 ```
+
+**JavaScript/WebAssembly** (npm)
+
 ```bash
-uv pip install seraplot
+npm install seraplot
 ```
+
 ---
 
 ### Gallery — Chart Types
@@ -59,19 +64,3 @@ uv pip install seraplot
 | ![Bench-1](https://raw.githubusercontent.com/feur25/seraplot-documentation/main/benchmark/1.png) | ![Bench-2](https://raw.githubusercontent.com/feur25/seraplot-documentation/main/benchmark/2.png) | ![Bench-3](https://raw.githubusercontent.com/feur25/seraplot-documentation/main/benchmark/3.png) |
 
 **SeraPlot outperforms Plotly and Matplotlib by 100–8000× on chart generation speed.**
-
----
-
-### Quick Start
-
-```python
-from seraplot import build_bar_chart
-
-# Create a simple bar chart
-build_bar_chart(
-    'Sales by Region',
-    ['North', 'South', 'East', 'West'],
-    [120, 95, 150, 110],
-    width=900, height=500
-)
-```

{seraplot-2.3.89 → seraplot-2.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "seraplot"
-version = "2.3.89"
+version = "2.4.1"
 description = "Rust data visualization framework - The modern Plotly alternative"
 readme = "README.md"
 readme-content-type = "text/markdown"

seraplot-2.4.1/src/.gitignore

@@ -0,0 +1,4 @@
+book/
+target/
+*.lock
+.DS_Store

{seraplot-2.3.89 → seraplot-2.4.1}/src/bindings/commands/charts.rs

@@ -319,9 +319,12 @@ pub fn build_kmeans_chart(input: &str) -> String {
 pub fn build_scatter_chart(input: &str) -> String {
     let (title_s, a, o) = parse_all(input);
     let title = title_s.as_str();
-    let x = a.x.unwrap_or_default();
-    let y = a.y.unwrap_or_default();
-    let lbls = a.labels.unwrap_or_default();
+    let raw_labels = a.labels.unwrap_or_default();
+    let x: Vec<f64> = a.x.unwrap_or_else(|| {
+        raw_labels.iter().enumerate().map(|(i, s)| s.parse::<f64>().unwrap_or(i as f64)).collect()
+    });
+    let y: Vec<f64> = a.y.unwrap_or_else(|| a.values.unwrap_or_default());
+    let lbls = raw_labels;
     let sz = a.sizes.unwrap_or_default();
     let cgs = o.color_groups.clone().unwrap_or_default();
     let hover = o.hj();
@@ -591,7 +594,8 @@ pub fn build_area_chart(input: &str) -> String {
     let (title_s, a, o) = parse_all(input);
     let title = title_s.as_str();
     let x_labels = a.x_labels.or(a.labels).unwrap_or_default();
-    let series_flat = a.series.unwrap_or_default();
+    let values_fallback = a.values;
+    let series_flat = a.series.unwrap_or_else(|| values_fallback.map(|v| vec![v]).unwrap_or_default());
     use crate::plot::statistical::{AreaConfig, render_area_html};
     let hover = o.hj();
     let sn = o.series_names.clone().unwrap_or_default();
@@ -1450,6 +1454,372 @@ pub fn ml_kmeans_fit_predict(input: &str) -> String {
         serde_json::to_string(&labels).unwrap_or_default(), inertia)
 }
 
+pub fn ml_metric_score(input: &str) -> String {
+    use crate::ml::metrics::*;
+    #[derive(Deserialize, Default)]
+    struct I {
+        name: Option<String>,
+        y_true: Option<Vec<f64>>,
+        y_pred: Option<Vec<f64>>,
+        y_score: Option<Vec<f64>>,
+        labels: Option<Vec<i32>>,
+        labels_true: Option<Vec<i32>>,
+        labels_pred: Option<Vec<i32>>,
+        x: Option<Vec<Vec<f64>>>,
+        average: Option<String>,
+        pos_label: Option<i32>,
+        beta: Option<f64>,
+        alpha: Option<f64>,
+        eps: Option<f64>,
+    }
+    let i: I = serde_json::from_str(input).unwrap_or_default();
+    let name = i.name.unwrap_or_default();
+    let to_i32 = |v: &[f64]| v.iter().map(|x| *x as i32).collect::<Vec<i32>>();
+    let yt_f = i.y_true.clone().unwrap_or_default();
+    let yp_f = i.y_pred.clone().unwrap_or_default();
+    let ys_f = i.y_score.clone().unwrap_or_default();
+    let yt_i = to_i32(&yt_f);
+    let yp_i = to_i32(&yp_f);
+    let pos = i.pos_label.unwrap_or(1);
+    let avg = match i.average.as_deref().unwrap_or("binary") {
+        "macro" => Average::Macro,
+        "weighted" => Average::Weighted,
+        _ => Average::Binary(pos),
+    };
+    let value: f64 = match name.as_str() {
+        "accuracy_score" => accuracy_score(&yt_i, &yp_i),
+        "balanced_accuracy_score" => balanced_accuracy_score(&yt_i, &yp_i),
+        "precision_score" => precision_score(&yt_i, &yp_i, avg),
+        "recall_score" => recall_score(&yt_i, &yp_i, avg),
+        "f1_score" => f1_score(&yt_i, &yp_i, avg),
+        "fbeta_score" => fbeta_score(&yt_i, &yp_i, i.beta.unwrap_or(1.0), avg),
+        "jaccard_score" => jaccard_score(&yt_i, &yp_i, pos),
+        "matthews_corrcoef" => matthews_corrcoef(&yt_i, &yp_i),
+        "cohen_kappa_score" => cohen_kappa_score(&yt_i, &yp_i),
+        "hamming_loss" => hamming_loss(&yt_i, &yp_i),
+        "zero_one_loss" => zero_one_loss(&yt_i, &yp_i),
+        "binary_log_loss" => binary_log_loss(&yt_i, &yp_f, i.eps.unwrap_or(1e-15)),
+        "brier_score_loss" => brier_score_loss(&yt_i, &yp_f),
+        "hinge_loss" => hinge_loss(&yt_i, &yp_f),
+        "roc_auc_score" => roc_auc_score(&yt_i, &ys_f, pos),
+        "average_precision_score" => average_precision_score(&yt_i, &ys_f, pos),
+        "mean_squared_error" => mean_squared_error(&yt_f, &yp_f),
+        "root_mean_squared_error" => root_mean_squared_error(&yt_f, &yp_f),
+        "mean_absolute_error" => mean_absolute_error(&yt_f, &yp_f),
+        "median_absolute_error" => median_absolute_error(&yt_f, &yp_f),
+        "r2_score" => r2_score(&yt_f, &yp_f),
+        "explained_variance_score" => explained_variance_score(&yt_f, &yp_f),
+        "max_error" => max_error(&yt_f, &yp_f),
+        "mean_absolute_percentage_error" => mean_absolute_percentage_error(&yt_f, &yp_f),
+        "mean_squared_log_error" => mean_squared_log_error(&yt_f, &yp_f),
+        "root_mean_squared_log_error" => root_mean_squared_log_error(&yt_f, &yp_f),
+        "mean_pinball_loss" => mean_pinball_loss(&yt_f, &yp_f, i.alpha.unwrap_or(0.5)),
+        "d2_absolute_error_score" => d2_absolute_error_score(&yt_f, &yp_f),
+        "silhouette_score" | "davies_bouldin_score" | "calinski_harabasz_score" => {
+            let rows = i.x.clone().unwrap_or_default();
+            let n = rows.len();
+            let p = if n > 0 { rows[0].len() } else { 0 };
+            let mut flat = Vec::with_capacity(n * p);
+            for r in &rows { flat.extend_from_slice(&r[..p.min(r.len())]); if r.len() < p { flat.extend(std::iter::repeat(0.0).take(p - r.len())); } }
+            let labs = i.labels.clone().unwrap_or_default();
+            match name.as_str() {
+                "silhouette_score" => silhouette_score(&flat, &labs, n, p),
+                "davies_bouldin_score" => davies_bouldin_score(&flat, &labs, n, p),
+                _ => calinski_harabasz_score(&flat, &labs, n, p),
+            }
+        }
+        "adjusted_rand_score" | "normalized_mutual_info_score" | "fowlkes_mallows_score"
+        | "homogeneity_score" | "completeness_score" | "v_measure_score" => {
+            let lt = i.labels_true.clone().unwrap_or_default();
+            let lp = i.labels_pred.clone().unwrap_or_default();
+            match name.as_str() {
+                "adjusted_rand_score" => adjusted_rand_score(&lt, &lp),
+                "normalized_mutual_info_score" => normalized_mutual_info_score(&lt, &lp),
+                "fowlkes_mallows_score" => fowlkes_mallows_score(&lt, &lp),
+                "homogeneity_score" => homogeneity_score(&lt, &lp),
+                "completeness_score" => completeness_score(&lt, &lp),
+                _ => v_measure_score(&lt, &lp),
+            }
+        }
+        _ => f64::NAN,
+    };
+    if value.is_nan() { format!("{{\"error\":\"unknown metric: {}\"}}", name) }
+    else { format!("{{\"value\":{}}}", value) }
+}
+
+pub fn ml_metric_curve(input: &str) -> String {
+    use crate::ml::metrics::*;
+    #[derive(Deserialize, Default)]
+    struct I {
+        name: Option<String>,
+        y_true: Option<Vec<f64>>,
+        y_score: Option<Vec<f64>>,
+        pos_label: Option<i32>,
+    }
+    let i: I = serde_json::from_str(input).unwrap_or_default();
+    let yt: Vec<i32> = i.y_true.unwrap_or_default().iter().map(|v| *v as i32).collect();
+    let ys = i.y_score.unwrap_or_default();
+    let pos = i.pos_label.unwrap_or(1);
+    match i.name.as_deref().unwrap_or("") {
+        "roc_curve" => {
+            let (a, b, c) = roc_curve(&yt, &ys, pos);
+            format!("{{\"fpr\":{},\"tpr\":{},\"thresholds\":{}}}",
+                serde_json::to_string(&a).unwrap_or_default(),
+                serde_json::to_string(&b).unwrap_or_default(),
+                serde_json::to_string(&c).unwrap_or_default())
+        }
+        "precision_recall_curve" => {
+            let (a, b, c) = precision_recall_curve(&yt, &ys, pos);
+            format!("{{\"precision\":{},\"recall\":{},\"thresholds\":{}}}",
+                serde_json::to_string(&a).unwrap_or_default(),
+                serde_json::to_string(&b).unwrap_or_default(),
+                serde_json::to_string(&c).unwrap_or_default())
+        }
+        n => format!("{{\"error\":\"unknown curve: {}\"}}", n),
+    }
+}
+
+pub fn ml_fit_transform(input: &str) -> String {
+    use crate::ml::preprocessing::transformers::*;
+    use crate::ml::preprocessing::scalers::*;
+    #[derive(Deserialize, Default)]
+    struct I {
+        name: Option<String>,
+        data: Option<Vec<Vec<f64>>>,
+        strategy: Option<String>,
+        fill_value: Option<f64>,
+        degree: Option<usize>,
+        interaction_only: Option<bool>,
+        include_bias: Option<bool>,
+        n_bins: Option<usize>,
+        method: Option<String>,
+        n_quantiles: Option<usize>,
+        output_distribution: Option<String>,
+    }
+    let i: I = serde_json::from_str(input).unwrap_or_default();
+    let rows = i.data.unwrap_or_default();
+    let n = rows.len();
+    let p = if n > 0 { rows[0].len() } else { 0 };
+    let mut flat = Vec::with_capacity(n * p);
+    for r in &rows {
+        flat.extend_from_slice(&r[..p.min(r.len())]);
+        if r.len() < p { flat.extend(std::iter::repeat(0.0).take(p - r.len())); }
+    }
+    let (out, cols, extra): (Vec<f64>, usize, String) = match i.name.as_deref().unwrap_or("") {
+        "SimpleImputer" => {
+            let mut t = SimpleImputer::new(i.strategy.as_deref().unwrap_or("mean"), i.fill_value.unwrap_or(0.0));
+            t.fit(&flat, n, p);
+            let o = t.transform(&flat, n, p);
+            (o, p, format!(",\"statistics\":{}", serde_json::to_string(&t.statistics).unwrap_or_default()))
+        }
+        "PolynomialFeatures" => {
+            let mut t = PolynomialFeatures::new(i.degree.unwrap_or(2), i.interaction_only.unwrap_or(false), i.include_bias.unwrap_or(true));
+            t.fit(&flat, n, p);
+            let o = t.transform(&flat, n, p);
+            let nf = t.n_output_features();
+            (o, nf, format!(",\"n_features_out\":{}", nf))
+        }
+        "KBinsDiscretizer" => {
+            let mut t = KBinsDiscretizer::new(i.n_bins.unwrap_or(5), i.strategy.as_deref().unwrap_or("quantile"));
+            t.fit(&flat, n, p);
+            let o = t.transform(&flat, n, p);
+            (o, p, String::new())
+        }
+        "PowerTransformer" => {
+            let mut t = PowerTransformer::new(i.method.as_deref().unwrap_or("yeo-johnson"));
+            t.fit(&flat, n, p);
+            let o = t.transform(&flat, n, p);
+            (o, p, format!(",\"lambdas\":{}", serde_json::to_string(&t.lambdas).unwrap_or_default()))
+        }
+        "QuantileTransformer" => {
+            let mut t = QuantileTransformer::new(i.n_quantiles.unwrap_or(1000), i.output_distribution.as_deref().unwrap_or("uniform"));
+            t.fit(&flat, n, p);
+            let o = t.transform(&flat, n, p);
+            (o, p, String::new())
+        }
+        "StandardScaler" => {
+            let mut t = StandardScaler::new(true, true);
+            t.fit(&flat, n, p);
+            let o = t.transform(&flat, n, p);
+            (o, p, String::new())
+        }
+        "MinMaxScaler" => {
+            let mut t = MinMaxScaler::new((0.0, 1.0));
+            t.fit(&flat, n, p);
+            let o = t.transform(&flat, n, p);
+            (o, p, String::new())
+        }
+        "RobustScaler" => {
+            let mut t = RobustScaler::new(true, true);
+            t.fit(&flat, n, p);
+            let o = t.transform(&flat, n, p);
+            (o, p, String::new())
+        }
+        "MaxAbsScaler" => {
+            let mut t = MaxAbsScaler::new();
+            t.fit(&flat, n, p);
+            let o = t.transform(&flat, n, p);
+            (o, p, String::new())
+        }
+        n_ => return format!("{{\"error\":\"unknown transformer: {}\"}}", n_),
+    };
+    let mut data: Vec<Vec<f64>> = Vec::with_capacity(n);
+    for r in 0..n {
+        data.push(out[r * cols..(r + 1) * cols].to_vec());
+    }
+    format!("{{\"data\":{},\"n\":{},\"cols\":{}{}}}",
+        serde_json::to_string(&data).unwrap_or_default(), n, cols, extra)
+}
+
+pub fn ml_kfold_split(input: &str) -> String {
+    use crate::ml::model_selection::split::*;
+    #[derive(Deserialize, Default)]
+    struct I {
+        kind: Option<String>,
+        n: Option<usize>,
+        k: Option<usize>,
+        seed: Option<u64>,
+        y: Option<Vec<i32>>,
+        groups: Option<Vec<i32>>,
+    }
+    let i: I = serde_json::from_str(input).unwrap_or_default();
+    let kind = i.kind.unwrap_or_else(|| "kfold".to_string());
+    let k = i.k.unwrap_or(5);
+    let seed = i.seed.unwrap_or(0);
+    let folds = match kind.as_str() {
+        "stratified" => stratified_kfold_indices(&i.y.unwrap_or_default(), k, seed),
+        "group" => group_kfold_indices(&i.groups.unwrap_or_default(), k),
+        _ => kfold_indices(i.n.unwrap_or(0), k, seed),
+    };
+    let payload: Vec<serde_json::Value> = folds.into_iter().map(|(tr, te)| {
+        serde_json::json!({"train": tr, "test": te})
+    }).collect();
+    serde_json::to_string(&payload).unwrap_or_else(|_| "[]".to_string())
+}
+
+pub fn ml_isolation_forest(input: &str) -> String {
+    use crate::ml::anomaly::isolation_forest::IsolationForest;
+    #[derive(Deserialize, Default)]
+    struct I {
+        data: Option<Vec<Vec<f64>>>,
+        x_test: Option<Vec<Vec<f64>>>,
+        n_estimators: Option<usize>,
+        max_samples: Option<usize>,
+        contamination: Option<f64>,
+        seed: Option<u64>,
+    }
+    let i: I = serde_json::from_str(input).unwrap_or_default();
+    let rows = i.data.unwrap_or_default();
+    let n = rows.len();
+    if n == 0 { return "{\"labels\":[],\"scores\":[],\"threshold\":0.0}".to_string(); }
+    let p = rows[0].len();
+    let mut flat = Vec::with_capacity(n * p);
+    for r in &rows { flat.extend_from_slice(&r[..p.min(r.len())]); if r.len() < p { flat.extend(std::iter::repeat(0.0).take(p - r.len())); } }
+    let mut model = IsolationForest::new(
+        i.n_estimators.unwrap_or(100),
+        i.max_samples.unwrap_or(256),
+        i.contamination.unwrap_or(0.1),
+        i.seed.unwrap_or(42),
+    );
+    model.fit(&flat, n, p);
+    let labels = model.predict(&flat, n, p);
+    let scores = model.score_samples(&flat, n, p);
+    let test_payload = if let Some(rows_t) = i.x_test {
+        let nt = rows_t.len();
+        if nt == 0 {
+            String::new()
+        } else {
+            let mut flat_t = Vec::with_capacity(nt * p);
+            for r in &rows_t { flat_t.extend_from_slice(&r[..p.min(r.len())]); if r.len() < p { flat_t.extend(std::iter::repeat(0.0).take(p - r.len())); } }
+            let lt = model.predict(&flat_t, nt, p);
+            let st = model.score_samples(&flat_t, nt, p);
+            format!(",\"test_labels\":{},\"test_scores\":{}",
+                serde_json::to_string(&lt).unwrap_or_default(),
+                serde_json::to_string(&st).unwrap_or_default())
+        }
+    } else { String::new() };
+    format!("{{\"labels\":{},\"scores\":{},\"threshold\":{}{}}}",
+        serde_json::to_string(&labels).unwrap_or_default(),
+        serde_json::to_string(&scores).unwrap_or_default(),
+        model.threshold_,
+        test_payload)
+}
+
+pub fn ml_permutation_importance(input: &str) -> String {
+    use crate::ml::model_selection::permutation::*;
+    #[derive(Deserialize, Default)]
+    struct I {
+        data: Option<Vec<Vec<f64>>>,
+        y: Option<Vec<f64>>,
+        baseline_pred: Option<Vec<f64>>,
+        perm_preds: Option<Vec<Vec<Vec<f64>>>>,
+        task: Option<String>,
+        n_repeats: Option<usize>,
+        seed: Option<u64>,
+    }
+    let i: I = serde_json::from_str(input).unwrap_or_default();
+    let rows = i.data.unwrap_or_default();
+    let n = rows.len();
+    if n == 0 { return "{\"importances_mean\":[],\"importances_std\":[]}".to_string(); }
+    let p = rows[0].len();
+    let mut flat = Vec::with_capacity(n * p);
+    for r in &rows { flat.extend_from_slice(&r[..p.min(r.len())]); if r.len() < p { flat.extend(std::iter::repeat(0.0).take(p - r.len())); } }
+    let yf = i.y.clone().unwrap_or_default();
+    let task = i.task.unwrap_or_else(|| "regression".to_string());
+    let n_repeats = i.n_repeats.unwrap_or(5);
+    let seed = i.seed.unwrap_or(0);
+    let perm_preds = i.perm_preds.unwrap_or_default();
+    let baseline_pred = i.baseline_pred.unwrap_or_default();
+    let _ = (n_repeats, seed, flat, n);
+    if perm_preds.is_empty() || baseline_pred.is_empty() {
+        return "{\"importances_mean\":[],\"importances_std\":[],\"error\":\"baseline_pred and perm_preds[p][n_repeats][n] are required\"}".to_string();
+    }
+    if task == "classification" {
+        let yi: Vec<i32> = yf.iter().map(|v| *v as i32).collect();
+        let baseline_i: Vec<i32> = baseline_pred.iter().map(|v| *v as i32).collect();
+        let baseline = crate::ml::metrics::classification::accuracy_score(&yi, &baseline_i);
+        let mut means = vec![0.0; p];
+        let mut stds = vec![0.0; p];
+        for j in 0..p.min(perm_preds.len()) {
+            let reps = &perm_preds[j];
+            let mut diffs = Vec::with_capacity(reps.len());
+            for rep in reps {
+                let pi: Vec<i32> = rep.iter().map(|v| *v as i32).collect();
+                let s = crate::ml::metrics::classification::accuracy_score(&yi, &pi);
+                diffs.push(baseline - s);
+            }
+            let m = diffs.iter().sum::<f64>() / diffs.len().max(1) as f64;
+            let v = diffs.iter().map(|x| (x - m).powi(2)).sum::<f64>() / diffs.len().max(1) as f64;
+            means[j] = m;
+            stds[j] = v.sqrt();
+        }
+        format!("{{\"importances_mean\":{},\"importances_std\":{},\"baseline\":{}}}",
+            serde_json::to_string(&means).unwrap_or_default(),
+            serde_json::to_string(&stds).unwrap_or_default(),
+            baseline)
+    } else {
+        let baseline = crate::ml::metrics::regression::r2_score(&yf, &baseline_pred);
+        let mut means = vec![0.0; p];
+        let mut stds = vec![0.0; p];
+        for j in 0..p.min(perm_preds.len()) {
+            let reps = &perm_preds[j];
+            let mut diffs = Vec::with_capacity(reps.len());
+            for rep in reps {
+                let s = crate::ml::metrics::regression::r2_score(&yf, rep);
+                diffs.push(baseline - s);
+            }
+            let m = diffs.iter().sum::<f64>() / diffs.len().max(1) as f64;
+            let v = diffs.iter().map(|x| (x - m).powi(2)).sum::<f64>() / diffs.len().max(1) as f64;
+            means[j] = m;
+            stds[j] = v.sqrt();
+        }
+        format!("{{\"importances_mean\":{},\"importances_std\":{},\"baseline\":{}}}",
+            serde_json::to_string(&means).unwrap_or_default(),
+            serde_json::to_string(&stds).unwrap_or_default(),
+            baseline)
+    }
+}
+
 pub fn set_global_background(input: &str) -> String {
     let color = input.trim().trim_matches('"');
     set_global_bg(if color.is_empty() { None } else { Some(color.to_string()) });