Stop sequences (language models) (SV)

Stop Sequence (stoppsekvens) i kontexten av stora språkmodeller (LLM) är en speciell sekvens av tecken eller tokens som signalerar till modellen att den ska avsluta textgenereringen. Denna mekanism är en viktig komponent i autoregressiva språkmodeller och säkerställer ett kontrollerbart och förutsägbart svar.

När en stop sequence används kontrollerar modellen vid varje genereringssteg om den redan genererade texten slutar med någon av de angivna sekvenserna. Om en matchning hittas avbryts processen omedelbart, varvid stop sequence inte inkluderas i det slutliga utdatan. Detta gör det möjligt för utvecklaren att exakt styra svarsgränserna utan att ändra själva prompten.

Grundläggande funktionsprinciper

I autoregressiva språkmodeller sker textgenerering sekventiellt, token för token. Vid varje steg förutsäger modellen nästa token baserat på hela den föregående sekvensen (inmatningsprompten och den redan genererade texten). Matematiskt uttrycks detta som en betingad sannolikhet:

$P(y_t\mid y_{<t},x)$

där $y_t$ är den aktuella genererade token, $y_{<t}$ är sekvensen av tidigare genererade tokens, och $x$ är inmatningssekvensen.

Mekanismen stop sequence fungerar som ett externt kriterium för att avbryta denna iterativa process.

Typer av stoppsekvenser

Det finns flera grundläggande typer av stoppmekanismer som kan användas antingen separat eller i kombination.

1. End-of-Sequence-tokens (EOS)

End-of-Sequence (EOS) är speciella tokens (till exempel `<|endoftext|>`) som är inbyggda i modellens vokabulär och är avsedda att markera slutet på ett logiskt textavsnitt. Modellen tränas att generera EOS-token när den anser att svaret är färdigt, eftersom alla texter i träningsdatan avslutas med denna token. När en EOS-token detekteras avslutas genereringen automatiskt.

Forskning visar att förekomsten av EOS-tokens påverkar uppmärksamhetsarkitekturen: modeller utvecklar interna mekanismer för positionsräkning, vilket dock kan begränsa deras förmåga att extrapolera på sekvenser som avsevärt överskrider längden på träningsexemplen.

2. Användardefinierade sekvenser

Dessa är godtyckliga strängar som en utvecklare anger för en specifik uppgift. De är inte en del av modellens vokabulär men spåras på teckennivå. Exempel inkluderar:

• Radbrytningar: `\n` eller `\n\n` för att stoppa efter ett stycke.
• Kontextmarkörer: `Human:`, `User:` eller `Q:` för att separera repliker i en dialog.
• Specialmarkörer: `###`, `</output>` eller `END`.

3. Strukturella sekvenser

Dessa är specialiserade markörer som används för att avsluta specifika strukturella element, vilket är avgörande vid generering av formaterat innehåll:

• Kod: Trippla backtick-tecken (```) för att avsluta ett kodblock.
• JSON/XML: Avslutande klammerparenteser (`}`) eller taggar (`</element>`).

Teknisk implementation och problem

Effektiv detektering av stop sequences är en icke-trivial uppgift som medför en rad svårigheter.

Detekteringsalgoritm och optimering

Detekteringsprocessen i verkliga system inkluderar:

1. Kontroll vid varje steg: Efter generering av varje ny token kontrollerar systemet om det aktuella utdatan slutar med någon av de angivna stop sequences.
2. Hantering av partiella matchningar: Systemet måste spåra situationer där en del av sekvensen redan har genererats men ingen fullständig matchning ännu har skett.
3. Flerkriteriekontroll: De flesta system (till exempel OpenAI API) tillåter spårning av flera (upp till fyra) stop sequences samtidigt.

I Hugging Face Transformers-ramverket implementeras den abstrakta klassen `StoppingCriteria` för detta ändamål, vilket möjliggör skapandet av anpassade stoppkriterier såsom `MaxLengthCriteria` (baserat på längd) eller `EosTokenCriteria` (baserat på EOS-token).

Problem och begränsningar

• Tokeniseringsproblem: Detta är den huvudsakliga tekniska svårigheten. Samma teckensekvens (till exempel `\nUser:`) kan delas upp i tokens på olika sätt beroende på kontexten. Detta försvårar tillförlitlig detektering, eftersom stop sequence kan vara uppdelad över flera tokens.
• Prestanda: Att kontrollera många långa stop sequences vid varje steg kan sakta ner genereringen, särskilt vid arbete med långa sekvenser i realtid.
• Falska positiva: Den angivna sekvensen kan av misstag förekomma mitt i det önskade svaret, vilket leder till ett för tidigt avslutande. Det är därför viktigt att välja tillräckligt unika och specifika markörer (till exempel `\n###\n`).

Tillämpning och användningsscenarier

Stop sequences är ett kraftfullt verktyg för att styra LLM:ers beteende.

• Längd- och kostnadskontroll: Gör det möjligt att begränsa den maximala svarsstorleken och därmed minska tokenförbrukningen, vilket är viktigt vid användning av betalda API:er.
• Dialogsystem: Används för att tydligt separera samtalsparternas repliker, så att assistentmodellen inte genererar svar åt användaren.
• Generering av strukturerat innehåll: Oumbärliga för att erhålla korrekt utdata i formaten JSON, XML eller vid kodskrivning, vilket förhindrar att extra information läggs till efter att strukturen är avslutad.
• Förebyggande av oönskat beteende: Hjälper till att avbryta genereringen när repetitivt eller felaktigt innehåll (hallucinationer) uppträder.
• Träning och fine-tuning: I träningsdataset används ofta unika markörer (till exempel `###`) som stop sequences, så att modellen lär sig att avsluta svaret på rätt plats.

Aktuella forskningsinriktningar

• Adaptiva stoppkriterier: Utveckling av metoder som dynamiskt bestämmer avslutningspunkten baserat på kontexten och kvaliteten på den genererade texten.
• Entropibaserade metoder: Användning av entropin i tokendistributionen som kriterium. Hög entropi kan indikera modellens osäkerhet och fungera som en signal för att avsluta genereringen.

Referenser

• OpenAI:s dokumentation om användning av stop sequences
• Hugging Face dokumentation om StoppingCriteria

Litteratur

• Sutskever, I.; Vinyals, O.; Le, Q. V. (2014). Sequence to Sequence Learning with Neural Networks. arXiv:1409.3215.
• Vaswani, A. et al. (2017). Attention Is All You Need. arXiv:1706.03762.
• Keskar, N. S. et al. (2019). CTRL: A Conditional Transformer Language Model for Controllable Generation. arXiv:1909.05858.
• Holtzman, A. et al. (2020). The Curious Case of Neural Text Degeneration. arXiv:1904.09751.
• Brown, T. et al. (2020). Language Models are Few-Shot Learners. arXiv:2005.14165.
• Zong, M.; Krishnamachari, B. (2022). A Survey on GPT-3. arXiv:2212.00857.
• Zhao, Y. et al. (2022). Calibrating Sequence Likelihood Improves Conditional Language Generation. arXiv:2210.00045.
• Hu, J. C.; Cavicchioli, R.; Capotondi, A. (2023). A Request for Clarity over the End-of-Sequence Token in the Self-Critical Sequence Training. arXiv:2305.12254.
• Zhu, W. et al. (2024). Improving Open-Ended Text Generation via Adaptive Decoding. arXiv:2402.18223.
• Zhang, H. et al. (2024). Adaptable Logical Control for Large Language Models. arXiv:2406.13892.
• Suh, Y. J. et al. (2025). The Curious Case of Sequentially Mis-calibrated Language Models. arXiv:2205.11916.