[pytorch框架] 5.3 fashion mnist进行分类 -凯发真人娱乐

文章目录

5.3 fashion mnist进行分类
fashion mnist 介绍
数据集介绍
分类
格式
数据提交
数据加载
创建网络
损失函数
优化器
开始训练
训练后操作
可视化损失函数
保存模型
模型评估
进一步优化
再次进行评估
总结

import torch,math

from pathlib import path

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

import torchvision.datasets as dsets

from torch.utils.data import dataset, dataloader
import torch.nn.functional as f

import torch.nn as nn

torch.__version__

'1.2.0'

fashion mnist 介绍

fashion mnist数据集 是kaggle上提供的一个图像分类入门级的数据集，其中包含10个类别的70000个灰度图像。如图所示，这些图片显示的是每件衣服的低分辨率(28×28像素)

数据集的下载和介绍：地址

fashion mnist的目标是作为经典mnist数据的替换——通常被用作计算机视觉机器学习程序的“hello, world”。

mnist数据集包含手写数字(0-9等)的图像，格式与我们将在这里使用的衣服相同，mnist只有手写的0-1数据的复杂度不高，所以他只能用来做“hello, world”

而fashion mnist 的由于使用的是衣服的数据，比数字要复杂的多，并且图片的内容也会更加多样性，所以它是一个比常规mnist稍微更具挑战性的问题。

fashion mnist这个数据集相对较小，用于验证算法是否按预期工作。它们是测试和调试代码的好起点。

数据集介绍

分类

0 t-shirt/top

1 trouser

2 pullover

3 dress

4 coat

5 sandal

6 shirt

7 sneaker

8 bag

9 ankle boot

格式

fashion-mnist_test.csv

fashion-mnist_train.csv

存储的训练的数据和测试的数据，格式如下：

label是分类的标签
pixel1-pixel784是每一个像素代表的值 因为是灰度图像，所以是一个0-255之间的数值。

为什么是784个像素？ 28 * 28 = 784

数据提交

fashion mnist不需要我们进行数据的提交，数据集中已经帮助我们将 训练集和测试集分好了，我们只需要载入、训练、查看即可，所以fashion mnist 是一个非常好的入门级别的数据集

#指定数据目录

data_path=path('./data/')

train = pd.read_csv(data_path / "fashion-mnist_train.csv");

train.head(10)

	label	pixel1	pixel2	pixel3	pixel4	pixel5	pixel6	pixel7	pixel8	pixel9	...	pixel775	pixel776	pixel777	pixel778	pixel779	pixel780	pixel781	pixel782	pixel783	pixel784
0	2	0	0	0	0	0	0	0	0	0	...	0	0	0	0	0	0	0	0	0	0
1	9	0	0	0	0	0	0	0	0	0	...	0	0	0	0	0	0	0	0	0	0
2	6	0	0	0	0	0	0	0	5	0	...	0	0	0	30	43	0	0	0	0	0
3	0	0	0	0	1	2	0	0	0	0	...	3	0	0	0	0	1	0	0	0	0
4	3	0	0	0	0	0	0	0	0	0	...	0	0	0	0	0	0	0	0	0	0
5	4	0	0	0	5	4	5	5	3	5	...	7	8	7	4	3	7	5	0	0	0
6	4	0	0	0	0	0	0	0	0	0	...	14	0	0	0	0	0	0	0	0	0
7	5	0	0	0	0	0	0	0	0	0	...	0	0	0	0	0	0	0	0	0	0
8	4	0	0	0	0	0	0	3	2	0	...	1	0	0	0	0	0	0	0	0	0
9	8	0	0	0	0	0	0	0	0	0	...	203	214	166	0	0	0	0	0	0	0

10 rows × 785 columns

test = pd.read_csv(data_path / "fashion-mnist_test.csv");

test.head(10)

	label	pixel1	pixel2	pixel3	pixel4	pixel5	pixel6	pixel7	pixel8	pixel9	...	pixel775	pixel776	pixel777	pixel778	pixel779	pixel780	pixel781	pixel782	pixel783	pixel784
0	0	0	0	0	0	0	0	0	9	8	...	103	87	56	0	0	0	0	0	0	0
1	1	0	0	0	0	0	0	0	0	0	...	34	0	0	0	0	0	0	0	0	0
2	2	0	0	0	0	0	0	14	53	99	...	0	0	0	0	63	53	31	0	0	0
3	2	0	0	0	0	0	0	0	0	0	...	137	126	140	0	133	224	222	56	0	0
4	3	0	0	0	0	0	0	0	0	0	...	0	0	0	0	0	0	0	0	0	0
5	2	0	0	0	0	0	44	105	44	10	...	105	64	30	0	0	0	0	0	0	0
6	8	0	0	0	0	0	0	0	0	0	...	0	0	0	0	0	0	0	0	0	0
7	6	0	0	0	0	0	0	0	1	0	...	174	136	155	31	0	1	0	0	0	0
8	5	0	0	0	0	0	0	0	0	0	...	0	0	0	0	0	0	0	0	0	0
9	0	0	0	0	0	0	0	0	0	0	...	57	70	28	0	2	0	0	0	0	0

10 rows × 785 columns

train.max()

label         9

pixel1       16

pixel2       36

pixel3      226

pixel4      164

           ...

pixel780    255

pixel781    255

pixel782    255

pixel783    255

pixel784    170

length: 785, dtype: int64

ubyte文件标识了数据的格式

其中idx3的数字表示数据维度。也就是图像为3维，
idx1 标签维1维。

具体格式详解：http://yann.lecun.com/exdb/mnist/

import struct

from pil import image 
with open(data_path / "train-images-idx3-ubyte", 'rb') as file_object:

    header_data=struct.unpack(">4i",file_object.read(16))

    print(header_data)

(2051, 60000, 28, 28)

with open(data_path / "train-labels-idx1-ubyte", 'rb') as file_object:

    header_data=struct.unpack(">2i",file_object.read(8))

    print(header_data)

(2049, 60000)

如下是训练的图片的二进制格式

[offset] [type]          [value]          [description]

0000     32 bit integer  0x00000803(2051) magic number

0004     32 bit integer  60000            number of images

0008     32 bit integer  28               number of rows

0012     32 bit integer  28               number of columns

0016     unsigned byte   ??               pixel

0017     unsigned byte   ??               pixel

........

xxxx     unsigned byte   ??               pixel

有四字节的header_data，故使用unpack_from进行二进制转换时，偏置offset=16

with open(data_path / "train-images-idx3-ubyte", 'rb') as file_object:

    raw_img=file_object.read()

img = struct.unpack_from(">784b",raw_img,16)

image = np.asarray(img)

image = image.reshape((28,28))

print(image.shape)

plt.imshow(image,cmap = plt.cm.gray)

plt.show()

(28, 28)

with open(data_path / "train-labels-idx1-ubyte", 'rb') as file_object:

    raw_img = file_object.read(1)

    label = struct.unpack(">b",raw_img)

    print(label)

(0,)

这里好像有点错误，显示的错位了，但是我的确是按照格式进行处理的。这种格式处理起来比较复杂，并且数据集中的csv直接给出了每个像素的值，所以这里我们可以直接使用csv格式的数据。

数据加载

为了使用pytorch的dataloader进行数据的加载，需要先创建一个自定义的dataset

class fashionmnistdataset(dataset):

    def __init__(self, csv_file, transform=none):

        data = pd.read_csv(csv_file)

        self.x = np.array(data.iloc[:, 1:]).reshape(-1, 1, 28, 28).astype(float)

        self.y = np.array(data.iloc[:, 0]);

        del data;  #结束data对数据的引用,节省空间

        self.len=len(self.x)
    def __len__(self):

        #return len(self.x)

        return self.len
    def __getitem__(self, idx):

        item = self.x[idx]

        label = self.y[idx]

        return (item, label)

对于自定义的数据集，只需要实现三个函数：

__init__： 初始化函数主要用于数据的加载，这里直接使用pandas将数据读取为dataframe，然后将其转成numpy数组来进行索引

__len__： 返回数据集的总数，pytorch里面的datalorder需要知道数据集的总数的

__getitem__：会返回单张图片，它包含一个index，返回值为样本及其标签。

创建训练和测试集

train_dataset = fashionmnistdataset(csv_file=data_path / "fashion-mnist_train.csv")

test_dataset = fashionmnistdataset(csv_file=data_path / "fashion-mnist_test.csv")

在使用pytorch的dataloader读取数据之前，需要指定一个batch size 这也是一个超参数，涉及到内存的使用量，如果出现oom的错误则要减小这个数值，一般这个数值都为2的幂或者2的倍数。

#因为是常量，所以大写，需要说明的是，这些常量建议都使用完整的英文单词，减少歧义

batch_size=256 # 这个batch 可以在m250的笔记本显卡中进行训练，不会oom

我们接着使用dataloader模块来使用这些数据

train_loader = torch.utils.data.dataloader(dataset=train_dataset,

                                           batch_size=batch_size,

                                           shuffle=true) # shuffle 标识要打乱顺序

test_loader = torch.utils.data.dataloader(dataset=test_dataset,

                                           batch_size=batch_size,

                                           shuffle=false) # shuffle 标识要打乱顺序，测试集不需要打乱

查看一下数据

a=iter(train_loader)

data=next(a)

img=data[0][0].reshape(28,28)

data[0][0].shape,img.shape

(torch.size([1, 28, 28]), torch.size([28, 28]))

plt.imshow(img,cmap = plt.cm.gray)

plt.show()

这回看着就没问题了，是一个完整的图了，所以我们还是用csv吧

创建网络

三层的简单的cnn网络

class cnn(nn.module):

    def __init__(self):

        super(cnn, self).__init__()

        self.layer1 = nn.sequential(

            nn.conv2d(1, 16, kernel_size=5, padding=2),

            nn.batchnorm2d(16),

            nn.relu()) #16, 28, 28

        self.pool1=nn.maxpool2d(2) #16, 14, 14

        self.layer2 = nn.sequential(

            nn.conv2d(16, 32, kernel_size=3),

            nn.batchnorm2d(32),

            nn.relu())#32, 12, 12

        self.layer3 = nn.sequential(

            nn.conv2d(32, 64, kernel_size=3),

            nn.batchnorm2d(64),

            nn.relu()) #64, 10, 10

        self.pool2=nn.maxpool2d(2)  #64, 5, 5

        self.fc = nn.linear(5*5*64, 10)

    def forward(self, x):

        out = self.layer1(x)

        #print(out.shape)

        out=self.pool1(out)

        #print(out.shape)

        out = self.layer2(out)

        #print(out.shape)

        out=self.layer3(out)

        #print(out.shape)

        out=self.pool2(out)

        #print(out.shape)

        out = out.view(out.size(0), -1)

        #print(out.shape)

        out = self.fc(out)

        return out

以上代码看起来很简单。这里面都是包含的数学的含义。我们只讲pytorch相关的：在函数里使用torch.nn提供的模块来定义各个层，在每个卷积层后使用了批次的归一化和relu激活并且在每一个操作分组后面进行了pooling的操作（减少信息量，避免过拟合），后我们使用了全连接层来输出10个类别。

view函数用来改变输出值矩阵的形状来匹配最后一层的维度。

cnn = cnn();

#可以通过以下方式验证，没报错说明没问题，

cnn(torch.rand(1,1,28,28))

tensor([[-0.9031,  0.1854, -1.2564,  0.0946, -0.9428,  0.9311, -0.4686, -0.5068,

         -0.3318, -0.6995]], grad_fn=)

#打印下网络，做最后的确认

print(cnn)

cnn(

  (layer1): sequential(

    (0): conv2d(1, 16, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))

    (1): batchnorm2d(16, eps=1e-05, momentum=0.1, affine=true, track_running_stats=true)

    (2): relu()

  )

  (pool1): maxpool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=false)

  (layer2): sequential(

    (0): conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1))

    (1): batchnorm2d(32, eps=1e-05, momentum=0.1, affine=true, track_running_stats=true)

    (2): relu()

  )

  (layer3): sequential(

    (0): conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))

    (1): batchnorm2d(64, eps=1e-05, momentum=0.1, affine=true, track_running_stats=true)

    (2): relu()

  )

  (pool2): maxpool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=false)

  (fc): linear(in_features=1600, out_features=10, bias=true)

)

从定义模型开始就要指定模型计算的位置，cpu还是gpu，所以需要加另外一个参数

device=torch.device("cpu")

if torch.cuda.is_available():

        device=torch.device("cuda")

print(device)

cuda

#先把网络放到gpu上

cnn=cnn.to(device)

损失函数

多分类因为使用softmax回归将神经网络前向传播得到的结果变成概率分布 所以使用交叉熵损失。
在pytorch中
nn.crossentropyloss 是将 nn.logsoftmax() 和 nn.nllloss()进行了整合，crossentropyloss ,我们也可以分开来写使用两步计算，这里为了方便直接一步到位

#损失函数也需要放到gpu中

criterion = nn.crossentropyloss().to(device)

优化器

adam 优化器：简单，暴力，最主要还是懒

#另外一个超参数，学习率

learning_rate=0.01

#优化器不需要放gpu

optimizer = torch.optim.adam(cnn.parameters(), lr=learning_rate)

开始训练

#另外一个超参数，指定训练批次

total_epochs=50

%%time

#记录损失函数

losses = [];

for epoch in range(total_epochs):

    for i, (images, labels) in enumerate(train_loader):

        images = images.float().to(device)

        labels = labels.to(device)

        #清零

        optimizer.zero_grad()

        outputs = cnn(images)

        #计算损失函数

        loss = criterion(outputs, labels)

        loss.backward()

        optimizer.step()

        losses.append(loss.cpu().data.item());

        if (i 1) % 100 == 0:

            print ('epoch : %d/%d, iter : %d/%d,  loss: %.4f'%(epoch 1, total_epochs, i 1, len(train_dataset)//batch_size, loss.data.item()))

epoch : 1/50, iter : 100/234,  loss: 0.4569

epoch : 1/50, iter : 200/234,  loss: 0.3623

epoch : 2/50, iter : 100/234,  loss: 0.2648

epoch : 2/50, iter : 200/234,  loss: 0.3044

epoch : 3/50, iter : 100/234,  loss: 0.2107

epoch : 3/50, iter : 200/234,  loss: 0.3022

epoch : 4/50, iter : 100/234,  loss: 0.2583

epoch : 4/50, iter : 200/234,  loss: 0.2837

epoch : 5/50, iter : 100/234,  loss: 0.2377

epoch : 5/50, iter : 200/234,  loss: 0.2422

epoch : 6/50, iter : 100/234,  loss: 0.1537

epoch : 6/50, iter : 200/234,  loss: 0.2270

epoch : 7/50, iter : 100/234,  loss: 0.1485

epoch : 7/50, iter : 200/234,  loss: 0.1740

epoch : 8/50, iter : 100/234,  loss: 0.3264

epoch : 8/50, iter : 200/234,  loss: 0.2096

epoch : 9/50, iter : 100/234,  loss: 0.1844

epoch : 9/50, iter : 200/234,  loss: 0.1927

epoch : 10/50, iter : 100/234,  loss: 0.1343

epoch : 10/50, iter : 200/234,  loss: 0.2225

epoch : 11/50, iter : 100/234,  loss: 0.1251

epoch : 11/50, iter : 200/234,  loss: 0.1789

epoch : 12/50, iter : 100/234,  loss: 0.1439

epoch : 12/50, iter : 200/234,  loss: 0.1290

epoch : 13/50, iter : 100/234,  loss: 0.2017

epoch : 13/50, iter : 200/234,  loss: 0.1130

epoch : 14/50, iter : 100/234,  loss: 0.0992

epoch : 14/50, iter : 200/234,  loss: 0.1736

epoch : 15/50, iter : 100/234,  loss: 0.0920

epoch : 15/50, iter : 200/234,  loss: 0.1557

epoch : 16/50, iter : 100/234,  loss: 0.0914

epoch : 16/50, iter : 200/234,  loss: 0.1508

epoch : 17/50, iter : 100/234,  loss: 0.1273

epoch : 17/50, iter : 200/234,  loss: 0.1982

epoch : 18/50, iter : 100/234,  loss: 0.1752

epoch : 18/50, iter : 200/234,  loss: 0.1517

epoch : 19/50, iter : 100/234,  loss: 0.0586

epoch : 19/50, iter : 200/234,  loss: 0.0984

epoch : 20/50, iter : 100/234,  loss: 0.1409

epoch : 20/50, iter : 200/234,  loss: 0.1286

epoch : 21/50, iter : 100/234,  loss: 0.0900

epoch : 21/50, iter : 200/234,  loss: 0.1168

epoch : 22/50, iter : 100/234,  loss: 0.0755

epoch : 22/50, iter : 200/234,  loss: 0.1217

epoch : 23/50, iter : 100/234,  loss: 0.0703

epoch : 23/50, iter : 200/234,  loss: 0.1383

epoch : 24/50, iter : 100/234,  loss: 0.0916

epoch : 24/50, iter : 200/234,  loss: 0.0685

epoch : 25/50, iter : 100/234,  loss: 0.0947

epoch : 25/50, iter : 200/234,  loss: 0.1244

epoch : 26/50, iter : 100/234,  loss: 0.0615

epoch : 26/50, iter : 200/234,  loss: 0.0478

epoch : 27/50, iter : 100/234,  loss: 0.0280

epoch : 27/50, iter : 200/234,  loss: 0.0459

epoch : 28/50, iter : 100/234,  loss: 0.0213

epoch : 28/50, iter : 200/234,  loss: 0.0764

epoch : 29/50, iter : 100/234,  loss: 0.0391

epoch : 29/50, iter : 200/234,  loss: 0.0899

epoch : 30/50, iter : 100/234,  loss: 0.0541

epoch : 30/50, iter : 200/234,  loss: 0.0750

epoch : 31/50, iter : 100/234,  loss: 0.0605

epoch : 31/50, iter : 200/234,  loss: 0.0766

epoch : 32/50, iter : 100/234,  loss: 0.1368

epoch : 32/50, iter : 200/234,  loss: 0.0588

epoch : 33/50, iter : 100/234,  loss: 0.0253

epoch : 33/50, iter : 200/234,  loss: 0.0705

epoch : 34/50, iter : 100/234,  loss: 0.0248

epoch : 34/50, iter : 200/234,  loss: 0.0751

epoch : 35/50, iter : 100/234,  loss: 0.0449

epoch : 35/50, iter : 200/234,  loss: 0.1006

epoch : 36/50, iter : 100/234,  loss: 0.0281

epoch : 36/50, iter : 200/234,  loss: 0.0418

epoch : 37/50, iter : 100/234,  loss: 0.0547

epoch : 37/50, iter : 200/234,  loss: 0.1003

epoch : 38/50, iter : 100/234,  loss: 0.0694

epoch : 38/50, iter : 200/234,  loss: 0.0340

epoch : 39/50, iter : 100/234,  loss: 0.0620

epoch : 39/50, iter : 200/234,  loss: 0.1004

epoch : 40/50, iter : 100/234,  loss: 0.0588

epoch : 40/50, iter : 200/234,  loss: 0.0309

epoch : 41/50, iter : 100/234,  loss: 0.0387

epoch : 41/50, iter : 200/234,  loss: 0.0136

epoch : 42/50, iter : 100/234,  loss: 0.0149

epoch : 42/50, iter : 200/234,  loss: 0.0448

epoch : 43/50, iter : 100/234,  loss: 0.0076

epoch : 43/50, iter : 200/234,  loss: 0.0593

epoch : 44/50, iter : 100/234,  loss: 0.0267

epoch : 44/50, iter : 200/234,  loss: 0.0308

epoch : 45/50, iter : 100/234,  loss: 0.0150

epoch : 45/50, iter : 200/234,  loss: 0.0764

epoch : 46/50, iter : 100/234,  loss: 0.0221

epoch : 46/50, iter : 200/234,  loss: 0.0325

epoch : 47/50, iter : 100/234,  loss: 0.0190

epoch : 47/50, iter : 200/234,  loss: 0.0359

epoch : 48/50, iter : 100/234,  loss: 0.0256

epoch : 48/50, iter : 200/234,  loss: 0.0374

epoch : 49/50, iter : 100/234,  loss: 0.0198

epoch : 49/50, iter : 200/234,  loss: 0.0300

epoch : 50/50, iter : 100/234,  loss: 0.0465

epoch : 50/50, iter : 200/234,  loss: 0.0558

wall time: 7min 18s

训练后操作

可视化损失函数

plt.xkcd();

plt.xlabel('epoch #');

plt.ylabel('loss');

plt.plot(losses);

plt.show();

保存模型

torch.save(cnn.state_dict(), "fm-cnn3.pth")

# 加载用这个

#cnn.load_state_dict(torch.load("fm-cnn3.pth"))

模型评估

模型评估就是使用测试集对模型进行的评估，应该是添加到训练中进行了，这里为了方便说明直接在训练完成后评估了

cnn.eval()

correct = 0

total = 0

for images, labels in test_loader:

    images = images.float().to(device)

    outputs = cnn(images).cpu()

    _, predicted = torch.max(outputs.data, 1)

    total  = labels.size(0)

    correct  = (predicted == labels).sum()

print('准确率: %.4f %%' % (100 * correct / total))

准确率: 90.0000 %

模型评估的步骤如下：

将网络的模式改为eval。
将图片输入到网络中得到输出。
通过取出one-hot输出的最大值来得到输出的 标签。
统计正确的预测值。

进一步优化

%%time

#修改学习率和批次

cnn.train()

learning_rate=learning_rate / 10

total_epochs=20

optimizer = torch.optim.adam(cnn.parameters(), lr=0.001)

losses = [];

for epoch in range(total_epochs):

    for i, (images, labels) in enumerate(train_loader):

        images = images.float().to(device)

        labels = labels.to(device)

        #清零

        optimizer.zero_grad()

        outputs = cnn(images)

        #计算损失函数

        #损失函数直接放到cpu中，因为还有其他的计算

        loss = criterion(outputs, labels).cpu()

        loss.backward()

        optimizer.step()

        losses.append(loss.data.item());

        if (i 1) % 100 == 0:

            print ('epoch : %d/%d, iter : %d/%d,  loss: %.4f'%(epoch 1, total_epochs, i 1, len(train_dataset)//batch_size, loss.data.item()))

epoch : 1/20, iter : 100/234,  loss: 0.0096

epoch : 1/20, iter : 200/234,  loss: 0.0124

epoch : 2/20, iter : 100/234,  loss: 0.0031

epoch : 2/20, iter : 200/234,  loss: 0.0020

epoch : 3/20, iter : 100/234,  loss: 0.0013

epoch : 3/20, iter : 200/234,  loss: 0.0041

epoch : 4/20, iter : 100/234,  loss: 0.0016

epoch : 4/20, iter : 200/234,  loss: 0.0023

epoch : 5/20, iter : 100/234,  loss: 0.0010

epoch : 5/20, iter : 200/234,  loss: 0.0008

epoch : 6/20, iter : 100/234,  loss: 0.0017

epoch : 6/20, iter : 200/234,  loss: 0.0010

epoch : 7/20, iter : 100/234,  loss: 0.0009

epoch : 7/20, iter : 200/234,  loss: 0.0009

epoch : 8/20, iter : 100/234,  loss: 0.0005

epoch : 8/20, iter : 200/234,  loss: 0.0008

epoch : 9/20, iter : 100/234,  loss: 0.0005

epoch : 9/20, iter : 200/234,  loss: 0.0006

epoch : 10/20, iter : 100/234,  loss: 0.0016

epoch : 10/20, iter : 200/234,  loss: 0.0011

epoch : 11/20, iter : 100/234,  loss: 0.0003

epoch : 11/20, iter : 200/234,  loss: 0.0009

epoch : 12/20, iter : 100/234,  loss: 0.0010

epoch : 12/20, iter : 200/234,  loss: 0.0002

epoch : 13/20, iter : 100/234,  loss: 0.0004

epoch : 13/20, iter : 200/234,  loss: 0.0005

epoch : 14/20, iter : 100/234,  loss: 0.0003

epoch : 14/20, iter : 200/234,  loss: 0.0004

epoch : 15/20, iter : 100/234,  loss: 0.0002

epoch : 15/20, iter : 200/234,  loss: 0.0005

epoch : 16/20, iter : 100/234,  loss: 0.0002

epoch : 16/20, iter : 200/234,  loss: 0.0007

epoch : 17/20, iter : 100/234,  loss: 0.0003

epoch : 17/20, iter : 200/234,  loss: 0.0002

epoch : 18/20, iter : 100/234,  loss: 0.0004

epoch : 18/20, iter : 200/234,  loss: 0.0001

epoch : 19/20, iter : 100/234,  loss: 0.0003

epoch : 19/20, iter : 200/234,  loss: 0.0005

epoch : 20/20, iter : 100/234,  loss: 0.0002

epoch : 20/20, iter : 200/234,  loss: 0.0002

wall time: 2min 21s

可视化一下损失

plt.xkcd();

plt.xlabel('epoch #');

plt.ylabel('loss');

plt.plot(losses);

plt.show();

再次进行评估

cnn.eval()

correct = 0

total = 0

for images, labels in test_loader:

    images = images.float().to(device)

    outputs = cnn(images).cpu()

    _, predicted = torch.max(outputs.data, 1)

    total  = labels.size(0)

    correct  = (predicted == labels).sum()

print('准确率: %.4f %%' % (100 * correct / total))

准确率: 91.0000 %

%%time

#修改学习率和批次

cnn.train()

learning_rate=learning_rate / 10

total_epochs=10

optimizer = torch.optim.adam(cnn.parameters(), lr=0.001)

losses = [];

for epoch in range(total_epochs):

    for i, (images, labels) in enumerate(train_loader):

        images = images.float().to(device)

        labels = labels.to(device)

        #清零

        optimizer.zero_grad()

        outputs = cnn(images)

        #计算损失函数

        #损失函数直接放到cpu中，因为还有其他的计算

        loss = criterion(outputs, labels)

        loss.backward()

        optimizer.step()

        losses.append(loss.cpu().data.item());

        if (i 1) % 100 == 0:

            print ('epoch : %d/%d, iter : %d/%d,  loss: %.4f'%(epoch 1, total_epochs, i 1, len(train_dataset)//batch_size, loss.data.item()))

epoch : 1/10, iter : 100/234,  loss: 0.0002

epoch : 1/10, iter : 200/234,  loss: 0.0001

epoch : 2/10, iter : 100/234,  loss: 0.0001

epoch : 2/10, iter : 200/234,  loss: 0.0005

epoch : 3/10, iter : 100/234,  loss: 0.0002

epoch : 3/10, iter : 200/234,  loss: 0.0001

epoch : 4/10, iter : 100/234,  loss: 0.0003

epoch : 4/10, iter : 200/234,  loss: 0.0001

epoch : 5/10, iter : 100/234,  loss: 0.0002

epoch : 5/10, iter : 200/234,  loss: 0.0003

epoch : 6/10, iter : 100/234,  loss: 0.0002

epoch : 6/10, iter : 200/234,  loss: 0.0002

epoch : 7/10, iter : 100/234,  loss: 0.0001

epoch : 7/10, iter : 200/234,  loss: 0.0002

epoch : 8/10, iter : 100/234,  loss: 0.0008

epoch : 8/10, iter : 200/234,  loss: 0.0008

epoch : 9/10, iter : 100/234,  loss: 0.0005

epoch : 9/10, iter : 200/234,  loss: 0.0002

epoch : 10/10, iter : 100/234,  loss: 0.0006

epoch : 10/10, iter : 200/234,  loss: 0.0002

wall time: 1min 9s

plt.xkcd();

plt.xlabel('epoch #');

plt.ylabel('loss');

plt.plot(losses);

plt.show();

cnn.eval()

correct = 0

total = 0

for images, labels in test_loader:

    images = images.float().to(device)

    outputs = cnn(images).cpu()

    _, predicted = torch.max(outputs.data, 1)

    total  = labels.size(0)

    correct  = (predicted == labels).sum()

print('准确率: %.4f %%' % (100 * correct / total))

准确率: 91.0000 %

损失小了，但是准确率没有提高，这就说明已经接近模型的瓶颈了，如果再要进行优化，就需要修改模型了。另外还有一个判断模型是否到瓶颈的标准，就是看损失函数，最后一次的训练的损失函数明显的没有下降的趋势，只是在震荡，这说明已经没有什么优化的空间了。

通过简单的操作，我们也能够看到adam优化器的暴力性，我们只要简单的修改学习率就能够达到优化的效果，adam优化器的使用一般情况下是首先使用0.1进行预热，然后再用0.01进行大批次的训练，最后使用0.001这个学习率进行收尾，再小的学习率一般情况就不需要了。

总结

最后我们再总结一下几个超参数:

batch_size: 批次数量，定义每次训练时多少数据作为一批，这个批次需要在dataloader初始化时进行设置，并且需要这对模型和显存进行配置，如果出现oom有线减小，一般设为2的倍数

device：进行计算的设备，主要是cpu还是gpu

learning_rate：学习率，反向传播时使用

total_epochs：训练的批次，一般情况下会根据损失和准确率等阈值

其实优化器和损失函数也算超参数，这里就不说了

[pytorch框架] 5.3 fashion mnist进行分类的相关教程结束。