pytorch DataLoader详细介绍 代码举例说明_train_loader参数

batch_size、iteration、epoch简介：

batch_size：每批数据量的大小。深度学习通常用SGD的优化算法进行训练，也就是一次（1 个iteration）一起训练batch_size个样本，计算它们的平均损失函数值，来更新参数。

iteration：1个iteration即迭代一次，也就是用batchsize个样本训练一次。

epoch：1个epoch指：将训练集中的全部样本训练一次。

举例说明：比如数据集样本数是60000，一次训练32(batch_size)个样本，要迭代(iteration)或循环1875次才能训练完所有样本。训练所有样本完成一次就是1个num_epoches。

Dataloader参数详解

dataset(Dataset):传入的数据集

batch_size(int, optional):每个batch有多少个样本

shuffle(bool, optional):在每个epoch开始的时候，对数据进行重新打乱

sampler(Sampler, optional):自定义从数据集中取样本的策略，如果指定这个参数，那么shuffle必须为False

batch_sampler(Sampler, optional):与sampler类似，但是一次只返回一个batch的indices（索引），需要注意的是，一旦指定了这个参数，那么batch_size,shuffle,sampler,drop_last就不能再制定了（互斥——Mutually exclusive）

num_workers (int, optional):这个参数决定了有几个进程来处理data loading。0意味着所有的数据都会被load进主进程。（默认为0）

collate_fn (callable, optional):将一个list的sample组成一个mini-batch的函数

pin_memory (bool, optional)：如果设置为True，那么data loader将会在返回它们之前，将tensors拷贝到CUDA中的固定内存（CUDA pinned memory）中.

drop_last (bool, optional):如果设置为True：这个是对最后的未完成的batch来说的，比如你的batch_size设置为64，而一个epoch只有100个样本，那么训练的时候后面的36个就被扔掉了…
如果为False（默认），那么会继续正常执行，只是最后的batch_size会小一点。

timeout(numeric, optional):如果是正数，表明等待从worker进程中收集一个batch等待的时间，若超出设定的时间还没有收集到，那就不收集这个内容了。这个numeric应总是大于等于0。默认为0

worker_init_fn (callable, optional):每个worker初始化函数

上代码说明：

import torch
import torch.utils.data as Data
torch.manual_seed(1)

x = torch.linspace(1, 10, 10)
y = torch.linspace(10, 1, 10)
BATCH_SIZE = 5 #每一个迭代训练5个数据


torch_dataset = Data.TensorDataset(x, y)
loader = DataLoader(dataset = torch_dataset,batch_size = BATCH_SIZE,shuffle = True, drop_last=True)
print("len:", len(torch_dataset))#数据长度是10
#epoch全部样本训练的次数 这里是3次 也就是所有的样本训练3次
for epoch in range(3):
    for step, (batchX, batchY) in enumerate(loader):
        print('Epoch: ', epoch, '| Step: ', step, '| batch x: ',batchX.numpy(), '| batch y: ', batchY.numpy())

输出结果：
len: 10
Epoch:  0 | Step:  0 | batch x:  [ 5.  7. 10.  3.  4.] | batch y:  [6. 4. 1. 8. 7.]
Epoch:  0 | Step:  1 | batch x:  [2. 1. 8. 9. 6.] | batch y:  [ 9. 10.  3.  2.  5.]
Epoch:  1 | Step:  0 | batch x:  [ 4.  6.  7. 10.  8.] | batch y:  [7. 5. 4. 1. 3.]
Epoch:  1 | Step:  1 | batch x:  [5. 3. 2. 1. 9.] | batch y:  [ 6.  8.  9. 10.  2.]
Epoch:  2 | Step:  0 | batch x:  [ 4.  2.  5.  6. 10.] | batch y:  [7. 9. 6. 5. 1.]
Epoch:  2 | Step:  1 | batch x:  [3. 9. 1. 8. 7.] | batch y:  [ 8.  2. 10.  3.  4.]
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

从结果可以看出，每一个迭代训练（BATCH_SIZE）5个数字，我们总的数据长度是10，因此2个迭代训练完成。每一次epoch将所有数据都训练一次。

上面是总数据长度刚好能整除BATCH_SIZE，下面测试不能整除，上代码：

import torch
import torch.utils.data as Data
torch.manual_seed(1)

x = torch.linspace(1, 10, 10)
y = torch.linspace(10, 1, 10)
BATCH_SIZE = 3 #每一个迭代训练3个数据


torch_dataset = Data.TensorDataset(x, y)
loader = DataLoader(dataset = torch_dataset,batch_size = BATCH_SIZE,shuffle = True, drop_last=False)
print("len:", len(torch_dataset))#数据长度是10
#epoch全部样本训练的次数 这里是3次 也就是所有的样本训练3次
for epoch in range(3):
    for step, (batchX, batchY) in enumerate(loader):
        print('Epoch: ', epoch, '| Step: ', step, '| batch x: ',batchX.numpy(), '| batch y: ', batchY.numpy())

输出结果：
len: 10
Epoch:  0 | Step:  0 | batch x:  [ 5.  7. 10.] | batch y:  [6. 4. 1.]
Epoch:  0 | Step:  1 | batch x:  [3. 4. 2.] | batch y:  [8. 7. 9.]
Epoch:  0 | Step:  2 | batch x:  [1. 8. 9.] | batch y:  [10.  3.  2.]
Epoch:  0 | Step:  3 | batch x:  [6.] | batch y:  [5.]
Epoch:  1 | Step:  0 | batch x:  [4. 6. 7.] | batch y:  [7. 5. 4.]
Epoch:  1 | Step:  1 | batch x:  [10.  8.  5.] | batch y:  [1. 3. 6.]
Epoch:  1 | Step:  2 | batch x:  [3. 2. 1.] | batch y:  [ 8.  9. 10.]
Epoch:  1 | Step:  3 | batch x:  [9.] | batch y:  [2.]
Epoch:  2 | Step:  0 | batch x:  [4. 2. 5.] | batch y:  [7. 9. 6.]
Epoch:  2 | Step:  1 | batch x:  [ 6. 10.  3.] | batch y:  [5. 1. 8.]
Epoch:  2 | Step:  2 | batch x:  [9. 1. 8.] | batch y:  [ 2. 10.  3.]
Epoch:  2 | Step:  3 | batch x:  [7.] | batch y:  [4.]
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

从结果可以看出，每一个迭代训练（BATCH_SIZE）3个数字，我们总的数据长度是10，因此4个迭代训练完成。

再看，drop_last=True

import torch
import torch.utils.data as Data
torch.manual_seed(1)

x = torch.linspace(1, 10, 10)
y = torch.linspace(10, 1, 10)
BATCH_SIZE = 3 #每一个迭代训练3个数据


torch_dataset = Data.TensorDataset(x, y)
loader = DataLoader(dataset = torch_dataset,batch_size = BATCH_SIZE,shuffle = True, drop_last=True)
print("len:", len(torch_dataset))#数据长度是10
#epoch全部样本训练的次数 这里是3次 也就是所有的样本训练3次
for epoch in range(3):
    for step, (batchX, batchY) in enumerate(loader):
        print('Epoch: ', epoch, '| Step: ', step, '| batch x: ',batchX.numpy(), '| batch y: ', batchY.numpy())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

输出结果：

len: 10
Epoch:  0 | Step:  0 | batch x:  [ 5.  7. 10.] | batch y:  [6. 4. 1.]
Epoch:  0 | Step:  1 | batch x:  [3. 4. 2.] | batch y:  [8. 7. 9.]
Epoch:  0 | Step:  2 | batch x:  [1. 8. 9.] | batch y:  [10.  3.  2.]
Epoch:  1 | Step:  0 | batch x:  [4. 6. 7.] | batch y:  [7. 5. 4.]
Epoch:  1 | Step:  1 | batch x:  [10.  8.  5.] | batch y:  [1. 3. 6.]
Epoch:  1 | Step:  2 | batch x:  [3. 2. 1.] | batch y:  [ 8.  9. 10.]
Epoch:  2 | Step:  0 | batch x:  [4. 2. 5.] | batch y:  [7. 9. 6.]
Epoch:  2 | Step:  1 | batch x:  [ 6. 10.  3.] | batch y:  [5. 1. 8.]
Epoch:  2 | Step:  2 | batch x:  [9. 1. 8.] | batch y:  [ 2. 10.  3.]
1
2
3
4
5
6
7
8
9
10

本来是要训练4次的，但是drop_last=True,最后一次只有一个数据，不够一次，因此放弃掉。

from torchvision import datasets
from torch.utils.data import DataLoader
from torchvision import transforms

train_dataset = datasets.MNIST(
    root='F:/PycharmProjects/pytorch-beginner-master/02-Logistic Regression/data', train=True, transform=transforms.ToTensor(), download=True)
test_dataset = datasets.MNIST(
    root='F:/PycharmProjects/pytorch-beginner-master/02-Logistic Regression/data', train=False, transform=transforms.ToTensor())
batch_size = 32 #一次训练所抓取的数据样本数量；
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
print("训练集总长度： ", len(train_dataset))
print("每个mini_batch的size为32，一共有: ", len(train_loader), "个")
for i, data in enumerate(train_loader, 1):
    img, label = data  #j将数据从train_loader读出来 一次读取的样本数是32个
    img, label = Variable(img), Variable(label)
    print("img.data.size(): ", img.data.size(), "img.data.size(): ", label.data.size())

输出结果：
训练集总长度：  60000
每个mini_batch的size为32，一共有:  1875 个。也就是for循环1875次才能将整个数据训练完
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20