diff --git a/code/chapter07_optimization/7.2_gd-sgd.ipynb b/code/chapter07_optimization/7.2_gd-sgd.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..43f87fec94c25bbba3800f20e16c0a82291e59b5
--- /dev/null
+++ b/code/chapter07_optimization/7.2_gd-sgd.ipynb
@@ -0,0 +1,3361 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# 7.2 梯度下降和随机梯度下降"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%matplotlib inline\n",
+ "import numpy as np\n",
+ "import torch\n",
+ "import math\n",
+ "import sys\n",
+ "sys.path.append(\"..\") \n",
+ "import d2lzh_pytorch as d2l"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 7.2.1 一维梯度下降"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "epoch 10, x: 0.06046617599999997\n"
+ ]
+ }
+ ],
+ "source": [
+ "def gd(eta):\n",
+ " x = 10\n",
+ " results = [x]\n",
+ " for i in range(10):\n",
+ " x -= eta * 2 * x # f(x) = x * x的导数为f'(x) = 2 * x\n",
+ " results.append(x)\n",
+ " print('epoch 10, x:', x)\n",
+ " return results\n",
+ "\n",
+ "res = gd(0.2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/svg+xml": [
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def show_trace(res):\n",
+ " n = max(abs(min(res)), abs(max(res)), 10)\n",
+ " f_line = np.arange(-n, n, 0.1)\n",
+ " d2l.set_figsize()\n",
+ " d2l.plt.plot(f_line, [x * x for x in f_line])\n",
+ " d2l.plt.plot(res, [x * x for x in res], '-o')\n",
+ " d2l.plt.xlabel('x')\n",
+ " d2l.plt.ylabel('f(x)')\n",
+ "\n",
+ "show_trace(res)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 7.2.2 学习率"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "epoch 10, x: 3.4867844009999995\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": [
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "show_trace(gd(0.05))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "epoch 10, x: 61.917364224000096\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": [
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "show_trace(gd(1.1))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 7.2.3 多维梯度下降"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "def train_2d(trainer): # 本函数将保存在d2lzh_pytorch包中方便以后使用\n",
+ " x1, x2, s1, s2 = -5, -2, 0, 0 # s1和s2是自变量状态，本章后续几节会使用\n",
+ " results = [(x1, x2)]\n",
+ " for i in range(20):\n",
+ " x1, x2, s1, s2 = trainer(x1, x2, s1, s2)\n",
+ " results.append((x1, x2))\n",
+ " print('epoch %d, x1 %f, x2 %f' % (i + 1, x1, x2))\n",
+ " return results\n",
+ "\n",
+ "def show_trace_2d(f, results): # 本函数将保存在d2lzh_pytorch包中方便以后使用\n",
+ " d2l.plt.plot(*zip(*results), '-o', color='#ff7f0e')\n",
+ " x1, x2 = np.meshgrid(np.arange(-5.5, 1.0, 0.1), np.arange(-3.0, 1.0, 0.1))\n",
+ " d2l.plt.contour(x1, x2, f(x1, x2), colors='#1f77b4')\n",
+ " d2l.plt.xlabel('x1')\n",
+ " d2l.plt.ylabel('x2')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "epoch 20, x1 -0.057646, x2 -0.000073\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": [
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "eta = 0.1\n",
+ "\n",
+ "def f_2d(x1, x2): # 目标函数\n",
+ " return x1 ** 2 + 2 * x2 ** 2\n",
+ "\n",
+ "def gd_2d(x1, x2, s1, s2):\n",
+ " return (x1 - eta * 2 * x1, x2 - eta * 4 * x2, 0, 0)\n",
+ "\n",
+ "show_trace_2d(f_2d, train_2d(gd_2d))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 7.2.4 随机梯度下降"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "epoch 20, x1 -0.047150, x2 -0.075628\n"
+ ]
+ },
+ {
+ "data": {
+ "image/svg+xml": [
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def sgd_2d(x1, x2, s1, s2):\n",
+ " return (x1 - eta * (2 * x1 + np.random.normal(0.1)),\n",
+ " x2 - eta * (4 * x2 + np.random.normal(0.1)), 0, 0)\n",
+ "\n",
+ "show_trace_2d(f_2d, train_2d(sgd_2d))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python [default]",
+ "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.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/code/d2lzh_pytorch/utils.py b/code/d2lzh_pytorch/utils.py
index 706bc9e6cc089d93f96d14600d771514f4fb36f9..db7ea9f8701c4d2c4d4f23cd5537c5ca965dc8e6 100644
--- a/code/d2lzh_pytorch/utils.py
+++ b/code/d2lzh_pytorch/utils.py
@@ -533,3 +533,23 @@ def train_and_predict_rnn_pytorch(model, num_hiddens, vocab_size, device,
print(' -', predict_rnn_pytorch(
prefix, pred_len, model, vocab_size, device, idx_to_char,
char_to_idx))
+
+
+
+
+# ######################################## 7.2 ###############################################
+def train_2d(trainer): # 本函数将保存在d2lzh_pytorch包中方便以后使用
+ x1, x2, s1, s2 = -5, -2, 0, 0 # s1和s2是自变量状态，本章后续几节会使用
+ results = [(x1, x2)]
+ for i in range(20):
+ x1, x2, s1, s2 = trainer(x1, x2, s1, s2)
+ results.append((x1, x2))
+ print('epoch %d, x1 %f, x2 %f' % (i + 1, x1, x2))
+ return results
+
+def show_trace_2d(f, results): # 本函数将保存在d2lzh_pytorch包中方便以后使用
+ d2l.plt.plot(*zip(*results), '-o', color='#ff7f0e')
+ x1, x2 = np.meshgrid(np.arange(-5.5, 1.0, 0.1), np.arange(-3.0, 1.0, 0.1))
+ d2l.plt.contour(x1, x2, f(x1, x2), colors='#1f77b4')
+ d2l.plt.xlabel('x1')
+ d2l.plt.ylabel('x2')
\ No newline at end of file
diff --git a/docs/chapter07_optimization/7.2_gd-sgd.md b/docs/chapter07_optimization/7.2_gd-sgd.md
new file mode 100644
index 0000000000000000000000000000000000000000..79ccf70fbf1882ad354f83a1770cd1b6f8c4b710
--- /dev/null
+++ b/docs/chapter07_optimization/7.2_gd-sgd.md
@@ -0,0 +1,227 @@
+# 7.2 梯度下降和随机梯度下降
+
+在本节中，我们将介绍梯度下降（gradient descent）的工作原理。虽然梯度下降在深度学习中很少被直接使用，但理解梯度的意义以及沿着梯度反方向更新自变量可能降低目标函数值的原因是学习后续优化算法的基础。随后，我们将引出随机梯度下降（stochastic gradient descent）。
+
+## 7.2.1 一维梯度下降
+
+我们先以简单的一维梯度下降为例，解释梯度下降算法可能降低目标函数值的原因。假设连续可导的函数$f: \mathbb{R} \rightarrow \mathbb{R}$的输入和输出都是标量。给定绝对值足够小的数$\epsilon$，根据泰勒展开公式，我们得到以下的近似：
+
+$$f(x + \epsilon) \approx f(x) + \epsilon f'(x) .$$
+
+这里$f'(x)$是函数$f$在$x$处的梯度。一维函数的梯度是一个标量，也称导数。
+
+接下来，找到一个常数$\eta > 0$，使得$\left|\eta f'(x)\right|$足够小，那么可以将$\epsilon$替换为$-\eta f'(x)$并得到
+
+$$f(x - \eta f'(x)) \approx f(x) - \eta f'(x)^2.$$
+
+如果导数$f'(x) \neq 0$，那么$\eta f'(x)^2>0$，所以
+
+$$f(x - \eta f'(x)) \lesssim f(x).$$
+
+这意味着，如果通过
+
+$$x \leftarrow x - \eta f'(x)$$
+
+来迭代$x$，函数$f(x)$的值可能会降低。因此在梯度下降中，我们先选取一个初始值$x$和常数$\eta > 0$，然后不断通过上式来迭代$x$，直到达到停止条件，例如$f'(x)^2$的值已足够小或迭代次数已达到某个值。
+
+下面我们以目标函数$f(x)=x^2$为例来看一看梯度下降是如何工作的。虽然我们知道最小化$f(x)$的解为$x=0$，这里依然使用这个简单函数来观察$x$是如何被迭代的。首先，导入本节实验所需的包或模块。
+
+``` python
+%matplotlib inline
+import numpy as np
+import torch
+import math
+import sys
+sys.path.append("..")
+import d2lzh_pytorch as d2l
+```
+
+接下来使用$x=10$作为初始值，并设$\eta=0.2$。使用梯度下降对$x$迭代10次，可见最终$x$的值较接近最优解。
+
+``` python
+def gd(eta):
+ x = 10
+ results = [x]
+ for i in range(10):
+ x -= eta * 2 * x # f(x) = x * x的导数为f'(x) = 2 * x
+ results.append(x)
+ print('epoch 10, x:', x)
+ return results
+
+res = gd(0.2)
+```
+输出：
+```
+epoch 10, x: 0.06046617599999997
+```
+
+下面将绘制出自变量$x$的迭代轨迹。
+
+``` python
+def show_trace(res):
+ n = max(abs(min(res)), abs(max(res)), 10)
+ f_line = np.arange(-n, n, 0.1)
+ d2l.set_figsize()
+ d2l.plt.plot(f_line, [x * x for x in f_line])
+ d2l.plt.plot(res, [x * x for x in res], '-o')
+ d2l.plt.xlabel('x')
+ d2l.plt.ylabel('f(x)')
+
+show_trace(res)
+```
+
+
+
+
+
+
+
+
+
+
+