PyTorch是Python的主要开源机器学习库。PyTorch通常用作其他机器学习库的替代品，例如TensorFlow。

特别是，由于与其他库相比，执行某些任务的记录速度更快，因此PyTorch在机器学习爱好者中获得了一些青睐。PyTorch是由Facebook开发的，作为谷歌TensorFlow的竞争性深度学习软件包。

文章的目的

在本文中，您将了解神经网络，以及如何使用PyTorch库构建此类机器学习模型。

神经网络简介

那么，什么是神经网络呢？神经网络是一种基于现有数据创建预测的系统。

具体地说，神经网络模型是通过一种称为反向传播的技术来工作的——当新的信息被输入到模型中时，神经网络的权重会不断调整——因此，随着迭代次数的增加，可以进行更精确的预测。

神经网络包括：

• 输入层：根据现有数据获取输入的层
• 隐藏层：使用反向传播优化输入变量权重的层，以提高模型的预测能力
• 输出层：基于输入和隐藏层数据的预测输出

当我们提到“深度“神经网络时，我们的意思是说有一个隐藏层，这是我们将在我们的例子中使用的神经网络的类型。

基于神经网络的回归建模

为了理解神经网络如何用于自然语言处理等更高级的任务，首先要了解神经网络如何用于更传统的建模是很重要的。

在这方面，让我们探讨如何使用神经网络来解决回归问题。

什么是回归问题？

回归问题是我们试图以区间形式预测因变量的值，也就是说，我们的变量取值范围很广。这与分类问题不同，分类问题中我们的变量只能取与特定类别对应的值(例如0 =女性，1 =男性)。

让我们考虑以下问题。

假设我们希望根据以下自变量预测一个人的每月互联网使用量（以兆字节为单位）：

• 年龄
• 性别（0 =女性，1 =男性）
• 每周访问的网页
• 每周视频小时数
• 每月收入

此处提供了此问题的数据集(http://www.kankanyun.com/data/internet.csv)。让我们澄清术语依赖和自变量的含义：

• 因变量：受其他变量影响的变量。在这种情况下，数据使用受到其他因素的影响。
• 自变量：影响另一个变量的变量。例如，一个人每周观看的视频时间越多，这将增加消耗的数据量。

在我们将库加载到Python之前，我们必须首先确保安装了所有适当的库。

用pip安装库

请注意，我使用的是Python 3.6.5版。对于本教程，为了无缝地运行Python代码，我建议您在运行时使用此版本。

我们将使用pip命令安装适当的库。

对于torch 库（PyTorch），打开命令行并键入以下内容：

pip3 install torch torchvision

pip命令还用于将其他库安装到Python环境中。例如，假设您还需要安装scikit-learn库。为此，您将相应地输入：

pip3 install scikit-learn

一旦安装了所有适当的库，就可以将它们加载到Python环境中了。

导入库和预处理数据

我们将从加载Python并导入以下库开始：

import torch
import torch.nn as nn
import numpy as np
import pandas as pd
from sklearn import preprocessing
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import os;

然后，我们可以设置文件路径以导入CSV：

path="/home/yourdirectory"
os.chdir(path)
os.getcwd()
dataset=np.loadtxt("internet.csv", delimiter=",")

一旦我们完成了这项工作，我们现在需要在将数据提供给神经网络之前正确准备我们的数据。

x=dataset[:,0:5]
y=dataset[:,5]
y=np.reshape(y, (-1,1))
scaler = preprocessing.Normalizer()
yscale=scaler.fit_transform(y)
xscale=scaler.fit_transform(x)

首先，我们定义了x（自变量）和y（因变量）。然后，我们使用sklearn中的预处理库来归一化我们的数据并缩放变量，以便神经网络可以正确地解释它们。

如果运行这些，您将看到我们的新变量xscale和yscale现在在0和1之间，这允许神经网络更容易地解释我们的变量，从而产生更准确的结果。

训练/测试拆分

完成此操作后，我们需要将数据拆分为训练和测试数据。基本上，我们将在训练数据上构建神经网络模型，然后将其与测试数据进行交叉验证，以确定神经模型对不见数据的准确性。

要执行80％训练/ 20％测试拆分，我们使用以下命令：

X_train, X_test, y_train, y_test = train_test_split(xscale, yscale, test_size=0.2)

将numpy转换为张量

然后，我们将数据从numpy转换为tensor格式，如下所示：

xtrain = torch.Tensor(X_train)
ytrain = torch.Tensor(y_train)
>>> xtrain
tensor([[0.0029, 0.0000, 0.0029, 0.0002, 1.0000],
[0.0028, 0.0001, 0.0040, 0.0014, 1.0000],
[0.0040, 0.0000, 0.0048, 0.0004, 1.0000],
...,
[0.0062, 0.0000, 0.0055, 0.0000, 1.0000],
[0.0099, 0.0000, 0.0030, 0.0005, 0.9999],
[0.0055, 0.0000, 0.0067, 0.0003, 1.0000]])
>>> ytrain
tensor([[1.],
[1.],
[1.],
[1.],
[1.],
......
[1.],
[1.],
[1.]])

神经网络

现在，让我们运行神经网络模型。

对于这个特定的例子，我们使用具有5个输入层和10个隐藏层的线性神经网络，具有ReLU和sigmoid 函数作为附加层。

model = nn.Sequential(nn.Linear(5, 10),
nn.ReLU(),
nn.Linear(10, 1),
nn.Sigmoid())

一旦建立了模型本身，我们将在多次迭代（也称为epoch）上训练模型，并且我们将使用所谓的损失函数来判断模型的准确性。

在这种情况下，损失函数是均方误差。换句话说，我们的模型的估计值与实际值之间的平均平方差。

对于这个例子，我们训练模型超过500个epochs并为每个epoch生成损失读数。损失越低越好，因为在这种情况下，我们正在寻求最小化实际值和预测值之间的均方误差。我们执行以下操作：

数据的损失函数

criterion = torch.nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
for epoch in range(500):
 y_pred = model(xtrain)
 loss = criterion(y_pred, ytrain)
 print('epoch: ', epoch,' loss: ', loss.item())
 optimizer.zero_grad()
 loss.backward()
 optimizer.step()

我们看到随着epochs数量的增加，我们的损失读数相应下降：

epoch: 0 loss: 0.17553377151489258

epoch: 1 loss: 0.17494110763072968

epoch: 2 loss: 0.17435060441493988

epoch: 3 loss: 0.1737622767686844

epoch: 4 loss: 0.173176109790802

epoch: 5 loss: 0.17259210348129272

epoch: 6 loss: 0.17201022803783417

......

epoch: 494 loss: 0.03921870142221451

epoch: 495 loss: 0.03911843150854111

epoch: 496 loss: 0.03901850804686546

epoch: 497 loss: 0.038918931037187576

epoch: 498 loss: 0.03881969302892685

epoch: 499 loss: 0.03872080147266388

现在，让我们看看当我们在测试数据而不是训练数据上运行此模型时会发生什么。

我们以相同的方式设置模型，只是这次我们输入测试数据而不是训练数据：

#PyTorch array
xtest = torch.Tensor(X_test)
xtest.size
ytest = torch.Tensor(y_test)
ytest.size
model = nn.Sequential(nn.Linear(5, 10),
 nn.ReLU(),
 nn.Linear(10, 1),
 nn.Sigmoid())
criterion = torch.nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
## Loss function for test data
for epoch in range(500):
 y_pred = model(xtest)
 loss = criterion(y_pred, ytest)
 print('epoch: ', epoch,' loss: ', loss.item())
 optimizer.zero_grad()
 loss.backward()
 optimizer.step()

现在，让我们看看这次我们的损失读数显示了什么。

epoch: 0 loss: 0.3186935484409332

epoch: 1 loss: 0.3175300061702728

epoch: 2 loss: 0.31636855006217957

epoch: 3 loss: 0.31520920991897583

epoch: 4 loss: 0.31405195593833923

epoch: 5 loss: 0.31289681792259216

epoch: 6 loss: 0.3117437958717346

......

epoch: 494 loss: 0.040621303021907806

epoch: 495 loss: 0.040476154536008835

epoch: 496 loss: 0.04033173993229866

epoch: 497 loss: 0.040188051760196686

epoch: 498 loss: 0.04004509001970291

epoch: 499 loss: 0.03990283980965614

我们发现，在分析测试数据时，在epoch 499显示出与我们训练数据相似的读数。

让我们为我们的训练和测试数据绘制我们的损失函数:

如上所述，我们可以看到，虽然我们的测试数据的损失读数最初高于我们的训练数据，但两者最终会随着我们增加epochs数而收敛，这表明我们的神经网络模型在预测测试方面做得很好。