AbleVLabs

A public laboratory of Python tools, built to make difficult things easier and shared in the open.

pip install ablevlabs

Three independent tools ship in the package, each importable on its own:

from ablevlabs import kami   # machine learning for beginners
from ablevlabs import lana   # compare and rank anything
from ablevlabs import agoge  # a reps-in-reserve training coach

kami: machine learning that teaches as you go

kami wraps scikit-learn in a guided, beginner-first workflow. It catches the classic mistakes for you and explains them in plain English, and it teaches you what's happening as it happens, so you get smarter while you use it. It takes you the whole way from a raw file to real predictions.

from ablevlabs import kami

df = kami.load("houses.csv")            # opens CSV, Excel, JSON, Parquet, and more
kami.look(df, target="price")           # understand the data before you model it
result = kami.train(df, target="price") # trains a model, handling the usual traps
kami.predict(result, new_houses)        # make predictions on new rows

What's inside:

• Understand your data: look, report, audit, and recommend size up a dataset and suggest what to predict.
• Clean it: clean tidies the common messes and explains each fix as it makes it.
• Train and compare: train builds one model, and bakeoff races several, ranks them with a full metric table (precision, recall, F1, ROC AUC — or R², MAE, RMSE), and names a winner. On lopsided data it ranks by F1 instead of accuracy on its own, and explains why. The winner carries the whole race on champ.bakeoff_table — every model's metrics plus training time and a readability score — so you can decide on more than one number.
• Trust it: feature_importance and plot_predictions show what the model leaned on and how well it did.
• Use it: predict scores new data, and whatif shows how a prediction shifts as you change one input.
• Charts in one line: bar, line, scatter, hist, pie, heatmap, quickplot.
• Go deeper: deep_look, deep_train, deep_check and friends wrap PyTorch the same way, and keep helping after you start writing your own training loops. See below.
• A built-in classroom: info, learn, models, roadmap, and translate explain the concepts and the jargon as you go — including learn("TabPFN") on the tabular foundation models now challenging gradient boosting.

New to it? Run kami.info().

Neural networks: the deep half

Since 0.10.0, kami also teaches PyTorch, and it is built to stop helping as you get better at it. Three rungs, and you are expected to climb off the top:

kami.deep_look(df, target="churn")            # should this be a network at all?
result = kami.deep_train(df, target="churn")  # rung 1: kami does all of it
result.show_code()                            # rung 2: the exact PyTorch it just ran
kami.deep_check(my_model, df, target="churn", # rung 3: read code YOU wrote
                loss_fn=loss_fn, loop=my_loop)

Rung three is the reason it exists. Most teaching wrappers stop helping the moment you write your own training loop. deep_check reads your model and your loop and names the traps that do not raise an error: a nn.Softmax in front of CrossEntropyLoss, a missing optimizer.zero_grad(), a model.eval() that never gets called while dropout is still on. Your code runs, your loss falls a little, and the model is quietly worse than it should be. That is why most people's first hand-written loop underperforms.

Hand deep_look a folder of photos instead of a table and the same verb reads your classes, then finds the near-duplicates:

kami.deep_look(folder="photos/")

Forty frames of one burst are forty files and one picture. Split at random and copies of the same shot land on both sides, so the model is scored on images it already trained on. Kami fingerprints every image, counts your classes in pictures rather than files, and splits so every copy stays on one side. On a test folder a random split left 264 near-duplicate pairs straddling train and test; the grouped split left zero.

PyTorch is optional and never imported at module load:

pip install ablevlabs[deep]     # torch, for the table half
pip install ablevlabs[vision]   # torch, torchvision and Pillow, for folders of images

Run kami.deep_info() for the whole map.

lana: compare and rank anything

lana (Logical Attribute Node Aligner) weighs records field by field, using the priorities you set, and tells you which one wins. Hand it two records for a head-to-head verdict, or a whole list for a ranked leaderboard. It works on anything with comparable fields: job candidates, products, model runs, vehicles, game characters.

from ablevlabs import lana

a = {"name": "Zoro",  "power": 9100, "speed": 80}
b = {"name": "Sanji", "power": 8800, "speed": 95}

lana.show(lana.compare(a, b, priority={"power": 5, "speed": 3}))

Rank a whole field the same way:

lana.show(lana.rank([a, b, c, d], priority={"power": 5, "speed": 3}))

What's inside:

• Two modes: compare for a head-to-head, rank for a leaderboard across many records.
• Your priorities: weight the fields that matter with priority, mark fields where smaller is better with lower_better, and smooth over mismatched key names with aliases.
• Results are just data: every result is a plain dict, easy to inspect and reuse.
• Export anywhere: to_json, to_csv, to_markdown, to_df (pandas), or save() straight to disk.

See it live at ablevlabs.com/lana.html.

kami + lana: picking a model on more than one number

bakeoff's rank_by collapses a many-sided decision into a single metric. That's the right default, but shipping a model is a trade-off — accuracy against training cost against whether you can explain it to anyone. lana exists to weigh exactly that kind of trade-off, and kami hands it the race as plain rows:

from ablevlabs import kami, lana

champ = kami.bakeoff(df, target="churn")        # kami races and scores

lana.show(lana.rank(                            # you decide what matters
    champ.bakeoff_table,
    priority={"f1": 5, "train_seconds": 2, "interpretability": 3},
    lower_better=["train_seconds"],
))

A model at F1 0.81 that trains in a fifth of a second and reads as plain coefficients can genuinely be the better ship than one at 0.84 that takes nine seconds and explains nothing. Which one wins depends on your constraints — so this makes those constraints explicit and arguable instead of leaving them unstated.

One honest caveat: the weights are your judgement, not evidence. lana makes your priorities reproducible; it doesn't discover the right trade-off for you.

agoge: your reps-in-reserve training coach

agoge — named for the Spartan training system, the most famous structured program in history — answers the questions a lifter actually asks: how many reps do I have left, how many should I do, and what should today's sets look like? You calibrate a lift once from a couple of hard sets, and from then on agoge estimates your reps in reserve on every set, tracks fatigue across the session, and prescribes what comes next. It runs on the Vivanco Proximity-to-Failure Model (VPFM).

from ablevlabs import agoge

bench = agoge.calibrate(weight1=315, reps1=5, weight2=275, reps2=9, name="Bench")
w = agoge.Workout(bench)
w.target_reps(weight=275, rir=2)                 # reps to leave 2 in reserve, right now
w.log_set(weight=275, reps=8)                    # log a set; get a coaching readout back
w.build_plan(weight=275, target_rir=2, sets=5)   # prescribe today's sets

What's inside:

• Calibrate with confidence: build a lift from your hard sets, and agoge scores how much to trust it and flags any set that doesn't fit.
• Coaching on every set: reps in reserve and RPE, a plain-language label, and advice on what to do next.
• Three ways to plan: hold a target RIR, hold fixed reps, or run a top set with back-offs.
• Fit it to you: feed in your own logged sessions and agoge fits the fatigue model to your data, validating against held-out sets.
• Learn it fast: agoge.help() explains the ideas, and agoge.info() lists every function in plain English.

About AbleVLabs

AbleVLabs is my public laboratory. It's where I learn, experiment, build things, break them, fix them, and share whatever I work out along the way. Every project is one more step from total beginner toward the engineer I'm trying to become. I believe in open source and in learning out loud, because almost every tool I use exists thanks to someone who shared their knowledge for free. This is me paying that back. If something I build helps even one person learn a little faster than I did, then it already did its job.

Requirements

Python 3.8+. Dependencies (numpy, pandas, scikit-learn, matplotlib) install automatically.

PyTorch is not among them. Nothing in the package imports torch until you call a deep_ function, so installing ablevlabs stays as light as it ever was. When you want the deep half:

pip install ablevlabs[deep]     # torch
pip install ablevlabs[vision]   # torch, torchvision, Pillow

License

MIT © AbleVLabs

Links

• ablevlabs.com
• github.com/AbleVLabs
• PyPI: ablevlabs