Models
Train, fine-tune, and manage AI models
W&B Models helps you 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 them interactively, and quickly build higher-quality models. Centralize the tracking of models, datasets, metadata, and their lineage in the Registry to support governance, reproducibility, and CI/CD. Automate workflows for training, evaluation, and deployment to enable rapid iteration.
Accelerate experiment velocity
Track, version, and visualize experiments with just a few lines of code. Run hundreds of thousands of experiments faster and produce higher quality models more quickly. Easily visualize and analyze experiment results and uncover insights.
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).
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
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.
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.
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.
Learn what you can track
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.
See our integrations
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})
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)
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)
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})
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()
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(...)
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())
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,
)
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")
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)
Secure deployment for enterprises
Saas cloud
Dedicated cloud
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.
Get started with one line of code
The Weights & Biases platform helps you streamline your workflow from end to end
Models
Weave
The Weights & Biases platform helps you streamline your workflow from end to end
Models
Experiments
Track and visualize your ML experiments
Sweeps
Optimize your hyperparameters
Registry
Publish and share your ML models and datasets
Automations
Trigger workflows automatically
Weave
Traces
Explore and
debug LLMs
Evaluations
Rigorous evaluations of GenAI applications