Stop sequences (language models) (NL)

Stop sequence (stopsequentie) is in de context van grote taalmodellen (LLM) een speciale reeks tekens of tokens die het model aangeeft dat het de tekstgeneratie moet stoppen. Dit mechanisme is een belangrijk onderdeel van autoregressieve taalmodellen en zorgt voor een beheerste en voorspelbare afsluiting van het antwoord.

Bij gebruik van een stop sequence controleert het model bij elke generatiestap of de al gegenereerde tekst eindigt op een van de opgegeven sequenties. Als een overeenkomst wordt gevonden, stopt het proces onmiddellijk; de stop sequence zelf wordt niet opgenomen in de uiteindelijke uitvoer. Dit stelt de ontwikkelaar in staat de grenzen van het antwoord nauwkeurig te bepalen zonder het verzoek zelf te wijzigen.

Basisprincipes van het functioneren

In autoregressieve taalmodellen verloopt de tekstgeneratie sequentieel, token voor token. Bij elke stap voorspelt het model het volgende token op basis van de volledige voorafgaande reeks (de invoerprompt en de al gegenereerde tekst). Wiskundig wordt dit uitgedrukt als een voorwaardelijke kans:

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

waar $y_t$ het huidige te genereren token is, $y_{<t}$ de reeks eerder gegenereerde tokens, en $x$ de invoersequentie.

Het mechanisme van de stop sequence functioneert als een extern afbreekcriterium voor dit iteratieve proces.

Typen stopsequenties

Er bestaan verschillende hoofdtypen stopsequenties, die zowel afzonderlijk als in combinatie kunnen worden gebruikt.

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

End-of-Sequence (EOS) — dit zijn speciale tokens (bijvoorbeeld `<|endoftext|>`) die ingebouwd zijn in het woordenboek van het model en bedoeld zijn om het einde van een logisch tekstfragment aan te duiden. Het model wordt getraind om een EOS-token te genereren wanneer het het antwoord als afgerond beschouwt, omdat alle teksten in de trainingsset eindigen met dit token. Bij detectie van een EOS-token stopt de generatie automatisch.

Onderzoek toont aan dat de aanwezigheid van EOS-tokens invloed heeft op de attention-architectuur: modellen ontwikkelen interne mechanismen voor het bijhouden van posities, wat echter hun vermogen tot extrapolatie op sequenties die aanzienlijk langer zijn dan de trainingsvoorbeelden kan beperken.

2. Aangepaste sequenties

Dit zijn willekeurige tekenreeksen die de ontwikkelaar voor een specifieke taak opgeeft. Ze maken geen deel uit van het woordenboek van het model, maar worden op tekenniveau bijgehouden. Voorbeelden zijn:

• Regelafbreektekens: `\n` of `\n\n` om na een alinea te stoppen.
• Contextmarkeringen: `Human:`, `User:` of `Q:` voor het scheiden van beurten in een dialoog.
• Speciale markeringen: `###`, `</output>` of `END`.

3. Structurele sequenties

Dit zijn gespecialiseerde markeringen die worden gebruikt voor het afsluiten van bepaalde structurele elementen, wat van cruciaal belang is bij het genereren van geformatteerde inhoud:

• Code: drievoudige backticks (```) voor het afsluiten van een codeblok.
• JSON/XML: sluitende haakjes (`}`) of tags (`</element>`).

Technische implementatie en problemen

Effectieve detectie van stop sequences is een niet-triviale taak die gepaard gaat met een aantal uitdagingen.

Detectie-algoritme en optimalisatie

Het detectieproces in praktische systemen omvat:

1. Controle bij elke stap: Na het genereren van elk nieuw token controleert het systeem of de huidige uitvoer eindigt op een van de opgegeven stop sequences.
2. Verwerking van gedeeltelijke overeenkomsten: Het systeem moet situaties bijhouden waarbij een deel van de sequentie al is gegenereerd, maar er nog geen volledige overeenkomst is.
3. Meervoudige controle: De meeste systemen (bijvoorbeeld de OpenAI API) ondersteunen het tegelijkertijd bijhouden van meerdere (tot vier) stop sequences.

In het Hugging Face Transformers-framework is hiervoor de abstracte klasse `StoppingCriteria` geïmplementeerd, waarmee aangepaste stopcriteriya kunnen worden aangemaakt, zoals `MaxLengthCriteria` (op basis van lengte) of `EosTokenCriteria` (op basis van een EOS-token).

Problemen en beperkingen

• Tokenisatieprobleem: Dit is de voornaamste technische uitdaging. Dezelfde tekenreeks (bijvoorbeeld `\nUser:`) kan afhankelijk van de context op verschillende manieren worden opgedeeld in tokens. Dit bemoeilijkt betrouwbare detectie, omdat een stop sequence over meerdere tokens verdeeld kan zijn.
• Prestaties: Het controleren van meerdere lange stop sequences bij elke stap kan de generatie vertragen, met name bij het in real-time verwerken van lange sequenties.
• Fout-positieven: De opgegeven sequentie kan per ongeluk in het midden van het gewenste antwoord voorkomen, wat leidt tot vroegtijdige afbreking. Het is daarom belangrijk voldoende unieke en specifieke markeringen te kiezen (bijvoorbeeld `\n###\n`).

Toepassingen en gebruiksscenario's

Stop sequences zijn een krachtig hulpmiddel voor het sturen van het gedrag van LLM's.

• Beheersing van lengte en kosten: Ze maken het mogelijk de maximale omvang van het antwoord te beperken en daarmee het tokenverbruik te verminderen, wat belangrijk is bij gebruik van betaalde API's.
• Dialoogsystemen: Ze worden gebruikt voor een duidelijke scheiding van de beurten van gesprekspartners, zodat het assistent-model niet namens de gebruiker een antwoord genereert.
• Generatie van gestructureerde inhoud: Ze zijn onmisbaar voor het verkrijgen van correcte uitvoer in JSON-, XML-formaat of bij het schrijven van code, door te voorkomen dat er overbodige informatie wordt toegevoegd na het afsluiten van de structuur.
• Voorkomen van ongewenst gedrag: Ze helpen de generatie te onderbreken wanneer herhalende of onjuiste inhoud (hallucinaties) verschijnt.
• Training en fine-tuning: In trainingssets worden vaak unieke markeringen (bijvoorbeeld `###`) gebruikt als stop sequence, zodat het model leert het antwoord op de juiste plaats af te sluiten.

Actuele onderzoeksrichtingen

• Adaptieve stopcriteriya: De ontwikkeling van methoden die het eindpunt dynamisch bepalen op basis van de context en de kwaliteit van de gegenereerde tekst.
• Entropiegebaseerde benaderingen: Het gebruik van de entropie van de tokendistributie als criterium. Hoge entropie kan duiden op onzekerheid van het model en dienen als signaal om de generatie te stoppen.

Verwijzingen

• Documentatie van OpenAI over het gebruik van stop sequences
• Documentatie van Hugging Face over StoppingCriteria

Literatuur

• 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.