add chap2-preliminaries of paddle (#1103)

* add chap2-preliminaries of paddle * change 15.2 title in chinese version (#1109) change title ’15.2. 情感分析：使用递归神经网络‘ to ’15.2. 情感分析：使用循环神经网络‘ * 修改部分语义表述 (#1105) * update chap2-preliminaries of paddle * Update r0.17.5 (#1120) * Bump versions in installation * add d2l lib * Update chapter_preliminaries/calculus.md * Sync paddle lib chap2 Co-authored-by: zhou201505013 <[email protected]> Co-authored-by: Xinwei Liu <[email protected]> Co-authored-by: Anirudh Dagar <[email protected]> Co-authored-by: Aston Zhang <[email protected]>
d2l-ai · Apr 12, 2022 · 0e40d9f · 0e40d9f
1 parent b71d503
commit 0e40d9f
Show file tree

Hide file tree

Showing 19 changed files with 550 additions and 31 deletions.
diff --git a/chapter_installation/index.md b/chapter_installation/index.md
@@ -88,8 +88,8 @@ pip install mxnet==1.7.0.post1
 你可以按如下方式安装PyTorch的CPU或GPU版本：
 
 ```bash
-pip install torch==1.10.2
-pip install torchvision==0.11.3
+pip install torch==1.11.0
+pip install torchvision==0.12.0
 ```
 
 
@@ -109,7 +109,7 @@ pip install tensorflow-probability==0.16.0
 我们的下一步是安装`d2l`包，以方便调取本书中经常使用的函数和类：
 
 ```bash
-pip install d2l==0.17.4
+pip install d2l==0.17.5
 ```
 
 

diff --git a/chapter_linear-networks/linear-regression.md b/chapter_linear-networks/linear-regression.md
@@ -223,7 +223,7 @@ $\eta$表示*学习率*（learning rate）。
 %matplotlib inline
 from d2l import mxnet as d2l
 import math
-import numpy as np
+from mxnet import np
 import time
 ```
 
@@ -350,7 +350,18 @@ def normal(x, mu, sigma):
 我们现在(**可视化正态分布**)。
 
 ```{.python .input}
-#@tab all
+#@tab mxnet
+# 再次使用numpy进行可视化
+x = np.arange(-7, 7, 0.01)
+# Mean and standard deviation pairs
+params = [(0, 1), (0, 2), (3, 1)]
+d2l.plot(x.asnumpy(), [normal(x, mu, sigma).asnumpy() for mu, sigma in params], xlabel='x',
+         ylabel='p(x)', figsize=(4.5, 2.5),
+         legend=[f'mean {mu}, std {sigma}' for mu, sigma in params])
+```
+
+```{.python .input}
+#@tab pytorch, tensorflow
 # 再次使用numpy进行可视化
 x = np.arange(-7, 7, 0.01)
 

diff --git a/chapter_multilayer-perceptrons/kaggle-house-price.md b/chapter_multilayer-perceptrons/kaggle-house-price.md
@@ -439,7 +439,6 @@ def train(net, train_features, train_labels, test_features, test_labels,
 具体地说，它选择第$i$个切片作为验证数据，其余部分作为训练数据。
 注意，这并不是处理数据的最有效方法，如果我们的数据集大得多，会有其他解决办法。
 
-
 ```{.python .input}
 #@tab all
 def get_k_fold_data(k, i, X, y):
@@ -514,7 +513,7 @@ print(f'{k}-折验证: 平均训练log rmse: {float(train_l):f}, '
 
 ```{.python .input}
 #@tab all
-def train_and_pred(train_features, test_feature, train_labels, test_data,
+def train_and_pred(train_features, test_features, train_labels, test_data,
                    num_epochs, lr, weight_decay, batch_size):
     net = get_net()
     train_ls, _ = train(net, train_features, train_labels, None, None,

diff --git a/chapter_natural-language-processing-applications/sentiment-analysis-rnn.md b/chapter_natural-language-processing-applications/sentiment-analysis-rnn.md
@@ -1,4 +1,4 @@
-# 情感分析：使用递归神经网络
+# 情感分析：使用循环神经网络
 :label:`sec_sentiment_rnn`
 
 与词相似度和类比任务一样，我们也可以将预先训练的词向量应用于情感分析。由于 :numref:`sec_sentiment`中的IMDb评论数据集不是很大，使用在大规模语料库上预训练的文本表示可以减少模型的过拟合。作为 :numref:`fig_nlp-map-sa-rnn`中所示的具体示例，我们将使用预训练的GloVe模型来表示每个词元，并将这些词元表示送入多层双向循环神经网络以获得文本序列表示，该文本序列表示将被转换为情感分析输出 :cite:`Maas.Daly.Pham.ea.2011`。对于相同的下游应用，我们稍后将考虑不同的架构选择。

diff --git a/chapter_optimization/optimization-intro.md b/chapter_optimization/optimization-intro.md
@@ -98,7 +98,24 @@ annotate('saddle point', (0, -0.2), (-0.52, -5.0))
 如下例所示，较高维度的鞍点甚至更加隐蔽。考虑这个函数$f(x, y) = x^2 - y^2$。它的鞍点为$(0, 0)$。这是关于$y$的最大值，也是关于$x$的最小值。此外，它*看起来*像马鞍，这就是这个数学属性的名字由来。
 
 ```{.python .input}
-#@tab all
+#@tab mxnet
+x, y = d2l.meshgrid(
+    d2l.linspace(-1.0, 1.0, 101), d2l.linspace(-1.0, 1.0, 101))
+z = x**2 - y**2
+ax = d2l.plt.figure().add_subplot(111, projection='3d')
+ax.plot_wireframe(x.asnumpy(), y.asnumpy(), z.asnumpy(),
+                  **{'rstride': 10, 'cstride': 10})
+ax.plot([0], [0], [0], 'rx')
+ticks = [-1, 0, 1]
+d2l.plt.xticks(ticks)
+d2l.plt.yticks(ticks)
+ax.set_zticks(ticks)
+d2l.plt.xlabel('x')
+d2l.plt.ylabel('y');
+```
+
+```{.python .input}
+#@tab pytorch, tensorflow
 x, y = d2l.meshgrid(
     d2l.linspace(-1.0, 1.0, 101), d2l.linspace(-1.0, 1.0, 101))
 z = x**2 - y**2

diff --git a/chapter_preface/index.md b/chapter_preface/index.md
@@ -24,9 +24,9 @@
 
 许多教科书教授一系列的主题，每一个都非常详细。例如，Chris Bishop的优秀教科书 :cite:`Bishop.2006` ，对每个主题都教得很透彻，以至于要读到线性回归这一章需要大量的工作。虽然专家们喜欢这本书正是因为它的透彻性，但对于初学者来说，这一特性限制了它作为介绍性文本的实用性。
 
-在这本书中，我们将适时教授大部分概念。换句话说，你将在实现某些实际目的所需的非常时刻学习概念。虽然我们在开始时花了一些时间来教授基础基础知识，如线性代数和概率，但我们希望你在担心更深奥的概率分布之前，先体会一下训练第一个模型的满足感。
+在这本书中，我们将适时教授大部分概念。换句话说，你将在实现某些实际目的所需的非常时刻学习概念。虽然我们在开始时花了一些时间来教授基础的背景知识，如线性代数和概率，但我们希望你在思考更深奥的概率分布之前，先体会一下训练模型的满足感。
 
-除了提供基本数学背景速成课程的几节初步课程外，后续的每一章都介绍了合理数量的新概念，并提供一个独立工作的例子——使用真实的数据集。这带来了组织上的挑战。某些模型可能在逻辑上组合在单节中。而一些想法可能最好是通过连续允许几个模型来传授。另一方面，坚持“一个工作例子一节”的策略有一个很大的好处：这使你可以通过利用我们的代码尽可能轻松地启动你自己的研究项目。只需复制这一节的内容并开始修改即可。
+除了提供基本数学背景速成课程的几节初步课程外，后续的每一章都介绍了适量的新概念，并提供可独立工作的例子——使用真实的数据集。这带来了组织上的挑战。某些模型可能在逻辑上组合在单节中。而一些想法可能最好是通过连续允许几个模型来传授。另一方面，坚持“一个工作例子一节”的策略有一个很大的好处：这使你可以通过利用我们的代码尽可能轻松地启动你自己的研究项目。只需复制这一节的内容并开始修改即可。
 
 我们将根据需要将可运行代码与背景材料交错。通常，在充分解释工具之前，我们常常会在提供工具这一方面犯错误（我们将在稍后解释背景）。例如，在充分解释*随机梯度下降*为什么有用或为什么有效之前，我们可以使用它。这有助于给从业者提供快速解决问题所需的弹药，同时需要读者相信我们的一些决定。
 
@@ -63,6 +63,7 @@ from collections import defaultdict
 from IPython import display
 import math
 from matplotlib import pyplot as plt
+from matplotlib_inline import backend_inline
 import os
 import pandas as pd
 import random

diff --git a/chapter_preliminaries/autograd.md b/chapter_preliminaries/autograd.md
@@ -40,6 +40,14 @@ x = tf.range(4, dtype=tf.float32)
 x
 ```
 
+```{.python .input}
+#@tab paddle
+import paddle
+
+x = paddle.arange(4, dtype='float32')
+x
+```
+
 [**在我们计算$y$关于$\mathbf{x}$的梯度之前，我们需要一个地方来存储梯度。**]
 重要的是，我们不会在每次对一个参数求导时都分配新的内存。
 因为我们经常会成千上万次地更新相同的参数，每次都分配新的内存可能很快就会将内存耗尽。
@@ -63,6 +71,12 @@ x.grad  # 默认值是None
 x = tf.Variable(x)
 ```
 
+```{.python .input}
+#@tab paddle
+x = paddle.to_tensor(x, stop_gradient=False)
+x.grad  # 默认值是None
+```
+
 (**现在让我们计算$y$。**)
 
 ```{.python .input}
@@ -86,6 +100,12 @@ with tf.GradientTape() as t:
 y
 ```
 
+```{.python .input}
+#@tab paddle
+y = 2 * paddle.dot(x, x)
+y
+```
+
 `x`是一个长度为4的向量，计算`x`和`x`的点积，得到了我们赋值给`y`的标量输出。
 接下来，我们[**通过调用反向传播函数来自动计算`y`关于`x`每个分量的梯度**]，并打印这些梯度。
 
@@ -106,6 +126,12 @@ x_grad = t.gradient(y, x)
 x_grad
 ```
 
+```{.python .input}
+#@tab paddle
+y.backward()
+x.grad
+```
+
 函数$y=2\mathbf{x}^{\top}\mathbf{x}$关于$\mathbf{x}$的梯度应为$4\mathbf{x}$。
 让我们快速验证这个梯度是否计算正确。
 
@@ -123,6 +149,11 @@ x.grad == 4 * x
 x_grad == 4 * x
 ```
 
+```{.python .input}
+#@tab paddle
+x.grad == 4 * x
+```
+
 [**现在让我们计算`x`的另一个函数。**]
 
 ```{.python .input}
@@ -148,6 +179,15 @@ with tf.GradientTape() as t:
 t.gradient(y, x)  # 被新计算的梯度覆盖
 ```
 
+```{.python .input}
+#@tab paddle
+# 在默认情况下，PaddlePaddle会累积梯度，我们需要清除之前的值
+x.clear_gradient()
+y = paddle.sum(x)
+y.backward()
+x.grad
+```
+
 ## 非标量变量的反向传播
 
 当`y`不是标量时，向量`y`关于向量`x`的导数的最自然解释是一个矩阵。
@@ -184,6 +224,14 @@ with tf.GradientTape() as t:
 t.gradient(y, x)  # 等价于y=tf.reduce_sum(x*x)
 ```
 
+```{.python .input}
+#@tab paddle
+x.clear_gradient()
+y = x * x
+paddle.sum(y).backward() 
+x.grad
+```
+
 ## 分离计算
 
 有时，我们希望[**将某些计算移动到记录的计算图之外**]。
@@ -229,6 +277,17 @@ x_grad = t.gradient(z, x)
 x_grad == u
 ```
 
+```{.python .input}
+#@tab paddle
+x.clear_gradient()
+y = x * x
+u = y.detach()
+z = u * x
+
+paddle.sum(z).backward()
+x.grad == u
+```
+
 由于记录了`y`的计算结果，我们可以随后在`y`上调用反向传播，
 得到`y=x*x`关于的`x`的导数，即`2*x`。
 
@@ -249,6 +308,13 @@ x.grad == 2 * x
 t.gradient(y, x) == 2 * x
 ```
 
+```{.python .input}
+#@tab paddle
+x.clear_gradient()
+paddle.sum(y).backward()
+x.grad == 2 * x
+```
+
 ## Python控制流的梯度计算
 
 使用自动微分的一个好处是：
@@ -293,6 +359,19 @@ def f(a):
     return c
 ```
 
+```{.python .input}
+#@tab paddle
+def f(a):
+    b = a * 2
+    while paddle.norm(b) < 1000:
+        b = b * 2
+    if paddle.sum(b) > 0:
+        c = b
+    else:
+        c = 100 * b
+    return c
+```
+
 让我们计算梯度。
 
 ```{.python .input}
@@ -319,6 +398,13 @@ d_grad = t.gradient(d, a)
 d_grad
 ```
 
+```{.python .input}
+#@tab paddle
+a = paddle.to_tensor(paddle.randn(shape=[1]), stop_gradient=False)
+d = f(a)
+d.backward()
+```
+
 我们现在可以分析上面定义的`f`函数。
 请注意，它在其输入`a`中是分段线性的。
 换言之，对于任何`a`，存在某个常量标量`k`，使得`f(a)=k*a`，其中`k`的值取决于输入`a`。
@@ -338,6 +424,11 @@ a.grad == d / a
 d_grad == d / a
 ```
 
+```{.python .input}
+#@tab paddle
+a.grad == d / a
+```
+
 ## 小结
 
 * 深度学习框架可以自动计算导数：我们首先将梯度附加到想要对其计算偏导数的变量上。然后我们记录目标值的计算，执行它的反向传播函数，并访问得到的梯度。

diff --git a/chapter_preliminaries/calculus.md b/chapter_preliminaries/calculus.md
@@ -53,7 +53,7 @@
 ```{.python .input}
 %matplotlib inline
 from d2l import mxnet as d2l
-from IPython import display
+from matplotlib_inline import backend_inline
 from mxnet import np, npx
 npx.set_np()
 
@@ -65,7 +65,7 @@ def f(x):
 #@tab pytorch
 %matplotlib inline
 from d2l import torch as d2l
-from IPython import display
+from matplotlib_inline import backend_inline
 import numpy as np
 
 def f(x):
@@ -76,9 +76,21 @@ def f(x):
 #@tab tensorflow
 %matplotlib inline
 from d2l import tensorflow as d2l
-from IPython import display
+from matplotlib_inline import backend_inline
 import numpy as np
 
+def f(x):
+    return 3 * x ** 2 - 4 * x
+```
+
+```{.python .input}
+#@tab paddle
+%matplotlib inline
+from d2l import paddle as d2l
+from matplotlib_inline import backend_inline
+import numpy as np
+
+
 def f(x):
     return 3 * x ** 2 - 4 * x
 ```
@@ -145,7 +157,7 @@ $$\frac{d}{dx} \left[\frac{f(x)}{g(x)}\right] = \frac{g(x) \frac{d}{dx} [f(x)] -
 #@tab all
 def use_svg_display():  #@save
     """使用svg格式在Jupyter中显示绘图"""
-    display.set_matplotlib_formats('svg')
+    backend_inline.set_matplotlib_formats('svg')
 ```
 
 我们定义`set_figsize`函数来设置图表大小。