Optimizeer LLM met DSPy: Een stap-voor-stap gids voor het bouwen, optimaliseren en evalueren van AI-systemen Specificeer invoersleutels In DSPy hebben Example-objecten een with_inputs()-methode om specifieke velden te markeren als invoer: Waarden kunnen worden toegang met de puntoperator, en methoden zoals inputs() en labels() retourneren nieuwe Example-objecten die alleen invoer- of niet-invoervelden bevatten. Optimalisatoren in DSPy Een DSPy-optimalisator stemt de parameters van een DSPy-programma (d.w.z. prompts en/of LM-gewichten) af om de gespecificeerde metrieken te maximaliseren. DSPy biedt verschillende ingebouwde optimalisatoren, waarbij elk een andere strategie wordt gebruikt. Beschikbare optimalisatoren BootstrapFewShot: Genereert few-shot voorbeelden met behulp van de verstrekte gelabelde invoer- en uitvoergegevenspunten. BootstrapFewShotWithRandomSearch: Past BootstrapFewShot meerdere keren toe met een willekeurige zoekopdracht over gegenereerde demonstraties. COPRO: Genereert en verfijnt nieuwe instructies voor elke stap, waardoor deze worden geoptimaliseerd met behulp van coördinatenstijging. MIPRO: Optimaliseert instructies en few-shot voorbeelden met behulp van Bayesian Optimization. Kies een optimalisator Als u niet zeker weet waar u moet beginnen, gebruikt u BootstrapFewShotWithRandomSearch: Voor zeer weinig gegevens (10 voorbeelden), gebruikt u BootstrapFewShot. Voor iets meer gegevens (50 voorbeelden), gebruikt u BootstrapFewShotWithRandomSearch. Voor grotere datasets (300+ voorbeelden), gebruikt u MIPRO.

Naarmate de mogelijkheden van grote taalmodellen (LLM’s) zich blijven uitbreiden, is het ontwikkelen van robuuste AI-systemen die hun potentieel benutten, steeds complexer geworden. Conventionele benaderingen omvatten vaak ingewikkelde prompttechnieken, gegevensgeneratie voor fine-tuning en handmatige begeleiding om te garanderen dat ze voldoen aan domeinspecifieke beperkingen. Dit proces kan echter saai, foutgevoelig en sterk afhankelijk van menselijke tussenkomst zijn.

Kom DSPy binnen, een revolutionair kader ontworpen om de ontwikkeling van AI-systemen aangedreven door LLM’s te stroomlijnen. DSPy introduceert een systematische aanpak voor het optimaliseren van LM-prompts en -gewichten, waardoor ontwikkelaars geavanceerde toepassingen kunnen bouwen met minimale handmatige inspanning.

In deze uitgebreide gids zullen we de kernbeginselen van DSPy, de modulaire architectuur en de reeks krachtige functies die het biedt, verkennen. We zullen ook duiken in praktische voorbeelden, waarin wordt aangetoond hoe DSPy de manier waarop u AI-systemen met LLM’s ontwikkelt, kan transformeren.

Wat is DSPy, en waarom hebt u het nodig?

DSPy is een kader dat de stroom van uw programma (modules) scheidt van de parameters (LM-prompts en -gewichten) van elke stap. Deze scheiding maakt een systematische optimalisatie van LM-prompts en -gewichten mogelijk, waardoor u complexe AI-systemen kunt bouwen met grotere betrouwbaarheid, voorspelbaarheid en naleving van domeinspecifieke beperkingen.

Traditioneel hield het ontwikkelen van AI-systemen met LLM’s een tijdrovend proces in van het opdelen van het probleem in stappen, het maken van ingewikkelde prompts voor elke stap, het genereren van synthetische voorbeelden voor fine-tuning en het handmatig begeleiden van de LLM’s om te voldoen aan specifieke beperkingen. Deze benadering was niet alleen tijdrovend, maar ook foutgevoelig, aangezien zelfs kleine wijzigingen in de pijplijn, de LM of de gegevens een uitgebreide herschrijving van prompts en fine-tuningstappen konden vereisen.

DSPy adresseert deze uitdagingen door een nieuw paradigma te introduceren: optimalisatoren. Deze LM-gestuurde algoritmes kunnen de prompts en gewichten van uw LM-aanroepen afstemmen, gegeven een metriek die u wilt maximaliseren. Door het optimalisatieproces te automatiseren, empoweren DSPy-ontwikkelaars om robuuste AI-systemen te bouwen met minimale handmatige tussenkomst, waardoor de betrouwbaarheid en voorspelbaarheid van LM-uitvoer worden verbeterd.

De modulaire architectuur van DSPy

In het hart van DSPy ligt een modulaire architectuur die de compositie van complexe AI-systemen faciliteert. Het kader biedt een reeks ingebouwde modules die verschillende prompttechnieken abstract, zoals dspy.ChainOfThought en dspy.ReAct. Deze modules kunnen worden gecombineerd en samengesteld tot grotere programma’s, waardoor ontwikkelaars ingewikkelde pijplijnen kunnen bouwen die zijn aangepast aan hun specifieke vereisten.

Elke module omvat leerbare parameters, waaronder instructies, voorbeelden met weinig schoten en LM-gewichten. Wanneer een module wordt aangeroepen, kunnen de optimalisatoren van DSPy deze parameters afstemmen om de gewenste metriek te maximaliseren, waardoor wordt gegarandeerd dat de uitvoer van de LM voldoet aan de gespecificeerde beperkingen en vereisten.

Optimaliseren met DSPy

DSPy introduceert een reeks krachtige optimalisatoren die zijn ontworpen om de prestaties en betrouwbaarheid van uw AI-systemen te verbeteren. Deze optimalisatoren gebruiken LM-gestuurde algoritmes om de prompts en gewichten van uw LM-aanroepen af te stemmen, waardoor de gespecificeerde metriek wordt gemaximaliseerd en domeinspecifieke beperkingen in acht worden genomen.

Enkele van de belangrijkste optimalisatoren die beschikbaar zijn in DSPy, zijn:

1. BootstrapFewShot: Deze optimalisator breidt de handtekening uit door automatisch geoptimaliseerde voorbeelden te genereren en op te nemen in de prompt die naar het model wordt verzonden, waardoor few-shot learning wordt geïmplementeerd.
2. BootstrapFewShotWithRandomSearch: Past BootstrapFewShot meerdere keren toe met een willekeurige zoekopdracht over gegenereerde demonstraties, waarbij het beste programma over de optimalisatie wordt geselecteerd.
3. MIPRO: Genereert instructies en voorbeelden met weinig schoten in elke stap, waarbij de instructiegeneratie gegevensbewust en demonstratiebewust is. Het gebruikt Bayesian Optimization om effectief te zoeken naar de ruimte van generatie-instructies en demonstraties over uw modules.
4. BootstrapFinetune: Distilleert een prompt-gebaseerd DSPy-programma in gewichtsupdates voor kleinere LM’s, waardoor u de onderliggende LLM(s) kunt fine-tunen voor verbeterde efficiëntie.

Door deze optimalisatoren te gebruiken, kunnen ontwikkelaars hun AI-systemen systematisch optimaliseren, waardoor wordt gegarandeerd dat de uitvoer van hoge kwaliteit is en domeinspecifieke beperkingen en vereisten in acht worden genomen.

Aan de slag met DSPy

Om de kracht van DSPy te demonstreren, laten we een praktisch voorbeeld zien van het bouwen van een retrieval-augmented generation (RAG)-systeem voor vraagbeantwoording.

Stap 1: Configuratie van de taalmodel en de retrievalmodel

De eerste stap omvat het configureren van het taalmodel (LM) en het retrievalmodel (RM) binnen DSPy.

Om DSPy te installeren, voer uit:

pip install dspy-ai

DSPy ondersteunt meerdere LM- en RM-API’s, evenals lokale modelhosting, waardoor het gemakkelijk is om uw voorkeursmodellen te integreren.

import dspy

# Configureer het LM en het RM
turbo = dspy.OpenAI(model='gpt-3.5-turbo')
colbertv2_wiki17_abstracts = dspy.ColBERTv2(url='http://20.102.90.50:2017/wiki17_abstracts')

dspy.settings.configure(lm=turbo, rm=colbertv2_wiki17_abstracts)

Stap 2: Laden van de dataset

Vervolgens laden we de HotPotQA-dataset, die een verzameling van complexe vraag-antwoordparen bevat die meestal op een multi-hop-manier worden beantwoord.

from dspy.datasets import HotPotQA

# Laad de dataset
dataset = HotPotQA(train_seed=1, train_size=20, eval_seed=2023, dev_size=50, test_size=0)

# Specificeer het 'vraag'-veld als invoer
trainset = [x.with_inputs('vraag') for x in dataset.train]
devset = [x.with_inputs('vraag') for x in dataset.dev]

Stap 3: Bouwen van handtekeningen

DSPy gebruikt handtekeningen om het gedrag van modules te definiëren. In dit voorbeeld definiëren we een handtekening voor de antwoordgeneratie, waarbij we de invoervelden (context en vraag) en het uitvoerveld (antwoord) specificeren.

class GenerateAnswer(dspy.Signature):
"""Beantwoord vragen met korte feitenvragen."""

context = dspy.InputField(desc='kan relevante feiten bevatten')
vraag = dspy.InputField()
antwoord = dspy.OutputField(desc='vaak tussen 1 en 5 woorden')

Stap 4: Bouwen van de pijplijn

We bouwen onze RAG-pijplijn als een DSPy-module, die bestaat uit een initialisatiemethode (__init__) om de submodules (dspy.Retrieve en dspy.ChainOfThought) te declareren en een forward-methode (forward) om de besturingsstroom van het beantwoorden van de vraag met behulp van deze modules te beschrijven.

class RAG(dspy.Module):
def __init__(self, num_passages=3):
super().__init__()

self.retrieve = dspy.Retrieve(k=num_passages)
self.generate_answer = dspy.ChainOfThought(GenerateAnswer)

def forward(self, vraag):
context = self.retrieve(vraag).passages
voorspelling = self.generate_answer(context=context, vraag=vraag)
return dspy.Prediction(context=context, antwoord=voorspelling.antwoord)

Stap 5: Optimaliseren van de pijplijn

Met de pijplijn gedefinieerd, kunnen we deze nu optimaliseren met behulp van de optimalisatoren van DSPy. In dit voorbeeld gebruiken we de BootstrapFewShot-optimalisator, die effectieve prompts voor onze modules genereert en selecteert op basis van een trainingsset en een metriek voor validatie.

from dspy.teleprompt import BootstrapFewShot

# Validatiemetric
def validate_context_and_answer(example, pred, trace=None):
antwoord_EM = dspy.evaluate.answer_exact_match(example, pred)
antwoord_PM = dspy.evaluate.answer_passage_match(example, pred)
return antwoord_EM and antwoord_PM

# Stel de optimalisator in
teleprompter = BootstrapFewShot(metric=validate_context_and_answer)

# Compileer het programma
compiled_rag = teleprompter.compile(RAG(), trainset=trainset)

Stap 6: Evalueren van de pijplijn

Na het compileren van het programma, is het essentieel om de prestaties te evalueren op een ontwikkelingsset om ervoor te zorgen dat deze voldoet aan de gewenste nauwkeurigheid en betrouwbaarheid.

from dspy.evaluate import Evaluate

# Stel de evaluator in
evaluate = Evaluate(devset=devset, metric=validate_context_and_answer, num_threads=4, display_progress=True, display_table=0)

# Evalueer het gecompileerde RAG-programma
evaluation_result = evaluate(compiled_rag)

print(f"Evaluatieresultaat: {evaluation_result}")

Stap 7: Inspecteren van modelgeschiedenis

Voor een dieper inzicht in de interacties van het model, kunt u de meest recente generaties inspecteren door de geschiedenis van het model te inspecteren.

# Inspecteer de geschiedenis van het model
turbo.inspect_history(n=1)

Stap 8: Voorspellingen maken

Met de pijplijn geoptimaliseerd en geëvalueerd, kunt u deze nu gebruiken om voorspellingen te maken voor nieuwe vragen.

# Voorbeeldvraag
vraag = "Welke prijs ontving het eerste boek van Gary Zukav?"

# Maak een voorspelling met het gecompileerde RAG-programma
voorspelling = compiled_rag(vraag)

print(f"Vraag: {vraag}")
print(f"Antwoord: {voorspelling.antwoord}")
print(f"Geretourneerde context: {voorspelling.context}")

Minimale werkende voorbeeld met DSPy

Laten we nu een andere minimale werkende voorbeeld doorlopen met behulp van de GSM8K-dataset en het OpenAI GPT-3.5-turbo-model om promptingtaken binnen DSPy te simuleren.

Setup