【Pytorch神经网络实战案例】08 识别黑白图中的服装图案(Fashion-MNIST)

1 Fashion-MNIST简介

FashionMNIST 是一个替代 MNIST 手写数字集 的图像数据集。 它是由 Zalando（一家德国的时尚科技公司）旗下的研究部门提供。其涵盖了来自 10 种类别的共 7 万个不同商品的正面图片。
FashionMNIST 的大小、格式和训练集/测试集划分与原始的 MNIST 完全一致。60000/10000 的训练测试数据划分，28x28 的灰度图片。你可以直接用它来测试你的机器学习和深度学习算法性能，且不需要改动任何的代码。说白了就是手写数字没有衣服鞋子之类的更复杂。

1.1 Fashion-MNIST数据集标签类件组成

Fashion-MNIST数据集包含了10个类别的图像，分别是：t-shirt（T恤），trouser（牛仔裤），pullover（套衫），dress（裙子），coat（外套），sandal（凉鞋），shirt（衬衫），sneaker（运动鞋），bag（包），ankle boot（短靴）。

1.2 Fashion-MNIST数据集文件组成

共包含四个文件，分别为：

• 训练数据图片train-images-idx3-ubyte
• 训练数据标签train-labels-idx1-ubyte
• 测试数据图片t10k-images-idx3-ubyte
• 测试数据标签t10k-labels-idx1-ubyte

1.3 Fashion-MNIST数据集序列号

标注编号描述
0：T-shirt/top（T恤）
1：Trouser（裤子）
2：Pullover（套衫）
3：Dress（裙子）
4：Coat（外套）
5：Sandal（凉鞋）
6：Shirt（汗衫）
7：Sneaker（运动鞋）
8：Bag（包）
9：Ankle boot（踝靴）

2 识别黑白图中的服装图案实战代码分解

2.1 自动下载Fashion-MNIST数据集

2.1.1 自动下载代码---Fashion-MNISt-CNN.py（第1部分）

import  torchvision
import torchvision.transforms as transforms
import pylab
import torch
from matplotlib import pyplot as plt
import torch.utils.data
import torch.nn.functional as F
import numpy as np
import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"

# 定义显示图像的函数
def imshow(img):
    print("图片形状",np.shape(img))
    img = img/2 +0.5
    npimg = img.numpy()
    plt.axis('off')
    plt.imshow(np.transpose(npimg,(1,2,0)))

### 1.1 自动下载FashionMNIST数据集
data_dir = './fashion_mnist' # 设置存放位置
transform = transforms.Compose([transforms.ToTensor()]) # 可以自动将图片转化为Pytorch支持的形状[通道，高，宽]，同时也将图片的数值归一化
train_dataset = torchvision.datasets.FashionMNIST(data_dir,train=True,transform=transform,download=True)
print("训练集的条数",len(train_dataset))

2.2 读取及其显示Fashion-MNIST中的数据

2.2.1 读取及其显示Fashion-MNIST中的数据代码实现 ---Fashion-MNISt-CNN.py（第2部分）

### 1.2 读取及显示FashionMNIST数据集中的数据
val_dataset = torchvision.datasets.FashionMNIST(root=data_dir,train=False,transform=transform)
print("测试集的条数",len(val_dataset))

2.2.2 FAshion-MNIST数据集补充知识

Fashion-MNST数据集中的图片大小是28像素×28像素。每-幅图就是1行784(28×28)列的数据括二中的每个值优麦一个像素。

关于像素：如果是黑白的图片，那么图案中黑色的地方数值为Q；在有图案的地方，数据为0~255的数字，代表其颜色的深度。如果是彩色的图片，那么一个像素会有3个值来表示其RGB(红、绿、蓝)值。

2.3 制造批次数据集

2.3.1 数据集封装类 DataLoader

torch.utils.data.DataLoader(dataset, batch_size=1,shuffle=False,sampler=None,
                            batch_sampler=None, num_workers=0, collate_fn=None,
                            pin_memory=False, drop_last=False, timeout=0，
                            worker_init_fn=None)
Arguments:
    dataset (Dataset): 是一个DataSet对象，表示需要加载的数据集.
    batch_size (int, optional): 每一个batch加载多少组样本，即指定batch_size，默认是 1 
    shuffle (bool, optional): 布尔值True或者是False ，表示每一个epoch之后是否对样本进行随机打乱，默认是False
------------------------------------------------------------------------------------
    sampler (Sampler, optional): 接受一个采集器对象，并且使用该策略进行提取样本，如果指定这个参数，那么shuffle必须为False
    batch_sampler (Sampler, optional): 与sampler类似，但是一次只返回一个batch的indices（索引），需要注意的是，一旦指定了这个参数，那么batch_size,shuffle,sampler,drop_last就不能再制定了（互斥）。
------------------------------------------------------------------------------------
    num_workers (int, optional): 设置加载数据的额外进程数量。0意味着所有的数据都会被load进主进程。（默认为0）
    collate_fn (callable, optional): 接收一个自定义函数。当该参数不为None时，系统会在从数据集中取出数据之后，将数据传入collate_fn中，由collate_fn参数所指向的函数对数据进行二次加工。该参数常用于在不同场景（测试和训练场景）下对同一数据集的数据提取。
    pin_memory (bool, optional): 如果设置为True，那么data loader将会在返回它们之前，将tensors拷贝到CUDA中的固定内存（CUDA pinned memory）中.
------------------------------------------------------------------------------------
    drop_last (bool, optional): 如果设置为True：这个是对最后的未完成的batch来说的，比如你的batch_size设置为64，而一个epoch只有100个样本，那么训练的时候后面的36个就被扔掉了，如果为False（默认），那么会继续正常执行，只是最后的batch_size会小一点。
------------------------------------------------------------------------------------
    timeout (numeric, optional): 如果是正数，表明等待从worker进程中收集一个batch等待的时间，若超出设定的时间还没有收集到，停止收集。这个numeric应总是大于等于0。默认为0.            
    worker_init_fn (callable, optional): 每个子进程的初始化函数，加载数据之前运行。

2.3.3 DataLoader中的Sampler类

• SequentialSampler：按照原有的样本顺序进行采样。
• RandomSampler：按照随机u顺序进行采样，可以设置是否重复采样。
• SubsetRandomSampler：按照指定的集合或索引列表进行随机顺序采样。
• WeightedRandomSampler：按照指定的概率进行随机，顺序采样。
• BatchSampler：按照指定的批次索引进行采样。

2.3.4 按照批次封装Fashion-MNIST数据集 ---Fashion-MNISt-CNN.py（第3部分）

### 1.3 按批次封装FashionMNIST数据集
batch_size = 10 #设置批次大小
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size, shuffle=False)

2.3.5 读取批次数据集实战代码 ---Fashion-MNISt-CNN.py（第4部分）

### 1.4 读取批次数据集
## 定义类别名称
classes = ('T-shirt', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle_Boot')
sample = iter(train_loader) # 将数据集转化成迭代器
images,labels = sample.next() # 从迭代器中取得一批数据
print("样本形状",np.shape(images)) # 打印样本形状
# 输出 样本形状 torch.Size([10, 1, 28, 28])
print("样本标签",labels)
# 输出 图片形状 torch.Size([3, 32, 302])
imshow(torchvision.utils.make_grid(images,nrow = batch_size)) # 数据可视化：make_grid()将该批次的图片内容组合为一个图片，用于显示，nrow用于设置生成图片中每行的样本数量
print(','.join('%5s' % classes[labels[j]] for j in range(len(images))))
# 输出 Trouser,Trouser,Dress,  Bag,Shirt,Sandal,Shirt,Dress,  Bag,  Bag

2.4 构建并训练模型

2.4.1 定义模型类MyConNet---Fashion-MNISt-CNN.py（第5部分）

总体结构为两个卷积层结合3个全连接层，如下图：

### 1.5 定义模型类
class myConNet(torch.nn.Module):
    def __init__(self):
        super(myConNet, self).__init__()
        # 定义卷积层
        self.conv1 = torch.nn.Conv2d(in_channels = 1 ,out_channels = 6,kernel_size = 5)
        self.conv2 = torch.nn.Conv2d(in_channels = 6,out_channels = 12,kernel_size = 5)
        # 定义全连接层
        self.fc1 = torch.nn.Linear(in_features = 12*4*4,out_features = 120)
        self.fc2 = torch.nn.Linear(in_features = 120,out_features = 60)
        self.out = torch.nn.Linear(in_features = 60,out_features = 10) # 10是固定的，因为必须要和模型所需要的分类个数一致
    def forward(self,t):
        # 第一层卷积和池化处理
        t = self.conv1(t)
        t = F.relu(t)
        t = F.max_pool2d(t, kernel_size=2, stride=2)
        # 第二层卷积和池化处理
        t = self.conv2(t)
        t = F.relu(t)
        t = F.max_pool2d(t, kernel_size=2, stride=2)
        # 搭建全连接网络，第一层全连接
        t = t.reshape(-1, 12 * 4 * 4)  # 将卷积结果由4维变为2维
        t = self.fc1(t)
        t = F.relu(t)
        # 第二层全连接
        t = self.fc2(t)
        t = F.relu(t)
        # 第三层全连接
        t = self.out(t)
        return t
if __name__ == '__main__':
    network = myConNet() # 生成自定义模块的实例化对象
    #指定设备
    device = torch.device("cuda:0"if torch.cuda.is_available() else "cpu")
    print(device)
    network.to(device)
    print(network) # 打印myConNet网络

输出：

cuda:0
myConNet(
  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
  (conv2): Conv2d(6, 12, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear(in_features=192, out_features=120, bias=True)
  (fc2): Linear(in_features=120, out_features=60, bias=True)
  (out): Linear(in_features=60, out_features=10, bias=True)
)

2.4.2 定义损失的计算方法与优化---Fashion-MNISt-CNN.py（第6部分）

### 1.6 损失函数与优化器
    criterion = torch.nn.CrossEntropyLoss()  #实例化损失函数类
    optimizer = torch.optim.Adam(network.parameters(), lr=.01)

2.4.3 训练模型---Fashion-MNISt-CNN.py（第7部分）

### 1.7 训练模型
    for epoch in range(2):  # 数据集迭代2次
        running_loss = 0.0
        for i, data in enumerate(train_loader, 0):  # 循环取出批次数据 使用enumerate()函数对循环计数，第二个参数为0，表示从0开始
            inputs, labels = data
            inputs, labels = inputs.to(device), labels.to(device)  #
            optimizer.zero_grad()  # 清空之前的梯度
            outputs = network(inputs)
            loss = criterion(outputs, labels)  # 计算损失
            loss.backward()  # 反向传播
            optimizer.step()  # 更新参数

            running_loss += loss.item()
            ### 训练过程的显示
            if i % 1000 == 999:
                print('[%d, %5d] loss: %.3f' %
                      (epoch + 1, i + 1, running_loss / 2000))
                running_loss = 0.0
    print('Finished Training')

输出：

[1,  1000] loss: 0.465
[1,  2000] loss: 0.346
[1,  3000] loss: 0.320
[1,  4000] loss: 0.301
[1,  5000] loss: 0.293
[1,  6000] loss: 0.293
[2,  1000] loss: 0.290
[2,  2000] loss: 0.280
[2,  3000] loss: 0.280
[2,  4000] loss: 0.288
[2,  5000] loss: 0.285
[2,  6000] loss: 0.288
Finished Training

2.4.4 保存模型---Fashion-MNISt-CNN.py（第8部分）

### 1.8 保存模型
    torch.save(network.state_dict(),'./models/CNNFashionMNist.PTH')

2.5 加载模型，并进行预测

2.5.1 加载模型并预测代码实现 ---Fashion-MNISt-CNN.py（第9部分）

### 1.9 加载模型，并且使用该模型进行预测
    network.load_state_dict(torch.load('./models/CNNFashionMNist.PTH')) # 加载模型
    # 使用模型
    dataiter = iter(test_loader) # 获取测试数据
    images, labels = dataiter.next()
    inputs, labels = images.to(device), labels.to(device)

    imshow(torchvision.utils.make_grid(images, nrow=batch_size)) # 取出一批数据进行展示
    print('真实标签: ', ' '.join('%5s' % classes[labels[j]] for j in range(len(images))))
    # 输出：真实标签:  Ankle_Boot Pullover Trouser Trouser Shirt Trouser  Coat Shirt Sandal Sneaker
    outputs = network(inputs) # 调用network对输入样本进行预测，得到测试结果outputs
    _, predicted = torch.max(outputs, 1) # 对于预测结果outputs沿着第1维度找出最大值及其索引值，该索引值即为预测的分类结果

    print('预测结果: ', ' '.join('%5s' % classes[predicted[j]] for j in range(len(images))))
    # 输出：预测结果:  Ankle_Boot Pullover Trouser Trouser Pullover Trouser Shirt Shirt Sandal Sneaker

输出：

图片形状 torch.Size([3, 32, 302])
真实标签: Ankle_Boot Pullover Trouser Trouser Shirt Trouser  Coat Shirt Sandal Sneaker
预测结果: Ankle_Boot Pullover Trouser Trouser Shirt Trouser Pullover Shirt Sandal Sneaker

2.6 评估模型

2.6.1 评估模型的作用

对于模型的能力进行一个精确的评估，需要对每一个分类的精度进行量化计算

2.6.2 评估模型代码实现

### 1.10 评估模型
    # 测试模型
    class_correct = list(0. for i in range(10)) # 定义列表，收集每个类的正确个数
    class_total = list(0. for i in range(10)) # 定义列表，收集每个类的总个数
    with torch.no_grad():
        for data in test_loader: # 遍历测试数据集
            images, labels = data
            inputs, labels = images.to(device), labels.to(device)
            outputs = network(inputs) # 将每个批次的数据输入模型
            _, predicted = torch.max(outputs, 1) # 计算预测结果
            predicted = predicted.to(device)
            c = (predicted == labels).squeeze() # 统计正确的个数
            for i in range(10): # 遍历所有类别
                label = labels[i]
                class_correct[label] = class_correct[label] + c[i].item() # 若该类别正确则+1
                class_total[label] = class_total[label] + 1 # 根据标签中的类别，计算类的总数
    sumacc = 0
    for i in range(10): # 输出每个类的预测结果
        Accuracy = 100 * class_correct[i] / class_total[i]
        print('Accuracy of %5s : %2d %%' % (classes[i], Accuracy))
        sumacc = sumacc + Accuracy
    print('Accuracy of all : %2d %%' % (sumacc / 10.)) # 输出最终的准确率

输出：

Accuracy of T-shirt : 70 %
Accuracy of Trouser : 91 %
Accuracy of Pullover : 77 %
Accuracy of Dress : 81 %
Accuracy of  Coat : 64 %
Accuracy of Sandal : 89 %
Accuracy of Shirt : 50 %
Accuracy of Sneaker : 90 %
Accuracy of   Bag : 94 %
Accuracy of Ankle_Boot : 95 %

Accuracy of all : 80 %

2.6.3 Tip

• 模型的测试结果只是一个模型能力的参考值，它并不能完全反映模型的真实情况。这取决于训练样本和测试样本的分布情况，也取决于摸型本身的拟合质量。
• 在计算机上运行代码时，得到的值可能的值不一样，甚至每次运行时，得到的值也不一样，这是因为每次初始的权重w是随机的。由于初始权重不同，而且每次训练的批次数据也不同，因此最终生成的模型也不会完全相同。但如果核心算法一致，那么会保证最终的结果不会有太大的偏差。

3 识别黑白图中的服装图案总览

import  torchvision
import torchvision.transforms as transforms
import pylab
import torch
from matplotlib import pyplot as plt
import torch.utils.data
import torch.nn.functional as F
import numpy as np
import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"

# 定义显示图像的函数
def imshow(img):
    print("图片形状",np.shape(img))
    img = img/2 +0.5
    npimg = img.numpy()
    plt.axis('off')
    plt.imshow(np.transpose(npimg,(1,2,0)))

### 1.1 自动下载FashionMNIST数据集
data_dir = './fashion_mnist' # 设置存放位置
transform = transforms.Compose([transforms.ToTensor()]) # 可以自动将图片转化为Pytorch支持的形状[通道，高，宽]，同时也将图片的数值归一化
train_dataset = torchvision.datasets.FashionMNIST(data_dir,train=True,transform=transform,download=True)
print("训练集的条数",len(train_dataset))

### 1.2 读取及显示FashionMNIST数据集中的数据
val_dataset = torchvision.datasets.FashionMNIST(root=data_dir,train=False,transform=transform)
print("测试集的条数",len(val_dataset))
##1.2.1 显示数据集中的数据
im = train_dataset[0][0].numpy()
im = im.reshape(-1,28)
pylab.imshow(im)
pylab.show()
print("当前图片的标签为",train_dataset[0][1])

### 1.3 按批次封装FashionMNIST数据集
batch_size = 10 #设置批次大小
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size, shuffle=False)

### 1.4 读取批次数据集
## 定义类别名称
classes = ('T-shirt', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle_Boot')
sample = iter(train_loader) # 将数据集转化成迭代器
images,labels = sample.next() # 从迭代器中取得一批数据
print("样本形状",np.shape(images)) # 打印样本形状
# 输出 样本形状 torch.Size([10, 1, 28, 28])
print("样本标签",labels)
# 输出 图片形状 torch.Size([3, 32, 302])
imshow(torchvision.utils.make_grid(images,nrow = batch_size)) # 数据可视化：make_grid()将该批次的图片内容组合为一个图片，用于显示，nrow用于设置生成图片中每行的样本数量
print(','.join('%5s' % classes[labels[j]] for j in range(len(images))))
# 输出 Trouser,Trouser,Dress,  Bag,Shirt,Sandal,Shirt,Dress,  Bag,  Bag

### 1.5 定义模型类
class myConNet(torch.nn.Module):
    def __init__(self):
        super(myConNet, self).__init__()
        # 定义卷积层
        self.conv1 = torch.nn.Conv2d(in_channels = 1 ,out_channels = 6,kernel_size = 5)
        self.conv2 = torch.nn.Conv2d(in_channels = 6,out_channels = 12,kernel_size = 5)
        # 定义全连接层
        self.fc1 = torch.nn.Linear(in_features = 12*4*4,out_features = 120)
        self.fc2 = torch.nn.Linear(in_features = 120,out_features = 60)
        self.out = torch.nn.Linear(in_features = 60,out_features = 10) # 10是固定的，因为必须要和模型所需要的分类个数一致
    def forward(self,t):
        # 第一层卷积和池化处理
        t = self.conv1(t)
        t = F.relu(t)
        t = F.max_pool2d(t, kernel_size=2, stride=2)
        # 第二层卷积和池化处理
        t = self.conv2(t)
        t = F.relu(t)
        t = F.max_pool2d(t, kernel_size=2, stride=2)
        # 搭建全连接网络，第一层全连接
        t = t.reshape(-1, 12 * 4 * 4)  # 将卷积结果由4维变为2维
        t = self.fc1(t)
        t = F.relu(t)
        # 第二层全连接
        t = self.fc2(t)
        t = F.relu(t)
        # 第三层全连接
        t = self.out(t)
        return t
if __name__ == '__main__':
    network = myConNet() # 生成自定义模块的实例化对象
    #指定设备
    device = torch.device("cuda:0"if torch.cuda.is_available() else "cpu")
    print(device)
    network.to(device)
    print(network) # 打印myConNet网络
### 1.6 损失函数与优化器
    criterion = torch.nn.CrossEntropyLoss()  #实例化损失函数类
    optimizer = torch.optim.Adam(network.parameters(), lr=.01)
### 1.7 训练模型
    for epoch in range(2):  # 数据集迭代2次
        running_loss = 0.0
        for i, data in enumerate(train_loader, 0):  # 循环取出批次数据 使用enumerate()函数对循环计数，第二个参数为0，表示从0开始
            inputs, labels = data
            inputs, labels = inputs.to(device), labels.to(device)  #
            optimizer.zero_grad()  # 清空之前的梯度
            outputs = network(inputs)
            loss = criterion(outputs, labels)  # 计算损失
            loss.backward()  # 反向传播
            optimizer.step()  # 更新参数

            running_loss += loss.item()
            ### 训练过程的显示
            if i % 1000 == 999:
                print('[%d, %5d] loss: %.3f' %
                      (epoch + 1, i + 1, running_loss / 2000))
                running_loss = 0.0
    print('Finished Training')
### 1.8 保存模型
    torch.save(network.state_dict(),'./models/CNNFashionMNist.PTH')

### 1.9 加载模型，并且使用该模型进行预测
    network.load_state_dict(torch.load('./models/CNNFashionMNist.PTH')) # 加载模型
    # 使用模型
    dataiter = iter(test_loader) # 获取测试数据
    images, labels = dataiter.next()
    inputs, labels = images.to(device), labels.to(device)

    imshow(torchvision.utils.make_grid(images, nrow=batch_size)) # 取出一批数据进行展示
    print('真实标签: ', ' '.join('%5s' % classes[labels[j]] for j in range(len(images))))
    # 输出：真实标签:  Ankle_Boot Pullover Trouser Trouser Shirt Trouser  Coat Shirt Sandal Sneaker
    outputs = network(inputs) # 调用network对输入样本进行预测，得到测试结果outputs
    _, predicted = torch.max(outputs, 1) # 对于预测结果outputs沿着第1维度找出最大值及其索引值，该索引值即为预测的分类结果

    print('预测结果: ', ' '.join('%5s' % classes[predicted[j]] for j in range(len(images))))
    # 输出：预测结果:  Ankle_Boot Pullover Trouser Trouser Pullover Trouser Shirt Shirt Sandal Sneaker

### 1.10 评估模型
    # 测试模型
    class_correct = list(0. for i in range(10)) # 定义列表，收集每个类的正确个数
    class_total = list(0. for i in range(10)) # 定义列表，收集每个类的总个数
    with torch.no_grad():
        for data in test_loader: # 遍历测试数据集
            images, labels = data
            inputs, labels = images.to(device), labels.to(device)
            outputs = network(inputs) # 将每个批次的数据输入模型
            _, predicted = torch.max(outputs, 1) # 计算预测结果
            predicted = predicted.to(device)
            c = (predicted == labels).squeeze() # 统计正确的个数
            for i in range(10): # 遍历所有类别
                label = labels[i]
                class_correct[label] = class_correct[label] + c[i].item() # 若该类别正确则+1
                class_total[label] = class_total[label] + 1 # 根据标签中的类别，计算类的总数
    sumacc = 0
    for i in range(10): # 输出每个类的预测结果
        Accuracy = 100 * class_correct[i] / class_total[i]
        print('Accuracy of %5s : %2d %%' % (classes[i], Accuracy))
        sumacc = sumacc + Accuracy
    print('Accuracy of all : %2d %%' % (sumacc / 10.)) # 输出最终的准确率