第四章 基于PyTorch的可视化工具

1. 网络结构的可视化

本节我们定义一个简单CNN对手写数据集进行分类，并通过相关的可视化库进行可视化。

模块导入

1
2
3
4
5
6
7
8
import torch
import torch.nn as nn
import torchvision
import torchvision.utils as vutils
from torch.optim import SGD
import torch.utils.data as Data
from sklearn.metrics import  accuracy_score
import matplotlib.pyplot as plt

数据准备

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# 首先是获取手写数据集
train_data=torchvision.datasets.MNIST(
    root="./data/MNIST",
    train=True, # 只使用训练集
    transform=torchvision.transforms.ToTensor(), # 这里是使用了tv的transforms接口，转换为Tensor
    download=False # 如果下载过了就不需要重新下载，可改为False
)

# 有了数据集之后捏，就需要把数据分批处理
# 我们一般是创建一个DataLoader
train_loader=Data.DataLoader(
    dataset=train_data,
    batch_size=256,
    shuffle=True
)

# 可以看下数据的格式
for step,(b_x,b_y) in enumerate(train_loader):
    if step>0:
        break # 只拿出一个batch查看

print(b_x.shape)
print(b_y.shape)

# 然后是测试数据集
test_data=torchvision.datasets.MNIST(
    root="./data/MNIST",
    train=False,  # 不使用训练集
    download=False
)

# 这里我们需要个数据添加一个通道(channel)
# 并且将数值范围缩放到[0,1]

test_data_x=test_data.data.type(torch.FloatTensor)/255
test_data_x=torch.unsqueeze(test_data_x,dim=1)
test_data_y=test_data.targets # 数据集中提供的标签数据

print("Test_x",test_data_x.shape)
print("Test_y",test_data_y.shape)

结果如下：

1
2
3
4
5
6
'''
torch.Size([256, 1, 28, 28])
torch.Size([256])
Test_x torch.Size([10000, 1, 28, 28])
Test_y torch.Size([10000])
'''

网络搭建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
# 搭建一个CNN
class ConvNet(nn.Module):

    def __init__(self):
        super(ConvNet,self).__init__()
        # 本网络由两个卷积层和一个全连接层构成

        # 第一个卷积层
        self.conv1=nn.Sequential(
            # 1->16
            nn.Conv2d(1,16,3,padding=1,stride=1),
            # 激活函数
            nn.ReLU(),
            # 卷积做完后进行池化
            # 本网络使用平均池化，目的是压缩信息量
            nn.AvgPool2d(kernel_size=2,stride=2)
        )

        # 第二个卷积层
        self.conv2=nn.Sequential(
            # 16->32
            nn.Conv2d(16,32,kernel_size=3,stride=1,padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2,2)
        )

        # 第三层全连接层
        self.mlp=nn.Sequential(
            nn.Linear(
                # 输入特征数
                # 图片有32个channel
                # 且大小为： 28>>2
                in_features=32*7*7,
                out_features=128
            ),
            nn.ReLU(),
            nn.Linear(128,64),
            nn.ReLU()
        )
        # 最后的输出映射十个数字
        self.out=nn.Linear(64,10)

    def forward(self,x):
        # return self.out(self.mlp(self.conv2(self.conv1(x))))
        # 注意此时是图像数据
        # 为了让MLP线性层能够处理
        # 需要平铺为一维向量

        # x:->[batch,1,28,28]
        x=self.conv2(self.conv1(x))
        # x:->[batch,32,7,7]
        x=x.view(x.size(0),-1)
        # x:->[32*7*7]^T
        return self.out(self.mlp(x))         # x:->10

Conv1=ConvNet()
print(Conv1)

HiddenLayer可视化

1
2
3
4
5
6
7
8
# 借助hiddenlayer库进行可视化
import hiddenlayer as hl

# 可视化CNN
hl_graph=hl.build_graph(Conv1,torch.zeros([1,1,28,28]))
hl_graph.theme=hl.graph.THEMES["blue"].copy()
# 可以将其保存为图片
hl_graph.save(r"C:\Users\落花雨\Desktop\0001.png",format="png")

PyTorchViz可视化

1
2
3
4
5
6
7
8
9
10
from torchviz import make_dot

# 使用make_dot可视化网络
x=torch.randn(1,1,28,28).requires_grad_(True)
y=Conv1(x)
ConvVis=make_dot(y,params=dict(list(Conv1.named_parameters())+[("x",x)]))
# 将其保存为图片
ConvVis.format="png"
ConvVis.directory=r"C:\Users\落花雨\Desktop"
ConvVis.view() # 会自动在当前目录下生成文件

2. 训练过程可视化

2.1 tensorboardX

tensorboardX的部分API如下：

函数 功能 用法
SummaryWriter() 创建编写器，保存日志 writer=SummaryWriter()
writer.add_scalar() 添加标量 writer.add_scalar(‘myscalar’,value,iteration)
writer.add_image() 添加图像 writer.add_image(‘imresult’,x,itertation)
writer.add_histogram() 添加直方图 writer.add_histogram(‘hist’,array,iteration)
writer.add_graph() 添加网络结构 writer.add_graph(model,input_to_model=None)
writer.add_audio() 添加音频 add_audio(tag,audio,iteration,sample_rate)
writer.add_text() 添加文本 writer.add_text(tag,text_string,global_step=None)

以下案例展现了tensorboard的使用方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
# 我们利用tensorboardX进行可视化
Sumwriter=SummaryWriter(log_dir="data/log/chap4")
# 定义优化器
optimizer=torch.optim.Adam(CNN1.parameters(),lr=0.0003)
# 定义损失函数
loss_func=nn.CrossEntropyLoss()
# 初始化损失
train_loss=0
# 计算迭代输出次数
# 每迭代一百次进行一次输出
print_step=100

# 进行训练
for epoch in range(5):

    for step,(b_x,b_y) in enumerate(train_loader):
        # 计算每个batch损失
        output=CNN1(b_x)
        # 交叉熵
        loss=loss_func(output,b_y)
        # 梯度初始化
        optimizer.zero_grad()
        # 计算梯度并优化
        optimizer.step()
        # 计算累计损失和
        train_loss+=loss
        # 计算迭代次数
        niter=epoch*len(train_loader)+step+1
        # 每一百次进行输出
        if niter%print_step==0:
            # 为日志添加训练集损失函数
            Sumwriter.add_scalar(tag="train_loss",scalar_value=train_loss.item()/niter,
                                     global_step=niter)
            # 计算在测试集上的精度
            output=CNN1(test_data_x)
            # 在维度1上的最大值
            # 前面是值，后面是最大值索引
            _,pre_lab=torch.max(output,1)
            acc=accuracy_score(test_data_y,pre_lab)
            # 为训练日志添加预测精度
            Sumwriter.add_scalar(tag="test acc",scalar_value=acc.item(),global_step=niter)
            # 为训练日志添加可视化图像
            # 使用当前batch的图像
            b_x_im=vutils.make_grid(b_x,nrow=12)
            Sumwriter.add_image(tag="train image sample",img_tensor=b_x_im,global_step=niter)
            # 使用直方图可视化网络参数的分布情况
            for name,param in CNN1.named_parameters():
                Sumwriter.add_histogram(name,param.data.numpy(),niter)

3. Visdom可视化

Visdom是Facebook专门为PyTorch开发的一款可视化工具，可视化的同时支持Tensor和Numpy两种数据格式。

函数 功能
vis.image 可视化一张图像
vis.images 可视化一个batch的图像，或者一个图像列表
vis.text 可视化文本
vis.audio 播放音频
vis.video 播放视频
vis.matplot 可视化matplotlib的图像
vis.scatter 2D或3D的散点图
vis.line 线图
vis.stem 茎叶图
vis.hearmap 热力图
vis.bar 条形图
vis.histogram 直方图
vis.boxplot 盒形图
vis.surf 曲面图
vis.contour 等高线图
vis.quiver 箭头图
vis.mesh 网格图

Visdom服务器需要先挂起

1
python -m visdom.server

以下使用一个案例来运用Visdom

1
2
3
4
5
6
from visdom import Visdom
from sklearn.datasets import load_iris

# 导入鸢尾花数据集
# 为: x:(150,4) y:(150)
ix,iy=load_iris(return_X_y=True)

散点图

1
2
3
4
5
6
7
# 接下来绘制散点图
vis=Visdom()
vis.scatter(ix[:,0:2],Y=iy+1,win="windows1",env="main")
vis.scatter(ix[:,0:3],Y=iy+1,win="3D 散点图",env="main",
            opts=dict(markersize=4,
                      xlabel="特征1",
                      ylabel="特征2"))
image-20220728200129712 image-20220728200135598

折线图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 绘制折线图
x=torch.linspace(-6,6,100).view((-1,1))
sigmoid=torch.nn.Sigmoid()
sigmoidy=sigmoid(x)
tanh=torch.nn.Tanh()
tanhy=tanh(x)
relu=torch.nn.ReLU()
reluy=relu(x)

ploty=torch.cat((sigmoidy,tanhy,reluy),dim=1)
plotx=torch.cat((x,x,x),dim=1)
vis.line(Y=ploty,X=plotx,win="line plot",env="main",
         opts=dict(dash=np.array(["solid","dash","dashdot"]),
                   legend=['sigmoid','tanh','relu']))
image-20220728200141579

茎叶图

1
2
3
4
5
6
7
8
9
10
# 茎叶图
x=torch.linspace(-6,6,100).view((-1,1))
y1=torch.sin(x)
y2=torch.cos(x)

plotx=torch.cat((y1,y2),1)
ploty=torch.cat((x,x),1)

vis.stem(X=plotx,Y=ploty,win="stem plot",env="main",
         opts=dict(legend=['sin','cos'],title="茎叶图"))
image-20220728200149240

热力图

1
2
3
4
5
6
7
8
# 热力图
# 计算相关系数
irs_cor=torch.from_numpy(np.corrcoef(ix,rowvar=False))
vis.heatmap(irs_cor,win='heatmap',env="main",opts=dict(
    rownames=["x1","x2","x3","x4"],
    columnnames=["x1","x2","x3","x4"],
    title="热力图"
))
image-20220728200156034

图片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 创建新环境并显示手写数字集合
bx=0
for step,(x,by) in enumerate(train_loader):
    bx=x
    if step>0:
        break
vis.image(bx[0,...],win="one image",env="Myimage",opts=dict(
    title="图片"
))

# 生成一个图像网络
vis.images(bx,win="batch image",env="Myimage",nrow=16,opts=dict(
    title="一批图片"
))
image-20220728200203965

文本

1
2
3
4
5
6
7
# 可视化一段文本
text='''
asdsadasfhoisauew 
'''
vis.text(text,win="text plot",env="Myimage",opts=dict(
    title="文本"
))
image-20220728200210071