Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Meervoudige completions met de parameter n

Les 15 van 16 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Meerdere antwoorden genereren in één oproep
  2. Het beste antwoord selecteren
  3. Twee prompts vergelijken op een steekproef
  4. Classificatiebetrouwbaarheid verbeteren via stemming
  5. Wanneer n > 1 gebruiken
  6. Belangrijkste punten

Meerdere antwoorden genereren in één oproep

De parameter n instrueert het model om meerdere alternatieve antwoorden op dezelfde prompt te produceren binnen één API-verzoek. Hoewel dit misschien als een kleine functie lijkt, maakt het drie serieuze use-cases mogelijk: het vergelijken van twee prompt-formuleringen op een steekproef, het automatisch selecteren van het beste antwoord uit een batch, en het verkennen van de oplossingsruimte in plaats van het accepteren van de eerste output.

Standaard is n=1 en retourneert de API één enkel antwoord in choices. Als u n=5 instelt, bevat de array vijf items, elk met een eigen index. Let op de temperatuur die in het onderstaande voorbeeld op 1,0 staat: zonder voldoende randomisatie zouden alle vijf de antwoorden identiek zijn, waardoor de oproep nutteloos wordt.

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))

response = client.chat.complete(
    model="ministral-3b-latest",
    messages=[
        {"role": "user", "content": "What is the best programming language for beginners? One word only."}
    ],
    temperature=1.0,  # Hoge temperatuur om diversiteit te maximaliseren
    n=5
)

for choice in response.choices:
    print(f"Response {choice.index}: {choice.message.content}")

Twee factoren bepalen de praktische waarde van deze parameter. De eerste is facturatie: input-tokens worden slechts één keer in rekening gebracht omdat de prompt slechts één keer wordt verzonden, maar output-tokens worden voor elke completion in rekening gebracht. Met n=5 en max_tokens=100 springt uw output-limiet naar 500 tokens. Dit is precies wat n aantrekkelijk maakt voor lange prompts: het afschrijven van een grote context over vijf antwoorden kost aanzienlijk minder dan het doen van vijf aparte oproepen.

print(f"Prompt tokens  : {response.usage.prompt_tokens}")     # 1x in rekening gebracht
print(f"Response tokens: {response.usage.completion_tokens}")  # nx in rekening gebracht
print(f"Total          : {response.usage.total_tokens}")

De tweede factor is compatibiliteit: niet alle Mistral-modellen ondersteunen n. Vanaf april 2026 ondersteunen recente versies van mistral-large geen n > 1. Gebruik ministral-3b-latest of andere compatibele modellen voor deze functie—daarom vertrouwen alle voorbeelden in deze les op dat model.

Het beste antwoord selecteren

De eerste use-case betreft het genereren van meerdere kandidaten en het behouden van de beste op basis van een criterium dat u definieert. Het mechanisme is bewust generiek: best_of_n accepteert elke scoring-functie, waardoor u kunt meten wat in uw context belangrijk is—aanwezigheid van een verplicht trefwoord, JSON-geldigheid, of naleving van een doellengte. De functie length_scorer illustreert dit laatste criterium, waarbij de score evenredig afneemt met de afwijking van de doellengte.

def best_of_n(client, messages, n=5, scorer=None, **kwargs):
    """Genereert N antwoorden en selecteert de beste."""
    response = client.chat.complete(
        model="ministral-3b-latest",
        messages=messages,
        n=n,
        temperature=0.9,
        **kwargs
    )

    candidates = [
        {
            "index": c.index,
            "content": c.message.content,
            "score": scorer(c.message.content) if scorer else 0
        }
        for c in response.choices
    ]

    if scorer:
        candidates.sort(key=lambda x: x["score"], reverse=True)

    return candidates

# Scorer: passende lengte (niet te kort, niet te lang)
def length_scorer(text: str, target=200) -> float:
    """Score gebaseerd op nabijheid tot een doellengte."""
    diff = abs(len(text) - target)
    return max(0, 1 - diff / target)

candidates = best_of_n(
    client,
    [{"role": "user", "content": "Write a summary of generative AI in 2026."}],
    n=5,
    scorer=length_scorer,
    max_tokens=300
)

print("Best response:")
print(candidates[0]["content"])
print(f"Score: {candidates[0]['score']:.2f}")

Twee prompts vergelijken op een steekproef

De tweede use-case is methodologisch rather dan productgericht. Bij het kiezen tussen twee prompt-formuleringen bewijst het vergelijken van één enkel antwoord met een ander niets: variantie van het model alleen zou het verschil kunnen verklaren. Door N antwoorden voor elke versie te genereren en de gemiddelde lengte en het percentage unieke antwoorden te meten, verkrijgt u voorlopig bewijs. Een diversiteitsscore van 1,0 op een prompt die bedoeld is om een stabiel formaat te produceren, is een waarschuwingssignaal, geen goed nieuws.

def ab_test_prompts(client, prompt_a: str, prompt_b: str, n: int = 5):
    """Vergelijkt twee prompts door voor elk N antwoorden te genereren."""
    results = {}

    for label, prompt in [("A", prompt_a), ("B", prompt_b)]:
        response = client.chat.complete(
            model="ministral-3b-latest",
            messages=[{"role": "user", "content": prompt}],
            n=n,
            temperature=0.8,
            max_tokens=200
        )

        texts = [c.message.content for c in response.choices]
        avg_length = sum(len(t) for t in texts) / len(texts)
        unique_ratio = len(set(texts)) / len(texts)

        results[label] = {
            "avg_length": round(avg_length),
            "diversity": round(unique_ratio, 2),
            "sample": texts[0][:150]
        }

    return results

# Test
results = ab_test_prompts(
    client,
    "Summarize the benefits of Python.",
    "List the 3 main benefits of Python in one sentence each."
)

for label, data in results.items():
    print(f"\nPrompt {label}:")
    print(f"  Average length : {data['avg_length']} chars")
    print(f"  Diversity      : {data['diversity']}")
    print(f"  Sample         : {data['sample']}...")

Classificatiebetrouwbaarheid verbeteren via stemming

De derde use-case biedt de hoogste ROI in productie. Voor een classificatietaak vertelt één enkel antwoord u niets over het vertrouwen van het model: het antwoord kan voor de hand liggend zijn, of het kan een grensgeval zijn tussen twee categorieën. Genereer zeven antwoorden, tel de stemmen, en u verkrijgt zowel een label als een bruikbare betrouwbaarheidsgraad—een 4/7-classificatie kan worden doorgestuurd voor menselijke validatie, terwijl een 7/7 direct wordt verwerkt. Het gebruik van een oneven aantal voorkomt gelijke standen.

from collections import Counter

def majority_vote(client, messages, n=7, **kwargs):
    """Meerderheidsstemming classificatie over N completions."""
    response = client.chat.complete(
        model="ministral-3b-latest",
        messages=messages,
        n=n,
        temperature=0.7,
        max_tokens=20,
        **kwargs
    )

    votes = [c.message.content.strip().upper() for c in response.choices]
    counts = Counter(votes)
    winner, count = counts.most_common(1)[0]
    confidence = count / n

    return {
        "result": winner,
        "confidence": round(confidence, 2),
        "votes": dict(counts),
        "n": n
    }

# Sentimentclassificatie
result = majority_vote(
    client,
    messages=[
        {"role": "system", "content": "Classify the sentiment: POSITIVE, NEGATIVE, or NEUTRAL. Reply with one word only."},
        {"role": "user", "content": "The product is okay but the delivery was very slow."}
    ],
    n=7
)

print(f"Result    : {result['result']}")
print(f"Confidence: {result['confidence']:.0%}")
print(f"Votes     : {result['votes']}")

Wanneer n > 1 gebruiken

Deze parameter is niet overal gerechtvaardigd: bij standaard verkeer is elke extra completion een output-kost zonder rendement. De onderstaande tabel vat verdedigbare waarden samen op basis van het scenario.

ScenarioAanbevolen nWaarom
Standaard productie1Minimale kosten
Kwaliteitsselectie3-5Best-of-N voor kritieke tekst
Robuuste classificatie5-9 (oneven)Meerderheidsstemming voor betrouwbaarheid
Prompt A/B-testen5-10Voldoende steekproefgrootte voor vergelijking
Brainstormen5-10Maximale ideeëndiversiteit

Belangrijkste punten

  • De parameter n genereert meerdere antwoorden in één API-oproep
  • Input-tokens worden één keer in rekening gebracht; output-tokens worden vermenigvuldigd met N
  • Niet alle modellen ondersteunen n > 1—verifieer compatibiliteit
  • Meerderheidsstemming verbetert de betrouwbaarheid van classificatie
  • Best-of-N selecteert het beste antwoord op basis van een meetbaar criterium
  • Gebruik een hoge temperatuur met n > 1 om de diversiteit van antwoorden te maximaliseren