Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Parallelism och samtidighet

Lektion 8 av 20 Uppdaterad 28 juli 2026 Avancerad
På denna sida
  1. Att vänta tillsammans är inte att beräkna tillsammans
  2. Starta samtidiga anrop
  3. Map-reduce-mönstret applicerat på text
  4. När multiprocessering blir relevant igen
  5. Verifiera verklig genomströmning
  6. Viktiga punkter

Att vänta tillsammans är inte att beräkna tillsammans

Ett API-anrop till OpenAI är en I/O-bunden operation: ditt program knådar inte siffror, det väntar på ett nätverkssvar. Denna egenskap styr valet av rätt verktyg. Parallelism, i bemärkelsen multiprocessering, fördelar beräkningar över flera kärnor; det kostar en hel process per arbetsenhet, och att köra hundra processer som alla väntar på nätverket är rent slöseri. Samtidighet, som tillhandahålls av asyncio, låter en enda process hantera hundratals samtidiga väntelägen till försumbar kostnad. Det är detta som maximerar din genomströmning av anrop.

Skillnaden är mer än akademisk: ett team som paralleliserar sina LLM-anrop med en processpool kommer att förbruka flera gigabyte minne utan någon vinst jämfört med några rader asyncio.

Starta samtidiga anrop

SDK:t exponerar en asynkron klient, AsyncOpenAI, vars anrop avvaktas med await. Genom att samla flera korutiner i en asyncio.gather låter du dem alla fortskrida samtidigt, där den totala varaktigheten närmar sig det långsammaste anropet snarare än summan av alla.

import asyncio
import openai

client = openai.AsyncOpenAI()

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

async def concurrent_calls(prompts: list[str]) -> list[str]:
    """Startar alla anrop 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"Fel vid prompt {i}: {result}")

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

Flaggan return_exceptions=True är vad som skiljer en prototyp från produktionsklassad bearbetning. Utan den avbryter det första felet gather och du förlorar de nittionio resultat som redan hämtats. Med den blir fel värden som du inspekterar, loggar och försöker igen i din egen takt.

Denna råa version har dock en omedelbar brist: att starta tusen anrop på en gång kommer att spränga dina hastighetsbegränsningar (rate limits) på några sekunder. En semafor löser detta genom att endast tillåta ett fast antal samtidiga anrop, medan resten väntar tålmodigt på sin tur. Tjugo är en rimlig startpunkt, att justeras baserat på din organisations faktiska kvoter.

async def calls_with_limit(
    prompts: list[str],
    max_concurrency: int = 20,
) -> list[str]:
    """Begränsar antalet samtidiga anrop."""
    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önstret applicerat på text

Ett dokument på tvåhundra sidor kan inte sammanfattas i ett enda anrop, och att skiva upp det sekventiellt skulle ta minuter. Map-reduce-mönstret passar naturligt här: dela upp i bitar, sammanfatta varje bit samtidigt, och be sedan modellen om en syntes av sammanfattningarna. Map-fasen drar full nytta av samtidighet, medan reduce-fasen är ett enda anrop på text som har blivit kort.

async def map_reduce_summary(
    document: str,
    chunk_size: int = 3000,
) -> str:
    """Sammanfattar ett långt dokument via parallell map-reduce."""

    # Fas MAP: dela upp och sammanfatta parallellt
    chunks = [
        document[i:i + chunk_size]
        for i in range(0, len(document), chunk_size)
    ]

    map_prompts = [
        f"Sammanfatta detta stycke i 3 nyckelpunkter:\n\n{chunk}"
        for chunk in chunks
    ]

    partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)

    # Fas REDUCE: kombinera sammanfattningar
    summary_text = "\n\n---\n\n".join(
        r for r in partial_summaries if isinstance(r, str)
    )

    final_summary = await single_call(
        f"Syntetisera dessa delsammanfattningar till en sammanhängande sammanfattning "
        f"av 5 nyckelpunkter:\n\n{summary_text}"
    )

    return final_summary

Filtreringen if isinstance(r, str) är lika mycket ett produktbeslut som en teknisk försiktighetsåtgärd: det innebär att den slutgiltiga syntesen kommer att produceras även om tre bitar misslyckades, tyst och stilla. Beroende på kontexten är detta exakt vad du vill ha, eller så är det oacceptabelt. Beslut explicit, och logga antalet förlorade bitar under alla omständigheter.

När multiprocessering blir relevant igen

Det finns fortfarande sällsynta situationer där beräkningen återtar kontrollen: tung efterbearbetning av svar, entitetsutvinning, poängsättning, strukturerad parsning. Detta arbete är CPU-bundet och vinner inget på asyncio. Den eleganta kombinationen är att kedja de två regimerna i en enda pipeline: nätverksanrop med samtidighet, följt av beräkning fördelad över en processpool via run_in_executor.

import asyncio
from concurrent.futures import ProcessPoolExecutor

def heavy_post_processing(text: str) -> dict:
    """CPU-bunden bearbetning på resultatet (NLP, parsning, etc.)."""
    # Exempel: entitetsutvinning, poängsättning, etc.
    words = text.split()
    return {
        "word_count": len(words),
        "unique_words": len(set(words)),
    }

async def complete_pipeline(prompts: list[str]) -> list[dict]:
    """Pipeline: asynkrona LLM-anrop + parallell CPU-efterbearbetning."""
    # Steg 1: samtidiga LLM-anrop
    llm_results = await calls_with_limit(prompts)

    # Steg 2: parallell efterbearbetning (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

Verifiera att beräkningen verkligen motiverar poolen innan du introducerar den: att serialisera data till en annan process har en kostnad, och för behandlingar som varar några millisekunder överstiger denna kostnad vinsten.

Verifiera verklig genomströmning

Att finjustera max_concurrency är inte gissningslek. För lågt, och du lämnar genomströmning på bordet; för högt, och du utlöser hastighetsbegränsningar som kostar dig mer tid än de sparar. Mät på din faktiska belastning, variera värdet, och titta på både genomströmning och antal lyckade anrop – en mycket snabb pipeline som misslyckas var femte gång är inte snabb.

import time

async def benchmark_throughput(num_requests: int = 100):
    """Mäter den verkliga genomströmningen i din pipeline."""
    prompts = [
        f"Ge ett intressant 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"Förfrågningar: {num_requests}")
    print(f"Lyckade: {successes}")
    print(f"Varaktighet: {duration:.1f}s")
    print(f"Genomströmning: {successes / duration:.1f} req/s")

Viktiga punkter

  • Använd AsyncOpenAI och asyncio.gather för I/O-samtidighet
  • Begränsa samtidighet med en semafor för att respektera kvoter
  • Map-reduce-mönstret paralleliserar bearbetning av långa dokument
  • Reservera ProcessPoolExecutor för CPU-intensiv efterbearbetning