Optimalizujte LLM s DSPy: Krok za krokem k sestavení, optimalizaci a vyhodnocení AI systémů

Jak se schopnosti velkých jazykových modelů (LLM) dále rozšiřují, stal se vývoj robustních AI systémů, které využívají jejich potenciál, stále složitějším. Konvenční přístupy často zahrnují složité techniky pro vyvolání, generování dat pro jemné ladění a manuální vedení, aby se zajistilo dodržování doménově specifických omezení. Tento proces však může být únavný, náchylný k chybám a silně závislý na lidském zásahu.

Vstoupí DSPy, revoluční rámec navržený pro zjednodušení vývoje AI systémů poháněných LLM. DSPy představuje systematický přístup k optimalizaci LM promptů a váh, umožňující vývojářům vytvářet sofistikované aplikace s minimálním manuálním úsilím.

V tomto komplexním průvodci prozkoumáme základní principy DSPy, jeho modulární architekturu a řadu mocných funkcí, které nabízí. Také se ponoříme do praktických příkladů, demonstrujících, jak DSPy může transformovat způsob, jakým vyvíjíte AI systémy s LLM.

Co je DSPy a proč ho potřebujete?

DSPy je rámec, který odděluje tok vašeho programu (moduly) od parametrů (LM promptů a váh) každého kroku. Tento oddělení umožňuje systematickou optimalizaci LM promptů a váh, umožňující vám budovat komplexní AI systémy s větší spolehlivostí, předvídatelností a dodržováním doménově specifických omezení.

Tradičně, vývoj AI systémů s LLM zahrnoval zdlouhavý proces rozdělení problému na kroky, vytváření složitých promptů pro každý krok, generování syntetických příkladů pro jemné ladění a manuální vedení LLM, aby dodržovaly specifická omezení. Tento přístup nebyl pouze časově náročný, ale také náchylný k chybám, protože i malé změny v pipeline, LM nebo datech mohly vyžadovat rozsáhlou rekonstrukci promptů a kroků jemného ladění.

DSPy řeší tyto výzvy zavedením nové paradigmatické změny: optimalizéry. Tyto LM-řízené algoritmy mohou ladit prompty a váhy vašich LM volání, dané metriky, které chcete maximalizovat. Automatizací procesu optimalizace, DSPy umožňuje vývojářům budovat robustní AI systémy s minimálním manuálním zásahem, zvyšující spolehlivost a předvídatelnost LM výstupů.

Modulární architektura DSPy

V srdci DSPy leží modulární architektura, která usnadňuje složení komplexních AI systémů. Rámec poskytuje sadu vestavěných modulů, které abstrahují různé techniky pro vyvolání, jako je dspy.ChainOfThought a dspy.ReAct. Tyto moduly lze kombinovat a skládat do větších programů, umožňující vývojářům budovat složité pipeline přizpůsobené jejich specifickým požadavkům.

Každý modul zahrnuje učitelné parametry, včetně instrukcí, few-shot příkladů a LM váh. Když je modul vyvolán, optimalizéry DSPy mohou tyto parametry jemně ladit, aby maximalizovaly požadovanou metriku, zajišťující, že LM výstupy dodržují specifikovaná omezení a požadavky.

Optimalizace s DSPy

DSPy představuje řadu mocných optimalizérů navržených pro zlepšení výkonu a spolehlivosti vašich AI systémů. Tyto optimalizéry využívají LM-řízené algoritmy pro ladění promptů a váh vašich LM volání, maximalizující specifikovanou metriku a dodržují doménově specifická omezení.

Některé z klíčových optimalizérů dostupných v DSPy zahrnují:

1. BootstrapFewShot: Tento optimalizér rozšiřuje signaturu automaticky generováním a zahrnutím optimalizovaných příkladů do promptu odeslaného do modelu, implementujícím few-shot učení.
2. BootstrapFewShotWithRandomSearch: Používá BootstrapFewShot několikrát s náhodným vyhledáváním přes vygenerované demonstrace, vybírající nejlepší program přes optimalizaci.
3. MIPRO: Generuje instrukce a few-shot příklady v každém kroku, přičemž generování instrukcí je datově vědomé a demonstračně vědomé. Používá Bayesian Optimization pro efektivní vyhledávání v prostoru generování instrukcí a demonstrací přes vaše moduly.
4. BootstrapFinetune: Destiluje prompt-založený DSPy program do weight updates pro menší LMy, umožňující vám jemně ladit podkladový LLM pro zvýšenou efektivitu.

Používáním těchto optimalizérů, vývojáři mohou systematicky optimalizovat své AI systémy, zajišťující vysokou kvalitu výstupů a dodržují doménově specifická omezení a požadavky.

Zahájení práce s DSPy

Pro ilustraci moci DSPy, procházíme praktickým příkladem budování systému pro zotavení-augmentované generace (RAG) pro zodpovězení otázek.

Krok 1: Nastavení jazykového modelu a modelu pro zotavení

Prvním krokem je konfigurace jazykového modelu (LM) a modelu pro zotavení (RM) v rámci DSPy.

Pro instalaci DSPy spusťte:

pip install dspy-ai

DSPy podporuje několik LM a RM API, stejně jako lokální hosting modelů, což usnadňuje integraci vašich preferovaných modelů.

import dspy

<p># Konfigurace LM a RM
turbo = dspy.OpenAI(model='gpt-3.5-turbo')
colbertv2_wiki17_abstracts = dspy.ColBERTv2(url='http://20.102.90.50:2017/wiki17_abstracts')</p>

<p>dspy.settings.configure(lm=turbo, rm=colbertv2_wiki17_abstracts)</p>

Krok 2: Načtení datové sady

Dalším krokem je načtení datové sady HotPotQA, která obsahuje kolekci komplexních otázek a odpovědí, obvykle zodpovězených v multi-hop fashion.

from dspy.datasets import HotPotQA

<p># Načtení datové sady
dataset = HotPotQA(train_seed=1, train_size=20, eval_seed=2023, dev_size=50, test_size=0)</p>

<p># Specifikace 'question' pole jako vstup
trainset = [x.with_inputs('question') for x in dataset.train]
devset = [x.with_inputs('question') for x in dataset.dev]</p>

Krok 3: Budování signatur

DSPy používá signatury pro definici chování modulů. V tomto příkladu definujeme signaturu pro úlohu generování odpovědí, specifikující vstupní pole (kontext a otázka) a výstupní pole (odpověď).

<p>class GenerateAnswer(dspy.Signature):
"""Odpoví na otázky s krátkými faktoidními odpověďmi."""

context = dspy.InputField(desc="může obsahovat relevantní fakta")
question = dspy.InputField()
answer = dspy.OutputField(desc="často mezi 1 a 5 slovy")

Krok 4: Budování pipeline

Budujeme náš RAG pipeline jako DSPy modul, který se skládá z inicializační metody (__init__) pro deklaraci sub-modulů (dspy.Retrieve a dspy.ChainOfThought) a forward metody (forward) pro popis kontrolního toku zodpovězení otázky pomocí těchto modulů.

<p>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, question):
context = self.retrieve(question).passages
prediction = self.generate_answer(context=context, question=question)
return dspy.Prediction(context=context, answer=prediction.answer)

Krok 5: Optimalizace pipeline

S pipeline definovaným, můžeme nyní optimalizovat jej pomocí optimalizérů DSPy. V tomto příkladu použijeme optimalizér BootstrapFewShot, který generuje a vybírá efektivní prompty pro naše moduly na základě trénovací sady a metriky pro validaci.

<p>from dspy.teleprompt import BootstrapFewShot</p>

<p># Validace metrika
def validate_context_and_answer(example, pred, trace=None):
answer_EM = dspy.evaluate.answer_exact_match(example, pred)
answer_PM = dspy.evaluate.answer_passage_match(example, pred)
return answer_EM and answer_PM

<p># Nastavení optimalizéru
teleprompter = BootstrapFewShot(metric=validate_context_and_answer)

<p># Kompilace programu
compiled_rag = teleprompter.compile(RAG(), trainset=trainset)

Krok 6: Hodnocení pipeline

Po zkompilování programu je důležité vyhodnotit jeho výkon na vývojové sadě, aby se zajistilo, že splňuje požadovanou přesnost a spolehlivost.

from dspy.evaluate import Evaluate

<p># Nastavení vyhodnocovače
evaluate = Evaluate(devset=devset, metric=validate_context_and_answer, num_threads=4, display_progress=True, display_table=0)

<p># Vyhlášení zkompilovaného RAG programu
evaluation_result = evaluate(compiled_rag)

<p>print(f"Výsledek hodnocení: {evaluation_result}")

Krok 7: Inspekce modelové historie

Pro hlubší pochopení interakcí modelu, můžete zkontrolovat nejnovější generace inspekcí modelové historie.

<p># Inspekce modelové historie
turbo.inspect_history(n=1)

Krok 8: Předpověď

S pipeline optimalizovaným a vyhodnoceným, můžete nyní použít jej pro předpověď na nové otázky.

<p># Příklad otázky
question = "Kterou cenu získal první kniha Garyho Zukava?"

<p># Předpověď pomocí zkompilovaného RAG programu
prediction = compiled_rag(question)

<p>print(f"Otázka: {question}")
print(f"Odpověď: {prediction.answer}")
print(f"Získané kontexty: {prediction.context}")

Minimální pracovní příklad s DSPy

Teď, procházíme další minimální pracovní příklad pomocí datové sady GSM8K a modelu OpenAI GPT-3.5-turbo pro simulaci úkolů pro vyvolání v rámci DSPy.

Nastavení

Prvním krokem je zajištění, že vaše prostředí je správně nakonfigurováno:

<p>import dspy
from dspy.datasets.gsm8k import GSM8K, gsm8k_metric</p>

<p># Nastavení LM
turbo = dspy.OpenAI(model='gpt-3.5-turbo-instruct', max_tokens=250)
dspy.settings.configure(lm=turbo)

<p># Načtení matematických otázek z datové sady GSM8K
gsm8k = GSM8K()
gsm8k_trainset, gsm8k_devset = gsm8k.train[:10], gsm8k.dev[:10]

print(gsm8k_trainset)

Datová sada gsm8k_trainset a gsm8k_devset obsahuje seznam příkladů s každým příkladem, který má otázku a odpověď pole.

Definice modulu

Dalším krokem je definice vlastního programu, který využívá modul ChainOfThought pro krok za krokem odůvodnění:

<p>class CoT(dspy.Module):
def __init__(self):
super().__init__()
self.prog = dspy.ChainOfThought("question -&gt; answer")

def forward(self, question):
return self.prog(question=question)

Kompilace a vyhodnocení modelu

Teď zkompilujeme jej s optimalizérem BootstrapFewShot:

<p>from dspy.teleprompt import BootstrapFewShot</p>

<p># Nastavení optimalizéru
config = dict(max_bootstrapped_demos=4, max_labeled_demos=4)

<p># Optimalizace pomocí gsm8k_metric
teleprompter = BootstrapFewShot(metric=gsm8k_metric, **config)
optimized_cot = teleprompter.compile(CoT(), trainset=gsm8k_trainset)

<p># Nastavení vyhodnocovače
from dspy.evaluate import Evaluate
evaluate = Evaluate(devset=gsm8k_devset, metric=gsm8k_metric, num_threads=4, display_progress=True, display_table=0)
evaluate(optimized_cot)

<p># Inspekce modelové historie
turbo.inspect_history(n=1)

Tento příklad demonstruje, jak nastavit vaše prostředí, definovat vlastní modul, zkompilovat model a důkladně vyhodnotit jeho výkon pomocí poskytnuté datové sady a konfigurace optimalizéru.

Správa dat v DSPy

DSPy pracuje s trénovacími, vývojovými a testovacími sadami. Pro každý příklad ve vašich datech, máte obvykle tři typy hodnot: vstupy, mezilehlé štítky a konečné štítky. Zatímco mezilehlé nebo konečné štítky jsou volitelné, mít několik příkladů vstupů je nezbytné.

Vytvoření příkladových objektů

Příkladové objekty v DSPy jsou podobné jako Pythonovské slovníky, ale přicházejí s užitečnými utilitami:

<p>qa_pair = dspy.Example(question="Toto je otázka?", answer="Toto je odpověď.")

<p>print(qa_pair)
print(qa_pair.question)
print(qa_pair.answer)

Výstup:

<p>Příklad({'question': 'Toto je otázka?', 'answer': 'Toto je odpověď.'}) (input_keys=None)
Toto je otázka?
Toto je odpověď.

Specifikace vstupních klíčů

V DSPy, příkladové objekty mají metodu with_inputs() pro označení specifických polí jako vstupy:

<p>print(qa_pair.with_inputs("question"))
print(qa_pair.with_inputs("question", "answer"))

Hodnoty lze přistupovat pomocí tečkového operátoru a metody jako inputs() a labels() vracejí nové příkladové objekty, které obsahují pouze vstupní nebo non-vstupní klíče.

Optimalizéry v DSPy

Optimalizér DSPy ladí parametry programu DSPy (tj. prompty a/nebo LM váhy) pro maximalizaci specifikovaných metrik. DSPy nabízí různé vestavěné optimalizéry, každý z nich využívá různé strategie.

Dostupné optimalizéry

• BootstrapFewShot: Generuje few-shot příklady pomocí poskytnutých označených vstupních a výstupních datových bodů.
• BootstrapFewShotWithRandomSearch: Používá BootstrapFewShot několikrát s náhodným vyhledáváním přes vygenerované demonstrace.
• COPRO: Generuje a rafinuje nové instrukce pro každý krok, optimalizuje je pomocí koordinovaného vzestupu.
• MIPRO: Optimalizuje instrukce a few-shot příklady pomocí Bayesian Optimization.

Výběr optimalizéru

Pokud si nejste jisti, kde začít, použijte BootstrapFewShotWithRandomSearch:

Pro velmi málo dat (10 příkladů), použijte BootstrapFewShot.
Pro trochu více dat (50 příkladů), použijte BootstrapFewShotWithRandomSearch.
Pro větší datové sady (300+ příkladů), použijte MIPRO.

Zde je, jak použít BootstrapFewShotWithRandomSearch:

<p>from dspy.teleprompt import BootstrapFewShotWithRandomSearch</p>

<p>config = dict(max_bootstrapped_demos=4, max_labeled_demos=4, num_candidate_programs=10, num_threads=4)
teleprompter = BootstrapFewShotWithRandomSearch(metric=YOUR_METRIC_HERE, **config)
optimized_program = teleprompter.compile(YOUR_PROGRAM_HERE, trainset=YOUR_TRAINSET_HERE)

Uložení a načtení optimalizovaných programů

Po spuštění programu přes optimalizér, uložte jej pro budoucí použití:

optimized_program.save(YOUR_SAVE_PATH)

Načtěte uložený program:

<p>loaded_program = YOUR_PROGRAM_CLASS()
loaded_program.load(path=YOUR_SAVE_PATH)

Pokročilé funkce: DSPy Assertions

DSPy Assertions automatizují vynucování výpočetních omezení na LMy, zvyšují spolehlivost, předvídatelnost a správnost LM výstupů.

Používání asercí

Definujte validační funkce a deklarujte asercí po generování modelu. Například:

<p>dspy.Suggest(
len(query) &lt;= 100,
&quot;Dotaz by měl být krátký a méně než 100 znaků&quot;,
)

<p>dspy.Suggest(
validate_query_distinction_local(prev_queries, query),
"Dotaz by měl být odlišný od: " + "; ".join(f"{i+1}) {q}" for i, q in enumerate(prev_queries)),
)

Transformace programů s asercemi

<p>from dspy.primitives.assertions import assert_transform_module, backtrack_handler</p>

<p>baleen_with_assertions = assert_transform_module(SimplifiedBaleenAssertions(), backtrack_handler)

<p>Alternativně, aktivujte asercí přímo na programu:</p>

[code language="Python"]

<p>baleen_with_assertions = SimplifiedBaleenAssertions().activate_assertions()

Asercí-řízené optimalizace

DSPy Assertions pracují s optimalizacemi DSPy, zejména s BootstrapFewShotWithRandomSearch, včetně nastavení jako:

• Kompilace s asercemi
• Kompilace + inference s asercemi

Závěr

DSPy nabízí mocný a systematický přístup k optimalizaci jazykových modelů a jejich promptů. Postupem podle kroků uvedených v těchto příkladech, můžete budovat, optimalizovat a vyhodnocovat komplexní AI systémy s lehkostí. Modulární design a pokročilé optimalizéry DSPy umožňují efektivní a efektivní integraci různých jazykových modelů, což z něj činí cenný nástroj pro každého, kdo pracuje v oblasti NLP a AI.

Bez ohledu na to, zda stavíte jednoduchý systém pro zodpovězení otázek nebo složitější pipeline, DSPy poskytuje flexibilitu a robustnost potřebnou pro dosažení vysoké výkonnosti a spolehlivosti.