TensorboardX

pytorch有一个工具借鉴了tensorboard

pip install tensorboardX

有查看变量的数值、监听曲线等功能

如何使用

新建SummaryWriter()实例

要把监听的数据，比如说要监听dummy_s1[0]（y
坐标）存放到data/scalar1中，n_iter是哪一个epoch的（即x坐标，n_iter时间戳的数据）

tensorboard本质上是抽取numpy的数据，如果要跟tensor直接做转换的话，需要把tensor转换到cpu上

Visdom

visdom可以接收tensor，且运行效率更高，因为tensorboard会把数据写到文件里面去，经常会导致监听文件非常大

如何安装visdompip install visdom

安装完成之后需要开启监听的进程，visdom本质上是可一个web服务器，程序向web服务器丢数据，这个web服务器会把数据渲染到网页上去
，因此确保程序在运行之前要确保开启visdompython -m visdom.server

在windows上可能会遇到这个问题

如果遇到这个问题，从0开始安装

1. 先把现在安装的visdom卸载pip unstall visdom
2. 从官方网页下载最新的源代码visdom
3. 进入visdom目录中运行pip install -e.

这样安装会省略很多麻烦

退回到用户目录运行python -m visdom.server

功能

画一条曲线，比如train loss

创建一条直线viz.line([0.],[0.],win='train_loss',opts=dict(title='train loss')) 首先给一个初始的点，这里只有一个点，第一个[0.]的意思是Y赋值为0，第二个[0.]的意思是X赋值为0，win是一个唯一的标识符可以理解为id，还有另外一个id叫env，visdom每一个大的窗口是一个env，这个窗口可以理解为程序，一个程序里面可能有很多小窗口，env不指定的话默认是main，会在main窗口里面创建小窗口，查询现有的窗口有没有train_loss这个id，没有的话就会创建一个win，opts会配置额外的配置信息，比如把窗口名字命名成train_loss,可以很好的识别倒是的train_loss,还是test_loss

通过这句话会创建一个train_loss窗口，点只有[0,0]

viz.line([loss.item()],[global_step],win='train loss',update='append')，在训练的时候把数据逐步添加进去,X坐标是[global_step]（时间戳），Y坐标是[loss.item()]，对于非image数据传入的还是一个numpy数据，但是image可以直接接收tensor，需要指定update操作时append，添加在当前的直线后面

多条曲线

一个曲线占用一个窗口的话，会使得窗口非常多

比如要同时看train loss 和 test loss，此时Y要同时传入两个数值[Y1,Y2],legend接收list，代表了Y1的label和Y2的label

两条线范围不一样，loss是0到100，accuracy是0到1，看起来会很奇怪

visual X

可视化

data是[batch,1,28,28]的tensor，如果使用tensorboardX的话必须复制到cpu上，即.cpu().numpy()数据才能传给tensorboard

还可以看字符串，把pred的值转换成string类型

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

from visdom import Visdom


def load_data(batch_size):
    train_loader = torch.utils.data.DataLoader(
        datasets.MNIST('mnist_data', train=True, download=True,
                       transform=transforms.Compose([
                           transforms.ToTensor(),
                           # transforms.Normalize((0.1307,), (0.3081,))
                       ])),
        batch_size=batch_size, shuffle=True)
    test_loader = torch.utils.data.DataLoader(
        datasets.MNIST('mnist_data', train=False, transform=transforms.Compose([
            transforms.ToTensor(),
            # transforms.Normalize((0.1307,), (0.3081,))
        ])),
        batch_size=batch_size, shuffle=True)
    return train_loader, test_loader


class MLP(nn.Module):

    def __init__(self):
        super(MLP, self).__init__()

        self.model = nn.Sequential(
            nn.Linear(784, 200),
            nn.LeakyReLU(inplace=True),
            nn.Linear(200, 200),
            nn.LeakyReLU(inplace=True),
            nn.Linear(200, 10),
            nn.LeakyReLU(inplace=True),
        )

    def forward(self, x):
        x = self.model(x)

        return x


def training(train_loader, device, net, viz, global_step):
    for batch_idx, (data, target) in enumerate(train_loader):
        data = data.view(-1, 28 * 28)
        data, target = data.to(device), target.cuda()

        logits = net(data)
        loss = criteon(logits, target)

        optimizer.zero_grad()
        loss.backward()
        # print(w1.grad.norm(), w2.grad.norm())
        optimizer.step()

        global_step += 1
        viz.line([loss.item()], [global_step], win='train_loss', update='append')

        if batch_idx % 100 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset), 100. * batch_idx / len(train_loader),
                loss.item()))


def testing(test_loader, device, net, viz, global_step):
    test_loss = 0
    correct = 0
    for data, target in test_loader:
        data = data.view(-1, 28 * 28)
        data, target = data.to(device), target.cuda()
        logits = net(data)
        test_loss += criteon(logits, target).item()

        pred = logits.argmax(dim=1)
        correct += pred.eq(target).float().sum().item()

    viz.line([[test_loss, correct / len(test_loader.dataset)]],
             [global_step], win='test', update='append')
    viz.images(data.view(-1, 1, 28, 28), win='x')
    viz.text(str(pred.detach().cpu().numpy()), win='pred',
             opts=dict(title='pred'))

    test_loss /= len(test_loader.dataset)
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))


global net

if __name__ == '__main__':
    batch_size = 200
    learning_rate = 0.01
    epochs = 10

    train_loader, test_loader = load_data(batch_size)

    device = torch.device('cuda:0')
    net = MLP().to(device)
    optimizer = optim.SGD(net.parameters(), lr=learning_rate)
    criteon = nn.CrossEntropyLoss().to(device)

    # 需要启动Visdom
    # python -m visdom.server
    viz = Visdom()

    viz.line([0.], [0.], win='train_loss', opts=dict(title='train loss'))
    viz.line([[0.0, 0.0]], [0.], win='test', opts=dict(title='test loss&acc.',
                                                       legend=['loss', 'acc.']))

    global_step = 0

    for epoch in range(epochs):
        training(train_loader, device, net, viz, global_step)
        testing(test_loader, device, net, viz, global_step)