سرفصل‌ها درس 187 از 250 · الگوهای تولید: تلاش‌های مجدد، غیرهم‌زمان، پخش جریانی و حافظه
الگوهای تولید: تلاش‌های مجدد، غیرهم‌زمان، پخش جریانی و حافظه

فراخوانی‌های دسته‌ای همزمان (توسعه محدود)

وقتی برای هزاران پرس‌وجو به پاسخ نیاز دارید، فراخوانی مدل به‌صورت تک‌تک و انتظار برای هر پاسخ به‌شدت کند است. اپلیکیشن‌های واقعی درخواست‌های زیادی را به‌طور همزمان ارسال می‌کنند -> اما نه نامحدود: هر ارائه‌دهنده تعداد تماس‌های در حال اجرا را محدود می‌کند، بنابراین شما کار را در دسته‌های با اندازهٔ ثابت پردازش می‌کنید. دو واقعیت هم‌زمانی را پیچیده می‌کنند و هر دو در اینجا دیده می‌شوند.

  • نتایج ممکن است به‌صورت نامرتب بازگردند. ممکن است یک پرسش کوتاه قبل از پرسش بلندی که ابتدا ارسال کرده‌اید، پاسخ دهد. کد شما باید پاسخ‌ها را بر اساس موقعیت اصلی ورودی‌شان دوباره مرتب کند، نه بر اساس کسی که زودتر پاسخ داده است.
  • نرخ انتقال داده توسط این محدودیت تعیین می‌شود. با n پرامپت‌ها و یک محدودیت برای c، شما اجرا می‌کنید ceil(n / c) دسته‌های کاری -> عددی که هر طرح ظرفیت بر اساس آن ساخته می‌شود.

یک نسخه تولیدی از asyncio و یک کلاینت شبکه واقعی. برای اینکه این نسخهٔ اول آسان دنبال شود، همان ساختار را با توابع ساده و یک حلقهٔ زمان‌بندی مدل می‌کنید -> بدون حلقهٔ رویداد، بدون شبکه، بدون مدل واقعی. در اینجا شکل واقعی، برای مرجع، همان منطق با یک حلقهٔ رویداد زنده است:

import asyncio

async def run_batch(prompts, worker, cap=4):
    sem = asyncio.Semaphore(cap)            # the concurrency cap
    async def one(i):
        async with sem:                     # at most cap in flight
            return i, await worker(prompts[i])
    pairs = await asyncio.gather(*(one(i) for i in range(len(prompts))))
    results = [None] * len(prompts)
    for i, r in pairs:                       # reassemble by ORIGINAL index
        results[i] = r["result"]
    return results

A Semaphore محدودیت را اعمال می‌کند، gather فراخوانی‌ها را با هم اجرا می‌کند، و شما همچنان هر پاسخ را به جایگاه اصلی‌اش بازمی‌نویسید. یک تفاوت با دسته‌های آتی را ببینید: با استفاده از سِمافور، یک فراخوانی جدید به محض پایان هر فراخوانی آغاز می‌شود، بنابراین همیشه تا cap در حین اجرا، در حالی که دسته‌های ثابت قبل از شروع تماس بعدی، منتظر کندترین تماس در هر دسته می‌مانند. نسخه سِمافور سریع‌تر است؛ استدلال درباره دسته‌ها ساده‌تر است. کد ناهمزمان نیز قابل تست است (با asyncio.run و کارگران ساختگی)؛ در اینجا نسخهٔ دسته‌ای را با یک زمان‌بندی‌کنندهٔ ساده می‌سازید تا منطق حفظ شود. یک worker(prompt) نماینده فراخوان مدل است و مقدار بازگشتی را برمی‌گرداند {"result": ..., "cost": ...}، که cost نشان‌دهنده مدت زمانی است که آن آیتم طول می‌کشد. شما عمداً هر دسته را با ترتیب هزینه متفاوت زمان‌بندی می‌کنید تا ثابت کنید مونتاژ نتیجه شما به‌طور پنهانی به آن وابسته نیست.

for start in range(0, len(prompts), cap):
    window = range(start, min(start + cap, len(prompts)))
    # work the window in ANY order, but write results[i] = worker(prompts[i])["result"]
    ...

run_batch(prompts, worker, cap=4) را بسازید. Map worker بر روی هر prompt در دسته‌های با اندازه cap، و بازگردانید {"results": [...], "batches": n_batches} که results[i] نتیجه کارگر برای prompts[i] (ترتیب ورودی حفظ شده) و batches است ceil(len(prompts) / cap). یک لیست خالی پرامپت، صفر دسته را اجرا می‌کند.

نوبت شما

نوشتن run_batch(prompts, worker, cap=4) که یک (شبیه‌سازی‌شده) را نگاشت می‌کند worker روی هر prompt به‌صورت دسته‌ای از cap و بازمی‌گرداند {"results", "batches"}. results باید در ترتیب ورودی باشد، هرچند هر آیتم دارای یک ... متفاوت است cost که می‌توانید آن را زمان‌بندی کنید؛ batches است ceil(len(prompts) / cap). از توابع ساده و یک حلقه زمان‌بندی استفاده کنید -> خیر asyncio، بدون شبکه. یک مجموعه ورودی دوم متمایز باید نتایج متفاوتی بدهد؛ یک لیست خالی صفر دسته را اجرا می‌کند.

مشکلی در این درس دیدید؟ گزارشش کنید · دربارهٔ این درس بپرسید

این تمرین به‌زودی باز می‌شود

درس پیش از آن را تمام کنید تا این یکی باز شود. کل دوره رایگان است، حساب کاربری لازم نیست، و می‌توانید همین الان این درس را بخوانید.