millwright 0.1.1__tar.gz → 0.2.0__tar.gz

millwright-0.2.0/CHANGELOG.md

@@ -0,0 +1,118 @@
+# Changelog
+
+All notable changes to Millwright are recorded here. The format follows
+[Keep a Changelog](https://keepachangelog.com/), and the project aims at
+[Semantic Versioning](https://semver.org/).
+
+## [Unreleased]
+
+## [0.2.0] - 2026-08-23
+
+### Added
+- **rayon parallelism.** Cross-validation folds and search candidates now
+  evaluate in parallel: `cross_val_score` is fold-parallel, `Bagging` fits its
+  base estimators in parallel, and `AutoML::parallel()` adds candidate-level
+  parallelism. The core contract traits gained `Send + Sync` bounds (every
+  concrete model already satisfied them). Results stay seed-reproducible.
+- **`Boosting`** — SAMME adaptive boosting over any weak learner (an
+  `alpha`-weighted vote of models each reweighted toward the last round's
+  mistakes), joining `Voting`/`Bagging`/`Stacking`.
+- **Three more models over the smartcore backend:** `Knn` (k-nearest-neighbours),
+  `Svc` (support vector classifier, linear or RBF, one-vs-one for multiclass),
+  and `NaiveBayes` (Gaussian). All implement the same `Estimator`/`Predictor`
+  contract, so they drop into pipelines, ensembles, and search unchanged — and
+  they are exposed to Python too (`mw.Knn`, `mw.Svc` / `mw.Svc.rbf()`,
+  `mw.NaiveBayes`, plus `pipe.knn()` / `pipe.svc()` / `pipe.naive_bayes()`).
+- **Python: a scikit-learn-shaped object API.** `mw.Frame` with `from_pandas` /
+  `from_numpy` / `from_rows` ingest; composable transformer/estimator objects
+  (`StandardScaler`, `MinMaxScaler`, `SimpleImputer`, `OneHotEncoder`,
+  `RandomForest`, `LinearRegression`) added via `pipe.step(name, obj)` /
+  `pipe.estimator(name, obj)`; `fit`/`predict`/`evaluate` accept a `Frame`.
+- **Python: `pipeline.explain(...)`** returns SHAP feature importance
+  (`Explainer.kernel()` configurable), and **`pipeline.export_onnx(path)`**
+  writes the fitted pipeline to a single ONNX file. The `python` wheel now
+  bundles the `model-selection`, `explain`, and `onnx` engines.
+- **Python: `GridSearch` / `KFold` / `StratifiedKFold`** over a pipeline, with
+  a `SearchResult` (`best_score`, `best_params()`, `predict()`).
+- **`InferenceModel` is now an `Estimator` + `Predictor`**, so a pre-trained
+  ONNX model (from scikit-learn, PyTorch, …) can be dropped into a `Pipeline`
+  as a frozen estimator behind Millwright's preprocessing — in Rust and, via
+  `mw.OnnxModel(path)`, from Python.
+- **Python: `mw.Table` + `mw.Profile`** — dtype-aware CSV/Parquet ingest and
+  automated EDA (`Profile.of(table_or_frame).to_html(path)`). The wheel now
+  bundles the `eda` (polars) engine, so it is larger than the pure-model build.
+- **`Table::from_frame`** (Rust): build a numeric `Table` from a `Frame`, so the
+  numeric world can round-trip back into the typed one (e.g. to profile it).
+- **Richer EDA in `Profile`** — excess `kurtosis` and z-score outlier counts per
+  numeric column; a **Spearman** rank-correlation matrix beside the Pearson one;
+  a **co-missing** map (columns whose null patterns correlate); high-cardinality
+  categoricals now suggest `TargetEncoder`; and `suggest_pipeline` adds a
+  train-time **SMOTE** balancer on class imbalance (with `preprocessing`).
+- **AutoML is seeded by EDA.** With the `eda` engine on, the search fixes its
+  preprocessing to `Profile::suggest_pipeline()` and varies only the model,
+  pruning the space (it falls back to a scaler sweep without `eda`).
+
+### Fixed
+- **Cross-validated F1 no longer returns `NaN`.** A fold whose predictions
+  contain no true positives left smartcore's F1 evaluating `0/0`; a single NaN
+  fold poisoned the CV mean and a search's `best_score`. An undefined F1 is now
+  0.0 (scikit-learn's `zero_division=0` convention), so `GridSearch(...).scoring(F1)`
+  yields finite, comparable scores.
+
+## [0.1.1]
+
+### Added
+
+- **`LogisticRegression`** — a native, core binary classifier with genuine
+  `predict_proba`: the framework's first real `ProbaPredictor`.
+- **`calibration` feature** — `PlattScaling`, `IsotonicRegression`,
+  `reliability_curve`, and `CalibratedClassifier`, which wraps any
+  `ProbaPredictor` and returns calibrated probabilities.
+- **`anomaly` feature** — `Mahalanobis` and `KnnScore`, unified behind an
+  `OutlierDetector` trait.
+- **`eda` feature** — a polars-backed, dtype-aware `Table` (CSV/Parquet ingest
+  that lowers to the numeric `Frame`) and a typed `Profile` with an HTML report,
+  actionable alerts, and `suggest_pipeline()`.
+- **Transformers** — `Winsorize`, `PowerTransform` (Yeo-Johnson),
+  `ColumnTransformer`, and the supervised `TargetEncoder`.
+- **Convenience** — `Frame::from_csv` (dependency-free numeric loader),
+  `Table::head`.
+- **Python** — `min_max_scaler`, `simple_imputer`, `one_hot`,
+  `linear_regression`, and `evaluate()`.
+- **Examples** — `explore` (ingest → profile → pipeline) and `trust`
+  (calibration → reliability → anomaly detection).
+- **Benchmarks** — `benches/throughput.rs` (criterion): the boundary conversion
+  and core fit/predict, backing the "Rust speed" claim.
+- **One-hot ingest** — `Table::to_frame_with` / `into_dataset_with` and a
+  `CategoryEncoding` enum: lower nominal categories to 0/1 indicator columns
+  instead of ordinal codes.
+- **Schema-aware preprocessing** — `Frame` carries a per-column `Dtype`; `Table`
+  marks categoricals as it lowers; scalers / `Winsorize` / `PowerTransform` pass
+  categorical columns through untouched, and `OneHotEncoder` encodes by dtype
+  rather than a value heuristic when the schema is known.
+- **Real-data validation** — an end-to-end integration test on Quinlan's
+  PlayTennis (`tests/real_data.rs`): CSV → profile → suggested pipeline → fit.
+
+### Changed
+
+- Exact-version pins on every engine crate; `Cargo.lock` committed; a
+  feature-matrix CI (fmt, clippy `-D warnings`, docs, matrix, OS, examples,
+  benches, publish dry-run, wheel).
+- `selection.rs` split into `selection/{scoring,cv,search}`.
+- MSRV is **1.95** (dep-dictated — `sysinfo` via tract, and polars); enforced by
+  cargo via `rust-version` rather than a dedicated CI job (which would break on
+  every transitive bump). The default install needs 1.85.
+- De-staled the crate and module docs (no more "Phase 0 · the spine").
+
+### Fixed
+
+- Golden tests and the crate doctest build under every feature subset (they were
+  unconditionally referencing backend-gated types).
+- Float sorts use `f64::total_cmp`, closing a NaN-driven panic class.
+
+## [0.1.0]
+
+- Phases 0–8: the `Frame`/trait spine and smartcore backend, preprocessing and
+  model selection, a second backend (linfa) and HPO, evaluation/diagnostics/
+  explainability, ONNX export and inference, serving + drift monitoring + a model
+  registry, time-series and out-of-core estimators, AutoML, and 1.0 hardening.

millwright-0.2.0/CONTRIBUTING.md

@@ -0,0 +1,55 @@
+# Contributing to Millwright
+
+Thanks for your interest! Millwright assembles proven Rust crates into one
+composable ML lifecycle. Bug reports, small fixes, and focused features are all
+welcome.
+
+## Getting set up
+
+```bash
+git clone https://github.com/mi7plus/millwright
+cd millwright
+cargo test              # default features
+```
+
+Rust **1.95+** is required (the floor is dictated by transitive engine deps).
+
+## Before you open a PR
+
+The CI is a feature matrix, so run the same checks locally:
+
+```bash
+cargo fmt --all --check
+cargo clippy --features full --all-targets -- -D warnings
+cargo test --features full
+cargo test --no-default-features            # the bare-core build must pass too
+cargo doc --no-deps --features full         # with RUSTDOCFLAGS="-D warnings"
+```
+
+- **Every capability is a cargo feature.** New functionality behind a young
+  single-author crate goes behind its own feature; the core stays lean. See the
+  feature list in `Cargo.toml`.
+- **Engines are pinned to exact versions** (`=x.y.z`) and `Cargo.lock` is
+  committed — bump them deliberately, one line, one commit.
+- **Add tests.** Prefer a `#[test]` next to the code; lock numeric behaviour in
+  `tests/golden.rs` when it matters. Feature-gate tests that need a backend.
+- **Run the examples** you touch: `cargo run --features full --example <name>`.
+
+## Try it out
+
+- Examples: [`examples/`](examples) — one runnable program per feature group.
+- Benchmarks: `cargo bench --features smartcore-backend`.
+- Docs/tutorial: <https://millwright-rs.dev/docs/>.
+
+## Releasing
+
+Maintainers: bump `Cargo.toml` + `pyproject.toml`, roll `CHANGELOG.md`, and tag
+`vX.Y.Z` — the workflows publish to crates.io and PyPI via OIDC. The helper
+`scripts/release.sh X.Y.Z` does the mechanical steps. See
+[`RELEASING.md`](RELEASING.md).
+
+## Scope & conduct
+
+Millwright is a thin facade over proven engines — it orchestrates, it doesn't
+reimplement numerics. Please keep PRs focused, and be kind and constructive in
+issues and reviews.

{millwright-0.1.1 → millwright-0.2.0}/Cargo.lock

@@ -1935,7 +1935,7 @@ dependencies = [
 
 [[package]]
 name = "millwright"
-version = "0.1.1"
+version = "0.2.0"
 dependencies = [
  "axum",
  "chronos-ts",
@@ -1957,6 +1957,7 @@ dependencies = [
  "plotters-statistical",
  "polars",
  "pyo3",
+ "rayon",
  "regression-diagnostics",
  "serde",
  "serde_json",

{millwright-0.1.1 → millwright-0.2.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "millwright"
-version = "0.1.1"
+version = "0.2.0"
 edition = "2021"
 rust-version = "1.95"
 description = "A unified ML framework for Rust — proven Rust crates, assembled into one machine."
@@ -56,6 +56,7 @@ polars = { version = "=0.55.2", default-features = false, features = ["csv", "pa
 # --- general infrastructure: caret ranges, reproduced via Cargo.lock ---
 pyo3 = { version = "0.24", features = ["extension-module", "abi3-py39"], optional = true }
 ndarray = { version = "0.16", optional = true }
+rayon = { version = "1", optional = true }
 plotters = { version = "0.3.7", default-features = false, features = ["svg_backend", "all_series"], optional = true }
 tract-onnx = { version = "0.23", optional = true }
 axum = { version = "0.8", optional = true }
@@ -90,11 +91,13 @@ smartcore-backend = ["dep:smartcore"]
 preprocessing = ["dep:imbalance-rs", "dep:ndarray"]
 
 # Cross-validation splitters, scoring, and grid/random search over a pipeline.
-model-selection = ["dep:model-selection-rs", "dep:ndarray"]
+# CV folds and search candidates are evaluated in parallel via rayon.
+model-selection = ["dep:model-selection-rs", "dep:ndarray", "dep:rayon"]
 
 # Voting / bagging / stacking meta-estimators, composed over the four traits.
-# Leak-free stacking uses the model-selection CV engine when it is enabled.
-ensemble = []
+# Leak-free stacking uses the model-selection CV engine when it is enabled;
+# bagging fits its base estimators in parallel via rayon.
+ensemble = ["dep:rayon"]
 
 # Ingest & EDA — the front of the lifecycle. A polars-backed, dtype-aware
 # `Table` (CSV/Parquet in, real string/categorical/datetime/null columns) that
@@ -151,7 +154,7 @@ onnx = [
 # Deliberately NOT part of `full`: pyo3's `extension-module` defers libpython
 # symbols, so a plain `cargo test`/`clippy` cannot link a test binary with it.
 # Build & test this feature through maturin instead (see pyproject.toml).
-python = ["dep:pyo3", "smartcore-backend"]
+python = ["dep:pyo3", "smartcore-backend", "model-selection", "explain", "onnx", "eda"]
 
 # Phase 5 · OPERATIONS — past where scikit-learn stops.
 # A versioned model registry: content-addressed ONNX artifact + metadata +

millwright-0.2.0/GUIDE.md

@@ -0,0 +1,41 @@
+# The Millwright Guide
+
+*A unified ML framework for Rust — ten crates, one lifecycle.*
+
+The full hands-on tutorial now lives as a browsable, multi-page site:
+
+### → **[millwright-rs.dev/docs/](https://millwright-rs.dev/docs/)**  (source in [`docs/`](docs/index.html))
+
+It walks the whole lifecycle, one topic per page: **Data & EDA** · **Pipelines &
+Models** · **Insight** (evaluate, explain, calibrate, detect) · **Deploy**
+(ONNX, serving, registry, AutoML) · **Python**.
+
+## Quickstart
+
+```toml
+[dependencies]
+millwright = "0.1"          # or features = ["full"] for the whole lifecycle
+```
+
+```rust
+use millwright::prelude::*;
+
+// features as rows + a target -> a Dataset
+let train = Dataset::new(x, y)?;
+
+// standardize, then a random forest — one composable object
+let mut pipe = Pipeline::new()
+    .step("scale", StandardScaler::new())
+    .estimator("rf", RandomForest::new());
+
+pipe.fit(&train)?;
+let preds = pipe.predict(&test)?;
+```
+
+## Where to go
+
+- **Tutorial:** <https://millwright-rs.dev/docs/> — the full, hands-on walk-through.
+- **API reference:** [docs.rs/millwright](https://docs.rs/millwright).
+- **Design brief (the *why*):** <https://millwright-rs.dev/>.
+- **Examples:** [`examples/`](examples) — a runnable program for each feature group.
+- **Python:** [`pip install millwright`](https://pypi.org/project/millwright/).

{millwright-0.1.1 → millwright-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: millwright
-Version: 0.1.1
+Version: 0.2.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Intended Audience :: Science/Research
@@ -16,10 +16,19 @@ Project-URL: Repository, https://github.com/mi7plus/millwright
 
 # millwright
 
+[![crates.io](https://img.shields.io/crates/v/millwright.svg)](https://crates.io/crates/millwright)
+[![docs.rs](https://img.shields.io/docsrs/millwright)](https://docs.rs/millwright)
+[![PyPI](https://img.shields.io/pypi/v/millwright.svg)](https://pypi.org/project/millwright/)
+[![CI](https://github.com/mi7plus/millwright/actions/workflows/ci.yml/badge.svg)](https://github.com/mi7plus/millwright/actions/workflows/ci.yml)
+[![downloads](https://img.shields.io/crates/d/millwright.svg)](https://crates.io/crates/millwright)
+[![license](https://img.shields.io/crates/l/millwright.svg)](LICENSE)
+
 A unified ML framework for Rust — *ten crates, one lifecycle.*
 
-- **Tutorial:** [`GUIDE.md`](GUIDE.md) — the hands-on walk through the whole
-  lifecycle (also as a page: [`guide.html`](guide.html)).
+- **Tutorial:** the hands-on docs site at <https://millwright-rs.dev/docs/>
+  (source in [`docs/`](docs/index.html); a short [`GUIDE.md`](GUIDE.md) has the
+  quickstart).
+- **Contributing:** see [`CONTRIBUTING.md`](CONTRIBUTING.md).
 - **Design brief:** the *why*, at **<https://millwright-rs.dev/>**.
 
 > *"Ten crates"* is the ecosystem this project assembles —

{millwright-0.1.1 → millwright-0.2.0}/README.md

@@ -1,9 +1,18 @@
 # millwright
 
+[![crates.io](https://img.shields.io/crates/v/millwright.svg)](https://crates.io/crates/millwright)
+[![docs.rs](https://img.shields.io/docsrs/millwright)](https://docs.rs/millwright)
+[![PyPI](https://img.shields.io/pypi/v/millwright.svg)](https://pypi.org/project/millwright/)
+[![CI](https://github.com/mi7plus/millwright/actions/workflows/ci.yml/badge.svg)](https://github.com/mi7plus/millwright/actions/workflows/ci.yml)
+[![downloads](https://img.shields.io/crates/d/millwright.svg)](https://crates.io/crates/millwright)
+[![license](https://img.shields.io/crates/l/millwright.svg)](LICENSE)
+
 A unified ML framework for Rust — *ten crates, one lifecycle.*
 
-- **Tutorial:** [`GUIDE.md`](GUIDE.md) — the hands-on walk through the whole
-  lifecycle (also as a page: [`guide.html`](guide.html)).
+- **Tutorial:** the hands-on docs site at <https://millwright-rs.dev/docs/>
+  (source in [`docs/`](docs/index.html); a short [`GUIDE.md`](GUIDE.md) has the
+  quickstart).
+- **Contributing:** see [`CONTRIBUTING.md`](CONTRIBUTING.md).
 - **Design brief:** the *why*, at **<https://millwright-rs.dev/>**.
 
 > *"Ten crates"* is the ecosystem this project assembles —

{millwright-0.1.1 → millwright-0.2.0}/RELEASING.md

@@ -3,7 +3,19 @@
 Millwright ships as one Rust crate (crates.io) and one Python wheel (PyPI), from
 the same source.
 
-## Preflight
+## The easy way
+
+With `main` green and `CHANGELOG.md`'s `[Unreleased]` section filled in, run:
+
+```bash
+bash scripts/release.sh 0.1.2
+```
+
+It bumps both manifests, rolls the changelog, syncs `Cargo.lock`, verifies the
+package, commits, tags `v0.1.2`, and (after a prompt) pushes — which triggers the
+publish workflows below. The rest of this file is the manual equivalent.
+
+## Preflight (manual)
 
 1. `main` is green in CI and `CHANGELOG.md`'s `[Unreleased]` section is current.
 2. Bump the version in **both** `Cargo.toml` and `pyproject.toml`, move the

millwright-0.2.0/docs/data.html

@@ -0,0 +1,114 @@
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Millwright · Data &amp; EDA</title>
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<link rel="stylesheet" href="site.css">
+</head><body><header class="top">
+  <div class="wrap">
+    <div class="brand"><a href="../index.html"><span class="mark">⚙</span>millwright</a><span class="ver">docs</span></div>
+    <nav>
+      <a href="index.html">home</a>
+      <a href="data.html" class="active">data &amp; EDA</a>
+      <a href="pipelines.html">pipelines</a>
+      <a href="insight.html">insight</a>
+      <a href="deploy.html">deploy</a>
+      <a href="python.html">python</a>
+      <a href="../index.html">design brief</a>
+      <a class="repo" href="https://github.com/mi7plus/millwright">GitHub ↗</a>
+    </nav>
+  </div>
+</header>
+
+<main>
+  <div class="wrap">
+    <div class="hero">
+      <div class="eyebrow">01 · data &amp; EDA</div>
+      <h1>The boundary type,<br>and the typed layer in front of it.</h1>
+      <p class="lede"><code class="inl">Frame</code> is the numeric boundary the whole API speaks. <code class="inl">Table</code> (feature <code class="inl">eda</code>) is the polars-backed, dtype-aware world that ingests real CSV/Parquet and lowers into it.</p>
+    </div>
+  </div>
+
+  <!-- FRAME -->
+  <section id="frame">
+    <div class="wrap">
+      <div class="head col">
+        <div class="eyebrow">Frame &amp; Dataset</div>
+        <h2>One contiguous <span class="mono">f64</span> buffer, plus a schema.</h2>
+        <p class="muted">Everything the <em>public</em> API speaks is a <code class="inl">Frame</code>: a contiguous, row-major <code class="inl">f64</code> buffer with named columns. It is what lets a linfa model and a smartcore <code class="inl">DenseMatrix</code> meet in one signature without your code ever naming their array versions — each backend converts <code class="inl">Frame</code> ⇄ its native type inside the adapter only. A <code class="inl">Dataset</code> pairs a frame with a target.</p>
+      </div>
+<pre><span class="k">use</span> millwright::prelude::*;
+
+<span class="k">let</span> x = <span class="f">Frame</span>::from_rows(
+    <span class="f">vec!</span>[<span class="f">vec!</span>[<span class="k">0.0</span>, <span class="k">0.1</span>], <span class="f">vec!</span>[<span class="k">0.4</span>, <span class="k">0.2</span>], <span class="f">vec!</span>[<span class="k">9.0</span>, <span class="k">9.1</span>], <span class="f">vec!</span>[<span class="k">9.4</span>, <span class="k">8.7</span>]],
+    <span class="f">vec!</span>[<span class="s">"a"</span>.into(), <span class="s">"b"</span>.into()],
+)?;
+<span class="k">assert_eq!</span>(x.shape(), (<span class="k">4</span>, <span class="k">2</span>));        <span class="c">// (rows, cols)</span>
+
+<span class="k">let</span> train = <span class="f">Dataset</span>::new(x.clone(), <span class="f">vec!</span>[<span class="k">0.0</span>, <span class="k">0.0</span>, <span class="k">1.0</span>, <span class="k">1.0</span>])?;
+<span class="k">let</span> _features = train.features();  <span class="c">// &Frame</span>
+<span class="k">let</span> _target   = train.target();    <span class="c">// &[f64]</span></pre>
+      <p class="tiny">The task — classification vs. regression — is inferred from the target: an all-integral target is class labels, anything else is regression. A pure-numeric CSV loads directly with <code class="inl">Frame::from_csv</code>; typed data uses <code class="inl">Table</code> below.</p>
+    </div>
+  </section>
+
+  <!-- INGEST -->
+  <section id="ingest">
+    <div class="wrap">
+      <div class="head col">
+        <div class="eyebrow">Ingest &amp; explore</div>
+        <h2><span class="mono">Table</span> reads it, <span class="mono">Profile</span> reports it.</h2>
+        <p class="muted">Behind the <code class="inl">eda</code> feature, a polars-backed <code class="inl">Table</code> reads real CSV/Parquet — strings, categories, dates, booleans, nulls — and a <code class="inl">Profile</code> returns a <em>typed</em> analysis (not just an HTML blob) and drafts the preprocessing.</p>
+      </div>
+<pre><span class="k">let</span> table = <span class="f">Table</span>::from_csv(<span class="s">"customers.csv"</span>)?;   <span class="c">// or ::from_parquet(…)</span>
+
+<span class="c">// a typed profile — overview, per-column stats, missingness, correlations, alerts</span>
+<span class="k">let</span> profile = <span class="f">Profile</span>::of_with_target(&amp;table, <span class="s">"churned"</span>)?;
+<span class="f">println!</span>(<span class="s">"{}"</span>, profile.summary());
+<span class="k">for</span> alert <span class="k">in</span> profile.alerts() {
+    <span class="f">println!</span>(<span class="s">"{alert}"</span>);   <span class="c">// "[city] categorical (3 levels) → OneHotEncoder"</span>
+}
+profile.to_html(<span class="s">"eda_report.html"</span>)?;             <span class="c">// a shareable report</span></pre>
+      <p class="muted">Because Millwright owns EDA <em>and</em> the pipeline, the profile drafts the starting preprocessing from its own findings — the loop scikit-learn can't close:</p>
+<pre><span class="c">// lower the typed table to the numeric world</span>
+<span class="k">let</span> train = table.into_dataset(<span class="s">"churned"</span>)?;   <span class="c">// categoricals encoded, nulls → NaN</span>
+
+<span class="c">// EDA drafts the pipeline; you just add the model</span>
+<span class="k">let mut</span> pipe = profile.suggest_pipeline()        <span class="c">// impute · encode · scale, from the alerts</span>
+    .estimator(<span class="s">"rf"</span>, <span class="f">RandomForest</span>::new());
+pipe.fit(&amp;train)?;</pre>
+      <p class="run">cargo run --example explore --features "eda smartcore-backend"</p>
+    </div>
+  </section>
+
+  <!-- DTYPES -->
+  <section id="dtypes">
+    <div class="wrap">
+      <div class="head col">
+        <div class="eyebrow">Dtype-aware</div>
+        <h2>Types flow through the pipeline.</h2>
+        <p class="muted">A <code class="inl">Frame</code> carries a per-column <code class="inl">Dtype</code> (defaulting to <code class="inl">Numeric</code>). <code class="inl">Table</code> marks the columns it knows are <code class="inl">Categorical</code> as it lowers — so preprocessing doesn't have to <em>guess</em>: scalers, <code class="inl">Winsorize</code>, and <code class="inl">PowerTransform</code> pass categorical columns through untouched, and <code class="inl">OneHotEncoder</code> encodes by dtype rather than a value heuristic.</p>
+      </div>
+<pre><span class="c">// a genuinely-integer feature is NOT wrongly one-hot'd; the categorical one is</span>
+<span class="k">let</span> f = <span class="f">Frame</span>::from_rows(rows, cols)?
+    .with_dtypes(<span class="f">vec!</span>[<span class="f">Dtype</span>::Categorical, <span class="f">Dtype</span>::Numeric])?;
+<span class="k">let</span> out = <span class="f">OneHotEncoder</span>::infer().fit_transform(&amp;f)?;   <span class="c">// expands only column 0</span>
+
+<span class="c">// or one-hot at the Table boundary, with real category names</span>
+<span class="k">let</span> train = table.into_dataset_with(<span class="s">"churned"</span>, <span class="f">CategoryEncoding</span>::OneHot)?;</pre>
+      <p class="tiny">Nominal categories become <code class="inl">"{col}={value}"</code> indicator columns instead of ordinal codes — the correct representation for linear and tree models.</p>
+    </div>
+  </section>
+
+  <div class="wrap">
+    <div class="pager">
+      <a href="index.html"><span class="dir">← prev</span><b>Home</b></a>
+      <a class="next" href="pipelines.html"><span class="dir">next →</span><b>Pipelines &amp; Models</b></a>
+    </div>
+  </div>
+</main>
+
+<footer>
+  <div class="wrap">
+    <span class="mono">⚙ millwright docs</span>
+    <span class="mono"><a href="../index.html">design brief</a> · <a href="https://crates.io/crates/millwright">crates.io</a> · <a href="https://pypi.org/project/millwright/">PyPI</a> · <a href="https://docs.rs/millwright">docs.rs</a> · <a href="https://github.com/mi7plus/millwright">GitHub</a></span>
+  </div>
+</footer>
+</body></html>

millwright-0.2.0/docs/deploy.html

@@ -0,0 +1,134 @@
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Millwright · Deploy</title>
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<link rel="stylesheet" href="site.css">
+</head><body><header class="top">
+  <div class="wrap">
+    <div class="brand"><a href="../index.html"><span class="mark">⚙</span>millwright</a><span class="ver">docs</span></div>
+    <nav>
+      <a href="index.html">home</a>
+      <a href="data.html">data &amp; EDA</a>
+      <a href="pipelines.html">pipelines</a>
+      <a href="insight.html">insight</a>
+      <a href="deploy.html" class="active">deploy</a>
+      <a href="python.html">python</a>
+      <a href="../index.html">design brief</a>
+      <a class="repo" href="https://github.com/mi7plus/millwright">GitHub ↗</a>
+    </nav>
+  </div>
+</header>
+
+<main>
+  <div class="wrap">
+    <div class="hero">
+      <div class="eyebrow">04 · deploy</div>
+      <h1>Past where<br>scikit-learn stops.</h1>
+      <p class="lede">Export to one portable ONNX artifact, serve a drift-monitored endpoint, version every model with its lineage, and — the framework pointed at itself — let AutoML search for the best <em>deployable</em> pipeline.</p>
+    </div>
+  </div>
+
+  <!-- ONNX -->
+  <section id="onnx">
+    <div class="wrap">
+      <div class="head col">
+        <div class="eyebrow">Portability</div>
+        <h2>ONNX in and out.</h2>
+        <p class="muted">With <code class="inl">onnx</code>, any model — or a whole pipeline — exports to one <code class="inl">.onnx</code> file. Whole-pipeline export folds leading affine scalers into the estimator's graph: raw features in, predictions out. <code class="inl">InferenceModel::load</code> runs any ONNX file back through tract.</p>
+      </div>
+<pre><span class="k">let mut</span> pipe = <span class="f">Pipeline</span>::new()
+    .step(<span class="s">"scale"</span>, <span class="f">StandardScaler</span>::new())
+    .estimator(<span class="s">"lr"</span>, <span class="f">LinearRegression</span>::new());
+pipe.fit(&amp;train)?;
+<span class="k">let</span> native = pipe.predict(&amp;probe)?;
+
+pipe.export_onnx(<span class="s">"pipeline.onnx"</span>)?;                 <span class="c">// scaler + model, one graph</span>
+<span class="k">let</span> model = <span class="f">InferenceModel</span>::load(<span class="s">"pipeline.onnx"</span>)?;
+<span class="k">let</span> via_onnx = model.predict(&amp;probe)?;              <span class="c">// matches `native`</span></pre>
+      <p class="tiny">Linear/affine/pipeline graphs run inside tract for a full round-trip. A random forest exports to a valid ONNX-ML tree-ensemble artifact for external runtimes (onnxruntime); tract implements NN ops, not the ONNX-ML tree ops.</p>
+      <p class="run">cargo run --example portability --features "smartcore-backend onnx"</p>
+    </div>
+  </section>
+
+  <!-- OPERATE -->
+  <section id="operate">
+    <div class="wrap">
+      <div class="head col">
+        <div class="eyebrow">Operations</div>
+        <h2>Registry, drift, serving.</h2>
+        <p class="muted">The <code class="inl">registry</code> versions the ONNX artifact (content-addressed, with a reference distribution and movable tags); <code class="inl">monitor</code> watches the prediction stream for PSI drift; <code class="inl">serve</code> exposes a validated endpoint that feeds the monitor.</p>
+      </div>
+<pre><span class="k">let</span> reg = <span class="f">Registry</span>::local(<span class="s">"./models"</span>);
+<span class="k">let</span> v1 = reg.register(<span class="s">"demand"</span>, &amp;model, <span class="f">Metadata</span> {
+    metrics: <span class="f">vec!</span>[(<span class="s">"r2"</span>.into(), <span class="k">1.0</span>)],
+    reference: reference.clone(),   <span class="c">// the distribution drift watches against</span>
+    note: <span class="s">"baseline"</span>.into(),
+})?;
+reg.tag(<span class="s">"demand"</span>, &amp;v1.id, <span class="s">"prod"</span>)?;
+<span class="k">let</span> reverted = reg.rollback(<span class="s">"demand"</span>, <span class="s">"prod"</span>)?;   <span class="c">// revert in one line</span>
+
+<span class="c">// serve the prod artifact, watching for drift on every request</span>
+<span class="f">Server</span>::from_onnx(reg.onnx_path(<span class="s">"demand"</span>, <span class="s">"prod"</span>)?)?
+    .route(<span class="s">"/predict"</span>)
+    .with_monitor(<span class="f">DriftMonitor</span>::psi(&amp;reference)?)
+    .serve(<span class="s">"0.0.0.0:8080"</span>).<span class="k">await</span>?;         <span class="c">// POST /predict, GET /metrics</span></pre>
+      <p class="run">cargo run --example operations --features "onnx registry monitor serve"</p>
+    </div>
+  </section>
+
+  <!-- SPECIALIZED -->
+  <section id="specialized">
+    <div class="wrap">
+      <div class="head col">
+        <div class="eyebrow">Specialized shapes</div>
+        <h2>Time series &amp; out-of-core.</h2>
+        <p class="muted">Same contract, different data shapes — each gets its own trait. These two crates pin <code class="inl">ndarray 0.15</code> while the rest of the stack uses <code class="inl">0.16</code>; Cargo links both and converts only inside the adapters.</p>
+      </div>
+<pre><span class="c">// time series (feature = "timeseries")</span>
+<span class="k">let mut</span> arima = <span class="f">AutoArima</span>::new().max_p(<span class="k">3</span>).max_q(<span class="k">3</span>);
+arima.fit(&amp;series)?;                  <span class="c">// &[f64]</span>
+<span class="k">let</span> forecast = arima.forecast(<span class="k">6</span>)?;   <span class="c">// six steps ahead</span>
+
+<span class="c">// out-of-core (feature = "incremental") — never holds the whole set in memory</span>
+<span class="k">let mut</span> model = <span class="f">IncrementalLinear</span>::with_rate(<span class="k">0.05</span>, <span class="k">0.0</span>);
+<span class="k">for</span> batch <span class="k">in</span> batches {
+    model.partial_fit(&amp;batch)?;      <span class="c">// one batch at a time</span>
+}</pre>
+      <p class="run">cargo run --example specialized --features "timeseries incremental"</p>
+    </div>
+  </section>
+
+  <!-- AUTOML -->
+  <section id="automl">
+    <div class="wrap">
+      <div class="head col">
+        <div class="eyebrow">Synthesis</div>
+        <h2>AutoML — the framework, pointed at itself.</h2>
+        <p class="muted">Profiling, preprocessing, CV, search, and ensembling are exactly what an AutoML engine needs — so <code class="inl">AutoML</code> is not a bolt-on, it is the framework orchestrating its own parts. Point it at data and a budget; get a leaderboard and the best <em>deployable</em> model.</p>
+      </div>
+<pre><span class="k">let</span> result = <span class="f">AutoML</span>::classifier()      <span class="c">// or ::regressor()</span>
+    .budget(<span class="f">Budget</span>::trials(<span class="k">20</span>))         <span class="c">// or Budget::minutes(10)</span>
+    .metric(<span class="f">Metric</span>::F1)
+    .cv(<span class="f">StratifiedKFold</span>::new(<span class="k">5</span>))
+    .seed(<span class="k">0</span>)
+    .fit(&amp;train)?;
+
+<span class="f">println!</span>(<span class="s">"{}"</span>, result.leaderboard());
+result.export_onnx(<span class="s">"model.onnx"</span>)?;   <span class="c">// deployable — unlike a TPOT object</span></pre>
+      <p class="run">cargo run --example automl --features "automl onnx"</p>
+    </div>
+  </section>
+
+  <div class="wrap">
+    <div class="pager">
+      <a href="insight.html"><span class="dir">← prev</span><b>Insight</b></a>
+      <a class="next" href="python.html"><span class="dir">next →</span><b>Python</b></a>
+    </div>
+  </div>
+</main>
+
+<footer>
+  <div class="wrap">
+    <span class="mono">⚙ millwright docs</span>
+    <span class="mono"><a href="../index.html">design brief</a> · <a href="https://crates.io/crates/millwright">crates.io</a> · <a href="https://pypi.org/project/millwright/">PyPI</a> · <a href="https://docs.rs/millwright">docs.rs</a> · <a href="https://github.com/mi7plus/millwright">GitHub</a></span>
+  </div>
+</footer>
+</body></html>