Python中的Dataset和Dataloader详解

from torch.utils.data import Dataloader

from torch.utils.data import DataLoader
DataLoader(
    dataset,
    batch_size=1,
    shuffle=False,
    num_workers=0,
    collate_fn=None,
    pin_memory=False,
 )
"""
dataset:是数据集
batch_size:是指一次迭代中使用的训练样本数。通常我们将数据分成训练集和测试集，并且我们可能有不同的批量大小。
shuffle:是传递给 DataLoader 类的另一个参数。该参数采用布尔值（真/假）。如果 shuffle 设置为 True，则所有样本都被打乱并分批加载。否则，它们会被一个接一个地发送，而不会进行任何洗牌。
num_workers:允许多处理来增加同时运行的进程数
collate_fn：合并数据集
pin_memory:锁页内存：将张量固定在内存中
"""

# Import MNIST
from torchvision.datasets import MNIST
# Download and Save MNIST 
data_train = MNIST('~/mnist_data', train=True, download=True)
# Print Data
print(data_train)
print(data_train[12])
#Dataset MNIST Number of datapoints: 60000 Root location: /Users/viharkurama/mnist_data Split: Train (<PIL.Image.Image image mode=L size=28x28 at 0x11164A100>, 3)

import matplotlib.pyplot as plt
random_image = data_train[0][0]
random_image_label = data_train[0][1]
# Print the Image using Matplotlib
plt.imshow(random_image)
print("The label of the image is:", random_image_label)

import torch
from torchvision import transforms
data_train = torch.utils.data.DataLoader(
    MNIST(
          '~/mnist_data', train=True, download=True, 
          transform = transforms.Compose([
              transforms.ToTensor()
          ])),
          batch_size=64,
          shuffle=True
          )
for batch_idx, samples in enumerate(data_train):
      print(batch_idx, samples)

#__getitem__() 方法通过索引返回数据集中选定的样本。
#__len__() 方法返回数据集的总大小。例如，如果您的数据集包含 1,00,000 个样本，则 len 方法应返回 1,00,000。
class Dataset(object):
    def __getitem__(self, index):
        raise NotImplementedError
    def __len__(self):
        raise NotImplementedError

import torch
import torchvision
from torch.utils.data import Dataset, DataLoader
from torchvision import datasets, transforms
class SquareDataset(Dataset):
     def __init__(self, a=0, b=1):
         super(Dataset, self).__init__()
         assert a <= b
         self.a = a
         self.b = b
     def __len__(self):
         return self.b - self.a + 1
     def __getitem__(self, index):
        assert self.a <= index <= self.b
        return index, index**2
data_train = SquareDataset(a=1,b=64)
data_train_loader = DataLoader(data_train, batch_size=64, shuffle=True)
print(len(data_train))

import torch
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

transform = transforms.Compose([
    # resize
    transforms.Resize(32),
    # center-crop
    transforms.CenterCrop(32),
    # to-tensor
    transforms.ToTensor(),
    # normalize
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])
"""
resize:此调整大小转换将所有图像转换为定义的大小。在这种情况下，我们要将所有图像的大小调整为 32×32。因此，我们将 32 作为参数传递。
center-crop:接下来，我们使用 CenterCrop 变换裁剪图像。 我们发送的参数也是分辨率/大小，但由于我们已经将图像大小调整为 32x32，因此图像将与此裁剪中心对齐。 这意味着图像将从中心裁剪 32 个单位（垂直和水平）。
to-tensor:我们使用 ToTensor() 方法将图像转换为张量数据类型。
normalize:这将张量中的所有值归一化，使它们位于 0.5 和 1 之间。
"""

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=False)