Weights & Biases – iAIFeed https://www.iaifeed.com iAIFeed Mon, 12 Oct 2026 12:44:22 +0000 en-US hourly 1 https://wordpress.org/?v=7.1.3 https://www.iaifeed.com/wp-content/uploads/2026/07/cropped-iaifeed1-80x80.png Weights & Biases – iAIFeed https://www.iaifeed.com 32 32 How to Version ML Datasets and Models With W&B Artifacts https://www.iaifeed.com/how-to-version-ml-datasets-and-models-with-wb-artifacts https://www.iaifeed.com/how-to-version-ml-datasets-and-models-with-wb-artifacts#respond Mon, 12 Oct 2026 12:44:22 +0000 https://www.iaifeed.com/how-to-version-ml-datasets-and-models-with-wb-artifacts Tracking metrics is half the job. The other half is knowing which dataset and which weights produced those metrics. Weights & Biases calls these versioned files artifacts, and they turn an experiment log into a reproducible record.

Quick answer: Log files with run.log_artifact(path, type="dataset"), consume them with run.use_artifact("...:latest"), and W&B gives each version a hash and a lineage graph linking data to model.

Most teams adopt artifacts only after a painful incident — a model that cannot be retrained because the exact training split is gone. Setting it up beforehand is cheap; reconstructing it afterward is not.

How do you log a dataset as an artifact?

import wandb

run = wandb.init(project="churn-model", job_type="data-prep")
art = wandb.Artifact("training-data", type="dataset",
                     description="Churn data through 2026-09")
art.add_file("data/train.parquet")
run.log_artifact(art)
run.finish()

W&B hashes the contents and gives you a version like v0, v1. Change one byte and the next version is distinct — no manual numbering.

How do you consume an artifact in training?

run = wandb.init(project="churn-model", job_type="train")
data = run.use_artifact("training-data:latest")
path = data.download()

# train...
model = wandb.Artifact("churn-classifier", type="model")
model.add_file("model.pt")
run.log_artifact(model)
run.finish()

Because training calls use_artifact, W&B records the exact dataset version in the run’s lineage. Months later you can trace a model back to the data it saw.

What do the version aliases mean?

Alias Meaning
v0, v1 Immutable version numbers
latest Newest version of that artifact
best Whatever you alias as best
production Alias for the deployed version

Aliases move; versions do not. Point your deployment at production and promote a new version to that alias when you are ready — the old one stays available for rollback.

How do you promote and roll back a model?

# promote\nart = run.use_artifact("churn-classifier:v3")
art.aliases.append("production")
art.save()

Rolling back is the same call with the previous version. Because every version persists, you are never stuck with a bad deploy once you catch it.

What are the storage and cost limits?

Artifact storage counts against your plan’s quota. The free tier covers personal projects with a few gigabytes; datasets of images or video blow through that quickly and push you to a paid team plan. Model checkpoints are the usual culprit — log the final weights, not every epoch.

What trips people up?

  • Logging large artifacts every step fills your quota fast; log at the end.
  • Forgetting to call run.finish() leaves the run open and the artifact pending.
  • Downloading to the same path each time overwrites local files silently.
  • Aliases are per-artifact, so best on one model is unrelated to best on another.

Who this suits: teams shipping models to production who need rollback and audit trails. Who should skip it: if you train locally on one dataset and never redeploy, a git repo for code plus a folder of weights is honestly sufficient.

Quick Summary

  • Artifacts version datasets and model weights with automatic content hashing.
  • Log with log_artifact, consume with use_artifact to build lineage.
  • Aliases like production enable one-call promotion and rollback.
  • Versions are immutable, so old models stay reproducible.
  • Storage counts against your plan — do not log every checkpoint.
]]> https://www.iaifeed.com/how-to-version-ml-datasets-and-models-with-wb-artifacts/feed 0 How to Track Machine Learning Experiments With Weights & Biases https://www.iaifeed.com/how-to-track-ml-experiments-with-weights-and-biases https://www.iaifeed.com/how-to-track-ml-experiments-with-weights-and-biases#respond Mon, 12 Oct 2026 12:43:57 +0000 https://www.iaifeed.com/how-to-track-ml-experiments-with-weights-and-biases Weights & Biases is an experiment tracking platform. You add a few lines to your training script and it records metrics, configs, and model files to a dashboard where you can compare runs.

Quick answer: pip install wandb, run wandb login, then call wandb.init() and wandb.log() inside your training loop. Free for personal projects and academic use.

The honest case for it: if you have ever trained five variants and could not remember which learning rate was which, you need this. If you train one model once, a print statement is fine.

How do you install and log in?

pip install wandb
wandb login

wandb login opens a browser for an API key. On a headless server, set WANDB_API_KEY as an environment variable instead and the client picks it up.

How do you log a training run?

import wandb

wandb.init(project="churn-model",
           config={"lr": 1e-3, "batch_size": 64, "epochs": 20})

for epoch in range(20):
    train_loss = train_one_epoch()
    val_loss = evaluate()
    wandb.log({"train_loss": train_loss,
               "val_loss": val_loss, "epoch": epoch})

wandb.finish()

The config dictionary is what makes runs comparable. Anything you put there shows up as a filterable column in the dashboard.

How do you compare runs?

Each wandb.init() is one run. Open the project dashboard and you get a table of runs with their configs, plus overlay charts that plot every run’s loss curve on one axis. Sorting by final validation loss tells you which config won in one glance.

What are runs and artifacts?

Concept What it holds
Run One execution: metrics, config, logs
Artifact Versioned files: datasets, model weights
Sweep A grid or Bayesian hyperparameter search
Report A shareable write-up with live charts

Artifacts are the underused feature. Version your dataset and your trained weights, and you can reproduce a run months later instead of hunting through folders.

How do you run a hyperparameter sweep?

sweep = {"method": "bayes",
         "metric": {"name": "val_loss", "goal": "minimize"},
         "parameters": {"lr": {"values": [1e-4, 1e-3, 1e-2]},
                        "batch_size": {"values": [32, 64, 128]}}}

sweep_id = wandb.sweep(sweep, project="churn-model")
wandb.agent(sweep_id, function=train)

The Bayesian method usually finds a good config in fewer runs than a full grid. You can stop a sweep early once the best metric plateaus.

Is W&B free?

Free for personal projects and academic use, with limits on storage and team members. Team and enterprise plans bill per seat and add private projects, SSO, and longer retention. For a solo practitioner the free tier is usually enough for a long time.

What are the downsides?

  • Runs are logged to their cloud by default; offline mode exists but you lose the live dashboard.
  • Logging every step of a huge run can slow training if you are careless with frequency.
  • Free-tier storage is not unlimited — large artifacts can hit the cap.
  • The Python API is stable, but the product surface changes often.

Who this suits: anyone running repeated experiments, especially teams who need to share results. Who should skip it: one-off training jobs where a text log already answers every question you have.

Quick Summary

  • W&B logs metrics, configs, and artifacts from any Python training script.
  • Use wandb.init, wandb.log, and wandb.finish in that order.
  • Config dictionaries make runs filterable and comparable.
  • Artifacts version datasets and model weights for later reproduction.
  • Free for personal and academic use; paid for teams.
]]> https://www.iaifeed.com/how-to-track-ml-experiments-with-weights-and-biases/feed 0