Pytorch Visdom可视化工具

分手后的思念是犯贱 2021-11-04 19:00 705阅读 0赞

Pytorch官方支持的可视化工具是Visdom(当然也支持TensorBoardX)，Visdom更简洁方便一些（例如对image数据的可视化可以直接使用Tensor，而不必转到cpu上再转为numpy数据），刷新率也更快。

1. 安装Visdom

sudo pip3 install visdom

2. 启动Visdom服务

python3 -m visdom.server

启动成功后可以看到如下信息：

It's Alive!
    INFO:root:Application Started
    You can navigate to http://localhost:8097

3. 用chrome浏览器访问上面的url连接：[http://localhost:8097][http_localhost_8097]

![å¨è¿éæå¥å¾çæè¿°][20190326135416260.png]

可视化的数据可以在上面的web页面中进行展示。

4. 可视化训练-测试过程

先开启上面的Visdom服务。在自定义网络实现MNIST分类的代码基础上，添加一些Visdom可视化的内容。

在最前面导入Visdom：

from visdom import Visdom

在训练-测试的迭代过程之前，定义两条曲线，在训练-测试的过程中再不断填充点以实现曲线随着训练动态增长：

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.']))

这里第一步可以提供参数`env='xxx'`来设置环境窗口的名称，这里什么都没传，所以是在默认的`main`窗口下。

第二第三步的viz.line的前两个参数是曲线的Y和X的坐标（前面是纵轴后面才是横轴），这里为了占位所以都设置了0（实际上为Loss初始Y值设置为0的话，在图中刚开始的地方会有个大跳跃有点难看，因为Loss肯定是从大往小了走的）。为它们设置了不同的win参数，它们就会在不同的窗口中展示，因为第三步定义的是测试集的loss和acc两条曲线，所以在X等于0时Y给了两个初始值。

为了知道训练了多少个batch了，紧接着设置一个全局的计数器：

global_step = 0

在每个batch训练完后，为训练曲线添加点，来让曲线实时增长：

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

注意这里用`win`参数来选择是哪条曲线，用`update='append'`的方式添加曲线的增长点，前面是Y坐标，后面是X坐标。

在每次测试结束后，并在另外两个窗口（用`win`参数设置）中展示图像（`.images`）和真实值（文本用`.text`）：

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'))

完整代码：

import torch
    import torch.nn as nn
    import torch.nn.functional as F
    import torch.optim as optim
    from torchvision import datasets, transforms
    
    from visdom import Visdom
    
    batch_size = 200
    learning_rate = 0.01
    epochs = 10
    
    train_loader = torch.utils.data.DataLoader(
    	datasets.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('../data', train=False, transform=transforms.Compose([
    		transforms.ToTensor(),
    		# transforms.Normalize((0.1307,), (0.3081,))
    	])),
    	batch_size=batch_size, shuffle=True)
    
    
    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
    
    
    device = torch.device('cuda:0')
    net = MLP().to(device)
    optimizer = optim.SGD(net.parameters(), lr=learning_rate)
    criteon = nn.CrossEntropyLoss().to(device)
    
    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):
    
    	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()))
    
    	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)))

可视化结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaWNhbzE5OTA_size_16_color_FFFFFF_t_70][]

参考链接：[https://blog.csdn.net/u012436149/article/details/69389610?utm\_source=gold\_browser\_extension][https_blog.csdn.net_u012436149_article_details_69389610_utm_source_gold_browser_extension]

[http_localhost_8097]: http://localhost:8097
[20190326135416260.png]: /images/20211104/55df0ed472854cc4a9a4b051532d2084.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaWNhbzE5OTA_size_16_color_FFFFFF_t_70]: /images/20211104/4fc51f20aaf34b348c0bce1e4ae28b20.png
[https_blog.csdn.net_u012436149_article_details_69389610_utm_source_gold_browser_extension]: https://blog.csdn.net/u012436149/article/details/69389610?utm_source=gold_browser_extension