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

Sekwencje stopu

Lekcja 7 z 16 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Zatrzymywanie generowania we właściwym momencie
  2. Jak działa parametr stop
  3. Trzy typowe przypadki użycia
  4. Łączenie sekwencji stopu ze strumieniowaniem
  5. Ograniczenia mechanizmu
  6. Kosztowne błędy
  7. Pełny przykład: kontrolowane Q&A
  8. Kluczowe wnioski

Zatrzymywanie generowania we właściwym momencie

Domyślnie model przestaje generować tekst tylko z dwóch powodów: sam decyduje, że zakończył odpowiedź i emituje token końcowy, lub osiąga limit max_tokens. Te dwa kryteria nie pokrywają wszystkich przypadków użycia. Czasami chcesz, aby generowanie ustało w momencie znanym tylko Tobie – tuż przed następną sekcją dokumentu, zaraz po zamknięciu bloku JSON lub w chwili, gdy model zaczyna dodawać niepotrzebny komentarz.

Sekwencje stopu dodają to trzecie kryterium: gdy tylko model wygeneruje wskazany przez Ciebie ciąg znaków, proces natychmiast się zatrzymuje. Traktuj to jak precyzyjne narzędzie do cięcia, będące naturalnym uzupełnieniem instrukcji formatowania zawartych w wiadomości systemowej, których model przestrzega dobrze, ale nie zawsze idealnie.

Jak działa parametr stop

Parametr ten przyjmuje listę ciągów znaków. Generowanie kończy się w momencie wystąpienia pierwszego z nich w wyjściu:

from mistralai.client import Mistral
import os

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

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {"role": "user", "content": "List the 10 largest cities in France."}
    ],
    stop=["6."]  # Stop after the first 5
)

print(response.choices[0].message.content)
# 1. Paris
# 2. Marseille
# 3. Lyon
# 4. Toulouse
# 5. Nice

W tym przykładzie wyróżniają się dwa zachowania. Sekwencja stopu nie jest uwzględniana w odpowiedzi: otrzymujesz tekst ją poprzedzający, bez konieczności czyszczenia go po Twojej stronie. Ponadto pole finish_reason ma wartość "stop", dokładnie tak jak w przypadku naturalnego zakończenia – API nie rozróżnia tych dwóch sytuacji, więc to Ty musisz pamiętać, czego zażądałeś.

Trzy typowe przypadki użycia

Pierwszy przypadek dotyczy modelu zbyt gadatliwego. Pytasz o stolicę, a otrzymujesz jej nazwę plus trzy zdania wyjaśnienia, których Twój interfejs nie oczekiwał. Monit systemowy określa intencję, a sekwencje stopu ją egzekwują:

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "Answer with only the city name, nothing else."
        },
        {
            "role": "user",
            "content": "What is the capital of Italy?"
        }
    ],
    stop=["\n", ".", "Explanation"]  # Stop at the first newline or period
)

print(response.choices[0].message.content.strip())
# Rome

Drugi przypadek obejmuje generowanie dokumentów sekcja po sekcji, gdy chcesz zachować kontrolę między częściami, zamiast pozwalać modelowi na wyprodukowanie całego raportu za jednym razem. Zatrzymujesz generowanie na delimiterach sygnalizujących to, co ma nastąpić dalej:

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "Write the Introduction section of a report."
        },
        {
            "role": "user",
            "content": "Topic: the impact of AI on employment in Europe."
        }
    ],
    stop=["## ", "---", "Conclusion"]  # Stop before the next section
)

Trzeci przypadek jest w praktyce najbardziej opłacalny: ekstrakcja użytecznego JSON-a bez etapu czyszczenia. Modele mają tendencję do otaczania swojego wyjścia tekstem wyjaśniającym, co powoduje błędy przy json.loads(); ucięcie outputu podwójnym znakiem nowej linii lub potrójnym backtickiem eliminuje problem u źródła.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "Respond only with valid JSON."
        },
        {
            "role": "user",
            "content": "Give me info for Paris: population, country, time zone."
        }
    ],
    stop=["\n\n", "```"]  # Stop after the JSON block
)

Łączenie sekwencji stopu ze strumieniowaniem

Nic nie stoi na przeszkodzie, aby łączyć oba mechanizmy: strumień zatrzymuje się natychmiast po wykryciu jednej z sekwencji stopu w generowanym tekście, a chunki, które już otrzymałeś, pozostają ważne.

stream = client.chat.stream(
    model="mistral-large-latest",
    messages=[
        {"role": "user", "content": "Tell a short story."}
    ],
    stop=["Fin.", "THE END", "---"]
)

full_text = ""
for chunk in stream:
    content = chunk.data.choices[0].delta.content
    if content:
        full_text += content
        print(content, end="", flush=True)

print(f"\n\nText: {len(full_text)} characters")

Ograniczenia mechanizmu

Działanie parametru stop regulują cztery ograniczenia. Możesz podać maksymalnie cztery sekwencje na żądanie, co zmusza Cię do wyboru tych najbardziej wyróżniających, zamiast ich nadmiernego mnożenia. Rozróżniają one wielkość liter: "end" nigdy nie przechwyci "End", więc musisz uwzględnić istotne warianty. Sekwencja nigdy nie jest включана do odpowiedzi, co ma znaczenie, jeśli oczekiwany format kończy się tym delimiterem. Wreszcie, wykrywanie odbywa się token po tokenie: jeśli sekwencja wypadnie w środku tokenu, zostanie niezauważona – to kolejny powód, by wybierać wieloznakowe delimitery zamiast pojedynczych symboli.

Kosztowne błędy

Najczęstszym błędem jest użycie sekwencji zbyt krótkiej, co powoduje przedwczesne zatrzymanie. Pojedyncza kropka zatrzyma generowanie przy pierwszym zdaniu, nawet w środku skrótu; symetrycznym błędem jest wybór ciągu, którego model nigdy nie wyprodukuje – w takim przypadku parametr nie działa, a Ty błędnie sądzisz, że ustanowiłeś zabezpieczenie.

# BAD: sequence too short, premature stops
stop=["."]  # Stops at every sentence!

# GOOD: context-specific sequence
stop=[".\n\n"]  # Stops after a period followed by a double newline

# BAD: sequence the model will never produce
stop=["XYZZY"]  # Has no effect

# GOOD: realistic sequence based on expected format
stop=["Next question:", "---"]

Zasada wynikająca z tych czterech linii jest prosta: dobra sekwencja stopu wynika z formatu, o który poprosiłeś model, a nie z Twojej wyobraźni.

Pełny przykład: kontrolowane Q&A

Złóżmy te elementy w krótką funkcję typu pytanie-odpowiedź, gdzie niska temperatura zapewnia stabilność faktów, max_tokens ustanawia bezpieczny sufit, a sekwencje stopu odcinają komentarze, które model mógłby dodać po swojej odpowiedzi:

from mistralai.client import Mistral
import os

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

def ask_single_question(question: str) -> str:
    """Ask a question and get a concise answer without chatter."""
    response = client.chat.complete(
        model="mistral-large-latest",
        messages=[
            {
                "role": "system",
                "content": "Answer in a single sentence, directly and factually."
            },
            {"role": "user", "content": question}
        ],
        max_tokens=100,
        stop=["\n\n", "Remark:", "Note:"],
        temperature=0.1
    )

    return response.choices[0].message.content.strip()

# Test
questions = [
    "What is the speed of light?",
    "Who invented the telephone?",
    "How many planets are in the solar system?"
]

for q in questions:
    print(f"Q: {q}")
    print(f"A: {ask_single_question(q)}\n")

Uruchom ten skrypt raz w obecnej formie, a drugi raz po usunięciu parametru stop: porównanie obu wyników pokaże Ci dokładnie, co filtrują te trzy sekwencje.

Kluczowe wnioski

  • Sekwencje stopu zatrzymują generowanie, gdy model wyprodukuje określony tekst
  • Maksymalnie 4 sekwencje na żądanie; rozróżniają wielkość liter
  • Sekwencja stopu nigdy nie jest uwzględniana w odpowiedzi
  • Używaj sekwencji wystarczająco specyficznych, aby uniknąć przedwczesnych stopów
  • Kompatybilne ze strumieniowaniem i wszystkimi innymi parametrami