PyTorch教程-4.2. 图像分类数据集

广泛用于图像分类的数据集之一是手写数字的MNIST 数据集 （LeCun等人，1998 年） 。在 1990 年代发布时，它对大多数机器学习算法提出了巨大挑战，其中包含 60,000 张图像 28×28像素分辨率（加上 10,000 张图像的测试数据集）。客观地说，在 1995 年，配备高达 64MB RAM 和惊人的 5 MFLOPs 的 Sun SPARCStation 5 被认为是 AT&T 贝尔实验室最先进的机器学习设备。实现数字识别的高精度是一个1990 年代 USPS 自动分拣信件的关键组件。深度网络，如 LeNet-5 （LeCun等人，1995 年）、具有不变性的支持向量机 （Schölkopf等人，1996 年）和切线距离分类器 （Simard等人，1998 年）都允许达到 1% 以下的错误率。

十多年来，MNIST 一直是比较机器学习算法的参考点。虽然它作为基准数据集运行良好，但即使是按照当今标准的简单模型也能达到 95% 以上的分类准确率，这使得它不适合区分强模型和弱模型。更重要的是，数据集允许非常高的准确性，这在许多分类问题中通常是看不到的。这种算法的发展偏向于可以利用干净数据集的特定算法系列，例如活动集方法和边界搜索活动集算法。今天，MNIST 更像是一种健全性检查，而不是基准。ImageNet ( Deng et al. , 2009 )提出了一个更相关的挑战。不幸的是，对于本书中的许多示例和插图来说，ImageNet 太大了，因为训练这些示例需要很长时间才能使示例具有交互性。作为替代，我们将在接下来的部分中重点讨论定性相似但规模小得多的 Fashion-MNIST 数据集（Xiao等人，2017 年），该数据集于 2017 年发布。它包含 10 类服装的图像 28×28像素分辨率。

%matplotlib inline
import time
import torch
import torchvision
from torchvision import transforms
from d2l import torch as d2l

d2l.use_svg_display()

%matplotlib inline
import time
from mxnet import gluon, npx
from mxnet.gluon.data.vision import transforms
from d2l import mxnet as d2l

npx.set_np()

d2l.use_svg_display()

%matplotlib inline
import time
import jax
import numpy as np
import tensorflow as tf
import tensorflow_datasets as tfds
from jax import numpy as jnp
from d2l import jax as d2l

d2l.use_svg_display()

No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)

%matplotlib inline
import time
import tensorflow as tf
from d2l import tensorflow as d2l

d2l.use_svg_display()

4.2.1. 加载数据集

由于它是一个经常使用的数据集，所有主要框架都提供了它的预处理版本。我们可以使用内置的框架实用程序将 Fashion-MNIST 数据集下载并读取到内存中。

class FashionMNIST(d2l.DataModule): #@save
  """The Fashion-MNIST dataset."""
  def __init__(self, batch_size=64, resize=(28, 28)):
    super().__init__()
    self.save_hyperparameters()
    trans = transforms.Compose([transforms.Resize(resize),
                  transforms.ToTensor()])
    self.train = torchvision.datasets.FashionMNIST(
      root=self.root, train=True, transform=trans, download=True)
    self.val = torchvision.datasets.FashionMNIST(
      root=self.root, train=False, transform=trans, download=True)

class FashionMNIST(d2l.DataModule): #@save
  """The Fashion-MNIST dataset."""
  def __init__(self, batch_size=64, resize=(28, 28)):
    super().__init__()
    self.save_hyperparameters()
    trans = transforms.Compose([transforms.Resize(resize),
                  transforms.ToTensor()])
    self.train = gluon.data.vision.FashionMNIST(
      train=True).transform_first(trans)
    self.val = gluon.data.vision.FashionMNIST(
      train=False).transform_first(trans)

class FashionMNIST(d2l.DataModule): #@save
  """The Fashion-MNIST dataset."""
  def __init__(self, batch_size=64, resize=(28, 28)):
    super().__init__()
    self.save_hyperparameters()
    self.train, self.val = tf.keras.datasets.fashion_mnist.load_data()

class FashionMNIST(d2l.DataModule): #@save
  """The Fashion-MNIST dataset."""
  def __init__(self, batch_size=64, resize=(28, 28)):
    super().__init__()
    self.save_hyperparameters()
    self.train, self.val = tf.keras.datasets.fashion_mnist.load_data()

Fashion-MNIST 包含来自 10 个类别的图像，每个类别在训练数据集中由 6,000 个图像表示，在测试数据集中由 1,000 个图像表示。测试 数据集用于评估模型性能（不得用于训练）。因此，训练集和测试集分别包含 60,000 和 10,000 张图像。

data = FashionMNIST(resize=(32, 32))
len(data.train), len(data.val)

(60000, 10000)

data = FashionMNIST(resize=(32, 32))
len(data.train), len(data.val)

(60000, 10000)

data = FashionMNIST(resize=(32, 32))
len(data.train[0]), len(data.val[0])

(60000, 10000)

data = FashionMNIST(resize=(32, 32))
len(data.train[0]), len(data.val[0])

(60000, 10000)

图像是灰度和放大到32×32分辨率以上的像素。这类似于由（二进制）黑白图像组成的原始 MNIST 数据集。但请注意，大多数具有 3 个通道（红色、绿色、蓝色）的现代图像数据和超过 100 个通道的高光谱图像（HyMap 传感器有 126 个通道）。按照惯例，我们将图像存储为 c×h×w张量，其中c是颜色通道数，h是高度和w是宽度。

data.train[0][0].shape

torch.Size([1, 32, 32])

data.train[0][0].shape

(1, 32, 32)

data.train[0][0].shape

(28, 28)

data.train[0][0].shape

(28, 28)

Fashion-MNIST 的类别具有人类可理解的名称。以下便捷方法在数字标签及其名称之间进行转换。

@d2l.add_to_class(FashionMNIST) #@save
def text_labels(self, indices):
  """Return text labels."""
  labels = ['t-shirt', 'trouser', 'pullover', 'dress', 'coat',
       'sandal', 'shirt', 'sneaker', 'bag', 'ankle boot']
  return [labels[int(i)] for i in indices]

4.2.2. 读取一个小批量

为了让我们在读取训练集和测试集时更轻松，我们使用内置的数据迭代器而不是从头开始创建一个。回想一下，在每次迭代中，数据迭代器读取一个大小为 的小批量数据batch_size。我们还随机打乱训练数据迭代器的示例。

@d2l.add_to_class(FashionMNIST) #@save
def get_dataloader(self, train):
  data = self.train if train else self.val
  return torch.utils.data.DataLoader(data, self.batch_size, shuffle=train,
                    num_workers=self.num_workers)

@d2l.add_to_class(FashionMNIST) #@save
def get_dataloader(self, train):
  data = self.train if train else self.val
  return gluon.data.DataLoader(data, self.batch_size, shuffle=train,
                 num_workers=self.num_workers)

@d2l.add_to_class(FashionMNIST) #@save
def get_dataloader(self, train):
  data = self.train if train else self.val
  process = lambda X, y: (tf.expand_dims(X, axis=3) / 255,
              tf.cast(y, dtype='int32'))
  resize_fn = lambda X, y: (tf.image.resize_with_pad(X, *self.resize), y)
  shuffle_buf = len(data[0]) if train else 1
  return tfds.as_numpy(
    tf.data.Dataset.from_tensor_slices(process(*data)).batch(
      self.batch_size).map(resize_fn).shuffle(shuffle_buf))

@d2l.add_to_class(FashionMNIST) #@save
def get_dataloader(self, train):
  data = self.train if train else self.val
  process = lambda X, y: (tf.expand_dims(X, axis=3) / 255,
              tf.cast(y, dtype='int32'))
  resize_fn = lambda X, y: (tf.image.resize_with_pad(X, *self.resize), y)
  shuffle_buf = len(data[0]) if train else 1
  return tf.data.Dataset.from_tensor_slices(process(*data)).batch(
    self.batch_size).map(resize_fn).shuffle(shuffle_buf)

为了了解这是如何工作的，让我们通过调用该 train_dataloader方法来加载一小批图像。它包含 64 张图像。

X, y = next(iter(data.train_dataloader()))
print(X.shape, X.dtype, y.shape, y.dtype)

torch.Size([64, 1, 32, 32]) torch.float32 torch.Size([64]) torch.int64

X, y = next(iter(data.train_dataloader()))
print(X.shape, X.dtype, y.shape, y.dtype)

(64, 1, 32, 32) float32 (64,) int32

X, y = next(iter(data.train_dataloader()))
print(X.shape, X.dtype, y.shape, y.dtype)

WARNING:tensorflow:From /home/d2l-worker/miniconda3/envs/d2l-en-release-1/lib/python3.9/site-packages/tensorflow/python/autograph/pyct/static_analysis/liveness.py:83: Analyzer.lamba_check (from tensorflow.python.autograph.pyct.static_analysis.liveness) is deprecated and will be removed after 2023-09-23.
Instructions for updating:
Lambda fuctions will be no more assumed to be used in the statement where they are used, or at least in the same block. https://github.com/tensorflow/tensorflow/issues/56089
(64, 32, 32, 1) float32 (64,) int32

X, y = next(iter(data.train_dataloader()))
print(X.shape, X.dtype, y.shape, y.dtype)

WARNING:tensorflow:From /home/d2l-worker/miniconda3/envs/d2l-en-release-1/lib/python3.9/site-packages/tensorflow/python/autograph/pyct/static_analysis/liveness.py:83: Analyzer.lamba_check (from tensorflow.python.autograph.pyct.static_analysis.liveness) is deprecated and will be removed after 2023-09-23.
Instructions for updating:
Lambda fuctions will be no more assumed to be used in the statement where they are used, or at least in the same block. https://github.com/tensorflow/tensorflow/issues/56089
(64, 32, 32, 1)  (64,) 

让我们看看读取图像所花费的时间。尽管它是一个内置的加载程序，但速度并不快。尽管如此，这已经足够了，因为使用深度网络处理图像需要更长的时间。因此，训练网络不受 IO 约束就足够了。

tic = time.time()
for X, y in data.train_dataloader():
  continue
f'{time.time() - tic:.2f} sec'

'5.06 sec'

tic = time.time()
for X, y in data.train_dataloader():
  continue
f'{time.time() - tic:.2f} sec'

'4.12 sec'

tic = time.time()
for X, y in data.train_dataloader():
  continue
f'{time.time() - tic:.2f} sec'

'0.96 sec'

tic = time.time()
for X, y in data.train_dataloader():
  continue
f'{time.time() - tic:.2f} sec'

'0.95 sec'

4.2.3. 可视化

我们将经常使用 Fashion-MNIST 数据集。一个便利的功能show_images可以用来可视化图像和相关的标签。其实施细节推迟到附录。

def show_images(imgs, num_rows, num_cols, titles=None, scale=1.5): #@save
  """Plot a list of images."""
  raise NotImplementedError

让我们好好利用它。通常，可视化和检查您正在训练的数据是个好主意。人类非常善于发现不寻常的方面，因此，可视化可以作为一种额外的保护措施，防止实验设计中的错误和错误。以下是训练数据集中前几个示例的图像及其相应标签（文本）。

@d2l.add_to_class(FashionMNIST) #@save
def visualize(self, batch, nrows=1, ncols=8, labels=[]):
  X, y = batch
  if not labels:
    labels = self.text_labels(y)
  d2l.show_images(X.squeeze(1), nrows, ncols, titles=labels)
batch = next(iter(data.val_dataloader()))
data.visualize(batch)

@d2l.add_to_class(FashionMNIST) #@save
def visualize(self, batch, nrows=1, ncols=8, labels=[]):
  X, y = batch
  if not labels:
    labels = self.text_labels(y)
  d2l.show_images(X.squeeze(1), nrows, ncols, titles=labels)
batch = next(iter(data.val_dataloader()))
data.visualize(batch)

@d2l.add_to_class(FashionMNIST) #@save
def visualize(self, batch, nrows=1, ncols=8, labels=[]):
  X, y = batch
  if not labels:
    labels = self.text_labels(y)
  d2l.show_images(jnp.squeeze(X), nrows, ncols, titles=labels)

batch = next(iter(data.val_dataloader()))
data.visualize(batch)

@d2l.add_to_class(FashionMNIST) #@save
def visualize(self, batch, nrows=1, ncols=8, labels=[]):
  X, y = batch
  if not labels:
    labels = self.text_labels(y)
  d2l.show_images(tf.squeeze(X), nrows, ncols, titles=labels)
batch = next(iter(data.val_dataloader()))
data.visualize(batch)

我们现在准备好在接下来的部分中使用 Fashion-MNIST 数据集。

4.2.4. 概括

我们现在有一个稍微更真实的数据集用于分类。Fashion-MNIST 是一个服装分类数据集，由代表 10 个类别的图像组成。我们将在后续部分和章节中使用该数据集来评估各种网络设计，从简单的线性模型到高级残差网络。正如我们通常对图像所做的那样，我们将它们读取为形状的张量（批量大小、通道数、高度、宽度）。目前，我们只有一个通道，因为图像是灰度的（上面的可视化使用假调色板来提高可见性）。

最后，数据迭代器是实现高效性能的关键组件。例如，我们可能会使用 GPU 进行高效的图像解压缩、视频转码或其他预处理。只要有可能，您就应该依靠利用高性能计算的良好实现的数据迭代器来避免减慢您的训练循环。

4.2.5. 练习

减少batch_size（例如，减少到 1）会影响阅读性能吗？

数据迭代器的性能很重要。您认为当前的实施是否足够快？探索改进它的各种选项。使用系统分析器找出瓶颈所在。

查看框架的在线 API 文档。还有哪些其他数据集可用？