Update translation: lectures/numpy_vs_numba_vs_jax.md

Author: mmcky

lectures/numpy_vs_numba_vs_jax.md

@@ -17,8 +17,6 @@ translation:
     Vectorized operations::Parallelized Numba: Numba موازی شده
     Vectorized operations::Vectorized code with JAX: کد برداری شده با JAX
     Vectorized operations::JAX plus vmap: JAX به علاوه vmap
-    Vectorized operations::JAX plus vmap::Version 1: نسخه 1
-    Vectorized operations::vmap version 2: نسخه 2 vmap
     Vectorized operations::Summary: خلاصه
     Sequential operations: عملیات ترتیبی
     Sequential operations::Numba Version: نسخه Numba
@@ -27,7 +25,7 @@ translation:
     Overall recommendations: توصیه‌های کلی
 ---
 
-(parallel)=
+(numpy_numba_jax)=
 ```{raw} jupyter
 <div id="qe-notebook-header" align="right" style="text-align:right;">
         <a href="https://quantecon.org/" title="quantecon.org">
@@ -156,7 +154,7 @@ for x in grid:
 grid = np.linspace(-3, 3, 3_000)
 x, y = np.meshgrid(grid, grid)
 
-with qe.Timer(precision=8):
+with qe.Timer():
     z_max_numpy = np.max(f(x, y))
 
 print(f"NumPy result: {z_max_numpy:.6f}")
@@ -179,13 +177,17 @@ def compute_max_numba(grid):
     for x in grid:
         for y in grid:
             z = np.cos(x**2 + y**2) / (1 + x**2 + y**2)
-            if z > m:
-                m = z
+            m = max(m, z)
     return m
+```
+
+بیایید آن را آزمایش کنیم:
 
+```{code-cell} ipython3
 grid = np.linspace(-3, 3, 3_000)
 
-with qe.Timer(precision=8):
+with qe.Timer():
+    # First run
     z_max_numba = compute_max_numba(grid)
 
 print(f"Numba result: {z_max_numba:.6f}")
@@ -194,22 +196,23 @@ print(f"Numba result: {z_max_numba:.6f}")
 بیایید دوباره اجرا کنیم تا زمان کامپایل حذف شود.
 
 ```{code-cell} ipython3
-with qe.Timer(precision=8):
+with qe.Timer():
+    # Second run
     compute_max_numba(grid)
 ```
 
-بسته به دستگاه شما، نسخه Numba می‌تواند کمی کندتر یا کمی سریعتر از NumPy باشد.
+بسته به دستگاه شما، نسخه Numba ممکن است کندتر یا سریعتر از NumPy باشد.
 
-از یک طرف، NumPy محاسبات کارآمد (مانند Numba) را با مقداری چندنخی (برخلاف این کد Numba) ترکیب می‌کند که مزیتی فراهم می‌کند.
+در اکثر موارد، Numba کمی بهتر است.
+
+از یک طرف، NumPy محاسبات کارآمد را با مقداری چندنخی ترکیب می‌کند که مزیتی فراهم می‌کند.
 
 از طرف دیگر، روال Numba از حافظه بسیار کمتری استفاده می‌کند، زیرا ما فقط با یک شبکه یک‌بعدی کار می‌کنیم.
 
 ### Numba موازی شده
 
 حالا بیایید موازی‌سازی با Numba را با استفاده از `prange` امتحان کنیم:
 
-در اینجا یک تلاش ساده و *نادرست* آمده است.
-
 ```{code-cell} ipython3
 @numba.jit(parallel=True)
 def compute_max_numba_parallel(grid):
@@ -220,57 +223,25 @@ def compute_max_numba_parallel(grid):
             x = grid[i]
             y = grid[j]
             z = np.cos(x**2 + y**2) / (1 + x**2 + y**2)
-            if z > m:
-                m = z
+            m = max(m, z)
     return m
-
 ```
 
-معمولاً این نتیجه نادرستی برمی‌گرداند:
-
-```{code-cell} ipython3
-z_max_parallel_incorrect = compute_max_numba_parallel(grid)
-print(f"Numba result: {z_max_parallel_incorrect} 😱")
-```
-
-دلیل این است که متغیر `m` بین نخ‌ها مشترک است و به درستی کنترل نمی‌شود.
-
-وقتی چندین نخ سعی می‌کنند همزمان `m` را بخوانند و بنویسند، با یکدیگر تداخل می‌کنند.
-
-نخ‌ها مقادیر قدیمی `m` را می‌خوانند یا به‌روزرسانی‌های یکدیگر را بازنویسی می‌کنند --- یا `m` هرگز از مقدار اولیه خود به‌روزرسانی نمی‌شود.
-
-در اینجا یک نسخه با دقت بیشتری نوشته شده است.
+در اینجا یک اجرای گرم‌کننده و آزمایش آمده است.
 
 ```{code-cell} ipython3
-@numba.jit(parallel=True)
-def compute_max_numba_parallel(grid):
-    n = len(grid)
-    row_maxes = np.empty(n)
-    for i in numba.prange(n):
-        row_max = -np.inf
-        for j in range(n):
-            x = grid[i]
-            y = grid[j]
-            z = np.cos(x**2 + y**2) / (1 + x**2 + y**2)
-            if z > row_max:
-                row_max = z
-        row_maxes[i] = row_max
-    return np.max(row_maxes)
-```
+with qe.Timer():
+    # First run
+    z_max_parallel = compute_max_numba_parallel(grid)
 
-اکنون بلوک کدی که `for i in numba.prange(n)` روی آن عمل می‌کند بین `i` ها مستقل است.
-
-هر نخ به یک عنصر جداگانه از آرایه `row_maxes` می‌نویسد و موازی‌سازی ایمن است.
-
-```{code-cell} ipython3
-z_max_parallel = compute_max_numba_parallel(grid)
 print(f"Numba result: {z_max_parallel:.6f}")
 ```
 
-در اینجا زمان‌بندی آمده است.
+در اینجا زمان‌بندی برای نسخه از پیش کامپایل شده آمده است.
 
 ```{code-cell} ipython3
-with qe.Timer(precision=8):
+with qe.Timer():
+    # Second run
     compute_max_numba_parallel(grid)
 ```
 
@@ -284,8 +255,7 @@ with qe.Timer(precision=8):
 
 اما تفاوت‌هایی نیز وجود دارد که در اینجا آنها را برجسته می‌کنیم.
 
-بیایید با تابع شروع کنیم.
-
+بیایید با تابع شروع کنیم که `np` را به `jnp` تغییر می‌دهد و `jax.jit` را اضافه می‌کند.
 
 ```{code-cell} ipython3
 @jax.jit
@@ -299,9 +269,15 @@ def f(x, y):
 ```{code-cell} ipython3
 grid = jnp.linspace(-3, 3, 3_000)
 x_mesh, y_mesh = jnp.meshgrid(grid, grid)
+```
+
+حالا بیایید اجرا و زمان‌بندی کنیم
 
-with qe.Timer(precision=8):
+```{code-cell} ipython3
+with qe.Timer():
+    # First run
     z_max = jnp.max(f(x_mesh, y_mesh))
+    # Hold interpreter
     z_max.block_until_ready()
 
 print(f"Plain vanilla JAX result: {z_max:.6f}")
@@ -310,8 +286,10 @@ print(f"Plain vanilla JAX result: {z_max:.6f}")
 بیایید دوباره اجرا کنیم تا زمان کامپایل حذف شود.
 
 ```{code-cell} ipython3
-with qe.Timer(precision=8):
+with qe.Timer():
+    # Second run
     z_max = jnp.max(f(x_mesh, y_mesh))
+    # Hold interpreter
     z_max.block_until_ready()
 ```
 
@@ -339,14 +317,14 @@ x_mesh.nbytes + y_mesh.nbytes
 
 خوشبختانه، JAX رویکرد متفاوتی را با استفاده از [jax.vmap](https://docs.jax.dev/en/latest/_autosummary/jax.vmap.html) می‌پذیرد.
 
-#### نسخه 1
+ایده `vmap` این است که برداری‌سازی را به مراحل تقسیم کند و تابعی که روی مقادیر منفرد عمل می‌کند را به تابعی تبدیل کند که روی آرایه‌ها عمل می‌کند.
 
-در اینجا یک راه برای اعمال `vmap` آمده است.
+در اینجا نحوه اعمال آن به مسئله ما آمده است.
 
 ```{code-cell} ipython3
-# f را تنظیم کنید تا f(x, y) را در هر x برای هر y داده شده محاسبه کند
+# Set up f to compute f(x, y) at every x for any given y
 f_vec_x = lambda y: f(grid, y)
-# یک تابع دوم ایجاد کنید که این عملیات را روی تمام y برداری کند
+# Create a second function that vectorizes this operation over all y
 f_vec = jax.vmap(f_vec_x)
 ```
 
@@ -355,49 +333,37 @@ f_vec = jax.vmap(f_vec_x)
 بیایید زمان‌بندی را ببینیم:
 
 ```{code-cell} ipython3
-with qe.Timer(precision=8):
+with qe.Timer():
     z_max = jnp.max(f_vec(grid))
     z_max.block_until_ready()
 
 print(f"JAX vmap v1 result: {z_max:.6f}")
 ```
 
 ```{code-cell} ipython3
-with qe.Timer(precision=8):
+with qe.Timer():
     z_max = jnp.max(f_vec(grid))
     z_max.block_until_ready()
 ```
 
-با اجتناب از آرایه‌های ورودی بزرگ `x_mesh` و `y_mesh`، این نسخه `vmap` از حافظه بسیار کمتری استفاده می‌کند.
-
-وقتی روی CPU اجرا می‌شود، زمان اجرای آن شبیه به نسخه meshgrid است.
-
-وقتی روی GPU اجرا می‌شود، معمولاً به طور قابل توجهی سریعتر است.
-
-در واقع، استفاده از `vmap` مزیت دیگری دارد: به ما اجازه می‌دهد برداری‌سازی را به مراحل تقسیم کنیم.
-
-این منجر به کدی می‌شود که اغلب راحت‌تر از کد برداری شده سنتی قابل درک است.
+با اجتناب از آرایه‌های ورودی بزرگ `x_mesh` و `y_mesh`، این نسخه `vmap` از حافظه بسیار کمتری استفاده می‌کند و زمان اجرا نیز تغییر چندانی نمی‌کند.
 
-ما این ایده‌ها را بیشتر هنگام حل مسائل بزرگتر بررسی خواهیم کرد.
+این خوب است --- اما هنوز از دستاوردهای سرعت بهره نمی‌بریم!
 
-### نسخه 2 vmap
+اول توجه کنید که کد بالا آرایه دوبعدی کامل `f(x,y)` را محاسبه می‌کند که پیش از گرفتن حداکثر، سربارهایی ایجاد می‌کند.
 
-می‌توانیم با استفاده از vmap همچنان کارآمدتر از نظر حافظه باشیم.
+دوم، فراخوانی `jnp.max` خارج از تابع JIT-compiled شده `f` قرار دارد، بنابراین کامپایلر نمی‌تواند این عملیات را در یک kernel واحد ادغام کند.
 
-در حالی که در نسخه قبلی از آرایه‌های ورودی بزرگ اجتناب می‌کنیم، هنوز آرایه خروجی بزرگ `f(x,y)` را قبل از محاسبه حداکثر ایجاد می‌کنیم.
-
-بیایید یک رویکرد کمی متفاوت را امتحان کنیم که max را به داخل می‌برد.
-
-به دلیل این تغییر، ما هرگز آرایه دوبعدی `f(x,y)` را محاسبه نمی‌کنیم.
+می‌توانیم هر دو مشکل را با انتقال max به داخل و پوشش دادن همه چیز در یک `@jax.jit` واحد برطرف کنیم:
 
 ```{code-cell} ipython3
 @jax.jit
-def compute_max_vmap_v2(grid):
-    # یک تابع بسازید که حداکثر را در امتداد هر سطر بگیرد
+def compute_max_vmap(grid):
+    # Construct a function that takes the max along each row
     f_vec_x_max = lambda y: jnp.max(f(grid, y))
-    # تابع را برداری کنید تا بتوانیم روی تمام سطرها همزمان فراخوانی کنیم
+    # Vectorize the function so we can call on all rows simultaneously
     f_vec_max = jax.vmap(f_vec_x_max)
-    # تابع برداری شده را فراخوانی کنید و حداکثر را بگیرید
+    # Call the vectorized function and take the max
     return jnp.max(f_vec_max(grid))
 ```
 
@@ -408,24 +374,32 @@ def compute_max_vmap_v2(grid):
 
 ما این تابع را روی تمام سطرها اعمال می‌کنیم و سپس حداکثر max های سطر را می‌گیریم.
 
+از آنجایی که max را به داخل انتقال می‌دهیم، هرگز آرایه دوبعدی کامل `f(x,y)` را نمی‌سازیم و حافظه بیشتری ذخیره می‌کنیم.
+
+و از آنجایی که همه چیز زیر یک `@jax.jit` واحد است، کامپایلر می‌تواند تمام عملیات را در یک kernel بهینه ادغام کند.
+
 بیایید آن را امتحان کنیم.
 
 ```{code-cell} ipython3
-with qe.Timer(precision=8):
-    z_max = compute_max_vmap_v2(grid).block_until_ready()
+with qe.Timer():
+    # First run
+    z_max = compute_max_vmap(grid)
+    # Hold interpreter
+    z_max.block_until_ready()
 
-print(f"JAX vmap v2 result: {z_max:.6f}")
+print(f"JAX vmap result: {z_max:.6f}")
 ```
 
 بیایید دوباره اجرا کنیم تا زمان کامپایل حذف شود:
 
 ```{code-cell} ipython3
-with qe.Timer(precision=8):
-    z_max = compute_max_vmap_v2(grid).block_until_ready()
+with qe.Timer():
+    # Second run
+    z_max = compute_max_vmap(grid)
+    # Hold interpreter
+    z_max.block_until_ready()
 ```
 
-اگر این را روی GPU اجرا می‌کنید، همانطور که ما این کار را می‌کنیم، باید افزایش سرعت قابل توجه دیگری را ببینید.
-
 ### خلاصه
 
 به نظر ما، JAX برنده برای عملیات برداری شده است.
@@ -467,14 +441,16 @@ def qm(x0, n, α=4.0):
 ```{code-cell} ipython3
 n = 10_000_000
 
-with qe.Timer(precision=8):
+with qe.Timer():
+    # First run
     x = qm(0.1, n)
 ```
 
 بیایید دوباره اجرا کنیم تا زمان کامپایل حذف شود:
 
 ```{code-cell} ipython3
-with qe.Timer(precision=8):
+with qe.Timer():
+    # Second run
     x = qm(0.1, n)
 ```
 
@@ -493,7 +469,7 @@ Numba این عملیات ترتیبی را به طور بسیار کارآمد
 ```{code-cell} ipython3
 cpu = jax.devices("cpu")[0]
 
-@partial(jax.jit, static_argnums=(1,), device=cpu)
+@partial(jax.jit, static_argnames=('n',), device=cpu)
 def qm_jax(x0, n, α=4.0):
     def update(x, t):
         x_new = α * x * (1 - x)
@@ -506,32 +482,32 @@ def qm_jax(x0, n, α=4.0):
 این کد خواندن آسانی ندارد اما، در اصل، `lax.scan` به طور مکرر `update` را فراخوانی می‌کند و بازگشت‌های `x_new` را در یک آرایه جمع می‌کند.
 
 ```{note}
-خوانندگان تیزبین متوجه خواهند شد که ما `device=cpu` را در decorator `jax.jit` مشخص می‌کنیم.
-
-محاسبه از بسیاری عملیات ترتیبی کوچک تشکیل شده است که فرصت کمی برای بهره‌برداری GPU از موازی‌سازی باقی می‌گذارد.
-
-در نتیجه، سربار راه‌اندازی kernel تمایل دارد روی GPU غالب شود و CPU را متناسب‌تر برای این بار کاری می‌کند.
-
-خوانندگان کنجکاو می‌توانند حذف این گزینه را امتحان کنند تا ببینند چگونه عملکرد تغییر می‌کند.
+ما `device=cpu` را در decorator `jax.jit` مشخص می‌کنیم زیرا این محاسبه از بسیاری عملیات ترتیبی کوچک تشکیل شده است که فرصت کمی برای بهره‌برداری GPU از موازی‌سازی باقی می‌گذارد. در نتیجه، سربار راه‌اندازی kernel تمایل دارد روی GPU غالب شود و CPU را متناسب‌تر برای این بار کاری می‌کند.
 ```
 
 بیایید آن را با همان پارامترها زمان‌بندی کنیم:
 
 ```{code-cell} ipython3
-with qe.Timer(precision=8):
-    x_jax = qm_jax(0.1, n).block_until_ready()
+with qe.Timer():
+    # First run
+    x_jax = qm_jax(0.1, n)
+    # Hold interpreter
+    x_jax.block_until_ready()
 ```
 
 بیایید دوباره اجرا کنیم تا سربار کامپایل حذف شود:
 
 ```{code-cell} ipython3
-with qe.Timer(precision=8):
-    x_jax = qm_jax(0.1, n).block_until_ready()
+with qe.Timer():
+    # Second run
+    x_jax = qm_jax(0.1, n)
+    # Hold interpreter
+    x_jax.block_until_ready()
 ```
 
 JAX نیز برای این عملیات ترتیبی کاملاً کارآمد است.
 
-هم JAX و هم Numba عملکرد قوی پس از کامپایل ارائه می‌دهند، با این که Numba معمولاً (اما نه همیشه) سرعت‌های کمی بهتری در عملیات کاملاً ترتیبی ارائه می‌دهد.
+هم JAX و هم Numba عملکرد قوی پس از کامپایل ارائه می‌دهند.
 
 ### خلاصه
 
@@ -545,7 +521,7 @@ JAX نیز برای این عملیات ترتیبی کاملاً کارآمد 
 
 علاوه بر این، آرایه‌های تغییرناپذیر JAX به این معنی است که نمی‌توانیم به سادگی عناصر آرایه را در جا به‌روزرسانی کنیم و تکرار مستقیم الگوریتم مورد استفاده توسط Numba را سخت می‌کند.
 
-برای این نوع عملیات ترتیبی، Numba برنده واضح از نظر وضوح کد و سهولت پیاده‌سازی، و همچنین عملکرد بالا است.
+برای این نوع عملیات ترتیبی، Numba برنده واضح از نظر وضوح کد و سهولت پیاده‌سازی است.
 
 ## توصیه‌های کلی