Understanding the Target Audience

The target audience for this guide primarily consists of data scientists, machine learning engineers, and business analysts who are interested in enhancing their experiment tracking capabilities. They are likely to be in roles where they are responsible for developing and deploying machine learning models. Their pain points include difficulty in managing and tracking numerous experiments, a lack of real-time insights into model performance, and challenges in visualizing results in a meaningful way.

These professionals aim to streamline their workflows, improve productivity, and make data-driven decisions based on comprehensive metrics. They value clear, concise communication and prefer tutorials that provide hands-on, practical examples with code snippets that can be easily implemented.

Tutorial Overview

In this tutorial, we walk through Hugging Face Trackio step by step, exploring how to track experiments locally, cleanly, and intuitively. We begin by installing Trackio in Google Colab, preparing a dataset, and setting up multiple training runs with different hyperparameters. Along the way, we log metrics, visualize confusion matrices as tables, and demonstrate the flexibility of the tool by importing results from a CSV file. By running everything in one notebook, we gain hands-on experience with Trackio’s lightweight yet powerful dashboard, seeing our results update in real time.

Getting Started

First, we install the required libraries:

        !pip -q install -U trackio scikit-learn pandas matplotlib
        

Next, we import essential Python modules and machine learning utilities:

        import os, time, math, json, random, pathlib, itertools, tempfile
from dataclasses import dataclass
import numpy as np
import pandas as pd
from sklearn.datasets import make_classification
from sklearn.linear_model import SGDClassifier
from sklearn.metrics import accuracy_score, log_loss, confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import trackio
        

Dataset Creation

We create a synthetic dataset using the following function:

        def make_dataset(n=12000, n_informative=18, n_classes=3, seed=42):
   X, y = make_classification(
       n_samples=n, n_features=32, n_informative=n_informative, n_redundant=0,
       n_classes=n_classes, random_state=seed, class_sep=2.0
   )
   X_train, X_temp, y_train, y_temp = train_test_split(X, y, test_size=0.3, random_state=seed)
   X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, random_state=seed)
   ss = StandardScaler().fit(X_train)
   return ss.transform(X_train), y_train, ss.transform(X_val), y_val, ss.transform(X_test), y_test
        

Training and Logging

We define a configuration class to store our training settings and a function that runs an SGD classifier while logging metrics to Trackio:

        def train_and_log(cfg: RunCfg, Xtr, ytr, Xva, yva):
   run = trackio.init(
       project=cfg.project,
       name=f"sgd_lr{cfg.lr}_l2{cfg.l2}",
       config={"lr": cfg.lr, "l2": cfg.l2, "epochs": cfg.epochs, "batch_size": cfg.batch_size, "seed": cfg.seed}
   )
   clf = SGDClassifier(loss="log_loss", penalty="l2", alpha=cfg.l2, learning_rate="constant",
                       eta0=cfg.lr, random_state=cfg.seed)
   # ... (additional code) ...
   trackio.finish()
   return val_acc
        

This function tracks losses, accuracy, and confusion matrices across epochs, providing both numeric and visual insights into model performance in real time.

Hyperparameter Sweep

We run a small hyperparameter sweep over learning rates and L2 regularization:

        grid = list(itertools.product([0.01, 0.03, 0.1], [1e-5, 1e-4, 1e-3]))
results = []
for lr, l2 in grid:
   acc = train_and_log(RunCfg(lr=lr, l2=l2, seed=123), Xtr, ytr, Xva, yva)
   results.append({"lr": lr, "l2": l2, "val_acc": acc})
        

We summarize the results into a table, log the best configuration to Trackio, and finish the summary run.

Importing External Data

We simulate a CSV file of metrics and import it into Trackio:

        csv_path = "/content/trackio_demo_metrics.csv"
df_csv = pd.DataFrame({
   "step": np.arange(10),
   "metric_x": np.linspace(1.0, 0.2, 10),
   "metric_y": np.linspace(0.1, 0.9, 10),
})
df_csv.to_csv(csv_path, index=False)
trackio.import_csv(csv_path, project="trackio-csv-import")
        

This allows us to view both logged runs and external data side by side in Trackio’s interactive interface.

Conclusion

In this tutorial, we have explored how Trackio streamlines experiment tracking without the complexity of heavy infrastructure or API setups. We not only logged and compared runs but also captured structured results, imported external data, and launched an interactive dashboard directly inside Colab. This workflow empowers users to stay organized, monitor progress effectively, and make better decisions during experimentation.