Przejdź do głównej treści
Polski— Wybierz język
Menu

Uzupełnienia N i sekwencje zatrzymujące

Lekcja 12 z 16 Zaktualizowano 2 listopada 2026 Początkujący
Na tej stronie
  1. Generowanie wielu odpowiedzi w jednym żądaniu
  2. Parametr n: jak to działa
  3. Sekwencje zatrzymujące: kontroluj miejsce zakończenia generowania
  4. Parametr max_tokens
  5. Łączenie parametrów
  6. Kluczowe wnioski

Generowanie wielu odpowiedzi w jednym żądaniu

Aby zakończyć ten rozdział o parametrach generowania, przyjrzyjmy się dwóm praktycznym narzędziom kontroli: parametrowi N completions (liczba uzupełnień), który pozwala zażądać wielu odpowiedzi na ten sam prompt w ramach jednego wywołania API, oraz sekwencjom zatrzymującym (stop sequences), które decydują o momencie zakończenia generowania. Pierwsze narzędzie pomaga porównywać alternatywy, zwiększać szanse na uzyskanie optymalnej odpowiedzi lub zasilać proces automatycznej selekcji; drugie daje Ci kontrolę nad długością i formatem wyników.

Parametr n: jak to działa

Gdy ustawisz n=5, model generuje 5 niezależnych odpowiedzi na Twój prompt, z których każda jest zwracana jako osobny wybór w obiekcie odpowiedzi. Jeden aspekt rozliczeń wymaga Twojej uwagi przed intensywnym wykorzystaniem tej funkcji: tokeny wejściowe (Twój prompt) są rozliczane tylko raz, natomiast tokeny wyjściowe są rozliczane dla każdego uzupełnienia. Przy n=5 płacisz pięciokrotnie za tokeny wyjściowe, ale tylko raz za prompt: w przypadku długiego promptu i krótkich odpowiedzi jest to znacznie bardziej ekonomiczne niż pięć osobnych wywołań.

from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {"role": "user", "content": "Propose a slogan for a French organic coffee brand."}
    ],
    n=5,
    temperature=0.8
)

for i, choice in enumerate(response.choices):
    print(f"Option {i+1}: {choice.message.content}")

Ten kod generuje 5 różnych haseł reklamowych, z których wybierasz najlepsze. To pierwsze główne zastosowanie n: generowanie kreatywne, gdzie uzyskanie wielu opcji hasła, tytułu lub nazwy produktu jest lepsze niż pojedyncza próba. Drugim zastosowaniem jest klasyfikacja z głosowaniem: generujesz N klasyfikacji tego samego tekstu i zachowujesz odpowiedź większościową, co wygładza okazjonalne błędy. Wykorzystujesz to również do eksploracji – testowania kilku podejść do tego samego problemu – oraz do kontroli jakości, sprawdzając spójność modelu poprzez porównanie jego własnych odpowiedzi.

Zanim wdrożysz to rozwiązanie, poznaj trzy ograniczenia. Po pierwsze, nie wszystkie modele Mistral obsługują n większe niż 1: sprawdź dokumentację używanego modelu. Po drugie, opóźnienie (latencja) rośnie wraz z n, ponieważ model generuje łącznie więcej tokenów. Wreszcie – i to klasyczny błąd początkujących – zawsze łącz n > 1 z wystarczająco wysoką temperaturą (0,5 i wyżej): przy temperaturze 0 Twoje pięć odpowiedzi będzie niemal identycznych, a zapłacisz pięciokrotnie za to samo zdanie.

Sekwencje zatrzymujące: kontroluj miejsce zakończenia generowania

Sekwencje zatrzymujące (stop sequences) to ciągi znaków, które zmuszają model do natychmiastowego zatrzymania się, gdy tylko je wygeneruje. Jest to kluczowy mechanizm kontrolowania długości i formatu odpowiedzi. Zacznijmy od celowo uproszczonego przykładu, aby wyjaśnić tę koncepcję:

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {"role": "user", "content": "List the days of the week, one per line."}
    ],
    stop=["Saturday"]
)

Tutaj model zatrzymuje się natychmiast po wygenerowaniu słowa „Saturday“, tworząc uciętą listę. W praktyce sekwencje zatrzymujące są najbardziej przydatne w przypadku separatorów strukturalnych. Pierwszy przypadek użycia: wyodrębnienie pojedynczej sekcji ze strukturyzowanej odpowiedzi. Jeśli Twój prompt wymaga analizy w trzech częściach, zatrzymanie generowania przy drugim nagłówku da Ci tylko pierwszą część:

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {"role": "user", "content": """Analyze this product:
## Strengths
(your analysis here)
## Weaknesses
(your analysis here)
## Conclusion
(your analysis here)"""}
    ],
    stop=["## Weaknesses"]
)
# Model zatrzymuje się po sekcji Strengths

Drugi przypadek: ograniczenie generowania do bloku JSON, łącząc sekwencję zatrzymującą z wstępnym wypełnieniem (pre-fill) wiadomości asystenta, które otwiera nawias klamrowy:

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {"role": "user", "content": "Return the metadata for this article in JSON."},
        {"role": "assistant", "content": "{", "prefix": True}
    ],
    stop=["}"]
)
# Model generuje zawartość JSON i zatrzymuje się przy zamykającym nawiasie klamrowym

Trzeci przypadek: zapobieganie kontynuowaniu odpowiedzi przez model po udzieleniu odpowiedzi. W przypadku pytania zamkniętego, zatrzymanie przy pierwszym znaku nowej linii gwarantuje suche „TAK“ lub „NIE“, bez akapitu z uzasadnieniem, o który nie prosiłeś:

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {"role": "user", "content": "Answer the following question with YES or NO only.\nIs the Earth round?"}
    ],
    stop=["\n"]
)

Parametr max_tokens

Uzupełniając sekwencje zatrzymujące, max_tokens ustawia sztywny limit liczby tokenów wyjściowych:

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {"role": "user", "content": "Summarize the history of France."}
    ],
    max_tokens=200
)

Zwróć uwagę na jego działanie: max_tokens ucina odpowiedź gwałtownie, potencjalnie w połowie zdania – Twoje podsumowanie może kończyć się słowami „i tak Napoleon“. Traktuj to jako siatkę bezpieczeństwa przed nieskończonymi odpowiedziami, a nie jako główny sposób kontrolowania długości. Do tego celu preferuj instrukcje w prompcie („odpowiedz w 3 zdaniach“) połączone z hojnym limitem max_tokens.

Łączenie parametrów

Mechanizmy te najlepiej sprawdzają się, gdy są używane razem. Poniższy przykład generuje 5 różnych tytułów artykułów, z których każdy jest ograniczony do pojedynczej linii dzięki sekwencji zatrzymującej, z sufitem 50 tokenów jako zabezpieczeniem:

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "You generate blog article titles. One title per response."
        },
        {
            "role": "user",
            "content": "Theme: workplace productivity in 2026"
        }
    ],
    n=5,
    temperature=0.8,
    max_tokens=50,
    stop=["\n"]
)

titres = [choice.message.content.strip() for choice in response.choices]
for i, titre in enumerate(titres):
    print(f"{i+1}. {titre}")

Kluczowe wnioski

  • Parametr n generuje wiele odpowiedzi w jednym wywołaniu (tokeny wejściowe rozliczane raz)
  • Łącz n > 1 z wystarczająco wysoką temperaturą, aby uzyskać rzeczywiste warianty
  • Sekwencje zatrzymujące halują generowanie przy określonym separatorze
  • max_tokens to siatka bezpieczeństwa, a nie główna metoda kontroli długości
  • Łącz te parametry, aby uzyskać precyzyjną kontrolę nad generowaniem