Drop a CSV, Excel, JSON, or Parquet file. PrePro Auto reads it, detects the
encoding and delimiter automatically, and creates a job you can run the whole pipeline on.
Drop your file here
or click to browse · csv, xlsx, json, parquet · max 200 MB
Dataset type:
Step 2 of 4
Profile the data
Profiling infers each column's true type, missing rate, and quality, and detects
ordered categories. This must run before any cleaning stage.
Profiling your dataset…
Step 3 of 6
View dataset
A live view of your data at the current version. It updates after every
change anywhere — cleaning stages, transforms, undo/redo. Toggle between the original
(raw) data and the current state.
Original (raw)
Current
Step 4 of 6
Clean the data
Each stage proposes decisions. Approve, override, or skip each one, then execute the
stage to apply them and write a new snapshot. Stages run in order.
OverrideReject the recommendation and pick a different action from the dropdown (the alternatives PrePro Auto considered). Use this when you know better — for example, keep outliers PrePro Auto wanted to cap.
SkipLeave this column unchanged for this stage.
Step 5 of 6
Transform
Full manual control over the dataset: create, drop, rename, merge, cast, filter,
map, and apply math to columns and rows. Every transform is a new version — undo any time.
Preset operations
Expression (advanced)
AI assistant
Visualize & metrics
Dashboard (before/after)
Data drift
Tip: select multiple columns to run the same operation on all of them at once.
Nothing applies directly — every result below ends with
approve or decline.
Click to try: loading examples for your columns…
What can I use in an expression?
Available:df (the current dataset), pd, np, and the
builtins abs min max round len sum sorted str int float bool list dict range zip. Works: arithmetic and comparisons · .str methods
(.str.strip(), .str.upper(), .str.extract()) ·
.astype() · .fillna() · .clip(lower=0) ·
.round(2) · .rank() · .where() ·
pd.to_numeric(df["x"], errors="coerce") · pd.to_datetime(...) ·
pd.cut(...) · np.log1p / np.where / np.sqrt ·
df.groupby("g")["v"].transform("mean") · .map({'a': 1}) Blocked: imports · dunder access · lambdas and comprehensions ·
.apply/.applymap/.pipe (they run arbitrary callables) ·
.eval/.query · every read_*/to_* file
operation. Shape rules: return one value per row and name a target column, or return a whole
table and leave the target blank. Keyword arguments are fine — validation reads the parsed
syntax tree, not the raw text, so a column named opening_price or
important_flag works normally.
Expressions run in a locked-down sandbox: no imports, file, network, or
OS access. Two modes: Evaluate answers a question (a count, a value, a mask summary)
and never touches the data; Preview change shows exactly what the dataset would
become, and the change is applied only from that preview — never directly. Enter only the
right-hand-side value (not df[...] = ...); each applied change is a new
undoable version.
Chat with your data
Tell it what to change in plain English. It confirms what it understood,
shows a 2-row preview, and waits for your approval before touching anything.
Need data-prep advice instead? (what should I do for my goal)
Nothing is applied until you click Approve. Approving runs the change on your
full dataset as one undoable step. You can also copy the code into the Expression tab. Requires an
LLM key in .env.
Chart builder
Metric counter
Raw vs current
Ask (AI)
Power-BI-style overview comparing the raw dataset to the current cleaned version.
KPIs at the top, then per-column changes.
Per-column comparison
Compare two datasets for distribution drift
Upload your reference dataset (e.g. last month's training data) and a new dataset
(e.g. recent production data). PrePro Auto computes per-column PSI and KS test for numerics,
PSI for categoricals. No model required — works on any two CSV / Parquet / Excel / JSON files.
Baseline / training / last period
Recent / production / current period
Step 6 of 6
Results & export
See exactly what preprocessing changed — the quality score, the column types
before vs after, and a data sample — then download your deliverables.
Before & after
Comparison of the raw upload against the cleaned result.
Loading comparison…
Download
Take your results away.
Clean data
The processed dataset as CSV or Parquet.
Audit report
A PDF listing every transformation and who decided it.
Pipeline code
A standalone Python script reproducing the cleaning.
Deliverable templates
The dataset (and the forecast store) in the exact shape your offtaker expects —
columns picked, renamed, aggregated, scaled. Every column's recipe travels in the file as a
manifest header, and a column sourced from forecasts is always marked PREDICTED — no
template can make a forecast masquerade as measurement.
Step 7 of 7
Train a model
Train a model on top of your cleaning recipe. It starts with the split, because that
one decision determines whether every number that follows is honest — and the test rows stay
sealed until the very end.
1 · SplitDecide which rows the model never sees. The preview is the split the run uses — and the test rows stay sealed until the very last step.
2+3 · Candidates & tuningCatalog models scored against your training rows, then search spaces adapted to them — every number shows its arithmetic.
4 · Select & evaluateCompare by cross-validation only, choose the champion, and spend the test set once — on that model alone.
AI
Describe the goal — the AI plans, the engine runs
The AI reads computed facts about your current dataset (schema, distinct
counts, missing shares — your privacy settings apply) and fills in the same plan you could
set by hand: target, split, candidates, tuning. Every choice comes back with its reason, every
correction the validator makes is listed, and the metric is derived by the engine from your goal
— the AI computes none of the numbers. The run itself goes through the same phases below:
CV comparison first, then you pick the champion, then the single test read.
Phase 1
Split the data
Decide which rows the model never sees. Nothing is fit here — you get the exact
partition the run will use, so you can check it before committing.
The column you want to predict.
Correct when no row depends on another.
Share held back for the final score.
Used to choose the model, on train only.
Same seed → same split, every time.
Training mode
Setup
What you're predicting and why. Everything else can stay on defaults.
The column you want to predict.
Steers the metric. Plain English is fine.
Forecast (time series)
Predict the target N steps AHEAD. The label becomes the future value; a purge
gap of N rows separates train from test and every walk-forward fold from its validation
window, so no training label comes from the rows that judge it. Persistence
(tomorrow = today) is always scored as the baseline the champion must beat.
Empty = ordinary regression, not a forecast.
A physics estimate to score alongside persistence.
e.g. 0 … rated kW — applied INSIDE the shipped pipeline.
Validation & search
Comma-separated ids. Leave blank to compare everything, including custom models below.
Phase 2
Candidates
Every model in the catalog, scored against your training rows — the same
split Phase 1 previewed, so the test set has no say in this ranking either. Each score shows
its arithmetic; disagree with a factor and pick differently.
Phase 3
Tune hyperparameters
Each selected model gets a search space: the algorithm’s standard ranges, reshaped
to your training rows — and every reshape states the arithmetic that caused it. The search
runs inside the same CV folds Phase 1 previewed; the test set stays sealed, and so does the decision
threshold (chosen out-of-fold on train).
Auto is arithmetic, not taste: exhaustive grid when the space fits the budget,
a random sample otherwise.
Each setting costs one fit per CV fold.
Phase 4
Choose the champion
Candidates compared by cross-validation on training folds only — the test
rows are still unread, so nothing on this board was shaped by them. The CV winner is preselected;
confirm it or pick another. The next step reads the test set once, for that model alone, and
cannot be repeated.
Zero-shot
Forecast with TimesFM 2.5 — no training, scored anyway
A frozen pretrained model reads the target's own history and forecasts it. Nothing is fit,
there is no training split and nothing to tune — so the most recent windows are held back and
each is forecast from the history before it, then scored against persistence and
seasonal-naive. Every number on the result is computed from those windows. The forecast
never enters the dataset; it leaves as a marked CSV, an offline chart, or the forecast store.
One configuration, fixed per installation and printed on every result.
Custom model advanced
Bring your own estimator — any scikit-learn-compatible model, whether ML, statistical,
or a neural net. It runs through the same leakage-safe pipeline and lands on the leaderboard with the rest.
Permutation importance on the holdout, normalised to the strongest column (0–1).
A near-zero bar can mean redundant with a correlated twin, not useless — so pruning
is decided by a before/after cross-validation comparison, never by the bar alone.
Drop features with normalised importance below
Model input contract — what the pkl requires
Introspected from the SHIPPED artifact: the exact raw columns, their dtypes, and
the preprocessing each flows through inside the pipeline. Supply RAW values — imputation,
scaling and encoding happen inside.
Issue a prediction from the latest data row (issue_time is the data's own
timestamp — re-issuing on unchanged data is an idempotent skip), reconcile when actuals
arrive, and watch live skill against the persistence captured at issue time. Overlapping
runs fill in the skill-vs-lead-time curve on their own.
Actual vs predicted — every run in the store
The target column against each run's issued forecasts (trained runs and TimesFM alike),
on one axis, with persistence dotted underneath. The MAE in the headline is each run's error on the
same rows — the moments every selected run predicted and that have a realized actual.
Enter feature values and get a live prediction from the trained model.
Export model
The trained pipeline bundles preprocessing + model together — load it and call predict, no re-fitting.
Bundle (.joblib)
Preprocessing + model in one object, ready to load in Python.
Scorer script (.py)
A standalone predict script carrying the feature schema.
Training script (.py)
Re-runs this exact training — same split, seed, preprocessing and champion — and checks every reproduced metric against the recorded ones. Exit 0 = the report reproduces.
ONNX
Portable model for cross-language serving (when supported).
AI settings
Pick a provider and paste your API key. AI features are optional — everything works offline without one.
Off by default (safer). Only enable on your own machine; not for shared/hosted use.