TensorBoard 使用教程：PyTorch/TensorFlow 机器学习可视化工具安装与实战

tensorboard by davila7/claude-code-templates

241 周安装量

27,000 GitHub Stars

GitHub

安装命令

npx skills add https://github.com/davila7/claude-code-templates --skill tensorboard

AI/机器学习数据可视化调试

🇨🇳中文介绍

TensorBoard：机器学习可视化工具包

何时使用此技能

在以下场景中使用 TensorBoard：

可视化训练指标，例如随时间变化的损失和准确率
通过直方图和分布图调试模型
比较多次实验运行的结果
可视化模型图和架构
将嵌入向量投影到低维空间（t-SNE、PCA）
跟踪超参数实验
分析性能并识别瓶颈
可视化训练过程中的图像和文本

用户：年下载量 2000 万+ | GitHub 星标：2.7 万+ | 许可证：Apache 2.0

安装

# 安装 TensorBoard
pip install tensorboard

# PyTorch 集成
pip install torch torchvision tensorboard

# TensorFlow 集成（包含 TensorBoard）
pip install tensorflow

# 启动 TensorBoard
tensorboard --logdir=runs
# 访问地址：http://localhost:6006

快速开始

PyTorch

from torch.utils.tensorboard import SummaryWriter

# 创建写入器
writer = SummaryWriter('runs/experiment_1')

# 训练循环
for epoch in range(10):
    train_loss = train_epoch()
    val_acc = validate()

    # 记录指标
    writer.add_scalar('Loss/train', train_loss, epoch)
    writer.add_scalar('Accuracy/val', val_acc, epoch)

# 关闭写入器
writer.close()

# 启动：tensorboard --logdir=runs

广告位招租

在这里展示您的产品或服务

触达数万 AI 开发者，精准高效

联系我们

1. SummaryWriter (PyTorch)

from torch.utils.tensorboard import SummaryWriter

# 默认目录：runs/CURRENT_DATETIME
writer = SummaryWriter()

# 自定义目录
writer = SummaryWriter('runs/experiment_1')

# 自定义注释（附加到默认目录）
writer = SummaryWriter(comment='baseline')

# 记录数据
writer.add_scalar('Loss/train', 0.5, step=0)
writer.add_scalar('Loss/train', 0.3, step=1)

# 刷新并关闭
writer.flush()
writer.close()

# PyTorch
from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter()

for epoch in range(100):
    train_loss = train()
    val_loss = validate()

    # 记录单个指标
    writer.add_scalar('Loss/train', train_loss, epoch)
    writer.add_scalar('Loss/val', val_loss, epoch)
    writer.add_scalar('Accuracy/train', train_acc, epoch)
    writer.add_scalar('Accuracy/val', val_acc, epoch)

    # 学习率
    lr = optimizer.param_groups[0]['lr']
    writer.add_scalar('Learning_rate', lr, epoch)

writer.close()

# TensorFlow
import tensorflow as tf

train_summary_writer = tf.summary.create_file_writer('logs/train')
val_summary_writer = tf.summary.create_file_writer('logs/val')

for epoch in range(100):
    with train_summary_writer.as_default():
        tf.summary.scalar('loss', train_loss, step=epoch)
        tf.summary.scalar('accuracy', train_acc, step=epoch)

    with val_summary_writer.as_default():
        tf.summary.scalar('loss', val_loss, step=epoch)
        tf.summary.scalar('accuracy', val_acc, step=epoch)

3. 记录多个标量

# PyTorch: 分组相关指标
writer.add_scalars('Loss', {
    'train': train_loss,
    'validation': val_loss,
    'test': test_loss
}, epoch)

writer.add_scalars('Metrics', {
    'accuracy': accuracy,
    'precision': precision,
    'recall': recall,
    'f1': f1_score
}, epoch)

# PyTorch
import torch
from torchvision.utils import make_grid

# 单张图像
writer.add_image('Input/sample', img_tensor, epoch)

# 多张图像以网格形式显示
img_grid = make_grid(images[:64], nrow=8)
writer.add_image('Batch/inputs', img_grid, epoch)

# 预测结果可视化
pred_grid = make_grid(predictions[:16], nrow=4)
writer.add_image('Predictions', pred_grid, epoch)

# TensorFlow
import tensorflow as tf

with file_writer.as_default():
    # 将图像编码为 PNG
    tf.summary.image('Training samples', images, step=epoch, max_outputs=25)

# PyTorch: 跟踪权重分布
for name, param in model.named_parameters():
    writer.add_histogram(name, param, epoch)

    # 跟踪梯度
    if param.grad is not None:
        writer.add_histogram(f'{name}.grad', param.grad, epoch)

# 跟踪激活值
writer.add_histogram('Activations/relu1', activations, epoch)

# TensorFlow
with file_writer.as_default():
    tf.summary.histogram('weights/layer1', layer1.kernel, step=epoch)
    tf.summary.histogram('activations/relu1', activations, step=epoch)

# PyTorch
import torch

model = MyModel()
dummy_input = torch.randn(1, 3, 224, 224)

writer.add_graph(model, dummy_input)
writer.close()

# TensorFlow (Keras 自动记录)
tensorboard_callback = tf.keras.callbacks.TensorBoard(
    log_dir='logs',
    write_graph=True
)

model.fit(x, y, callbacks=[tensorboard_callback])

在 2D/3D 中可视化高维数据（嵌入向量、特征）。

import torch
from torch.utils.tensorboard import SummaryWriter

# 获取嵌入向量（例如，词嵌入、图像特征）
embeddings = model.get_embeddings(data)  # 形状：(N, embedding_dim)

# 元数据（每个点的标签）
metadata = ['class_1', 'class_2', 'class_1', ...]

# 图像（可选，用于图像嵌入）
label_images = torch.stack([img1, img2, img3, ...])

# 记录到 TensorBoard
writer.add_embedding(
    embeddings,
    metadata=metadata,
    label_img=label_images,
    global_step=epoch
)

在 TensorBoard 中：

导航到 "Projector" 选项卡
选择 PCA、t-SNE 或 UMAP 可视化
搜索、过滤和探索聚类

from torch.utils.tensorboard import SummaryWriter

# 尝试不同的超参数
for lr in [0.001, 0.01, 0.1]:
    for batch_size in [16, 32, 64]:
        # 创建唯一的运行目录
        writer = SummaryWriter(f'runs/lr{lr}_bs{batch_size}')

        # 记录超参数
        writer.add_hparams(
            {'lr': lr, 'batch_size': batch_size},
            {'hparam/accuracy': final_acc, 'hparam/loss': final_loss}
        )

        # 训练并记录
        for epoch in range(10):
            loss = train(lr, batch_size)
            writer.add_scalar('Loss/train', loss, epoch)

        writer.close()

# 在 TensorBoard 的 "HParams" 选项卡中比较

# PyTorch: 记录文本（例如，模型预测、摘要）
writer.add_text('Predictions', f'Epoch {epoch}: {predictions}', epoch)
writer.add_text('Config', str(config), 0)

# 记录 Markdown 表格
markdown_table = """
| Metric | Value |
|--------|-------|
| Accuracy | 0.95 |
| F1 Score | 0.93 |
"""
writer.add_text('Results', markdown_table, epoch)

用于分类的精确率-召回率曲线。

from torch.utils.tensorboard import SummaryWriter

# 获取预测和标签
predictions = model(test_data)  # 形状：(N, num_classes)
labels = test_labels  # 形状：(N,)

# 记录每个类别的 PR 曲线
for i in range(num_classes):
    writer.add_pr_curve(
        f'PR_curve/class_{i}',
        labels == i,
        predictions[:, i],
        global_step=epoch
    )

PyTorch 训练循环

import torch
import torch.nn as nn
from torch.utils.tensorboard import SummaryWriter

# 设置
writer = SummaryWriter('runs/resnet_experiment')
model = ResNet50()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()

# 记录模型图
dummy_input = torch.randn(1, 3, 224, 224)
writer.add_graph(model, dummy_input)

# 训练循环
for epoch in range(50):
    model.train()
    train_loss = 0.0
    train_correct = 0

    for batch_idx, (data, target) in enumerate(train_loader):
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

        train_loss += loss.item()
        pred = output.argmax(dim=1)
        train_correct += pred.eq(target).sum().item()

        # 记录批次指标（每 100 个批次）
        if batch_idx % 100 == 0:
            global_step = epoch * len(train_loader) + batch_idx
            writer.add_scalar('Loss/train_batch', loss.item(), global_step)

    # 周期指标
    train_loss /= len(train_loader)
    train_acc = train_correct / len(train_loader.dataset)

    # 验证
    model.eval()
    val_loss = 0.0
    val_correct = 0

    with torch.no_grad():
        for data, target in val_loader:
            output = model(data)
            val_loss += criterion(output, target).item()
            pred = output.argmax(dim=1)
            val_correct += pred.eq(target).sum().item()

    val_loss /= len(val_loader)
    val_acc = val_correct / len(val_loader.dataset)

    # 记录周期指标
    writer.add_scalars('Loss', {'train': train_loss, 'val': val_loss}, epoch)
    writer.add_scalars('Accuracy', {'train': train_acc, 'val': val_acc}, epoch)

    # 记录学习率
    writer.add_scalar('Learning_rate', optimizer.param_groups[0]['lr'], epoch)

    # 记录直方图（每 5 个周期）
    if epoch % 5 == 0:
        for name, param in model.named_parameters():
            writer.add_histogram(name, param, epoch)

    # 记录样本预测
    if epoch % 10 == 0:
        sample_images = data[:8]
        writer.add_image('Sample_inputs', make_grid(sample_images), epoch)

writer.close()

TensorFlow/Keras 训练

import tensorflow as tf

# 定义模型
model = tf.keras.models.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu', input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# TensorBoard 回调
tensorboard_callback = tf.keras.callbacks.TensorBoard(
    log_dir='logs/fit',
    histogram_freq=1,          # 每个周期记录直方图
    write_graph=True,          # 可视化模型图
    write_images=True,         # 将权重可视化为图像
    update_freq='epoch',       # 每个周期记录指标
    profile_batch='500,520',   # 分析第 500-520 批次
    embeddings_freq=1          # 每个周期记录嵌入向量
)

# 训练
model.fit(
    x_train, y_train,
    epochs=10,
    validation_data=(x_val, y_val),
    callbacks=[tensorboard_callback]
)

# 使用不同配置运行实验
python train.py --lr 0.001 --logdir runs/exp1
python train.py --lr 0.01 --logdir runs/exp2
python train.py --lr 0.1 --logdir runs/exp3

# 一起查看所有运行
tensorboard --logdir=runs

在 TensorBoard 中：

所有运行出现在同一个仪表板中
切换运行的显示/隐藏以进行比较
使用正则表达式过滤运行名称
叠加图表以比较指标

# 分层组织
runs/
├── baseline/
│   ├── run_1/
│   └── run_2/
├── improved/
│   ├── run_1/
│   └── run_2/
└── final/
    └── run_1/

# 使用层次结构记录
writer = SummaryWriter('runs/baseline/run_1')

1. 使用描述性的运行名称

# ✅ 良好：描述性名称
from datetime import datetime
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
writer = SummaryWriter(f'runs/resnet50_lr0.001_bs32_{timestamp}')

# ❌ 不佳：自动生成的名称
writer = SummaryWriter()  # 创建 runs/Jan01_12-34-56_hostname

2. 分组相关指标

# ✅ 良好：分组指标
writer.add_scalar('Loss/train', train_loss, step)
writer.add_scalar('Loss/val', val_loss, step)
writer.add_scalar('Accuracy/train', train_acc, step)
writer.add_scalar('Accuracy/val', val_acc, step)

# ❌ 不佳：扁平命名空间
writer.add_scalar('train_loss', train_loss, step)
writer.add_scalar('val_loss', val_loss, step)

3. 定期记录但不要过于频繁

# ✅ 良好：始终记录周期指标，偶尔记录批次指标
for epoch in range(100):
    for batch_idx, (data, target) in enumerate(train_loader):
        loss = train_step(data, target)

        # 每 100 个批次记录一次
        if batch_idx % 100 == 0:
            writer.add_scalar('Loss/batch', loss, global_step)

    # 始终记录周期指标
    writer.add_scalar('Loss/epoch', epoch_loss, epoch)

# ❌ 不佳：记录每个批次（创建巨大的日志文件）
for batch in train_loader:
    writer.add_scalar('Loss', loss, step)  # 过于频繁

4. 完成后关闭写入器

# ✅ 良好：使用上下文管理器
with SummaryWriter('runs/exp1') as writer:
    for epoch in range(10):
        writer.add_scalar('Loss', loss, epoch)
# 自动关闭

# 或手动关闭
writer = SummaryWriter('runs/exp1')
# ... 记录 ...
writer.close()

5. 为训练/验证使用独立的写入器

# ✅ 良好：独立的日志目录
train_writer = SummaryWriter('runs/exp1/train')
val_writer = SummaryWriter('runs/exp1/val')

train_writer.add_scalar('loss', train_loss, epoch)
val_writer.add_scalar('loss', val_loss, epoch)

# 启用性能分析
tensorboard_callback = tf.keras.callbacks.TensorBoard(
    log_dir='logs',
    profile_batch='10,20'  # 分析第 10-20 批次
)

model.fit(x, y, callbacks=[tensorboard_callback])

# 在 TensorBoard Profile 选项卡中查看
# 显示：GPU 利用率、内核统计、内存使用、瓶颈

import torch.profiler as profiler

with profiler.profile(
    activities=[
        profiler.ProfilerActivity.CPU,
        profiler.ProfilerActivity.CUDA
    ],
    on_trace_ready=torch.profiler.tensorboard_trace_handler('./runs/profiler'),
    record_shapes=True,
    with_stack=True
) as prof:
    for batch in train_loader:
        loss = train_step(batch)
        prof.step()

# 在 TensorBoard Profile 选项卡中查看

文档：https://www.tensorflow.org/tensorboard
PyTorch 集成：https://pytorch.org/docs/stable/tensorboard.html
GitHub：https://github.com/tensorflow/tensorboard (2.7 万+ 星标)
TensorBoard.dev：https://tensorboard.dev (公开分享实验)

references/visualization.md - 全面的可视化指南
references/profiling.md - 性能分析模式
references/integrations.md - 特定框架集成示例

2026 年 1 月 21 日

🇺🇸English

TensorBoard: Visualization Toolkit for ML

When to Use This Skill

Use TensorBoard when you need to:

Visualize training metrics like loss and accuracy over time
Debug models with histograms and distributions
Compare experiments across multiple runs
Visualize model graphs and architecture
Project embeddings to lower dimensions (t-SNE, PCA)
Track hyperparameter experiments
Profile performance and identify bottlenecks
Visualize images and text during training

Users : 20M+ downloads/year | GitHub Stars : 27k+ | License : Apache 2.0

Installation

# Install TensorBoard
pip install tensorboard

# PyTorch integration
pip install torch torchvision tensorboard

# TensorFlow integration (TensorBoard included)
pip install tensorflow

# Launch TensorBoard
tensorboard --logdir=runs
# Access at http://localhost:6006

Quick Start

PyTorch

from torch.utils.tensorboard import SummaryWriter

# Create writer
writer = SummaryWriter('runs/experiment_1')

# Training loop
for epoch in range(10):
    train_loss = train_epoch()
    val_acc = validate()

    # Log metrics
    writer.add_scalar('Loss/train', train_loss, epoch)
    writer.add_scalar('Accuracy/val', val_acc, epoch)

# Close writer
writer.close()

# Launch: tensorboard --logdir=runs

TensorFlow/Keras

import tensorflow as tf

# Create callback
tensorboard_callback = tf.keras.callbacks.TensorBoard(
    log_dir='logs/fit',
    histogram_freq=1
)

# Train model
model.fit(
    x_train, y_train,
    epochs=10,
    validation_data=(x_val, y_val),
    callbacks=[tensorboard_callback]
)

# Launch: tensorboard --logdir=logs

Core Concepts

1. SummaryWriter (PyTorch)

from torch.utils.tensorboard import SummaryWriter

# Default directory: runs/CURRENT_DATETIME
writer = SummaryWriter()

# Custom directory
writer = SummaryWriter('runs/experiment_1')

# Custom comment (appended to default directory)
writer = SummaryWriter(comment='baseline')

# Log data
writer.add_scalar('Loss/train', 0.5, step=0)
writer.add_scalar('Loss/train', 0.3, step=1)

# Flush and close
writer.flush()
writer.close()

2. Logging Scalars

# PyTorch
from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter()

for epoch in range(100):
    train_loss = train()
    val_loss = validate()

    # Log individual metrics
    writer.add_scalar('Loss/train', train_loss, epoch)
    writer.add_scalar('Loss/val', val_loss, epoch)
    writer.add_scalar('Accuracy/train', train_acc, epoch)
    writer.add_scalar('Accuracy/val', val_acc, epoch)

    # Learning rate
    lr = optimizer.param_groups[0]['lr']
    writer.add_scalar('Learning_rate', lr, epoch)

writer.close()



# TensorFlow
import tensorflow as tf

train_summary_writer = tf.summary.create_file_writer('logs/train')
val_summary_writer = tf.summary.create_file_writer('logs/val')

for epoch in range(100):
    with train_summary_writer.as_default():
        tf.summary.scalar('loss', train_loss, step=epoch)
        tf.summary.scalar('accuracy', train_acc, step=epoch)

    with val_summary_writer.as_default():
        tf.summary.scalar('loss', val_loss, step=epoch)
        tf.summary.scalar('accuracy', val_acc, step=epoch)

3. Logging Multiple Scalars

# PyTorch: Group related metrics
writer.add_scalars('Loss', {
    'train': train_loss,
    'validation': val_loss,
    'test': test_loss
}, epoch)

writer.add_scalars('Metrics', {
    'accuracy': accuracy,
    'precision': precision,
    'recall': recall,
    'f1': f1_score
}, epoch)

4. Logging Images

# PyTorch
import torch
from torchvision.utils import make_grid

# Single image
writer.add_image('Input/sample', img_tensor, epoch)

# Multiple images as grid
img_grid = make_grid(images[:64], nrow=8)
writer.add_image('Batch/inputs', img_grid, epoch)

# Predictions visualization
pred_grid = make_grid(predictions[:16], nrow=4)
writer.add_image('Predictions', pred_grid, epoch)



# TensorFlow
import tensorflow as tf

with file_writer.as_default():
    # Encode images as PNG
    tf.summary.image('Training samples', images, step=epoch, max_outputs=25)

5. Logging Histograms

# PyTorch: Track weight distributions
for name, param in model.named_parameters():
    writer.add_histogram(name, param, epoch)

    # Track gradients
    if param.grad is not None:
        writer.add_histogram(f'{name}.grad', param.grad, epoch)

# Track activations
writer.add_histogram('Activations/relu1', activations, epoch)



# TensorFlow
with file_writer.as_default():
    tf.summary.histogram('weights/layer1', layer1.kernel, step=epoch)
    tf.summary.histogram('activations/relu1', activations, step=epoch)

6. Logging Model Graph

# PyTorch
import torch

model = MyModel()
dummy_input = torch.randn(1, 3, 224, 224)

writer.add_graph(model, dummy_input)
writer.close()



# TensorFlow (automatic with Keras)
tensorboard_callback = tf.keras.callbacks.TensorBoard(
    log_dir='logs',
    write_graph=True
)

model.fit(x, y, callbacks=[tensorboard_callback])

Advanced Features

Embedding Projector

Visualize high-dimensional data (embeddings, features) in 2D/3D.

import torch
from torch.utils.tensorboard import SummaryWriter

# Get embeddings (e.g., word embeddings, image features)
embeddings = model.get_embeddings(data)  # Shape: (N, embedding_dim)

# Metadata (labels for each point)
metadata = ['class_1', 'class_2', 'class_1', ...]

# Images (optional, for image embeddings)
label_images = torch.stack([img1, img2, img3, ...])

# Log to TensorBoard
writer.add_embedding(
    embeddings,
    metadata=metadata,
    label_img=label_images,
    global_step=epoch
)

In TensorBoard:

Navigate to "Projector" tab
Choose PCA, t-SNE, or UMAP visualization
Search, filter, and explore clusters

Hyperparameter Tuning

from torch.utils.tensorboard import SummaryWriter

# Try different hyperparameters
for lr in [0.001, 0.01, 0.1]:
    for batch_size in [16, 32, 64]:
        # Create unique run directory
        writer = SummaryWriter(f'runs/lr{lr}_bs{batch_size}')

        # Log hyperparameters
        writer.add_hparams(
            {'lr': lr, 'batch_size': batch_size},
            {'hparam/accuracy': final_acc, 'hparam/loss': final_loss}
        )

        # Train and log
        for epoch in range(10):
            loss = train(lr, batch_size)
            writer.add_scalar('Loss/train', loss, epoch)

        writer.close()

# Compare in TensorBoard's "HParams" tab

Text Logging

# PyTorch: Log text (e.g., model predictions, summaries)
writer.add_text('Predictions', f'Epoch {epoch}: {predictions}', epoch)
writer.add_text('Config', str(config), 0)

# Log markdown tables
markdown_table = """
| Metric | Value |
|--------|-------|
| Accuracy | 0.95 |
| F1 Score | 0.93 |
"""
writer.add_text('Results', markdown_table, epoch)

PR Curves

Precision-Recall curves for classification.

from torch.utils.tensorboard import SummaryWriter

# Get predictions and labels
predictions = model(test_data)  # Shape: (N, num_classes)
labels = test_labels  # Shape: (N,)

# Log PR curve for each class
for i in range(num_classes):
    writer.add_pr_curve(
        f'PR_curve/class_{i}',
        labels == i,
        predictions[:, i],
        global_step=epoch
    )

Integration Examples

PyTorch Training Loop

import torch
import torch.nn as nn
from torch.utils.tensorboard import SummaryWriter

# Setup
writer = SummaryWriter('runs/resnet_experiment')
model = ResNet50()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()

# Log model graph
dummy_input = torch.randn(1, 3, 224, 224)
writer.add_graph(model, dummy_input)

# Training loop
for epoch in range(50):
    model.train()
    train_loss = 0.0
    train_correct = 0

    for batch_idx, (data, target) in enumerate(train_loader):
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

        train_loss += loss.item()
        pred = output.argmax(dim=1)
        train_correct += pred.eq(target).sum().item()

        # Log batch metrics (every 100 batches)
        if batch_idx % 100 == 0:
            global_step = epoch * len(train_loader) + batch_idx
            writer.add_scalar('Loss/train_batch', loss.item(), global_step)

    # Epoch metrics
    train_loss /= len(train_loader)
    train_acc = train_correct / len(train_loader.dataset)

    # Validation
    model.eval()
    val_loss = 0.0
    val_correct = 0

    with torch.no_grad():
        for data, target in val_loader:
            output = model(data)
            val_loss += criterion(output, target).item()
            pred = output.argmax(dim=1)
            val_correct += pred.eq(target).sum().item()

    val_loss /= len(val_loader)
    val_acc = val_correct / len(val_loader.dataset)

    # Log epoch metrics
    writer.add_scalars('Loss', {'train': train_loss, 'val': val_loss}, epoch)
    writer.add_scalars('Accuracy', {'train': train_acc, 'val': val_acc}, epoch)

    # Log learning rate
    writer.add_scalar('Learning_rate', optimizer.param_groups[0]['lr'], epoch)

    # Log histograms (every 5 epochs)
    if epoch % 5 == 0:
        for name, param in model.named_parameters():
            writer.add_histogram(name, param, epoch)

    # Log sample predictions
    if epoch % 10 == 0:
        sample_images = data[:8]
        writer.add_image('Sample_inputs', make_grid(sample_images), epoch)

writer.close()

TensorFlow/Keras Training

import tensorflow as tf

# Define model
model = tf.keras.models.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu', input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# TensorBoard callback
tensorboard_callback = tf.keras.callbacks.TensorBoard(
    log_dir='logs/fit',
    histogram_freq=1,          # Log histograms every epoch
    write_graph=True,          # Visualize model graph
    write_images=True,         # Visualize weights as images
    update_freq='epoch',       # Log metrics every epoch
    profile_batch='500,520',   # Profile batches 500-520
    embeddings_freq=1          # Log embeddings every epoch
)

# Train
model.fit(
    x_train, y_train,
    epochs=10,
    validation_data=(x_val, y_val),
    callbacks=[tensorboard_callback]
)

Comparing Experiments

Multiple Runs

# Run experiments with different configs
python train.py --lr 0.001 --logdir runs/exp1
python train.py --lr 0.01 --logdir runs/exp2
python train.py --lr 0.1 --logdir runs/exp3

# View all runs together
tensorboard --logdir=runs

In TensorBoard:

All runs appear in the same dashboard
Toggle runs on/off for comparison
Use regex to filter run names
Overlay charts to compare metrics

Organizing Experiments

# Hierarchical organization
runs/
├── baseline/
│   ├── run_1/
│   └── run_2/
├── improved/
│   ├── run_1/
│   └── run_2/
└── final/
    └── run_1/

# Log with hierarchy
writer = SummaryWriter('runs/baseline/run_1')

Best Practices

1. Use Descriptive Run Names

# ✅ Good: Descriptive names
from datetime import datetime
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
writer = SummaryWriter(f'runs/resnet50_lr0.001_bs32_{timestamp}')

# ❌ Bad: Auto-generated names
writer = SummaryWriter()  # Creates runs/Jan01_12-34-56_hostname

2. Group Related Metrics

# ✅ Good: Grouped metrics
writer.add_scalar('Loss/train', train_loss, step)
writer.add_scalar('Loss/val', val_loss, step)
writer.add_scalar('Accuracy/train', train_acc, step)
writer.add_scalar('Accuracy/val', val_acc, step)

# ❌ Bad: Flat namespace
writer.add_scalar('train_loss', train_loss, step)
writer.add_scalar('val_loss', val_loss, step)

3. Log Regularly but Not Too Often

# ✅ Good: Log epoch metrics always, batch metrics occasionally
for epoch in range(100):
    for batch_idx, (data, target) in enumerate(train_loader):
        loss = train_step(data, target)

        # Log every 100 batches
        if batch_idx % 100 == 0:
            writer.add_scalar('Loss/batch', loss, global_step)

    # Always log epoch metrics
    writer.add_scalar('Loss/epoch', epoch_loss, epoch)

# ❌ Bad: Log every batch (creates huge log files)
for batch in train_loader:
    writer.add_scalar('Loss', loss, step)  # Too frequent

4. Close Writer When Done

# ✅ Good: Use context manager
with SummaryWriter('runs/exp1') as writer:
    for epoch in range(10):
        writer.add_scalar('Loss', loss, epoch)
# Automatically closes

# Or manually
writer = SummaryWriter('runs/exp1')
# ... logging ...
writer.close()

5. Use Separate Writers for Train/Val

# ✅ Good: Separate log directories
train_writer = SummaryWriter('runs/exp1/train')
val_writer = SummaryWriter('runs/exp1/val')

train_writer.add_scalar('loss', train_loss, epoch)
val_writer.add_scalar('loss', val_loss, epoch)

Performance Profiling

TensorFlow Profiler

# Enable profiling
tensorboard_callback = tf.keras.callbacks.TensorBoard(
    log_dir='logs',
    profile_batch='10,20'  # Profile batches 10-20
)

model.fit(x, y, callbacks=[tensorboard_callback])

# View in TensorBoard Profile tab
# Shows: GPU utilization, kernel stats, memory usage, bottlenecks

PyTorch Profiler

import torch.profiler as profiler

with profiler.profile(
    activities=[
        profiler.ProfilerActivity.CPU,
        profiler.ProfilerActivity.CUDA
    ],
    on_trace_ready=torch.profiler.tensorboard_trace_handler('./runs/profiler'),
    record_shapes=True,
    with_stack=True
) as prof:
    for batch in train_loader:
        loss = train_step(batch)
        prof.step()

# View in TensorBoard Profile tab

Resources

Documentation : https://www.tensorflow.org/tensorboard
PyTorch Integration : https://pytorch.org/docs/stable/tensorboard.html
GitHub : https://github.com/tensorflow/tensorboard (27k+ stars)
TensorBoard.dev : https://tensorboard.dev (share experiments publicly)

TensorBoard 使用教程：PyTorch/TensorFlow 机器学习可视化工具安装与实战

🇨🇳中文介绍

TensorBoard：机器学习可视化工具包

何时使用此技能

安装

快速开始

PyTorch

相关 Skills

TensorFlow/Keras

核心概念

1. SummaryWriter (PyTorch)

2. 记录标量

3. 记录多个标量

4. 记录图像

5. 记录直方图

6. 记录模型图

高级功能

嵌入投影器

超参数调优

文本记录

PR 曲线

集成示例

PyTorch 训练循环

TensorFlow/Keras 训练

比较实验

多次运行

组织实验

最佳实践

1. 使用描述性的运行名称

2. 分组相关指标

3. 定期记录但不要过于频繁

4. 完成后关闭写入器

5. 为训练/验证使用独立的写入器

性能分析

TensorFlow Profiler

PyTorch Profiler

资源

另请参阅

🇺🇸English

TensorBoard: Visualization Toolkit for ML

When to Use This Skill

Installation

Quick Start

PyTorch

TensorFlow/Keras

Core Concepts

1. SummaryWriter (PyTorch)

2. Logging Scalars

3. Logging Multiple Scalars

4. Logging Images

5. Logging Histograms

6. Logging Model Graph

Advanced Features

Embedding Projector

Hyperparameter Tuning

Text Logging

PR Curves

Integration Examples

PyTorch Training Loop

TensorFlow/Keras Training

Comparing Experiments

Multiple Runs

Organizing Experiments

Best Practices

1. Use Descriptive Run Names

2. Group Related Metrics

3. Log Regularly but Not Too Often

4. Close Writer When Done

5. Use Separate Writers for Train/Val

Performance Profiling

TensorFlow Profiler

PyTorch Profiler

Resources

See Also

最新 Skills