Silabus Pelajaran 187 dari 250 · Pola Produksi: Retries, Async, Streaming & Memory
Pola Produksi: Retries, Async, Streaming & Memory

Panggilan Batch Konkuren (bounded fan-out)

Saat kamu butuh jawaban untuk seribu prompt, memanggil model satu per satu dan menunggu setiap balasan itu lambat sekali. Aplikasi asli mengirim banyak permintaan secara bersamaan -> tapi tidak tanpa batas: setiap penyedia membatasi berapa banyak panggilan yang berjalan, jadi kamu memproses pekerjaan dalam batch dengan ukuran tetap. Dua fakta membuat konkurensi jadi sulit, dan keduanya muncul di sini.

  • Hasilnya keluar tidak berurutan. Prompt pendek mungkin selesai sebelum prompt panjang yang kamu kirim lebih dulu. Kode kamu harus menyusun ulang jawaban berdasarkan posisi input asli, bukan siapa yang selesai lebih dulu.
  • Throughput dibatasi oleh cap. Dengan n prompts dan cap c, kamu menjalankan ceil(n / c) batches -> angka yang jadi dasar setiap rencana kapasitas.
Versi produksi

A akan menggunakan asyncio dan klien jaringan asli. Untuk menjaga versi pertama ini agar mudah diikuti, kamu memodelkan bentuk yang sama dengan fungsi biasa dan loop penjadwalan -> tanpa event loop, tanpa jaringan, tanpa model asli. Ini adalah bentuk aslinya, sebagai referensi, logika yang sama dengan event loop aktif:

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 membatasi kapasitas, gather menjalankan panggilan bersamaan, dan kamu tetap menulis setiap jawaban kembali ke slot aslinya. Perhatikan satu perbedaan dari batch yang akan kamu buat: dengan semaphore panggilan baru dimulai saat panggilan apa pun selesai, jadi selalu ada hingga cap yang berjalan, sementara batch tetap menunggu panggilan terlambat di setiap batch sebelum memulai yang berikutnya. Versi semaphore lebih cepat; batch lebih mudah dipahami. Kode async juga bisa diuji (dengan asyncio.run dan fake workers); di sini kamu membangun versi batch dengan scheduler biasa agar logikanya tetap terlihat. Sebuah worker(prompt) menggantikan panggilan model dan mengembalikan {"result": ..., "cost": ...}, di mana cost mewakili berapa lama item tersebut akan memakan waktu. Kamu sengaja menjadwalkan setiap batch dalam urutan biaya yang berbeda untuk membuktikan perakitan hasilmu tidak bergantung secara tersembunyi pada hal itu.

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

Bangun run_batch(prompts, worker, cap=4). Map worker ke setiap prompt dalam batch ukuran cap, dan kembalikan {"results": [...], "batches": n_batches} di mana results[i] adalah hasil worker untuk prompts[i] (urutan input tetap) dan batches adalah ceil(len(prompts) / cap). Daftar prompt kosong menjalankan nol batch.

Giliranku

Tulis run_batch(prompts, worker, cap=4) yang memetakan (mocked) worker ke setiap prompt dalam batch cap dan mengembalikan {"results", "batches"}. results harus dalam urutan INPUT meskipun setiap item membawa cost berbeda yang bisa kamu jadwalkan; batches adalah ceil(len(prompts) / cap). Gunakan fungsi biasa dan loop penjadwalan -> tidak ada asyncio, tidak ada jaringan. Set input kedua yang berbeda harus memberikan hasil berbeda; list kosong menjalankan nol batch.

Ada masalah di pelajaran ini? Laporkan · Tanya tentang pelajaran ini

Latihan ini akan segera dibuka

Selesaikan pelajaran sebelumnya agar pelajaran ini terbuka. Seluruh kursus ini gratis, tidak butuh akun, dan kamu bisa baca pelajaran ini sekarang.