Greita inžinerija
Optimizuokite LLM naudodami DSPy : nuoseklus AI sistemų kūrimo, optimizavimo ir įvertinimo vadovas
Kadangi didelių kalbų modelių (LLM) galimybės ir toliau plečiasi, kurti tvirtas AI sistemas, kurios išnaudoja jų potencialą, tampa vis sudėtingiau. Įprasti metodai dažnai apima sudėtingus raginimo būdus, duomenų generavimą koregavimui ir rankinį nurodymą, kad būtų laikomasi konkrečios srities apribojimų. Tačiau šis procesas gali būti varginantis, galintis sukelti klaidų ir labai priklausyti nuo žmogaus įsikišimo.
įeiti DSPy, revoliucinė sistema, skirta supaprastinti AI sistemų, kurias maitina LLM, kūrimą. DSPy pristato sistemingą LM raginimų ir svarmenų optimizavimo metodą, leidžiantį kūrėjams kurti sudėtingas programas su minimaliomis rankinėmis pastangomis.
Šiame išsamiame vadove išnagrinėsime pagrindinius DSPy principus, jo modulinę architektūrą ir daugybę galingų funkcijų. Taip pat pasinersime į praktinius pavyzdžius, parodydami, kaip DSPy gali pakeisti AI sistemų kūrimo būdą su LLM.
Kas yra DSPy ir kodėl jums to reikia?
DSPy yra sistema, kuri atskiria jūsų programos srautą (modules) iš kiekvieno žingsnio parametrų (LM raginimų ir svarmenų). Šis atskyrimas leidžia sistemingai optimizuoti LM raginimus ir svorius, leidžiančius kurti sudėtingesnes AI sistemas, pasižyminčias didesniu patikimumu, nuspėjamumu ir konkrečių domeno apribojimų laikymusi.
Tradiciškai kuriant dirbtinio intelekto sistemas su LLM, buvo sunku suskaidyti problemą į žingsnius, kiekvienam žingsniui sukurti sudėtingus raginimus, generuoti sintetinius pavyzdžius, skirtus tiksliam derinimui, ir rankiniu būdu nukreipti LM laikytis konkrečių apribojimų. Šis metodas ne tik užtruko daug laiko, bet ir buvo linkęs į klaidas, nes net ir nedideliems konvejerio, LM ar duomenų pakeitimams gali prireikti iš esmės pertvarkyti raginimus ir koreguoti veiksmus.
DSPy sprendžia šiuos iššūkius pristatydama naują paradigmą: optimizatoriai. Šie LM pagrįsti algoritmai gali sureguliuoti jūsų LM skambučių raginimus ir svorį, atsižvelgiant į metriką, kurią norite maksimaliai padidinti. Automatizuodamas optimizavimo procesą, DSPy įgalina kūrėjus sukurti patikimas AI sistemas su minimaliu rankiniu įsikišimu, padidindamas LM išėjimų patikimumą ir nuspėjamumą.
DSPy modulinė architektūra
DSPy esmė yra modulinė architektūra, palengvinanti sudėtingų AI sistemų sudėtį. Sistema suteikia integruotų modulių rinkinį, kuris abstrahuoja įvairius raginimo būdus, pvz dspy.ChainOfThought ir dspy.ReAct. Šiuos modulius galima sujungti ir sudaryti į didesnes programas, todėl kūrėjai gali sukurti sudėtingus vamzdynus, pritaikytus jų specifiniams reikalavimams.
Kiekvienas modulis apima išmokstamus parametrus, įskaitant instrukcijas, kelių kadrų pavyzdžius ir LM svarmenis. Kai iškviečiamas modulis, DSPy optimizatoriai gali tiksliai sureguliuoti šiuos parametrus, kad maksimaliai padidintų norimą metriką, užtikrinant, kad LM išėjimai atitiktų nurodytus apribojimus ir reikalavimus.
Optimizavimas naudojant DSPy
DSPy pristato daugybę galingų optimizatorių, skirtų pagerinti jūsų AI sistemų našumą ir patikimumą. Šie optimizatoriai naudoja LM pagrįstus algoritmus, kad sureguliuotų jūsų LM skambučių raginimus ir svorį, maksimaliai padidindami nurodytą metriką, laikydamiesi konkrečiam domenui taikomų apribojimų.
Kai kurie pagrindiniai DSPy optimizatoriai yra šie:
- BootstrapFewShot: Šis optimizavimo įrankis išplečia parašą automatiškai generuodamas ir įtraukdamas optimizuotus pavyzdžius į modeliui siunčiamą raginimą, įgyvendindamas kelių kadrų mokymąsi.
- BootstrapFewShotWithRandomSearch: Taikoma
BootstrapFewShotkelis kartus su atsitiktine paieška per sugeneruotas demonstracijas, pasirenkant geriausią programą per optimizavimą. - MIPRO: kiekviename žingsnyje generuoja instrukcijas ir kelių kadrų pavyzdžius, o instrukcijos generuoja duomenis ir demonstruoja. Jis naudoja Bajeso optimizavimą, kad efektyviai ieškotų generavimo instrukcijų ir demonstracijų tarp jūsų modulių.
- BootstrapFinetune: Distiliuoja skubiai pagrįstą DSPy programą į mažesnių LM svorio atnaujinimus, leidžiančius tiksliai sureguliuoti pagrindinį (-ius) LLM, kad būtų padidintas efektyvumas.
Naudodami šiuos optimizavimo įrankius, kūrėjai gali sistemingai optimizuoti savo AI sistemas, užtikrindami aukštos kokybės rezultatus, laikydamiesi konkrečiam domenui taikomų apribojimų ir reikalavimų.
Darbo su DSPy pradžia
Norėdami iliustruoti DSPy galią, pažvelkime į praktinį pavyzdį, kaip sukurti atsakymų į klausimus sistemos (RAG) sukūrimą.
1 veiksmas: Kalbos modelio ir paieškos modelio nustatymas
Pirmasis žingsnis apima kalbos modelio (LM) ir paieškos modelio (RM) konfigūravimą DSPy.
Norėdami įdiegti DSPy paleiskite:
pip install dspy-ai
DSPy palaiko kelias LM ir RM API, taip pat vietinį modelių prieglobą, todėl lengva integruoti pageidaujamus modelius.
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)
2 veiksmas: įkelkite duomenų rinkinį
Tada įkelsime „HotPotQA“ duomenų rinkinį, kuriame yra sudėtingų klausimų ir atsakymų porų, į kurias paprastai atsakoma kelių šuolių būdu, rinkinys.
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]
3 veiksmas: parašų kūrimas
DSPy naudoja parašus modulių veikimui apibrėžti. Šiame pavyzdyje apibrėžsime atsakymo generavimo užduoties parašą, nurodydami įvesties laukus (kontekstą ir klausimą) ir išvesties lauką (atsakymą).
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")
4 žingsnis: vamzdyno tiesimas
Mes sukursime savo RAG dujotiekį kaip DSPy modulį, kurį sudaro inicijavimo metodas (__init__) submoduliams deklaruoti (dspy.Retrieve ir dspy.ChainOfThought) ir pirmyn metodas (persiųsti), skirtas aprašyti atsakymo valdymo srautą. Klausimas naudojant šiuos modulius.
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)
5 veiksmas: vamzdyno optimizavimas
Apibrėžę dujotiekį, dabar galime jį optimizuoti naudodami DSPy optimizatorius. Šiame pavyzdyje naudosime „BootstrapFewShot“ optimizavimo priemonę, kuri generuoja ir atrenka efektyvius raginimus mūsų moduliams pagal mokymo rinkinį ir patvirtinimo metriką.
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)
6 veiksmas: vamzdyno įvertinimas
Sukūrus programą, būtina įvertinti jos veikimą kūrimo rinkinyje, siekiant užtikrinti, kad ji atitiktų pageidaujamą tikslumą ir patikimumą.
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}")
7 veiksmas: modelio istorijos patikrinimas
Norėdami geriau suprasti modelio sąveiką, galite peržiūrėti naujausias kartas, peržiūrėję modelio istoriją.
# Inspect the model's history turbo.inspect_history(n=1)
8 veiksmas: numatykite
Optimizavus ir įvertinus dujotiekį, dabar galite jį naudoti norėdami numatyti naujų klausimų.
# 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}")
Minimalus darbo pavyzdys su DSPy
Dabar pažiūrėkime per kitą minimalų darbo pavyzdį naudojant GSM8K duomenų rinkinys ir OpenAI GPT-3.5-turbo modelis, skirtas imituoti raginimo užduotis DSPy.
Sąrankos
Pirmiausia įsitikinkite, kad jūsų aplinka yra tinkamai sukonfigūruota:
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)
Šios gsm8k_trainset ir gsm8k_devset duomenų rinkiniuose yra pavyzdžių sąrašas, kiekviename pavyzdyje yra klausimų ir atsakymų laukai.
Apibrėžkite modulį
Tada apibrėžkite pasirinktinę programą naudodami ChainOfThought modulį, kad galėtumėte nuosekliai samprotauti:
class CoT(dspy.Module):
def __init__(self):
super().__init__()
self.prog = dspy.ChainOfThought("question -> answer")
def forward(self, question):
return self.prog(question=question)
Sudarykite ir įvertinkite modelį
Dabar sukompiliuokite jį su BootstrapFewShot teleprompteris:
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)
Šiame pavyzdyje parodyta, kaip nustatyti aplinką, apibrėžti pasirinktinį modulį, sudaryti modelį ir tiksliai įvertinti jo našumą naudojant pateiktą duomenų rinkinį ir teleprompterio konfigūracijas.
Duomenų valdymas DSPy
DSPy veikia su mokymo, kūrimo ir bandymų rinkiniais. Kiekvienam duomenų pavyzdžiui paprastai turite trijų tipų vertes: įvestis, tarpines ir galutines etiketes. Nors tarpinės arba galutinės etiketės yra neprivalomos, būtina turėti keletą įvesties pavyzdžių.
Pavyzdinių objektų kūrimas
DSPy objektų pavyzdžiai yra panašūs į Python žodynus, tačiau juose yra naudingų paslaugų:
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)
Rezultatas:
Example({'question': 'This is a question?', 'answer': 'This is an answer.'}) (input_keys=None)
This is a question?
This is an answer.
Nurodykite įvesties klavišus
DSPy pavyzdiniai objektai turi with_inputs() metodą, skirtą pažymėti konkrečius laukus kaip įvestis:
print(qa_pair.with_inputs("question"))
print(qa_pair.with_inputs("question", "answer"))
Vertes galima pasiekti naudojant taško operatorių, o tokie metodai kaip inputs() ir labels() pateikia naujus pavyzdinius objektus, kuriuose atitinkamai yra tik įvesties arba ne įvesties raktai.
Optimizatoriai DSPy
DSPy optimizatorius derina DSPy programos parametrus (ty raginimus ir (arba) LM svarmenis), kad maksimaliai padidintų nurodytą metriką. DSPy siūlo įvairius integruotus optimizatorius, kurių kiekvienas naudoja skirtingas strategijas.
Galimos optimizavimo priemonės
- BootstrapFewShot: generuoja kelių kadrų pavyzdžius naudojant pateiktus pažymėtus įvesties ir išvesties duomenų taškus.
- BootstrapFewShotWithRandomSearch: Taiko BootstrapFewShot kelis kartus su atsitiktine paieška per sugeneruotas demonstracijas.
- COPRO: generuoja ir tobulina naujas kiekvieno žingsnio instrukcijas, optimizuodama jas koordinatės kilimu.
- MIPRO: optimizuoja instrukcijas ir kelių kadrų pavyzdžius naudojant Bajeso optimizavimą.
Optimizavimo priemonės pasirinkimas
Jei nesate tikri, nuo ko pradėti, naudokite BootstrapFewShotWithRandomSearch:
Jei norite gauti labai mažai duomenų (10 pavyzdžių), naudokite BootstrapFewShot.
Norėdami gauti šiek tiek daugiau duomenų (50 pavyzdžių), naudokite BootstrapFewShotWithRandomSearch.
Didesniems duomenų rinkiniams (300 ir daugiau pavyzdžių) naudokite MIPRO.
Štai kaip naudoti 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)
Optimizuotų programų išsaugojimas ir įkėlimas
Paleidę programą per optimizavimo priemonę, išsaugokite ją būsimam naudojimui:
optimizuota_programa.save(YOUR_SAVE_PATH)
Įkelti išsaugotą programą:
loaded_program = YOUR_PROGRAM_CLASS() loaded_program.load(path=YOUR_SAVE_PATH)
Išplėstinės funkcijos: DSPy teiginiai
DSPy teiginiai automatizuoja LM skaičiavimo apribojimų vykdymą, padidindami LM išvesties patikimumą, nuspėjamumą ir teisingumą.
Naudojant teiginius
Apibrėžkite patvirtinimo funkcijas ir deklaruokite tvirtinimus po atitinkamo modelio generavimo. Pavyzdžiui:
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)),
)
Programų transformavimas su teiginiais
from dspy.primitives.assertions import assert_transform_module, backtrack_handler baleen_with_assertions = assert_transform_module(SimplifiedBaleenAssertions(), backtrack_handler)
Arba suaktyvinkite tvirtinimus tiesiogiai programoje:
baleen_with_assertions = SimplifiedBaleenAssertions().activate_assertions()
Teiginiais pagrįsti optimizavimai
DSPy tvirtinimai veikia su DSPy optimizavimu, ypač su BootstrapFewShotWithRandomSearch, įskaitant nustatymus, tokius kaip:
- Kompiliacija su teiginiais
- Kompiliacija + išvados su teiginiais
Išvada
DSPy siūlo galingą ir sistemingą požiūrį į kalbos modelių ir jų raginimų optimizavimą. Vykdydami šiuose pavyzdžiuose aprašytus veiksmus galite lengvai kurti, optimizuoti ir įvertinti sudėtingas AI sistemas. DSPy modulinis dizainas ir pažangūs optimizatoriai leidžia efektyviai ir efektyviai integruoti įvairius kalbų modelius, todėl tai yra vertingas įrankis visiems, dirbantiems NLP ir AI srityje.
Nesvarbu, ar kuriate paprastą atsakymo į klausimus sistemą, ar sudėtingesnį vamzdyną, DSPy suteikia lankstumo ir tvirtumo, reikalingo aukštam našumui ir patikimumui pasiekti.
