Chiamate concorrenti a lotti (fan-out limitato)
Quando ti servono risposte per mille prompt, chiamare il modello uno alla volta aspettando ogni risposta è terribilmente lento. Le app vere lanciano molte richieste in modo concorrente -> ma non senza limiti: ogni fornitore limita quante chiamate in corso permette, quindi elabori il lavoro in lotti di dimensione fissa. Due fatti rendono delicata la concorrenza, ed entrambi compaiono qui.
- I risultati tornano in disordine. Un prompt corto può finire prima di uno lungo che hai mandato prima. Il tuo codice deve rimettere insieme le risposte secondo la loro posizione originale in ingresso, non secondo chi ha finito per primo.
- La capacità è limitata dal tetto. Con
nprompt e un tetto dic, faiceil(n / c)lotti -> il numero su cui si costruisce ogni piano di capacità.
Una versione di produzione userebbe asyncio e un vero client di rete. Per tenere questa prima versione facile da seguire, rappresenti la stessa forma con semplici funzioni e un ciclo di pianificazione -> niente ciclo di eventi, niente rete, niente modello vero. Ecco la forma vera, come riferimento, la stessa logica con un vero ciclo di eventi:
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 resultsUn Semaphore impone il tetto, gather fa girare insieme le chiamate, e scrivi comunque ogni risposta al suo posto originale. Nota una differenza rispetto ai lotti che stai per costruire: con un semaforo una nuova chiamata parte nel momento in cui una qualsiasi chiamata finisce, quindi ce ne sono sempre fino a cap in corso, mentre i lotti fissi aspettano la chiamata più lenta di ogni lotto prima di far partire il successivo. La versione con semaforo è più veloce; i lotti sono più semplici da ragionare. Anche il codice async si può testare (con asyncio.run e lavoratori finti); qui costruisci la versione a lotti con un semplice pianificatore così la logica resta in vista. Un worker(prompt) sta al posto della chiamata al modello e restituisce {"result": ..., "cost": ...}, dove cost rappresenta quanto tempo richiederebbe quell'elemento. Pianifichi di proposito ogni lotto in un ordine di costo diverso per dimostrare che l'assemblaggio dei risultati non dipende di nascosto da quello.
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"]
...Costruisci run_batch(prompts, worker, cap=4). Applica worker a ogni prompt in lotti di dimensione cap, e restituisci {"results": [...], "batches": n_batches} dove results[i] è il risultato del worker per prompts[i] (ordine in ingresso conservato) e batches è ceil(len(prompts) / cap). Una lista di prompt vuota fa zero lotti.
Scrivi run_batch(prompts, worker, cap=4) che applica un worker (simulato) a ogni prompt in lotti di cap e restituisce {"results", "batches"}. results deve essere nell'ordine di INGRESSO anche se ogni elemento porta un cost diverso secondo cui puoi pianificare; batches è ceil(len(prompts) / cap). Usa semplici funzioni e un ciclo di pianificazione -> niente asyncio, niente rete. Un secondo insieme di ingressi distinto deve dare risultati diversi; una lista vuota fa zero lotti.
Hai notato un problema in questa lezione? Segnalalo · Chiedi qualcosa su questa lezione
Questo esercizio si apre presto
Finisci la lezione precedente e questa si sblocca. L'intero corso è gratuito, senza account, e puoi leggere questa lezione subito.
Questo browser blocca i cookie per learn.floati.life, quindi le lezioni che hai finito qui non si possono aprire in ordine. Consenti i cookie per questo sito e ricarica.