浅谈一下基于Pytorch的可视化工具

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
 
"""
下面导入手写字体数据，并将数据处理为数据加载器
"""
train_data=torchvision.datasets.MNIST(
    root="./Dataset",
    train=True,
    #将数据转化为torch使用的张量，取值范围为[0-1]
    transfORM=torchvision.transforms.ToTensor(),
    download=False#因为数据已经下载过所以这里不在下载
    )
#定义一个数据加载器
train_loader=Data.DataLoader(
    dataset=train_data,#使用的数据集
    batch_size=128,#批处理样本大小
    shuffle=True,
    num_workers=0
)
#准备需要的测试集
test_data=torchvision.datasets.MNIST(
    root="./Dataset",
    train=False,
    download=False
)
#为数据添加一个通道维度，并且取值范围缩放到[0-1]之间
test_data_x=test_data.data.type(torch.FloatTensor)/255.0
test_data_x=torch.unsqueeze(test_data_x,dim=1)
test_data_y=test_data.targets#测试集的标签
print(test_data_x.shape)
print(test_data_y.shape)
"""
(1)针对训练集使用torchvision.datasets.MNIST()函数导入数据，
并将其像素值转化到0~1之间，然后使用Data.DataLoader()函数定义一个数据加载器，
每个batch包含128张图像。
(2)针对测试数据，同样使用torchvision.datasets.MNIST()函数导入数据，
但不将数据处理为数据加载器，而是将整个测试集作为一个batch，方便计算模型在测试集上的预测精度。
"""
#搭建一个卷积神经网络
class ConvNet(nn.Module):
    def __init__(self):
        super(ConvNet,self).__init__()
        #定义第一个卷积层
        self.conv1=nn.Sequential(
            nn.Conv2d(
                in_channels=1,#输入的feature_map
                out_channels=16,#输出的feature_map
                kernel_size=3,#卷积核尺寸
                stride=1,#卷积核步长
                padding=1,#进行填充
            ),
            nn.ReLU(),#激活函数
            nn.AvgPool2d(
                kernel_size=2,#平均值池化层,使用2*2
                stride=2,#池化步长为2
            ),
        )
        #定义第二个卷积层
        self.conv2=nn.Sequential(
            nn.Conv2d(16,32,3,1,1),
            nn.ReLU(),#激活函数
            nn.MaxPool2d(2,2)#最大值池化
        )
        #定义全连接层
        self.fc=nn.Sequential(
            nn.Linear(
                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):
        x=self.conv1(x),
        x=self.conv2(x),
        x=x.view(x.size(0),-1),#展平多维的卷积图层
        x=self.fc(x),
        output=self.out(x),
        return output
myConvNet=ConvNet()

from torchviz import make_dot
x=torch.randn(1,1,28,28).requires_grad_(True)
y=myConvNet(x)
#make_dot用来得到网络的可视化图像
myConvNets=make_dot(y,params=dict(list(myConvNet.named_parameters())+[("x",x)]))
myConvNets.format='png'#指定可视化图像的格式
myConvNets.directory="model_graph/"#指定图像保存的文件夹
myConvNets.view()

from tensorboardX import SummaryWriter
SumWriter=SummaryWriter(log_dir='./log')#日志保存路径
#定义优化器
optimizer=torch.optim.Adam(myConvNet.parameters(),lr=0.003)
#定义损失函数
loss_func=nn.CrossEntropyLoss()
train_loss=0
print_step=100#每经过100次迭代，输出损失
#对模型进行迭代训练，对所有的数据训练epoch轮
for epoch in range(5):
    #对训练数据的加载器进行迭代计算
    for step,(b_x,b_y) in enumerate(train_loader):
        #计算每个batch上的损失
        output=myConvNet(b_x)
        loss=loss_func(output,b_y)#交叉熵损失函数
        optimizer.zero_grad()#每个迭代步的梯度初始化为0
        loss.backward()#损失后向传播
        optimizer.step()#使用梯度进行优化
        train_loss=train_loss+loss#计算累加损失
        niter=epoch*len(train_loader)+step+1#计算迭代次数
        #计算每经过print_step次迭代后的输出
        if niter % print_step==0:
            #为日志添加训练集损失函数
            SumWriter.add_scalar("train loss",train_loss.item() / niter,global_step=niter)
            #计算在测试集上的精度
            output=myConvNet(test_data_x)
            _,pre_lab=torch.max(output,1)
            acc=accuracy_score(test_data_y,pre_lab)
            #为日志添加测试集上的预测精度
            SumWriter.add_scalar("test acc",acc.item(),niter)
            #为日志中添加训练数据的可视化图像，使用当前batch的图像
            #将一个batch的数据进行预处理
            b_x_im=vutils.make_grid(b_x,nrow=12)
            SumWriter.add_image('train image sample',b_x_im,niter)
            #使用直方图可视化网络中参数的分布情况
            for name,param in myConvNet.named_parameters():
                SumWriter.add_histogram(name,param.data.numpy(),niter)
 

import numpy as np
import torch
from visdom import Visdom
from sklearn.datasets import load_iris
iris_x,iris_y=load_iris(return_X_y=True)
print(iris_x.shape)
print(iris_y.shape)
"""
上面的程序导入了鸢尾花数据集，包含3类数据，150个样本，每个样本包含4个特征。
"""
vis=Visdom()
#2D散点图
vis.scatter(iris_x[:,0:2],Y=iris_y+1,win="windows1",env="main")
#3D散点图
vis.scatter(iris_x[:,0:3],Y=iris_y+1,win="3D 散点图",env="main",opts=dict(markersize=4,xlabel="特征一",ylabel="特征二"))
"""
程序中使用vis = Visdom()初始化一个绘图对象，通过vis.scatter()为对象添加散点图。
在该函数中，如果输入的X为二维则可得到2D散点图，如果输入的X为三维则可得到3D散点图，
其中参数Y用于指定数据的分组情况,参数win指定图像的窗口名称，参数env则指定图像所在的环境。
可以发现两幅图像都在主环境main中。图像的其他设置可使用opts参数通过字典的形式设置。
在上述初始化的可视化图像环境main中，继续添加其他窗口，以绘制不同类型的图像，如添加折线图.
"""
#添加折线图
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)
#连接3个张量
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"]))
"""
上面的程序中，可视化出了sigmoid、Tanh和ReLU三种激活函数的图像。
在可视化折线时，使用vis.line()函数进行绘图，图像在环境main中，
通过win参数指定窗口名称为line plot，然后通过opts参数为不同的线设置了不同的线型。
"""
#添加茎叶图
x=torch.linspace(-6,6,100).view((-1,1))
y1=torch.sin(x)
y2=torch.cos(x)
#连接2个变量
plotx=torch.cat((y1,y2),dim=1)
ploty=torch.cat((x,x),dim=1)
vis.stem(X=plotx,Y=ploty,win="stem plot",env="main",
         #设置图例
        opts=dict(legend=["sin","cos"],title="茎叶图") )
"""
上面的程序中，可视化出了正弦和余弦函数的茎叶图。
在可视化时通过vis.stem()函数绘图，图像在环境main中，
通过win参数指定窗口名称为stem plot，然后通过opts参数为图像添加图例和标题。
"""
#添加热力图
iris_corr=torch.from_numpy(np.corrcoef(iris_x,rowvar=False))
vis.heatmap(iris_corr,win="heatmap",env="main",
            #设置每个特征的名称
            opts=dict(rownames=["x1","x2","x3","x4"],columnnames=["x1","x2","x3","x4"],title="热力图"))
"""
程序中可视化出了鸢尾花数据集中4个特征的相关系数热力图。
在可视化时通过vis.heatmap()函数进行绘图，图像在环境main中，
通过win参数指定窗口名称为heatmap，然后通过opts参数为图像添加X轴的变量名称、Y轴变量名称和标题。
"""