seraplot 2.3.88__tar.gz → 2.4.0__tar.gz

{seraplot-2.3.88 → seraplot-2.4.0}/Cargo.lock

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

{seraplot-2.3.88 → seraplot-2.4.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "seraplot"
-version = "2.3.88"
+version = "2.4.0"
 edition = "2021"
 authors = ["feur25"]
 description = "Rust data visualization framework - The modern Plotly alternative"

{seraplot-2.3.88 → seraplot-2.4.0}/PKG-INFO

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

{seraplot-2.3.88 → seraplot-2.4.0}/pyproject.toml

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

seraplot-2.4.0/src/.gitignore

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

{seraplot-2.3.88 → seraplot-2.4.0}/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()) });