点击左上方蓝字关注咱们php
课程简介：git
“跟着雨哥学AI”是百度飞桨开源框架近期针对高层API推出的系列课。本课程由多位资深飞桨工程师精心打造，不只提供了从数据处理、到模型组网、模型训练、模型评估和推理部署全流程讲解；还提供了丰富的趣味案例，旨在帮助开发者更全面清晰地掌握百度飞桨框架的用法，并可以触类旁通、灵活使用飞桨框架进行深度学习实践。github
本章分别对内置数据集、数据集定义、数据加强、数据采样以及数据加载这几个功能点进行详细的讲解。web
在上个月发布的 飞桨开源框架2.0，带你走进全新高层API，十行代码搞定深度学习模型开发 中，已经给你们简单介绍了飞桨高层API的定义、特色、总体框架以及具体API。这节课咱们将介绍飞桨高层API的第一个模块--数据管道。俗话说『九层之台,起于垒土』，数据管道是模型训练过程当中最重要的前置工做。在飞桨的整个框架中，数据管道包含了五个功能点：内置数据集、数据集定义、数据加强、数据采样以及数据加载。接下来我将分别对这五个功能点进行详细的讲解。好的，那下面就让咱们进入今天的内容吧。缓存
下载安装命令 ## CPU版本安装命令 pip install -f https://paddlepaddle.org.cn/pip/oschina/cpu paddlepaddle ## GPU版本安装命令 pip install -f https://paddlepaddle.org.cn/pip/oschina/gpu paddlepaddle-gpu
什么是数据管道？微信
在完成深度学习领域的任务时，咱们最早面临的挑战就是数据处理，即须要将数据处理成模型可以"看懂"的语言，从而进行模型的训练。好比，在图像分类任务中，咱们须要按格式处理图像数据与其对应的标签，而后才能将其输入到模型中，开始训练。在这个过程当中，咱们须要将图片数据从jpg、png或其它格式转换为numpy array的格式，而后对其进行一些加工，如重置大小、旋转变换、改变亮度等等，从而进行数据加强。因此，数据的预处理和加载方式很大程度上决定了模型最终的性能水平。传统框架经常包含着复杂的数据加载模式，多重的预处理操做经常会劝退许多人。而飞桨框架为了简化数据管道的流程，对数据管道相关的场景进行了高级封装，经过很是少许代码，便可实现数据的处理，更愉快的进行深度学习模型研发。网络
数据管道详解框架
在数据管道总共包含5个模块，分别是飞桨框架内置数据集、自定义数据集、数据加强、数据采样以及数据加载5个部分。关系图以下: dom
下面，让我来一一介绍这些内容。分布式
2.1 内置数据集
内置数据集介绍：
为了节约你们处理数据时所耗费的时间和精力，飞桨框架将一些咱们经常使用到的数据集做为领域API对用户进行开放，用户经过调用paddle.vision.datasets和paddle.text.datasets便可直接使用领域API，这两个API内置包含了许多CV和NLP领域相关的常见数据集，具体以下：
import paddle
import numpy as np
paddle.__version__
'2.0.0-rc1'
print('视觉相关数据集：', paddle.vision.datasets.__all__)
print('天然语言相关数据集：', paddle.text.datasets.__all__)
视觉相关数据集： ['DatasetFolder', 'ImageFolder', 'MNIST', 'FashionMNIST', 'Flowers', 'Cifar10', 'Cifar100', 'VOC2012']
天然语言相关数据集： ['Conll05st', 'Imdb', 'Imikolov', 'Movielens', 'UCIHousing', 'WMT14', 'WMT16']
内置数据集使用：
为了方便你们理解，这里我演示一下如何使用内置的手写数字识别的数据集，其余数据集的使用方式也相似，你们能够动手试一下哦。具体能够见下面的代码，注意，咱们经过使用mode参数用来标识训练集与测试集。调用数据集接口后，相应的API会自动下载数据集到本机缓存目录~/.cache/paddle/dataset。
import paddle.vision as vision
print("训练集下载中...")
# 训练数据集
train_dataset = vision.datasets.MNIST(mode='train')
print("训练集下载完成！")
print("测试集下载中...")
# 验证数据集
test_dataset = vision.datasets.MNIST(mode='test')
print("测试集下载完成！")
训练集下载中...
Cache file /home/aistudio/.cache/paddle/dataset/mnist/train-images-idx3-ubyte.gz not found, downloading https://dataset.bj.bcebos.com/mnist/train-images-idx3-ubyte.gz
Begin to download
Download finished
Cache file /home/aistudio/.cache/paddle/dataset/mnist/train-labels-idx1-ubyte.gz not found, downloading https://dataset.bj.bcebos.com/mnist/train-labels-idx1-ubyte.gz
Begin to download
........
Download finished
训练集下载完成！
测试集下载中...
Cache file /home/aistudio/.cache/paddle/dataset/mnist/t10k-images-idx3-ubyte.gz not found, downloading https://dataset.bj.bcebos.com/mnist/t10k-images-idx3-ubyte.gz
Begin to download
Download finished
Cache file /home/aistudio/.cache/paddle/dataset/mnist/t10k-labels-idx1-ubyte.gz not found, downloading https://dataset.bj.bcebos.com/mnist/t10k-labels-idx1-ubyte.gz
Begin to download
..
Download finished
测试集下载完成！
内置数据集可视化：
经过上面的步骤，咱们就定义好了训练集与测试集，接下来，让咱们来看一下数据集的内容吧。
import numpy as np
import matplotlib.pyplot as plt
train_data_0, train_label_0 = np.array(train_dataset[0][0]), train_dataset[0][1]
train_data_0 = train_data_0.reshape([28, 28])
plt.figure(figsize=(2, 2))
plt.imshow(train_data_0, cmap=plt.cm.binary)
print('train_data0 label is: ' + str(train_label_0))
train_data0 label is: [5]
从上例中能够看出，train_dataset 是一个 map-style 式的数据集，咱们能够经过下标直接获取单个样本的图像数据与标签，从而进行可视化。
Note: map-style 是指能够经过下标的方式来获取指定样本，除此以外，还有 iterable-style 式的数据集，只能经过迭代的方式来获取样本，具体说明能够见下一节。
2.2 数据集定义
有同窗提出虽然飞桨框架提供了许多领域数据集供咱们使用，可是在实际的使用场景中，若是咱们须要使用已有的数据来训练模型怎么办呢？别慌，飞桨也贴心地准备了 map-style 的 paddle.io.Dataset 基类 和 iterable-style 的 paddle.io.IterableDataset 基类 ，来完成数据集定义。此外，针对一些特殊的场景，飞桨框架也提供了 paddle.io.TensorDataset 基类，能够直接处理 Tensor 数据为 dataset，一键完成数据集的定义。
让咱们来看一下它们的使用方式吧~
paddle.io.Dataset的使用方式：
这个是咱们最推荐使用的API，来完成数据的定义。使用 paddle.io.Dataset，最后会返回一个 map-style 的 Dataset 类。能够用于后续的数据加强、数据加载等。而使用 paddle.io.Dataset 也很是简单，只须要按格式完成如下四步便可。
class MyDataset(paddle.io.Dataset):
"""
步骤一：继承paddle.io.Dataset类
"""
def __init__(self, mode='train'):
"""
步骤二：实现构造函数，定义数据读取方式，划分训练和测试数据集
"""
super(MyDataset, self).__init__()
if mode == 'train':
self.data = [
['train_image_0.jpg', '1'],
['train_image_1.jpg', '2'],
['train_image_2.jpg', '3'],
['train_image_3.jpg', '4'],
]
else:
self.data = [
['test_image_0.jpg', '1'],
['test_image_1.jpg', '2'],
['test_image_2.jpg', '3'],
['test_image_3.jpg', '4'],
]
def _load_img(self, image_path):
# 实际使用时使用Pillow相关库进行图片读取便可，这里咱们对数据先作个模拟
image = np.random.randn(32, 32, 3)
return image
def __getitem__(self, index):
"""
步骤三：实现__getitem__方法，定义指定index时如何获取数据，并返回单条数据（训练数据，对应的标签）
"""
image = self._load_img(self.data[index][0])
label = self.data[index][1]
return image, np.array(label, dtype='int64')
def __len__(self):
"""
步骤四：实现__len__方法，返回数据集总数目
"""
return len(self.data)
# 测试定义的数据集
train_dataset = MyDataset(mode='train')
test_dataset = MyDataset(mode='test')
print('=============train dataset=============')
for image, label in train_dataset:
print('image shape: {}, label: {}'.format(image.shape, label))
print('=============evaluation dataset=============')
for image, label in test_dataset:
print('image shape: {}, label: {}'.format(image.shape, label))
=============train dataset=============
image shape: (32, 32, 3), label: 1
image shape: (32, 32, 3), label: 2
image shape: (32, 32, 3), label: 3
image shape: (32, 32, 3), label: 4
=============evaluation dataset=============
image shape: (32, 32, 3), label: 1
image shape: (32, 32, 3), label: 2
image shape: (32, 32, 3), label: 3
image shape: (32, 32, 3), label: 4
paddle.io.Dataset实战：
看了上面的例子，你是否想本身动手写一个Dataset呢？就让我用实战来演示一下：
# 下载训练集
!wget http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz
# 下载训练集标签
!wget http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz
# 下载测试集
!wget http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz
# 下载测试集标签
!wget http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz
import os
import gzip
class FashionMNISTDataset(paddle.io.Dataset):
"""
步骤一：继承paddle.io.Dataset类
"""
def __init__(self, path='./', mode='train'):
"""
步骤二：实现构造函数，定义数据读取方式，划分训练和测试数据集
"""
super(FashionMNISTDataset, self).__init__()
images_data_path = os.path.join(path,
'%s-images-idx3-ubyte.gz'
% mode)
labels_data_path = os.path.join(path,
'%s-labels-idx1-ubyte.gz'
% mode)
with gzip.open(labels_data_path, 'rb') as lbpath:
self.labels = np.frombuffer(lbpath.read(), dtype=np.uint8,
offset=8)
with gzip.open(images_data_path, 'rb') as imgpath:
self.images = np.frombuffer(imgpath.read(), dtype=np.uint8,
offset=16).reshape(len(self.labels), 784)
def __getitem__(self, index):
"""
步骤三：实现__getitem__方法，定义指定index时如何获取数据，并返回单条数据（训练数据，对应的标签）
"""
image = self.images[index]
label = self.labels[index]
return image, label
def __len__(self):
"""
步骤四：实现__len__方法，返回数据集总数目
"""
return len(self.images)
# 测试定义的数据集
fashion_mnist_train_dataset = FashionMNISTDataset(mode='train')
fashion_mnist_test_dataset = FashionMNISTDataset(mode='t10k')
# 可视化训练集
fashion_mnist_train_data_0 = np.array(fashion_mnist_train_dataset[0][0])
fashion_mnist_train_label_0 = fashion_mnist_train_dataset[0][1]
fashion_mnist_train_data_0 = fashion_mnist_train_data_0.reshape([28,28])
plt.figure(figsize=(2,2))
plt.imshow(fashion_mnist_train_data_0, cmap=plt.cm.binary)
print('train_data0 label is: ' + str(fashion_mnist_train_label_0))
train_data0 label is: 9
paddle.io.IterableDataset 的使用方式
使用 paddle.io.IterableDataset，最后会返回一个 iterable-style 的 Dataset 类。而使用 paddle.io.IterableDataset 也很是简单，只须要按格式完成如下两步便可。
import math import paddle import numpy as np from paddle.io import IterableDataset, DataLoader, get_worker_info class SplitedIterableDataset(IterableDataset): """ 步骤一：继承paddle.io.Dataset类 """ def __init__(self, start, end): self.start = start self.end = end def __iter__(self): """ 步骤二：实现__iter__方法， """ worker_info = get_worker_info() if worker_info is None: iter_start = self.start iter_end = self.end else: per_worker = int( math.ceil((self.end - self.start) / float( worker_info.num_workers))) worker_id = worker_info.id iter_start = self.start + worker_id * per_worker iter_end = min(iter_start + per_worker, self.end) for i in range(iter_start, iter_end): yield np.array([i]) dataset = SplitedIterableDataset(start=2, end=9) dataloader = DataLoader(dataset, num_workers=2, batch_size=1, drop_last=True) for data in dataloader: print(data[0].numpy()) [[2]] [[6]] [[3]] [[7]] [[4]] [[8]] [[5]]
paddle.io.TensorDataset的使用方式
上面介绍了两种数据集的定义方式，分别经过继承paddle.io.Dataset与paddle.io.IterableDataset就能够实现。不过，还有一种场景，若是咱们已经有了Tensor类型的数据，想要快速、直接的建立Dataset，而不去实现paddle.io.Dataset的各类方法，能够么？这时，咱们就可使用 paddle.io.TensorDataset，直接将 Tensor 类型的 数据与标签传入 TensorDataset 类便可。
快来看看这是怎么实现的吧：
from paddle.io import TensorDataset
input_np = np.random.random([2, 3, 4]).astype('float32')
input_tensor = paddle.to_tensor(input_np)
label_np = np.random.random([2, 1]).astype('int32')
label_tensor = paddle.to_tensor(label_np)
dataset = TensorDataset([input_tensor, label_tensor])
for i in range(len(dataset)):
input, label = dataset[i]
print(input, label)
Tensor(shape=[3, 4], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
[[0.91451722, 0.94088864, 0.52030772, 0.80783033],
[0.74379814, 0.18669823, 0.41893899, 0.89299613],
[0.67413408, 0.82801068, 0.02079745, 0.95862854]]) Tensor(shape=[1], dtype=int32, place=CUDAPlace(0), stop_gradient=True,
[0])
Tensor(shape=[3, 4], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
[[0.30733261, 0.82390237, 0.99652219, 0.93594497],
[0.62558615, 0.83836132, 0.34213212, 0.72257715],
[0.80075997, 0.38913822, 0.25709155, 0.00520579]]) Tensor(shape=[1], dtype=int32, place=CUDAPlace(0), stop_gradient=True,
[0])
能够看出，咱们将Tensor类型的 input 与 label 直接传入TensorDataset中，就能够完成 Dataset 的定义，彻底不须要实现上述自定义的那四个步骤。在咱们的实际使用中，若是想要简单的作个测试，彻底能够直接使用TensorDataset来建立数据集。那么，使用 TensorDataset 有什么要求呢？只有一个要求，就是传入的 Tensor，它们的第一维维度要相同，从上例中能够看出， input 与 label 的第一维都是2，表明数据集的大小。
2.3 数据加强
在训练模型的过程当中，咱们偶尔会遇到过拟合的问题。这时，最好的作法是增长训练集的数量，以此提高模型的泛化能力。可是，因为获取数据集的成本比较高，因此一般咱们都会采用加强训练数据的方式对数据进行处理，从而获得更多不一样的数据集。
在计算机视觉领域中，常见的数据加强的方式包括随机裁剪、旋转变换、改变图像亮度、对比度等等。能够看出，这些方法都是对图像的常见处理方式，因此，飞桨框架直接提供了这类的API，定义在paddle.vision.transofrms下，包含了计算机视觉中对图像的各类经常使用的处理，具体以下：
print("飞桨支持的数据预处理方式：" + str(paddle.vision.transforms.__all__))
飞桨支持的数据预处理方式：['BaseTransform', 'Compose', 'Resize', 'RandomResizedCrop', 'CenterCrop', 'RandomHorizontalFlip', 'RandomVerticalFlip', 'Transpose', 'Normalize', 'BrightnessTransform', 'SaturationTransform', 'ContrastTransform', 'HueTransform', 'ColorJitter', 'RandomCrop', 'Pad', 'RandomRotation', 'Grayscale', 'ToTensor', 'to_tensor', 'hflip', 'vflip', 'resize', 'pad', 'rotate', 'to_grayscale', 'crop', 'center_crop', 'adjust_brightness', 'adjust_contrast', 'adjust_hue', 'normalize']
那么该怎么使用呢？咱们这里分两种场景来介绍，一种是飞桨内置数据集使用数据加强，另外一种是自定义数据集使用数据加强。
内置数据集使用数据加强:
内置数据集使用数据加强的方式很是简单，咱们能够直接定义一个数据预处理的方式，而后将其做为参数，在加载内置数据集的时候，传给 transform 参数便可；而若是咱们想对一个数据集进行多个数据预处理的方式，能够先定义一个 transform 的容器 Compose，将咱们须要的数据预处理方法以 list 的格式传入 Compose，而后在加载内置数据集的时候，传给 transform 参数便可。
具体能够看下面的例子：
import paddle.vision.transforms as T
# 方式一 只对图像进行调整亮度的操做
transform = T.BrightnessTransform(0.4)
# 经过transform参数传递定义好的数据增方法便可完成对自带数据集的数据加强
train_dataset_without_transform = vision.datasets.Cifar10(mode='train')
train_dataset_with_transform = vision.datasets.Cifar10(mode='train', transform=transform)
index = 10
print("未调整亮度的图像")
train_dataset_without_data_0 = np.array(train_dataset_without_transform[index][0])
train_dataset_without_data_0 = train_dataset_without_data_0.astype('float32') / 255.
plt.imshow(train_dataset_without_data_0)
未调整亮度的图像
<matplotlib.image.AxesImage at 0x7fb13e129090>
print("调整亮度的图像")
train_dataset_with_data_0 = np.array(train_dataset_with_transform[index][0])
train_dataset_with_data_0 = train_dataset_with_data_0.astype('float32') / 255.
plt.imshow(train_dataset_with_data_0)
调整亮度的图像
<matplotlib.image.AxesImage at 0x7fb19b1b5f90>
import paddle.vision.transforms as T
# 方式二 对图像进行多种操做
transform = T.Compose([T.BrightnessTransform(0.4), T.ContrastTransform(0.4)])
# 经过transform参数传递定义好的数据增方法便可完成对自带数据集的数据加强
train_dataset_without_compose = vision.datasets.Cifar10(mode='train')
train_dataset_with_compose = vision.datasets.Cifar10(mode='train', transform=transform)
index = 10
print("未调整的图像")
train_dataset_without_compose_data_0 = np.array(train_dataset_without_compose[index][0])
train_dataset_without_compose_data_0 = train_dataset_without_compose_data_0.astype('float32') / 255.
plt.imshow(train_dataset_without_compose_data_0)
未调整的图像
<matplotlib.image.AxesImage at 0x7fb13065fb90>
print("多种调整后的图像")
train_dataset_with_compose_data_0 = np.array(train_dataset_with_compose[index][0])
train_dataset_with_compose_data_0 = train_dataset_with_compose_data_0.astype('float32') / 255.
plt.imshow(train_dataset_with_compose_data_0)
多种调整后的图像
<matplotlib.image.AxesImage at 0x7fb1b818c610>
自定义数据集使用数据加强:
针对自定义数据集使用数据加强的方式， 比较直观的方式是在在数据集的构造函数中进行数据加强方法的定义，以后对__getitem__中返回的数据进行应用。咱们以上述中FashionMNIST数据集为例来讲明，具体以下：
class FashionMNISTDataset(paddle.io.Dataset): """ 步骤一：继承paddle.io.Dataset类 """ def __init__(self, path='./', mode='train', transform='None'): """ 步骤二：实现构造函数，定义数据读取方式，划分训练和测试数据集 """ super(FashionMNISTDataset, self).__init__() images_data_path = os.path.join(path, '%s-images-idx3-ubyte.gz' % mode) labels_data_path = os.path.join(path, '%s-labels-idx1-ubyte.gz' % mode) with gzip.open(labels_data_path, 'rb') as lbpath: self.labels = np.frombuffer(lbpath.read(), dtype=np.uint8, offset=8) with gzip.open(images_data_path, 'rb') as imgpath: self.images = np.frombuffer(imgpath.read(), dtype=np.uint8, offset=16).reshape(len(self.labels), 784) self.transform = None if transform != 'None': self.transform = transform def __getitem__(self, index): """ 步骤三：实现__getitem__方法，定义指定index时如何获取数据，并返回单条数据（训练数据，对应的标签） """ if self.transform: image = self.transform(self.images[index].reshape(28, 28)) else: image = self.images[index] label = self.labels[index] return image, label def __len__(self): """ 步骤四：实现__len__方法，返回数据集总数目 """ return len(self.images) # 测试未处理的数据集 fashion_mnist_train_dataset_without_transform = FashionMNISTDataset(mode='train') # 可视化 fashion_mnist_train_dataset_without_transform = np.array(fashion_mnist_train_dataset_without_transform[0][0]) fashion_mnist_train_dataset_without_transform = fashion_mnist_train_dataset_without_transform.reshape([28, 28]) plt.imshow(fashion_mnist_train_dataset_without_transform, cmap=plt.cm.binary) <matplotlib.image.AxesImage at 0x7fb130421ed0>
# 测试处理的数据集 from paddle.vision.transforms import RandomVerticalFlip fashion_mnist_train_dataset_with_transform = FashionMNISTDataset(mode='train', transform=RandomVerticalFlip(0.4)) # 可视化 fashion_mnist_train_dataset_with_transform = np.array(fashion_mnist_train_dataset_with_transform[0][0]) fashion_mnist_train_dataset_with_transform = fashion_mnist_train_dataset_with_transform.reshape([28, 28]) plt.imshow(fashion_mnist_train_dataset_with_transform, cmap=plt.cm.binary) <matplotlib.image.AxesImage at 0x7fb130367b50>
2.4 数据加载
当咱们定义了数据集后，就须要加载数据集。咱们能够经过 paddle.io.DataLoader 完成数据的加载。
train_loader = paddle.io.DataLoader(train_dataset, batch_size=64, shuffle=True) for batch_id, data in enumerate(train_loader()): x_data = data[0] y_data = data[1] print(x_data.numpy().shape) print(y_data.numpy().shape) break (4, 32, 32, 3) (4,)
DataLoader 能够加载咱们定义好的数据集。虽然看起来很简单是很简单的操做，可是，DataLoader 的参数中包含了许多强大的功能。如 shuffle 设为 True， 能够对下标进行随机打散的操做；drop_last 设为 True 能够丢掉最后一个不知足 batch_size 大小的 batch；num_workers 能够设置多个子进程来加速数据加载。此外，咱们还能够针对不一样的数据集，设置不一样的采样器，来完成数据的采样。
2.5 数据采样
飞桨框架提供了多种数据采样器，用于不一样的场景，来提高训练模型的泛化性能。飞桨框架包含的采样器以下：paddle.io.BatchSampler 、 paddle.io.DistributedBatchSampler 、paddle.io.RandomSampler、paddle.io.SequenceSampler 等，接下来来一一介绍。
from paddle.io import SequenceSampler, RandomSampler, BatchSampler, DistributedBatchSampler
class RandomDataset(paddle.io.Dataset):
def __init__(self, num_samples):
self.num_samples = num_samples
def __getitem__(self, idx):
image = np.random.random([784]).astype('float32')
label = np.random.randint(0, 9, (1, )).astype('int64')
return image, label
def __len__(self):
return self.num_samples
train_dataset = RandomDataset(100)
print('-----------------顺序采样----------------')
sampler = SequenceSampler(train_dataset)
batch_sampler = BatchSampler(sampler=sampler, batch_size=10)
for index in batch_sampler:
print(index)
print('-----------------随机采样----------------')
sampler = RandomSampler(train_dataset)
batch_sampler = BatchSampler(sampler=sampler, batch_size=10)
for index in batch_sampler:
print(index)
print('-----------------分布式采样----------------')
batch_sampler = DistributedBatchSampler(train_dataset, num_replicas=2, batch_size=10)
for index in batch_sampler:
print(index)
-----------------顺序采样----------------
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
[20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
[30, 31, 32, 33, 34, 35, 36, 37, 38, 39]
[40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
[50, 51, 52, 53, 54, 55, 56, 57, 58, 59]
[60, 61, 62, 63, 64, 65, 66, 67, 68, 69]
[70, 71, 72, 73, 74, 75, 76, 77, 78, 79]
[80, 81, 82, 83, 84, 85, 86, 87, 88, 89]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
-----------------随机采样----------------
[9, 7, 54, 93, 84, 14, 12, 46, 67, 72]
[10, 57, 32, 61, 38, 71, 63, 51, 37, 11]
[21, 76, 69, 22, 48, 88, 19, 59, 47, 60]
[89, 85, 31, 80, 91, 30, 50, 52, 39, 3]
[70, 45, 62, 75, 35, 8, 96, 94, 5, 98]
[49, 33, 28, 13, 18, 42, 90, 0, 36, 79]
[81, 15, 6, 78, 40, 86, 2, 23, 95, 43]
[87, 65, 68, 25, 99, 26, 73, 82, 1, 53]
[77, 29, 17, 44, 55, 4, 56, 64, 97, 83]
[66, 41, 16, 74, 92, 34, 27, 24, 58, 20]
-----------------分布式采样----------------
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
[40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
[60, 61, 62, 63, 64, 65, 66, 67, 68, 69]
[80, 81, 82, 83, 84, 85, 86, 87, 88, 89]
总结
恭喜同窗们学会了数据集的下载、数据集的自定义、数据的预处理以及数据的批加载等知识，你们已经能够很好地应对模型训练任务的第一步啦。那么今天的课程到这里就结束了，对课程内容有疑问或者建议的同窗能够在评论区留言，看到后我会及时回复哦，最后但愿你们fork一下该项目，否则就找不到这个课程了。我是雨哥，下节课见~
下载安装命令 ## CPU版本安装命令 pip install -f https://paddlepaddle.org.cn/pip/oschina/cpu paddlepaddle ## GPU版本安装命令 pip install -f https://paddlepaddle.org.cn/pip/oschina/gpu paddlepaddle-gpu
有任何问题能够在本项目中评论或到飞桨Github仓库（连接）提交Issue。
欢迎扫码加入飞桨框架高层API技术交流群
·飞桨官网地址·
https://www.paddlepaddle.org.cn/
·飞桨开源框架项目地址·
GitHub: https://github.com/PaddlePaddle/Paddle
Gitee: https://gitee.com/paddlepaddle/Paddle
微信号 : PaddleOpenSource
飞桨(PaddlePaddle)以百度多年的深度学习技术研究和业务应用为基础，是中国首个开源开放、技术领先、功能完备的产业级深度学习平台，包括飞桨开源平台和飞桨企业版。飞桨开源平台包含核心框架、基础模型库、端到端开发套件与工具组件，持续开源核心能力，为产业、学术、科研创新提供基础底座。飞桨企业版基于飞桨开源平台，针对企业级需求加强了相应特性，包含零门槛AI开发平台EasyDL和全功能AI开发平台BML。EasyDL主要面向中小企业，提供零门槛、预置丰富网络和模型、便捷高效的开发平台；BML是为大型企业提供的功能全面、可灵活定制和被深度集成的开发平台。
本文同步分享在 博客“飞桨PaddlePaddle”（CSDN）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。