Update translation: lectures/numpy_vs_numba_vs_jax.md

Author: mmcky

lectures/numpy_vs_numba_vs_jax.md

@@ -24,6 +24,7 @@ translation:
     Sequential operations::Numba Version: نسخه Numba
     Sequential operations::JAX Version: نسخه JAX
     Sequential operations::Summary: خلاصه
+    Overall recommendations: توصیه‌های کلی
 ---
 
 (parallel)=
@@ -69,13 +70,17 @@ tags: [hide-output]
 
 ```{code-cell} ipython3
 import random
+from functools import partial
+
 import numpy as np
+import numba
 import quantecon as qe
 import matplotlib.pyplot as plt
 from mpl_toolkits.mplot3d.axes3d import Axes3D
 from matplotlib import cm
 import jax
 import jax.numpy as jnp
+from jax import lax
 ```
 
 ## عملیات برداری شده
@@ -113,7 +118,7 @@ ax.plot_surface(x,
                 y,
                 f(x, y),
                 rstride=2, cstride=2,
-                cmap=cm.jet,
+                cmap=cm.viridis,
                 alpha=0.7,
                 linewidth=0.25)
 ax.set_zlim(-0.5, 1.0)
@@ -139,7 +144,6 @@ for x in grid:
             m = z
 ```
 
-
 ### برداری‌سازی NumPy
 
 اگر به برداری‌سازی به سبک NumPy تغییر دهیم، می‌توانیم از یک شبکه بسیار بزرگتر استفاده کنیم و کد نسبتاً سریع اجرا می‌شود.
@@ -164,14 +168,11 @@ print(f"NumPy result: {z_max_numpy:.6f}")
 
 (موازی‌سازی نمی‌تواند بسیار کارآمد باشد زیرا فایل باینری قبل از اینکه اندازه آرایه‌های `x` و `y` را ببیند کامپایل می‌شود.)
 
-
 ### مقایسه با Numba
 
 حالا بیایید ببینیم آیا می‌توانیم با استفاده از Numba با یک حلقه ساده به عملکرد بهتری دست یابیم.
 
 ```{code-cell} ipython3
-import numba
-
 @numba.jit
 def compute_max_numba(grid):
     m = -np.inf
@@ -185,9 +186,9 @@ def compute_max_numba(grid):
 grid = np.linspace(-3, 3, 3_000)
 
 with qe.Timer(precision=8):
-    z_max_numpy = compute_max_numba(grid)
+    z_max_numba = compute_max_numba(grid)
 
-print(f"Numba result: {z_max_numpy:.6f}")
+print(f"Numba result: {z_max_numba:.6f}")
 ```
 
 بیایید دوباره اجرا کنیم تا زمان کامپایل حذف شود.
@@ -203,7 +204,6 @@ with qe.Timer(precision=8):
 
 از طرف دیگر، روال Numba از حافظه بسیار کمتری استفاده می‌کند، زیرا ما فقط با یک شبکه یک‌بعدی کار می‌کنیم.
 
-
 ### Numba موازی شده
 
 حالا بیایید موازی‌سازی با Numba را با استفاده از `prange` امتحان کنیم:
@@ -278,7 +278,6 @@ with qe.Timer(precision=8):
 
 برای دستگاه‌های قدرتمندتر و اندازه‌های شبکه بزرگتر، موازی‌سازی می‌تواند افزایش سرعت قابل توجهی ایجاد کند، حتی روی CPU.
 
-
 ### کد برداری شده با JAX
 
 در ظاهر، کد برداری شده در JAX شبیه به کد NumPy است.
@@ -299,7 +298,7 @@ def f(x, y):
 
 ```{code-cell} ipython3
 grid = jnp.linspace(-3, 3, 3_000)
-x_mesh, y_mesh = np.meshgrid(grid, grid)
+x_mesh, y_mesh = jnp.meshgrid(grid, grid)
 
 with qe.Timer(precision=8):
     z_max = jnp.max(f(x_mesh, y_mesh))
@@ -316,11 +315,10 @@ with qe.Timer(precision=8):
     z_max.block_until_ready()
 ```
 
-پس از کامپایل، JAX به دلیل شتاب GPU به طور قابل توجهی سریعتر از NumPy است.
+پس از کامپایل، JAX به ویژه روی GPU به طور قابل توجهی سریعتر از NumPy است.
 
 سربار کامپایل یک هزینه یک‌بار مصرف است که زمانی که تابع به طور مکرر فراخوانی می‌شود، بازگشت سرمایه دارد.
 
-
 ### JAX به علاوه vmap
 
 یک مشکل با کد NumPy و کد JAX وجود دارد:
@@ -382,7 +380,6 @@ with qe.Timer(precision=8):
 
 ما این ایده‌ها را بیشتر هنگام حل مسائل بزرگتر بررسی خواهیم کرد.
 
-
 ### نسخه 2 vmap
 
 می‌توانیم با استفاده از vmap همچنان کارآمدتر از نظر حافظه باشیم.
@@ -417,7 +414,7 @@ def compute_max_vmap_v2(grid):
 with qe.Timer(precision=8):
     z_max = compute_max_vmap_v2(grid).block_until_ready()
 
-print(f"JAX vmap v1 result: {z_max:.6f}")
+print(f"JAX vmap v2 result: {z_max:.6f}")
 ```
 
 بیایید دوباره اجرا کنیم تا زمان کامپایل حذف شود:
@@ -429,7 +426,6 @@ with qe.Timer(precision=8):
 
 اگر این را روی GPU اجرا می‌کنید، همانطور که ما این کار را می‌کنیم، باید افزایش سرعت قابل توجه دیگری را ببینید.
 
-
 ### خلاصه
 
 به نظر ما، JAX برنده برای عملیات برداری شده است.
@@ -444,7 +440,6 @@ with qe.Timer(precision=8):
 
 برای اکثر موارد مواجه شده در اقتصاد، اقتصادسنجی و امور مالی، بسیار بهتر است که برای موازی‌سازی کارآمد به کامپایلر JAX تحویل دهیم تا اینکه سعی کنیم این روال‌ها را خودمان کدنویسی دستی کنیم.
 
-
 ## عملیات ترتیبی
 
 برخی عملیات ذاتاً ترتیبی هستند -- و از این رو برداری کردن آنها دشوار یا غیرممکن است.
@@ -453,7 +448,6 @@ with qe.Timer(precision=8):
 
 برای مقایسه این انتخاب‌ها، مسئله تکرار روی نقشه درجه دوم را که در {doc}`سخنرانی Numba <numba>` خود دیدیم، دوباره بررسی خواهیم کرد.
 
-
 ### نسخه Numba
 
 در اینجا نسخه Numba آمده است.
@@ -497,9 +491,6 @@ Numba این عملیات ترتیبی را به طور بسیار کارآمد
 (ما `n` را ایستا نگه می‌داریم زیرا بر اندازه آرایه تأثیر می‌گذارد و از این رو JAX می‌خواهد روی مقدار آن در کد کامپایل شده تخصصی شود.)
 
 ```{code-cell} ipython3
-from jax import lax
-from functools import partial
-
 cpu = jax.devices("cpu")[0]
 
 @partial(jax.jit, static_argnums=(1,), device=cpu)
@@ -542,7 +533,6 @@ JAX نیز برای این عملیات ترتیبی کاملاً کارآمد 
 
 هم JAX و هم Numba عملکرد قوی پس از کامپایل ارائه می‌دهند، با این که Numba معمولاً (اما نه همیشه) سرعت‌های کمی بهتری در عملیات کاملاً ترتیبی ارائه می‌دهد.
 
-
 ### خلاصه
 
 در حالی که هم Numba و هم JAX عملکرد قوی برای عملیات ترتیبی ارائه می‌دهند، *تفاوت‌های قابل توجهی در خوانایی کد و سهولت استفاده وجود دارد*.
@@ -555,4 +545,30 @@ JAX نیز برای این عملیات ترتیبی کاملاً کارآمد 
 
 علاوه بر این، آرایه‌های تغییرناپذیر JAX به این معنی است که نمی‌توانیم به سادگی عناصر آرایه را در جا به‌روزرسانی کنیم و تکرار مستقیم الگوریتم مورد استفاده توسط Numba را سخت می‌کند.
 
-برای این نوع عملیات ترتیبی، Numba برنده واضح از نظر وضوح کد و سهولت پیاده‌سازی، و همچنین عملکرد بالا است.
+برای این نوع عملیات ترتیبی، Numba برنده واضح از نظر وضوح کد و سهولت پیاده‌سازی، و همچنین عملکرد بالا است.
+
+## توصیه‌های کلی
+
+حال قدمی به عقب بر می‌داریم و مبادلات را خلاصه می‌کنیم.
+
+برای **عملیات برداری‌سازی‌شده**، JAX قوی‌ترین انتخاب است.
+
+به لطف کامپایل JIT و موازی‌سازی کارآمد روی CPU و GPU، در سرعت با NumPy برابری می‌کند یا از آن پیشی می‌گیرد.
+
+تبدیل `vmap` مصرف حافظه را کاهش می‌دهد و اغلب نسبت به برداری‌سازی سنتی مبتنی بر meshgrid، کد روشن‌تری ارائه می‌دهد.
+
+علاوه بر این، توابع JAX به‌صورت خودکار مشتق‌پذیر هستند، همان‌طور که در {doc}`autodiff` بررسی می‌کنیم.
+
+برای **عملیات ترتیبی**، Numba مزایای آشکاری دارد.
+
+کد طبیعی و خوانا است --- صرفاً یک حلقه پایتون با یک decorator --- و کارایی آن عالی است.
+
+JAX می‌تواند مسائل ترتیبی را از طریق `lax.scan` مدیریت کند، اما نحو آن کمتر شهودی است و برای کارهای کاملاً ترتیبی، بهره‌وری اضافی ناچیز است.
+
+با این حال، `lax.scan` یک مزیت مهم دارد: از مشتق‌گیری خودکار در طول حلقه پشتیبانی می‌کند، که Numba قادر به انجام آن نیست.
+
+اگر نیاز دارید از طریق یک محاسبه ترتیبی مشتق بگیرید (مثلاً محاسبه حساسیت‌های یک مسیر نسبت به پارامترهای مدل)، JAX علی‌رغم نحو کمتر طبیعی‌اش، انتخاب بهتری است.
+
+در عمل، بسیاری از مسائل ترکیبی از هر دو الگو هستند.
+
+یک قاعده سرانگشتی مناسب: برای پروژه‌های جدید، به‌ویژه زمانی که شتاب‌دهی سخت‌افزاری یا مشتق‌پذیری ممکن است مفید باشد، به‌طور پیش‌فرض از JAX استفاده کنید، و هنگامی که یک حلقه ترتیبی فشرده نیاز به سرعت و خوانایی دارد، به Numba متوسل شوید.