MODELS
Pre-train, fine-tune, and manage AI models
W&B Models helps you pre-train, fine-tune, govern, and manage models from experimentation to production, accelerating time to market. It boosts experiment speed and team collaboration to bring models to production faster while ensuring performance, data reliability, and security.
Run more experiments, analyze results interactively, and quickly build higher-quality models. Centralize the tracking of models, datasets, metadata, and their lineage in W&B Registry to support governance, reproducibility, and CI/CD. Automate workflows for training, evaluation, and deployment to enable rapid iteration.
Now available:
Weights & Biases mobile app
The first iOS app to monitor AI experiments and track training runs anytime, anywhere.
Accelerate experiment velocity
Track, version, compare, and reproduce experiments across multimodal workflows with just a few lines of code, reducing experiment tracking from hours to minutes. Run hundreds of thousands of experiments and build higher quality models faster. Advanced visualization tools make it easy to explore multimodal data, uncover insights, perform qualitative evaluations, and quickly identify improvements or regressions.
Access CoreWeave infrastructure observability in your workspace
When training on CoreWeave, W&B Models automatically synthesizes information about infrastructure events such as service bottlenecks, GPU errors, and network timeouts, from CoreWeave’s Mission Control, the system continuously monitoring and repairing your infrastructure. Get timelines, event descriptions, and expert remediation tips directly within your W&B workspace, fully contextualized to your training runs. Skip the hassle of digging through unfamiliar dashboards and system logs. Quickly troubleshoot, optimize, and elevate your training and fine-tuning jobs.
Extensive system metrics tracking
W&B Models offers pre-built integrations with hardware platforms like NVIDIA, tracking a full range of GPU/CPU system metrics out of the box. Using W&B Models, you can visualize this data side by side with other metrics to maximize GPU utilization and cut training costs. No hassle of setting up system metrics logging yourself.
Manage models centrally
After training, you can publish and share models, datasets, and metadata in the Registry, creating a single source of truth for all your AI assets. This enables reproducibility, versioning, lineage tracking, and continuous integration/deployment (CI/CD).
Debug RL fine-tuning runs with W&B Weave traces
The Weave Traces panel in W&B Models lets you inspect detailed agent trajectories at every step of an RL fine-tuning run, visualize rollouts, and correlate metrics to the underlying trajectories. Weights & Biases integrates with popular RL frameworks, including OpenPipe’s ART, Prime Intellect’s Verifiers, and ByteDance’s VERL, to auto-log Weave Traces alongside your metrics during fine-tuning.
Scale with performance
W&B Models is built to support large-scale and long-running experiments and extensive data logging. Run 100,000+ experiments with thousands of metrics and millions of data points at fast logging performance. Quickly upload and download large model files at frontier AI scale.
Infinite scale, responsive UI
100K+
Visualize experiments interactively at any scale, no limit on visible runs
1000’s of metrics with correlations
Full fidelity charts with every data spike visible on the graph
Hyperscale data ingestion
1M+
data points per second ingestion speed
Redundancy controls to prevent data loss
Built-in support for distributed training
Long-running experiments
Run forking for monitoring months-long experiments
Replay mechanism if part of ingestion fails due to system or network issues
Asynchronous streaming data ingestion
Improve governance and security
Use the Registry and lineage graphs to reproduce the exact recipe for a given model to improve collaboration and regulatory compliance. W&B Models provides enterprise security with endpoint protection, encryption, and backup controls. It offers fine-grained, role-based access through custom roles, teams, and projects, allowing secure data sharing with appropriate access levels. Your data is protected with robust encryption: TLS 1.2+ for in-transit and AES 256 for at-rest, ensuring security throughout the data lifecycle.
Built-in integrations
Easily integrate with your existing ML development stack with no vendor or framework lock-in. With thousands of integrations for the most commonly used ML frameworks, libraries, and repos, the W&B SDK works with the tools your team uses every day.
INTEGRATE QUICKLY
LANGCHAIN
LLAMAINDEX
PyTorch
HF Transformers
Lightning
TensorFlow
Keras
Scikit-LEARN
XGBoost
import wandb
# 1. Start a W&B run
run = wandb.init(project="my_first_project")
# 2. Save model inputs and hyperparameters
config = wandb.config
config.learning_rate = 0.01
# 3. Log metrics to visualize performance over time
for i in range(10):
run.log({"loss": 2**-i})
Copy
import weave
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
# Initialize Weave with your project name
weave.init("langchain_demo")
llm = ChatOpenAI()
prompt = PromptTemplate.from_template("1 + {number} = ")
llm_chain = prompt | llm
output = llm_chain.invoke({"number": 2})
print(output)
Copy
import weave
from llama_index.core.chat_engine import SimpleChatEngine
# Initialize Weave with your project name
weave.init("llamaindex_demo")
chat_engine = SimpleChatEngine.from_defaults()
response = chat_engine.chat(
"Say something profound and romantic about fourth of July"
)
print(response)
Copy
import wandb
# 1. Start a new run
run = wandb.init(project="gpt5")
# 2. Save model inputs and hyperparameters
config = run.config
config.dropout = 0.01
# 3. Log gradients and model parameters
run.watch(model)
for batch_idx, (data, target) in enumerate(train_loader):
...
if batch_idx % args.log_interval == 0:
# 4. Log metrics to visualize performance
run.log({"loss": loss})
Copy
import wandb
# 1. Define which wandb project to log to and name your run
run = wandb.init(project="gpt-5",
run_name="gpt-5-base-high-lr")
# 2. Add wandb in your `TrainingArguments`
args = TrainingArguments(..., report_to="wandb")
# 3. W&B logging will begin automatically when your start training your Trainer
trainer = Trainer(..., args=args)
trainer.train()
Copy
from lightning.pytorch.loggers import WandbLogger
# initialise the logger
wandb_logger = WandbLogger(project="llama-4-fine-tune")
# add configs such as batch size etc to the wandb config
wandb_logger.experiment.config["batch_size"] = batch_size
# pass wandb_logger to the Trainer
trainer = Trainer(..., logger=wandb_logger)
# train the model
trainer.fit(...)
Copy
import wandb
# 1. Start a new run
run = wandb.init(project="gpt4")
# 2. Save model inputs and hyperparameters
config = wandb.config
config.learning_rate = 0.01
# Model training here
# 3. Log metrics to visualize performance over time
with tf.Session() as sess:
# ...
wandb.tensorflow.log(tf.summary.merge_all())
Copy
import wandb
from wandb.keras import (
WandbMetricsLogger,
WandbModelCheckpoint,
)
# 1. Start a new run
run = wandb.init(project="gpt-4")
# 2. Save model inputs and hyperparameters
config = wandb.config
config.learning_rate = 0.01
... # Define a model
# 3. Log layer dimensions and metrics
wandb_callbacks = [\
WandbMetricsLogger(log_freq=5),\
WandbModelCheckpoint("models"),\
]
model.fit(
X_train, y_train, validation_data=(X_test, y_test),
callbacks=wandb_callbacks,
)
Copy
import wandb
wandb.init(project="visualize-sklearn")
# Model training here
# Log classifier visualizations
wandb.sklearn.plot_classifier(clf, X_train, X_test, y_train, y_test, y_pred, y_probas, labels,
model_name="SVC", feature_names=None)
# Log regression visualizations
wandb.sklearn.plot_regressor(reg, X_train, X_test, y_train, y_test, model_name="Ridge")
# Log clustering visualizations
wandb.sklearn.plot_clusterer(kmeans, X_train, cluster_labels, labels=None, model_name="KMeans")
Copy
import wandb
from wandb.xgboost import wandb_callback
# 1. Start a new run
run = wandb.init(project="visualize-models")
# 2. Add the callback
bst = xgboost.train(param, xg_train, num_round, watchlist, callbacks=[wandb_callback()])
# Get predictions
pred = bst.predict(xg_test)
Copy
Flexibility of deployment options
W&B Models gives you a choice of deployment options, including multi-tenant and dedicated cloud environments managed by us, as well as on-premises and private cloud environments that you manage independently.