翻译原文：https://blog.paperspace.com/pytorch-101-building-neural-networks/
说在前面：这篇文章是Ayoosh Kathuria关于PyTorch教程的系列文章，非常喜欢他的系列教程，讲的很详细很有启发。因此把原文的系列教程翻译了下来，并结合了自己的部分理解。因为本人能力有限，难免和原文表达的含义有所出入，仅仅作为交流使用。本篇博客是该系列论文的第二篇（一共有五篇）
PyTorch 101, Part 2: 构建你的第一个卷积神经网络
在这个部分，我们将会实现一个卷积神经网络，对CIFAR-10的图片进行分类。我们会涉及到实现卷积神经网络，数据加载和设置衰退学习率的策略。
在这篇文章中，我们将会讨论如何使用PyTorch去构建定制的神经网络架构，怎样去配置你的训练循环。我们将会实现一个RestNet网络架构，对CIFAR-10数据集的图片进行分类。
在文章开始之前，我强调一下这篇教程的目的不是在任务中获得最好的精度，而是向你展示如何去使用PyTorch。
我再强调一下，这是我们的基于PyTorch系列教程的第二部分。尽管阅读第一部分对这片文章来说不是必要的，但是还是强烈建议去读一下。
在这篇文章中，我们将会涉及：
- 如何使用nn.Module类去构建神经网络
- 如何使用Dataset和Dataloader类去构建带有数据增广的定制数据输入。
- 如何使用不同学习率策略去配置你的学习率。
- 在CIFAR-10数据集中，训练一个基于分类器Resnet网络进行图片分类.
目录
PyTorch 101, Part 2: 构建你的第一个卷积神经网络
5.3 torch.utils.data.Dataloader
1 前沿知识
- 链式求导法则
- 了解深度学习的基础知识
- PyTorch 1.0
- 阅读过了教程第一部分
2 一个简单的神经网络
在这个教程中，我们将会实现一个非常简单的神经网络：
3 构造网络
在PyTorch中，torch.nn模块是设计神经网络的基石。通过实例化torch.nn.Module对象，可以实现一个网络层，比如一个全连接层，一个卷积层，一个池化层，一个激活函数，以及一个完整的网络架构（从这里开始，我们用nn.module来表示torch.nn.Module）。
多个nn.Module对象连接在一起可以形成一个更大的nn.Module对象，这就是我们可以使用很多网络层去实现一个神经网络的原因。事实上，在PyTorch中，nn.Module可以用来表示随意的函数f。
在使用nn.Module类的时候，你必须要去重写它的两个函数。
- __init__()函数。在你创建一个nn.Module实例对象的时候，这个函数就会被调用。在这里，你可以定义网络层的很多参数，比如过滤器，卷积层中卷积核的尺寸，dropout层中dropout的可能性。
- forward()函数。这里是你定义你的输出是如何计算的地方。这个函数不需要你显示的调用，通过调用nn.Module的实例就可以运行。就像一个带参的函数一样。
# Very simple layer that just multiplies the input by a number
class MyLayer(nn.Module):
def __init__(self, param):
super().__init__()
self.param = param
def forward(self, x):
return x * self.param
myLayerObject = MyLayer(5)
output = myLayerObject(torch.Tensor([5, 4, 3]) ) #calling forward inexplicitly
print(output)
从上面我们可以看到，在PyTorch中，网络的定义和数据处理是分开进行的。在__init__()函数中，我们定义网络层的先后顺序，并设置卷积核尺寸，步长大小等等；而在forward()函数中，我们定义数据在网络层中是如何进行处理的。
另外一个经常使用并且非常重要的类是nn.Sequential类。当我们初始化这个类的时候，我们可以传入一个特定顺序的nn.Module对象。这个对象由nn.Sequential类返回，并且它本身即是一个nn.Module对象。当我们传入输入数据运行这个对象的时候，它按照我们输入给他们的顺序来，有序地运行我们传入的所有的nn.Module对象。
combinedNetwork = nn.Sequential(MyLayer(5), MyLayer(10))
output = combinedNetwork([3,4])
#equivalent to..
# out = MyLayer(5)([3,4])
# out = MyLayer(10)(out)
我们开始去实现我们的分类网络。我们将会使用卷积层和池化层，以及一个定制的实现好了的残差层：
尽管PyTorch的torch.nn模块提供了很多的模块，但是我们还是需要自己去实现残差块。在我们实现一个神经网络之前，我们需要实现RestNet模块（ResNet模块实际实际上就是不同网络层的不同排列组合）：
class ResidualBlock(nn.Module):
def __init__(self, in_channels, out_channels, stride=1):
super(ResidualBlock, self).__init__()
# Conv Layer 1
self.conv1 = nn.Conv2d(
in_channels=in_channels, out_channels=out_channels,
kernel_size=(3, 3), stride=stride, padding=1, bias=False
)
self.bn1 = nn.BatchNorm2d(out_channels)
# Conv Layer 2
self.conv2 = nn.Conv2d(
in_channels=out_channels, out_channels=out_channels,
kernel_size=(3, 3), stride=1, padding=1, bias=False
)
self.bn2 = nn.BatchNorm2d(out_channels)
# Shortcut connection to downsample residual
# In case the output dimensions of the residual block is not the same
# as it's input, have a convolutional layer downsample the layer
# being bought forward by approporate striding and filters
self.shortcut = nn.Sequential()
if stride != 1 or in_channels != out_channels:
self.shortcut = nn.Sequential(
nn.Conv2d(
in_channels=in_channels, out_channels=out_channels,
kernel_size=(1, 1), stride=stride, bias=False
),
nn.BatchNorm2d(out_channels)
)
def forward(self, x):
# 其实还可以把ReLU层放在__init__()中，将Con,BN,ReLU层一起构成一个Sequential
out = nn.ReLU()(self.bn1(self.conv1(x)))
out = self.bn2(self.conv2(out))
out += self.shortcut(x)
out = nn.ReLU()(out)
return out
在ResNet网络模块中，我们可以看到有两中类型的ResNet模块：
- 当输入通道数=输出通道数或者stride=1的时候，恒等映射就是一条直线。
- 当输入通道数！=输出通道数或者stride!=1的时候，恒等映射就是一个卷积操作
因为存在这两种情况，因此我们需要进行if判断，到底恒等映射应该是哪一种情况。
如你所见，在__init__函数中，我们定义了网络层，或者我们网络的组件。在forward函数中，我们是如何将这些组件串起来，去计算我们输入的输出的。
现在，我们可以定义我们整个网络。
class ResNet(nn.Module):
def __init__(self, num_classes=10):
super(ResNet, self).__init__()
# Initial input conv
self.conv1 = nn.Conv2d(
in_channels=3, out_channels=64, kernel_size=(3, 3),
stride=1, padding=1, bias=False
)
self.bn1 = nn.BatchNorm2d(64)
# Create blocks
self.block1 = self._create_block(64, 64, stride=1)
self.block2 = self._create_block(64, 128, stride=2)
self.block3 = self._create_block(128, 256, stride=2)
self.block4 = self._create_block(256, 512, stride=2)
self.linear = nn.Linear(512, num_classes)
# A block is just two residual blocks for ResNet18
def _create_block(self, in_channels, out_channels, stride):
return nn.Sequential(
ResidualBlock(in_channels, out_channels, stride),
ResidualBlock(out_channels, out_channels, 1)
)
def forward(self, x):
# Output of one layer becomes input to the next
out = nn.ReLU()(self.bn1(self.conv1(x)))
out = self.stage1(out)
out = self.stage2(out)
out = self.stage3(out)
out = self.stage4(out)
# 这一层也可以放在__init__函数中，4指的是进行平均池化层的kernel_size
out = nn.AvgPool2d(4)(out)
# 在进行全连接之前，我们需要将数据调整成行向量
out = out.view(out.size(0), -1)
out = self.linear(out)
return out
4 输入格式
现在，我们已经拥有了我们的网络对象，我们将我们的目光转移到输入上。当我们在使用深度学习的时候，我们遇到很多不同种类的输入。图像，音频或者是高维的结构数据。
我们正在处理的这些类型的数据，会规定我们的输入格式。在PyTorch中，通常总是让batch在第一维度。因为这里处理的是图像，我会描述一下接收图片的输入格式。
图片的输入格式是[B C H W]。其中B是批量的尺寸，C是图片的通道数，H和W分别是图片的高和宽。
因为我们使用随机的权重，因此我们神经网络的输出现在来说还是不确定的。接下来让我们训练我们的网络。
5 加载数据
现在，让我们加载数据，我们将会使用torch.utils.data.Dataset和torch.utils.data.Dotaloader这两个类。
我们首先需要再我们的代码文件目录中下载CIFAR-10数据集。打开终端，转到你的代码目录下，然后运行下面的命令。
wget http://pjreddie.com/media/files/cifar.tgz
tar xzf cifar.tgz
如果你使用macOS，你可能需要使用curl，或者如果你使用windows，你需要手动下载。
我们需要读取CIFAR数据集中的类别标签。
data_dir = "cifar/train/"
with open("cifar/labels.txt") as label_file:
labels = label_file.read().split()
label_mapping = dict(zip(labels, list(range(len(labels)))))
我们将会使用PIL库去读取图片。在我们写函数取加载我们数据之前，我们需要写一个预处理函数来进行下面的工作。
- 使用0.5的可能性去随机水平我们的图片
- 使用CIFAR数据集的均值标准差去归一化我们的图片
- 将图片的通道由W H C变成C H W
def preprocess(image):
image = np.array(image)
if random.random() > 0.5:
image = image[:-1,:,:]
cifar_mean = np.array([0.4914, 0.4822, 0.4465]).reshape(1,1,-1)
cifar_std = np.array([0.2023, 0.1994, 0.2010]).reshape(1,1,-1)
image = (image - cifar_mean) / cifar_std
# 下面个等价于：image = image.permute(2,1,0)
# permute输入的是转置之后的维度顺序；transpose输入的是哪两个维度需要进行转置
image = image.transpose(2,0)
return image
通常，PyTorch给你提供了两个和构造加载数据的输入管线的类。
- torch.data.utils.dataset， 现在我们将其称之为dataset类。
- torch.data.utils.dataLoader，现在我们将会将其称之为dataloader类。
5.1 torch.data.utils.dataset
dataset是一个加载数据并且返回生成器的类，因此你可以迭代它。它还可以在你的输入中加入数据增广的技巧。
如果你想为你的数据创建一个dataset实例对象，你需要去重写三个函数。
- __init__函数。在这里，你可以定义和你的数据集相关的东西。最重要的是你的数据集的位置。你还可以定义很多你想要应用的数据增广的技巧。
- __len__函数。在这里，你只需要返回数据集的长度。
- __getitem__函数。这个函数接收一个索引i的参数，然后返回一个数据样例。在我们训练循环的过程中，dataset实例对象会使用不同的i，在每次迭代中调用这个函数。
这里有个CIFAR数据集的dataset对象的实现。
class Cifar10Dataset(torch.utils.data.Dataset):
def __init__(self, data_dir, data_size = 0, transforms = None):
files = os.listdir(data_dir)
files = [os.path.join(data_dir,x) for x in files]
if data_size < 0 or data_size > len(files):
assert("Data size should be between 0 to number of files in the dataset")
if data_size == 0:
data_size = len(files)
self.data_size = data_size
self.files = random.sample(files, self.data_size)
self.transforms = transforms
def __len__(self):
return self.data_size
def __getitem__(self, idx):
image_address = self.files[idx]
image = Image.open(image_address)
image = preprocess(image)
label_name = image_address[:-4].split("_")[-1]
label = label_mapping[label_name]
image = image.astype(np.float32)
if self.transforms:
image = self.transforms(image)
return image, label
我们可以使用__getitem__函数去取提取一个在它文件夹中编码的图片的标签。
Dataset类允许我们去合并延迟数据加载原则。这意味着，可以不一次性将所有数据加载到内存中（这个可以通过在__init__函数中将所有图片加载到内存中来实现，而不是仅仅加载地址），而是当需要的时候，一次性只加载一个数据样例（当__getitem__调用的时候）。
当你创建一个Dataset类的对象的时候，你基本上可以迭代所有对象，就像遍历任何python迭代器一样。每此迭代，__getitem__函数就会用索引i当做是它的输入参数。
5.2 数据增广
在__init__函数中，我也传入了一个transforms的参数。它可以是实现数据增广的任意的python函数。尽管你可以在预处理代码中进行数据增广，但是在__getitem__进行只不过是个人习惯而已。
这里，你也可是添加数据增广。这些数据增强既可以是函数也可以是类。你只需要确保在__getitem__函数中，你使用它们能够得到你想要的输出就行。
我们有很多数据增广的库，你可以使用它们去进行数据增广。
在我们的例子中，torchvision库提供了很多预制的变换，以及将他们组成一个更大变换的能力。但是在这里我们只限于讨论PyTorch。
5.3 torch.utils.data.Dataloader
这个Dataloader类能够简便：
- 批量化数据
- 随机化数据
- 使用线程一次加载多个数据
- 预取数据，也就是，当GPU处理当前批次数据的时候，Dataloader能够同时将下一批次数据加载到内存中。这意味着GPU不需要等待下一个批次的数据，而且能够加快训练。
你可以使用一个Dataset对象去实例化一个Dataloader实例对象。然后你就可以像迭代一个dataset实例对象一样，去迭代一个Dataloader实例对象。
然而，你可以具体制定不同的选项，这些选项能够让你对循环选项有着更多的控制。
trainset = Cifar10Dataset(data_dir = "cifar/train/", transforms=None)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=2)
testset = Cifar10Dataset(data_dir = "cifar/test/", transforms=None)
testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=True, num_workers=2)
trainset和trainloader都是python生成器对象，你可以用下面的方式去迭代它们。
for data in trainloader: # or trainset
img, label = data
然而，Dataloader类比Dataset类更便利一些。在每一次迭代中，Dataset类会给我们返回__getitem__()函数的输出，Dataloader的作用比这个大。
- 注意，trainset的__getitem__()方法返回一个3*32*32形状的numpy 数组。Dataloader将图片批量化成一个128*3*32*32形状的Tensor（因为在你的代码中batch_size=128）
- 还需要注意，当我们的__getitem__()方法输出一个numpy数组的时候，Dataloader类就会自动将它转换成一个Tensor
- 即使__getitem__()方法返回一个非数值类型的对象，这个Dataloader类也会把它转换成一个尺寸为B的列表或者元组（在我们的例子中B是128）。假设__getitem__()也返回一个string，也就是标签值。如果我们在实例化dataloader的时候，设置batch=128，那么每个迭代，Dataloader将会给我们返回一个包含128字符串的元组。
除了上述优点外，还可以添加预取、多线程加载，几乎每次都建议使用Dataloader类。
6 训练和评估
在我们开始写我们的循环之前，我们需要决定我们的超参数和我们优化算法。PyTorch在torch.optim中给我们提供了很多预制的优化算。
6.1 torch.optim
torch.optim模块给你提供了训练和优化之类的函数。
- 不同优化算法（比如optim.SGD, optim.Adam）
- 能够设置学习率
- 不同的参数能够有不同的学习率的能力（尽管在这篇文章中我们不讨论这个问题）
我们使用一个交叉熵损失函数，和基于SGD优化算法的动量梯度下降法。我们的学习率在第150代和200代的时候会有0.1的下降。
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") #Check whether a GPU is present.
clf = ResNet()
clf.to(device) #Put the network on GPU if present
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(clf.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4)
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[150, 200], gamma=0.1)
在代码的第一行，如果有GPU 0或者没有cpu的话，device设置为cuda:0。
在我们初始化一个网络的时候，它默认是在CPU上面的。如果GPU存在的话，clf.to(device)会将这个网络移动到GPU上。在另一篇文章中，我们将回介绍如何使用多个GPU的细节。我们还可以使用clf.cuda(0)去将我们的网络clf移动到GPU 0上（在一般情况下，使用CPU的索引代替0）。
criterions基本上是一个nn.CrossEntropy类的实例对象，顾名思义，它实现了交叉熵损失函数。它是nn.Module的子类。
我们之后定义了变量optimizer作为optim.SGD的实例对象。optim.SGD的第一个参数是clf.parameters()。nn.Module对象的parameters()函数返回一个parameters（作为nn.Parameter对象的实现，我们将会在下一节中学习这个类，在那里我们探索PyTorch高级的功能。现在，把他们想象成一个和Tensor相关的列表，他们都是可学习的）。clf.parameters()是我们神经网络的基本权重。
正如你在代码中看到的，在我们的代码中，我们将会调用optimizer的step()函数。当step()函数调用的时候，这个优化器就会使用梯度更新规则方程去更新clf.parameters()中的每个Tensor。可以使用每个Tensor的grad属性获取他们的梯度。
一般情况下，任何优化器SGD, Adam或者是RMSprop，它的第一个参数，是要去更新的Tensors列表。剩下的参数定义了不同的超参数。
顾名思义，sheduler可以规划optimizer的不同的超参数。optimizer是用来初始化scheduler的。我们调用scheduler.step()的使用，它每次都会更新超参数。
7 训练循环
我们最终训练200代，你可以增加epochs的数量，在GPU上，这可能需要等一下。再次重申一下，这篇教程的目的是去展示PyTorch是如何工作的，而不是去获得最高的准确率。
for epoch in range(10):
losses = []
scheduler.step()
# Train
start = time.time()
for batch_idx, (inputs, targets) in enumerate(trainloader):
inputs, targets = inputs.to(device), targets.to(device)
optimizer.zero_grad() # Zero the gradients
outputs = clf(inputs) # Forward pass
loss = criterion(outputs, targets) # Compute the Loss
loss.backward() # Compute the Gradients
optimizer.step() # Updated the weights
losses.append(loss.item())
end = time.time()
if batch_idx % 100 == 0:
print('Batch Index : %d Loss : %.3f Time : %.3f seconds ' % (batch_idx, np.mean(losses), end - start))
start = time.time()
# Evaluate
clf.eval()
total = 0
correct = 0
with torch.no_grad():
for batch_idx, (inputs, targets) in enumerate(testloader):
inputs, targets = inputs.to(device), targets.to(device)
outputs = clf(inputs)
_, predicted = torch.max(outputs.data, 1)
total += targets.size(0)
correct += predicted.eq(targets.data).cpu().sum()
print('Epoch : %d Test Acc : %.3f' % (epoch, 100.*correct/total))
print('--------------------------------------------------------------')
clf.train()
现在，上面是一大块代码。我没有把它拆成更小的代码，因此不会有连续性的风险。尽管在代码中我已经添加了注释去提醒读者它们的作用，但是我现在会解释代码中不那么琐碎的部分。
我们首先在每个epoch的开始，调用了scheduler.step()函数，来确保optimizer会使用正确的学习率。
在循环中，我们做的第一件事是我们把我们的input和target移动到GPU 0上了。这个应该和我们模型所在的设备相同，否则的话PyTorch就会报错并且停止。
注意，在我们前向传播之前，我们调用了optimizer.zero_grad()函数。这是因为一个叶子Tensor（存放我们权重的地方）会从前面的传播中保存梯度。如果损失函数重新调用了backward函数，新的梯度就会简单地添加到有grad属性保存的之前的梯度。当我们使用RNNs的时候，这个函数就很方便了，但是现在，我们需要设置梯度为零，因此不需要去计算后面的梯度。
我们也将我们的评估代码放到了torch.no_grad上下文中，因此评估的时候不需要创建计算图。如果你觉得难以理解，你可以回到part1去更新你的autograd的概念。
还需要注意，在评估之前，我们调用了clf.eval()函数，然后clf.train()在它后面。在PyTorch中的模型有两个状态eval()和train()。这个状态的不同归根于状态层，比如Batch Norm层（训练中批处理统计vs推理总体统计）和Dropout层，在推理和训练中，他们有着不同的表现。eval告诉nn.Module去将这些层放在推理模块中，但是train()告诉nn.Module把它放在训练模块中。
8 结论
这是一个非常详细的教程，我们向你展示了如何去构造一个基本的训练分类器。但是这仅仅是一个开始，我们已经涉及了所有的构造块，它可以让你开始使用PyTorch去构建深层网络架构。
在这个系列论文的下一节，我们将研究一下PyTorch中高级的功能，这将增强你的深度学习的设计。这将包括创建更为复杂的架构，如何去定制训练，比如不同的参数有着不同的学习率。