选自GitHub上，机器之心编译。
本教程展示了如何从了解张量开始到使用PyTorch训练简单的神经网络，是非常基础的PyTorch入门资源.PyTorch建立在Python和火炬库之上，并提供了一种类似Numpy的抽象方法来表征量（或多维数组），它还能利用GPU来提升性能。本教程的代码并不完整，详情请查看原Jupyter Notebook文档。
PyTorch使入门深度学习变得简单，即使你这方面的背景知识不太充足。至少，知道多层神经网络模型可视为由权重连接的节点图就是有帮助的，你可以基于前向和反向传播，利用优化过程（如梯度计算）从数据中估计权重。
- 必备知识：该教程假设读者熟悉Python和NumPy。
- 必备软件：在运行原Jupyter Notebook之前你需要安装PyTorch。原笔记本有代码单元格可以验证你是否做好准备。
- 必需硬件：你需要安装NVIDIA GPU和CUDA SDK。据报告此举可能实现10-100的加速。当然，如果你没有进行此设置，那么你仍然可以在仅使用CPU的情况下运行PyTorch。但是，记住，在训练神经网络模型时，生命苦短！所以还是尽可能使用GPU吧！
项目地址：
1.必要的PyTorch背景
- PyTorch是一个建立在Torch库之上的Python包，旨在加速深度学习应用。
- PyTorch提供一种类似NumPy的抽象方法来表征张量（或多维数组），它可以利用GPU来加速训练。
1.1 PyTorch张量
PyTorch的关键数据结构是张量，即多维数组。其功能与NumPy的ndarray对象类似，如下我们可以使用torch.Tensor（）创建张量。
＃生成2-d pytorch张量（即，基质） pytorch_tensor = torch.Tensor（10，20）的打印（“类型：” ，类型（pytorch_tensor）， “ 和尺寸：”，pytorch_tensor.shape）复制代码
如果你需要一个兼容NumPy的表征，或者你想从现有的NumPy对象中创建一个PyTorch张量，那么就很简单了。
＃将pytorch张量转换为numpy数组： numpy_tensor = pytorch_tensor.numpy（）print（“type：”，type（numpy_tensor），“and size：”，numpy_tensor.shape）＃将numpy数组转换为Pytorch Tensor： print（“type：”，type（torch.Tensor（numpy_tensor）），“and size：”，torch.Tensor（numpy_tensor）.shape）复制代码
1.2 PyTorch与NumPy
PyTorch并不是NumPy的简单替代品，但它实现了很多NumPy功能。其中有一个不便之处是其命名规则，有时它和和NumPy的命名方法相当不同。我们来举几个例子说明其中的区别：
1张量创建
T = torch.rand（2，4，3，5）一个= np.random.rand（2，4，3，5）复制代码
2张量分割
T = torch.rand（2，4，3，5）一个= t.numpy（）pytorch_slice = T [ 0，1：3，：，4 ] numpy_slice = A [ 0，1：3，：，4 ] 打印（'张量[0，1：3，：1,4]：\ N'，pytorch_slice）打印（'NdArray [0，1：3，：1,4]：\ N'，numpy_slice）------- -------------------------------------------------- ---------------- 张量[ 0，1：3，：，4 ]： 0.2032 0.1594 0.3114 0.9073 0.6497 0.2826 [torch.FloatTensor大小的2 ×3] NdArray [ 0，1：3，：，4 ]：[[ 0.20322084 0.15935552 0.31143939 ] [ 0.90726137 0.64966112 0.28259504 ]]复制代码
3张量掩蔽
t = t - 0.5 a = t.numpy（）pytorch_masked = t [t> 0 ] numpy_masked = a [a> 0 ]复制代码
4张量重塑
pytorch_reshape = t.view（[ 6，5，4 ]）numpy_reshape = a.reshape（[ 6，5，4 ]）复制代码
1.3 PyTorch变量
- PyTorch张量的简单封装
- 帮助建立计算图
- Autograd（自动微分库）的必要部分
- 将关于这些变量的梯度保存在.grad中
结构图：
计算图和变量：在PyTorch中，神经网络会使用相互连接的变量作为计算图来表示.PyTorch允许通过代码构造计算图来构建网络模型;之后PyTorch会简化估计模型权重的流程，例如通过自动计算梯度的方式。
举例来说，假设我们想构建两层模型，那么首先要输入和输出创建张量变量。我们可以将PyTorch Tensor包装进变量对象中：
从 torch.autograd 进口可变进口 torch.nn.functional 作为 ˚F X =变数（torch.randn（4，1），requires_grad = 假）Y =变量（torch.randn（3，1），requires_grad = 假）复制代码
我们把requires_grad设置为True，表明我们想要自动计算梯度，这将用于反向传播中以优化权重。
现在我们来定义权重：
W1 =变数（torch.randn（5，4），requires_grad = 真）W2 =变量（torch.randn（3，5），requires_grad = 真）复制代码
训练模型：
def model_forward （x）： return F.sigmoid（w2 @ F.sigmoid（w1 @ x）） print（w1） print（w1.data.shape） print（w1.grad）＃最初，不存在 ---- -------------------------------------------------- -------------------可变含： 1.6068 -1.3304 -0.6717 -0.6097 -0.3414 -0.5062 -0.2533 1.0260 -0.0341 -1.2144 -1.5983 -0.1392 -0.5473 0.0084 0.4054 0.0970 0.3596 0.5987 -0.0324 0.6116 [torch.Float传感器的大小5 X4的] torch.Size（[ 5，4 ]）无复制代码
1.4 PyTorch反向传播
这样我们有了输入和目标，模型权重，那么是时候训练模型了我们需要三个组件：
损失函数：描述我们模型的预测距离目标还有多远;
导入 torch.nn 为 nn 条件= nn.MSELoss（）复制代码
优化算法：用于更新权重;
导入 torch.optim 作为 optim optimizer = optim.SGD（[w1，w2]，lr = 0.001）复制代码
反向传播步骤：
对于历元在范围（10）： 损耗=标准（model_forward（x）中，y）的 optimizer.zero_grad（） ＃零出以前梯度 loss.backward（）＃计算新梯度 optimizer.step（） ＃应用这些梯度打印（ w1）------------------------------------------------ ------------------------- 变量包含： 1.6067 -1.3303 -0.6717 -0.6095 -0.3414 -0.5062 -0.2533 1.0259 -0.0340 -1.2145 -1.5983 -0.1396 -0.5476 0.0085 0.4055 0.0976 0.3597 0.5986 -0.0324 0.6113 [火炬。尺寸为5 x4的飞溅传感器 ]复制代码
1.5 PyTorch CUDA接口
PyTorch的优势之一是为张量和autograd库提供CUDA接口。使用CUDA GPU，你不仅可以加速神经网络训练和推断，还可以加速任何映射至PyTorch张量的工作负载。
你可以调用torch.cuda.is_available（）函数，检查PyTorch中是否有可用CUDA。
cuda_gpu = torch.cuda.is_available（）if（cuda_gpu）： print（“Great，you have a GPU！”）else： print（“Life is short - consider a GPU！”）复制代码
很好，现在你有GPU了。
.cuda（）
之后，使用cuda加速代码就和调用一样简单。如果你在张量上调用.cuda（），则它将执行从CPU到CUDA GPU的数据迁移。如果你在模型上调用.cuda（），则它不仅将所有内部储存移到GPU，还将整个计算图映射至GPU。
要想将张量或模型复制回CPU，比如想和NumPy交互，你可以调用.cpu（）。
如果 cuda_gpu： x = x.cuda（） print（type（x.data））x = x.cpu（）print（type（x.data））--------------- -------------------------------------------------- -------- < class ' 火炬。cuda。FloatTensor '> < class ' 火炬。FloatTensor '>复制代码
我们来定义两个函数（训练函数和测试函数）来使用我们的模型执行训练和推断任务。该代码同样来自PyTorch官方教程，我们摘选了所有训练/推断的必要步骤。
对于训练和测试网络，我们需要执行一系列动作，这些动作可直接映射至PyTorch代码：
1.我们将模型转换到训练/推断模式;
2.我们通过在数据集上成批获取图像，以迭代训练模型;
3.对于每一个批量的图像，我们都要加载数据和标注，运行网络的前向步骤来获取模型输出;
4.我们定义损失函数，计算每个批量的模型输出和目标之间的损失;
5.训练时，我们初始化梯度为零，使用上一步定义的优化器和反向传播，来计算所有与损失有关的层级梯度;
6.训练时，我们执行权重更新步骤。
def train （model，epoch，criterion，optimizer，data_loader）： model.train（） for batch_idx，（data，target） in enumerate（data_loader）： if cuda_gpu： data，target = data.cuda（），target.cuda（ ） model.cuda（） 数据，目标=变量（数据），变量（目标） 输出=模型（数据） optimizer.zero_grad（） 损失=标准（输出，目标） loss.backward（） optimizer.step（） if（ batch_idx + 1）％ 400 == 0： print（'Train Epoch：{} [{} / {}（{：.0f}％）] \ tLoss：{：.6f}'. format（ epoch，（batch_idx + 1）* len（data），len（data_loader.dataset ）， 100 *（batch_idx + 1）/ LEN（data_loader），loss.data [ 0 ]））DEF 试验（模型，历元，标准，data_loader） ： model.eval（） test_loss = 0 正确= 0 为数据，目标在 data_loader中： if cuda_gpu： data，target = data.cuda（），target.cuda（） model.cuda（） 数据，target =变量（数据），变量（目标） output = model（data） test_loss + = criterion（output，target）.data [ 0 ] pred = output.data.max（1）[ 1 ] ＃获取最大对数概率索引 + = pred.eq（目标数据）.cpu（）。sum（） test_loss / = len（data_loader）＃失败函数已经在批量大小上取平均值 acc = correct / len（data_loader.dataset） print（'\ nTest set：Average loss：{：。 4f}，准确度：{} / {}（{：.0f }％）\ n'.format（ test_loss，correct，len（data_loader.dataset），100. * acc）） return（acc，test_loss）复制代码 现在介绍完毕，让我们开始这次数据科学之旅吧！
2.使用PyTorch进行数据分析
- 使用torch.nn库构建模型
- 使用torch.autograd库训练模型
- 将数据封装进torch.utils.data.Dataset库
- 使用NumPy接口连接你的模型，数据和你最喜欢的工具
在查看复杂模型之前，我们先来看个简单的：简单合成数据集上的线性回归，我们可以使用sklearn工具生成这样的合成数据集。
从 sklearn.datasets 导入 make_regression 进口 seaborn 作为 SNS 进口熊猫作为 PD 进口 matplotlib.pyplot 作为 PLT sns.set（）x_train，y_train，W_target = make_regression（N_SAMPLES次= 100，n_features = 1，噪声= 10，COEF = 真）DF = pd.DataFrame（data = { 'X'：x_train.ravel（），'Y'：y_train.ravel（）}）sns.lmplot（x = 'X'，y = 'Y'，data = df，fit_reg = True）plt.show（）1）x_torch = torch.FloatTensor（x_train）y_torch = torch.FloatTensor（y_train）y_torch = y_torch.view（y_torch.size（）[ 0 ]，1）复制代码 PyTorch的nn库中有大量有用的模块，其中一个就是线性模块。如名字所示，它对输入执行线性变换，即线性回归。
class LinearRegression （torch.nn.Module）： def __init__ （self，input_size，output_size）： super（LinearRegression，self）.__ init __（） self.linear = torch.nn.Linear（input_size，output_size） def forward （self，x ）： 返回 self.linear（x）的模型=线性回归（ 1， 1）复制代码
要训练线性回归，我们需要从nn库中添加合适的损失函数。对于线性回归，我们将使用MSELoss（） - 均方差损失函数。
我们还需要使用优化函数（SGD），并运行与之前示例类似的反向传播。本质上，我们重复上文定义的train（）函数中的步骤。不能直接使用该函数的原因是我们实现它的目的是分类而不是回归，以及我们使用交叉熵损失和最大元素的索引作为模型预测。而对于线性回归，我们使用线性层的输出作为预测。
准则= torch.nn.MSELoss（）优化= torch.optim.SGD（model.parameters（），LR = 0.1） 对于历元在范围（50）： 数据，目标=变量（x_torch），变量（y_torch） 输出= model（data） optimizer.zero_grad（） loss = criterion（output，target） loss.backward（） optimizer.step（）predict = model（Variable（x_torch））。data.numpy（）复制代码
现在我们可以打印出原始数据和适合PyTorch的线性回归。
plt.plot（x_train，y_train，'o'，label = '原始数据'）plt.plot（x_train，predicted，label = 'Fitted line'）plt.legend（）plt.show（）复制代码
为了转向更复杂的模型，我们下载了MNIST数据集至「数据集」文件夹中，并测试了一些PyTorch中可用的初始预处理.PyTorch具备数据加载器和处理器，可用于不同的数据集。下载好后，你可以随时使用。你还可以将数据包装进PyTorch张量，创建自己的数据加载器类别。
批大小（batch size）是机器学习中的术语，指一次迭代中使用的训练样本数量。批大小可以是以下三种之一：
- batch模式：批大小等于整个数据集，因此迭代和epoch值一致;
- mini-batch模式：批大小大于1但小于整个数据集的大小。通常，数量可以是能被整个数据集整除的值。
- 随机模式：批大小等于1.因此梯度和神经网络参数在每个样本之后都要更新。
从 torchvision 导入数据集，变换batch_num_size = 64 train_loader = torch.utils.data.DataLoader（ datasets.MNIST（'data'，train = True，download = True，transform = transforms.Compose（[ transforms.ToTensor（））， 转换。 Normalize（（0.1307，），（0.3081，）） ]））， batch_size = batch_num_size，shuffle = True）test_loader = torch.utils.data.DataLoader（ datasets.MNIST（'data'，train = False，transform = transforms。撰写（[ transforms.ToTensor（）， transforms.Normalize（（0.1307，），（0.3081，）） ]））， batch_size = batch_num_size，shuffle = True）复制代码
3. PyTorch中的LeNet卷积神经网络（CNN）
现在我们从头开始创建第一个简单神经网络。该网络要执行图像分类，识别MNIST数据集中的手写数字。这是一个四层的卷积神经网络（CNN），一种分析MNIST数据集的常见架构。该代码来自PyTorch官方教程，你可以在这里（http://pytorch.org/tutorials/）找到更多示例。
我们将使用torch.nn库中的多个模块：
1.线性层：使用层的权重对输入张量执行线性变换;
2. Conv1和Conv2：卷积层，每个层输出在卷积核（小尺寸的权重张量）和同样尺寸输入区域之间的点积;
3. Relu：修正线性单元函数，使用逐元素的激活函数max（0，x）;
池化层：使用max运算执行特定区域的下采样（通常2x2像素）;
5. Dropout2D：随机将输入张量的所有通道设为零。当特征图具备强相关时，dropout2D提升特征图之间的独立性;
6. Softmax：将Log（Softmax（x））函数应用到n维输入张量，以使输出在0到1之间。
类 LeNet （nn.Module） ： DEF __init__ （个体）： 超级（LeNet，自我）.__ INIT __（） self.conv1 = nn.Conv2d（ 1， 10，kernel_size = 5） self.conv2 = nn.Conv2d（ 10， 20，kernel_size = 5） self.conv2_drop = nn.Dropout2d（） self.fc1 = nn.Linear（ 320， 50） self.fc2 = nn.Linear（ 50， 10） DEF 向前（个体，X） ： X = F .relu（F.max_pool2d（self.conv1（x）的2）） X = F.relu（F.max_pool2d（self.conv2_drop（self.conv2（X）），2）） X = x.view（-1，320） X = F.relu（self.fc1（X ）） x = F.dropout（x，training = self.training） x = self.fc2（x） return F.log_softmax（x，dim = 1）复制代码
创建LeNet类后，创建对象并移至GPU：
model = LeNet（）if cuda_gpu： model.cuda（）print（'MNIST_net model：\ n'）print（model）----------------------- -------------------------------------------------- MNIST_net模型：LeNet（ （CONV1）：Conv2d（1，10，kernel_size =（5，5），跨度=（1，1）） （CONV2）：Conv2d（10，20，kernel_size =（5，5），步幅=（1，1）） （conv2_drop）：Dropout2d（p值=0.5） （fc1）：线性（in_features = 320，out_features = 50，bias = 真） （fc2）：线性（in_features = 50，out_features = 10，bias = 真））复制代码
要训练该模型，我们需要使用带动量的SGD，学习率为0.01，动量为0.5。
criteria = nn.CrossEntropyLoss（） 优化器= optim.SGD（model.parameters（），lr = 0.005，动量= 0.9）复制代码
仅仅需要5个epoch（一个epoch意味着你使用整个训练数据集来更新训练模型的权重），我们就可以训练出一个相当准确的LeNet模型。这段代码检查可以确定文件中是否已有预训练好。的模型有则加载;无则训练一个并保存至磁盘。
import os epochs = 5 if（os.path.isfile（'pretrained / MNIST_net.t7'））： print（'Loading model'） model.load_state_dict（torch.load（'pretrained / MNIST_net.t7'，map_location = lambda storage ，LOC：存储）） ACC，损耗=试验（模型，1，标准，test_loader）否则： 打印（'训练模式'） 用于历元在范围（1，历元+ 1：） 系（模型，历元，标准，优化，train_loader） acc，loss = test（model，1，criterion，test_loader） torch.save（model.state_dict（），'pretrained / MNIST_net.t7'）------------------ -------------------------------------------------- ----- 加载模型试验组：平均损耗：0.0471，准确度：9859号文件 / 10000（99％）复制代码
现在我们来看下模型。首先，打印出该模型的信息。打印函数显示所有层（如Dropout被实现为一个单独的层）及其名称和参数。同样有一个迭代器在模型中所有已命名模块之间运行。当你具备一个包含多个「内部」模型的复杂时，此有所帮助。在所有已命名模块之间的迭代允许我们创建模型解析器，可读取模型参数，创建与该网络类似的模块。
print（'Internal models：'）for idx，m in enumerate（model.named_modules（））： print（idx，' - >'，m） print（'-------------- -------------------------------------------------- ---------”）＃输出：内部模型：0 - >（''，LeNet（ （CONV1）：Conv2d（1，10，kernel_size =（5，5），跨度=（1，1）） （CONV2）：Conv2d（10，20，kernel_size =（5，5），跨度=（1，1）） （conv2_drop）：Dropout2d（p值= 0.5） （FC1）：线性（in_features = 320，out_features = 50，偏压= 真） （FC2）：线性（in_features = 50，out_features = 10，bias = True）））----------------------------------------- -------------------------------- 1 - >（'CONV1'，Conv2d（1，10，kernel_size =（5，5），跨度=（1，1）））-------------------------------------------------- ----------------------- 2 - >（'CONV2'，Conv2d（10，20，kernel_size =（5，5），跨度=（1，1）））---------------------------------------------- --------------------------- 3 - >（'conv2_drop'，Dropout2d（p = 0.5））-------- -------------------------------------------------- --------------- 4 - >（'fc1'，Linear（in_features = 320，out_features = 50，bias = True））-------------------------------------------------- ----------------------- 5 - >（'fc2'，Linear（in_features = 50，out_features = 10，bias = True））---- -------------------------------------------------- -------------------复制代码
你可以使用.cpu（）方法将张量移到CPU（或确保它在那里）。或者，当GPU可用时（torch.cuda。可用），使用.cuda（）方法将张量移至GPU。你可以看到张量是否在GPU上，其类型为torch.cuda.FloatTensor。如果张量在CPU上，则其类型为torch.FloatTensor 。
print（type（t.cpu（）。data））if torch.cuda.is_available（）： print（“Cuda is available”） print（type（t.cuda（）。data））else： print（“Cuda is不可用“）---------------------------------------------- --------------------------- < 类 ' 炬。FloatTensor '> Cuda的 是 可用的 < 类 ' 炬。cuda。FloatTensor '>复制代码
如果张量在CPU上，我们可以将其转换成NumPy数组，其共享同样的内存位置，改变其中一个就会改变另一个。
如果 torch.cuda.is_available（）： 尝试： 打印（t.data.numpy（））， 除了 RuntimeError 为 e： “你不能将GPU张量转换为numpy nd数组，你必须将你的weight tendor复制到cpu然后获取numpy数组“ print（type（t.cpu（）。data.numpy（）））print（t.cpu（）。data.numpy（）。shape）print（t.cpu（）。data）。 numpy的（））复制代码
现在我们了解了如何将张量转换成NumPy数组，我们可以利用该知识使用matplotlib进行可视化！我们来打印出第一卷积层的卷积滤波器。
data = model.conv1.weight.cpu（）。data.numpy（）print（data.shape）print（data [:, 0 ] .shape）kernel_num = data.shape [ 0 ] fig，axes = plt.subplots（ NCOLS = kernel_num，figsize =（2 * kernel_num，2））为山口在范围（kernel_num）： 轴[COL] .imshow（数据[COL，0，：，：]，CMAP = plt.cm.gray）PLT。显示（）复制代码
以上是简要的教程资源，还有更多的内容和实验可以查看原项目了解更多。