Programma Lezione 187 di 250 · Schemi di produzione: nuovi tentativi, async, streaming e memoria
Schemi di produzione: nuovi tentativi, async, streaming e memoria

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 n prompt e un tetto di c, fai ceil(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 results

Un 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.

Tocca a te

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.