Sekvenser för avbrott
På denna sida
Att stoppa genereringen vid rätt tillfälle
Som standard slutar modellen bara av två anledningar: den avgör själv att svaret är klart och skickar sin sluttoken, eller så når den taket för max_tokens. Dessa två kriterier täcker inte alla användningsfall. Ibland vill du att genereringen ska stoppas vid en punkt som bara du känner till – precis innan nästa avsnitt i ett dokument, direkt efter att ett JSON-block stängs, eller så fort modellen börjar lägga till kommentarer du inte behöver.
Sekvenser för avbrott (stop sequences) lägger till detta tredje kriterium: så fort modellen producerar en textsekvens du har angivit, avbryts genereringen omedelbart. Tänk på det som ett precisionsverktyg för beskärning, det naturliga komplementet till formateringsinstruktionerna i ditt systemmeddelande, som modellen följer väl men inte alltid perfekt.
Hur parametern stop fungerar
Parametern accepterar en lista med strängar. Den första som dyker upp i utdata avslutar genereringen:
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
Två beteenden sticker ut i detta exempel. Avbrottssekvensen inkluderas inte i svaret: du får texten som föregår den, utan att du behöver städa upp något. Och finish_reason blir "stop", precis som vid ett naturligt stopp – API:t gör ingen skillnad mellan de två, så det är upp till dig att komma ihåg vad du begärde.
Tre typiska användningsfall
Det första fallet hanterar den pratsamma modellen. Du frågar efter en huvudstad och får huvudstaden plus tre meningar förklaring som ditt gränssnitt inte förväntade sig. Systemprompten sätter intentionen; sekvenser för avbrott upprätthåller den:
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
Det andra fallet täcker dokumentgenerering avsnitt för avsnitt, när du vill behålla kontrollen mellan delarna istället för att låta modellen producera en hel rapport i ett svep. Du stoppar vid avgränsarna som signalerar vad som kommer härnäst:
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
)
Det tredje fallet är det mest kostnadseffektiva i praktiken: att extrahera användbar JSON utan ett städsteg. Modeller har en tendens att linda in sin utdata i förklarande text, vilket krossar json.loads(); att klippa vid dubbla nyrader eller triple backticks eliminerar problemet vid källan.
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
)
Kombinera sekvenser för avbrott och streaming
Inget hindrar dig från att kombinera båda mekanismerna: strömmen stoppas så fort en av avbrottssekvenserna upptäcks i den genererade texten, och de chunkar du redan har mottagit förblir giltiga.
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")
Begränsningar i mekanismen
Fyra begränsningar styr användningen av parametern stop. Du kan ange högst fyra sekvenser per begäran, vilket tvingar dig att välja de mest särskiljande istället för att bara stapla på dem. De är skiftlägeskänsliga: "end" fångar aldrig "End", så du måste ta hänsyn till de varianter som spelar roll. Sekvensen inkluderas aldrig i svaret, vilket är viktigt om ditt förväntade format slutar med den avgränsaren. Slutligen sker detektering token för token: om din sekvens hamnar mitt i en token går den obemärkt förbi – ytterligare en anledning att välja avgränsare med flera tecken snarare än en enda symbol.
Dyra misstag
Det vanligaste felet är en sekvens som är för kort, vilket utlöser för tidiga stopp. En ensam punkt stoppar genereringen vid den första mening den ser, även mitt i en förkortning; det symmetriska misstaget är att välja en sträng som modellen aldrig kommer att producera, i vilket fall parametern inte gör något och du tror felaktigt att du har satt upp ett skyddsräcke.
# 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:", "---"]
Regeln som följer av dessa fyra rader är enkel: en bra avbrottssekvens härleds från det format du bad modellen använda, aldrig från din fantasi.
Komplett exempel: kontrollerad Q&A
Låt oss sätta ihop dessa element till en kort fråge-och-svars-funktion, där låg temperatur säkerställer faktamässig stabilitet, max_tokens sätter ett säkerhetstak, och sekvenser för avbrott klipper bort de kommentarer modellen kan frestas att lägga till efter sitt svar:
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")
Kör detta skript en gång som det är, och en andra gång efter att du har tagit bort parametern stop: att jämföra de två utdatorna visar dig exakt vad dessa tre sekvenser filtrerar bort.
Viktiga punkter
- Sekvenser för avbrott stoppar genereringen när modellen producerar specifik text
- Högst 4 sekvenser per begäran; skiftlägeskänsliga
- Avbrottssekvensen inkluderas aldrig i svaret
- Använd sekvenser som är specifika nog för att undvika för tidiga stopp
- Kompatibelt med streaming och alla andra parametrar