Gelyktydige Batch-oproepe (beperkte fan-out)
Wanneer jy antwoorde vir duisend vraestellings nodig het, is dit pynlik stadig om die model een na een te roep en op elke antwoord te wag. Regte toepassings stuur baie versoeke concurrently -> maar nie onbeperkt nie: elke verskaffer beperk hoeveel aktiewe oproepe toegelaat word, so jy verwerk die werk in batches van 'n vaste grootte. Twee feite maak konkurrensie moeilik, en albei verskyn hier.
- Resultate kom uitmekaar in die verkeerde volgorde. 'n Kort versoek kan klaar wees voor 'n lang een wat jy eerste gestuur het. Jou kode moet die antwoorde herstel volgens hul oorspronklike invoerposisie, nie volgens wie eerste klaar is nie.
- Deurdraai is beperk deur die limiet. Met
nprompts en 'n limiet vanc, hardloop jyceil(n / c)batches -> die getal waarom elke kapasiteitsplan gebou word.
A produksievergelyking sou asyncio en 'n regte netwerkkliënt gebruik. Om hierdie eerste weergawe maklik om te volg te hou, modelleer jy dieselfde vorm met eenvoudige funksies en 'n skeduleringloop -> geen event loop, geen netwerk, geen regte model. Hier is die regte vorm, vir verwysing, dieselfde logika met 'n lewendige event loop:
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'n Semaphore dwing die limiet af, gather voer die oproepe saam uit, en jy skryf steeds elke antwoord terug in sy oorspronklike gleuf. Let op een verskil van die bondels wat jy gaan bou: met 'n semafoor begin 'n nuwe oproep die oomblik wanneer enige oproep klaar is, so daar is altyd tot cap aan die gang, terwyl vaste bondels wag vir die stadigste oproep in elke bondel voordat die volgende begin. Die semafoor-weergawe is vinniger; bondels is makliker om oor te redeneer. Asinchrone kode kan ook getoets word (met asyncio.run en vals werkers); hier bou jy die bondelweergawe met 'n gewone skeduleerder sodat die logika sigbaar bly. 'n worker(prompt) staan in vir die modeloproep en gee {"result": ..., "cost": ...} terug, waar cost voorstel hoe lank daardie item sou neem. Jy skeduleer elke bondel doelbewus in 'n ander kostevolgorde om te bewys dat jou samestelling van die resultaat nie in die geheim daarvan afhang nie.
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"]
...Bou run_batch(prompts, worker, cap=4). Map worker oor elke prompt in batches van grootte cap, en gee {"results": [...], "batches": n_batches} terug waar results[i] die werkerresultaat vir prompts[i] is (inputvolgorde behou) en batches is ceil(len(prompts) / cap). 'n Leë promptlys hardloop nul batches.
Skryf run_batch(prompts, worker, cap=4) wat 'n (gemokte) worker oor elke prompt in batches van cap kaart en {"results", "batches"} teruggee. results moet in INPUT-orde wees selfs al dra elke item 'n verskillende cost wat jy kan skeduleer; batches is ceil(len(prompts) / cap). Gebruik eenvoudige funksies en 'n skeduleringslus -> geen asyncio, geen netwerk. 'n Tweede aparte inset moet verskillende resultate gee; 'n leë lys hardloop nul batches.
Sien jy 'n probleem in hierdie les? Rapporteer dit · Vra oor hierdie les
Hierdie oefening open binnekort
Voltooi die lesie voor dit en hierdie een sal ontvanklik wees. Die hele kursus is gratis, geen rekening nodig nie, en jy kan hierdie les nou lees.
Hierdie blutser blokkeer koekies vir learn.floati.life, so lesse wat jy hier voltooi het kan nie in volgorde oopgaan nie. Laat koekies vir hierdie webwerf toe en laai nuut.