TensorFlow,Keras,PyTorch框架了解–实现线性回归

  • A+
所属分类:深度学习
摘要这一篇文章会介绍常用的三个深度学习的框架,TensorFlow、Keras和PyTorch。我会通过一个线性回归的例子来讲这三个框架的使用,把使用顺一遍。把三个框架放在一起,也是为了方便比较,和之后使用起来方便查找整体的流程。

前言

这一篇会使用TensorFlow,KerasPyTorch三种框架实现线性回归,也是作为简单了解一下这三种最常用的深度学习框架的使用。做这个线性回归,既可以顺一遍整个框架的流程,也不会太麻烦。

这三个框架,我个人使用起来觉得Keras是会方便一些(Keras底层是TensorFlow),只不过又做了一次封装。PyTorch使用起来也不是很麻烦。怎么说呢,多用几次,多看看文档,多了解一下框架设计的时候的想法。

之后的话会实现一些经典的神经网络。

三种框架实现线性回归

首先我们先准备一下数据集:

数据准备

我们首先准备好需要回归的数据,并用图形显示出来:

  1. import numpy as np
  2. from matplotlib import pyplot as plt
  3. %matplotlib inline
  4. np.random.seed(7)
  5. x = np.linspace(1, 10, 50)
  6. y = 2 * x + 3 * np.random.rand(50)
  7. plt.style.use("ggplot") # 使用美观的样式
  8. plt.scatter(x, y)
上海鲜花港 - 郁金香

下面我们依次按照TensorFlow,Keras和PyTorch这三个框架的顺序进行回归。

TensorFlow

  • TensorFlow文档
  • https://www.tensorflow.org/api_docs/python/
  1. import tensorflow as tf
  2. import os
  3. # --------
  4. # 初始化变量
  5. # --------
  6. X = x.reshape(-1,1)
  7. Y = y.reshape(-1,1)
  8. # 定义占位量,之后为了分批训练
  9. x_batch = tf.placeholder(tf.float32, [None, 1])
  10. y_batch = tf.placeholder(tf.float32, [None, 1])
  11. # 需要预测的数据
  12. X_pre = np.linspace(0, 11, 1000).reshape(-1,1)
  13. # ---------
  14. # 定义网络层
  15. # ---------
  16. dense_1 = tf.layers.dense(inputs=x_batch, units=1, activation=None)
  17. # ---------
  18. # 定义损失函数和优化器
  19. # ---------
  20. loss = tf.losses.mean_squared_error(labels=dense_1,predictions=y_batch)
  21. # 优化器
  22. learning_rate = 0.01
  23. optimizer = tf.train.GradientDescentOptimizer(learning_rate = learning_rate)
  24. training_op = optimizer.minimize(loss)
  25. # -------
  26. # 训练模型
  27. # -------
  28. batch_size = 25 # 定义batch_size
  29. init = tf.global_variables_initializer() # 之后可以对所有节点初始化
  30. n_epochs = 10
  31. loss_list = [] # 存储训练的误差
  32. with tf.Session() as sess:
  33.     sess.run(init)
  34.     for epochs in range(n_epochs):
  35.         train_batch = zip(range(0, len(x), batch_size), range(batch_size, len(x) + 1, batch_size))
  36.         i = 0
  37.         for start, end in train_batch:
  38.             X_batch = X[start:end] # 获得X的小批量训练数据
  39.             Y_batch = Y[start:end] # 获得Y的小批量训练数据
  40.             loss_epoch = sess.run(loss, feed_dict={x_batch: X_batch, y_batch: Y_batch}) # 计算误差
  41.             print("Epoch", epochs, 'i', i, "loss =", loss_epoch)
  42.             loss_list.append(loss_epoch)
  43.             sess.run(training_op, feed_dict={x_batch: X_batch, y_batch: Y_batch}) # 进行反向传播
  44.             i = i + 1
  45.     result = sess.run(dense_1, feed_dict={x_batch : X_pre})
  46. # ----------
  47. # 绘制预测图像
  48. # ----------
  49. plt.style.use("ggplot") # 使用美观的样式
  50. plt.scatter(x, y)
  51. plt.scatter(X_pre,result)

上面就是使用TensorFlow进行回归的整个流程,虽然只有50个数据,但是作为样例还是使用了batch进行训练。

我们看一下部分输出,训练10次,每次传入25个数据进行训练,从图像上看直线拟合效果还是很好的:

tensorflow

Keras

  1. from keras.models import Sequential
  2. from keras.layers import Dense
  3. # --------
  4. # 初始化数据
  5. # --------
  6. X = x # 就是numpy的类型
  7. Y = y
  8. # ------
  9. # 模型构建
  10. # ------
  11. model = Sequential() # 声明序贯模型
  12. # 这里input_dim为输入向量的维度,units为输出的维度
  13. model.add(Dense(input_dim=1, units=1))
  14. # -------
  15. # 定义模型的损失函数与优化器
  16. # -------
  17. model.compile(loss='mean_squared_error', optimizer='sgd')
  18. # -------
  19. # 模型训练
  20. # -------
  21. model.fit(X, Y, epochs=10, batch_size=32)
  22. # ----------
  23. # 画出拟合图像
  24. # ----------
  25. weight = model.get_weights()[0] # 权重
  26. bias = model.get_weights()[1] # 偏置项
  27. plt.style.use("ggplot") # 使用美观的样式
  28. plt.scatter(x, y)
  29. x_plot = np.linspace(1, 10, 500)
  30. print('weight : ', weight, 'bias : ', bias)
  31. plt.plot(x_plot, (weight*x_plot+bias).flatten(), c='black') # 这里要转为numpy才能绘制

可以看到Keras的代码会比上面使用TensorFlow少一些,同时使用Keras来设置批训练等是很方便的。我们这里训练了10次,可以看一下最后部分输出的结果和拟合的图像:

Keras

同样可以看到直线的拟合效果还是很不错的。

PyTorch

  • PyTorch文档
  • https://pytorch.org/docs/stable/index.html
  1. import torch as t
  2. import torch.nn as nn
  3. from torch.nn.functional import sigmoid
  4. from torch import optim
  5. from torch.autograd import Variable
  6. import torch.utils.data as Data
  7. # -------
  8. # 定义网络
  9. # -------
  10. class LinearRegressionModel(nn.Module):
  11.     def __init__(self):
  12.         super(LinearRegressionModel, self).__init__() # 等价于 nn.Module.__init__(self)
  13.         self.linear1 = nn.Linear(1, 1)
  14.     def forward(self, x):
  15.         out = self.linear1(x)
  16.         return out
  17. # ------
  18. # 定义损失函数和优化器
  19. # ------
  20. model = LinearRegressionModel() # 实例化模型
  21. loss_fn = nn.MSELoss(size_average=True# 定义损失函数,这里True表示会求平均
  22. optimiser = optim.SGD(params=model.parameters(), lr=0.01) # 定义优化器
  23. # ------
  24. # 定义变量
  25. # ------
  26. X = t.Tensor(x).reshape(-1,1) # 输入 x 张量
  27. # X = Variable(x.reshape(len(x),1)) # 也可以通过这种方式进行shape的转换
  28. Y = t.Tensor(y).reshape(-1,1) # 输入 y 张量
  29. # 使用batch训练
  30. torch_dataset = Data.TensorDataset(X, Y) # 合并训练数据和目标数据
  31. MINIBATCH_SIZE = 25
  32. loader = Data.DataLoader(
  33.     dataset=torch_dataset,
  34.     batch_size=MINIBATCH_SIZE,
  35.     shuffle=True,
  36.     num_workers=2           # set multi-work num read data
  37. )
  38. # ------
  39. # 进行训练
  40. # ------
  41. for epoch in range(100):
  42.     for step, (batch_x, batch_y) in enumerate(loader):
  43.         optimiser.zero_grad() # 梯度清零
  44.         out = model(batch_x) # 前向传播
  45.         loss = loss_fn(out, batch_y) # 计算损失
  46.         loss.backward() # 反向传播
  47.         optimiser.step() # 随机梯度下降
  48.         if epoch % 10 == 0:
  49.             print('epoch {}, step {}, loss {}'.format(epoch, step, loss.item()))
  50. # ----------
  51. # 画出拟合图像
  52. # ----------
  53. weight = model.state_dict()['linear1.weight'] # 权重
  54. bias = model.state_dict()['linear1.bias'] # 偏置项
  55. plt.style.use("ggplot") # 使用美观的样式
  56. plt.scatter(x, y)
  57. x_plot = np.linspace(1, 10, 500)
  58. # 注意下面的 tensor转numpy
  59. print('weight : ', weight, 'bias : ', bias)
  60. plt.plot(x_plot, (weight.numpy()*x_plot+bias.numpy()).flatten(), c='black') # 这里要转为numpy才能绘制

上面是使用PyTorch进行回归分析,这里训练了100次,可以看一下最后的效果:

PyTorch

结语

到这里使用三种框架来完成线性回归的工作就已经完成了,把这三个写在一起也是为了方便我的比较和查找。

之后的话我会找一些论文里经典的网络来实现以下,顺便看看别人论文的结构之类的,就先写这么多了,之后慢慢更新。

  • 微信公众号
  • 关注微信公众号
  • weinxin
  • QQ群
  • 我们的QQ群号
  • weinxin
王 茂南

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: