CS231n-assignment2-PyTorch

介绍PyTorch

你在这个作业中写了很多代码来提供一整套的神经网络功能。Dropout, Batch Normalization，和2D卷积是计算机视觉中深度学习的主要工具。您还努力使代码高效和向量化。

但是，对于本作业的最后一部分，我们将离开您漂亮的代码库，转而迁移到两个流行的深度学习框架之一:PyTorch(或者TensorFlow)

为什么我们要使用深度学习框架?

我们的代码现在可以在gpu上运行了!这将使我们的模型训练得更快。当使用像PyTorch或TensorFlow这样的框架时，你可以利用GPU的力量来为你自己的自定义神经网络架构，而不必直接编写CUDA代码(这超出了这个类的范围)。

在这门课中，我们希望你准备好在你的项目中使用这些框架中的一个，这样你就可以比手工编写每个功能更有效地进行试验。

我们要你站在巨人的肩膀上!TensorFlow和PyTorch都是非常优秀的框架，它们会让你的生活变得更简单，现在你了解了它们的本质，你可以自由地使用它们了:)

最后，我们希望你能接触到你可能在学术界或业界遇到的深度学习代码。

PyTorch是什么?

PyTorch是一个用于在行为类似于numpy ndarray的张量对象上执行动态计算图的系统。它带有一个强大的自动差异化引擎，消除了手动反向传播的需要。

这个作业有5个部分。您将在三个不同的抽象级别上学习PyTorch，这将帮助您更好地理解它，并为最终的项目做好准备。

第一部分，准备:我们将使用CIFAR-10数据集。

第二部分，Barebones PyTorch:抽象级别1，我们将直接使用最低级别的PyTorch张量。

第三部分，PyTorch模块API:抽象级别2，我们将使用nn.Module来定义任意的神经网络结构。

第四部分，PyTorch Sequential API:抽象级别3，我们将使用nn.Sequential定义一个线性前馈网络非常方便。

第五部分，CIFAR-10开放式挑战:请在CIFAR-10上实现您自己的网络，以获得尽可能高的精度。您可以使用任何层、优化器、超参数或其他高级功能进行试验。

ln[1]:

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torch.utils.data import sampler

import torchvision.datasets as dset
import torchvision.transforms as T

import numpy as np

USE_GPU = True
dtype = torch.float32 # We will be using float throughout this tutorial.

if USE_GPU and torch.cuda.is_available():
    device = torch.device('cuda')
else:
    device = torch.device('cpu')

# Constant to control how frequently we print train loss.
print_every = 100
print('using device:', device)

第一部分的准备

现在，让我们加载CIFAR-10数据集。这在第一次执行时可能需要几分钟，但之后文件应该会保持缓存。

在之前的作业中，我们必须编写自己的代码来下载CIFAR-10数据集，对它进行预处理，并在小批量中遍历它;PyTorch为我们提供了方便的工具来自动化这个过程。
ln[2]:

NUM_TRAIN = 49000

# The torchvision.transforms package provides tools for preprocessing data
# and for performing data augmentation; here we set up a transform to
# preprocess the data by subtracting the mean RGB value and dividing by the
# standard deviation of each RGB value; we've hardcoded the mean and std.
transform = T.Compose([
                T.ToTensor(),
                T.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
            ])

# We set up a Dataset object for each split (train / val / test); Datasets load
# training examples one at a time, so we wrap each Dataset in a DataLoader which
# iterates through the Dataset and forms minibatches. We divide the CIFAR-10
# training set into train and val sets by passing a Sampler object to the
# DataLoader telling how it should sample from the underlying Dataset.
cifar10_train = dset.CIFAR10('./cs231n/datasets', train=True, download=True,
                             transform=transform)
loader_train = DataLoader(cifar10_train, batch_size=64, 
                          sampler=sampler.SubsetRandomSampler(range(NUM_TRAIN)))

cifar10_val = dset.CIFAR10('./cs231n/datasets', train=True, download=True,
                           transform=transform)
loader_val = DataLoader(cifar10_val, batch_size=64, 
                        sampler=sampler.SubsetRandomSampler(range(NUM_TRAIN, 50000)))

cifar10_test = dset.CIFAR10('./cs231n/datasets', train=False, download=True, 
                            transform=transform)
loader_test = DataLoader(cifar10_test, batch_size=64)

这里我已经下好了

第二部分，Barebones PyTorch

PyTorch附带了高级api来帮助我们方便地定义模型架构，我们将在本教程的第二部分中介绍这些内容。在本节中，我们将从基本的PyTorch元素开始，以更好地理解autograd引擎。在这个练习之后，您将更加欣赏高级模型API。

我们将从一个简单的全连接的ReLU网络开始，它有两个隐藏层，没有CIFAR分类的偏差。这个实现使用PyTorch张量上的操作来计算前向传递，并使用PyTorch autograd来计算梯度。理解每一行是很重要的，因为在示例之后你会写出一个更难的版本。

当我们用requires_grad=True创建一个PyTorch张量时，涉及这个张量的操作将不仅仅是计算值;他们还会在后台建立一个计算图，让我们可以很容易地通过这个图反向传播，计算一些张量相对于下游损失的梯度。具体地说，如果x是一个带有x的张量requires_grad == True，那么在反向传播之后，x grad将是另一个张量，在最后保持x相对于标量损失的梯度。

PyTorch张量:Flatten函数

PyTorch张量在概念上类似于numpy数组:它是一个n维的数字网格，并且像numpy一样PyTorch提供了许多函数来有效地操作张量。作为一个简单的例子，我们提供了一个flatten函数，它可以在全连接的神经网络中重塑图像数据。

回想一下，图像数据通常存储在形状为N x C x H x W的张量中，其中:

N是数据点的个数

C是通道的数量

H为中间特征图的高度，以像素为单位

W为中间特征图的高度，以像素为单位

当我们在做2D卷积之类的事情时，这是表示数据的正确方法，这需要空间理解中间特征彼此之间的相对位置。然而，当我们使用完全连接的仿射层来处理图像时，我们希望每个数据点用单个向量表示——分离数据的不同通道、行和列不再有用。因此，我们使用“flatten”操作将每个表示的C x H x W值折叠成一个单独的长向量。下面的flatten函数首先从给定的一批数据中读取N、C、H和W值，然后返回该数据的“视图”。“View”类似于numpy的“重塑”方法)

ln[3]:

def flatten(x):
    N = x.shape[0] # read in N, C, H, W
    return x.view(N, -1)  # "flatten" the C * H * W values into a single vector per image

def test_flatten():
    x = torch.arange(12).view(2, 1, 3, 2)
    print('Before flattening: ', x)
    print('After flattening: ', flatten(x))

test_flatten()

Barebones PyTorch:两层网络
这里我们定义了一个函数two_layer_fc，它执行对一批图像数据的两层全连接ReLU网络的转发。在定义前向传递之后，我们检查它是否会崩溃，并通过网络运行0来生成正确的形状。

您不必在这里编写任何代码，但阅读并理解实现是很重要的
ln[4]:

import torch.nn.functional as F  # useful stateless functions

def two_layer_fc(x, params):
    """
    A fully-connected neural networks; the architecture is:
    NN is fully connected -> ReLU -> fully connected layer.
    Note that this function only defines the forward pass; 
    PyTorch will take care of the backward pass for us.
    
    The input to the network will be a minibatch of data, of shape
    (N, d1, ..., dM) where d1 * ... * dM = D. The hidden layer will have H units,
    and the output layer will produce scores for C classes.
    
    Inputs:
    - x: A PyTorch Tensor of shape (N, d1, ..., dM) giving a minibatch of
      input data.
    - params: A list [w1, w2] of PyTorch Tensors giving weights for the network;
      w1 has shape (D, H) and w2 has shape (H, C).
    
    Returns:
    - scores: A PyTorch Tensor of shape (N, C) giving classification scores for
      the input data x.
    """
    # first we flatten the image
    x = flatten(x)  # shape: [batch_size, C x H x W]
    
    w1, w2 = params
    
    # Forward pass: compute predicted y using operations on Tensors. Since w1 and
    # w2 have requires_grad=True, operations involving these Tensors will cause
    # PyTorch to build a computational graph, allowing automatic computation of
    # gradients. Since we are no longer implementing the backward pass by hand we
    # don't need to keep references to intermediate values.
    # you can also use `.clamp(min=0)`, equivalent to F.relu()
    x = F.relu(x.mm(w1))
    x = x.mm(w2)
    return x
    

def two_layer_fc_test():
    hidden_layer_size = 42
    x = torch.zeros((64, 50), dtype=dtype)  # minibatch size 64, feature dimension 50
    w1 = torch.zeros((50, hidden_layer_size), dtype=dtype)
    w2 = torch.zeros((hidden_layer_size, 10), dtype=dtype)
    scores = two_layer_fc(x, [w1, w2])
    print(scores.size())  # you should see [64, 10]

two_layer_fc_test()

Barebones PyTorch:三层ConvNet

在这里，您将完成函数three_layer_convnet的实现，该函数将执行三层卷积网络的前向传递。像上面一样，我们可以通过在网络中传递0来立即测试我们的实现。网络应具有以下架构:

1.带有channel_1滤波器的卷积层(带偏置)，每个滤波器的形状为KW1 x KH1，零填充为2

2.ReLU

3.带有channel_2滤波器的卷积层(带偏置)，每个滤波器的形状为KW2 x KH2，零填充为1

4.ReLU

5.带有偏差的全连接层，为C类生成分数。

请注意，在我们的全连接层之后，这里没有softmax激活:这是因为PyTorch的交叉熵损失为您执行了softmax激活，通过将该步骤绑定进来，使计算更加高效。
ln[5]:

def three_layer_convnet(x, params):
    """
    Performs the forward pass of a three-layer convolutional network with the
    architecture defined above.

    Inputs:
    - x: A PyTorch Tensor of shape (N, 3, H, W) giving a minibatch of images
    - params: A list of PyTorch Tensors giving the weights and biases for the
      network; should contain the following:
      - conv_w1: PyTorch Tensor of shape (channel_1, 3, KH1, KW1) giving weights
        for the first convolutional layer
      - conv_b1: PyTorch Tensor of shape (channel_1,) giving biases for the first
        convolutional layer
      - conv_w2: PyTorch Tensor of shape (channel_2, channel_1, KH2, KW2) giving
        weights for the second convolutional layer
      - conv_b2: PyTorch Tensor of shape (channel_2,) giving