Chamadas em Lote Concorrentes (fan-out limitado)
Quando você precisa de respostas para mil prompts, chamar o modelo um por um e esperar cada resposta é dolorosamente lento. Apps reais disparam muitas requisições concurrently -> mas não ilimitadas: cada provedor limita quantas chamadas em voo ele permite, então você processa o trabalho em batches de um tamanho fixo. Dois fatos tornam a concorrência difícil, e ambos aparecem aqui.
- Os resultados voltam fora de ordem. Um prompt curto pode terminar antes de um longo que você enviou primeiro. Seu código deve remontar as respostas pela posição original de entrada, não por quem terminou primeiro.
- O throughput é limitado pelo limite. Com
nprompts e um limite dec, você executaceil(n / c)batches -> o número em torno do qual cada plano de capacidade é construído.
A usaria asyncio e um cliente de rede real. Para manter esta primeira versão fácil de seguir, você modela o mesmo formato com funções simples e um laço de agendamento -> sem event loop, sem rede, sem modelo real. Aqui está o formato real, para referência, a mesma lógica com um event loop ao vivo:
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 resultsA Semaphore impõe o limite, gather executa as chamadas juntas, e você ainda escreve cada resposta de volta em seu slot original. Note uma diferença dos lotes que você está prestes a construir: com um semáforo uma nova chamada começa no momento em que qualquer chamada termina, então sempre há até cap em voo, enquanto lotes fixos esperam pela chamada mais lenta em cada lote antes de iniciar o próximo. A versão com semáforo é mais rápida; lotes são mais simples de raciocinar. Código assíncrono também pode ser testado (com asyncio.run e fake workers); aqui você constrói a versão de lote com um scheduler simples para que a lógica continue visível. Um worker(prompt) substitui a chamada do modelo e retorna {"result": ..., "cost": ...}, onde cost representa quanto tempo aquele item levaria. Você agenda deliberadamente cada lote em uma ordem de custo diferente para provar que sua montagem de resultados não depende disso secretamente.
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"]
...Construa run_batch(prompts, worker, cap=4). Mapeie worker sobre cada prompt em lotes de tamanho cap, e retorne {"results": [...], "batches": n_batches} onde results[i] é o resultado do worker para prompts[i] (ordem de entrada preservada) e batches é ceil(len(prompts) / cap). Uma lista de prompt vazia executa zero lotes.
Escreva run_batch(prompts, worker, cap=4) que mapeia um (mocked) worker sobre cada prompt em lotes de cap e retorna {"results", "batches"}. results deve estar em ordem de INPUT mesmo que cada item carregue um cost diferente que você pode agendar por; batches é ceil(len(prompts) / cap). Use funções simples e um laço de agendamento -> sem asyncio, sem rede. Um segundo conjunto de entrada distinto deve dar resultados diferentes; uma lista vazia executa zero lotes.
Viu um problema nesta lição? Reporte-o · Pergunte sobre esta lição
Este exercício abre em breve
Termine a lição anterior para que esta seja desbloqueada. O curso inteiro é gratuito, não precisa de conta, e você pode ler esta lição agora mesmo.
Este navegador está bloqueando cookies para learn.floati.life, então as lições que você terminou aqui não podem abrir em ordem. Permita cookies para este site e recarregue.