• PyTorchの可视化工具

    今天搬个工具来啊 其实也很少用~~ 不知道大伙用吗

    网络结构可视化和训练过程可视化

    一、网络结构的可视化

    我们训练神经网络时，除了随着step或者epoch观察损失函数的走势，从而建立对目前网络优化的基本认知外，也可以通过一些额外的可视化库来可视化我们的神经网络结构图。这将更加地高效地向读者展现目前的网络结构。

    为了可视化神经网络，我们先建立一个简单的卷积层神经网络：

    1.  import torch
    2.  import torch.nn as nn
    3.  
    4.  class ConvNet(nn.Module):
    5.      def __init__(self):
    6.          super(ConvNet, self).__init__()
    7.  
    8.          self.conv1 = nn.Sequential(
    9.              nn.Conv2d(1, 16, 3, 1, 1),
    10.              nn.ReLU(),
    11.              nn.AvgPool2d(2, 2)
    12.          )
    13.  
    14.          self.conv2 = nn.Sequential(
    15.              nn.Conv2d(16, 32, 3, 1, 1),
    16.              nn.ReLU(),
    17.              nn.MaxPool2d(2, 2)
    18.          )
    19.  
    20.          self.fc = nn.Sequential(
    21.              nn.Linear(32 * 7 * 7, 128),
    22.              nn.ReLU(),
    23.              nn.Linear(128, 64),
    24.              nn.ReLU()
    25.          )
    26.  
    27.          self.out = nn.Linear(64, 10)
    28.  
    29.      def forward(self, x):
    30.          x = self.conv1(x)
    31.          x = self.conv2(x)
    32.          x = x.view(x.size(0), -1)
    33.          x = self.fc(x)
    34.          output = self.out(x)
    35.          return output

    输出网络结构：

    1.  MyConvNet = ConvNet()
    2.  print(MyConvNet)

    输出结果：

    1.  ConvNet(
    2.    (conv1): Sequential(
    3.      (0): Conv2d(1, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    4.      (1): ReLU()
    5.      (2): AvgPool2d(kernel_size=2, stride=2, padding=0)
    6.    )
    7.    (conv2): Sequential(
    8.      (0): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    9.      (1): ReLU()
    10.      (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    11.    )
    12.    (fc): Sequential(
    13.      (0): Linear(in_features=1568, out_features=128, bias=True)
    14.      (1): ReLU()
    15.      (2): Linear(in_features=128, out_features=64, bias=True)
    16.      (3): ReLU()
    17.    )
    18.    (out): Linear(in_features=64, out_features=10, bias=True)
    19.  )

    有了基本的神经网络后，我们分别通过HiddenLayer和PyTorchViz库来可视化上述的卷积层神经网络。

    需要说明的是，这两个库都是基于Graphviz开发的，因此倘若你的电脑上没有安装并且没有添加环境变量，请自行安装Graphviz工具，安装教程

    1.1 通过HiddenLayer可视化网络

    首先当然是安装库啦，打开cmd，输入：

     pip install hiddenlayer

    绘制的基本程序如下：

    1.  import hiddenlayer as h
    2.  vis_graph = h.build_graph(MyConvNet, torch.zeros([1 ,1, 28, 28]))   # 获取绘制图像的对象
    3.  vis_graph.theme = h.graph.THEMES["blue"].copy()     # 指定主题颜色
    4.  vis_graph.save("./demo1.png")   # 保存图像的路径

    效果如下：

    1.2 通过PyTorchViz可视化网络

    先安装库：

     pip install torchviz

    这里我们只使用可视化函数make_dot()来获取绘图对象，基本使用和HiddenLayer差不多，不同的地方在于PyTorch绘图之前可以指定一个网络的输入值和预测值。

    1.  from torchviz import make_dot
    2.  x = torch.randn(1, 1, 28, 28).requires_grad_(True)  # 定义一个网络的输入值
    3.  y = MyConvNet(x)    # 获取网络的预测值
    4.  
    5.  MyConvNetVis = make_dot(y, params=dict(list(MyConvNet.named_parameters()) + [('x', x)]))
    6.  MyConvNetVis.format = "png"
    7.  # 指定文件生成的文件夹
    8.  MyConvNetVis.directory = "data"
    9.  # 生成文件
    10.  MyConvNetVis.view()

    打开与上述代码相同根目录下的data文件夹，里面会有一个.gv文件和一个.png文件，其中的.gv文件是Graphviz工具生成图片的脚本代码，.png是.gv文件编译生成的图片，直接打开.png文件就行。

    默认情况下，上述程序运行后会自动打开.png文件

    生成图片：

    二、训练过程可视化

    观察我们的网络的每一步的损失函数或准确率的变化可以有效地帮助我们判断当前训练过程的优劣。如果能将这些过程可视化，那么我们判断的准确性和舒适性都会有所增加。

    此处主要讲通过可视化神器tensorboardX和刚刚用到的HiddenLayer来实现训练过程的可视化。

    为了训练网络，我们先导入训练网络需要的数据，此处就导入MNIST数据集，并做训练前的一些基本的数据处理。

    1.  import torchvision
    2.  import torch.utils.data as Data
    3.  # 准备训练用的MNIST数据集
    4.  train_data = torchvision.datasets.MNIST(
    5.      root = "./data/MNIST",  # 提取数据的路径
    6.      train=True, # 使用MNIST内的训练数据
    7.      transform=torchvision.transforms.ToTensor(),    # 转换成torch.tensor
    8.      download=False   # 如果是第一次运行的话，置为True，表示下载数据集到root目录
    9.  )
    10.  
    11.  # 定义loader
    12.  train_loader = Data.DataLoader(
    13.      dataset=train_data,
    14.      batch_size=128,
    15.      shuffle=True,
    16.      num_workers=0
    17.  )
    18.  
    19.  test_data = torchvision.datasets.MNIST(
    20.      root="./data/MNIST",
    21.      train=False,    # 使用测试数据
    22.      download=False
    23.  )
    24.  
    25.  # 将测试数据压缩到0-1
    26.  test_data_x = test_data.data.type(torch.FloatTensor) / 255.0
    27.  test_data_x = torch.unsqueeze(test_data_x, dim=1)
    28.  test_data_y = test_data.targets
    29.  
    30.  # 打印一下测试数据和训练数据的shape
    31.  print("test_data_x.shape:", test_data_x.shape)
    32.  print("test_data_y.shape:", test_data_y.shape)
    33.  
    34.  for x, y in train_loader:
    35.      print(x.shape)
    36.      print(y.shape)
    37.      break

    结果：

    1.  test_data_x.shape: torch.Size([10000, 1, 28, 28])
    2.  test_data_y.shape: torch.Size([10000])
    3.  torch.Size([128, 1, 28, 28])
    4.  torch.Size([128])

    2.1 通过tensorboardX可视化训练过程

    tensorboard是谷歌开发的深度学习框架tensorflow的一套深度学习可视化神器，在pytorch团队的努力下，他们开发出了tensorboardX来让pytorch的玩家也能享受tensorboard的福利。

    先安装相关的库：

    1.  pip install tensorboardX
    2.  pip install tensorboard

    并将tensorboard.exe所在的文件夹路径加入环境变量path中（比如我的tensorboard.exe的路径为D:\Python376\Scripts\tensorboard.exe，那么就在path中加入D:\Python376\Scripts）

    下面是tensorboardX的使用过程。基本使用为，先通过tensorboardX下的SummaryWriter类获取一个日志编写器对象。然后通过这个对象的一组方法往日志中添加事件，即生成相应的图片，最后启动前端服务器，在localhost中就可以看到最终的结果了。

    训练网络，并可视化网络训练过程的代码如下：

    1.  from tensorboardX import SummaryWriter
    2.  logger = SummaryWriter(log_dir="data/log")
    3.  
    4.  # 获取优化器和损失函数
    5.  optimizer = torch.optim.Adam(MyConvNet.parameters(), lr=3e-4)
    6.  loss_func = nn.CrossEntropyLoss()
    7.  log_step_interval = 100      # 记录的步数间隔
    8.  
    9.  for epoch in range(5):
    10.      print("epoch:", epoch)
    11.      # 每一轮都遍历一遍数据加载器
    12.      for step, (x, y) in enumerate(train_loader):
    13.          # 前向计算->计算损失函数->(从损失函数)反向传播->更新网络
    14.          predict = MyConvNet(x)
    15.          loss = loss_func(predict, y)
    16.          optimizer.zero_grad()   # 清空梯度（可以不写）
    17.          loss.backward()     # 反向传播计算梯度
    18.          optimizer.step()    # 更新网络
    19.          global_iter_num = epoch * len(train_loader) + step + 1  # 计算当前是从训练开始时的第几步(全局迭代次数)
    20.          if global_iter_num % log_step_interval == 0:
    21.              # 控制台输出一下
    22.              print("global_step:{}, loss:{:.2}".format(global_iter_num, loss.item()))
    23.              # 添加的第一条日志：损失函数-全局迭代次数
    24.              logger.add_scalar("train loss", loss.item() ,global_step=global_iter_num)
    25.              # 在测试集上预测并计算正确率
    26.              test_predict = MyConvNet(test_data_x)
    27.              _, predict_idx = torch.max(test_predict, 1)     # 计算softmax后的最大值的索引，即预测结果
    28.              acc = accuracy_score(test_data_y, predict_idx)
    29.              # 添加第二条日志：正确率-全局迭代次数
    30.              logger.add_scalar("test accuary", acc.item(), global_step=global_iter_num)
    31.              # 添加第三条日志：这个batch下的128张图像
    32.              img = vutils.make_grid(x, nrow=12)
    33.              logger.add_image("train image sample", img, global_step=global_iter_num)
    34.              # 添加第三条日志：网络中的参数分布直方图
    35.              for name, param in MyConvNet.named_parameters():
    36.                  logger.add_histogram(name, param.data.numpy(), global_step=global_iter_num)
    37.  

    运行完后，我们通过cmd来到与代码同一级的目录（如果你使用的是pycharm，可以通过pycharm中的终端）输入指令tensorboard --logdir="./data/log"，启动服务器。

    logdir后面的参数是日志文件的文件夹的路径

    然后在谷歌浏览器中访问红框框中的url，便可得到可视化界面，点击上面的页面控件，可以查看我们通过add_scalar、add_image和add_histogram得到的图像，而且各方面做得都很丝滑。

    以下是笔者安装使用tensorboard时遇到的一些错误。

    好，作为一名没有装过TensorFlow的windows玩家，笔者下面开始踩坑。踩完后，直接把几个可能的错误呈上。

    第一个错误，运行tensorboard --logdir="./data/log"，遇到报错，内容为有重复的tensorboard的包。

    解决方法：找到site-packages（如果你是像我一样全局安装的，那么找到解释器那一级目录的site-packages，如果是在项目虚拟环境中安装的，那么找到项目中的site-packages），删去下图中红框框标出来的文件夹。

    第二个错误，在解决第一个错误后，再次运行命令，还是报错，内容为编码出错。由于笔者做过一点前端，在学习webpack项目时，曾经被告知项目路径不能含有中文，否则会有编码错误，而刚才的报错中涉及到了前端服务器的启动，因此，笔者想到从文件名入手。

    解决方法：确保命令涉及的文件路径、所有程序涉及到文件不含中文。笔者是计算机名字含有中文，然后tensorboard的日志文件是以本地计算机名为后缀的，所以笔者将计算机名修改成了英文，重启后再输入指令就ok了。

    2.2 HiddenLayer可视化训练过程

    tensorboard的图像很华丽，但是使用过程相较于其他的工具包较为繁琐，所以小网络一般没必要使用tensorboard。

    1.  import hiddenlayer as hl
    2.  import time
    3.  
    4.  # 记录训练过程的指标
    5.  history = hl.History()
    6.  # 使用canvas进行可视化
    7.  canvas = hl.Canvas()
    8.  
    9.  # 获取优化器和损失函数
    10.  optimizer = torch.optim.Adam(MyConvNet.parameters(), lr=3e-4)
    11.  loss_func = nn.CrossEntropyLoss()
    12.  log_step_interval = 100      # 记录的步数间隔
    13.  
    14.  for epoch in range(5):
    15.      print("epoch:", epoch)
    16.      # 每一轮都遍历一遍数据加载器
    17.      for step, (x, y) in enumerate(train_loader):
    18.          # 前向计算->计算损失函数->(从损失函数)反向传播->更新网络
    19.          predict = MyConvNet(x)
    20.          loss = loss_func(predict, y)
    21.          optimizer.zero_grad()   # 清空梯度（可以不写）
    22.          loss.backward()     # 反向传播计算梯度
    23.          optimizer.step()    # 更新网络
    24.          global_iter_num = epoch * len(train_loader) + step + 1  # 计算当前是从训练开始时的第几步(全局迭代次数)
    25.          if global_iter_num % log_step_interval == 0:
    26.              # 控制台输出一下
    27.              print("global_step:{}, loss:{:.2}".format(global_iter_num, loss.item()))
    28.              # 在测试集上预测并计算正确率
    29.              test_predict = MyConvNet(test_data_x)
    30.              _, predict_idx = torch.max(test_predict, 1)  # 计算softmax后的最大值的索引，即预测结果
    31.              acc = accuracy_score(test_data_y, predict_idx)
    32.  
    33.              # 以epoch和step为索引，创建日志字典
    34.              history.log((epoch, step),
    35.                          train_loss=loss,
    36.                          test_acc=acc,
    37.                          hidden_weight=MyConvNet.fc[2].weight)
    38.  
    39.              # 可视化
    40.              with canvas:
    41.                  canvas.draw_plot(history["train_loss"])
    42.                  canvas.draw_plot(history["test_acc"])
    43.                  canvas.draw_image(history["hidden_weight"])

    不同于tensorboard，hiddenlayer会在程序运行的过程中动态生成图像，而不是模型训练完后

    下面为模型训练的某一时刻的截图：

    三、使用Visdom进行可视化

    Visdom是Facebook为pytorch开发的一块可视化工具。类似于tensorboard，visdom也是通过在本地启动前端服务器来实现可视化的，而在具体操作上，visdom又类似于matplotlib.pyplot。所以使用起来很灵活。

    首先先安装visdom库，然后补坑。由于启动前端服务器需要大量依赖项，所以在第一次启动时可能会很慢（需要下载前端三板斧的依赖项），解决方法请见这里。

    先导入需要的第三方库：

    1.  from visdom import Visdom
    2.  from sklearn.datasets import  load_iris
    3.  import torch
    4.  import numpy as np
    5.  from PIL import Image

    matplotlib里，用户绘图可以通过plt这个对象来绘图，在visdom中，同样需要一个绘图对象，我们通过vis = Visdom()来获取。具体绘制时，由于我们会一次画好几张图，所以visdom要求用户在绘制时指定当前绘制图像的窗口名字（也就是win这个参数）；除此之外，为了到时候显示的分块，用户还需要指定绘图环境env，这个参数相同的图像，最后会显示在同一张页面上。

    绘制线图（相当于matplotlib中的plt.plot）

    1.  # 绘制图像需要的数据
    2.  iris_x, iris_y = load_iris(return_X_y=True)
    3.  
    4.  # 获取绘图对象，相当于plt
    5.  vis = Visdom()
    6.  
    7.  # 添加折线图
    8.  x = torch.linspace(-6, 6, 100).view([-1, 1])
    9.  sigmoid = torch.nn.Sigmoid()
    10.  sigmoid_y = sigmoid(x)
    11.  tanh = torch.nn.Tanh()
    12.  tanh_y = tanh(x)
    13.  relu = torch.nn.ReLU()
    14.  relu_y = relu(x)
    15.  # 连接三个张量
    16.  plot_x = torch.cat([x, x, x], dim=1)
    17.  plot_y = torch.cat([sigmoid_y, tanh_y, relu_y], dim=1)
    18.  # 绘制线性图
    19.  vis.line(X=plot_x, Y=plot_y, win="line plot", env="main",
    20.           opts={
    21.               "dash" : np.array(["solid", "dash", "dashdot"]),
    22.               "legend" : ["Sigmoid", "Tanh", "ReLU"]
    23.           })

    绘制散点图：

    1.  # 绘制2D和3D散点图
    2.  # 参数Y用来指定点的分布，win指定图像的窗口名称，env指定图像所在的环境，opts通过字典来指定一些样式
    3.  vis.scatter(iris_x[ : , 0 : 2], Y=iris_y+1, win="windows1", env="main")
    4.  vis.scatter(iris_x[ : , 0 : 3], Y=iris_y+1, win="3D scatter", env="main",
    5.              opts={
    6.                  "markersize" : 4,   # 点的大小
    7.                  "xlabel" : "特征1",
    8.                  "ylabel" : "特征2"
    9.              })

    绘制茎叶图：

    1.  # 添加茎叶图
    2.  x = torch.linspace(-6, 6, 100).view([-1, 1])
    3.  y1 = torch.sin(x)
    4.  y2 = torch.cos(x)
    5.  
    6.  # 连接张量
    7.  plot_x = torch.cat([x, x], dim=1)
    8.  plot_y = torch.cat([y1, y2], dim=1)
    9.  # 绘制茎叶图
    10.  vis.stem(X=plot_x, Y=plot_y, win="stem plot", env="main",
    11.           opts={
    12.               "legend" : ["sin", "cos"],
    13.               "title" : "茎叶图"
    14.           })

    绘制热力图：

    1.  # 计算鸢尾花数据集特征向量的相关系数矩阵
    2.  iris_corr = torch.from_numpy(np.corrcoef(iris_x, rowvar=False))
    3.  # 绘制热力图
    4.  vis.heatmap(iris_corr, win="heatmap", env="main",
    5.              opts={
    6.                  "rownames" : ["x1", "x2", "x3", "x4"],
    7.                  "columnnames" : ["x1", "x2", "x3", "x4"],
    8.                  "title" : "热力图"
    9.              })

    可视化图片，这里我们使用自定义的env名MyPlotEnv

    1.  # 可视化图片
    2.  img_Image = Image.open("./example.jpg")
    3.  img_array = np.array(img_Image.convert("L"), dtype=np.float32)
    4.  img_tensor = torch.from_numpy(img_array)
    5.  print(img_tensor.shape)
    6.  
    7.  # 这次env自定义
    8.  vis.image(img_tensor, win="one image", env="MyPlotEnv",
    9.            opts={
    10.                "title" : "一张图像"
    11.            })

    可视化文本，同样在MyPlotEnv中绘制：

    1.  # 可视化文本
    2.  text = "hello world"
    3.  vis.text(text=text, win="text plot", env="MyPlotEnv",
    4.           opts={
    5.               "title" : "可视化文本"
    6.           })
    7.  

    运行上述代码，再通过在终端中输入python3 -m visdom.server启动服务器，然后根据终端返回的URL，在谷歌浏览器中访问这个URL，就可以看到图像了。

    在Environment中输入不同的env参数可以看到我们在不同环境下绘制的图片。对于分类图集特别有用。

    在终端中按下Ctrl+C可以终止前端服务器。

    进一步

    需要注意，如果你的前端服务器停掉了，那么所有的图片都会丢失，因为此时的图像的数据都是驻留在内存中，而并没有dump到本地磁盘。那么如何保存当前visdom中的可视化结果，并在将来复用呢？其实很简单，比如我现在有一堆来之不易的Mel频谱图：

    点击Manage Views

    点击fork->save:（此处我只保存名为normal的env）

    接着，在你的User目录下（Windows是C:\Users\账户.visdom文件夹，Linux是在~.visdom文件夹下），可以看到保存好的env：

    它是以json文件格式保存的，那么如果你保存完后再shut down当前的前端服务器，图像数据便不会丢失。

    好的，现在在保存完你珍贵的数据后，请关闭你的visdom前端服务器。然后再启动它。

    如何查看保存的数据呢？很简答，下次打开visdom前端后，visdom会在.visdom文件夹下读取所有的保存数据完成初始化，这意味着，你直接启动visdom，其他什么也不用做就可以看到之前保存的数据啦！

    那么如何服用保存的数据呢？既然你都知道了visdom保存的数据在哪里，那么直接通过python的json包来读取这个数据文件，然后做解析就可以了，这是方法一，演示如下：

    1. import json
    2.  
    3. with open(r"...\.visdom\normal.json", "r", encoding="utf-8") as f:
    4.     dataset : dict = json.load(f)
    5.  
    6. jsons : dict = dataset["jsons"]      # 这里存着你想要恢复的数据
    7. reload : dict = dataset["reload"]    # 这里存着有关窗口尺寸的数据 
    8.  
    9. print(jsons.keys())     # 查看所有的win

    out:

    1. dict_keys(['jsons', 'reload'])
    2. dict_keys(['1.wav', '2.wav', '3.wav', '4.wav', '5.wav', '6.wav', '7.wav', '8.wav', '9.wav', '10.wav', '11.wav', '12.wav', '13.wav', '14.wav'])

    但这么做不是很优雅，所以visdom封装了第二种方法。你当然可以通过访问文件夹.visdom来查看当前可用的env，但是也可以这么做：

    1. from visdom import Visdom
    2.  
    3. vis = Visdom()
    4. print(vis.get_env_list())

    out:

    1. Setting up a new session...
    2. ['main', 'normal']

    在获取了可用的环境名后，你可以通过get_window_data方法来获取指定env、指定win下的图像数据。请注意，该方法返回str，故需要通过json来解析：

    1. from visdom import Visdom
    2. import json
    3.  
    4. vis = Visdom()
    5.  
    6. window = vis.get_window_data(win="1.wav", env="normal")    
    7. window = json.loads(window)         # window 是 str，需要解析为字典
    8.  
    9. content = window["content"]
    10. data = content["data"][0]
    11. print(data.keys())

    out:

    1. Setting up a new session...
    2. dict_keys(['z', 'x', 'y', 'zmin', 'zmax', 'type', 'colorscale'])

    通过索引这些keys，相信想复用原本的图像数据并不困难。 whaosoft aiot http://143ai.com 

    好了完事 搬完睡觉...

  • 相关阅读:
    python计算长方形面积 青少年编程电子学会python编程等级考试一级真题解析2022年6月
    python+vue在线学习教育平台django+flask
    js中的sort排序
    直方图，条形图，饼图
    【接口测试】Postman（三）-变量与集合
    L64.linux命令每日一练 -- 第十章 Linux网络管理命令 -- ifconfig和ifup
    Spring Cloud Netflix微服务组件-Eureka
    C++ 学习笔记（五）（泛型算法篇）
    软件人和硬件人有啥区别？
    成都榆熙：转化率的定义是什么？如何提升？
  • 原文地址：https://blog.csdn.net/qq_29788741/article/details/126924701