Keďže možnosti veľkých jazykových modelov (LLM) sa neustále rozširujú, vývoj robustných systémov AI, ktoré využívajú ich potenciál, je čoraz zložitejší. Konvenčné prístupy často zahŕňajú zložité techniky nabádania, generovanie údajov na jemné ladenie a manuálne vedenie na zabezpečenie dodržiavania obmedzení špecifických pre doménu. Tento proces však môže byť zdĺhavý, náchylný na chyby a vo veľkej miere závisí od ľudského zásahu.
Zadajte DSPy, revolučný rámec navrhnutý na zefektívnenie vývoja systémov AI poháňaných LLM. DSPy predstavuje systematický prístup k optimalizácii výziev a váh LM, čo umožňuje vývojárom vytvárať sofistikované aplikácie s minimálnym manuálnym úsilím.
V tejto komplexnej príručke preskúmame základné princípy DSPy, jeho modulárnu architektúru a množstvo výkonných funkcií, ktoré ponúka. Ponoríme sa aj do praktických príkladov, ktoré ukážu, ako môže DSPy zmeniť spôsob, akým vyvíjate systémy AI pomocou LLM.
Čo je DSPy a prečo ho potrebujete?
DSPy je rámec, ktorý oddeľuje tok vášho programu (modules) z parametrov (výzvy LM a váhy) každého kroku. Toto oddelenie umožňuje systematickú optimalizáciu výziev a váh LM, čo vám umožňuje vytvárať komplexné systémy AI s vyššou spoľahlivosťou, predvídateľnosťou a dodržiavaním obmedzení špecifických pre doménu.
Tradične vývoj systémov AI s LLM zahŕňal namáhavý proces rozdelenia problému na kroky, vytváranie zložitých výziev pre každý krok, generovanie syntetických príkladov na jemné ladenie a manuálne vedenie LM, aby dodržiavali špecifické obmedzenia. Tento prístup bol nielen časovo náročný, ale aj náchylný na chyby, pretože aj malé zmeny v potrubí, LM alebo údajoch si mohli vyžiadať rozsiahle prepracovanie výziev a dolaďovacích krokov.
DSPy rieši tieto výzvy zavedením novej paradigmy: optimalizátorov. Tieto algoritmy riadené LM dokážu vyladiť výzvy a váhy vašich hovorov LM podľa metriky, ktorú chcete maximalizovať. Automatizáciou procesu optimalizácie umožňuje DSPy vývojárom vytvárať robustné systémy AI s minimálnym manuálnym zásahom, čím sa zvyšuje spoľahlivosť a predvídateľnosť výstupov LM.
Modulárna architektúra DSPy
V srdci DSPy leží modulárna architektúra, ktorá uľahčuje zostavovanie komplexných systémov AI. Framework poskytuje sadu vstavaných modulov, ktoré abstrahujú rôzne techniky vyvolávania, ako napr dspy.ChainOfThought a dspy.ReAct. Tieto moduly je možné kombinovať a skladať do väčších programov, čo umožňuje vývojárom vytvárať zložité potrubia prispôsobené ich špecifickým požiadavkám.
Každý modul zapuzdruje naučiteľné parametre vrátane inštrukcií, príkladov niekoľkých záberov a závaží LM. Keď je modul vyvolaný, optimalizátori DSPy môžu jemne doladiť tieto parametre, aby maximalizovali požadovanú metriku a zabezpečili, že výstupy LM budú spĺňať špecifikované obmedzenia a požiadavky.
Optimalizácia pomocou DSPy
DSPy predstavuje rad výkonných optimalizátorov navrhnutých na zvýšenie výkonu a spoľahlivosti vašich systémov AI. Tieto optimalizátory využívajú algoritmy riadené LM na ladenie výziev a váh vašich hovorov LM, maximalizujúc špecifikovanú metriku pri dodržaní obmedzení špecifických pre doménu.
Niektoré z kľúčových optimalizátorov dostupných v DSPy zahŕňajú:
- BootstrapFewShot: Tento optimalizátor rozširuje podpis automatickým generovaním a zahrnutím optimalizovaných príkladov do výzvy odoslanej do modelu, pričom implementuje niekoľkonásobné učenie.
- BootstrapFewShotWithRandomSearch: Platí
BootstrapFewShotniekoľkokrát s náhodným prehľadávaním generovaných ukážok, výberom najlepšieho programu pred optimalizáciou. - MIPRO: Generuje inštrukcie a niekoľkonásobné príklady v každom kroku, pričom generovanie inštrukcií je založené na údajoch a demonštrácii. Využíva Bayesovskú optimalizáciu na efektívne vyhľadávanie v priestore generovania pokynov a ukážok vo vašich moduloch.
- BootstrapFinetune: Destiluje rýchly program DSPy do aktualizácií hmotnosti pre menšie LM, čo vám umožňuje jemne doladiť základné LLM pre vyššiu efektivitu.
Využitím týchto optimalizátorov môžu vývojári systematicky optimalizovať svoje systémy AI, čím zabezpečia vysokokvalitné výstupy a zároveň budú dodržiavať obmedzenia a požiadavky špecifické pre danú doménu.
Začíname s DSPy
Aby sme ilustrovali silu DSPy, prejdime si praktický príklad vytvorenia systému RAG (retrieval-augmented generation) na zodpovedanie otázok.
Krok 1: Nastavenie jazykového modelu a modelu vyhľadávania
Prvý krok zahŕňa konfiguráciu jazykového modelu (LM) a modelu vyhľadávania (RM) v rámci DSPy.
Ak chcete nainštalovať DSPy, spustite:
pip install dspy-ai
DSPy podporuje viacero rozhraní LM a RM API, ako aj hosťovanie miestnych modelov, čo uľahčuje integráciu preferovaných modelov.
import dspy # Configure the LM and 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čítanie množiny údajov
Ďalej načítame súbor údajov HotPotQA, ktorý obsahuje zbierku komplexných párov otázok a odpovedí, ktoré sa zvyčajne odpovedajú viacskokovým spôsobom.
from dspy.datasets import HotPotQA
# Load the dataset
dataset = HotPotQA(train_seed=1, train_size=20, eval_seed=2023, dev_size=50, test_size=0)
# Specify the 'question' field as the input
trainset = (x.with_inputs('question') for x in dataset.train)
devset = (x.with_inputs('question') for x in dataset.dev)
Krok 3: Vytváranie podpisov
DSPy používa podpisy na definovanie správania modulov. V tomto príklade zadefinujeme podpis pre úlohu generovania odpovede, pričom uvedieme vstupné polia (kontext a otázka) a výstupné pole (odpoveď).
class GenerateAnswer(dspy.Signature): """Answer questions with short factoid answers.""" context = dspy.InputField(desc="may contain relevant facts") question = dspy.InputField() answer = dspy.OutputField(desc="often between 1 and 5 words")
Krok 4: Budovanie potrubia
Vybudujeme náš kanál RAG ako modul DSPy, ktorý pozostáva z inicializačnej metódy (__init__) na deklarovanie podmodulov (dspy.Retrieve a dspy.ChainOfThought) a doprednej metódy (forward) na opísanie riadiaceho toku odpovedí. pomocou týchto modulov.
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: Optimalizácia potrubia
S definovaným potrubím ho teraz môžeme optimalizovať pomocou optimalizátorov DSPy. V tomto príklade použijeme optimalizátor BootstrapFewShot, ktorý generuje a vyberá efektívne výzvy pre naše moduly na základe sady školení a metriky na overenie.
from dspy.teleprompt import BootstrapFewShot # Validation metric 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 # Set up the optimizer teleprompter = BootstrapFewShot(metric=validate_context_and_answer) # Compile the program compiled_rag = teleprompter.compile(RAG(), trainset=trainset)
Krok 6: Vyhodnotenie potrubia
Po skompilovaní programu je nevyhnutné vyhodnotiť jeho výkon na vývojovej súprave, aby sa zabezpečilo, že spĺňa požadovanú presnosť a spoľahlivosť.
from dspy.evaluate import Evaluate
# Set up the evaluator
evaluate = Evaluate(devset=devset, metric=validate_context_and_answer, num_threads=4, display_progress=True, display_table=0)
# Evaluate the compiled RAG program
evaluation_result = evaluate(compiled_rag)
print(f"Evaluation Result: {evaluation_result}")
Krok 7: Kontrola histórie modelu
Pre hlbšie pochopenie interakcií modelu si môžete prezrieť najnovšie generácie tak, že si pozriete históriu modelu.
# Inspect the model's history turbo.inspect_history(n=1)
Krok 8: Vytváranie predpovedí
Vďaka optimalizovanému a vyhodnotenému kanálu ho teraz môžete použiť na predpovedanie nových otázok.
# Example question
question = "Which award did Gary Zukav's first book receive?"
# Make a prediction using the compiled RAG program
prediction = compiled_rag(question)
print(f"Question: {question}")
print(f"Answer: {prediction.answer}")
print(f"Retrieved Contexts: {prediction.context}")
Minimálny pracovný príklad s DSPy
Teraz si prejdime ďalší minimálny pracovný príklad s použitím Dátový súbor GSM8K a model OpenAI GPT-3.5-turbo na simuláciu úloh výzvy v rámci DSPy.
Nastaviť
Najprv sa uistite, že je vaše prostredie správne nakonfigurované:
import dspy from dspy.datasets.gsm8k import GSM8K, gsm8k_metric # Set up the LM turbo = dspy.OpenAI(model='gpt-3.5-turbo-instruct', max_tokens=250) dspy.settings.configure(lm=turbo) # Load math questions from the GSM8K dataset gsm8k = GSM8K() gsm8k_trainset, gsm8k_devset = gsm8k.train(:10), gsm8k.dev(:10) print(gsm8k_trainset)
The gsm8k_trainset a gsm8k_devset množiny údajov obsahujú zoznam príkladov, pričom každý príklad má pole otázky a odpovede.
Definujte modul
Ďalej definujte vlastný program využívajúci modul ChainOfThought na uvažovanie krok za krokom:
class CoT(dspy.Module):
def __init__(self):
super().__init__()
self.prog = dspy.ChainOfThought("question -> answer")
def forward(self, question):
return self.prog(question=question)
Zostavte a vyhodnoťte model
Teraz ho skompilujte s BootstrapFewShot teleprompter:
from dspy.teleprompt import BootstrapFewShot # Set up the optimizer config = dict(max_bootstrapped_demos=4, max_labeled_demos=4) # Optimize using the gsm8k_metric teleprompter = BootstrapFewShot(metric=gsm8k_metric, **config) optimized_cot = teleprompter.compile(CoT(), trainset=gsm8k_trainset) # Set up the evaluator 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) # Inspect the model's history turbo.inspect_history(n=1)
Tento príklad ukazuje, ako nastaviť svoje prostredie, definovať vlastný modul, zostaviť model a dôsledne vyhodnotiť jeho výkon pomocou poskytnutej množiny údajov a konfigurácií teleprompter.
Správa údajov v DSPy
DSPy pracuje s tréningovými, vývojovými a testovacími sadami. Pre každý príklad v údajoch máte zvyčajne tri typy hodnôt: vstupy, prechodné označenia a konečné označenia. Zatiaľ čo prechodné alebo konečné štítky sú voliteľné, je nevyhnutné mať niekoľko príkladov vstupov.
Vytváranie vzorových objektov
Príklady objektov v DSPy sú podobné slovníkom Pythonu, ale prichádzajú s užitočnými pomôckami:
qa_pair = dspy.Example(question="This is a question?", answer="This is an answer.") print(qa_pair) print(qa_pair.question) print(qa_pair.answer)
Výkon:
Example({'question': 'This is a question?', 'answer': 'This is an answer.'}) (input_keys=None)
This is a question?
This is an answer.
Určenie vstupných kľúčov
V DSPy majú Vzorové objekty metódu with_inputs() na označenie konkrétnych polí ako vstupov:
print(qa_pair.with_inputs("question"))
print(qa_pair.with_inputs("question", "answer"))
K hodnotám je možné pristupovať pomocou bodkového operátora a metódy ako inputs() a labels() vracajú nové vzorové objekty obsahujúce iba vstupné alebo nevstupné kľúče.
Optimalizátory v DSPy
Optimalizátor DSPy vylaďuje parametre programu DSPy (tj výzvy a/alebo váhy LM), aby maximalizoval špecifikované metriky. DSPy ponúka rôzne vstavané optimalizátory, z ktorých každý využíva iné stratégie.
Dostupné optimalizátory
- BootstrapFewShot: Generuje niekoľko záberov pomocou poskytnutých označených vstupných a výstupných dátových bodov.
- BootstrapFewShotWithRandomSearch: Aplikuje BootstrapFewShot viackrát s náhodným vyhľadávaním vo vygenerovaných ukážkach.
- I COPRO: Generuje a vylepšuje nové pokyny pre každý krok a optimalizuje ich pomocou súradnicového stúpania.
- MIPRO: Optimalizuje pokyny a niekoľkonásobné príklady pomocou Bayesiánskej optimalizácie.
Výber optimalizátora
Ak si nie ste istí, kde začať, použite BootstrapFewShotWithRandomSearch:
Pre veľmi málo údajov (10 príkladov) použite BootstrapFewShot.
Pre trochu viac údajov (50 príkladov) použite BootstrapFewShotWithRandomSearch.
Pre väčšie množiny údajov (viac ako 300 príkladov) použite MIPRO.
Tu je návod, ako používať 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=YOUR_METRIC_HERE, **config) optimized_program = teleprompter.compile(YOUR_PROGRAM_HERE, trainset=YOUR_TRAINSET_HERE)
Ukladanie a načítanie optimalizovaných programov
Po spustení programu cez optimalizátor ho uložte pre budúce použitie:
optimalizovaný_program.uložiť(VAŠA_CESTA_ULOŽENIA)
Načítať uložený program:
loaded_program = YOUR_PROGRAM_CLASS() loaded_program.load(path=YOUR_SAVE_PATH)
Pokročilé funkcie: Tvrdenia DSPy
Tvrdenia DSPy automatizujú presadzovanie výpočtových obmedzení na LM, čím zvyšujú spoľahlivosť, predvídateľnosť a správnosť výstupov LM.
Používanie tvrdení
Definujte overovacie funkcie a deklarujte tvrdenia po vygenerovaní príslušného modelu. Napríklad:
dspy.Suggest(
len(query) <= 100,
"Query should be short and less than 100 characters",
)
dspy.Suggest(
validate_query_distinction_local(prev_queries, query),
"Query should be distinct from: " + "; ".join(f"{i+1}) {q}" for i, q in enumerate(prev_queries)),
)
Transformácia programov s tvrdeniami
from dspy.primitives.assertions import assert_transform_module, backtrack_handler baleen_with_assertions = assert_transform_module(SimplifiedBaleenAssertions(), backtrack_handler)
Prípadne aktivujte asercie priamo v programe:
baleen_with_assertions = SimplifiedBaleenAssertions().activate_assertions()
Optimalizácie založené na tvrdeniach
Tvrdenia DSPy pracujú s optimalizáciami DSPy, najmä s BootstrapFewShotWithRandomSearch, vrátane nastavení ako:
- Kompilácia s tvrdeniami
- Kompilácia + inferencia s tvrdeniami
Záver
DSPy ponúka výkonný a systematický prístup k optimalizácii jazykových modelov a ich výziev. Podľa krokov uvedených v týchto príkladoch môžete jednoducho zostavovať, optimalizovať a vyhodnocovať zložité systémy AI. Modulárny dizajn a pokročilé optimalizátory DSPy umožňujú efektívnu a efektívnu integráciu rôznych jazykových modelov, vďaka čomu je cenným nástrojom pre každého, kto pracuje v oblasti NLP a AI.
Či už vytvárate jednoduchý systém odpovedania na otázky alebo zložitejší kanál, DSPy poskytuje flexibilitu a robustnosť potrebnú na dosiahnutie vysokého výkonu a spoľahlivosti.
