Prompt engineering
Optimalizujte LLM s DSPy: Krok za krokem průvodce budováním, optimalizací a vyhodnocením systémů AI
Jak se schopnosti velkých jazykových modelů (LLM) dále rozšiřují, stal se vývoj robustních systémů AI, které využívají jejich potenciál, stále složitějším. Konvenční přístupy často zahrnují složité techniky pro vyvolání odpovědí, generování dat pro jemné ladění a manuální vedení, aby se zajistilo dodržování omezení specifických pro doménu. 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 systémů AI poháněných LLM. DSPy představuje systematický přístup k optimalizaci LM podnětů a váh, umožňující vývojářům budovat 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 systémy AI s LLM.
Co je DSPy a proč jej potřebujete?
DSPy je rámec, který odděluje tok vašeho programu (moduly) od parametrů (LM podněty a váhy) každého kroku. Toto oddělení umožňuje systematickou optimalizaci LM podnětů a váh, umožňující vám budovat komplexní systémy AI s větší spolehlivostí, předvídatelností a dodržováním omezení specifických pro doménu.
Tradičně, vývoj systémů AI s LLM zahrnoval namáhavý proces rozdělení problému na kroky, vytváření složitých podnětů 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 potrubí, LM nebo datech mohly vyžadovat rozsáhlou rekonstrukci podnětů a kroků jemného ladění.
DSPy řeší tyto výzvy zavedením nového paradigmatu: optimalizéry. Tyto algoritmy poháněné LM mohou ladit podněty a váhy vašich LM volání, dané metriky, které chcete maximalizovat. Automatizací procesu optimalizace, DSPy umožňuje vývojářům budovat robustní systémy AI s minimálním manuálním zásahem, zlepšující spolehlivost a předvídatelnost výstupů LM.
Modulární architektura DSPy
V srdci DSPy leží modulární architektura, která usnadňuje složení komplexních systémů AI. Rámec poskytuje sadu vestavěných modulů, které abstrahují různé techniky pro vyvolání odpovědí, 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é potrubí přizpůsobené jejich specifickým požadavkům.
Každý modul zahrnuje učitelné parametry, včetně instrukcí, několika 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 výstupy LM 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 systémů AI. Tyto optimalizéry využívají algoritmy poháněné LM pro ladění podnětů a váh vašich LM volání, maximalizující specifikovanou metriku, zatímco dodržují omezení specifická pro doménu.
Některé z klíčových optimalizérů dostupných v DSPy zahrnují:
- BootstrapFewShot: Tento optimalizér rozšiřuje signaturu automatickým generováním a zahrnutím optimalizovaných příkladů do podnětu odeslaného do modelu, implementujícím několik příkladů.
- BootstrapFewShotWithRandomSearch: Používá
BootstrapFewShotněkolikrát s náhodným vyhledáváním vygenerovaných demonstrací, vybírajícím nejlepší program během optimalizace. - MIPRO: Generuje instrukce a několik příkladů v každém kroku, přičemž generování instrukcí je vědomé dat a demonstrací. Používá Bayesian Optimization pro efektivní vyhledávání prostoru generování instrukcí a demonstrací napříč vašimi moduly.
- BootstrapFinetune: Destiluje program založený na podnětu DSPy do aktualizací váh pro menší LM, umožňující vám jemně ladit základní LLM(s) pro zlepšení efektivity.
Používáním těchto optimalizérů mohou vývojáři systematicky optimalizovat své systémy AI, zajišťující vysoké kvality výstupů, zatímco dodržují omezení specifická pro doménu a požadavky.
Zahájení práce s DSPy
Abychom demonstrovali sílu DSPy, probereme praktický příklad budování systému pro generování na základě vyhledávání (RAG) pro otázka-odpověď.
Krok 1: Nastavení jazykového modelu a vyhledávacího modelu
Prvním krokem je konfigurace jazykového modelu (LM) a vyhledávacího modelu (RM) v rámci DSPy.
Chcete-li nainstalovat DSPy, spusťte:
pip install dspy-ai
DSPy podporuje několik LM a RM API, stejně jako místní hosting modelů, což usnadňuje integraci vašich preferovaných modelů.
import dspy # 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') dspy.settings.configure(lm=turbo, rm=colbertv2_wiki17_abstracts)
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
# Načtení datové sady
dataset = HotPotQA(train_seed=1, train_size=20, eval_seed=2023, dev_size=50, test_size=0)
# Specifikujte 'question' pole jako vstup
trainset = [x.with_inputs('question') for x in dataset.train]
devset = [x.with_inputs('question') for x in dataset.dev]
Krok 3: Budování signatur
DSPy používá signatury pro definici chování modulů. V tomto příkladu definujeme signaturu pro úloha generování odpovědí, specifikující vstupní pole (kontext a otázka) a výstupní pole (odpověď).
class GenerateAnswer(dspy.Signature): """Odpovídejte 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í potrubí
Budujeme naše RAG potrubí 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 toku řízení při zodpovídání otázky pomocí těchto modulů.
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 potrubí
S definovaným potrubím můžeme nyní optimalizovat pomocí optimalizérů DSPy. V tomto příkladu použijeme optimalizér BootstrapFewShot, který generuje a vybírá efektivní podněty pro naše moduly na základě trénovací sady a metriky pro validaci.
from dspy.teleprompt import BootstrapFewShot # Metrika validace 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 # Nastavení optimalizéru teleprompter = BootstrapFewShot(metric=validate_context_and_answer) # Kompilace programu compiled_rag = teleprompter.compile(RAG(), trainset=trainset)
Krok 6: Vyhodnocení potrubí
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
# Nastavení vyhodnocovače
evaluate = Evaluate(devset=devset, metric=validate_context_and_answer, num_threads=4, display_progress=True, display_table=0)
# Vyhodnocení zkompilovaného RAG programu
evaluation_result = evaluate(compiled_rag)
print(f"Vyhodnocení výsledku: {evaluation_result}")
Krok 7: Prohlížení historie modelu
Pro hlubší pochopení interakcí modelu můžete prohlédnout nejnovější generace prohlédnutím historie modelu.
# Prohlížení historie modelu turbo.inspect_history(n=1)
Krok 8: Předpovídání
S optimalizovaným a vyhodnoceným potrubím můžete nyní použít jej pro předpovídání na nových otázkách.
# Příklad otázky
question = "Kterou cenu získala první kniha Garyho Zukava?"
# Předpovídání pomocí zkompilovaného RAG programu
prediction = compiled_rag(question)
print(f"Otázka: {question}")
print(f"Odpověď: {prediction.answer}")
print(f"Načtené kontexty: {prediction.context}")
Minimální pracovní příklad s DSPy
Nyní probereme další minimální pracovní příklad pomocí datové sady GSM8K a modelu OpenAI GPT-3.5-turbo pro simulaci úkolů pro vyvolání odpovědí v rámci DSPy.
Nastavení
Nejdříve zajistěte, že vaše prostředí je správně nakonfigurováno:
import dspy from dspy.datasets.gsm8k import GSM8K, gsm8k_metric # Nastavení LM turbo = dspy.OpenAI(model='gpt-3.5-turbo-instruct', max_tokens=250) dspy.settings.configure(lm=turbo) # 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é sady gsm8k_trainset a gsm8k_devset obsahují seznam příkladů s každým příkladem, který má otázku a odpověď.
Definice modulu
Dalším krokem je definice vlastního programu pomocí modulu ChainOfThought pro krok za krokem uvažování:
class CoT(dspy.Module):
def __init__(self):
super().__init__()
self.prog = dspy.ChainOfThought("question -> answer")
def forward(self, question):
return self.prog(question=question)
Kompilace a vyhodnocení modelu
Nyní zkompilujeme jej pomocí teleprompteru BootstrapFewShot:
from dspy.teleprompt import BootstrapFewShot # Nastavení optimalizéru config = dict(max_bootstrapped_demos=4, max_labeled_demos=4) # Optimalizace pomocí gsm8k_metric teleprompter = BootstrapFewShot(metric=gsm8k_metric, **config) optimized_cot = teleprompter.compile(CoT(), trainset=gsm8k_trainset) # 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) # Prohlížení historie modelu 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 teleprompteru.
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í objektů příkladů
Objekty příkladů v DSPy jsou podobné jako Pythonovské slovníky, ale přicházejí s užitečnými nástroji:
qa_pair = dspy.Example(question="Toto je otázka?", answer="Toto je odpověď.") print(qa_pair) print(qa_pair.question) print(qa_pair.answer)
Výstup:
Example({'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 mají objekty příkladů metodu with_inputs() pro označení specifických polí jako vstupů:
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é objekty příkladů obsahující pouze vstupní nebo non-vstupní klíče.
Optimalizéry v DSPy
Optimalizér DSPy ladí parametry programu DSPy (tj. podněty a/nebo LM váhy) pro maximalizaci specifikovaných metrik. DSPy nabízí různé vestavěné optimalizéry, z nichž každý využívá různé strategie.
Dostupné optimalizéry
- BootstrapFewShot: Generuje několik příkladů pomocí poskytnutých označených vstupních a výstupních datových bodů.
- BootstrapFewShotWithRandomSearch: Používá
BootstrapFewShotněkolikrát s náhodným vyhledáváním vygenerovaných demonstrací. - COPRO: Generuje a rafinuje nové instrukce pro každý krok, optimalizuje je pomocí koordinovaného vzestupu.
- MIPRO: Optimalizuje instrukce a několik příkladů 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 slightly 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:
from dspy.teleprompt import BootstrapFewShotWithRandomSearch config = dict(max_bootstrapped_demos=4, max_labeled_demos=4, num_candidate_programs=10, num_threads=4) teleprompter = BootstrapFewShotWithRandomSearch(metric=VAŠE_METRIKA_ZDE, **config) optimized_program = teleprompter.compile(VAŠE_PROGRAM_ZDE, trainset=VAŠE_TRÉNOVACÍ_SADA_ZDE)
Uložení a načtení optimalizovaných programů
Po spuštění programu prostřednictvím optimalizéru uložte jej pro budoucí použití:
optimized_program.save(VAŠE_ULOŽENÍ_CESTA)
Načtěte uložený program:
loaded_program = VAŠE_TŘÍDA_PROGRAMU() loaded_program.load(path=VAŠE_ULOŽENÍ_CESTA)
Pokročilé funkce: Asertace DSPy
Asertace DSPy automatizují vynucování výpočetních omezení na LM, zlepšují spolehlivost, předvídatelnost a správnost výstupů LM.
Používání asertací
Definujte validační funkce a deklarujte asertace po generování modelu. Například:
dspy.Suggest(
len(query) <= 100,
"Dotaz by měl být krátký a méně než 100 znaků",
)
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 asertacemi
from dspy.primitives.assertions import assert_transform_module, backtrack_handler baleen_with_assertions = assert_transform_module(SimplifiedBaleenAssertions(), backtrack_handler)
Alternativně aktivujte asertace přímo na programu:
baleen_with_assertions = SimplifiedBaleenAssertions().activate_assertions()
Asertace-poháněné optimalizace
Asertace DSPy pracují s optimalizacemi DSPy, zejména s BootstrapFewShotWithRandomSearch, včetně nastavení jako:
- Kompilace s asertacemi
- Kompilace + inferencing s asertacemi
Závěr
DSPy nabízí mocný a systematický přístup k optimalizaci jazykových modelů a jejich podnětů. Sledováním kroků popsáných v těchto příkladech můžete budovat, optimalizovat a vyhodnocovat komplexní systémy AI 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 budujete jednoduchý systém pro otázka-odpověď nebo komplexnější potrubí, DSPy poskytuje flexibilitu a robustnost potřebnou pro dosažení vysoké výkonnosti a spolehlivosti.
