Huidige lange-context grote taalmodellen (LLM’s) kunnen invoer verwerken tot 100.000 tokens, maar hebben moeite om outputs te genereren die langer zijn dan 2.000 woorden. Gecontroleerde experimenten laten zien dat de effectieve generatielengte van het model inherent beperkt is door de voorbeelden die tijdens de supervisie gefine-tuned (SFT) zijn gezien. Met andere woorden, deze outputbeperking komt voort uit de schaarste aan lange-outputvoorbeelden in bestaande SFT-datasets.

Recente vooruitgang in lange-context LLM’s heeft geleid tot de ontwikkeling van modellen met aanzienlijk vergrote geheugencapaciteiten, die in staat zijn om geschiedenissen te verwerken die langer zijn dan 100.000 tokens. Echter, ondanks hun vermogen om uitgebreide invoer te verwerken, hebben huidige lange-context LLM’s moeite om even lange outputs te genereren.

Om deze beperking te onderzoeken, onderzoekt LongWriter de maximale outputlengte van state-of-the-art lange-contextmodellen met meerdere queries die antwoorden van verschillende lengtes vereisen, zoals “Schrijf een artikel van 10.000 woorden over de geschiedenis van het Romeinse Rijk”. De resultaten laten zien dat alle modellen consistent falen om outputs te produceren die langer zijn dan 2.000 woorden. Ondertussen laat de analyse van gebruikersinteractielogbestanden zien dat meer dan 1% van de gebruikersaanvragen expliciet outputs vraagt die deze limiet overschrijden, waardoor er een dringende behoefte is in het huidige onderzoek om deze beperking te overwinnen.

Om dit aan te pakken, introduceert LongWriter AgentWrite, een agent-gebaseerde pipeline die off-the-shelf LLM’s gebruikt om automatisch uitgebreide, samenhangende outputs te construeren. AgentWrite werkt in twee fasen: eerst maakt het een gedetailleerd schrijfplan dat de structuur en het woordentelling voor elke alinea beschrijft op basis van de invoer van de gebruiker. Vervolgens volgt het model dit plan en genereert het inhoud voor elke alinea in een sequentiële manier. LongWriter’s experimenten valideren dat AgentWrite hoge-kwaliteit en samenhangende outputs kan produceren van maximaal 20.000 woorden.

LongWriter ontwikkelt ook LongBench-Write, een uitgebreide benchmark voor het evalueren van ultra-lange generatiecapaciteiten. Het 9B parametermodel, verder verbeterd door DPO, bereikt state-of-the-art prestaties op deze benchmark, zelfs in vergelijking met grotere propriëtaire modellen.

In dit artikel zullen we het LongWriter-kader bespreken, de architectuur ervan onderzoeken en de prestaties ervan vergelijken met state-of-the-art lange-context grote taalmodellen. Laten we beginnen.

LongWriter: 10.000+ Woorden Generatiekader

Recente vooruitgang in lange-context grote taalmodellen heeft geleid tot de creatie van modellen met aanzienlijk vergrote geheugencapaciteiten, die in staat zijn om geschiedenissen te verwerken die langer zijn dan 100.000 tokens. Ondanks hun vermogen om uitgebreide invoer te verwerken, hebben huidige lange-context LLM’s moeite om outputs te genereren die even lang zijn. Om deze beperking te onderzoeken, onderzoekt LongWriter de maximale outputlengte van state-of-the-art lange-contextmodellen met meerdere queries die antwoorden van verschillende lengtes vereisen, zoals “Schrijf een artikel van 10.000 woorden over de geschiedenis van het Romeinse Rijk”. Op basis van de resultaten ziet LongWriter dat alle modellen consistent falen om outputs te produceren die langer zijn dan 2.000 woorden. Bovendien geeft de analyse van gebruikersinteractielogbestanden aan dat meer dan 1% van de gebruikersaanvragen expliciet outputs vraagt die deze limiet overschrijden, waardoor er een dringende behoefte is in het huidige onderzoek om deze beperking te overwinnen.

LongWriter’s studie onthult een belangrijke inzicht: de beperking op outputlengte is voornamelijk geworteld in de kenmerken van de Supervised Fine-Tuning (SFT) datasets. Specifiek vindt LongWriter dat de maximale generatielengte van een model effectief beperkt is door de bovengrens van outputlengtes in zijn SFT-dataset, ondanks zijn blootstelling aan veel langere sequenties tijdens de pretrainingfase. Deze bevinding verklaart de universele 2.000-woord generatielimiet voor huidige modellen, aangezien bestaande SFT-datasets zelden voorbeelden bevatten die deze lengte overschrijden. Bovendien, aangezien veel datasets zijn gedistilleerd uit state-of-the-art LLM’s, erven ze ook de outputlengtebeperking van hun bronmodellen.

Om deze beperking aan te pakken, introduceert LongWriter AgentWrite, een novale agent-gebaseerde pipeline die off-the-shelf LLM’s gebruikt om automatisch uitgebreide, samenhangende outputs te construeren. AgentWrite werkt in twee fasen: eerst breekt het lange schrijftaken op in subtaken, met elke subtaak die het model vraagt om slechts één alinea te schrijven. Het model voert deze subtaken vervolgens sequentieel uit, en LongWriter concateneert de subtaakoutputs om de finale lange output te verkrijgen. Een dergelijke aanpak van het opbreken van een complexe taak in meerdere subtaken met behulp van LLM-agents is al toegepast in verschillende domeinen, zoals probleemoplossing, softwareontwikkeling en modelbeoordeling. LongWriter’s werk is het eerste dat het integreren van planning onderzoekt om modellen in staat te stellen complexe lange-vormschrijftaken te voltooien. Elke stap van AgentWrite wordt hieronder in detail geïntroduceerd.

Stap I: Plan

Geïnspireerd door het denkproces van menselijke schrijvers, die typisch beginnen met het maken van een overall plan voor lange schrijftaken, gebruikt LongWriter de planningscapaciteiten van LLM’s om een schrijfplan te produceren gegeven een schrijfinstructie. Dit plan omvat de hoofdinhoud en woordentelling voor elke alinea. De prompt die door LongWriter wordt gebruikt, is als volgt:

“Ik heb je hulp nodig om de volgende lange-vormschrijfinstructie op te breken in meerdere subtaken. Elke subtaak zal de schrijf van één alinea in het essay begeleiden en moet de hoofdpunten en woordentelling voor die alinea bevatten. De schrijfinstructie is als volgt: {Gebruikersinstructie}. Breken het als volgt op, met elke subtaak die één regel inneemt:

Alinea 1 – Hoofdpunt: [Beschrijf het hoofdpunt van de alinea, in detail] – Woordentelling: [Woordentellingseis, bijv. 400 woorden]
Alinea 2 – Hoofdpunt: [Beschrijf het hoofdpunt van de alinea, in detail] – Woordentelling: [Woordentellingseis, bijv. 1000 woorden].

Zorg ervoor dat elke subtaak duidelijk en specifiek is, en dat alle subtaken de hele inhoud van de schrijfinstructie dekken. Verdeel de subtaken niet te fijn; elke subtaak’s alinea moet minstens 200 woorden en maximaal 1000 woorden zijn. Produceer geen andere inhoud.”

Stap II: Schrijf

Nadat het schrijfplan van Stap I is verkregen, roept LongWriter het LLM op om elke subtaak te voltooien, en genereert het schrijfinhoud sectie voor sectie. Om de samenhang van de output te waarborgen, wanneer LongWriter het model roept om de n-de sectie te genereren, worden de eerder gegenereerde n−1 secties ook als invoer gebruikt, waardoor het model kan doorgaan met het schrijven van de volgende sectie op basis van de bestaande schrijfgeschiedenis. Hoewel deze seriële manier het niet mogelijk maakt om parallelle oproepen te doen naar het model om meerdere subtaken tegelijk te voltooien, en de invoerlengte langer wordt, toont LongWriter aan in de validatie dat de algehele samenhang en kwaliteit van het geschrevene op deze manier verreweg superieur zijn aan de output gegenereerd in parallel.

De prompt die door LongWriter wordt gebruikt, is:
“Je bent een excellente schrijfassistent. Ik zal je een originele schrijfinstructie geven en mijn geplande schrijfstappen. Ik zal je ook de tekst geven die ik al heb geschreven. Help me alsjeblieft om verder te schrijven op basis van de schrijfinstructie, schrijfstappen en de al geschreven tekst.

Schrijfinstructie:
{Gebruikersinstructie}
Schrijfstappen:
{Het schrijfplan gegenereerd in Stap I}
Al geschreven tekst:
{Eerder gegenereerde (n-1) alinea’s}

Integreer de originele schrijfinstructie, schrijfstappen en de al geschreven tekst, en ga nu verder met het schrijven van {Het plan voor de n-de alinea, d.w.z. de n-de regel in het schrijfplan}.”

Validatie

LongWriter test de generatielengte en -kwaliteit van de voorgestelde AgentWrite-methode op twee lange-vormschrijftaken datasets. De eerste, LongWrite-Ruler, wordt gebruikt om te meten hoe lang de output kan zijn. De tweede, LongBench-Write, wordt voornamelijk gebruikt om te evalueren hoe goed de modelgegenereerde inhoud overeenkomt met de gebruikersinstructies in termen van lengte en schrijfkwaliteit.

LongBench-Write: Om de prestaties van het model op een meer diverse reeks lange-vormschrijfinstructies te evalueren, verzamelt LongWriter 120 variabele gebruikersschrijfprompt, met 60 in het Chinees en 60 in het Engels. Om beter te beoordelen of de outputlengte van het model voldoet aan de gebruikersvereisten, zorgt LongWriter ervoor dat alle instructies expliciete woordentellingseisen bevatten. Deze instructies zijn onderverdeeld in vier subsets op basis van de woordentellingseisen: 0-500 woorden, 500-2000 woorden, 2000-4000 woorden en langer dan 4000 woorden. Bovendien worden de instructies onderverdeeld in zeven categorieën op basis van het outputtype: Literatuur en creatief schrijven, academisch en monografisch, populairwetenschappelijk, functioneel schrijven, nieuwsrapport, communityforum en onderwijs en training.

Tijdens de evaluatie gebruikt LongWriter twee metrics: één voor het scoren van de outputlengte en één voor het scoren van de outputkwaliteit. De outputlengte van het model wordt gescoord op basis van hoe dicht het bij de vereisten in de instructies ligt. Voor de outputkwaliteit gebruikt LongWriter de LLM-as-a-judge-benadering, waarbij het state-of-the-art GPT-4o-model wordt geselecteerd om de output te scoren over zes dimensies: Relevantie, Accuratesse, Samenhang, Duidelijkheid, Breedte en Diepte, en Leeservaring. De finale score wordt berekend door de lengtescore en de kwaliteitsscore te middelen.

Validatieresultaten: LongWriter presenteert de outputlengtemeting op LongWrite-Ruler en vindt dat AgentWrite succesvol de outputlengte van GPT-4o van een maximum van 2k woorden tot ongeveer 20k woorden uitbreidt. LongWriter beoordeelt ook zowel de outputkwaliteit als de naleving van de vereiste outputlengte op LongBench-Write, waaruit blijkt dat GPT-4o succesvol taken kan voltooien met outputs onder de 2000 woorden in lengte bij het evalueren van de prestaties van AgentWrite.

Supervised Fine-Tuning

LongWriter voert training uit op basis van twee van de nieuwste open-source modellen, namelijk GLM-4-9B en Llama-3.1-8B. Beide zijn basismodellen en ondersteunen een contextwindow van maximaal 128k tokens, waardoor ze van nature geschikt zijn voor training op lange outputs. Om de training efficiënter te maken, past LongWriter packing training met loss weighting toe. De training op de twee modellen resulteert in twee modellen: LongWriter-9B (afgekort voor GLM-4-9B-LongWriter) en LongWriter-8B (afgekort voor Llama-3.1-8B-LongWriter).

Tegelijkertijd merkt LongWriter op dat, als het verlies gemiddeld wordt over de sequentie, d.w.z. door het nemen van het gemiddelde van elk sequentiegemiddelde verlies binnen een batch, de bijdrage van elk doeltoken tot het verlies in lange outputdata aanzienlijk minder zou zijn dan die met kortere outputs. In LongWriter’s experimenten wordt ook aangetoond dat dit leidt tot suboptimale modelprestaties op taken met lange outputs. Daarom kiest LongWriter voor een loss weighting-strategie die het verlies gemiddeld over de token berekent, waarbij het verlies wordt berekend als het gemiddelde van verliezen over alle doeltokens binnen die batch.

Alle modellen worden getraind met een node met 8xH800 80G GPUs en DeepSpeed+ZeRO3+CPU offloading. LongWriter gebruikt een batchgrootte van 8, een leeraantal van 1e-5 en een packinglengte van 32k. De modellen worden getraind voor 4 epochs, wat ongeveer 2.500-3.000 stappen duurt.

Alignement (DPO)

Om de outputkwaliteit van het model verder te verbeteren en zijn vermogen om lengtevereisten in instructies te volgen te verhogen, voert LongWriter directe voorkeursoptimalisatie (DPO) uit op het supervised fine-tuned LongWriter-9B-model. De DPO-gegevens komen van GLM-4’s chat DPO-gegevens (ongeveer 50k entries). Bovendien construeert LongWriter 4k paren gegevens die specifiek zijn gericht op lange-vormschrijfinstructies. Voor elke schrijfinstructie sampleert LongWriter 4 outputs van LongWriter-9B en scoort deze outputs volgens een specifieke methode. Een lengtevolgordescore wordt ook gecombineerd. De hoogst scorende output wordt vervolgens geselecteerd als de positieve sample, en één van de overige drie outputs wordt willekeurig geselecteerd als de negatieve sample.

Het resulterende model, LongWriter-9B-DPO, wordt getraind voor 250 stappen op de bovengenoemde gegevensmix. LongWriter volgt een specifiek recept voor DPO-training.

LongWriter: Experimenten en Resultaten

LongWriter evalueert 4 propriëtaire modellen en 5 open-source modellen op LongBench-Write, samen met de getrainde LongWriter-modellen. Volgens LongWriter’s kennis is Suri-IORPO het enige eerdere model dat ook is uitgelijnd voor lange-vormtekstgeneratie. Het is getraind op basis van Mistral-7B-Instruct-v0.2 met LoRA. In overeenstemming met de evaluatieopstelling op LongWrite-Ruler, stelt LongWriter de outputtemperatuur in op 0,5 en configureert het model’s generatiemaxtokensparameter tot het maximum dat is toegestaan door zijn API-aanroep. Voor open-source modellen wordt dit ingesteld op 32.768.

De meeste eerdere modellen zijn niet in staat om de lengtevereiste van meer dan 2.000 woorden te vervullen, terwijl LongWriter-modellen consistent langere en rijkere antwoorden op dergelijke prompts bieden.

Bij het observeren van de outputlengtescore SlS_lSl voor prompts in elke vereiste lengtebereik, vindt LongWriter dat eerdere modellen over het algemeen slecht presteren (scoren onder de 70) op prompts in het bereik [2k, 4k), met alleen Claude 3.5 Sonnet die een fatsoenlijke score behaalt. Voor prompts in het bereik [4k, 20k) zijn bijna alle eerdere modellen volledig onvermogend om de vereiste outputlengte te bereiken, zelfs met een score van 0 (wat betekent dat alle outputlengtes minder zijn dan één derde van de vereiste lengte). Door trainingdata van LongWriter-6k toe te voegen, kan LongWriter’s getrainde model effectief de vereiste outputlengte bereiken en tegelijkertijd een goede kwaliteit behouden, zoals gesuggereerd door de scores in het bereik [2k, 20k) en de scatterplots.

DPO verbetert effectief zowel de outputkwaliteit van het model als zijn vermogen om lengtevereisten in lange generatie te volgen.

Door de scores van LongWriter-9B en LongWriter-9B-DPO te vergelijken, vinden we dat DPO de scores Sl (+4%) en Sq (+3%) aanzienlijk verbetert, en dat de verbetering consistent is over alle bereiken. Dit toont aan dat in lange generatiescenario’s DPO nog steeds helpt om de outputkwaliteit van het model te verbeteren en kan beter de outputlengte van het model uitlijnen met de gevraagde lengte. Deze conclusie is ook onlangs waargenomen in Yuan et al. (2024) in kortere generaties. We annoteren ook handmatig pairwise wins en losses voor GPT-4o en drie LongWriter-modellen op hun outputs in LongBench-Write en visualiseren de resultaten in Figuur 9. We kunnen zien dat mensen de DPO-getrainde model in 58% van de gevallen boven LongWriter-9B verkiezen. Bovendien, ondanks het feit dat het minder parameters heeft, bereikt LongWriter-9B-DPO een gelijkspel met GPT-4o.

De outputlengtelimiet van de LongWriter-modellen wordt verlengd tot tussen de 10k en 20k woorden, terwijl meer gegevens met lange outputs zijn vereist om nog langere outputs te ondersteunen.

Volgend op de LongWrite-Ruler-test presenteert LongWriter ook de LongWrite-Ruler-testresultaten van de LongWriter-modellen. De resultaten suggereren dat hun maximale generatielengtes tussen de 10k en 20k woorden liggen. Het gebrek aan SFT-gegevens met langere outputs is waarschijnlijk de primaire reden waarom het model niet in staat is om langere outputlengtes te bereiken.

Finale Gedachten

In dit werk hebben we het LongWriter-kader besproken, de architectuur ervan onderzocht en de prestaties ervan vergeleken met state-of-the-art lange-context grote taalmodellen. Laten we beginnen. LongWriter introduceert AgentWrite, een agent-gebaseerde pipeline die off-the-shelf LLM’s gebruikt om automatisch uitgebreide, samenhangende outputs te construeren. LongWriter ontwikkelt ook LongBench-Write, een uitgebreide benchmark voor het evalueren van ultra-lange generatiecapaciteiten. Het 9B parametermodel, verder verbeterd door DPO, bereikt state-of-the-art prestaties op deze benchmark, zelfs in vergelijking met grotere propriëtaire modellen. Voor toekomstig onderzoek stelt LongWriter de volgende drie richtingen voor: 1. Het uitbreiden van het AgentWrite-kader om gegevens te construeren met langere outputs om de outputwindowgrootte van LLM’s verder te vergroten. 2. Het verfijnen van het AgentWrite-kader om hogere kwaliteit lange-outputgegevens te bereiken. 3. Langere modeloutputs brengen uitdagingen met zich mee voor de inferentie-efficiëntie. Verschillende methoden zijn voorgesteld om de inferentie-efficiëntie te verbeteren. Het is de moeite waard om te onderzoeken hoe deze methoden de model-efficiëntie kunnen verbeteren zonder de generatiekwaliteit te compromitteren.