What Tracker For Data Science Easy Actually Is
It is a lightweight experiment and pipeline tracking utility built for people who do not want to spend three days setting up MLflow or Weights & Biases before their first run logs anything. The basic idea is straightforward: you wrap your training loop or data processing script with a tracker object, it records metrics, parameters, and optional artifacts to disk, and you query them later with a small CLI or built-in viewer. It targets solo practitioners and small teams working on Kaggle-style projects, internal proofs of concept, or anything that never makes it to production where enterprise tracking tools live. That is the name people use when they are trying to find it quickly, and it is also how most documentation indexes it. The project sits on GitHub under a straightforward repo with a short readme. The install command is roughly pip install tracker-for-data-science-easy or whichever variation the current release uses, and the API surface is intentionally small. You initialize a tracker with a project directory, log parameters before the loop, log metrics inside it, and optionally push feature importance or confusion matrices as artifacts. Everything persists as JSON and parquet files in a structured folder layout, which means you can inspect raw runs without the UI. I used this for a season of notebook-to-script migrations on a commodity GPU workstation. The main reason I kept coming back was that the query syntax did not require me to learn a new backend language. It uses plain dictionary filters on the stored metadata, so a call like tracker.query(project="forecasts", params={"lr": 0.001}) returns the exact run objects without spinning up a web service or paying per minute for a hosted dashboard. The speed is decent. A typical 500-run sweep on local SSD comes back in about four to six seconds, which is fast enough that you stop using it just as a quick lookup tool instead of bothering with a heavier stack.
There is one edge case that cost me a morning I will not get back. When you track nested dictionaries for parameters, the tracker flattens them into a single string key by default, which sounds fine until you need to filter by a nested value across thousands of runs. I had an experiment where I stored model hyperparameters under config.model.optimizer and config.model.loss, then tried to compare runs by optimizer type. The filter dropped those keys silently because they were stored as compound strings, and I spent time thinking the query was broken before realizing the schema did not preserve the nesting. The workaround is to call tracker.set_nested_tracking(True) at initialization, or split the config into a separate artifact and keep the logged parameters flat with dot-separated keys that the filter engine can parse. I switched to the latter approach and started naming everything explicitly, which removed the confusion and made the query syntax more readable anyway. Another thing beginners miss is that the tracker does not automatically detect metric stability the way some hosted platforms do. It logs what you give it. If you call log_metric after every epoch but also every validation step inside the same function, your chart will show double the points and your filtering will get messy. I learned this when a run looked like it plateaued at epoch ten but was actually just my callback firing twice per epoch because I called validation inside both the training step and the epoch boundary hook. The fix is to separate the two calls and label them clearly, like train_loss and val_loss, rather than reusing the same metric name for different intervals. It is a small discipline, but it saves you from chasing ghosts in the plots later. The tool also has real limitations. It is not designed for team collaboration out of the box. Sharing runs requires either pushing the local directory to a shared storage location or exporting to a standard format, and the export is not lossless if you stored custom artifacts with nonstandard types. If your workflow involves multiple contributors changing the same project simultaneously, you will hit conflicts in the metadata files pretty quickly. In those situations, MLflow or a database-backed tracker like Sacred + PostgreSQL is more practical, even if the initial setup takes longer. Tracker For Data Science Easy works best when one person owns the data and the runs, or when the team agrees on a single output path and does not modify old runs.
Storage grows faster than most people expect. A typical run with model checkpoints saved as artifacts can add several gigabytes per hundred experiments if you are not careful. The tracker does not prune old data automatically, so I set up a simple cleanup script that deletes runs older than ninety days unless they are tagged as final. That cut my project directory from about forty gigabytes down to roughly twelve, which brought the query times back to reasonable levels. If you skip pruning, performance degrades noticeably after a few thousand runs because the filter has to scan more JSON files and the parquet cache gets stale. For downloading, the project is publicly available on GitHub, and the latest release tarball is linked on the repository page. The version numbers change frequently enough that I would not hardcode a specific URL here, but searching the repo with the exact project name brings it up immediately. Once installed, the getting started notebook shows a full sweep workflow in under two minutes, which is useful if you just want to verify the install before committing to a larger experiment. The readme also lists compatibility notes for Python 3.9 through 3.12, and the parquet dependency can be switched off if you prefer pure JSON, though queries will be slower without the columnar format. If you are deciding whether to use this or something heavier, the honest answer is to start with it for anything that is not production-critical. The friction is low, the learning curve is shallow, and the output format is portable enough to migrate to a proper tracking system later if the project actually ships. The only scenario where I would skip it entirely is when you need real-time shared dashboards across a team, cross-project aggregation, or integration with a managed orchestration pipeline. In those cases, the tracker still works, but you are fighting its design rather than using it. Most small-scale data science work does not fall into that category, and for the rest of it, this tends to be the path of least resistance.
Get the Full Details
