wandb的基本使用

《wandb简单使用》

三步即可快速使用

1. Initialize a W&B Run 初始化wandb.run
2. Capture a dictionary of 获取超参数、项目架构的一个字典
3. Log metrics inside your training loop 将相应的数据log到wandb上

import wandb
# 1.连接 可以写在命令行，也可以写在代码中，只要在代码运行之前运行过即可，这里是代码中的实现
wandb.login(key='') 
# 2.初始化wandb对象，主要用到6的几个参数
runs = wandb.init(
        project="wandb_study",
        # name=f"experiment",
        notes="这是一次test",
        tags=["test","Test"]
        ) 
# 3.初始化config
wandb.config = {"epochs": epochs, "learning_rate": lr, "batch_size": batch_size, "device": device, "architecture": "MLP",
                    "loss":"crossEntropyLoss","optimizer":"Adam"}
# 4.找到相应数据并添加，一般的字符串、整形、浮点型直接用字典的形式就可以，图片前面要加wandb.Image()解析成wandb的形式,表格，summary见8和9
wandb.log({"accuracy":step_acc,
	"loss":train_loss.item(),
	'images': wandb.Image(images[0]),
})

0.开始之前

首先要去wandb官网注册一个账号https://wandb.ai/，创建完后在项目里有一个默认的test，里面有你的key

1.初始化Wandb run

• wandb.init().(创建了一个wandb对象，用来后续传入数据)

• （本地创建了一个文件夹用来保存相关日志）

• （不会因为project名字相同会将之前的训练数据覆盖，二十会生成一个新的name在projct下面）

• 常用的参数有(第6节)

import wandb

# 第一步要先登录
wandb.login(key='******')  #密钥在主页

run = wandb.init(
    project="cat-classification",  # 大框架是什么，最高一级
    name="本次训练的名字"
    notes="My first experiment",  # 一般是简单描述这次train你动了哪些部分，比如网络加了注意力机制等等
    tags=["baseline", "paper1"],  # 一般是对notes结果的预测，后续在网站上面还可以自己根据预测结果手动增减删
)

2.创建参数字典（包括超参数、网络架构等等）

（为后续分析做基础，方便得知本次实验的超参数是哪些，还有主要架构啊（CNN、U-Net））等等，见上图

链接：官网教程应该用不太到我没怎么研究

#  2. Capture a dictionary of hyperparameters
wandb.config = {"epochs": 100, "learning_rate": 0.001, "batch_size": 128}

3.添加数据(不同数据类型在7，8，9)

wandb.log()

每一步增加数据（第二个内循环中）

用字典的形式添加进去，这里就要比tensorboard更加智能一点，tensorboard要知道这个类型是什么，而且tensorboard每上传一个数据就要写一句话。

链接：上传各种类型的数据

# Set up model and data
model, dataloader = get_model(), get_data()

for epoch in range(wandb.config.epochs):
    for batch in dataloader:
        loss, accuracy = model.training_step()
        #  3. Log metrics inside your training loop to visualize
        # model performance
        wandb.log({"accuracy": accuracy, "loss": loss}) 

可以参照这个写

experiment.log({
    'learning rate': optimizer.param_groups[0]['lr'],
    'validation Dice': val_score,
    'IOU':IOU,
    'images': wandb.Image(images[0].cpu()), # 每一个batch里只有第一张图片被上传
    'masks': {
        'true': wandb.Image(true_masks[0].float().cpu()),
        'pred': wandb.Image(masks_pred.argmax(dim=1)[0].float().cpu()),
    },
    'step': global_step,
    'epoch': epoch,
    **histograms
})

4.Log an artifact to W&B（可选）

我没有成功，不知道具体有什么作用

# Import the W&B Python Library
import wandb

# 1. Start a W&B Run
run = wandb.init(project="cat-classification", notes="", tags=["baseline", "paper1"])

#  2. Capture a dictionary of hyperparameters
wandb.config = {"epochs": 100, "learning_rate": 0.001, "batch_size": 128}

# Set up model and data
model, dataloader = get_model(), get_data()

for epoch in range(wandb.config.epochs):
    for batch in dataloader:
        loss, accuracy = model.training_step()
        #  3. Log metrics inside your training loop to visualize
        # model performance
        wandb.log({"accuracy": accuracy, "loss": loss})

# 4. Log an artifact to W&B
wandb.log_artifact(model)


# 这一步一般是在做模型部署的时候要将你的模型转成onnx，这里用不上
# Optional: save model at the end
model.to_onnx()
wandb.save("model.onnx")

5.wandb网站上查看图表

6.init常用参数

1. Config: 写配置的参数，网络等等
2. Project: 项目名称
3. Notes:commit简介
4. Tags:标签

1-5 总结

import wandb
# 1.连接 可以写在命令行，也可以写在代码中，只要在代码运行之前运行过即可，这里是代码中的实现
wandb.login(key='') 
# 2.初始化wandb对象，主要用到6的几个参数
runs = wandb.init(
        project="wandb_study",
        # name=f"experiment",
        notes="这是一次test",
        tags=["test","Test"]
        ) 
# 3.找到相应数据并添加，一般的字符串、整形、浮点型直接用字典的形式就可以，图片前面要加wandb.Image()解析成wandb的形式,表格，summary见8和9
wandb.log({"accuracy":step_acc,
	"loss":train_loss.item(),
	'images': wandb.Image(images[0]),
})

7.media(主要是图片)

只研究了图片，其他还有还有功能
就是在图片前面加这个wandb.Image转成wandb可以解析的形式，我这里的images是(b,c,w,h) tensor形式的

wandb.log({'images': wandb.Image(images[0]),})

8.tabel

8.1 建表

确定列名，无需确定每一个data应该是什么数据，同时要确保后续传入每列的数据应该是相同类型

有两种方式，

• List of Rows:声明表头和具体数据

wandb.Table(columns=["a", "b", "c"], data=[["1a", "1b", "1c"], ["2a", "2b", "2c"]])

• Pandas DataFrame：用pandas进行数据分析时，我还用不上

8.2 添加数据

表可变，可以逐渐往表里添加数据，最多200 000 行

• Add a Row

  table.add_data("3a", "3b", "3c")
  

• Add a Column

  table.add_column(name="col_name", data=col_data)
  

# create a Table with the same columns as above,
# plus confidence scores for all labels
columns = ["id", "image", "guess", "truth"]
for digit in range(10):
    columns.append("score_" + str(digit))
test_table = wandb.Table(columns=columns)

# run inference on every image, assuming my_model returns the
# predicted label, and the ground truth labels are available
for img_id, img in enumerate(mnist_test_data):
    true_label = mnist_test_data_labels[img_id]
    guess_label = my_model.predict(img)
    test_table.add_data(img_id, wandb.Image(img), guess_label, true_label)

8.3 Retrieve Data(检索数据)

应该用不上

• Row Iterator：for ndx, row in table.iterrows(): ...

• Get a Column:table.get_column("col_name")

8.4 Log a table to a run

上面还有一步保存，是本地浏览，没什么用，略过

仍要用.log方法将其传入wandb上去，这里用run对象的.log或者直接调用wandb.log都可以

run = wandb.init()
my_table = wandb.Table(columns=["a", "b"], data=[["1a", "1b"], ["2a", "2b"]])
run.log({"table_key": my_table})

8.5 总结实例

可以很清楚的看出来机器确实是在不断判断准确

test_table = wandb.Table(columns=["imgs","pred","prob"])
for epoch in range(epochs):
    for step, (images, labels) in enumerate(train_dl):
    	loss = ....
        acc = ....
        for i in range(len(images)):
            test_table.add_data(wandb.Image(images[i]),pred[i],prob[i]) # 这里是每一张图片都加进去，其实不一定需要，可以只加一点
        wandb.log({"accuracy":step_acc,
                       "loss":train_loss.item(),
                       'images': wandb.Image(images[0])})
        梯度归零....
        反向传播....
        参数跟新....
wandb.log({"table":test_table})

9. Log Summary Metrics（摘要指标）

acc是一个指标，但是他每一个step或者epoch都在变，你想要知道每一个它哪里最高是在什么时候，所以你可以用summary metrics来追踪。

wandb.define_metric("accuracy", summary="max")   #  只要声明就行了，这个名字要和字典的键值一样
wandb.define_metric("loss", summary="min") 
           "loss":train_loss.item(),
           'images': wandb.Image(images[0]),
          })

简单示例:pytorch mnist数据集

import math
import torch, torchvision
import torch.nn as nn
import torchvision.transforms as T
from torch.autograd import Variable
import wandb

class my_model(nn.Module):
    def __init__(self,width,height):
        super(my_model, self).__init__()
        self.flatten = nn.Flatten()
        self.linear = nn.Linear(width*height,256)
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(0.1)
        self.linear2 = nn.Linear(256,10)
    def forward(self,x):
        x = self.flatten(x)
        x = self.linear(x)
        x = self.relu(x)
        x  = self.dropout(x)
        x = self.linear2(x)
        return x
def get_dataloader(is_train, batch_size):
    full_dataset = torchvision.datasets.MNIST(root=".", train=is_train, transform=T.ToTensor(), download=True)
    subset_size1 = int(0.01 * len(full_dataset))
    subset1 = torch.utils.data.Subset(full_dataset, range(subset_size1))
    loader = torch.utils.data.DataLoader(dataset=subset1, batch_size=batch_size, shuffle=True)
    return loader


# def create_name():

if __name__ == "__main__":
    # 连接,key要替换成你的
    wandb.login(key='')
    runs = wandb.init(
        project="wandb_study",
        # name=f"experiment",
        notes="这是一次test",
        tags=["test","Test"]
        )
    # 超参数，这个一般是在args解释器里面
    device = "cuda:0" if torch.cuda.is_available() else "cpu"
    epochs = 10
    batch_size = 32
    lr = 1e-3
    train_dl = get_dataloader(is_train=True, batch_size=batch_size)
    n_steps_per_epoch = math.ceil(len(train_dl.dataset) / batch_size)

    if device == "cpu":
        model = my_model(train_dl.dataset.dataset.data.size(1),train_dl.dataset.dataset.data.size(2))
    else:
        model = my_model(train_dl.dataset.dataset.data.size(1),train_dl.dataset.dataset.data.size(2)).cuda()

    loss_func = nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
    # 跟新config字典, architecture
    wandb.config = {"epochs": epochs, "learning_rate": lr, "batch_size": batch_size, "device": device, "architecture": "MLP",
                    "loss":"crossEntropyLoss","optimizer":"Adam"}

    test_table = wandb.Table(columns=["imgs","pred","prob"])
    wandb.define_metric("accuracy", summary="max")
    wandb.define_metric("loss", summary="min")
    for epoch in range(epochs):
        model.train()
        loss_sum = 0
        acc = 0
        best_acc = 0
        for step, (images, labels) in enumerate(train_dl):
            images, labels = Variable(images.cuda()), Variable(labels.cuda())
            outputs = model(images)
            train_loss = loss_func(outputs, labels) # 到这里神经网络就已经可以开始更新权重了

            loss_sum += train_loss.item()
            pred = torch.max(outputs,1)
            prob = pred[0]
            pred = pred[1]
            step_acc = (pred==labels).sum() / len(images)
            acc += step_acc

            for i in range(len(images)):
                test_table.add_data(wandb.Image(images[i]),pred[i],prob[i])
            # 开始记录数据
            wandb.log({"accuracy":step_acc,
                       "loss":train_loss.item(),
                       'images': wandb.Image(images[0]),
                       })

            optimizer.zero_grad()
            train_loss.backward()
            optimizer.step()

        print("完成 {:d} epoch".format(epoch+1))
    wandb.log({"table":test_table})

    # runs.summary.update()