Weights & Biases (W&B)：像专业人士一样跟踪每个实验 — ML 实验平台 2026

import wandb

# Initialize a new run with your configuration
wandb.init(
    project="my-nlp-finetune",
    config={
        "learning_rate": 2e-5,
        "batch_size": 32,
        "epochs": 3,
        "model": "bert-base-uncased",
    }
)

for epoch in range(config.epochs):
    for batch in train_dataloader:
        loss = model.train_step(batch)
        # Log metrics — W&B handles the rest
        wandb.log({"train_loss": loss, "lr": config.learning_rate})

pip install wandb

wandb login
# Paste your API key from https://wandb.ai/authorize

docker pull wandb/launch
docker run -e WANDB_API_KEY=$WANDB_API_KEY \
  -v /path/to/code:/app wandb/launch python train.py

pip install wandb transformers
# W&B is pre-configured for Hugging Face Trainer

import pytorch_lightning as pl
from pytorch_lightning.callbacks import WandbCallback

class MyModel(pl.LightningModule):
    def training_step(self, batch, batch_idx):
        loss = self.forward(batch)
        self.log("train_loss", loss)
        return loss

# W&B callback auto-logs everything
trainer = pl.Trainer(callbacks=[WandbCallback()])
trainer.fit(model)

from transformers import Trainer, TrainingArguments
import wandb

training_args = TrainingArguments(
    output_dir="./results",
    report_to="wandb",  # Enable W&B reporting
    num_train_epochs=3,
    per_device_train_batch_size=16,
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
)
trainer.train()

import ray
from ray import tune
import wandb

ray.init()

def train_model(config):
    # W&B automatically captures the sweep config
    wandb.init(config=config)
    score = my_training_function(config)
    wandb.log({"score": score})

sweep = tune.run(
    train_model,
    config={
        "learning_rate": tune.choice([1e-4, 2e-5, 5e-5]),
        "batch_size": tune.choice([16, 32, 64]),
    },
    metric="score",
    mode="max",
)

# Log a confusion matrix as a W&B table
import numpy as np
import wandb

conf_matrix = compute_confusion_matrix(y_true, y_pred)
wandb.log({
    "confusion_matrix": wandb.plot.confusion_matrix(
        probs=None,
        preds=conf_matrix,
        class_names=["Cat", "Dog", "Bird"]
    )
})

# Version a dataset as an artifact
artifact = wandb.Artifact("training_data", type="dataset")
artifact.add_file("dataset.csv")
wandb.log_artifact(artifact)

# Log a model checkpoint as an artifact
model_artifact = wandb.Artifact("best_model", type="model")
model_artifact.add(model, "model.pt")

# Tag it for easy retrieval
wandb.log_artifact(model_artifact, aliases=["best", "v1.0"])

# Later, retrieve the exact version
run = wandb.init()
art = run.use_artifact("project/model:v1", type="model")
path = art.download()

# Create a report with custom panels
report = wandb.Report(
    title="Experiment Results",
    slides=[
        ("Overview", wandb.plot.line_series(
            xs="step", ys="loss", keys=["train_loss", "val_loss"],
            title="Training Loss Curve"
        )),
        ("Comparison", wandb.plot.bar(
            wandb.Table(columns=["run", "accuracy"],
            data=[["run-a", 0.92], ["run-b", 0.89]])
        )),
    ]
)
report.save("experiment-report")

# sweeps.yaml
name: nlp-sweep
program: train.py
metric:
  name: val_accuracy
  goal: maximize
parameters:
  learning_rate:
    values: [1e-5, 2e-5, 5e-5, 1e-4]
  optimizer:
    values: [adamw, adam]
  warmup_ratio:
    min: 0.0
    max: 0.1
command:
  - python
  - train.py

wandb sweep sweeps.yaml
wandb agent $SWEEP_ID

# Log model to the registry
run.log_model(
    path="./fine_tuned_model",
    name="my-nlp-model",
    aliases=["staging", "production"]
)

# Transition model to production
api = wandb.Api()
model = api.model("my-nlp-model:staging")
model.change_alias("production")

import wandb
import torch
from torch.optim import AdamW

wandb.init(project="custom-training")
config = wandb.config
config.learning_rate = 1e-4
config.batch_size = 64

model = MyModel()
optimizer = AdamW(model.parameters(), lr=config.learning_rate)

for epoch in range(config.epochs):
    model.train()
    epoch_loss = 0
    for i, (x, y) in enumerate(train_loader):
        optimizer.zero_grad()
        output = model(x)
        loss = criterion(output, y)
        loss.backward()
        optimizer.step()
        epoch_loss += loss.item()
        
        # Log every 100 steps
        if i % 100 == 0:
            wandb.log({
                "train_loss": loss.item(),
                "learning_rate": config.learning_rate,
                "epoch": epoch
            })
    
    # Log epoch summary
    wandb.log({
        "epoch_loss_avg": epoch_loss / len(train_loader),
        "epoch": epoch,
    })

# Create and log a dataset artifact
dataset_artifact = wandb.Artifact(
    name="cleaned_dataset",
    type="dataset",
    description="Cleaned and tokenized training data",
)

# Add files
dataset_artifact.add_file("data/train.csv")
dataset_artifact.add_file("data/val.csv")
dataset_artifact.add_file("data/test.csv")

# Log with alias for versioning
wandb.log_artifact(dataset_artifact, aliases=["latest", "v1.2"])

# Later, use this exact dataset version
run = wandb.init()
clean_data = run.use_artifact("project/cleaned_dataset:v1.2", type="dataset")
data_path = clean_data.download()