用tensorboard绘制简单的loss曲线图

  源码是csdn大佬的minst手写数字识别，我在他的源码上学习如何绘制loss曲线。

总的要点是

1关注enumerate函数的使用

2tensor.item()可以将tensor的值作为标量返回

3循环语句配合 writer才能绘制出loss曲线图

4用tensorboard --logdir=DATA命令查看loss曲线图

import torch
# @Time : 2020/6/6 13:23
# @Author : kingback
# @File : cnn_test.py
# @Software: PyCharm

import torch
import torch.nn as nn
from torch.autograd import Variable
import torch.utils.data as Data
import torchvision
from torch.utils.tensorboard import SummaryWriter

# Hyper prameters
EPOCH = 1
BATCH_SIZE = 50
LR = 0.001
DOWNLOAD_MNIST = True

train_data = torchvision.datasets.MNIST(
    root='./mnist',
    train=True,
    transform=torchvision.transforms.ToTensor(),  # 将下载的文件转换成pytorch认识的tensor类型，且将图片的数值大小从（0-255）归一化到（0-1）
    download=DOWNLOAD_MNIST
)

# 画一个图片显示出来
# print(train_data.data.size())
# print(train_data.targets.size())
# plt.imshow(train_data.data[0].numpy(),cmap='gray')
# plt.title('%i'%train_data.targets[0])
# plt.show()

train_loader = Data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)

test_data = torchvision.datasets.MNIST(
    root='./mnist',
    train=False,
)
with torch.no_grad():
    test_x = Variable(torch.unsqueeze(test_data.data, dim=1)).type(torch.FloatTensor)[
             :2000] / 255  # 只取前两千个数据吧，差不多已经够用了，然后将其归一化。
    test_y = test_data.targets[:2000]

'''开始建立CNN网络'''


class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        '''
        一般来说，卷积网络包括以下内容：
        1.卷积层
        2.神经网络
        3.池化层
        '''
        self.conv1 = nn.Sequential(
            nn.Conv2d(  # --> (1,28,28)
                in_channels=1,  # 传入的图片是几层的，灰色为1层，RGB为三层
                out_channels=16,  # 输出的图片是几层
                kernel_size=5,  # 代表扫描的区域点为5*5
                stride=1,  # 就是每隔多少步跳一下
                padding=2,  # 边框补全，其计算公式=（kernel_size-1）/2=(5-1)/2=2
            ),  # 2d代表二维卷积           --> (16,28,28)
            nn.ReLU(),  # 非线性激活层
            nn.MaxPool2d(kernel_size=2),  # 设定这里的扫描区域为2*2，且取出该2*2中的最大值          --> (16,14,14)
        )

        self.conv2 = nn.Sequential(
            nn.Conv2d(  # --> (16,14,14)
                in_channels=16,  # 这里的输入是上层的输出为16层
                out_channels=32,  # 在这里我们需要将其输出为32层
                kernel_size=5,  # 代表扫描的区域点为5*5
                stride=1,  # 就是每隔多少步跳一下
                padding=2,  # 边框补全，其计算公式=（kernel_size-1）/2=(5-1)/2=
            ),  # --> (32,14,14)
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),  # 设定这里的扫描区域为2*2，且取出该2*2中的最大值     --> (32,7,7)，这里是三维数据
        )

        self.out = nn.Linear(32 * 7 * 7, 10)  # 注意一下这里的数据是二维的数据

    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)  # （batch,32,7,7）
        # 然后接下来进行一下扩展展平的操作，将三维数据转为二维的数据
        x = x.view(x.size(0), -1)  # (batch ,32 * 7 * 7)
        output = self.out(x)
        return output


cnn = CNN()
# print(cnn)

# 添加优化方法
optimizer = torch.optim.Adam(cnn.parameters(), lr=LR)
# 指定损失函数使用交叉信息熵
loss_fn = nn.CrossEntropyLoss()
writer=SummaryWriter(log_dir='DATA', comment='LOSSSHOW')#设置函数曲线的存储位置及名称
'''
开始训练我们的模型哦
'''
step = 0
for epoch in range(EPOCH):
    # 加载训练数据
    for step, data in enumerate(train_loader):
        x, y = data
        # 分别得到训练数据的x和y的取值
        b_x = Variable(x)
        b_y = Variable(y)
        # print("step",step)
        output = cnn(b_x)  # 调用模型预测
        loss = loss_fn(output, b_y)  # 计算损失值
        optimizer.zero_grad()  # 每一次循环之前，将梯度清零
        loss.backward()  # 反向传播
        optimizer.step()  # 梯度下降
        writer.add_scalar("loss_show",loss.item(),step)#用writer.add_scalar()结合循环绘制图像曲线


'''
打印十个测试集的结果
'''