文章目录
- Dataset 和 DataLoader
- Dataset加载数据集
- transforms
- ToTensor()
- Lambda Transforms
- 迭代和可视化数据集
- 自定义数据集类——真假索隆
- DataLoader
Dataset 和 DataLoader
用于处理数据样本的代码可能会变得凌乱且难以维护；理想情况下，我们希望数据集代码与模型训练代码解耦，以获得更好的可读性和模块化。PyTorch提供的torch.utils.data.DataLoader 和 torch.utils.data.Dataset允许你使用预下载的数据集或自己制作的数据。Dataset用于存储样本及其相应的标签，而DataLoader能为数据集提供一个迭代器，以便于访问样本。
PyTorch域库提供了许多预加载的数据集（如FashionMNIST），且都是torch.utils.data.Dataset的子类。你可以在这里找到它们：图像数据集、文本数据集和音频数据集
Dataset加载数据集
以torchvision加载Fashion MNIST数据集为例。Fashion MNIST是Zalando文章里的图像数据集，包括60000个训练样本和10000个测试样本。每个示例包括一个28×28灰度图像(特征图)和10个类别之一的标签。
我们使用以下参数加载Fashion MNIST数据集：
-
root是要存储训练/测试数据的路径 -
train指定数据集为训练集或测试集， -
download=True表示如果在root无从获取数据集，则从网上下载。 -
transform和target_transform分别指定特征图和标签数据类型变换。
import torch
from torch.utils.data import Dataset
from torchvision import datasets
from torchvision.transforms import ToTensor,Lambda
import matplotlib.pyplot as plt
import numpy as np
training_data = datasets.FashionMNIST(
root="data",
train=True,
download=True,
transform=ToTensor(),
target_transform = Lambda(lambda y: torch.zeros(
10, dtype=torch.float).scatter_(dim=0, index=torch.tensor(y), value=1))
)
test_data = datasets.FashionMNIST(
root="data",
train=False,
download=True,
transform=ToTensor(),
target_transform = Lambda(lambda y: torch.zeros(
10, dtype=torch.float).scatter_(dim=0, index=torch.tensor(y), value=1))
)
运行以上程序，
Out:
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz to data/FashionMNIST/raw/train-images-idx3-ubyte.gz
Extracting data/FashionMNIST/raw/train-images-idx3-ubyte.gz to data/FashionMNIST/raw
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz to data/FashionMNIST/raw/train-labels-idx1-ubyte.gz
Extracting data/FashionMNIST/raw/train-labels-idx1-ubyte.gz to data/FashionMNIST/raw
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz to data/FashionMNIST/raw/t10k-images-idx3-ubyte.gz
Extracting data/FashionMNIST/raw/t10k-images-idx3-ubyte.gz to data/FashionMNIST/raw
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz to data/FashionMNIST/raw/t10k-labels-idx1-ubyte.gz
Extracting data/FashionMNIST/raw/t10k-labels-idx1-ubyte.gz to data/FashionMNIST/raw
transforms
数据被处理后的形式并不总是适合训练机器学习算法。所以，我们使用transforms对数据执行一些操作，使其适合于训练。
所有TorchVision数据集都有两个参数，其中transform用于修改特征图，target_transform用于修改标签。torchvision.transforms模块提供了几种常用的转换，如下文的ToTensor()、Lambda。
FashionMNIST的特征是PIL图像格式，标签是整数。对于训练，我们需要将特征规范化为张量（tensor），将标签用独热(one-hot)编码张量表示。为了进行这些转换，我们使用ToTensor和Lambda。
ToTensor()
ToSensor将PIL图像或NumPy ndarray转换为浮点张量(FloatTensor)。并图像的像素值在[限制在[0,1]范围内。
Lambda Transforms
Lambda转换应用任何用户定义的lambda函数。在这里，我们定义了一个函数来将整数转换为一个独热编码张量。它首先创建一个大小为class_num的零张量（数据集中标签的数量），并调用scatter_，它在标签y给定的索引上指定值为1。
target_transform = Lambda(lambda y: torch.zeros(
class_num, dtype=torch.float).scatter_(dim=0, index=torch.tensor(y), value=1))
迭代和可视化数据集
我们可以像列表一样索引数据集：training_data[index]。我们使用matplotlib可视化训练数据中的一些样本。
labels_map = {
0: "T-Shirt",
1: "Trouser",
2: "Pullover",
3: "Dress",
4: "Coat",
5: "Sandal",
6: "Shirt",
7: "Sneaker",
8: "Bag",
9: "Ankle Boot",
}
figure = plt.figure(figsize=(8, 8))
cols, rows = 3, 3
for i in range(1, cols * rows + 1):
sample_idx = torch.randint(len(training_data), size=(1,)).item()
img, label = training_data[sample_idx]
figure.add_subplot(rows, cols, i)
print('one-hot：',label)
index=torch.nonzero(label)[0][0] # one-hot转整数标签
plt.title(labels_map[index.item()])
plt.axis("off")
plt.imshow(img.squeeze(), cmap="gray")
plt.show()
one-hot： tensor([0., 0., 0., 0., 0., 0., 0., 1., 0., 0.])
one-hot： tensor([0., 0., 0., 1., 0., 0., 0., 0., 0., 0.])
one-hot： tensor([0., 0., 1., 0., 0., 0., 0., 0., 0., 0.])
one-hot： tensor([0., 0., 0., 1., 0., 0., 0., 0., 0., 0.])
one-hot： tensor([0., 0., 0., 0., 0., 0., 0., 1., 0., 0.])
one-hot： tensor([0., 0., 0., 0., 1., 0., 0., 0., 0., 0.])
one-hot： tensor([0., 0., 0., 1., 0., 0., 0., 0., 0., 0.])
one-hot： tensor([0., 0., 0., 0., 0., 0., 0., 0., 1., 0.])
one-hot： tensor([0., 0., 0., 0., 1., 0., 0., 0., 0., 0.])
自定义数据集类——真假索隆
首先，导入相关库：
import torch
from torch.utils.data import Dataset,DataLoader
from torchvision.transforms import ToTensor, ToPILImage, Lambda
import matplotlib.pyplot as plt
import os
import pandas as pd
from PIL import Image
图像所在文件夹与标签的Excel文件为：
img_path = '.\zoro'
label_path = '.\label_zoro.xlsx'
有10张图片，5张假(用0标记)5张真(用1标记)
链接：https://pan.baidu.com/s/1xGm6IMhq8zBQYZZCwwf3Aw
提取码：1111
自定义数据集类
自定义数据集类必须实现三个函数： __init__, __len__, 和__getitem__：
class ZoroDataset(Dataset):
def __init__(self, label_file, img_dir, transform=None, target_transform=None):
# 读取标签文件
self.labels = pd.read_excel(label_file)
# 定义文件目录
self.img_dir = img_dir
# 定义transform
self.transform = transform
self.target_transform = target_transform
def __len__(self):
'''返回数据集中的样本数'''
return len(self.labels)
def __getitem__(self, index):
'''获取数据的方法，会和Dataloader连用'''
# 获取图片路径，0表示Excel文件的第一列
img_path = os.path.join(self.img_dir, self.labels.iloc[index, 0])
# 读取图片
image = Image.open(img_path)
# 获取图片对应的标签，1表示Excel文件的第二列
y_label = int(self.labels.iloc[index, 1])
# 如果使用时附加了transform参数，则对图片、标签应用转换
if self.transform:
image = self.transform(image)
if self.target_transform:
y_label = self.target_transform(y_label)
return image, y_label
定义一个图像展示函数
def img_show(img):
'''将img转化为PIL图像格式后展示'''
to_pil_image = ToPILImage()
img = to_pil_image(img)
plt.imshow(img)
定义一个索隆数据集实例
# 这里标签采用one-hot编码只是为了展示效果，不考虑实际意义
dataset = ZoroDataset(label_file=label_path, img_dir=img_path, transform=ToTensor(),
target_transform=Lambda(lambda y: torch.zeros(
2, dtype=torch.float).scatter_(dim=0, index=torch.tensor(y), value=1)))
读取图片和标签
train_features, train_labels = dataset[0]
img_show(train_features)
print('one-hot标签：',train_labels)
plt.show()
输出：
one-hot标签： tensor([1., 0.])
DataLoader
Dataset一次检索只能检索一个样本。但我们在训练模型时，通常希望以“小批量”的方式采样，并在每个回合(epoch)打乱数据以避免模型过拟合。这就需要DataLoader了。DataLoader通过一个简单的API为我们抽象了这种复杂的功能，且是可迭代的。
batch_size = 2
train_dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
print('数据集样本数：', len(dataset)) # __len__()
遍历DataLoader
我们已经将该数据集加载到DataLoader中，接下来可以根据需要对数据集进行迭代。下面的例子中每次迭代都会返回一批train_features和train_labels（分别包含batch_size个特征和标签）。当我们指定了shuffle=True时，所以在对所有批进行迭代之后，数据顺序将被打乱。
可以用next()或for循环对DataLoader进行迭代：
- 用
next()：
for epoch in range(2):
data_iter = iter(train_dataloader) # 构建迭代器
for i in range(int(len(dataset) / batch_size)):
train_features, train_labels = next(data_iter)
plt.figure(i)
for j in range(batch_size):
plt.subplot(int(f"1{batch_size}{j + 1}"))
# print(train_features.size())
img = train_features[j]
label = train_labels[j]
img_show(img)
print(f"Label: {label}")
plt.show()
- 用
for循环
for epoch in range(2):
data_iter = iter(train_dataloader)
for i, (train_features, train_labels) in enumerate(data_iter):
plt.figure(i)
for j in range(batch_size):
plt.subplot(int(f"1{batch_size}{j + 1}"))
# print(train_features.size())
img = train_features[j]
label = train_labels[j]
img_show(img)
print(f"Label: {label}")
plt.show()
shuffle=True时，数据集被打乱：
|
|
|
|
|
shuffle=False时，按顺序迭代：
|
|
|
|
|
全部代码：
import torch
from torch.utils.data import Dataset, DataLoader
from torchvision.transforms import ToTensor, ToPILImage, Lambda
import matplotlib.pyplot as plt
import os
import pandas as pd
from PIL import Image
img_path = '.\zoro'
label_path = '.\label_zoro.xlsx'
class ZoroDataset(Dataset):
def __init__(self, label_file, img_dir, transform=None, target_transform=None):
# 读取标签文件
self.labels = pd.read_excel(label_file)
# 定义文件目录
self.img_dir = img_dir
# 定义transform
self.transform = transform
self.target_transform = target_transform
def __len__(self):
'''返回数据集中的样本数'''
return len(self.labels)
def __getitem__(self, index):
'''获取数据的方法，会和Dataloader连用'''
# 获取图片路径，0表示Excel文件的第一列
img_path = os.path.join(self.img_dir, self.labels.iloc[index, 0])
# 读取图片
image = Image.open(img_path)
# 获取图片对应的标签，1表示Excel文件的第二列
y_label = int(self.labels.iloc[index, 1])
# 如果使用时附加了transform参数，则对图片应用转换
if self.transform:
image = self.transform(image)
if self.target_transform:
y_label = self.target_transform(y_label)
return image, y_label
def img_show(img):
'''将img转化为PIL图像格式后展示'''
to_pil_image = ToPILImage()
img = to_pil_image(img)
plt.imshow(img)
# 这里标签采用one-hot编码只是为了展示效果，不考虑实际意义
dataset = ZoroDataset(label_file=label_path, img_dir=img_path, transform=ToTensor(),
target_transform=Lambda(lambda y: torch.zeros(
2, dtype=torch.float).scatter_(dim=0, index=torch.tensor(y), value=1)))
train_features, train_labels = dataset[0]
# img_show(train_features)
# print('one-hot标签：', train_labels)
# plt.show()
batch_size = 2
train_dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=False)
print('数据集样本数：', len(dataset))
for epoch in range(2):
data_iter = iter(train_dataloader)
for i, (train_features, train_labels) in enumerate(data_iter):
plt.figure(i)
for j in range(batch_size):
plt.subplot(int(f"1{batch_size}{j + 1}"))
# print(train_features.size())
img = train_features[j]
label = train_labels[j]
img_show(img)
print(f"Label: {label}")
plt.show()
参考：
[1]https://pytorch.org/tutorials/beginner/basics/data_tutorial.html
[2]https://zhuanlan.zhihu.com/p/401206843
