TensorFlow与PyTorch — 线性回归

代码医生工作室

发布于 2020-06-01 16:49:25

1.1K0

发布于 2020-06-01 16:49:25

文章被收录于专栏：相约机器人

来源 | Medium

编辑 | 代码医生团队

如果是深度学习和神经网络的新手，那么一定遇到过“ TensorFlow ”和“ PyTorch ” 这两个术语。这是在数据科学领域中使用的两个流行的深度学习框架。

在本练习中，将展示使用这两个框架实现的最简单的神经网络（线性回归）并比较其结果。

起源

PyTorch是基于Torch库的开源机器学习库。PyTorch主要由Facebook的AI研究实验室（FAIR）开发。它是一个免费的开源软件。

另一方面，TensorFlow由Google Brain团队开发，用于内部Google研究。它广泛用于机器学习应用程序，例如神经网络。它也是一个免费的开源软件。

比较两个框架的最有效的方法是使用两个框架来解决同一问题并分析其结果。在本练习中，将同时使用TensorFlow和PyTorch框架执行线性回归并比较其结果。

问题

在本练习中，将使用一个非常简单的示例。在这里，得到了一个数字数组，x = [-1.0，0.0，1.0，2.0，3.0，4.0]和y = [-3.0，-1.0，1.0，3.0，5.0，7.0]。在此使用的公式是y = 2 * x -1，它是线性回归。

x= [-1.0, 0.0, 1.0, 2.0, 3.0, 4.0]

y= [-3.0, -1.0, 1.0, 3.0, 5.0, 7.0]

y = 2*x -1

在使用两个框架训练线性回归模型时，将输入x = 10的新值，并查看该模型对y的预测。

TensorFlow框架

首先，将研究TensorFlow框架。

import tensorflow as tf
import numpy as np
from tensorflow import keras

model = tf.keras.Sequential([keras.layers.Dense(units=1, input_shape=[1])])

model.compile(optimizer='sgd', loss='mean_squared_error')

xs = np.array([-1.0,  0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)

model.fit(xs, ys, epochs=500)

print(model.predict([10.0]))

TensorFlow —线性回归

这是使用keras库使用TensorFlow执行线性回归的代码。遍历以上程序中的每个代码块。

第一步，将导入库。

import tensorflow as tf

import numpy as np

from tensorflow import keras

下一步，使用顺序模型设计模型，该模型是线性的层堆叠。在此模型中，仅使用一层（神经元）。

model = tf.keras.Sequential([keras.layers.Dense(units=1, input_shape=[1])])

在第二步中，定义优化器和损失函数以训练神经网络模型。在本文中，使用随机梯度下降（SDG）优化器和均方误差（MSE）作为损失函数。

model.compile(optimizer='sgd', loss='mean_squared_error')

在此步骤之后，使用两个变量“ xs ”和“ ys ” 初始化数字。

xs = np.array([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)

ys = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)

在最后一步，我们将模型拟合到变量“ xs”和“ ys”。以500个时期训练模型。

model.fit(xs, ys, epochs=500)

>>Epoch 500/500

1/1 [==============================] - 0s 1ms/step - loss: 5.1584e-05

在最后一步中，预测新的xs = 10的值。根据公式y = 2 * x-1，对于xs = 10，得到的值为19。现在看看使用TensorFlow框架创建的模型可以预测什么价值。

model.fit(xs, ys, epochs=500)

>>Epoch 500/500

1/1 [==============================] - 0s 1ms/step - loss: 5.1584e-05

看到，使用使用TensorFlow Framework设计的线性回归模型，得到的值接近19。

PyTorch框架

现在看看使用PyTorch框架设计的线性回归模型。

import torch
from torch.autograd import Variable


xs = [[-1.0],  [0.0], [1.0], [2.0], [3.0], [4.0]]
ys = [[-3.0], [-1.0], [1.0], [3.0], [5.0], [7.0]]

xs = Variable(torch.Tensor(xs))
ys = Variable(torch.Tensor(ys))

class LinearRegressionModel(torch.nn.Module):

    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = torch.nn.Linear(1, 1)

    def forward(self, x):
        y_pred = self.linear(x)
        return y_pred

model = LinearRegressionModel()

criterion = torch.nn.MSELoss(size_average = False)
optimizer = torch.optim.SGD(model.parameters(), lr = 0.01)

for epoch in range(500):
    pred_y = model(xs)
    loss = criterion(pred_y, ys)  
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    print('epoch {}, loss {}'.format(epoch, loss.item()))

new_var = Variable(torch.Tensor([[10.0]]))
pred_y = model(new_var)
print(model(new_var).item())

PyTorch —线性回归

与TensorFlow模型相比，线性回归的PyTorch应用程序确实庞大而复杂。分析模型的每个步骤。

第一步，导入设计线性回归模型所需的库。

import torch

from torch.autograd import Variable

在下一步中，初始化与TensorFlow模型中定义的“ xs ”和“ ys ” 相同的值。对于PyTorch应用程序，使用适当的函数将列表转换为Tensor 。

xs = [[-1.0], [0.0], [1.0], [2.0], [3.0], [4.0]]

ys = [[-3.0], [-1.0], [1.0], [3.0], [5.0], [7.0]]

xs = Variable(torch.Tensor(xs))

ys = Variable(torch.Tensor(ys))

此后定义一个类“ LinearRegressionModel ”，将使用该类来定义模型。由于这是具有1个输入和1个输出的简单线性回归，因此使用线性模型，其输入和输出维数均等于1。最后，使用上述定义的类创建“ 模型 ”。

class LinearRegressionModel(torch.nn.Module):

    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = torch.nn.Linear(1, 1)  # One in and one out

    def forward(self, x):
        y_pred = self.linear(x)
        return y_pred

model = LinearRegressionModel()

接下来，选择优化器和损失准则。选择了与TensorFlow应用程序相同的功能，即针对优化器的SDG功能和针对损失功能的MSE。此外，任意设定学习率为 0.01。

criterion = torch.nn.MSELoss(size_average = False)

optimizer = torch.optim.SGD(model.parameters(), lr = 0.01)

现在，进入训练步骤。在此阶段，将纪元值设置为500，从而执行了500次迭代的三个任务。

做一个直传通过将数据和预测YS每个XS的价值。
计算损失使用MSE损失函数。
将所有梯度重置为0，执行反向传播，最后更新权重。

for epoch in range(500):

    # Forward pass: Compute predicted y by passing  
    # x to the model
    pred_y = model(xs)

    # Compute and print loss
    loss = criterion(pred_y, ys)

    # Zero gradients, perform a backward pass,  
    # and update the weights.
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    print('epoch {}, loss {}'.format(epoch, loss.item()))
>>epoch 499, loss 5.151434834260726e-13

最后，使用该模型预测新的xs = 10的值。如前所述，必须获得接近19的值。现在看看PyTorch模型的输出。

new_var = Variable(torch.Tensor([[10.0]]))

pred_y = model(new_var)

print(model(new_var).item())

>>18.999998092651367

看到使用PyTorch框架构建的线性回归模型也提供了接近19的值。

比较

通过可视化从TensorFlow和PyTorch模型获得的结果，看到TensorFlow模型给结果为18.979048，而PyTorch模型结果为18.999998092651367。

TensorFlow模型— 18.979048

PyTorch模型— 18.999998092651367

可以清楚地看到，使用PyTorch框架构建的非常简单的神经网络比使用TensorFlow框架构建的模型具有更高的准确性。但是，PyTorch模型本质上更加复杂，初学者很难理解。

如果是深度学习和神经网络的新手，建议大家先从TensorFlow框架开始，然后在获得前者的经验后再转向PyTorch框架。