• Reference resources ：《 Hands-on deep learning 》（Pytorch） edition 3.5 section
• notes ： This article is about jupyter notebook Document conversion , Part of the code may not be copied and run directly ！

• The most commonly used image classification dataset is handwritten numeral recognition dataset MNIST, But most models are MNIST The classification accuracy on the is more than 95%, In order to more intuitively observe the differences between algorithms , This paper introduces a data set with more complex image content Fashion-MNIST, This data set is more difficult than MNIST high , But the size is not big , Only a few dozen M, No, GPU Your computer can stand it
• The data set can take advantage of torchvision Download and process packages , The package contains the following core modules
  1. torchvision.datasets: Provide functions for loading data and common data set interfaces ;
  2. torchvision.models: Contains common model structures （ Including pre training model ）, Such as AlexNet、VGG、ResNet etc. ;
  3. torchvision.transforms: Provide common image transformation methods , For example, cutting 、 Spin, etc ;
  4. torchvision.utils: Provide some other useful methods
• Before the introduction , Import the package first

  import torch
  import torchvision
  import torchvision.transforms as transforms
  import matplotlib.pyplot as plt
  import time
  import numpy as np
  from IPython import display
  

1. Get data set

• adopt torchvision.datasets.FashionMNIST Method to get the dataset

  mnist_train = torchvision.datasets.FashionMNIST(root='./Datasets/FashionMNIST', train=True, transform=transforms.ToTensor())
  mnist_test = torchvision.datasets.FashionMNIST(root='./Datasets/FashionMNIST', train=False, transform=transforms.ToTensor())
  

  Parameter description

  1. root Parameter specifies the data set saving path

  2. train Parameter specifies whether to obtain training set or test set

  3. download If the parameter is set to True, Found in root Automatically download from the Internet when there is no data set under the path , If there is an existing data set, no action will be taken

  4. transform = transforms.ToTensor() Convert all data into Tensor, If you do not convert, you will return PIL picture

     transforms.ToTensor() take “ Size is $H\times W\times C$ And the data is located in $[0,255]$ Of PIL picture ” perhaps “ The data type is np.uint8 Of NumPy Array ” Convert to “ Size is $C\times H\times W$ And the data type is torch.float32 And located in [0.0, 1.0] Of Tensor”

     Be careful transforms.ToTensor() The default input of some functions about pictures is uint8 type , If not, you may get unwanted results , therefore If you use $[0,255]$ The pixel value of represents the picture data , Set its type to uint8, To avoid unnecessary bug

• It's loaded here mnist_train and mnist_test All are torch.utils.data.Dataset Subclasses of , Some common methods are as follows

  print(type(mnist_train))
  print(len(mnist_train), len(mnist_test)) #  use  len()  Gets the size of the dataset 
  
  feature, label = mnist_train[0]          #  Access any sample by subscript 
  print(feature.shape, label)              # [Channel , Height , Width] label, Note that because the data set is grayscale , The number of channels is  1
  
  ''' torchvision.datasets.mnist.FashionMNIST 60000 10000 torch.Size([1, 28, 28]) 9 '''
  

• Fashion-MNIST It includes 10 Categories , Respectively

  1. t-shirt（T T-shirt ）
  2. trouser（ The trousers ）
  3. pullover（ Pullover ）
  4. dress（ dress ）
  5. coat（ coat ）
  6. sandal（ Sandals ）
  7. shirt（ shirt ）
  8. sneaker（ Sports shoes ）
  9. bag（ package ）
  10. ankle boot（ Boots ）

  Use the following function to convert the list of numeric labels into the corresponding list of text labels

  def get_fashion_mnist_labels(labels):
      text_labels = ['t-shirt', 'trouser', 'pullover', 'dress', 'coat',
                     'sandal', 'shirt', 'sneaker', 'bag', 'ankle boot']
      return [text_labels[int(i)] for i in labels]
  

• Use the following function to draw multiple images and corresponding labels in one line

  def show_fashion_mnist(images, labels):
      display.set_matplotlib_formats('svg')  # Use svg format to display plot in jupyter
      
      _, figs = plt.subplots(1, len(images), figsize=(12, 12))
      for f, img, lbl in zip(figs, images, labels):
          f.imshow(img.view((28, 28)).numpy())
          f.set_title(lbl)
          f.axes.get_xaxis().set_visible(False)
          f.axes.get_yaxis().set_visible(False)
      plt.show()
  

• Random display 10 Samples

  X, y = [], []
  for i in np.random.randint(0,60000,size = 10).tolist():
      X.append(mnist_train[i][0])
      y.append(mnist_train[i][1])
  show_fashion_mnist(X, get_fashion_mnist_labels(y))
  

  Here I come across an error report , Please refer to ‘OMP: Hint This means that multiple copies of the OpenMP runtime have been linked into the program’, I deleted... In the virtual environment libiomp5md.dll Solve this problem

2. Read small batch

• In practice , Data reading is often the performance bottleneck of training ,torch.utils Module provided DataLoader Method allows us to easily use multiple processes to speed up data reading

• mnist_train yes torch.utils.data.Dataset Subclasses of , So we can pass it into torch.utils.data.DataLoader To create a program that reads a small batch of data samples DataLoader example , When creating a

  1. Through parameters num_workers To specify the number of processes reading data
  2. adopt shuffle Parameter specifies whether to disrupt the reading

  batch_size = 256
  if sys.platform.startswith('win'): #  Judge the operating system as  windows
      num_workers = 4 #  Use  4  Two processes read at the same time 
  else:
      num_workers = 0 # 0 It means that there is no extra process to speed up reading data 
  
  train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=num_workers)
  test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=num_workers)
  

• See how long it takes to read the data once

  start = time.time()
  for X, y in train_iter:
      continue
  print('%.2f sec' % (time.time() - start))
  

  After testing , My laptop takes time without multi process acceleration 5.88s, Reduce to... After use 3.18s