آموزش Numba: افزایش چشمگیر سرعت کدهای محاسباتی پایتون

اگر از کندی اجرای کدهای محاسباتی، حلقه‌های تکرار طولانی یا پردازش‌های سنگین ریاضی در پایتون خسته شده‌اید، Numba نجات‌دهنده شماست. در این مقاله کاملاً کاربردی یاد می‌گیرید که چگونه با اضافه کردن تنها یک خط کد به توابع خود، سرعت اجرای آن‌ها را تا ۱۰۰ برابر افزایش دهید و به عملکردی هم‌سطح زبان‌های C یا C++ برسید. هدف ما آموزش گام‌به‌گام پیاده‌سازی این کتابخانه قدرتمند در پروژه‌های واقعی پایتون است.

۱. Numba چیست و چگونه کار می‌کند؟

پاسخ کوتاه: نامبا (Numba) یک کامپایلر JIT یا Just-In-Time برای پایتون است که کدهای ریاضیاتی و متمرکز بر آرایه‌ها را به کدهای ماشین بسیار سریع تبدیل می‌کند. این ابزار با استفاده از زیرساخت کامپایلر LLVM کار می‌کند و به شما اجازه می‌دهد بدون نیاز به یادگیری زبان‌های سختی مثل C، سرعت پردازش کدهای خود را بهینه‌سازی کنید.

وقتی شما یک تابع پایتون مجهز به دکوراتورهای Numba را اجرا می‌کنید، در اولین فراخوانی، بایت‌کد پایتون توسط Numba تحلیل شده و با توجه به نوع داده‌های ورودی، به کد ماشین بهینه برای پردازنده شما (CPU یا حتی GPU) کامپایل می‌شود. در دفعات بعدی اجرای این تابع، کد کامپایل‌شده مستقیماً روی سخت‌افزار اجرا می‌شود و مفسر کند پایتون کاملاً دور زده خواهد شد.

۲. چرا پایتون کند است و Numba چطور آن را حل می‌کند؟

پاسخ کوتاه: پایتون یک زبان پویا (Dynamically Typed) و مفسری است؛ یعنی در هر خط از اجرای کد، مفسر باید نوع داده‌ها را بررسی کند و مدیریت حافظه را انجام دهد که این کار در حلقه‌های تکرار بزرگ، افت شدید سرعت را به همراه دارد. Numba این مشکل را با تبدیل پویا به ایستا در زمان اجرا حل می‌کند.

برای مثال، وقتی در پایتون یک حلقه ساده را اجرا می‌کنید که یک میلیون بار تکرار می‌شود، مفسر پایتون در هر تکرار باید چک کند که آیا متغیرها هنوز از نوع عدد هستند یا خیر. این سربار بررسی مداوم، سرعت اجرای کد را به شدت کاهش می‌دهد. Numba قبل از شروع حلقه، نوع داده‌ها را مشخص کرده و کدی کامپایل می‌کند که درست مانند یک برنامه نوشته‌شده با زبان C، بدون هیچ بررسی اضافه‌ای، با حداکثر توان پردازنده اجرا می‌شود. برای بهینه‌سازی بیشتر در پروژه‌های خود، استفاده از تکه‌کدهای پایتون استاندارد در کنار ابزارهای بهینه‌سازی مثل Numba بهترین رویکرد است.

۳. نصب و راه‌اندازی Numba

پاسخ کوتاه: برای نصب Numba کافی است از مدیریت پکیج pip یا conda استفاده کنید. این کتابخانه به راحتی روی سیستم‌عامل‌های ویندوز، مک و لینوکس نصب می‌شود.

پیش‌نیاز اصلی این کتابخانه، وجود NumPy است که در فرآیند نصب به طور خودکار پیکربندی می‌شود. دستورات زیر را در ترمینال یا محیط Command Prompt خود اجرا کنید:

# نصب از طریق pip
pip install numba

# نصب از طریق conda (اگر از آناکوندا استفاده می‌کنید)
conda install numba

۴. اولین پروژه با Numba: بهینه‌سازی با دکوراتور @jit

پاسخ کوتاه: ساده‌ترین راه برای شتاب‌دهی به یک تابع در پایتون، ایمپورت کردن دکوراتور @jit یا بهتر از آن @njit از کتابخانه Numba و قرار دادن آن درست بالای تعریف تابع شماست.

بیایید با یک مثال عملی این موضوع را بررسی کنیم. فرض کنید تابعی داریم که فرمول ریاضی پیچیده‌ای را روی یک رنج بزرگ اعمال می‌کند:

from numba import njit
import time

# تعریف تابع بهینه‌سازی شده با Numba
@njit
def calculate_sum(n):
    total = 0.0
    for i in range(n):
        total += (i % 3) * 3.14
    return total

# اولین اجرای تابع (شامل زمان کامپایل)
start = time.time()
calculate_sum(50_000_000)
print(f"زمان اجرای اول: {time.time() - start:.4f} ثانیه")

# اجرای دوم (بدون زمان کامپایل - با حداکثر سرعت کدهای کامپایل شده)
start = time.time()
calculate_sum(50_000_000)
print(f"زمان اجرای دوم: {time.time() - start:.4f} ثانیه")

وقتی این کد را اجرا می‌کنید، متوجه تفاوت خیره‌کننده زمان اجرای اول و دوم خواهید شد. اجرای دوم عملاً در کسری از میلی‌ثانیه به پایان می‌رسد زیرا کدهای شما قبلاً به زبان ماشین کامپایل شده‌اند. استفاده از دکوراتور @njit در واقع حالت مخفف‌شده‌ی @jit(nopython=True) است که مطمئن‌ترین روش برای اجرای پرسرعت کدهاست.

۵. تفاوت حالت‌های nopython و object

پاسخ کوتاه: نامبا دو حالت اصلی برای اجرا دارد: حالت nopython mode که کد را کاملاً مستقل از مفسر پایتون اجرا کرده و بالاترین سرعت ممکن را ارائه می‌دهد، و حالت object mode که اگر نتواند متغیرها را به زبان ماشین ترجمه کند، کد را به اشیاء معمولی پایتون ارجاع می‌دهد که سرعت بسیار کمتری دارد.

جدول زیر تفاوت‌های کلیدی این دو حالت را به صورت خلاصه نشان می‌دهد:

۶. شتاب‌دهی به محاسبات NumPy و پردازش موازی

پاسخ کوتاه: Numba به طور پیش‌فرض سازگاری فوق‌العاده‌ای با آرایه‌های NumPy دارد. با فعال کردن آرگومان parallel=True، محاسبات آرایه‌ای شما بر روی تمام هسته‌های فیزیکی پردازنده توزیع و به صورت موازی اجرا می‌شوند.

برای پیاده‌سازی پردازش موازی واقعی، نامبا ابزار prange را ارائه می‌دهد که جایگزین حلقه سنتی range می‌شود. استفاده از این ابزار اجازه می‌دهد هر تکرار حلقه روی یک ترید (Thread) مجزا اجرا شود:

from numba import njit, prange
import numpy as np

@njit(parallel=True)
def parallel_vector_add(x, y):
    size = len(x)
    result = np.zeros(size)
    # استفاده از prange بجای range برای فعال‌سازی چند نخی
    for i in prange(size):
        result[i] = x[i] + y[i] * 2.0
    return result

این قابلیت به شما کمک می‌کند بدون سردرد کار با ماژول multiprocessing پایتون، پتانسیل سخت‌افزارهای مدرن چندهسته‌ای را برای محاسبات سنگین ریاضی خود به طور کامل مهار کنید.

۷. سناریوی کاربردی و تست بنچمارک واقعی

بیایید برای درک قدرت واقعی Numba، یک سناریوی بسیار مرسوم یعنی محاسبه فاصله اقلیدسی متقابل بین مجموعه‌ای از نقاط (Pairwise Distance) را بررسی کنیم. این مسئله به دلیل داشتن حلقه‌های تودرتو، در پایتون خام به شدت کند اجرا می‌شود.

import numpy as np
from numba import njit
import time

# تابع با پایتون خالص و کند
def pairwise_distance_python(X):
    n_samples = X.shape[0]
    n_features = X.shape[1]
    distances = np.zeros((n_samples, n_samples))
    for i in range(n_samples):
        for j in range(n_samples):
            d = 0.0
            for k in range(n_features):
                tmp = X[i, k] - X[j, k]
                d += tmp * tmp
            distances[i, j] = np.sqrt(d)
    return distances

# نسخه بهینه‌شده با Numba
@njit
def pairwise_distance_numba(X):
    n_samples = X.shape[0]
    n_features = X.shape[1]
    distances = np.zeros((n_samples, n_samples))
    for i in range(n_samples):
        for j in range(n_samples):
            d = 0.0
            for k in range(n_features):
                tmp = X[i, k] - X[j, k]
                d += tmp * tmp
            distances[i, j] = np.sqrt(d)
    return distances

# تولید داده نمونه تصادفی
X = np.random.random((1000, 10))

# تست زمان پایتون معمولی
start = time.time()
pairwise_distance_python(X)
print(f"مدت زمان پایتون معمولی: {time.time() - start:.4f} ثانیه")

# گرم کردن کامپایلر Numba
pairwise_distance_numba(X)

# تست زمان عملکرد Numba کامپایل شده
start = time.time()
pairwise_distance_numba(X)
print(f"مدت زمان Numba: {time.time() - start:.4f} ثانیه")

نتیجه آزمایش روی یک سیستم استاندارد: نسخه پایتون معمولی بیش از ۷ ثانیه طول می‌کشد؛ در حالی که کد مجهز به Numba فرآیند فوق را در کمتر از ۰.۰۵ ثانیه انجام می‌دهد. این یعنی بهبود عملکردی بیش از ۱۴۰ برابر، فقط با یک دکوراتور ساده!

۸. عیب‌یابی سریع خطاهای رایج

کار با Numba در ابتدای مسیر ممکن است با چالش‌هایی مواجه شود. در اینجا راه‌حل رفع خطاهای متداول آورده شده است:

• خطای TypingError: این خطا زمانی اتفاق می‌افتد که Numba نتواند نوع یک داده (مانند متغیرهای دیکشنری پیچیده یا آبجکت‌های سفارشی) را تشخیص دهد.
  راه حل: در داخل توابعی که دکوراتور @njit دارند، فقط از آرایه‌های NumPy و متغیرهای ساده مانند اعداد و لیست‌های استاندارد استفاده کنید و کلاس‌های سنگین پایتون را وارد بدنه تابع نکنید.
• عدم پشتیبانی از Pandas: اگر تلاش کنید کدهای دیتابیس یا دیتافریم پنداس را مستقیماً وارد دکوراتور نامبا کنید، خطا دریافت خواهید کرد.
  راه حل: قبل از فرستادن اطلاعات به تابع نامبا، دیتافریم‌های پنداس را با استفاده از متد .to_numpy() به آرایه نامپای تبدیل کنید و سپس روی آرایه محاسبات انجام دهید.
• مشکل بالا بودن زمان اولین اجرا: اولین اجرای برنامه شما با تاخیر مواجه می‌شود زیرا نامبا در حال کامپایل کردن توابع است.
  راه حل: می‌توانید از قابلیت cache=True در دکوراتور خود استفاده کنید (به صورت @njit(cache=True)) تا فرآیند کامپایل در فایل‌های دیسک ذخیره شده و در اجراهای بعدی نیازی به تکرار کامپایل نباشد.

۹. پرسش‌های متداول (FAQ)