例如,nn.Conv2d将接受一个4维的张量,每一维分别是张量的梯度累积。

为了说明,我们反向跟踪几步:

print(loss.grad_fn)  f net.parameters():
    f.data.sub_(f.grad.data * learning_rate)

然而,当你使用神经网络是,你想要使用各种不同的更新规则,比如SGD,Nesterov-SGD,Adam, RMSPROP等.为了能做到这一点,我们构建了一个包torch.optim实现了所有的这些规则.使用他们非常简单:

torch.optim optim

你已经学会如何去定义一个神经网络,计算损失值和更新网络的权重。
你现在可能在思考：数据哪里来呢？
关于数据
通常，当你处理图像，文本，音频和视频数据时，你可以使用标准的Python包来加载数据到一个numpy数组中.然后把这个数组转换成torch.*Tensor。
对于图像,有诸如Pillow,OpenCV包等非常实用
对于音频,有诸如scipy和librosa包
对于文本,可以用原始Python和Cython来加载,或者使用NLTK和SpaCy
对于视觉,我们创建了一个torchvision包,包含常见数据集的数据加载,比如Imagenet,CIFAR10,MNIST等,和图像转换器,也就是torchvision.datasets和torch.utils.data.DataLoader。
这提供了巨大的便利,也避免了代码的重复。
在这个教程中,我们使用CIFAR10数据集,它有如下10个类别:’airplane’,’automobile’,’bird’,’cat’,’deer’,’dog’,’frog’,’horse’,’ship’,’truck’。这个数据集中的图像大小为3*32*32,即,3通道,32*32像素。
训练一个图像分类器
我们将按照下列顺序进行:
使用torchvision加载和归一化CIFAR10训练集和测试集.
定义一个卷积神经网络
定义损失函数
在训练集上训练网络
在测试集上测试网络
1. 加载和归一化CIFAR0
使用torchvision加载CIFAR10是非常容易的。
torch
torchvision
torchvision.transforms transforms
torchvision的输出是[0,1]的PILImage图像,我们把它转换为归一化范围为[-1, 1]的张量。
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((                                       download=                                         shuffle=                                      download=                                        shuffle=          matplotlib.pyplot plt
numpy np

   img = img / +        npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (   plt.show()

% classes[labels[j]] j range(torch.nn nn
torch.nn.functional F

          super(Net, self).__init__()
        self.conv1 = nn.Conv2d(       self.pool = nn.MaxPool2d(       self.conv2 = nn.Conv2d(       self.fc1 = nn.Linear(* *        self.fc2 = nn.Linear(       self.fc3 = nn.Linear(          x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(* *        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        x

net = Net()
3. 定义损失函数和优化器
我们使用交叉熵作为损失函数,使用带动量的随机梯度下降。
torch.optim optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=epoch range(   running_loss =    i, data enumerate(trainloader,               inputs, labels = data

               optimizer.zero_grad()

               outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

               running_loss += loss.item()
        i % ==            print(%
                  (epoch +            running_loss = % classes[labels[j]] j range(% classes[predicted[j]]
                              j range(torch.no_grad():
    data testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data,        total += labels.size(       correct += (predicted == labels).sum().item()

print(% (
    * correct / total))
Accuracy of the network on the 10000 test images: 54 %
结果看起来好于偶然，偶然的正确率为10%,似乎网络学习到了一些东西。
那在什么类上预测较好，什么类预测结果不好呢？
class_correct = list(i range(i range(torch.no_grad():
    data testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs,        c = (predicted == labels).squeeze()
        i range(           label = labels[i]
            class_correct[label] += c[i].item()
            class_total[label] += i range(   print(% (
        classes[i], * class_correct[i] / class_total[i]))
Accuracy of plane : 52 %
Accuracy of   car : 63 %
Accuracy of  bird : 43 %
Accuracy of   cat : 33 %
Accuracy of  deer : 36 %
Accuracy of   dog : 46 %
Accuracy of  frog : 68 %
Accuracy of horse : 62 %
Accuracy of  ship : 80 %
Accuracy of truck : 63 %
接下来干什么?
我们如何在GPU上运行神经网络呢?
在GPU上训练
你是如何把一个Tensor转换GPU上,你就如何把一个神经网络移动到GPU上训练。这个操作会递归遍历有所模块,并将其参数和缓冲区转换为CUDA张量。
device = torch.device(torch.cuda.is_available()  (conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear(in_features=400, out_features=120, bias=True)
  (fc2): Linear(in_features=120, out_features=84, bias=True)
  (fc3): Linear(in_features=84, out_features=10, bias=True)
)
请记住，你也必须在每一步中把你的输入和目标值转换到GPU上:
inputs, labels = inputs.to(device), labels.to(device)
为什么我们没注意到GPU的速度提升很多?那是因为网络非常的小。
实践:
尝试增加你的网络的宽度(第一个nn.Conv2d的第2个参数, 第二个nn.Conv2d的第一个参数,他们需要是相同的数字),看看你得到了什么样的加速。
实现的目标:
深入了解了PyTorch的张量库和神经网络
训练了一个小网络来分类图片
本章的官方代码：
Jupyter notebook:
作者:Sung Kim和Jenny Kang
在这个教程里,我们将学习如何使用数据并行(DataParallel)来使用多GPU。
PyTorch非常容易的就可以使用GPU,你可以用如下方式把一个模型放到GPU上:
device = torch.device("cuda:0")
model.to(device)
然后你可以复制所有的张量到GPU上:
mytensor = my_tensor.to(device)
请注意,只调用mytensor.gpu()并没有复制张量到GPU上。你需要把它赋值给一个新的张量并在GPU上使用这个张量。
在多GPU上执行前向和反向传播是自然而然的事。然而，PyTorch默认将只是用一个GPU。你可以使用DataParallel让模型并行运行来轻易的让你的操作在多个GPU上运行。
model = nn.DataParallel(model)
这是这篇教程背后的核心，我们接下来将更详细的介绍它。
导入和参数
导入PyTorch模块和定义参数。
torch
torch.nn nn
torch.utils.data Dataset, DataLoader

torch.cuda.is_available()           self.len = length
        self.data = torch.randn(length, size)

           self.data[index]

           self.len

rand_loader = DataLoader(dataset=RandomDataset(input_size, data_size),
                         batch_size=batch_size, shuffle=             super(Model, self).__init__()
        self.fc = nn.Linear(input_size, output_size)

           output = self.fc(input)
        print(                    output
创建一个模型和数据并行
这是本教程的核心部分。首先，我们需要创建一个模型实例和检测我们是否有多个GPU。如果我们有多个GPU，我们使用nn.DataParallel来包装我们的模型。然后通过model.to(device)把模型放到GPU上。
model = Model(input_size, output_size)
torch.cuda.device_count() >  print(  model = nn.DataParallel(model)

model.to(device)
Model(
  (fc): Linear(in_features=5, out_features=2, bias=True)
)
运行模型
现在我们可以看输入和输出张量的大小。
data rand_loader:
    input = data.to(device)
    output = model(input)
    print(         
翻译版本github下载：
https://github.com/fengdu78/machine_learning_beginner/tree/master/PyTorch_beginner

备注：公众号菜单包含了整理了一本AI小抄，非常适合在通勤路上用学习。
往期精彩回顾




2019年公众号文章精选
适合初学者入门人工智能的路线及资料下载
机器学习在线手册
深度学习在线手册
AI基础下载（第一部分）
备注：加入本站微信群或者qq群，请回复“加群”
加入知识星球（4500+用户，ID：92416895），请回复“知识星球”
喜欢文章，点个在看