Technische Samenvatting: GOAT: Een Trainingsframework voor Doelgerichte Agenten met Hulpmiddelen

Probleemstelling

Grote Taalmodellen (LLM's) zijn geëvolueerd tot interactieve agenten die externe hulpmiddelen (API's) kunnen aanroepen. Er blijft echter een aanzienlijke kloof bestaan bij het verwerken van doelgerichte queries. In tegenstelling tot eenvoudigere taken die betrekking hebben op single-step queries of expliciet gespecificeerde instructies, vereisen doelgerichte taken dat een agent een hoog niveau doel ontleedt in een reeks onderling afhankelijke API-aanroepen. Dit vraagt om complex redeneren voor taakontleding, planning op lange termijn en het vermogen om geschikte argumenten voor API-functies af te leiden op basis van de uitvoer van eerdere aanroepen.

Huidige benaderingen voor het trainen van agenten voor deze taken worden beperkt door het ontbreken van hoogwaardige trainingsdata. Het construeren van datasets die inter-API-afhankelijkheden vastleggen, vereist doorgaans kostbare menselijke annotatie, wat niet schaalbaar is. Bijgevolg vertrouwen de meeste bestaande methoden op zero-shot evaluatie, waarbij van modellen wordt verwacht dat ze complex redeneren zonder taakspecifieke supervisie. Hoewel propriëtaire modellen (bijvoorbeeld GPT-4) enige capaciteit tonen, falen kleinere open-source modellen vaak bij het effectief uitvoeren van deze complexe hulpmiddel-gebruiksscenario's.

Methodologie: Het GOAT-framework

Om het probleem van data-schaarste aan te pakken, stellen de auteurs GOAT (Goal-Oriented Agent with Tools) voor, een volledig automatisch trainingsframework dat doelgerichte API-uitvoeringsdata synthetiseert uit bestaande API-documentatie zonder menselijke annotatie. Het framework werkt op de premisse dat API-documentatie doorgaans beschikbaar is voor doelgebieden en kan worden benut om trainingsdata te construeren.

1. Automatische Dataset-constructie

De kerninnovatie van GOAT is een call-first generatieparadigma, wat contrasteert met de "instruction-first"-strategieën die in eerdere werken worden gebruikt (waarbij een LLM eerst een query genereert en vervolgens probeert deze af te beelden op API-aanroepen). GOAT draait deze flow om om zelfversterkende bias naar "eenvoudige" gevallen te voorkomen.

Het proces voor dataconstructie omvat drie hoofdfasen:

• Constructie van een API-afhankelijkheidsgraf:

  • Parsen: API-documenten worden geparsed om input/output-specificaties te extraheren.
  • Initialisatie van de graf: Een volledig verbonden multidirecte graaf wordt geïnitieerd waarbij randen potentiële afhankelijkheden vertegenwoordigen (uitvoer van API $A$ als invoer voor API $B$).
  • Progressieve filtering: Om betrouwbaarheid te waarborgen, wordt de graf verfijnd via drie filterstappen:
    1. Embedding-similariteit: Grove filtering met SBERT-embeddings om semantisch incompatibele randen te verwijderen.
    2. LLM-verificatie: Een LLM evalueert semantische plausibiliteit op basis van beschrijvingen alleen.
    3. Uitvoeringsvalidatie: De meest rigoureuze stap, waarbij de LLM argumenten genereert, de bron-API uitvoert en verifieert of de uitvoer de parameters van de bestemmings-API geldig kan invullen. Dit zorgt ervoor dat alleen uitvoerbare workflows worden behouden.

• Synthese van doelgerichte data:

  • Sampling: Verbonden subgrafieken (die geldige API-sequenties vertegenwoordigen) worden uit de afhankelijkheidsgraf gehaald.
  • Call-first instantiatie: Het framework instantieert en voert de API-sequentie uit, waardoor concrete uitvoer wordt gegenereerd.
  • Generatie van query en respons: Op basis van de uitgevoerde sequentie en uitvoer genereert de LLM een natuurlijke taal gebruikersquery die het hoog niveau doel omvat en een eindrespons die de resultaten interpreteert. Dit creëert een dataset waarbij het supervisie-signaal (de API-aanroepsequentie) is verankerd in de realiteit, en de query een abstractie van die realiteit is.

2. Agent-training

Het framework fine-tunt twee componenten op de gesynthetiseerde dataset:

• LLM-agent: Instructie-getuned om de juiste reeks aanroepen te plannen, argumenten in te vullen (met argumentwaarden tijdens training gemaskeerd om overfitting op specifieke waarden te voorkomen) en de uiteindelijke natuurlijke taalrespons te genereren.
• Retriever: Een dense retrieval-model (gebaseerd op SBERT) getraind op ground-truth query-API-documentparen om gebruikersqueries af te beelden op relevante API-specificaties.

Belangrijkste Bijdragen

1. GOAT-framework: Een nieuw, volledig automatisch trainingsframework dat doelgerichte API-uitvoeringsdatasets construeert uit API-documentatie zonder menselijke annotatie. Het introduceert een call-first generatiestrategie die betrouwbare supervisie biedt voor het leren van complex redeneren door data te verankeren in uitvoerbare API-workflows.
2. State-of-the-art prestaties: Uitgebreide experimenten tonen aan dat agenten getraind met GOAT state-of-the-art prestaties behalen op meerdere bestaande doelgerichte benchmarks met open-source modellen, en in sommige gevallen gesloten bronmodellen met sterke redeneercapaciteiten overtreffen.
3. GOATBench: De introductie van een nieuwe, grootschalige evaluatiebenchmark voor doelgerichte taken. Gebouwd met de GOAT-pijplijn en lichte menselijke verificatie, dekt het diverse domeinen (Entertainment, Financiën, Voedsel, Reizen) en bevat het zowel "gezette" als "ongezette" API-composities om generalisatie te testen.

Experimentele Resultaten

De auteurs evalueerden GOAT op RestBench, API-Bank en de nieuwe GOATBench.

• RestBench: Open-source modellen (Llama-2-13B, Vicuna-13B) die met GOAT zijn gefine-tuned, toonden aanzienlijke verbeteringen ten opzichte van zero-shot baselines en eerdere open-source methoden (RestGPT). In sommige gevallen presteerden ze beter dan gesloten bronmodellen zoals GPT-4.
• API-Bank: Met GOAT getrainde modellen presteerden aanzienlijk beter dan zero-shot baselines en andere synthetische data-benaderingen, met hogere successpercentages en percentages voor correcte paden.
• GOATBench: Met GOAT getrainde agenten toonden consistente winsten ten opzichte van niet-gefine-tunde modellen en modellen getraind met instruction-first data (bijvoorbeeld van ToolLLM). Het framework bleek effectief in zowel single-tool als inter-tool (multi-API) scenario's.
• Ablatiestudies:
  • Call-First versus Instruction-First: Modellen getraind met call-first data behaalden consistent hogere successpercentages dan die getraind met instruction-first data, wat de strategie valideert om betere supervisie te bieden voor complex redeneren.
  • Generalisatie: Modellen getraind op GOATBench toonden verbeterde prestaties op ongezette API's en cross-benchmark generalisatie (bijvoorbeeld trainen op GOATBench en testen op RestBench), hoewel de winsten binnen het domein duidelijker waren.

Betekenis en Claims

Het artikel claimt dat GOAT een praktische en schaalbare weg biedt naar het bouwen van robuuste open-source LLM-agenten die complex redeneren en hulpmiddelgebruik aankunnen. Door de afhankelijkheid van kostbare menselijke annotatie te elimineren en het "call-first"-paradigma te benutten, maakt GOAT efficiënte domeinspecifieke adaptatie van LLM's mogelijk. De resultaten suggereren dat open-source modellen, wanneer correct gefine-tuned met deze synthetische data, kunnen wedijveren met of de prestaties van propriëtaire modellen kunnen overtreffen bij doelgericht hulpmiddelgebruik, waarmee een kritieke bottleneck in de implementatie van agentieke AI-systemen wordt aangepakt.

De auteurs erkennen beperkingen, met de opmerking dat hoewel het framework de prestaties binnen het domein verbetert, generalisatie naar volledig ongezette scenario's beperkt blijft en de kwaliteit van gegenereerde data afhankelijk is van de kwaliteit van de bron-API-documentatie. Niettemin legt het werk een nieuwe baseline vast voor het trainen van agenten op onderling afhankelijk hulpmiddelgebruik zonder menselijke tussenkomst.