Compute — the pipeline, and the call

Data science isn't the model — it's the machinery that turns data into a decision. Below is one data pipeline, driven from any angle: the Executive view for the call it produces, Engineer or Analyst for how it's built, the modelling workflow it feeds, and the real thing running live at the bottom.

Related craft: the abstract patterns beneath this — a transform pipeline, a running mean, a single neuron — in Python, C, C++, and C#, and a from-scratch SVM in C++ (SMO + pybind11).

The data pipeline, as an object

One abstract pipeline, no scrolling. The role (what's shown), industry, source (CSV / SQL / API), model, and threshold all reshape the object and its output. The architecture is real (@dataclass abstract classes, composed, a scikit-learn ColumnTransformer + StandardScaler under the hood) — and the cell at the very bottom runs it live in the browser (Pyodide, free CDN, $0), ending in a decision, not a metric.

role

industry

source

model

threshold$5,000

Manufacturing · from CSV · Regressor — the object these toggles compose:

# Manufacturing: ingest, wrangle, compose — put to use
repo = CsvRepository("changeover_events.csv")
service = WranglingService(numeric=["per_year", "avg_min"],
                           categorical=["line", "cause"])
pipe    = ModelPipeline(repo, service, model=HistGradientBoostingRegressor())

The pipeline's output for Manufacturing — the artifact a decision is made from. With a regressor, you get the ranked scorecard above — the drivers, in order. Drag the threshold to move the cut.

cause	recoverable $/yr
tool search	$11,527
first-piece rework	$10,798
material wait	$7,410
calibration	$3,562
paperwork	$2,280

Decision3 causes clear your $5,000 cutoff — fix them in dollar order; the rest can wait.

The modelling workflow it feeds — feature engineering → split → train → validate → select → deploy

predict changeover minutes · regression

Feature engineeringpandas

X = events.assign(prev_family=events.family.shift(),
              same_tool=events.tool.eq(events.tool.shift()))

Turn raw line events into per-changeover features: line, product family, shift, prior product, tooling class.

Put it to use — a real scikit-learn pipeline, run in your browser (and it ends in a decision)

Executes the regressor through the same ColumnTransformer + StandardScaler, entirely in your browser (Pyodide). First Run downloads scikit-learn once — heavier than pandas alone, but still $0 and offline after. Edit and re-run.

import warnings; warnings.filterwarnings("ignore")
import numpy as np, pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.pipeline import Pipeline

# synthetic changeover data: numeric + categorical features, a target, a class
rng = np.random.default_rng(0); n = 240
df = pd.DataFrame({
    "avg_min":  rng.normal(18, 5, n).clip(2).round(1),
    "per_year": rng.integers(50, 600, n),
    "line":     rng.choice(["L1", "L2", "L3"], n),
})
df["minutes"] = (0.4*df.avg_min + 0.01*df.per_year
                 + df.line.map({"L1": 2, "L2": 6, "L3": 10}) + rng.normal(0, 3, n)).round(1)
df["slow"] = (df.minutes > df.minutes.median()).astype(int)     # a class, for NLDA
X = df[["avg_min", "per_year", "line"]]

# the wrangling service, as a real ColumnTransformer (dense output)
ct = ColumnTransformer([
    ("num", StandardScaler(),                        ["avg_min", "per_year"]),
    ("cat", OneHotEncoder(handle_unknown="ignore"),  ["line"]),
], sparse_threshold=0)

from sklearn.ensemble import HistGradientBoostingRegressor
pipe = Pipeline([("wrangle", ct),
                 ("model", HistGradientBoostingRegressor())]).fit(X, df.minutes)
df["predicted"] = pipe.predict(X)
by_line = df.groupby("line").predicted.mean().round(1).sort_values(ascending=False)
print("predicted changeover, by line (minutes):")
print(by_line.to_string())
gap = round(float(by_line.iloc[0] - by_line.iloc[-1]), 1)
print()
print(f"-> {by_line.index[0]} runs ~{gap} min longer than {by_line.index[-1]}.")
print(f"   Standardize {by_line.index[0]} first -- the biggest, most consistent lever.")

This is the public taste of the machinery. The full, client-facing demos — live and playable, with scorecards and write-ups — run behind the client sign-in: a growing marketplace of decision tools beyond the changeover work.