From 4cf056027c05dcb4e9b79f9f07adbbb465f294f5 Mon Sep 17 00:00:00 2001 From: Shuhui Bu Date: Sun, 30 Sep 2018 18:15:29 +0800 Subject: [PATCH] Add pytorch linear_regression and poly_fitting --- 2_pytorch/0_basic/autograd.ipynb | 2 +- 2_pytorch/0_basic/autograd.py | 220 +++++++++++++ .../1_NN/linear-regression-gradient-descend.ipynb | 234 +++++++------- .../1_NN/linear-regression-gradient-descend.py | 355 +++++++++++++++++++++ demo_code/2_linear_regression.py | 72 +++++ demo_code/2_linear_regression_0.py | 92 ++++++ demo_code/2_poly_fitting.py | 77 +++++ demo_code/2_poly_fitting_0.py | 105 ++++++ demo_code/CNN_CIFAR.py | 4 +- demo_code/Neural_Network.0.py | 93 +++--- demo_code/{Nerual_Network.py => Neural_Network.py} | 30 +- tips/pytorch/tensor_divide_int.py | 6 + 12 files changed, 1106 insertions(+), 184 deletions(-) create mode 100644 2_pytorch/0_basic/autograd.py create mode 100644 2_pytorch/1_NN/linear-regression-gradient-descend.py create mode 100644 demo_code/2_linear_regression.py create mode 100644 demo_code/2_linear_regression_0.py create mode 100644 demo_code/2_poly_fitting.py create mode 100644 demo_code/2_poly_fitting_0.py rename demo_code/{Nerual_Network.py => Neural_Network.py} (82%) create mode 100644 tips/pytorch/tensor_divide_int.py diff --git a/2_pytorch/0_basic/autograd.ipynb b/2_pytorch/0_basic/autograd.ipynb index e236fbd..7e22996 100644 --- a/2_pytorch/0_basic/autograd.ipynb +++ b/2_pytorch/0_basic/autograd.ipynb @@ -645,7 +645,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.3" + "version": "3.5.2" } }, "nbformat": 4, diff --git a/2_pytorch/0_basic/autograd.py b/2_pytorch/0_basic/autograd.py new file mode 100644 index 0000000..dbb8431 --- /dev/null +++ b/2_pytorch/0_basic/autograd.py @@ -0,0 +1,220 @@ +# -*- coding: utf-8 -*- +# --- +# jupyter: +# jupytext_format_version: '1.2' +# kernelspec: +# display_name: Python 3 +# language: python +# name: python3 +# language_info: +# codemirror_mode: +# name: ipython +# version: 3 +# file_extension: .py +# mimetype: text/x-python +# name: python +# nbconvert_exporter: python +# pygments_lexer: ipython3 +# version: 3.5.2 +# --- + +# # 自动求导 +# 这次课程我们会了解 PyTorch 中的自动求导机制，自动求导是 PyTorch 中非常重要的特性，能够让我们避免手动去计算非常复杂的导数，这能够极大地减少了我们构建模型的时间，这也是其前身 Torch 这个框架所不具备的特性，下面我们通过例子看看 PyTorch 自动求导的独特魅力以及探究自动求导的更多用法。 + +import torch +from torch.autograd import Variable + +# ## 简单情况的自动求导 +# 下面我们显示一些简单情况的自动求导，"简单"体现在计算的结果都是标量，也就是一个数，我们对这个标量进行自动求导。 + +x = Variable(torch.Tensor([2]), requires_grad=True) +y = x + 2 +z = y ** 2 + 3 +print(z) + +# 通过上面的一些列操作，我们从 x 得到了最后的结果out，我们可以将其表示为数学公式 +# +# $$ +# z = (x + 2)^2 + 3 +# $$ +# +# 那么我们从 z 对 x 求导的结果就是 +# +# $$ +# \frac{\partial z}{\partial x} = 2 (x + 2) = 2 (2 + 2) = 8 +# $$ +# 如果你对求导不熟悉，可以查看以下[网址进行复习](https://baike.baidu.com/item/%E5%AF%BC%E6%95%B0#1) + +# 使用自动求导 +z.backward() +print(x.grad) + +# 对于上面这样一个简单的例子，我们验证了自动求导，同时可以发现发现使用自动求导非常方便。如果是一个更加复杂的例子，那么手动求导就会显得非常的麻烦，所以自动求导的机制能够帮助我们省去麻烦的数学计算，下面我们可以看一个更加复杂的例子。 + +# + +x = Variable(torch.randn(10, 20), requires_grad=True) +y = Variable(torch.randn(10, 5), requires_grad=True) +w = Variable(torch.randn(20, 5), requires_grad=True) + +out = torch.mean(y - torch.matmul(x, w)) # torch.matmul 是做矩阵乘法 +out.backward() +# - + +# 如果你对矩阵乘法不熟悉，可以查看下面的[网址进行复习](https://baike.baidu.com/item/%E7%9F%A9%E9%98%B5%E4%B9%98%E6%B3%95/5446029?fr=aladdin) + +# 得到 x 的梯度 +print(x.grad) + +# 得到 y 的的梯度 +print(y.grad) + +# 得到 w 的梯度 +print(w.grad) + +# 上面数学公式就更加复杂，矩阵乘法之后对两个矩阵对应元素相乘，然后所有元素求平均，有兴趣的同学可以手动去计算一下梯度，使用 PyTorch 的自动求导，我们能够非常容易得到 x, y 和 w 的导数，因为深度学习中充满大量的矩阵运算，所以我们没有办法手动去求这些导数，有了自动求导能够非常方便地解决网络更新的问题。 + +# +# + +# ## 复杂情况的自动求导 +# 上面我们展示了简单情况下的自动求导，都是对标量进行自动求导，可能你会有一个疑问，如何对一个向量或者矩阵自动求导了呢？感兴趣的同学可以自己先去尝试一下，下面我们会介绍对多维数组的自动求导机制。 + +m = Variable(torch.FloatTensor([[2, 3]]), requires_grad=True) # 构建一个 1 x 2 的矩阵 +n = Variable(torch.zeros(1, 2)) # 构建一个相同大小的 0 矩阵 +print(m) +print(n) + +# 通过 m 中的值计算新的 n 中的值 +n[0, 0] = m[0, 0] ** 2 +n[0, 1] = m[0, 1] ** 3 +print(n) + +# 将上面的式子写成数学公式，可以得到 +# $$ +# n = (n_0,\ n_1) = (m_0^2,\ m_1^3) = (2^2,\ 3^3) +# $$ + +# 下面我们直接对 n 进行反向传播，也就是求 n 对 m 的导数。 +# +# 这时我们需要明确这个导数的定义，即如何定义 +# +# $$ +# \frac{\partial n}{\partial m} = \frac{\partial (n_0,\ n_1)}{\partial (m_0,\ m_1)} +# $$ +# + +# 在 PyTorch 中，如果要调用自动求导，需要往`backward()`中传入一个参数，这个参数的形状和 n 一样大，比如是 $(w_0,\ w_1)$，那么自动求导的结果就是： +# $$ +# \frac{\partial n}{\partial m_0} = w_0 \frac{\partial n_0}{\partial m_0} + w_1 \frac{\partial n_1}{\partial m_0} +# $$ +# $$ +# \frac{\partial n}{\partial m_1} = w_0 \frac{\partial n_0}{\partial m_1} + w_1 \frac{\partial n_1}{\partial m_1} +# $$ + +n.backward(torch.ones_like(n)) # 将 (w0, w1) 取成 (1, 1) + +print(m.grad) + +# 通过自动求导我们得到了梯度是 4 和 27，我们可以验算一下 +# $$ +# \frac{\partial n}{\partial m_0} = w_0 \frac{\partial n_0}{\partial m_0} + w_1 \frac{\partial n_1}{\partial m_0} = 2 m_0 + 0 = 2 \times 2 = 4 +# $$ +# $$ +# \frac{\partial n}{\partial m_1} = w_0 \frac{\partial n_0}{\partial m_1} + w_1 \frac{\partial n_1}{\partial m_1} = 0 + 3 m_1^2 = 3 \times 3^2 = 27 +# $$ +# 通过验算我们可以得到相同的结果 + +# +# + +# ## 多次自动求导 +# 通过调用 backward 我们可以进行一次自动求导，如果我们再调用一次 backward，会发现程序报错，没有办法再做一次。这是因为 PyTorch 默认做完一次自动求导之后，计算图就被丢弃了，所以两次自动求导需要手动设置一个东西，我们通过下面的小例子来说明。 + +x = Variable(torch.FloatTensor([3]), requires_grad=True) +y = x * 2 + x ** 2 + 3 +print(y) + +y.backward(retain_graph=True) # 设置 retain_graph 为 True 来保留计算图 + +print(x.grad) + +y.backward() # 再做一次自动求导，这次不保留计算图 + +print(x.grad) + +# 可以发现 x 的梯度变成了 16，因为这里做了两次自动求导，所以讲第一次的梯度 8 和第二次的梯度 8 加起来得到了 16 的结果。 + +# +# + +# **小练习** +# +# 定义 +# +# $$ +# x = +# \left[ +# \begin{matrix} +# x_0 \\ +# x_1 +# \end{matrix} +# \right] = +# \left[ +# \begin{matrix} +# 2 \\ +# 3 +# \end{matrix} +# \right] +# $$ +# +# $$ +# k = (k_0,\ k_1) = (x_0^2 + 3 x_1,\ 2 x_0 + x_1^2) +# $$ +# +# 我们希望求得 +# +# $$ +# j = \left[ +# \begin{matrix} +# \frac{\partial k_0}{\partial x_0} & \frac{\partial k_0}{\partial x_1} \\ +# \frac{\partial k_1}{\partial x_0} & \frac{\partial k_1}{\partial x_1} +# \end{matrix} +# \right] +# $$ +# +# 参考答案： +# +# $$ +# \left[ +# \begin{matrix} +# 4 & 3 \\ +# 2 & 6 \\ +# \end{matrix} +# \right] +# $$ + +# + +x = Variable(torch.FloatTensor([2, 3]), requires_grad=True) +k = Variable(torch.zeros(2)) + +k[0] = x[0] ** 2 + 3 * x[1] +k[1] = x[1] ** 2 + 2 * x[0] +# - + +print(k) + +# + +j = torch.zeros(2, 2) + +k.backward(torch.FloatTensor([1, 0]), retain_graph=True) +j[0] = x.grad.data + +x.grad.data.zero_() # 归零之前求得的梯度 + +k.backward(torch.FloatTensor([0, 1])) +j[1] = x.grad.data +# - + +print(j) + +# 下一次课我们会介绍两种神经网络的编程方式，动态图编程和静态图编程 diff --git a/2_pytorch/1_NN/linear-regression-gradient-descend.ipynb b/2_pytorch/1_NN/linear-regression-gradient-descend.ipynb index 8f25d9a..134ce60 100644 --- a/2_pytorch/1_NN/linear-regression-gradient-descend.ipynb +++ b/2_pytorch/1_NN/linear-regression-gradient-descend.ipynb @@ -128,7 +128,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 1, @@ -147,9 +147,7 @@ { "cell_type": "code", "execution_count": 2, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "# 读入数据 x 和 y\n", @@ -170,7 +168,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 3, @@ -179,12 +177,14 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -199,9 +199,7 @@ { "cell_type": "code", "execution_count": 4, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "# 转换成 Tensor\n", @@ -216,9 +214,7 @@ { "cell_type": "code", "execution_count": 5, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "# 构建线性回归模型\n", @@ -232,9 +228,7 @@ { "cell_type": "code", "execution_count": 6, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "y_ = linear_model(x_train)" @@ -255,7 +249,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 7, @@ -264,12 +258,14 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD8CAYAAABn919SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nEOgAEIj/B0G15NO6D6dTAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -305,7 +301,7 @@ "source": [ "# 计算误差\n", "def get_loss(y_, y):\n", - " return torch.mean((y_ - y_train) ** 2)\n", + " return torch.mean((y_ - y) ** 2)\n", "\n", "loss = get_loss(y_, y_train)" ] @@ -319,10 +315,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Variable containing:\n", - " 153.3520\n", - "[torch.FloatTensor of size 1]\n", - "\n" + "tensor(153.3520, grad_fn=)\n" ] } ], @@ -346,9 +339,7 @@ { "cell_type": "code", "execution_count": 10, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "# 自动求导\n", @@ -364,14 +355,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Variable containing:\n", - " 161.0043\n", - "[torch.FloatTensor of size 1]\n", - "\n", - "Variable containing:\n", - " 22.8730\n", - "[torch.FloatTensor of size 1]\n", - "\n" + "tensor([161.0043])\n", + "tensor([22.8730])\n" ] } ], @@ -383,7 +368,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -401,27 +386,29 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 13, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAD8CAYAAABXe05zAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -441,23 +428,31 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "epoch: 0, loss: 3.1357719898223877\n", - "epoch: 1, loss: 0.3550889194011688\n", - "epoch: 2, loss: 0.30295443534851074\n", - "epoch: 3, loss: 0.30131956934928894\n", - "epoch: 4, loss: 0.3006229102611542\n", - "epoch: 5, loss: 0.29994693398475647\n", - "epoch: 6, loss: 0.299274742603302\n", - "epoch: 7, loss: 0.2986060082912445\n", - "epoch: 8, loss: 0.2979407012462616\n", - "epoch: 9, loss: 0.29727882146835327\n" + "epoch: 0, loss: 0.2959636151790619\n", + "epoch: 1, loss: 0.2953118681907654\n", + "epoch: 2, loss: 0.2946634888648987\n", + "epoch: 3, loss: 0.29401835799217224\n", + "epoch: 4, loss: 0.2933765947818756\n", + "epoch: 5, loss: 0.292738139629364\n", + "epoch: 6, loss: 0.29210299253463745\n", + "epoch: 7, loss: 0.29147112369537354\n", + "epoch: 8, loss: 0.2908424139022827\n", + "epoch: 9, loss: 0.29021692276000977\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/bushuhui/.virtualenv/dl/lib/python3.5/site-packages/ipykernel_launcher.py:11: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n", + " # This is added back by InteractiveShellApp.init_path()\n" ] } ], @@ -477,27 +472,29 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 15, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nUdOFjLYuAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -568,7 +565,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -600,27 +597,29 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 17, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD8CAYAAAB0IB+mAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIpIk/j8hjlpJApitKgAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -642,10 +641,8 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": { - "collapsed": true - }, + "execution_count": 24, + "metadata": {}, "outputs": [], "source": [ "# 构建数据 x 和 y\n", @@ -667,7 +664,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -692,27 +689,29 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 20, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD8CAYAAAB0IB+mAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nEr4xxsQIS/jGGBMj/h9fRUynBRhSVgAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -734,17 +733,14 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Variable containing:\n", - " 413.9843\n", - "[torch.FloatTensor of size 1]\n", - "\n" + "tensor(413.9844, grad_fn=)\n" ] } ], @@ -756,10 +752,8 @@ }, { "cell_type": "code", - "execution_count": 22, - "metadata": { - "collapsed": true - }, + "execution_count": 28, + "metadata": {}, "outputs": [], "source": [ "# 自动求导\n", @@ -768,23 +762,17 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Variable containing:\n", - " -34.1391\n", - "-146.6133\n", - "-215.9148\n", - "[torch.FloatTensor of size 3x1]\n", - "\n", - "Variable containing:\n", - "-27.0838\n", - "[torch.FloatTensor of size 1]\n", - "\n" + "tensor([[ -34.1391],\n", + " [-146.6133],\n", + " [-215.9149]])\n", + "tensor([-27.0838])\n" ] } ], @@ -796,10 +784,8 @@ }, { "cell_type": "code", - "execution_count": 24, - "metadata": { - "collapsed": true - }, + "execution_count": 30, + "metadata": {}, "outputs": [], "source": [ "# 更新一下参数\n", @@ -809,27 +795,29 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 25, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD8CAYAAAB0IB+mAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n/JAtQgAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -851,19 +839,27 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "epoch 20, Loss: 73.67840\n", - "epoch 40, Loss: 17.97097\n", + "epoch 20, Loss: 73.67843\n", + "epoch 40, Loss: 17.97095\n", "epoch 60, Loss: 4.94101\n", "epoch 80, Loss: 1.87171\n", "epoch 100, Loss: 1.12812\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/bushuhui/.virtualenv/dl/lib/python3.5/site-packages/ipykernel_launcher.py:14: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n", + " \n" + ] } ], "source": [ @@ -892,27 +888,29 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 27, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD8CAYAAAB0IB+mAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\neQAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], diff --git a/2_pytorch/1_NN/linear-regression-gradient-descend.py b/2_pytorch/1_NN/linear-regression-gradient-descend.py new file mode 100644 index 0000000..f0386de --- /dev/null +++ b/2_pytorch/1_NN/linear-regression-gradient-descend.py @@ -0,0 +1,355 @@ +# -*- coding: utf-8 -*- +# --- +# jupyter: +# jupytext_format_version: '1.2' +# kernelspec: +# display_name: Python 3 +# language: python +# name: python3 +# language_info: +# codemirror_mode: +# name: ipython +# version: 3 +# file_extension: .py +# mimetype: text/x-python +# name: python +# nbconvert_exporter: python +# pygments_lexer: ipython3 +# version: 3.5.2 +# --- + +# # 线性模型和梯度下降 +# 这是神经网络的第一课，我们会学习一个非常简单的模型，线性回归，同时也会学习一个优化算法-梯度下降法，对这个模型进行优化。线性回归是监督学习里面一个非常简单的模型，同时梯度下降也是深度学习中应用最广的优化算法，我们将从这里开始我们的深度学习之旅 + +# +# + +# ## 一元线性回归 +# 一元线性模型非常简单，假设我们有变量 $x_i$ 和目标 $y_i$，每个 i 对应于一个数据点，希望建立一个模型 +# +# $$ +# \hat{y}_i = w x_i + b +# $$ +# +# $\hat{y}_i$ 是我们预测的结果，希望通过 $\hat{y}_i$ 来拟合目标 $y_i$，通俗来讲就是找到这个函数拟合 $y_i$ 使得误差最小，即最小化 +# +# $$ +# \frac{1}{n} \sum_{i=1}^n(\hat{y}_i - y_i)^2 +# $$ + +# 那么如何最小化这个误差呢？ +# +# 这里需要用到**梯度下降**，这是我们接触到的第一个优化算法，非常简单，但是却非常强大，在深度学习中被大量使用，所以让我们从简单的例子出发了解梯度下降法的原理 + +# ## 梯度下降法 +# 在梯度下降法中，我们首先要明确梯度的概念，随后我们再了解如何使用梯度进行下降。 + +# ### 梯度 +# 梯度在数学上就是导数，如果是一个多元函数，那么梯度就是偏导数。比如一个函数f(x, y)，那么 f 的梯度就是 +# +# $$ +# (\frac{\partial f}{\partial x},\ \frac{\partial f}{\partial y}) +# $$ +# +# 可以称为 grad f(x, y) 或者 $\nabla f(x, y)$。具体某一点 $(x_0,\ y_0)$ 的梯度就是 $\nabla f(x_0,\ y_0)$。 +# +# 下面这个图片是 $f(x) = x^2$ 这个函数在 x=1 处的梯度 +# +# ![](https://ws3.sinaimg.cn/large/006tNc79ly1fmarbuh2j3j30ba0b80sy.jpg) + +# 梯度有什么意义呢？从几何意义来讲，一个点的梯度值是这个函数变化最快的地方，具体来说，对于函数 f(x, y)，在点 $(x_0, y_0)$ 处，沿着梯度 $\nabla f(x_0,\ y_0)$ 的方向，函数增加最快，也就是说沿着梯度的方向，我们能够更快地找到函数的极大值点，或者反过来沿着梯度的反方向，我们能够更快地找到函数的最小值点。 + +# ### 梯度下降法 +# 有了对梯度的理解，我们就能了解梯度下降发的原理了。上面我们需要最小化这个误差，也就是需要找到这个误差的最小值点，那么沿着梯度的反方向我们就能够找到这个最小值点。 +# +# 我们可以来看一个直观的解释。比如我们在一座大山上的某处位置，由于我们不知道怎么下山，于是决定走一步算一步，也就是在每走到一个位置的时候，求解当前位置的梯度，沿着梯度的负方向，也就是当前最陡峭的位置向下走一步，然后继续求解当前位置梯度，向这一步所在位置沿着最陡峭最易下山的位置走一步。这样一步步的走下去，一直走到觉得我们已经到了山脚。当然这样走下去，有可能我们不能走到山脚，而是到了某一个局部的山峰低处。 +# +# 类比我们的问题，就是沿着梯度的反方向，我们不断改变 w 和 b 的值，最终找到一组最好的 w 和 b 使得误差最小。 +# +# 在更新的时候，我们需要决定每次更新的幅度，比如在下山的例子中，我们需要每次往下走的那一步的长度，这个长度称为学习率，用 $\eta$ 表示，这个学习率非常重要，不同的学习率都会导致不同的结果，学习率太小会导致下降非常缓慢，学习率太大又会导致跳动非常明显，可以看看下面的例子 +# +# ![](https://ws2.sinaimg.cn/large/006tNc79ly1fmgn23lnzjg30980gogso.gif) +# +# 可以看到上面的学习率较为合适，而下面的学习率太大，就会导致不断跳动 +# +# 最后我们的更新公式就是 +# +# $$ +# w := w - \eta \frac{\partial f(w,\ b)}{\partial w} \\ +# b := b - \eta \frac{\partial f(w,\ b)}{\partial b} +# $$ +# +# 通过不断地迭代更新，最终我们能够找到一组最优的 w 和 b，这就是梯度下降法的原理。 +# +# 最后可以通过这张图形象地说明一下这个方法 +# +# ![](https://ws3.sinaimg.cn/large/006tNc79ly1fmarxsltfqj30gx091gn4.jpg) + +# +# + +# 上面是原理部分，下面通过一个例子来进一步学习线性模型 + +# + +import torch +import numpy as np +from torch.autograd import Variable + +torch.manual_seed(2017) + +# + +# 读入数据 x 和 y +x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168], + [9.779], [6.182], [7.59], [2.167], [7.042], + [10.791], [5.313], [7.997], [3.1]], dtype=np.float32) + +y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573], + [3.366], [2.596], [2.53], [1.221], [2.827], + [3.465], [1.65], [2.904], [1.3]], dtype=np.float32) + +# + +# 画出图像 +import matplotlib.pyplot as plt +# %matplotlib inline + +plt.plot(x_train, y_train, 'bo') + +# + +# 转换成 Tensor +x_train = torch.from_numpy(x_train) +y_train = torch.from_numpy(y_train) + +# 定义参数 w 和 b +w = Variable(torch.randn(1), requires_grad=True) # 随机初始化 +b = Variable(torch.zeros(1), requires_grad=True) # 使用 0 进行初始化 + +# + +# 构建线性回归模型 +x_train = Variable(x_train) +y_train = Variable(y_train) + +def linear_model(x): + return x * w + b +# - + +y_ = linear_model(x_train) + +# 经过上面的步骤我们就定义好了模型，在进行参数更新之前，我们可以先看看模型的输出结果长什么样 + +plt.plot(x_train.data.numpy(), y_train.data.numpy(), 'bo', label='real') +plt.plot(x_train.data.numpy(), y_.data.numpy(), 'ro', label='estimated') +plt.legend() + +# **思考：红色的点表示预测值，似乎排列成一条直线，请思考一下这些点是否在一条直线上？** + +# 这个时候需要计算我们的误差函数，也就是 +# +# $$ +# \frac{1}{n} \sum_{i=1}^n(\hat{y}_i - y_i)^2 +# $$ + +# + +# 计算误差 +def get_loss(y_, y): + return torch.mean((y_ - y) ** 2) + +loss = get_loss(y_, y_train) +# - + +# 打印一下看看 loss 的大小 +print(loss) + +# 定义好了误差函数，接下来我们需要计算 w 和 b 的梯度了，这时得益于 PyTorch 的自动求导，我们不需要手动去算梯度，有兴趣的同学可以手动计算一下，w 和 b 的梯度分别是 +# +# $$ +# \frac{\partial}{\partial w} = \frac{2}{n} \sum_{i=1}^n x_i(w x_i + b - y_i) \\ +# \frac{\partial}{\partial b} = \frac{2}{n} \sum_{i=1}^n (w x_i + b - y_i) +# $$ + +# 自动求导 +loss.backward() + +# 查看 w 和 b 的梯度 +print(w.grad) +print(b.grad) + +# 更新一次参数 +w.data = w.data - 1e-2 * w.grad.data +b.data = b.data - 1e-2 * b.grad.data + +# 更新完成参数之后，我们再一次看看模型输出的结果 + +y_ = linear_model(x_train) +plt.plot(x_train.data.numpy(), y_train.data.numpy(), 'bo', label='real') +plt.plot(x_train.data.numpy(), y_.data.numpy(), 'ro', label='estimated') +plt.legend() + +# 从上面的例子可以看到，更新之后红色的线跑到了蓝色的线下面，没有特别好的拟合蓝色的真实值，所以我们需要在进行几次更新 + +for e in range(10): # 进行 10 次更新 + y_ = linear_model(x_train) + loss = get_loss(y_, y_train) + + w.grad.zero_() # 记得归零梯度 + b.grad.zero_() # 记得归零梯度 + loss.backward() + + w.data = w.data - 1e-2 * w.grad.data # 更新 w + b.data = b.data - 1e-2 * b.grad.data # 更新 b + print('epoch: {}, loss: {}'.format(e, loss.data[0])) + +y_ = linear_model(x_train) +plt.plot(x_train.data.numpy(), y_train.data.numpy(), 'bo', label='real') +plt.plot(x_train.data.numpy(), y_.data.numpy(), 'ro', label='estimated') +plt.legend() + +# 经过 10 次更新，我们发现红色的预测结果已经比较好的拟合了蓝色的真实值。 +# +# 现在你已经学会了你的第一个机器学习模型了，再接再厉，完成下面的小练习。 + +# **小练习：** +# +# 重启 notebook 运行上面的线性回归模型，但是改变训练次数以及不同的学习率进行尝试得到不同的结果 + +# ## 多项式回归模型 + +# 下面我们更进一步，讲一讲多项式回归。什么是多项式回归呢？非常简单，根据上面的线性回归模型 +# +# $$ +# \hat{y} = w x + b +# $$ +# +# 这里是关于 x 的一个一次多项式，这个模型比较简单，没有办法拟合比较复杂的模型，所以我们可以使用更高次的模型，比如 +# +# $$ +# \hat{y} = w_0 + w_1 x + w_2 x^2 + w_3 x^3 + \cdots +# $$ +# +# 这样就能够拟合更加复杂的模型，这就是多项式模型，这里使用了 x 的更高次，同理还有多元回归模型，形式也是一样的，只是出了使用 x，还是更多的变量，比如 y、z 等等，同时他们的 loss 函数和简单的线性回归模型是一致的。 + +# +# + +# 首先我们可以先定义一个需要拟合的目标函数，这个函数是个三次的多项式 + +# + +# 定义一个多变量函数 + +w_target = np.array([0.5, 3, 2.4]) # 定义参数 +b_target = np.array([0.9]) # 定义参数 + +f_des = 'y = {:.2f} + {:.2f} * x + {:.2f} * x^2 + {:.2f} * x^3'.format( + b_target[0], w_target[0], w_target[1], w_target[2]) # 打印出函数的式子 + +print(f_des) +# - + +# 我们可以先画出这个多项式的图像 + +# + +# 画出这个函数的曲线 +x_sample = np.arange(-3, 3.1, 0.1) +y_sample = b_target[0] + w_target[0] * x_sample + w_target[1] * x_sample ** 2 + w_target[2] * x_sample ** 3 + +plt.plot(x_sample, y_sample, label='real curve') +plt.legend() +# - + +# 接着我们可以构建数据集，需要 x 和 y，同时是一个三次多项式，所以我们取了 $x,\ x^2, x^3$ + +# + +# 构建数据 x 和 y +# x 是一个如下矩阵 [x, x^2, x^3] +# y 是函数的结果 [y] + +x_train = np.stack([x_sample ** i for i in range(1, 4)], axis=1) +x_train = torch.from_numpy(x_train).float() # 转换成 float tensor + +y_train = torch.from_numpy(y_sample).float().unsqueeze(1) # 转化成 float tensor +# - + +# 接着我们可以定义需要优化的参数，就是前面这个函数里面的 $w_i$ + +# + +# 定义参数和模型 +w = Variable(torch.randn(3, 1), requires_grad=True) +b = Variable(torch.zeros(1), requires_grad=True) + +# 将 x 和 y 转换成 Variable +x_train = Variable(x_train) +y_train = Variable(y_train) + +def multi_linear(x): + return torch.mm(x, w) + b +# - + +# 我们可以画出没有更新之前的模型和真实的模型之间的对比 + +# + +# 画出更新之前的模型 +y_pred = multi_linear(x_train) + +plt.plot(x_train.data.numpy()[:, 0], y_pred.data.numpy(), label='fitting curve', color='r') +plt.plot(x_train.data.numpy()[:, 0], y_sample, label='real curve', color='b') +plt.legend() +# - + +# 可以发现，这两条曲线之间存在差异，我们计算一下他们之间的误差 + +# 计算误差，这里的误差和一元的线性模型的误差是相同的，前面已经定义过了 get_loss +loss = get_loss(y_pred, y_train) +print(loss) + +# 自动求导 +loss.backward() + +# 查看一下 w 和 b 的梯度 +print(w.grad) +print(b.grad) + +# 更新一下参数 +w.data = w.data - 0.001 * w.grad.data +b.data = b.data - 0.001 * b.grad.data + +# + +# 画出更新一次之后的模型 +y_pred = multi_linear(x_train) + +plt.plot(x_train.data.numpy()[:, 0], y_pred.data.numpy(), label='fitting curve', color='r') +plt.plot(x_train.data.numpy()[:, 0], y_sample, label='real curve', color='b') +plt.legend() +# - + +# 因为只更新了一次，所以两条曲线之间的差异仍然存在，我们进行 100 次迭代 + +# 进行 100 次参数更新 +for e in range(100): + y_pred = multi_linear(x_train) + loss = get_loss(y_pred, y_train) + + w.grad.data.zero_() + b.grad.data.zero_() + loss.backward() + + # 更新参数 + w.data = w.data - 0.001 * w.grad.data + b.data = b.data - 0.001 * b.grad.data + if (e + 1) % 20 == 0: + print('epoch {}, Loss: {:.5f}'.format(e+1, loss.data[0])) + +# 可以看到更新完成之后 loss 已经非常小了，我们画出更新之后的曲线对比 + +# + +# 画出更新之后的结果 +y_pred = multi_linear(x_train) + +plt.plot(x_train.data.numpy()[:, 0], y_pred.data.numpy(), label='fitting curve', color='r') +plt.plot(x_train.data.numpy()[:, 0], y_sample, label='real curve', color='b') +plt.legend() +# - + +# 可以看到，经过 100 次更新之后，可以看到拟合的线和真实的线已经完全重合了 + +# **小练习：上面的例子是一个三次的多项式，尝试使用二次的多项式去拟合它，看看最后能做到多好** +# +# **提示：参数 `w = torch.randn(2, 1)`，同时重新构建 x 数据集** diff --git a/demo_code/2_linear_regression.py b/demo_code/2_linear_regression.py new file mode 100644 index 0000000..d1cd8f0 --- /dev/null +++ b/demo_code/2_linear_regression.py @@ -0,0 +1,72 @@ + +import numpy as np + +import torch +from torch.autograd import Variable + +import matplotlib.pyplot as plt + +""" +Using pytorch to do linear regression +""" + +torch.manual_seed(2018) + +# model's real-parameters +w_target = 3 +b_target = 10 + +# generate data +n_data = 100 +x_train = np.random.rand(n_data, 1)*20 - 10 +y_train = w_target*x_train + b_target + (np.random.randn(n_data, 1)*10-5.0) + +# draw the data +plt.plot(x_train, y_train, 'bo') +plt.show() + + +# convert to tensor +x_train = torch.from_numpy(x_train).float() +y_train = torch.from_numpy(y_train).float() + +# define model parameters +w = Variable(torch.randn(1).float(), requires_grad=True) +b = Variable(torch.zeros(1).float(), requires_grad=True) + +# construct the linear model +x_train = Variable(x_train) +y_train = Variable(y_train) + + +# define model's function +def linear_model(x): + return x*w + b + +# define the loss function +def get_loss(y_pred, y): + return torch.mean((y_pred - y)**2) + +# upgrade parameters +eta = 1e-2 + +for i in range(100): + y_pred = linear_model(x_train) + + loss = get_loss(y_pred, y_train) + loss.backward() + + w.data = w.data - eta*w.grad.data + b.data = b.data - eta*b.grad.data + + w.grad.zero_() + b.grad.zero_() + + if i % 10 == 0: + print("epoch: %3d, loss: %f" % (i, loss.data[0])) + +# draw the results +plt.plot(x_train.data.numpy(), y_train.data.numpy(), 'bo', label="Real") +plt.plot(x_train.data.numpy(), y_pred.data.numpy(), 'ro', label="Estimated") +plt.legend() +plt.show() \ No newline at end of file diff --git a/demo_code/2_linear_regression_0.py b/demo_code/2_linear_regression_0.py new file mode 100644 index 0000000..2fede4e --- /dev/null +++ b/demo_code/2_linear_regression_0.py @@ -0,0 +1,92 @@ + +import numpy as np + +import torch +from torch.autograd import Variable + +import matplotlib.pyplot as plt + +""" +Using pytorch to do linear regression +""" + +torch.manual_seed(2018) + +# generate data +x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168], + [9.779], [6.182], [7.59], [2.167], [7.042], + [10.791], [5.313], [7.997], [3.1]], dtype=np.float32) + +y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573], + [3.366], [2.596], [2.53], [1.221], [2.827], + [3.465], [1.65], [2.904], [1.3]], dtype=np.float32) + + +# draw the data +plt.plot(x_train, y_train, 'bo') +plt.show() + + +# convert to tensor +x_train = torch.from_numpy(x_train) +y_train = torch.from_numpy(y_train) + +# define model parameters +w = Variable(torch.randn(1), requires_grad=True) +b = Variable(torch.zeros(1), requires_grad=True) + +# construct the linear model +x_train = Variable(x_train) +y_train = Variable(y_train) + +def linear_model(x): + return x*w + b + +# first predictive +y_pred = linear_model(x_train) + +# draw the real & predictived data +plt.plot(x_train.data.numpy(), y_train.data.numpy(), 'bo', label="Real") +plt.plot(x_train.data.numpy(), y_pred.data.numpy(), 'ro', label="Estimated") +plt.legend() +plt.show() + +# define the loss function +def get_loss(y_pred, y): + return torch.mean((y_pred - y)**2) + +loss = get_loss(y_pred, y_train) +print("loss = %f" % float(loss)) + + +# auto-grad +loss.backward() +print("w.grad = %f" % float(w.grad)) +print("b.grad = %f" % float(b.grad)) + +# upgrade parameters +eta = 1e-2 + +w.data = w.data - eta*w.grad.data +b.data = b.data - eta*w.grad.data + +y_pred = linear_model(x_train) +plt.plot(x_train.data.numpy(), y_train.data.numpy(), 'bo', label="Real") +plt.plot(x_train.data.numpy(), y_pred.data.numpy(), 'ro', label="Estimated") +plt.legend() +plt.show() + + +for i in range(10): + y_pred = linear_model(x_train) + loss = get_loss(y_pred, y_train) + + w.grad.zero_() + b.grad.zero_() + loss.backward() + + w.data = w.data - eta*w.grad.data + b.data = b.data - eta*b.grad.data + + print("epoch: %3d, loss: %f" % (i, loss.data[0])) + diff --git a/demo_code/2_poly_fitting.py b/demo_code/2_poly_fitting.py new file mode 100644 index 0000000..e6cc8ff --- /dev/null +++ b/demo_code/2_poly_fitting.py @@ -0,0 +1,77 @@ +import numpy as np + +import torch +from torch.autograd import Variable + +import matplotlib.pyplot as plt + + +""" +Polynomial fitting by pytorch +""" + +# define the real model's parameters +w_target = np.array([0.5, 3, 2.4]) +b_target = np.array([0.9]) + +f_des = "y = %f + %f * x + %f * x^2 + %f * x^3" % ( + b_target[0], + w_target[0], w_target[1], w_target[2]) +print(f_des) + +# draw the data +x_sample = np.arange(-3, 3.1, 0.1) +y_sample = b_target[0] + w_target[0]*x_sample + w_target[1]*x_sample**2 + w_target[2]*x_sample**3 + +plt.plot(x_sample, y_sample, label="Real") +plt.legend() +plt.show() + + +# construct variabels +x_train = np.stack([x_sample**i for i in range(1, 4)], axis=1) +x_train = torch.from_numpy(x_train).float() + +y_train = torch.from_numpy(y_sample).float().unsqueeze(1) + +# define model parameters +w = Variable(torch.randn(3, 1).float(), requires_grad=True) +b = Variable(torch.zeros(1).float(), requires_grad=True) + +x_train = Variable(x_train) +y_train = Variable(y_train) + + +# define the model function & loss function +def polynomial(x): + return torch.mm(x, w) + b + +def get_loss(y_pred, y): + return torch.mean((y_pred-y)**2) + + +# begin iterative optimization +eta = 0.001 + +for i in range(100): + y_pred = polynomial(x_train) + + loss = get_loss(y_pred, y_train) + loss.backward() + + w.data = w.data - eta*w.grad.data + b.data = b.data - eta*b.grad.data + + w.grad.data.zero_() + b.grad.data.zero_() + + if i % 10 == 0: + print("epoch: %4d, loss: %f" % (i, loss.data[0])) + +# draw the results +y_pred = polynomial(x_train) + +plt.plot(x_train.data.numpy()[:, 0], y_sample, label="Real", color='b') +plt.plot(x_train.data.numpy()[:, 0], y_pred.data.numpy(), label="Fitting", color='r') +plt.legend() +plt.show() diff --git a/demo_code/2_poly_fitting_0.py b/demo_code/2_poly_fitting_0.py new file mode 100644 index 0000000..3c17607 --- /dev/null +++ b/demo_code/2_poly_fitting_0.py @@ -0,0 +1,105 @@ +import numpy as np + +import torch +from torch.autograd import Variable + +import matplotlib.pyplot as plt + + +""" +Polynomial fitting by pytorch +""" + +# define the model's parameters +w_target = np.array([0.5, 3, 2.4]) +b_target = np.array([0.9]) + +f_des = "y = %f + %f * x + %f * x^2 + %f * x^3" % ( + b_target[0], + w_target[0], w_target[1], w_target[2]) +print(f_des) + +# draw the data +x_sample = np.arange(-3, 3.1, 0.1) +y_sample = b_target[0] + w_target[0]*x_sample + w_target[1]*x_sample**2 + w_target[2]*x_sample**3 + +plt.plot(x_sample, y_sample, label="Real") +plt.legend() +plt.show() + + +# construct variabels +x_train = np.stack([x_sample**i for i in range(1, 4)], axis=1) +x_train = torch.from_numpy(x_train).float() + +y_train = torch.from_numpy(y_sample).float().unsqueeze(1) + +# define model parameters +w = Variable(torch.randn(3, 1).float(), requires_grad=True) +b = Variable(torch.zeros(1).float(), requires_grad=True) + +x_train = Variable(x_train) +y_train = Variable(y_train) + +print(w.shape) +print(b.shape) +print(x_train.shape) +print(y_train.shape) + +def polynomial(x): + return torch.mm(x, w) + b + +def get_loss(y_pred, y): + return torch.mean((y_pred-y)**2) + +# draw initial graph +y_pred = polynomial(x_train) + +plt.plot(x_train.data.numpy()[:, 0], y_sample, label="Real", color='b') +plt.plot(x_train.data.numpy()[:, 0], y_pred.data.numpy(), label="Fitting", color='r') +plt.legend() +plt.show() + +# compute loss +loss = get_loss(y_pred, y_train) +print("Loss = %f" % loss) + +loss.backward() +print(w.grad) +print(b.grad) + +eta = 0.001 + +w.data = w.data - eta*w.grad.data +b.data = b.data - eta*b.grad.data + +# second draw +y_pred = polynomial(x_train) + +plt.plot(x_train.data.numpy()[:, 0], y_sample, label="Real", color='b') +plt.plot(x_train.data.numpy()[:, 0], y_pred.data.numpy(), label="Fitting", color='r') +plt.legend() +plt.show() + + +for i in range(100): + y_pred = polynomial(x_train) + + loss = get_loss(y_pred, y_train) + + w.grad.data.zero_() + b.grad.data.zero_() + loss.backward() + + w.data = w.data - eta*w.grad.data + b.data = b.data - eta*b.grad.data + + print("epoch: %4d, loss: %f" % (i, loss.data[0])) + +# second draw +y_pred = polynomial(x_train) + +plt.plot(x_train.data.numpy()[:, 0], y_sample, label="Real", color='b') +plt.plot(x_train.data.numpy()[:, 0], y_pred.data.numpy(), label="Fitting", color='r') +plt.legend() +plt.show() diff --git a/demo_code/CNN_CIFAR.py b/demo_code/CNN_CIFAR.py index d747a2d..bb1746d 100644 --- a/demo_code/CNN_CIFAR.py +++ b/demo_code/CNN_CIFAR.py @@ -34,7 +34,7 @@ trainloader = t.utils.data.DataLoader( # 测试集 testset = tv.datasets.CIFAR10( - dataset_path, train=False, download=True, transform=transform) + root=dataset_path, train=False, download=True, transform=transform) testloader = t.utils.data.DataLoader( testset, @@ -69,7 +69,7 @@ class Net(nn.Module): net = Net() print(net) -criterion = nn.CrossEntropyLoss() # 交叉熵损失函数 +criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) t.set_num_threads(8) diff --git a/demo_code/Neural_Network.0.py b/demo_code/Neural_Network.0.py index c6a9afd..cb28373 100644 --- a/demo_code/Neural_Network.0.py +++ b/demo_code/Neural_Network.0.py @@ -1,16 +1,18 @@ import torch from torch import nn, optim - from torch.autograd import Variable from torch.utils.data import DataLoader +import torch.nn.functional as F + from torchvision import transforms from torchvision import datasets +# set parameters batch_size = 32 learning_rate = 1e-2 num_epoches = 50 -# 下载训练集 MNIST 手写数字训练集 +# download & load MNIST dataset dataset_path = "../data/mnist" train_dataset = datasets.MNIST( @@ -23,70 +25,62 @@ train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False) -# 定义简单的前馈神经网络 -class Neuralnetwork(nn.Module): +# Define the network +class NeuralNetwork(nn.Module): def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim): - super(Neuralnetwork, self).__init__() + super(NeuralNetwork, self).__init__() self.layer1 = nn.Linear(in_dim, n_hidden_1) self.layer2 = nn.Linear(n_hidden_1, n_hidden_2) self.layer3 = nn.Linear(n_hidden_2, out_dim) def forward(self, x): - x = self.layer1(x) - x = self.layer2(x) + x = F.relu(self.layer1(x)) + x = F.relu(self.layer2(x)) x = self.layer3(x) return x -model = Neuralnetwork(28 * 28, 300, 100, 10) -if torch.cuda.is_available(): - model = model.cuda() +# create network & define loss function +model = NeuralNetwork(28 * 28, 300, 100, 10) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=learning_rate) +# train for epoch in range(num_epoches): - print('epoch {}'.format(epoch + 1)) - print('*' * 10) + print("epoch %6d" % int(epoch+1)) + print('-' * 40) + running_loss = 0.0 running_acc = 0.0 for i, data in enumerate(train_loader, 1): - # FIXME: label need to change one-hot coding img, label = data - img = img.view(img.size(0), -1) - target = torch.zeros(label.size(0), 10) - target = target.scatter_(1, label.data, 1) - - if torch.cuda.is_available(): - img = Variable(img).cuda() - label = Variable(label).cuda() - else: - img = Variable(img) - label = Variable(label) - + + img = Variable(img.view(img.size(0), -1)) + label = Variable(label) + # 向前传播 + optimizer.zero_grad() + out = model(img) loss = criterion(out, label) running_loss += loss.data[0] * label.size(0) - _, pred = torch.max(out, 1) - num_correct = (pred == label).sum() - running_acc += num_correct.data[0] - + + pred = out.data.max(1, keepdim=True)[1] + running_acc += float(pred.eq(label.data.view_as(pred)).cpu().sum()) + # 向后传播 - optimizer.zero_grad() loss.backward() optimizer.step() if i % 300 == 0: - print('[{}/{}] Loss: {:.6f}, Acc: {:.6f}'.format( - epoch + 1, num_epoches, running_loss / (batch_size * i), - running_acc / (batch_size * i))) - - print('Finish {} epoch, Loss: {:.6f}, Acc: {:.6f}'.format( - epoch + 1, running_loss / (len(train_dataset)), running_acc / (len( - train_dataset)))) - + print('[{}/{}] Loss: {:.6f}, Acc: {:.2f}%'.format( + epoch + 1, num_epoches, + 1.0*running_loss / (batch_size * i), + 100.0*running_acc / (batch_size * i))) + + # do test model.eval() eval_loss = 0. eval_acc = 0. @@ -94,22 +88,23 @@ for epoch in range(num_epoches): for data in test_loader: img, label = data img = img.view(img.size(0), -1) - if torch.cuda.is_available(): - img = Variable(img, volatile=True).cuda() - label = Variable(label, volatile=True).cuda() - else: - img = Variable(img, volatile=True) - label = Variable(label, volatile=True) + + img = Variable(img) + label = Variable(label) + out = model(img) loss = criterion(out, label) + eval_loss += loss.data[0] * label.size(0) - _, pred = torch.max(out, 1) - num_correct = (pred == label).sum() - eval_acc += num_correct.data[0] + pred = out.data.max(1, keepdim=True)[1] + eval_acc += float(pred.eq(label.data.view_as(pred)).cpu().sum()) + - print('Test Loss: {:.6f}, Acc: {:.6f}'.format(eval_loss / (len( - test_dataset)), eval_acc / (len(test_dataset)))) + print('\nTest Loss: {:.6f}, Acc: {:.2f}%'.format( + 1.0*eval_loss / (len(test_dataset)), + 100.0*eval_acc / (len(test_dataset)))) print() -# 保存模型 + +# save model torch.save(model.state_dict(), './model_Neural_Network.pth') diff --git a/demo_code/Nerual_Network.py b/demo_code/Neural_Network.py similarity index 82% rename from demo_code/Nerual_Network.py rename to demo_code/Neural_Network.py index 47d5c99..db7d6f2 100644 --- a/demo_code/Nerual_Network.py +++ b/demo_code/Neural_Network.py @@ -1,5 +1,3 @@ -from __future__ import print_function - import torch import torch.nn as nn import torch.nn.functional as F @@ -58,7 +56,8 @@ optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5) def train(epoch): - #model.train() + model.train() + for batch_idx, (data, target) in enumerate(train_loader): data, target = Variable(data), Variable(target) optimizer.zero_grad() @@ -66,30 +65,33 @@ def train(epoch): loss = criterion(output, target) loss.backward() optimizer.step() - if batch_idx % 10 == 0: - print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( + if batch_idx % 100 == 0: + print("Train epoch: %6d [%6d/%6d (%.0f %%)] \t Loss: %.6f" % ( epoch, batch_idx * len(data), len(train_loader.dataset), - 100. * batch_idx / len(train_loader), loss.data[0])) + 100. * batch_idx / len(train_loader), loss.data[0]) ) def test(): model.eval() - test_loss = 0 - correct = 0 + + test_loss = 0.0 + correct = 0.0 for data, target in test_loader: - data, target = Variable(data, volatile=True), Variable(target) + data, target = Variable(data), Variable(target) output = model(data) + # sum up batch loss test_loss += criterion(output, target).data[0] + # get the index of the max pred = output.data.max(1, keepdim=True)[1] - correct += pred.eq(target.data.view_as(pred)).cpu().sum() + correct += float(pred.eq(target.data.view_as(pred)).cpu().sum()) test_loss /= len(test_loader.dataset) - print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format( - test_loss, correct, len(test_loader.dataset), - 100. * correct / len(test_loader.dataset))) - + print("\nTest set: Average loss: %.4f, Accuracy: %6d/%6d (%4.2f %%)\n" % + (test_loss, + correct, len(test_loader.dataset), + 100.0*correct / len(test_loader.dataset)) ) for epoch in range(1, 10): train(epoch) diff --git a/tips/pytorch/tensor_divide_int.py b/tips/pytorch/tensor_divide_int.py new file mode 100644 index 0000000..62d763c --- /dev/null +++ b/tips/pytorch/tensor_divide_int.py @@ -0,0 +1,6 @@ +import torch + + +a = torch.tensor([1, 2, 3, 4, 3.5]) +f = 1.0 * a.sum() / 10.0 +print("f = %f" % f)