Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Parallelisme og samtidighed

Lektion 8 af 20 Opdateret 28. juli 2026 Avanceret
På denne side
  1. At vente sammen er ikke det samme som at regne sammen
  2. Opstart af samtidige kald
  3. Map-reduce-mønsteret anvendt på tekst
  4. Hvornår multiprocessering igen bliver relevant
  5. Verificering af reel gennemstrømning
  6. Vigtige pointer

At vente sammen er ikke det samme som at regne sammen

Et API-kald til OpenAI er en I/O-bundet operation: Dit program knuser ikke tal, det venter på et netsvar. Denne natur dikterer det rigtige værktøj. Parallelisme, i betydningen multiprocessering, fordeler beregninger på tværs af flere kerner; det koster en hel proces per arbejdsenhed, og at køre hundrede processer, der alle venter på netværket, er ren spild. Samtidighed, som leveret af asyncio, tillader en enkelt proces at håndtere hundredevis af samtidige venteperioder til en ubetydelig omkostning. Det er dette, der maksimerer din kald-gennemstrømning.

Distinktionen er mere end akademisk: Et team, der paralleliserer sine LLM-kald med en proces-pulje, vil forbruge flere gigabyte hukommelse for nul gevinst sammenlignet med et par linjer asyncio.

Opstart af samtidige kald

SDK’et eksponerer en asynkron klient, AsyncOpenAI, hvis kald afventes med await. Ved at samle flere korutiner i en asyncio.gather kan de alle skride frem samtidigt, hvor den samlede varighed nærmer sig den langsomste kalds varighed snarere end summen af dem alle.

import asyncio
import openai

client = openai.AsyncOpenAI()

async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
    """Et enkelt asynkront API-kald."""
    response = await client.responses.create(
        model=model,
        input=prompt,
    )
    return response.output_text

async def concurrent_calls(prompts: list[str]) -> list[str]:
    """Opstarter alle kald samtidigt."""
    tasks = [single_call(prompt) for prompt in prompts]
    results = await asyncio.gather(*tasks, return_exceptions=True)

    for i, result in enumerate(results):
        if isinstance(result, Exception):
            print(f"Fejl ved prompt {i}: {result}")

    return [r for r in results if not isinstance(r, Exception)]

Flaget return_exceptions=True er det, der adskiller en prototype fra produktionsegnet behandling. Uden det vil den første undtagelse afbryde gather, og du mister de nioghalvfems resultater, der allerede er opnået. Med det bliver fejl til værdier, som du inspicerer, logger og genprøver i dit eget tempo.

Denne rå version har dog en øjeblikkelig fejl: At opstarte tusind kald på én gang vil sprænge dine hastighedsgrænser på få sekunder. En semafor løser dette ved kun at tillade et fast antal samtidige kald, mens resten venter tålmodigt på deres tur. Tyve er et rimeligt udgangspunkt, som skal justeres baseret på din organisations faktiske kvoter.

async def calls_with_limit(
    prompts: list[str],
    max_concurrency: int = 20,
) -> list[str]:
    """Begrænser antallet af samtidige kald."""
    semaphore = asyncio.Semaphore(max_concurrency)

    async def limited_call(prompt: str) -> str:
        async with semaphore:
            return await single_call(prompt)

    tasks = [limited_call(prompt) for prompt in prompts]
    return await asyncio.gather(*tasks, return_exceptions=True)

Map-reduce-mønsteret anvendt på tekst

Et dokument på to hundrede sider kan ikke opsummeres i et enkelt kald, og at skære det op sekventielt ville tage minutter. Map-reduce-mønsteret passer naturligt her: Opdel i bidder, opsummer hver bid samtidigt, og bed derefter modellen om en syntese af opsummeringerne. Map-fasen drager fuld fordel af samtidighed, mens reduce-fasen er et enkelt kald på tekst, der er blevet kort.

async def map_reduce_summary(
    document: str,
    chunk_size: int = 3000,
) -> str:
    """Opsummerer et langt dokument via parallel map-reduce."""

    # Fase MAP: opdel og opsummer parallelt
    chunks = [
        document[i:i + chunk_size]
        for i in range(0, len(document), chunk_size)
    ]

    map_prompts = [
        f"Opsummer dette afsnit i 3 nøglepunkter:\n\n{chunk}"
        for chunk in chunks
    ]

    partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)

    # Fase REDUCE: kombinér opsummeringer
    summary_text = "\n\n---\n\n".join(
        r for r in partial_summaries if isinstance(r, str)
    )

    final_summary = await single_call(
        f"Syntetisér disse delvise opsummeringer til en sammenhængende opsummering "
        f"af 5 nøglepunkter:\n\n{summary_text}"
    )

    return final_summary

Filtreringen if isinstance(r, str) er lige så meget en produktbeslutning som en teknisk forholdsregel: Det betyder, at den endelige syntese vil blive produceret, selv hvis tre bidder fejlede, stille og roligt. Afhængigt af konteksten er det præcis, hvad du ønsker, eller også er det uacceptabelt. Beslut det eksplicit, og log antallet af tabte bidder under alle omstændigheder.

Hvornår multiprocessering igen bliver relevant

Der findes stadig sjældne situationer, hvor beregningen tager kontrol tilbage: Tung efterbehandling af svar, entitetsudtrækning, scoring, struktureret parsing. Dette arbejde er CPU-bundet og får ingen gevinst af asyncio. Den elegante kombination er at kæde de to regimer i en enkelt pipeline: Netværkskald i samtidighed, derefter beregning fordelt på tværs af en proces-pulje via run_in_executor.

import asyncio
from concurrent.futures import ProcessPoolExecutor

def heavy_post_processing(text: str) -> dict:
    """CPU-bundet behandling af resultatet (NLP, parsing osv.)."""
    # Eksempel: entitetsudtrækning, scoring osv.
    words = text.split()
    return {
        "word_count": len(words),
        "unique_words": len(set(words)),
    }

async def complete_pipeline(prompts: list[str]) -> list[dict]:
    """Pipeline: Asynkrone LLM-kald + parallel CPU-efterbehandling."""
    # Trin 1: Samtidige LLM-kald
    llm_results = await calls_with_limit(prompts)

    # Trin 2: Parallel efterbehandling (CPU)
    loop = asyncio.get_event_loop()
    with ProcessPoolExecutor(max_workers=4) as pool:
        tasks = [
            loop.run_in_executor(pool, heavy_post_processing, r)
            for r in llm_results
            if isinstance(r, str)
        ]
        final_results = await asyncio.gather(*tasks)

    return final_results

Verificér, at beregningen retfærdiggør puljen, før du introducerer den: Serialisering af data til en anden proces har en omkostning, og for behandlinger, der varer få millisekunder, overstiger denne omkostning gevinsten.

Verificering af reel gennemstrømning

Justering af max_concurrency er ikke gætværk. For lavt, og du efterlader gennemstrømning på bordet; for højt, og du udløser hastighedsgrænser, der koster dig mere tid, end de sparer. Mål på din faktiske belastning, varier værdien, og se på både gennemstrømning og antal succeser – en meget hurtig pipeline, der fejler én ud af fem gange, er ikke hurtig.

import time

async def benchmark_throughput(num_requests: int = 100):
    """Måler den reelle gennemstrømning af din pipeline."""
    prompts = [
        f"Giv et interessant faktum nummer {i}."
        for i in range(num_requests)
    ]

    start = time.perf_counter()
    results = await calls_with_limit(prompts, max_concurrency=20)
    duration = time.perf_counter() - start

    successes = sum(1 for r in results if isinstance(r, str))
    print(f"Forespørgsler: {num_requests}")
    print(f"Succeser: {successes}")
    print(f"Varighed: {duration:.1f}s")
    print(f"Gennemstrømning: {successes / duration:.1f} req/s")

Vigtige pointer

  • Brug AsyncOpenAI og asyncio.gather til I/O-samtidighed
  • Begræns samtidighed med en semafor for at overholde kvoter
  • Map-reduce-mønsteret paralleliserer behandling af lange dokumenter
  • Reserver ProcessPoolExecutor til CPU-intensiv efterbehandling