{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# 线性模型和梯度下降\n", "这是神经网络的第一课,我们会学习一个非常简单的模型,线性回归,同时也会学习一个优化算法-梯度下降法,对这个模型进行优化。线性回归是监督学习里面一个非常简单的模型,同时梯度下降也是深度学习中应用最广的优化算法,我们将从这里开始我们的深度学习之旅" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 一元线性回归\n", "一元线性模型非常简单,假设我们有变量 $x_i$ 和目标 $y_i$,每个 i 对应于一个数据点,希望建立一个模型\n", "\n", "$$\n", "\\hat{y}_i = w x_i + b\n", "$$\n", "\n", "$\\hat{y}_i$ 是我们预测的结果,希望通过 $\\hat{y}_i$ 来拟合目标 $y_i$,通俗来讲就是找到这个函数拟合 $y_i$ 使得误差最小,即最小化\n", "\n", "$$\n", "\\frac{1}{n} \\sum_{i=1}^n(\\hat{y}_i - y_i)^2\n", "$$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "那么如何最小化这个误差呢?\n", "\n", "这里需要用到**梯度下降**,这是我们接触到的第一个优化算法,非常简单,但是却非常强大,在深度学习中被大量使用,所以让我们从简单的例子出发了解梯度下降法的原理" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 梯度下降法\n", "在梯度下降法中,我们首先要明确梯度的概念,随后我们再了解如何使用梯度进行下降。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 梯度\n", "梯度在数学上就是导数,如果是一个多元函数,那么梯度就是偏导数。比如一个函数f(x, y),那么 f 的梯度就是 \n", "\n", "$$\n", "(\\frac{\\partial f}{\\partial x},\\ \\frac{\\partial f}{\\partial y})\n", "$$\n", "\n", "可以称为 grad f(x, y) 或者 $\\nabla f(x, y)$。具体某一点 $(x_0,\\ y_0)$ 的梯度就是 $\\nabla f(x_0,\\ y_0)$。\n", "\n", "下面这个图片是 $f(x) = x^2$ 这个函数在 x=1 处的梯度\n", "\n", "![](https://ws3.sinaimg.cn/large/006tNc79ly1fmarbuh2j3j30ba0b80sy.jpg)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "梯度有什么意义呢?从几何意义来讲,一个点的梯度值是这个函数变化最快的地方,具体来说,对于函数 f(x, y),在点 $(x_0, y_0)$ 处,沿着梯度 $\\nabla f(x_0,\\ y_0)$ 的方向,函数增加最快,也就是说沿着梯度的方向,我们能够更快地找到函数的极大值点,或者反过来沿着梯度的反方向,我们能够更快地找到函数的最小值点。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 梯度下降法\n", "有了对梯度的理解,我们就能了解梯度下降发的原理了。上面我们需要最小化这个误差,也就是需要找到这个误差的最小值点,那么沿着梯度的反方向我们就能够找到这个最小值点。\n", "\n", "我们可以来看一个直观的解释。比如我们在一座大山上的某处位置,由于我们不知道怎么下山,于是决定走一步算一步,也就是在每走到一个位置的时候,求解当前位置的梯度,沿着梯度的负方向,也就是当前最陡峭的位置向下走一步,然后继续求解当前位置梯度,向这一步所在位置沿着最陡峭最易下山的位置走一步。这样一步步的走下去,一直走到觉得我们已经到了山脚。当然这样走下去,有可能我们不能走到山脚,而是到了某一个局部的山峰低处。\n", "\n", "类比我们的问题,就是沿着梯度的反方向,我们不断改变 w 和 b 的值,最终找到一组最好的 w 和 b 使得误差最小。\n", "\n", "在更新的时候,我们需要决定每次更新的幅度,比如在下山的例子中,我们需要每次往下走的那一步的长度,这个长度称为学习率,用 $\\eta$ 表示,这个学习率非常重要,不同的学习率都会导致不同的结果,学习率太小会导致下降非常缓慢,学习率太大又会导致跳动非常明显,可以看看下面的例子\n", "\n", "![](https://ws2.sinaimg.cn/large/006tNc79ly1fmgn23lnzjg30980gogso.gif)\n", "\n", "可以看到上面的学习率较为合适,而下面的学习率太大,就会导致不断跳动\n", "\n", "最后我们的更新公式就是\n", "\n", "$$\n", "w := w - \\eta \\frac{\\partial f(w,\\ b)}{\\partial w} \\\\\n", "b := b - \\eta \\frac{\\partial f(w,\\ b)}{\\partial b}\n", "$$\n", "\n", "通过不断地迭代更新,最终我们能够找到一组最优的 w 和 b,这就是梯度下降法的原理。\n", "\n", "最后可以通过这张图形象地说明一下这个方法\n", "\n", "![](https://ws3.sinaimg.cn/large/006tNc79ly1fmarxsltfqj30gx091gn4.jpg)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "上面是原理部分,下面通过一个例子来进一步学习线性模型" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import torch\n", "import numpy as np\n", "from torch.autograd import Variable\n", "\n", "torch.manual_seed(2017)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# 读入数据 x 和 y\n", "x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168],\n", " [9.779], [6.182], [7.59], [2.167], [7.042],\n", " [10.791], [5.313], [7.997], [3.1]], dtype=np.float32)\n", "\n", "y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573],\n", " [3.366], [2.596], [2.53], [1.221], [2.827],\n", " [3.465], [1.65], [2.904], [1.3]], dtype=np.float32)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# 画出图像\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", "\n", "plt.plot(x_train, y_train, 'bo')" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor([2.2691], requires_grad=True)\n" ] } ], "source": [ "# 转换成 Tensor\n", "x_train = torch.from_numpy(x_train)\n", "y_train = torch.from_numpy(y_train)\n", "\n", "# 定义参数 w 和 b\n", "w = Variable(torch.randn(1), requires_grad=True) # 随机初始化\n", "b = Variable(torch.zeros(1), requires_grad=True) # 使用 0 进行初始化\n", "print(w)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "# 构建线性回归模型\n", "x_train = Variable(x_train)\n", "y_train = Variable(y_train)\n", "\n", "def linear_model(x):\n", " return x * w + b" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "y_ = linear_model(x_train)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "经过上面的步骤我们就定义好了模型,在进行参数更新之前,我们可以先看看模型的输出结果长什么样" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(x_train.data.numpy(), y_train.data.numpy(), 'bo', label='real')\n", "plt.plot(x_train.data.numpy(), y_.data.numpy(), 'ro', label='estimated')\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**思考:红色的点表示预测值,似乎排列成一条直线,请思考一下这些点是否在一条直线上?**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "这个时候需要计算我们的误差函数,也就是\n", "\n", "$$\n", "\\frac{1}{n} \\sum_{i=1}^n(\\hat{y}_i - y_i)^2\n", "$$" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "# 计算误差\n", "def get_loss(y_, y):\n", " return torch.mean((y_ - y) ** 2)\n", "\n", "loss = get_loss(y_, y_train)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor(153.3520, grad_fn=)\n" ] } ], "source": [ "# 打印一下看看 loss 的大小\n", "print(loss)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "定义好了误差函数,接下来我们需要计算 w 和 b 的梯度了,这时得益于 PyTorch 的自动求导,我们不需要手动去算梯度,有兴趣的同学可以手动计算一下,w 和 b 的梯度分别是\n", "\n", "$$\n", "\\frac{\\partial}{\\partial w} = \\frac{2}{n} \\sum_{i=1}^n x_i(w x_i + b - y_i) \\\\\n", "\\frac{\\partial}{\\partial b} = \\frac{2}{n} \\sum_{i=1}^n (w x_i + b - y_i)\n", "$$" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "# 自动求导\n", "loss.backward()" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor([161.0043])\n", "tensor([22.8730])\n" ] } ], "source": [ "# 查看 w 和 b 的梯度\n", "print(w.grad)\n", "print(b.grad)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "# 更新一次参数\n", "w.data = w.data - 1e-2 * w.grad.data\n", "b.data = b.data - 1e-2 * b.grad.data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "更新完成参数之后,我们再一次看看模型输出的结果" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "y_ = linear_model(x_train)\n", "plt.plot(x_train.data.numpy(), y_train.data.numpy(), 'bo', label='real')\n", "plt.plot(x_train.data.numpy(), y_.data.numpy(), 'ro', label='estimated')\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "从上面的例子可以看到,更新之后红色的线跑到了蓝色的线下面,没有特别好的拟合蓝色的真实值,所以我们需要在进行几次更新" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor(0.2934)\n", "epoch: 0, loss: 0.2933782935142517\n", "tensor(0.2927)\n", "epoch: 1, loss: 0.29273974895477295\n", "tensor(0.2921)\n", "epoch: 2, loss: 0.29210466146469116\n", "tensor(0.2915)\n", "epoch: 3, loss: 0.2914726436138153\n", "tensor(0.2908)\n", "epoch: 4, loss: 0.29084399342536926\n", "tensor(0.2902)\n", "epoch: 5, loss: 0.2902185022830963\n", "tensor(0.2896)\n", "epoch: 6, loss: 0.28959622979164124\n", "tensor(0.2890)\n", "epoch: 7, loss: 0.28897714614868164\n", "tensor(0.2884)\n", "epoch: 8, loss: 0.28836125135421753\n", "tensor(0.2877)\n", "epoch: 9, loss: 0.2877485454082489\n" ] } ], "source": [ "for e in range(10): # 进行 10 次更新\n", " y_ = linear_model(x_train)\n", " loss = get_loss(y_, y_train)\n", " \n", " w.grad.zero_() # 记得归零梯度\n", " b.grad.zero_() # 记得归零梯度\n", " loss.backward()\n", " print(loss.data)\n", " w.data = w.data - 1e-2 * w.grad.data # 更新 w\n", " b.data = b.data - 1e-2 * b.grad.data # 更新 b \n", " print('epoch: {}, loss: {}'.format(e, loss.item()))" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "y_ = linear_model(x_train)\n", "plt.plot(x_train.data.numpy(), y_train.data.numpy(), 'bo', label='real')\n", "plt.plot(x_train.data.numpy(), y_.data.numpy(), 'ro', label='estimated')\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "经过 10 次更新,我们发现红色的预测结果已经比较好的拟合了蓝色的真实值。\n", "\n", "现在你已经学会了你的第一个机器学习模型了,再接再厉,完成下面的小练习。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**小练习:**\n", "\n", "重启 notebook 运行上面的线性回归模型,但是改变训练次数以及不同的学习率进行尝试得到不同的结果" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 多项式回归模型" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "下面我们更进一步,讲一讲多项式回归。什么是多项式回归呢?非常简单,根据上面的线性回归模型\n", "\n", "$$\n", "\\hat{y} = w x + b\n", "$$\n", "\n", "这里是关于 x 的一个一次多项式,这个模型比较简单,没有办法拟合比较复杂的模型,所以我们可以使用更高次的模型,比如\n", "\n", "$$\n", "\\hat{y} = w_0 + w_1 x + w_2 x^2 + w_3 x^3 + \\cdots\n", "$$\n", "\n", "这样就能够拟合更加复杂的模型,这就是多项式模型,这里使用了 x 的更高次,同理还有多元回归模型,形式也是一样的,只是出了使用 x,还是更多的变量,比如 y、z 等等,同时他们的 loss 函数和简单的线性回归模型是一致的。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "首先我们可以先定义一个需要拟合的目标函数,这个函数是个三次的多项式" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "y = 0.90 + 0.50 * x + 3.00 * x^2 + 2.40 * x^3\n" ] } ], "source": [ "# 定义一个多变量函数\n", "\n", "w_target = np.array([0.5, 3, 2.4]) # 定义参数\n", "b_target = np.array([0.9]) # 定义参数\n", "\n", "f_des = 'y = {:.2f} + {:.2f} * x + {:.2f} * x^2 + {:.2f} * x^3'.format(\n", " b_target[0], w_target[0], w_target[1], w_target[2]) # 打印出函数的式子\n", "\n", "print(f_des)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "我们可以先画出这个多项式的图像" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# 画出这个函数的曲线\n", "x_sample = np.arange(-3, 3.1, 0.1)\n", "y_sample = b_target[0] + w_target[0] * x_sample + w_target[1] * x_sample ** 2 + w_target[2] * x_sample ** 3\n", "\n", "plt.plot(x_sample, y_sample, label='real curve')\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "接着我们可以构建数据集,需要 x 和 y,同时是一个三次多项式,所以我们取了 $x,\\ x^2, x^3$" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "# 构建数据 x 和 y\n", "# x 是一个如下矩阵 [x, x^2, x^3]\n", "# y 是函数的结果 [y]\n", "\n", "x_train = np.stack([x_sample ** i for i in range(1, 4)], axis=1)\n", "x_train = torch.from_numpy(x_train).float() # 转换成 float tensor\n", "\n", "y_train = torch.from_numpy(y_sample).float().unsqueeze(1) # 转化成 float tensor " ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "torch.Size([61, 3])\n" ] } ], "source": [ "print(x_train.size())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "接着我们可以定义需要优化的参数,就是前面这个函数里面的 $w_i$" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "# 定义参数和模型\n", "w = Variable(torch.randn(3, 1), requires_grad=True)\n", "b = Variable(torch.zeros(1), requires_grad=True)\n", "\n", "# 将 x 和 y 转换成 Variable\n", "x_train = Variable(x_train)\n", "y_train = Variable(y_train)\n", "\n", "def multi_linear(x):\n", " return torch.mm(x, w) + b" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "我们可以画出没有更新之前的模型和真实的模型之间的对比" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# 画出更新之前的模型\n", "y_pred = multi_linear(x_train)\n", "\n", "plt.plot(x_train.data.numpy()[:, 0], y_pred.data.numpy(), label='fitting curve', color='r')\n", "plt.plot(x_train.data.numpy()[:, 0], y_sample, label='real curve', color='b')\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "可以发现,这两条曲线之间存在差异,我们计算一下他们之间的误差" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor(413.9844, grad_fn=)\n" ] } ], "source": [ "# 计算误差,这里的误差和一元的线性模型的误差是相同的,前面已经定义过了 get_loss\n", "loss = get_loss(y_pred, y_train)\n", "print(loss)" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "# 自动求导\n", "loss.backward()" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor([[ -34.1391],\n", " [-146.6133],\n", " [-215.9149]])\n", "tensor([-27.0838])\n" ] } ], "source": [ "# 查看一下 w 和 b 的梯度\n", "print(w.grad)\n", "print(b.grad)" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "# 更新一下参数\n", "w.data = w.data - 0.001 * w.grad.data\n", "b.data = b.data - 0.001 * b.grad.data" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# 画出更新一次之后的模型\n", "y_pred = multi_linear(x_train)\n", "\n", "plt.plot(x_train.data.numpy()[:, 0], y_pred.data.numpy(), label='fitting curve', color='r')\n", "plt.plot(x_train.data.numpy()[:, 0], y_sample, label='real curve', color='b')\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "因为只更新了一次,所以两条曲线之间的差异仍然存在,我们进行 100 次迭代" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "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": [ "# 进行 100 次参数更新\n", "for e in range(100):\n", " y_pred = multi_linear(x_train)\n", " loss = get_loss(y_pred, y_train)\n", " \n", " w.grad.data.zero_()\n", " b.grad.data.zero_()\n", " loss.backward()\n", " \n", " # 更新参数\n", " w.data = w.data - 0.001 * w.grad.data\n", " b.data = b.data - 0.001 * b.grad.data\n", " if (e + 1) % 20 == 0:\n", " print('epoch {}, Loss: {:.5f}'.format(e+1, loss.data[0]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "可以看到更新完成之后 loss 已经非常小了,我们画出更新之后的曲线对比" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# 画出更新之后的结果\n", "y_pred = multi_linear(x_train)\n", "\n", "plt.plot(x_train.data.numpy()[:, 0], y_pred.data.numpy(), label='fitting curve', color='r')\n", "plt.plot(x_train.data.numpy()[:, 0], y_sample, label='real curve', color='b')\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "可以看到,经过 100 次更新之后,可以看到拟合的线和真实的线已经完全重合了" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "**小练习:上面的例子是一个三次的多项式,尝试使用二次的多项式去拟合它,看看最后能做到多好**\n", "\n", "**提示:参数 `w = torch.randn(2, 1)`,同时重新构建 x 数据集**" ] } ], "metadata": { "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.6.8" } }, "nbformat": 4, "nbformat_minor": 2 }