Merge remote-tracking branch 'origin/main' into translation-sync-2026-04-13T12-48-54-pr-530

# Conflicts:
#	.translate/state/jax_intro.md.yml
#	.translate/state/numpy_vs_numba_vs_jax.md.yml
#	lectures/jax_intro.md
#	lectures/numba.md
#	lectures/numpy_vs_numba_vs_jax.md

Co-authored-by: HumphreyYang <39026988+HumphreyYang@users.noreply.github.com>

Author: Copilot

.translate/state/jax_intro.md.yml

@@ -1,4 +1,4 @@
-source-sha: 11e7d823f7f355f5025d40cab40bf801b3262e56
+source-sha: 95378b8382b4dbd1cd3e0ffe0e152811894c357f
 synced-at: "2026-04-13"
 model: claude-sonnet-4-6
 mode: UPDATE

.translate/state/numpy_vs_numba_vs_jax.md.yml

@@ -1,4 +1,4 @@
-source-sha: 11e7d823f7f355f5025d40cab40bf801b3262e56
+source-sha: 95378b8382b4dbd1cd3e0ffe0e152811894c357f
 synced-at: "2026-04-13"
 model: claude-sonnet-4-6
 mode: UPDATE

lectures/jax_intro.md

@@ -21,11 +21,11 @@ translation:
     JAX as a NumPy Replacement::Differences::Size Experiment: 大小实验
     JAX as a NumPy Replacement::Differences::Precision: 精度
     JAX as a NumPy Replacement::Differences::Immutability: 不可变性
-    JAX as a NumPy Replacement::Differences::A Workaround: 变通方法
+    JAX as a NumPy Replacement::Differences::A workaround: 变通方法
     Functional Programming: 函数式编程
     Functional Programming::Pure functions: 纯函数
     Functional Programming::Examples: 示例
-    Functional Programming::Why Functional Programming?: 为什么要函数式编程？
+    Functional Programming::Why Functional Programming?: 为什么使用函数式编程？
     Random numbers: 随机数
     Random numbers::Random number generation: 随机数生成
     Random numbers::Why explicit random state?: 为什么要显式随机状态？
@@ -37,10 +37,6 @@ translation:
     JIT Compilation::Compiling the Whole Function: 编译整个函数
     JIT Compilation::How JIT compilation works: JIT 编译的工作原理
     JIT Compilation::Compiling non-pure functions: 编译非纯函数
-    Vectorization with vmap: 使用 vmap 进行向量化
-    Vectorization with vmap::A simple example: 一个简单的示例
-    Vectorization with vmap::Combining transformations: 组合变换
-    Automatic differentiation: a preview: 自动微分：预览
     Exercises: 练习
 ---
 
@@ -77,17 +73,17 @@ import numpy as np
 import quantecon as qe
 ```
 
+注意我们导入了 `jax.numpy as jnp`，它提供了类似 NumPy 的接口。
+
 ## JAX 作为 NumPy 的替代品
 
-让我们来看看 JAX 和 NumPy 之间的异同。
+JAX 的一个吸引人之处在于，它的数组处理操作在尽可能的情况下遵循 NumPy API。
 
-### 相似之处
+这意味着在许多情况下，我们可以将 JAX 作为 NumPy 的直接替代品使用。
 
-上面我们导入了 `jax.numpy as jnp`，它提供了类似 NumPy 的数组操作接口。
-
-JAX 的一个吸引人之处在于，这个接口在尽可能的情况下遵循 NumPy API。
+让我们来看看 JAX 和 NumPy 之间的异同。
 
-因此，我们通常可以将 JAX 作为 NumPy 的直接替代品使用。
+### 相似之处
 
 以下是使用 `jnp` 进行的一些标准数组操作：
 
@@ -107,7 +103,7 @@ print(jnp.sum(a))
 print(jnp.dot(a, a))
 ```
 
-但需要注意的是，数组对象 `a` 并不是 NumPy 数组：
+然而，数组对象 `a` 并不是 NumPy 数组：
 
 ```{code-cell} ipython3
 a
@@ -117,7 +113,7 @@ a
 type(a)
 ```
 
-即使是数组上的标量值映射也会返回 JAX 数组而非标量！
+即使是数组上的标量值映射也会返回 JAX 数组，而不是标量！
 
 ```{code-cell} ipython3
 jnp.sum(a)
@@ -130,18 +126,16 @@ jnp.sum(a)
 (jax_speed)=
 #### 速度！
 
-一个主要差异是 JAX 更快——有时快得多。
-
-为了说明这一点，假设我们想在许多点处计算余弦函数。
+假设我们想在许多点上计算余弦函数。
 
 ```{code-cell}
 n = 50_000_000
-x = np.linspace(0, 10, n)   # NumPy array
+x = np.linspace(0, 10, n)
 ```
 
 ##### 使用 NumPy
 
-让我们用 NumPy 来试试
+让我们先用 NumPy 试试：
 
 ```{code-cell}
 with qe.Timer():
@@ -159,7 +153,7 @@ with qe.Timer():
 
 这里
 
-* NumPy 使用预编译的二进制文件将余弦函数应用于浮点数数组
+* NumPy 使用预编译的二进制文件对浮点数数组应用余弦函数
 * 该二进制文件在本地机器的 CPU 上运行
 
 ##### 使用 JAX
@@ -181,8 +175,11 @@ with qe.Timer():
 ```
 
 ```{note}
-上面的 `block_until_ready` 方法会阻塞解释器，直到计算结果返回。
-这对于计时是必要的，因为 JAX 使用异步调度，允许 Python 解释器在数值计算之前继续运行。
+这里，为了测量实际速度，我们使用 `block_until_ready` 方法来阻塞解释器，直到计算结果返回。
+
+这是必要的，因为 JAX 使用异步调度，允许 Python 解释器在数值计算之前运行。
+
+对于非计时代码，可以删除包含 `block_until_ready` 的那一行。
 ```
 
 再来计时一次。
@@ -277,8 +274,7 @@ a[0] = 1
 a
 ```
 
-在 JAX 中，这会失败 😱。
-
+在 JAX 中，这会失败！
 
 ```{code-cell} ipython3
 a = jnp.linspace(0, 1, 3)
@@ -290,21 +286,13 @@ try:
     a[0] = 1
 except Exception as e:
     print(e)
-
 ```
 
-JAX 的设计者选择将数组设为不可变的，因为
-
-1. JAX 使用*函数式编程风格*，并且
-2. 函数式编程通常避免可变数据
-
-我们将在 {ref}`下面 <jax_func>` 讨论这些思想。
+JAX 的设计者选择将数组设为不可变的，因为 JAX 使用函数式编程风格，我们将在下面讨论这一点。
 
-
-(jax_at_workaround)=
 #### 变通方法
 
-JAX 确实通过 [`at` 方法](https://docs.jax.dev/en/latest/_autosummary/jax.numpy.ndarray.at.html) 提供了原地数组修改的直接替代方案。
+我们注意到 JAX 确实提供了一种替代原地数组修改的方式，使用 [`at` 方法](https://docs.jax.dev/en/latest/_autosummary/jax.numpy.ndarray.at.html)。
 
 ```{code-cell} ipython3
 a = jnp.linspace(0, 1, 3)
@@ -326,8 +314,6 @@ a
 
 （尽管它在 JIT 编译的函数中实际上可以很高效——但现在先把这个放在一边。）
 
-
-(jax_func)=
 ## 函数式编程
 
 来自 JAX 的文档：
@@ -860,40 +846,6 @@ fast_batch_mm_diff(X)
 
 `jit`、`vmap` 以及（我们接下来将看到的）`grad` 的这种组合方式是 JAX 设计的核心，使其在科学计算和机器学习领域尤为强大。
 
-
-## 自动微分：预览
-
-JAX 可以使用自动微分来计算梯度。
-
-这对于优化和求解非线性系统非常有用。
-
-以下是一个简单的示例，涉及函数 $f(x) = x^2 / 2$：
-
-```{code-cell} ipython3
-def f(x):
-    return (x**2) / 2
-
-f_prime = jax.grad(f)
-```
-
-```{code-cell} ipython3
-f_prime(10.0)
-```
-
-让我们绘制函数和导数，注意 $f'(x) = x$。
-
-```{code-cell} ipython3
-fig, ax = plt.subplots()
-x_grid = jnp.linspace(-4, 4, 200)
-ax.plot(x_grid, f(x_grid), label="$f$")
-ax.plot(x_grid, [f_prime(x) for x in x_grid], label="$f'$")
-ax.legend(loc='upper center')
-plt.show()
-```
-
-自动微分是一个有许多经济学和金融学应用的深层主题。我们在{doc}`自动微分讲座 <autodiff>`中提供了更深入的讨论。
-
-
 ## 练习
 
 

lectures/numpy_vs_numba_vs_jax.md

@@ -67,6 +67,7 @@ tags: [hide-output]
 我们将使用以下导入。
 
 ```{code-cell} ipython3
+import random
 from functools import partial
 
 import numpy as np
@@ -466,62 +467,15 @@ Numba 的编译通常相当快，对于像这样的顺序运算，生成的代
 
 ### JAX 版本
 
-现在让我们使用 `at[t].set` 风格的语法创建一个 JAX 版本，正如 {ref}`JAX 讲座中讨论的 <jax_at_workaround>`，这为不可变数组提供了一种变通方法。
+现在让我们使用 `lax.scan` 创建一个 JAX 版本：
 
-我们将使用 `lax.fori_loop`，它是一种可以被 XLA 编译的 for 循环版本。
+（我们将 `n` 设为静态，因为它影响数组大小，JAX 希望在编译代码中针对其值进行特化处理。）
 
 ```{code-cell} ipython3
 cpu = jax.devices("cpu")[0]
 
-@partial(jax.jit, static_argnames=("n",), device=cpu)
-def qm_jax_fori(x0, n, α=4.0):
-
-    x = jnp.empty(n + 1).at[0].set(x0)
-
-    def update(t, x):
-        return x.at[t + 1].set(α * x[t] * (1 - x[t]))
-
-    x = lax.fori_loop(0, n, update, x)
-    return x
-
-```
-
-* 我们将 `n` 设为静态，因为它影响数组大小，JAX 希望在编译代码中针对其值进行特化处理。
-* 我们通过 `device=cpu` 将计算固定在 CPU 上，因为这种顺序工作负载由许多小操作组成，几乎没有机会利用 GPU 并行性。
-
-虽然 `at[t].set` 看起来在每一步都创建了一个新数组，但在 JIT 编译的函数内部，编译器会检测到旧数组不再需要，并就地执行更新。
-
-让我们使用相同的参数计时：
-
-```{code-cell} ipython3
-with qe.Timer():
-    # First run
-    x_jax = qm_jax_fori(0.1, n)
-    # Hold interpreter
-    x_jax.block_until_ready()
-```
-
-让我们再次运行以消除编译开销：
-
-```{code-cell} ipython3
-with qe.Timer():
-    # Second run
-    x_jax = qm_jax_fori(0.1, n)
-    # Hold interpreter
-    x_jax.block_until_ready()
-```
-
-JAX 对于这种顺序运算也相当高效。
-
-
-我们还有另一种实现循环的方式，使用 `lax.scan`。
-
-这种替代方案可以说更符合 JAX 的函数式方法——尽管语法难以记忆。
-
-
-```{code-cell} ipython3
-@partial(jax.jit, static_argnames=("n",), device=cpu)
-def qm_jax_scan(x0, n, α=4.0):
+@partial(jax.jit, static_argnames=('n',), device=cpu)
+def qm_jax(x0, n, α=4.0):
     def update(x, t):
         x_new = α * x * (1 - x)
         return x_new, x_new
@@ -532,12 +486,16 @@ def qm_jax_scan(x0, n, α=4.0):
 
 这段代码不易阅读，但本质上，`lax.scan` 反复调用 `update` 并将返回值 `x_new` 累积到一个数组中。
 
+```{note}
+我们在 `jax.jit` 装饰器中指定了 `device=cpu`，因为该计算由许多小的顺序运算组成，几乎没有机会让 GPU 利用并行性。因此，GPU 上的内核启动开销往往占主导地位，使得 CPU 更适合这种工作负载。
+```
+
 让我们使用相同的参数计时：
 
 ```{code-cell} ipython3
 with qe.Timer():
     # First run
-    x_jax = qm_jax_scan(0.1, n)
+    x_jax = qm_jax(0.1, n)
     # Hold interpreter
     x_jax.block_until_ready()
 ```
@@ -547,11 +505,13 @@ with qe.Timer():
 ```{code-cell} ipython3
 with qe.Timer():
     # Second run
-    x_jax = qm_jax_scan(0.1, n)
+    x_jax = qm_jax(0.1, n)
     # Hold interpreter
     x_jax.block_until_ready()
 ```
 
+JAX 对于这种顺序运算也相当高效。
+
 JAX 和 Numba 在编译后都能提供出色的性能。
 
 ### 总结
@@ -562,9 +522,9 @@ Numba 版本简单直观，易于阅读：我们只需分配一个数组，然
 
 这正是大多数程序员思考该算法的方式。
 
-另一方面，JAX 版本需要使用 `lax.fori_loop` 或 `lax.scan`，两者都比标准 Python 循环更不直观。
+另一方面，JAX 版本需要使用 `lax.scan`，这明显不够直观。
 
-虽然 JAX 的 `at[t].set` 语法确实允许逐元素更新，但整体代码仍然比 Numba 等价版本更难阅读。
+此外，JAX 的不可变数组意味着我们无法简单地就地更新数组元素，这使得直接复制 Numba 使用的算法变得困难。
 
 对于这类顺序运算，在代码清晰度和实现便利性方面，Numba 是明显的赢家。
 
@@ -582,13 +542,13 @@ Numba 版本简单直观，易于阅读：我们只需分配一个数组，然
 
 对于**顺序操作**，Numba 具有明显优势。
 
-代码自然易读——只需一个带装饰器的 Python 循环——且性能出色。
+代码自然且可读——只需一个带有装饰器的 Python 循环——性能也非常出色。
 
-JAX 可以通过 `lax.fori_loop` 或 `lax.scan` 处理顺序问题，但语法不够直观。
+JAX 可以通过 `lax.scan` 处理顺序问题，但语法不够直观。
 
 ```{note}
-`lax.fori_loop` 和 `lax.scan` 有一个重要优势：它们支持对循环进行自动微分，而 Numba 无法做到这一点。
-如果需要对顺序计算进行微分（例如，计算轨迹对模型参数的敏感性），尽管语法不够自然，JAX 仍是更好的选择。
+`lax.scan` 的一个重要优势是它支持通过循环进行自动微分，而 Numba 无法做到这一点。
+如果您需要对顺序计算进行微分（例如，计算轨迹对模型参数的敏感性），尽管语法不够自然，JAX 仍是更好的选择。
 ```
 
 在实践中，许多问题涉及两种模式的混合。