调用 .watch 并传入你的 PyTorch 模型，即可自动记录梯度并存储网络拓扑结构。接下来，使用 .log 来跟踪其他指标。以下示例展示了如何操作：

import wandb

# 1. 开始一个新的运行
run = wandb.init(project="gpt4")

# 2. 保存模型输入和超参数
config = run.config
config.dropout = 0.01

# 3. 记录梯度和模型参数
run.watch(model)
for batch_idx, (data, target) in enumerate(train_loader):
    ...
    if batch_idx % args.log_interval == 0:
        # 4. 记录指标以可视化性能
        run.log({"loss": loss})

• 运行一个示例 Google Colab 笔记本。
• 阅读开发者指南，了解如何将 PyTorch 与 W&B 集成的技术细节。
• 探索W&B 报告。

以下代码示例展示了将 W&B 与 Keras 集成时脚本可能的样子：

# 此脚本需要安装以下库：
#   tensorflow, numpy

import wandb
from wandb.keras import WandbMetricsLogger, WandbModelCheckpoint

import random
import numpy as np
import tensorflow as tf


# 开始一次运行，跟踪超参数
run = wandb.init(
    # 设置本次运行将被记录的 W&B 项目
    project="my-awesome-project",
    # 使用 wandb.config 跟踪超参数和运行元数据
    config={
        "layer_1": 512,
        "activation_1": "relu",
        "dropout": random.uniform(0.01, 0.80),
        "layer_2": 10,
        "activation_2": "softmax",
        "optimizer": "sgd",
        "loss": "sparse_categorical_crossentropy",
        "metric": "accuracy",
        "epoch": 8,
        "batch_size": 256,
    },
)

# [可选] 使用 wandb.config 作为你的配置
config = run.config

# 获取数据
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
x_train, y_train = x_train[::5], y_train[::5]
x_test, y_test = x_test[::20], y_test[::20]
labels = [str(digit) for digit in range(np.max(y_train) + 1)]

# 构建模型
model = tf.keras.models.Sequential(
    [
        tf.keras.layers.Flatten(input_shape=(28, 28)),
        tf.keras.layers.Dense(config.layer_1, activation=config.activation_1),
        tf.keras.layers.Dropout(config.dropout),
        tf.keras.layers.Dense(config.layer_2, activation=config.activation_2),
    ]
)

# 编译模型
model.compile(optimizer=config.optimizer, loss=config.loss, metrics=[config.metric])

# WandbMetricsLogger 将训练和验证指标记录到 wandb
# WandbModelCheckpoint 将模型检查点上传到 wandb
history = model.fit(
    x=x_train,
    y=y_train,
    epochs=config.epoch,
    batch_size=config.batch_size,
    validation_data=(x_test, y_test),
    callbacks=[
        WandbMetricsLogger(log_freq=5),
        WandbModelCheckpoint("models"),
    ],
)

# [可选] 结束 W&B 运行，在笔记本中是必需的
run.finish()

立即开始将你的 Keras 模型与 W&B 集成吧：

• 运行一个示例 Google Colab 笔记本
• 阅读开发者指南，了解如何将 Keras 与 W&B 集成的技术细节。
• 探索W&B 报告。

在使用 HuggingFace Trainer 运行脚本时，将 wandb 传递给 report_to 参数。W&B 将自动记录损失、评估指标、模型拓扑和梯度。

注意：运行脚本的环境必须已安装 wandb。

以下示例展示了如何将 W&B 与 Hugging Face 集成：

# 此脚本需要安装以下库：
#   numpy, transformers, datasets

import wandb

import os
import numpy as np
from datasets import load_dataset
from transformers import TrainingArguments, Trainer
from transformers import AutoTokenizer, AutoModelForSequenceClassification


def tokenize_function(examples):
    return tokenizer(examples["text"], padding="max_length", truncation=True)


def compute_metrics(eval_pred):
    logits, labels = eval_pred
    predictions = np.argmax(logits, axis=-1)
    return {"accuracy": np.mean(predictions == labels)}


# 下载并准备数据
dataset = load_dataset("yelp_review_full")
tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")

small_train_dataset = dataset["train"].shuffle(seed=42).select(range(1000))
small_eval_dataset = dataset["test"].shuffle(seed=42).select(range(300))

small_train_dataset = small_train_dataset.map(tokenize_function, batched=True)
small_eval_dataset = small_eval_dataset.map(tokenize_function, batched=True)

# 下载模型
model = AutoModelForSequenceClassification.from_pretrained(
    "distilbert-base-uncased", num_labels=5
)

# 设置本次运行将被记录的 W&B 项目
os.environ["WANDB_PROJECT"] = "my-awesome-project"

# 将你训练好的模型检查点保存到 W&B
os.environ["WANDB_LOG_MODEL"] = "true"

# 关闭 watch 以加快日志记录速度
os.environ["WANDB_WATCH"] = "false"

# 将“wandb”传递给 `report_to` 参数以启用 W&B 日志记录
training_args = TrainingArguments(
    output_dir="models",
    report_to="wandb",
    logging_steps=5,
    per_device_train_batch_size=32,
    per_device_eval_batch_size=32,
    evaluation_strategy="steps",
    eval_steps=20,
    max_steps=100,
    save_steps=100,
)

# 定义训练器并开始训练
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=small_train_dataset,
    eval_dataset=small_eval_dataset,
    compute_metrics=compute_metrics,
)
trainer.train()

# [可选] 完成 wandb 运行，在笔记本中是必需的
wandb.finish()

• 运行一个示例 Google Colab Notebook。
• 阅读开发者指南，了解如何将 Hugging Face 与 W&B 集成的技术细节。

使用 Lightning 构建可扩展、结构化、高性能的 PyTorch 模型，并通过 W&B 进行日志记录。

# 此脚本需要安装以下库：
#   torch, torchvision, pytorch_lightning

import wandb

import os
from torch import optim, nn, utils
from torchvision.datasets import MNIST
from torchvision.transforms import ToTensor

import pytorch_lightning as pl
from pytorch_lightning.loggers import WandbLogger


class LitAutoEncoder(pl.LightningModule):
    def __init__(self, lr=1e-3, inp_size=28, optimizer="Adam"):
        super().__init__()

        self.encoder = nn.Sequential(
            nn.Linear(inp_size * inp_size, 64), nn.ReLU(), nn.Linear(64, 3)
        )
        self.decoder = nn.Sequential(
            nn.Linear(3, 64), nn.ReLU(), nn.Linear(64, inp_size * inp_size)
        )
        self.lr = lr

        # 将超参数保存到 self.hparams 中，由 wandb 自动记录
        self.save_hyperparameters()

    def training_step(self, batch, batch_idx):
        x, y = batch
        x = x.view(x.size(0), -1)
        z = self.encoder(x)
        x_hat = self.decoder(z)
        loss = nn.functional.mse_loss(x_hat, x)

        # 将指标记录到 wandb
        self.log("train_loss", loss)
        return loss

    def configure_optimizers(self):
        optimizer = optim.Adam(self.parameters(), lr=self.lr)
        return optimizer


# 初始化自编码器
autoencoder = LitAutoEncoder(lr=1e-3, inp_size=28)

# 准备数据
batch_size = 32
dataset = MNIST(os.getcwd(), download=True, transform=ToTensor())
train_loader = utils.data.DataLoader(dataset, shuffle=True)

# 初始化 wandb 日志记录器并命名你的 wandb 项目
wandb_logger = WandbLogger(project="my-awesome-project")

# 将你的批量大小添加到 wandb 配置中
wandb_logger.experiment.config["batch_size"] = batch_size

# 将 wandb_logger 传递给 Trainer
trainer = pl.Trainer(limit_train_batches=750, max_epochs=5, logger=wandb_logger)

# 训练模型
trainer.fit(model=autoencoder, train_dataloaders=train_loader)

# [可选] 完成 wandb 运行，在笔记本中是必需的
wandb.finish()

• 运行一个示例 Google Colab Notebook。
• 阅读开发者指南，了解如何将 PyTorch Lightning 与 W&B 集成的技术细节。

以下代码示例展示了您的脚本在与 XGBoost 集成 W&B 时可能的样子：

# 此脚本需要安装以下库：
#   numpy, xgboost

import wandb
from wandb.xgboost import WandbCallback

import numpy as np
import xgboost as xgb


# 设置 XGBoost 参数
param = {
    "objective": "multi:softmax",
    "eta": 0.1,
    "max_depth": 6,
    "nthread": 4,
    "num_class": 6,
}

# 开始一个新的 wandb 运行以跟踪此脚本
run = wandb.init(
    # 设置此运行将被记录的 wandb 项目
    project="my-awesome-project",
    # 跟踪超参数和运行元数据
    config=param,
)

# 从 wandb Artifacts 下载数据并准备数据
run.use_artifact("wandb/intro/dermatology_data:v0", type="dataset").download(".")
data = np.loadtxt(
    "./dermatology.data",
    delimiter=",",
    converters={33: lambda x: int(x == "?"), 34: lambda x: int(x) - 1},
)
sz = data.shape

train = data[: int(sz[0] * 0.7), :]
test = data[int(sz[0] * 0.7) :, :]

train_X = train[:, :33]
train_Y = train[:, 34]

test_X = test[:, :33]
test_Y = test[:, 34]

xg_train = xgb.DMatrix(train_X, label=train_Y)
xg_test = xgb.DMatrix(test_X, label=test_Y)
watchlist = [(xg_train, "train"), (xg_test, "test")]

# 向 wandb 运行添加另一个配置
num_round = 5
run.config["num_round"] = 5
run.config["data_shape"] = sz

# 将 WandbCallback 传递给 booster，以记录其配置和指标
bst = xgb.train(
    param, xg_train, num_round, evals=watchlist, callbacks=[WandbCallback()]
)

# 获取预测
pred = bst.predict(xg_test)
error_rate = np.sum(pred != test_Y) / test_Y.shape[0]

# 将你的测试指标记录到 wandb
run.summary["Error Rate"] = error_rate

# [可选] 完成 wandb 运行，在笔记本中是必需的
run.finish()

• 运行一个示例 Google Colab Notebook。
• 阅读开发者指南，了解如何将 XGBoost 与 W&B 集成的技术细节。

# 此脚本需要安装以下库：
#   numpy, sklearn

import wandb
from wandb.sklearn import plot_precision_recall, plot_feature_importances
from wandb.sklearn import plot_class_proportions, plot_learning_curve, plot_roc

import numpy as np
from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split


# 加载并处理数据
wbcd = datasets.load_breast_cancer()
feature_names = wbcd.feature_names
labels = wbcd.target_names

test_size = 0.2
X_train, X_test, y_train, y_test = train_test_split(
    wbcd.data, wbcd.target, test_size=test_size
)

# 训练模型
model = RandomForestClassifier()
model.fit(X_train, y_train)
model_params = model.get_params()

# 获取预测
y_pred = model.predict(X_test)
y_probas = model.predict_proba(X_test)
importances = model.feature_importances_
indices = np.argsort(importances)[::-1]

# 开始一个新的 wandb 运行并添加你的模型超参数
run = wandb.init(project="my-awesome-project", config=model_params)

# 向 wandb 添加额外的配置
run.config.update(
    {
        "test_size": test_size,
        "train_len": len(X_train),
        "test_len": len(X_test),
    }
)

# 将额外的可视化记录到 wandb
plot_class_proportions(y_train, y_test, labels)
plot_learning_curve(model, X_train, y_train)
plot_roc(y_test, y_probas, labels)
plot_precision_recall(y_test, y_probas, labels)
plot_feature_importances(model)

# [可选] 完成 wandb 运行，在笔记本中是必需的
run.finish()

• 运行一个示例 Google Colab 笔记本。
• 阅读开发者指南，了解如何将 Scikit-Learn 与 W&B 集成的技术细节。