Müfredat 250 dersinden 187. · Üretim Kalıpları: Retries, Async, Streaming ve Memory
Üretim Kalıpları: Retries, Async, Streaming ve Memory

Eşzamanlı Toplu Çağrılar (sınırlı fan-out)

Binlerce istem için cevap alman gerektiğinde, modeli her seferinde tek tek çağırmak ve her yanıtı beklemek can sıkıcı derecede yavaş. Gerçek uygulamalar birçok isteği eşzamanlı gönderir -> ama sınırsız değil: her sağlayıcı izin verdiği aktif çağrı sayısını sınırlar, bu yüzden işi sabit boyutlu gruplar halinde işlersin. İki gerçek eşzamanlılığı zorlaştırır ve her ikisi de burada karşımıza çıkıyor.

  • Sonuçlar karışık sırada geliyor. Kısa bir istem, önce gönderdiğin uzun bir istemden önce bitebilir. Kodun cevapları kimin önce bittiğine göre değil, orijinal giriş pozisyonuna göre yeniden birleştirmeli.
  • İşlem hacmi kapasite ile sınırlıdır. n istemleri ve c kapasitesi ile ceil(n / c) batch çalıştırırsın -> her kapasite planının üzerine kurulduğu sayı budur.

A üretim versiyonu asyncio ve gerçek bir ağ istemcisi kullanırdı. Bu ilk versiyonu takip etmesi kolay tutmak için, aynı yapıyı düz fonksiyonlar ve bir planlama döngüsü ile modelliyorsun -> olay döngüsü yok, ağ yok, gerçek model yok. İşte referans için gerçek yapı, canlı bir olay döngüsü ile aynı mantık:

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 sınırı zorlar, gather çağrıları birlikte çalıştırır ve sen her cevabı hala orijinal yuvasına yazarsın. Kuracağın paketlerden bir farkı fark et: bir semaphore ile herhangi bir çağrı bittiği anda yeni bir çağrı başlar, bu yüzden her zaman cap kadar çağrı havada olur, sabit paketler ise bir sonraki paketi başlatmadan önce her paketteki en yavaş çağrıyı bekler. Semaphore versiyonu daha hızlıdır; paketler üzerinde düşünmek daha kolaydır. Async kod da test edilebilir (asyncio.run ve sahte işçiler ile); burada mantık göz önünde kalsın diye paket versiyonunu düz bir scheduler ile kuruyorsun. Bir worker(prompt) model çağrısının yerini tutar ve {"result": ..., "cost": ...} döndürür, burada cost o öğenin ne kadar süreceğini temsil eder. Sonuç birleştirmenin gizlice buna bağlı olmadığını kanıtlamak için her paketi bilerek farklı bir maliyet sırasına göre planlıyorsun.

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"]
    ...

Build run_batch(prompts, worker, cap=4). Map worker her bir prompt üzerinde cap boyutunda paketler halinde çalıştır ve {"results": [...], "batches": n_batches} döndür, burada results[i] prompts[i] için işçi sonucudur (giriş sırası korundu) ve batches ceil(len(prompts) / cap)'dir. Boş bir prompt listesi sıfır paket çalıştırır.

Senin sıran

Her bir prompt için (mocklanmış) bir worker eşleyen ve cap boyutundaki paketler halinde {"results", "batches"} döndüren run_batch(prompts, worker, cap=4) yaz. Her bir öğe seninle planlayabileceğin farklı bir cost taşısa bile results INPUT sırasında olmalı; batches bir ceil(len(prompts) / cap)'dir. Düz fonksiyonlar ve bir planlama döngüsü kullan -> asyncio yok, ağ yok. İkinci farklı bir girdi seti farklı sonuçlar vermeli; boş bir liste sıfır paket çalıştırır.

Bu derste bir sorun mu fark ettin? Bildir · Bu ders hakkında soru sor

Bu alıştırma yakında açılacak

Bu dersi bitirince bu ders açılacak. Kursun tamamı ücretsiz, hesap gerekmiyor ve bu dersi hemen şimdi okuyabilirsin.