Learn machine learning by running it

Imagine teaching a child to recognise a cat. You do not write down rules like 'four legs, whiskers, pointy ears'. You just show them lots of cats, and soon they can spot a new cat they have never seen. Machine learning is the same idea for computers: instead of writing rules, we show the computer many examples, and it learns the pattern by itself. That learned pattern is called a MODEL.

Think of a spreadsheet. Each ROW is one example (say, one flower). Each COLUMN is a FEATURE, a fact about it (petal length, petal width, colour). One special column is the TARGET, the thing we want to predict (which species of flower). BreezeML learns the link between the features and the target. That is why you only ever tell it two things: your table, and the name of the target column.

Almost every ML problem is one of two jobs. CLASSIFICATION is sorting things into buckets: spam or not spam, cat or dog, which of 3 flowers. REGRESSION is guessing a number: tomorrow's temperature, a house price, how many visitors. BreezeML looks at your target column and picks the right job automatically. Press Run to SEE both side by side.

A classifier draws invisible borders between the groups. Anything that lands in a green region is called green; in a red region, red. Press Run to watch a real model draw those borders around 150 flowers using just two measurements. This picture IS the model.

When you study for an exam, you practise on some questions and then the real test uses NEW questions you have not seen. If the teacher tested you on the exact practice questions, a good score would not mean you actually learned. Models are the same: we TRAIN on some rows and TEST on other, unseen rows. BreezeML always keeps a fair, unseen test set for you, so its scores are honest.

Enough theory. Press Run. This loads 150 real flowers, learns to tell three species apart, and prints how often it is right, all inside this web page. You just did machine learning.

ACCURACY means 'out of 100 guesses, how many were right?'. Simple, but it can lie. If 99 out of 100 emails are NOT spam, a lazy model that always says 'not spam' is 99% accurate and completely useless. That is why BreezeML also shows F1 (a fairer score when the buckets are uneven) and, for yes/no problems, ROC AUC (how well it ranks the risky cases). More than one number keeps you honest.

A student who memorises the answer key gets 100% on practice and fails the real exam. A model can do this too: it 'memorises' the training rows instead of learning the real pattern, so it looks amazing in practice and flops on new data. This is OVERFITTING. Press Run to watch it happen: as the model gets more complex, the practice score keeps climbing while the real (unseen) score stalls and dips.

One test could be lucky or unlucky. So BreezeML splits your data into 5 parts, trains on 4 and tests on the 1 left out, then rotates until every part has been the test once. Averaging those 5 grades gives a score you can trust. Press Run to see all five grades and their average.

Imagine predicting whether a patient is sick, but one column is 'medicine already prescribed'. The model will look brilliant, because that column basically contains the answer, but it is useless in real life where you do not know it yet. This is LEAKAGE. BreezeML's audit() hunts for these traps before you train. Honesty first.

No pipelines to wire, no config files. Give it a table and the name of the column you want to predict. BreezeML figures out the rest (classification vs regression, cleaning, encoding, scaling, cross-validation) and hands back a trained model.

Set explain_decisions=True and BreezeML narrates every choice it makes in plain English as it makes it: why it picked a model, how it cleaned the data, which metric it optimized. It teaches while it works.

import breezeml

df = breezeml.datasets.wine()
model, report = breezeml.auto(
    df, "wine_class", explain_decisions=True
)

export() writes a standalone scikit-learn script that reproduces your exact pipeline with NO breezeml import. Delete the library and your model still runs. You are never trapped.

import breezeml

df = breezeml.datasets.iris()
model = breezeml.fit(df, "species")
breezeml.export(model, "train.py")   # pure sklearn

The core installs with only four packages, and a CI test fails the build if anyone adds a fifth. That discipline is why the whole library can even run inside this web page.

# the entire core dependency list
# scikit-learn, pandas, numpy, joblib
# (xgboost, lightgbm, onnx, etc. are optional extras)

Most tools shout a single accuracy number. BreezeML ships a whole honesty toolkit: leakage detection, fairness gaps, drift monitoring, statistical significance, and distribution-free uncertainty. See the Honesty section.

A built-in Model Context Protocol server lets Claude and other agents train, compare, explain, and deploy models with sound statistical defaults, and get the same explanations you would.

pip install "breezeml[mcp]"
claude mcp add breezeml -- breezeml-mcp

When the work is done, breezeml.zen() rakes the gravel: a breathing pause, a haiku about your model, a fortune, or a word from the sensei. Machine learning, with calm.

import breezeml

breezeml.haiku()
breezeml.fortune()

The core is four dependencies. Extras like xgboost, lightgbm, onnx, and the MCP server are opt-in.

pip install breezeml

# optional extras
pip install "breezeml[boost]"   # xgboost + lightgbm
pip install "breezeml[mcp]"     # agent server
pip install "breezeml[all]"     # everything

Practice datasets return a pandas DataFrame with a named target column. Available: iris, wine, breast_cancer, diabetes (regression), and penguins (needs seaborn).

The main entry point, and usually the only function a beginner needs. Name the target column and BreezeML detects the task, cleans and encodes the data, and trains a solid model scored with 5-fold cross-validation. It returns a fitted Model you can evaluate, explain, or ship. task='auto' picks classification vs regression for you; pass task='classification' or 'regression' to force it. Pitfall: the target must be a real column in df, not a separate array.

Use a trained model on new rows and get back an array of predictions, one per row. X is a DataFrame with the same feature columns you trained on; the target column does not need to be present. When to use: scoring fresh data after training. Pitfall: if a column is missing or renamed the call fails, so keep your input schema stable.

Read the honest, cross-validated scores of a fitted model, for example accuracy and macro-F1 for classification, or R2 and RMSE for regression. It returns a dict of metric names to values and prints them for you. When to use: right after fit, to see how good the model really is before trusting it. Pitfall: these are cross-validated scores on your training table, not a promise about a different population, so keep an eye on drift once you deploy.

A trained model can hand you calibrated uncertainty, not just a point guess. For regression, predict_interval() returns lower, point, and upper bounds that cover the truth at your chosen level; for classification, predict_set() returns a set of labels guaranteed to contain the right one. alpha controls the level, so alpha=0.1 aims for 90% coverage. When to use: decisions where being wrong quietly is costly. Pitfall: both need a held-out calibration set, because honest coverage needs unseen data, and a tiny calibration set gives shaky intervals.

import breezeml
from sklearn.model_selection import train_test_split

df = breezeml.datasets.wine()
train, calib = train_test_split(df, test_size=0.3, random_state=0)
model = breezeml.fit(train, "wine_class")

# a label set that covers the true class ~90% of the time
sets = model.predict_set(calib.drop(columns=["wine_class"]).head(), calib, alpha=0.1)
print(sets)

The teaching entry point. It trains the best default model AND returns a report, so you learn what happened, not just the score. It hands back a (model, report) tuple: the model behaves like fit's, and the report summarizes the metrics and the decisions it made. Set explain_decisions=True to narrate every step in plain English, or balanced=True to reweight for class imbalance. When to use: when you want to understand the pipeline, not just run it.

import breezeml

df = breezeml.datasets.wine()
model, report = breezeml.auto(df, "wine_class", explain_decisions=True)
print(report)

Skip the pandas step: from_csv reads the file and trains in one call. save writes the fitted model to a .joblib file and load reads it back, so you can train once and reuse the model in another script or a server. When to use: moving a model between training and serving. Pitfall: joblib files are tied to library versions, so pin scikit-learn if you plan to load a model months later.

import breezeml

model = breezeml.from_csv("data.csv", "target")
breezeml.save(model, "model.joblib")
same = breezeml.load("model.joblib")

The full arc for a category-prediction problem. Train a first model, compare it against the alternatives on the same folds, get an honest SHIP/WARN/STOP verdict, write a model card, then export a standalone script. Press Run to do the first four steps live; the final export line runs locally.

Never ship on a single accuracy number. Train, ask report() for the one-word verdict, and only trust a SHIP. Run audit() to see the leakage and balance detail behind it. Press Run: this clean model ships, but the pattern is the same when it does not.

Give every prediction a calibrated range instead of a bare point. Split off a calibration set, then ask the model for a label set (classification) or an interval (regression) with guaranteed coverage. Run this locally, calibration needs unseen data.

import breezeml
from sklearn.model_selection import train_test_split

df = breezeml.datasets.wine()
train, calib = train_test_split(df, test_size=0.3, random_state=0)
m = breezeml.fit(train, "wine_class")

X = calib.drop(columns=["wine_class"]).head()

# a label set that covers the true class ~90% of the time
print(m.predict_set(X, calib, alpha=0.1))

# for regression targets, use an interval instead:
#   lo, point, hi = m.predict_interval(X, calib, alpha=0.1)

Hand the whole loop to Claude through the MCP server. The agent trains a model, runs report(), and is instructed to confirm a SHIP verdict before it deploys. A WARN or STOP stops the line and the agent reports back instead of shipping a broken model.

# one-time setup
pip install "breezeml[mcp]"
claude mcp add breezeml -- breezeml-mcp

# then, in the agent conversation:
#   train(churn.csv, churn)            -> model_1, f1 0.81
#   report(model_1, churn.csv, churn)  -> verdict SHIP
#   (agent confirms SHIP)
#   deploy(model_1, api/)              -> FastAPI app written

The signature move: rank every classifier on the SAME cross-validation folds, then light the winner. Fair by construction. (The browser runs a fast subset; run locally for all 24.)

A confusion matrix shows, for every true class, what the model guessed. Bright squares on the diagonal are correct; anything off-diagonal is a mix-up. Press Run to see one for real wine classes.

Every classifier is a one-liner that returns a fitted model and an honest report. Swap the name to swap the algorithm.

import breezeml

df = breezeml.datasets.iris()
model, report = breezeml.classifiers.random_forest(df, "species")
print(report)

Tune the winner's hyperparameters over a small, sensible grid, no sprawling search.

import breezeml

df = breezeml.datasets.wine()
best = breezeml.classifiers.quick_tune(df, "wine_class", algo="random_forest")

Rank all regressors on the same folds, scored by R2, MAE and RMSE.

import breezeml

df = breezeml.datasets.diabetes()
breezeml.regressors.compare(df, "target")

Returns the cluster labels and a silhouette score (how well-separated the groups are).

import breezeml

df = breezeml.datasets.iris().drop(columns=["species"])
res = breezeml.clustering.kmeans(df, n_clusters=3)
print("silhouette:", round(res["silhouette"], 3))

Clustering gets NO answer column. It groups points purely by how close they are. Press Run to watch it rediscover the flower groups using only two measurements, no labels at all.

The whole honesty toolkit in a single call. It cross-validates the model against a naive baseline, scans for target leakage, and checks class balance (and fairness, if you pass a sensitive column), then returns a Report whose verdict is SHIP, WARN, or STOP. Read report.verdict for the decision and report.reasons for why. When to use: as the last gate before you deploy or export anything. Pitfall: a SHIP verdict means no blocking issues were found, not that the model is perfect, so still read the warnings. Press Run: the clean model ships.

Give the data a column that secretly contains the answer, and report() refuses to ship it. This is the guardrail that keeps a too-good-to-be-true score from reaching production. Press Run to watch it say STOP.

Scans your raw table for the traps that quietly ruin models: target leakage (a feature that secretly contains the answer), duplicate rows, ID-like columns, constants, and class imbalance. It returns a dict whose 'ok' flag is False when a critical issue is found, and prints a readable summary when show=True. When to use: before you train, and as a CI gate (the CLI exits 1 when it fails). Pitfall: audit reads the data, not the model, so run report() after training as well.

Checks whether rows leaked between your train and test sets, the sneakiest way to fool yourself with a great score. It compares the two tables for exact and near-duplicate rows and returns a dict describing the overlap. When to use: whenever you split data by hand instead of letting BreezeML do it. Pitfall: a model that memorized rows it also gets tested on looks brilliant and is worthless in production.

import breezeml

breezeml.contamination(train_df, test_df)

Measures whether your model treats groups differently. Pass the name of a sensitive column and it returns per-group accuracy, the demographic parity ratio, and a four-fifths-rule verdict, so you learn who the model is worse for. When to use: any model that touches people. Pitfall: overall accuracy can look great while one group is badly served, which is exactly what this surfaces.

import breezeml

breezeml.fairness.report(model, df, sensitive="gender")

Measures how far new data has drifted from the data the model was trained on, using the population stability index (PSI), and flags unseen categories and out-of-range values. It returns a dict of per-feature drift scores with a flag when any crosses the threshold. When to use: on a schedule in production, and it runs live in every deployed API. Pitfall: a model does not tell you when the world changed under it, so silent drift is how good models quietly go stale.

import breezeml

breezeml.drift.check(model, new_df)

Is model A's 2% edge real or luck? McNemar's test and a paired cross-validated t-test compare two models on the same rows and return a p-value instead of a hunch. When to use: before you replace a working model with a slightly better looking one. Pitfall: small score gaps are often noise, and shipping the wrong winner costs you real accuracy.

import breezeml

breezeml.significance.mcnemar(model_a, model_b, df, "target")

Distribution-free prediction sets with a guaranteed coverage level. Instead of one guess you get 'the answer is in {A, B} with 90% coverage', honest uncertainty on every prediction. alpha sets the miss rate you tolerate, so alpha=0.1 targets 90% coverage. When to use: high-stakes calls where you need to know when the model is unsure. Pitfall: coverage is only honest on a held-out calibration set, so never calibrate on the training rows.

import breezeml

sets = breezeml.conformal.conformal_classifier(
    model, calib_df, "target", alpha=0.1
)

For rare-event problems like fraud or disease, where a lazy model can score 99% by always guessing the majority. Summarize the imbalance, move the decision threshold to the metric you care about, calibrate the probabilities, and cost out false positives against false negatives. When to use: any time one class is much rarer than the other. Pitfall: the default 0.5 threshold is almost never right for rare events, so tune it to your real costs.

import breezeml

breezeml.imbalance.summary(df["target"])
breezeml.imbalance.tune_threshold(model, df, "target", metric="f1")

One call for a full plain-English explanation of the model: top features, direction of effect, and caveats.

Shuffle each feature and see how much the score drops; a model-agnostic, trustworthy importance ranking.

import breezeml

breezeml.explain.permutation_importance(model, df, "target")

Shows how the prediction changes as one feature moves, holding the rest fixed. The 'what-if' curve.

import breezeml

breezeml.explain.partial_dependence(model, df, "target", feature="age")

Pick the k most informative columns, compress with PCA, or expand with polynomial interactions, all one-liners.

import breezeml

top = breezeml.features.select(df, "target", k=10)
reduced = breezeml.features.pca(df, n_components=0.95)

Writes a standalone scikit-learn script that reproduces your pipeline with no breezeml import. The ultimate no-lock-in guarantee.

import breezeml

df = breezeml.datasets.iris()
model = breezeml.fit(df, "species")
breezeml.export(model, "train.py")

Generates an honest Markdown model card: data profile, metrics, decisions, and auto-detected caveats. Governance made easy.

Emits a FastAPI app + Dockerfile + pinned requirements. Every deployed API ships /predict, /health and a live /drift endpoint.

import breezeml

breezeml.deploy(model, "api/")
# -> main.py, Dockerfile, requirements.txt, model.joblib

Export to the ONNX open standard so your model runs in other languages and runtimes.

import breezeml

breezeml.deploy.to_onnx(model, "model.onnx")

Give it a time budget and it searches models and hyperparameters for you, then returns the best honest pipeline.

import breezeml

best = breezeml.automl(df, "target", time_budget=60)

Log every experiment to a local leaderboard, then blend your best models into an ensemble.

import breezeml

breezeml.track.log(model, report, name="run-1")
breezeml.track.leaderboard()

Not just correlation, causation: estimate the average treatment effect of an intervention, and model who responds to it (uplift).

import breezeml

breezeml.causal.estimate_ate(df, treatment="promo", outcome="spend")

Prediction intervals with guaranteed coverage: 'the price is 40k to 55k, 90% of the time'.

import breezeml

lo, hi = breezeml.conformal.conformal_regressor(model, calib, "price", alpha=0.1)

Find the weird rows with four methods, or compare them all at once.

import breezeml

breezeml.anomaly.isolation_forest(df, contamination=0.05)

Build lag/rolling features, compare forecasting models with proper time-aware splits, and forecast ahead.

import breezeml

feat = breezeml.timeseries.make_features(df, date_col="date", target="sales")
breezeml.timeseries.forecast(df, date_col="date", target="sales", horizon=30)

Time-to-event modeling: how long until churn, failure, or recovery, with censoring handled correctly.

import breezeml

breezeml.survival.kaplan_meier(df, "tenure_months", "churned")

Predict several labels at once, or build a collaborative-filtering recommender from a ratings table.

import breezeml

breezeml.multi.multi_label(df, targets=["tag_a", "tag_b"])

Label smartly (active learning), learn from mostly-unlabeled data (self-training), and auto-engineer new features.

import breezeml

next_to_label = breezeml.active.query(model, unlabeled_df, n=10)
breezeml.autofeat.engineer(df, "target")

Turn free-text columns into numeric embeddings you can feed to any model (needs the sentence-transformers extra).

import breezeml

df2 = breezeml.text.embed(df, text_columns="review")

Train a solid model in one line. Pass your table and the name of the column you want to predict; BreezeML cleans, encodes, cross-validates, and returns a fitted Model. Leave task='auto' to let it detect classification vs regression.

Run a fitted model on new rows and get back an array of predictions. X is a DataFrame with the same feature columns you trained on.

The teaching entry point. It trains the best default model AND hands back a report of what it did. Set explain_decisions=True to narrate every step in plain English, or balanced=True to handle class imbalance.

import breezeml

df = breezeml.datasets.wine()
model, report = breezeml.auto(df, "wine_class", explain_decisions=True)
print(report)

The honest verdict. Runs the whole honesty gauntlet (performance vs a naive baseline, leakage and data-quality audit, class balance, optional fairness) and returns a Report whose verdict is SHIP, WARN, or STOP. Check report.verdict before you ship anything.

Every fitted Model carries the workflow on itself, so you rarely need the module-level helpers. model.evaluate() reads the cross-validated scores, model.report(df) gives the SHIP/WARN/STOP verdict, model.explain(df) narrates the drivers, model.card() writes a model card, and model.export()/model.deploy() ship it. model.predict_interval() and model.predict_set() add calibrated uncertainty.

Honest uncertainty on top of a point guess. For regression, predict_interval() returns lower, point, and upper bounds that cover the truth at your chosen level; for classification, predict_set() returns a set of labels guaranteed to contain the right one. Both need a held-out calibration set, because honest coverage needs unseen data.

import breezeml
from sklearn.model_selection import train_test_split

df = breezeml.datasets.wine()
train, calib = train_test_split(df, test_size=0.3, random_state=0)
m = breezeml.fit(train, "wine_class")

X = calib.drop(columns=["wine_class"]).head()
print(m.predict_set(X, calib, alpha=0.1))

Turn a trained model into artifacts you own. export() writes a standalone scikit-learn script with zero breezeml import, deploy() emits a FastAPI app plus Dockerfile and pinned requirements, and card() writes an honest Markdown model card. No lock-in, ever.

import breezeml

df = breezeml.datasets.iris()
m = breezeml.fit(df, "species")

breezeml.export(m, "train.py")     # pure sklearn script
breezeml.deploy(m, "api/")          # FastAPI + Dockerfile
breezeml.card(m, "MODEL_CARD.md")   # governance doc

Persist a model to disk with joblib and read it back later, or train straight from a CSV file without loading it into pandas yourself.

import breezeml

m = breezeml.from_csv("data.csv", "target")
breezeml.save(m, "model.joblib")
same = breezeml.load("model.joblib")

Practice datasets that each return a pandas DataFrame with a named target column, so every example on this site is one line from a real table. iris, wine, and breast_cancer are classification; diabetes is regression.

Install the MCP extra, then register the breezeml-mcp server with your agent. The console script speaks stdio transport, so one line wires it into Claude Code. Once connected, the agent sees eleven tools: inspect_data, audit, train, compare, predict, explain, report, model_card, export, deploy, and save.

pip install "breezeml[mcp]"

# register the server with Claude Code
claude mcp add breezeml -- breezeml-mcp

Look before you leap. inspect_data profiles a CSV (rows, features, missing values, class balance) and audit scans it for target leakage, ID columns, constants, duplicates, and label noise. Both return JSON so the agent can reason about whether the data is even worth training on.

// tool: inspect_data
{ "csv_path": "churn.csv", "target": "churn" }

// result (abridged)
{ "rows": 7043, "features": 19, "missing": 0,
  "target": "churn", "classes": { "No": 5174, "Yes": 1869 } }

Trains the auto-selected model and stores it in the session under a model_id the agent reuses for later calls. The result includes the task, the chosen estimator, the cross-validated report, and a plain-English list of every pipeline decision.

// tool: train
{ "csv_path": "churn.csv", "target": "churn" }

// result
{ "model_id": "model_1", "task": "classification",
  "estimator": "HistGradientBoostingClassifier",
  "report": { "f1": 0.81, "roc_auc": 0.86 },
  "decisions": ["detected classification from 2 classes", "..."] }

Benchmarks every built-in model on the same cross-validation folds and returns a ranked leaderboard, so the agent picks a winner fairly instead of guessing an algorithm.

// tool: compare
{ "csv_path": "churn.csv", "target": "churn" }

// result
{ "task": "classification",
  "leaderboard": [
    { "model": "hist_gradient_boosting", "f1": 0.81 },
    { "model": "random_forest", "f1": 0.79 },
    { "model": "logistic", "f1": 0.76 } ] }

The gate. Runs the full honesty gauntlet on a trained model and returns a single SHIP, WARN, or STOP verdict with reasons. Agents are instructed to call this and confirm SHIP before they deploy or export. Pass a sensitive column to add a fairness check.

// tool: report
{ "model_id": "model_1", "csv_path": "churn.csv", "target": "churn" }

// result
{ "verdict": "SHIP", "target": "churn", "task": "classification",
  "reasons": [],
  "sections": { "performance": { "beats_baseline": true } } }

The shipping tools. deploy writes a complete FastAPI plus Docker serving directory, export writes a standalone scikit-learn script, model_card writes a Markdown governance doc, and save persists the model to a .joblib file. An honest agent only reaches for these after report returns SHIP.

// tool: deploy (only after a SHIP verdict)
{ "model_id": "model_1", "out_dir": "api/" }

// result
"Serving app written to api/ (run: cd api/ && pip install -r requirements.txt && uvicorn app:app)"

The whole point: the server nudges agents toward a sound workflow. Inspect the data, compare models, train the winner, then run report. Only if the verdict is SHIP does the agent deploy. A WARN or STOP stops the line and the agent reports back instead of shipping a broken model.

Agent: inspect_data(churn.csv, churn)   -> looks clean, 2 classes
Agent: compare(churn.csv, churn)        -> hist_gradient_boosting wins
Agent: train(churn.csv, churn)          -> model_1, f1 0.81
Agent: report(model_1, churn.csv, churn)-> verdict SHIP
Agent: SHIP confirmed, proceeding.
Agent: deploy(model_1, api/)            -> FastAPI app written

Trains the auto-selected model on a CSV, prints its report, and saves it to disk. Add --explain to narrate every pipeline decision in plain English as it works.

breezeml train data.csv --target churn --out model.joblib --explain

Prints a leaderboard of every built-in model ranked on the same cross-validation folds, so you can eyeball the winner before committing to one.

breezeml compare data.csv --target churn

Scans a CSV for leakage and data-quality problems and exits with status 1 on critical findings. That non-zero exit makes it a natural CI gate: wire it before training and a broken dataset fails the build instead of shipping a fantasy score.

# fails the pipeline (exit 1) if the data is broken
breezeml audit data.csv --target churn

Budget-aware model search. Give it a time budget in seconds and it searches models and hyperparameters, then saves the best honest pipeline it found.

breezeml automl data.csv --target churn --budget 120 --out best.joblib

Turns a saved model into a complete FastAPI plus Docker serving directory, ready to run with uvicorn or build into an image.

breezeml deploy model.joblib --out api/ --name churn-api

Generates an honest Markdown model card from a saved model: data profile, metrics, decisions, and auto-detected caveats. Governance in one command.

breezeml card model.joblib --out MODEL_CARD.md

Prints the garden path: a friendly map of the whole library and a suggestion for what to reach for first, based on the kind of task you have.

breezeml guide

When the work is done, rest. Prints the Zen of BreezeML: a calm pause at the end of an honest day of modeling.

breezeml zen

The core installs with only four packages, and a CI test fails the build if anyone adds a fifth. Small footprint means fast installs, fewer version conflicts, and code you can actually read. It is also why the whole library can run inside this web page. Heavy extras like xgboost and the MCP server stay strictly opt-in.

export() writes a plain scikit-learn script that reproduces your exact pipeline with no breezeml import anywhere. Delete the library and your model still trains and runs. You adopt BreezeML for the workflow, never because you are trapped.

Most tools shout a single accuracy number. BreezeML assumes a score is a claim that has to survive leakage checks, a naive baseline, class balance, and fairness before you trust it. report() folds all of that into one verdict, so the honest path is also the easy path.

A newcomer should go from a spreadsheet to an honest model in three lines, learning the ideas along the way, while an expert keeps every knob. Plain-English explanations, sensible defaults, and a calm tone are features, not decoration. Good tools teach while they work.

A 60-second breathing pause, a haiku about your model, a fortune for your next step, or a word of wisdom from the sensei.

import breezeml

breezeml.haiku()
breezeml.fortune()
breezeml.sensei()

Lost? guide() prints a friendly map of the whole library and suggests the next step for your task.

import breezeml

breezeml.guide()