millwright 0.2.0__tar.gz → 0.2.1__tar.gz

{millwright-0.2.0 → millwright-0.2.1}/CHANGELOG.md

@@ -6,6 +6,32 @@ All notable changes to Millwright are recorded here. The format follows
 
 ## [Unreleased]
 
+## [0.2.1] - 2026-08-23
+
+### Added
+- **Exported forests now serve in Millwright.** `InferenceModel` runs linear / NN
+  ONNX graphs through tract as before, and evaluates the ONNX-ML tree-ensemble
+  ops tract doesn't implement (from an exported `RandomForest`) with a small
+  native interpreter. A model exported by Millwright always round-trips back into
+  `InferenceModel`/`Server` — forests included — while the artifact stays portable
+  to any ONNX runtime.
+- **Imputers and one-hot encoders are ONNX-exportable.** A `SimpleImputer` step
+  exports as `Where(IsNaN(x), fill, x)`; a `OneHotEncoder` step exports as a
+  per-column `Gather` → `Round` → `Equal` → `Cast` → `Concat` expansion (with the
+  graph input re-declared at the raw feature width). So the whole realistic
+  `impute → one-hot → scale → model` pipeline exports and serves as one graph —
+  through tract (linear) or the native interpreter (behind a forest), verified
+  identical to the in-memory pipeline. The pipeline export generalized from
+  folding one affine map to splicing an ordered chain of transformer "prefixes"
+  (new `Transformer::onnx_prefix`). Only steps with no ONNX form now error.
+- **`SearchResult::export_onnx`** — a `GridSearch`/`RandomSearch` winner can now
+  be exported to ONNX (it could only `predict` before). Backed by a new
+  object-safe `Estimator::to_onnx_proto` on `Pipeline`.
+- **`Server::from_registry(&reg, name, tag)`** and
+  **`DriftMonitor::from_registry(&version)`** — serve a tagged artifact straight
+  from a registry, and build a PSI monitor from the version's stored reference
+  distribution.
+
 ## [0.2.0] - 2026-08-23
 
 ### Added

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

@@ -1935,7 +1935,7 @@ dependencies = [
 
 [[package]]
 name = "millwright"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "axum",
  "chronos-ts",
@@ -1956,6 +1956,7 @@ dependencies = [
  "plotters",
  "plotters-statistical",
  "polars",
+ "prost 0.13.5",
  "pyo3",
  "rayon",
  "regression-diagnostics",

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

@@ -1,6 +1,6 @@
 [package]
 name = "millwright"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 rust-version = "1.95"
 description = "A unified ML framework for Rust — proven Rust crates, assembled into one machine."
@@ -57,6 +57,10 @@ polars = { version = "=0.55.2", default-features = false, features = ["csv", "pa
 pyo3 = { version = "0.24", features = ["extension-module", "abi3-py39"], optional = true }
 ndarray = { version = "0.16", optional = true }
 rayon = { version = "1", optional = true }
+# Decode a saved ONNX file back into the proto, to natively evaluate ONNX-ML ops
+# (tree ensembles) that tract does not implement. Same version onnx-export-rs
+# uses, so the generated proto types decode cleanly.
+prost = { version = "0.13", 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 }
@@ -146,6 +150,7 @@ onnx = [
     "onnx-export-rs/smartcore-compat",
     "dep:tract-onnx",
     "dep:ndarray",
+    "dep:prost",
     "smartcore-backend",
     "smartcore/serde",
 ]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: millwright
-Version: 0.2.0
+Version: 0.2.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Intended Audience :: Science/Research

{millwright-0.2.0 → millwright-0.2.1}/docs/deploy.html

@@ -71,6 +71,7 @@ reg.tag(<span class="s">"demand"</span>, &amp;v1.id, <span class="s">"prod"</spa
     .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 class="callout"><b>Serving any model.</b> The <code class="inl">Server</code> runs linear / NN ONNX graphs through <code class="inl">tract</code>, and evaluates ONNX-ML tree ensembles (a forest) with a small native interpreter — so a model exported by Millwright always serves in Millwright, and the artifact stays portable to any ONNX runtime.</div>
     </div>
   </section>
 

{millwright-0.2.0 → millwright-0.2.1}/index.html

@@ -381,7 +381,7 @@ grid! {
 <span class="c">// 1 — compose a pipeline: preprocessing + a model, one object</span>
 <span class="k">let</span> pipe = <span class="f">Pipeline</span>::new()
     .step(<span class="s">"impute"</span>, <span class="f">SimpleImputer</span>::median())
-    .step(<span class="s">"encode"</span>, <span class="f">OneHot</span>::infer())
+    .step(<span class="s">"encode"</span>, <span class="f">OneHotEncoder</span>::infer())
     .step(<span class="s">"scale"</span>,  <span class="f">StandardScaler</span>::new())
     .balance(<span class="f">Smote</span>::default())              <span class="c">// imbalance-rs · train-time only</span>
     .estimator(<span class="s">"rf"</span>, <span class="f">RandomForest</span>::new());
@@ -392,15 +392,15 @@ grid! {
     .scoring(<span class="f">Metric</span>::F1)
     .fit(&amp;train)?;
 
-<span class="c">// 3 — assess &amp; explain</span>
-<span class="k">let</span> report = model.evaluate(&amp;test)?;         <span class="c">// metrics + regression-diagnostics</span>
-<span class="k">let</span> shap   = model.explain(<span class="f">Explainer</span>::kernel(), &amp;test)?;   <span class="c">// shap-rs</span>
+<span class="c">// 3 — assess &amp; explain the best model</span>
+<span class="k">let</span> report = model.evaluate(&amp;test)?;         <span class="c">// accuracy · precision · recall · f1</span>
+<span class="k">let</span> shap   = model.explain(&amp;<span class="f">Explainer</span>::kernel(), test.features())?; <span class="c">// shap-rs</span>
 
 <span class="c">// 4 — ship it: one ONNX artifact, served, with drift on every request</span>
 model.export_onnx(<span class="s">"churn.onnx"</span>)?;           <span class="c">// onnx-export-rs</span>
 
-<span class="f">Server</span>::from_onnx(<span class="s">"churn.onnx"</span>)             <span class="c">// tract inference</span>
-    .with_monitor(<span class="f">DriftMonitor</span>::psi(&amp;train)) <span class="c">// driftwatch</span>
+<span class="f">Server</span>::from_onnx(<span class="s">"churn.onnx"</span>)?            <span class="c">// forests run natively in Millwright</span>
+    .with_monitor(<span class="f">DriftMonitor</span>::psi(&amp;reference)?) <span class="c">// driftwatch · training preds</span>
     .route(<span class="s">"/predict"</span>)
     .serve(<span class="s">"0.0.0.0:8080"</span>).<span class="k">await</span>?;         <span class="c">// axum</span></pre>
       <p class="tiny" style="margin-top:1rem">The <code class="inl">timeseries</code> feature swaps the estimator for a <span class="mono">chronos-ts</span> auto-ARIMA forecaster behind the same <code class="inl">fit</code>/<code class="inl">predict</code> contract; <code class="inl">incremental</code> swaps <code class="inl">.fit()</code> for <code class="inl">.partial_fit()</code> over batches that never fully load into memory.</p>
@@ -638,17 +638,17 @@ pipe.export_onnx(<span class="s">"churn.onnx"</span>)               <span class=
         <div>
           <h3>Register, serve, roll back</h3>
           <pre><span class="c">// version a trained pipeline — artifact + ONNX + metrics + lineage</span>
-<span class="k">let</span> v = <span class="f">Registry</span>::local(<span class="s">"./models"</span>)
-    .register(<span class="s">"churn"</span>, &amp;model)?
-    .tag(<span class="s">"prod"</span>);                        <span class="c">// a movable pointer</span>
+<span class="k">let</span> reg = <span class="f">Registry</span>::local(<span class="s">"./models"</span>);
+<span class="k">let</span> v = reg.register(<span class="s">"churn"</span>, &amp;model, meta)?;   <span class="c">// meta: metrics + reference dist</span>
+reg.tag(<span class="s">"churn"</span>, &amp;v.id, <span class="s">"prod"</span>)?;              <span class="c">// a movable pointer</span>
 
 <span class="c">// serve straight from the registry; the monitor uses the stored reference</span>
-<span class="f">Server</span>::from_registry(<span class="s">"churn"</span>, <span class="s">"prod"</span>)
-    .with_monitor(<span class="f">DriftMonitor</span>::from_registry(&amp;v))
+<span class="f">Server</span>::from_registry(&amp;reg, <span class="s">"churn"</span>, <span class="s">"prod"</span>)?
+    .with_monitor(<span class="f">DriftMonitor</span>::from_registry(&amp;v)?)
     .serve(<span class="s">"0.0.0.0:8080"</span>).<span class="k">await</span>?;
 
 <span class="c">// when drift fires: retrain on the recorded lineage — or revert in one line</span>
-<span class="f">Registry</span>::local(<span class="s">"./models"</span>).rollback(<span class="s">"churn"</span>, <span class="s">"prod"</span>)?;</pre>
+reg.rollback(<span class="s">"churn"</span>, <span class="s">"prod"</span>)?;</pre>
         </div>
         <div>
           <h3>Closing the loop</h3>

{millwright-0.2.0 → millwright-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "millwright"
-version = "0.2.0"
+version = "0.2.1"
 description = "A unified ML framework for Rust — Python bindings over the Rust core."
 readme = "README.md"
 requires-python = ">=3.9"

{millwright-0.2.0 → millwright-0.2.1}/src/monitor.rs

@@ -46,6 +46,15 @@ impl DriftMonitor {
         })
     }
 
+    /// Build a monitor from the reference distribution a registry [`Version`]
+    /// stored at registration time.
+    ///
+    /// [`Version`]: crate::registry::Version
+    #[cfg(feature = "registry")]
+    pub fn from_registry(version: &crate::registry::Version) -> Result<Self> {
+        Self::psi(&version.metadata.reference)
+    }
+
     /// Record a batch of live predictions.
     pub fn observe(&self, predictions: &[f64]) {
         self.live