Optimoi LLM DSPyn avulla: Vaiheittainen opas AI-järjestelmien rakentamiseen, optimointiin ja arviointiin

Koska suurten kielen mallien (LLM) ominaisuudet jatkavat laajentumista, kehittää luotettavia AI-järjestelmiä, jotka hyödyntävät niiden potentiaalia, on tullut yhä monimutkaisemmaksi. Perinteiset lähestymistavat usein sisältävät monimutkaisia ohjelmointitekniikoita, datan luomista hienosäätöä varten ja manuaalista ohjausta varmistamaan noudattamista alakohtaisiin rajoituksiin. Tämä prosessi voi kuitenkin olla työläs, virhealtis ja riippuvainen voimakkaasti ihmisen väliintulosta.

Tässä vaiheessa tulee DSPy, vallankumouksellinen kehys, joka on suunniteltu virtaamaan AI-järjestelmien kehittämistä. DSPy esittää systemaattisen lähestymistavan LM-ohjelmien ja painojen optimointiin, mahdollistaen kehittäjien luoda monimutkaisia sovelluksia vähäisellä manuaalisella vaivalla.

Tässä kattavassa oppaassa tutkimme DSPyn perusperiaatteita, sen modulaarista arkkitehtuuria ja valikoimaa voimakkaita ominaisuuksia, joita se tarjoaa. Tutkimme myös käytännön esimerkkejä, osoittaen, miten DSPy voi muuttaa tapaa, jolla kehität AI-järjestelmiä LLM: n avulla.

Mikä on DSPy, ja miksi sinun tarvitsee se?

DSPy on kehys, joka erottaa ohjelman (moduulit) parametreistä (LM-ohjelmat ja painot) kussakin vaiheessa. Tämä erottelu mahdollistaa systemaattisen LM-ohjelmien ja painojen optimoinnin, mahdollistaen sinun luoda monimutkaisia AI-järjestelmiä suuremmalla luotettavuudella, ennustettavuudella ja noudattamisella alakohtaisiin rajoituksiin.

Perinteisesti AI-järjestelmien kehittäminen LLM: n avulla on vaatinut työlästä prosessia, jossa ongelma on jaettu vaiheisiin, luotu monimutkaisia ohjelmia kussakin vaiheessa, luotu synteettisiä esimerkkejä hienosäätöä varten ja manuaalista ohjausta, jotta LLM: t noudattavat tiettyjä rajoituksia. Tämä lähestymistapa ei ollut ainoastaan aikaa vievä, vaan myös altis virheille, koska jopa pienet muutokset putkessa, LLM: ssä tai datassa voivat edellyttää laajaa uudelleen työstämistä ohjelmia ja hienosäätövälineitä.

DSPy vastaa näihin haasteisiin esittämällä uuden paradigman: optimoijat. Nämä LM-ohjatut algoritmit voivat säätää LM-kutsujen ohjelmia ja painoja, annettuna metriikin, jonka haluat maksimoida. Automatisoidessaan optimointiprosessin DSPy antaa kehittäjille mahdollisuuden luoda luotettavia AI-järjestelmiä vähäisellä manuaalisella väliintulolla, parantaen LM-tulosteen luotettavuutta ja ennustettavuutta.

DSPyn modulaarinen arkkitehtuuri

DSPyn sydämessä on modulaarinen arkkitehtuuri, joka helpottaa monimutkaisten AI-järjestelmien koostamista. Kehys tarjoaa joukon valmiita moduuleja, jotka abstrahoivat erilaisia ohjelmointitekniikoita, kuten dspy.ChainOfThought ja dspy.ReAct. Nämä moduulit voidaan yhdistää ja koostaa suuremmiksi ohjelmiksi, mahdollistaen kehittäjien luoda monimutkaisia putkia, jotka on räätälöity heidän tiettyihin vaatimuksiin.

Kunkin moduulin sisällä on oppimiskykyisiä parametrejä, mukaan lukien ohjeet, vähän esimerkkejä ja LM-painot. Kun moduuli kutsutaan, DSPyn optimoijat voivat hienosäätää näitä parametrejä maksimoimaan haluttu metriikka, varmistaen, että LM-tulosteen noudattaa määritettyjä rajoituksia ja vaatimuksia.

Optimointi DSPyn avulla

DSPy esittää joukon voimakkaita optimoijia, jotka on suunniteltu parantamaan AI-järjestelmiesi suorituskykyä ja luotettavuutta. Nämä optimoijat hyödyntävät LM-ohjattuja algoritmejä säätääkseen LM-kutsujen ohjelmia ja painoja, maksimoiden määritetyn metriikan ja noudattaen alakohtaisia rajoituksia.

Jotkut DSPyssä saatavilla olevat avainoptimoijat ovat:

1. BootstrapFewShot: Tämä optimoija laajentaa allekirjoitusta automaattisesti luomalla ja sisällyttämällä optimoidut esimerkit ohjelmaan, jota lähettää malliin, toteuttaen vähän esimerkkejä.
2. BootstrapFewShotWithRandomSearch: Soveltaa BootstrapFewShot useita kertoja satunnaisella haulla luoduista esimerkeistä, valitsemalla parhaan ohjelman optimoinnissa.
3. MIPRO: Luo ohjeita ja vähän esimerkkejä kussakin vaiheessa, ohjeiden luomisen ollessa data- ja esimerkkitietoista. Se käyttää Bayesilaista optimointia etsimään tehokkaasti luotujen ohjeiden ja esimerkkien tilaa moduuleissasi.
4. BootstrapFinetune: Tislaa ohjelmaan perustuvan DSPy-ohjelman painopäivityksiä pienemmille LLM: lle, mahdollistaen sinun hienosäätää LLM: n tehokkuuden parantamiseksi.

Käyttämällä näitä optimoijia kehittäjät voivat systemaattisesti optimoida AI-järjestelmiään, varmistaen korkealaatuiset tulokset noudattaen alakohtaisia rajoituksia ja vaatimuksia.

Käynnistäminen DSPyllä

Esittelemme käytännön esimerkin rakentamalla hakuvälineen (RAG) kysymyksiin ja vastauksiin.

Vaihe 1: LLM:n ja hakumallin määrittäminen

Ensimmäinen vaihe vaatii LLM:n (kielen malli) ja hakumallin (hakumalli) määrittämisen DSPyssä.

Asenna DSPy suorittamalla:

pip install dspy-ai

DSPy tukee useita LLM- ja hakumallin API: ia sekä paikallista mallin isäntää, mikä tekee siitä helpon integroida suosikkimallisi.

import dspy

<p># Määritä LLM ja hakumalli
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>

Vaihe 2: Datatietojen lataaminen

Seuraavaksi ladataan HotPotQA-aineisto, joka sisältää joukon monimutkaisia kysymys-vastaus -paria, joita tyypillisesti vastataan usean askelen kautta.

from dspy.datasets import HotPotQA

<p># Lataa aineisto
dataset = HotPotQA(train_seed=1, train_size=20, eval_seed=2023, dev_size=50, test_size=0)</p>

<p># Määritä 'kysymys' -kenttä syötteenä
trainset = [x.with_inputs('kysymys') for x in dataset.train]
devset = [x.with_inputs('kysymys') for x in dataset.dev]</p>

Vaihe 3: Allekirjoitusten luominen

DSPy käyttää allekirjoituksia määrittämään moduulien käyttäytymistä. Tässä esimerkissä määritetään allekirjoitus vastausluomisen tehtävälle, määrittäen syöte- ja tulostekentät (konteksti ja kysymys).

<p>class GenerateAnswer(dspy.Signature):
"""Vastaa kysymyksiin lyhyillä faktatiedoilla."""</p>

<p>konteksti = dspy.InputField(desc='saattaa sisältää merkityksellisiä faktoja')
kysymys = dspy.InputField()
vastaus = dspy.OutputField(desc='usein 1-5 sanaa')</p>

Vaihe 4: Putken rakentaminen

Rakennamme RAG-putken DSPy-moduulina, joka koostuu alkuasetuksesta (__init__) julistamaan alimoduuleja (dspy.Retrieve ja dspy.ChainOfThought) ja eteenpäin -menetelmästä (forward) kuvaamaan kysymyksen vastaamisen ohjausvirran näiden moduulien avulla.

<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, kysymys):
konteksti = self.retrieve(kysymys).passages
ennuste = self.generate_answer(konteksti=konteksti, kysymys=kysymys)
return dspy.Prediction(konteksti=konteksti, vastaus=ennuste.vastaus)</p>

Vaihe 5: Putken optimointi

Putken määrittämisen jälkeen voidaan optimoida DSPyn optimoijien avulla. Tässä esimerkissä käytetään BootstrapFewShot-optimointia, joka luo ja valitsee tehokkaita ohjelmia moduuleille perustuen koulutusjoukkoon ja validointimetriikkaan.

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

<p># Validointimetriikka
def validate_context_and_answer(esimerkki, ennuste, jälki=None):
vastaus_EM = dspy.evaluate.answer_exact_match(esimerkki, ennuste)
vastaus_PM = dspy.evaluate.answer_passage_match(esimerkki, ennuste)
return vastaus_EM and vastaus_PM</p>

<p># Määritä optimoija
teleprompter = BootstrapFewShot(metric=validate_context_and_answer)</p>

<p># Käännä ohjelma
compiled_rag = teleprompter.compile(RAG(), trainset=trainset)</p>

Vaihe 6: Putken arviointi

Käännöksen jälkeen on tärkeää arvioida ohjelman suorituskykyä kehitysjoukolla, varmistaen, että se täyttää halutun tarkkuuden ja luotettavuuden.

from dspy.evaluate import Evaluate

<p># Määritä arvioija
evaluate = Evaluate(devset=devset, metric=validate_context_and_answer, num_threads=4, display_progress=True, display_table=0)</p>

<p># Arvioi käännetyt RAG-ohjelma
evaluation_result = evaluate(compiled_rag)</p>

<p>print(f"Arviointitulos: {evaluation_result}")</p>

Vaihe 7: Mallin historian tarkastelu

Mallin vuorovaikutuksien syvemmän ymmärtämisen vuoksi voidaan tarkastella viimeisimpiä sukupolvia tarkastelemalla mallin historiaa.

<p># Tarkastele mallin historiaa
turbo.inspect_history(n=1)</p>

Vaihe 8: Ennusteiden tekeminen

Putken optimoinnin ja arvioinnin jälkeen voidaan käyttää sitä tekemään ennusteita uusista kysymyksistä.

<p># Esimerkkikysymys
kysymys = "Mikä palkinto Gary Zukavin ensimmäinen kirja sai?"</p>

<p># Tee ennuste käännetyllä RAG-ohjelmalla
ennuste = compiled_rag(kysymys)</p>

<p>print(f"Kysymys: {kysymys}")
print(f"Vastaus: {ennuste.vastaus}")
print(f"Hakukontekstit: {ennuste.konteksti}")</p>

Minimiohjelma DSPyllä

Nyt käydään läpi toinen minimiohjelmaesimerkki, jossa käytetään GSM8K-aineistoa ja OpenAI GPT-3.5-turbo-mallia simuloimaan ohjelmointitehtäviä DSPyssä.

Asetukset

Varmista, että ympäristö on oikein määritetty:

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

<p># Määritä LLM
turbo = dspy.OpenAI(model='gpt-3.5-turbo-instruct', max_tokens=250)
dspy.settings.configure(lm=turbo)</p>

<p># Lataa matemaattisia kysymyksiä GSM8K-aineistosta
gsm8k = GSM8K()
gsm8k_trainset, gsm8k_devset = gsm8k.train[:10], gsm8k.dev[:10]</p>

print(gsm8k_trainset)

Gsm8k_trainset ja gsm8k_devset -aineistot sisältävät listan esimerkkejä, joissa kussakin esimerkissä on kysymys- ja vastauskenttä.

Määritä moduuli

Määritä mukautettu ohjelma, joka käyttää ChainOfThought-moduulia askelkohtaisessa päättelyssä:

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

<p>def forward(self, kysymys):
return self.prog(kysymys=kysymys)</p>

Käännä ja arvioi malli

Käännä se BootstrapFewShot-teleprompterilla:

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

<p># Määritä optimoija
config = dict(max_bootstrapped_demos=4, max_labeled_demos=4)</p>

<p>teleprompter = BootstrapFewShot(metric=gsm8k_metric, **config)
optimized_cot = teleprompter.compile(CoT(), trainset=gsm8k_trainset)</p>

<p># Määritä arvioija
from dspy.evaluate import Evaluate</p>

<p>evaluate = Evaluate(devset=gsm8k_devset, metric=gsm8k_metric, num_threads=4, display_progress=True, display_table=0)
evaluate(optimized_cot)</p>

<p># Tarkastele mallin historiaa
turbo.inspect_history(n=1)</p>

Tämä esimerkki osoittaa, miten voit määrittää ympäristösi, määrittää mukautetun moduulin, kääntää mallin ja arvioida sen suorituskykyä käyttäen annettua aineistoa ja teleprompter-määrityksiä.

Datanhallinta DSPyssä

DSPy toimii koulutus-, kehitys- ja testijoukoilla. Kussakin esimerkissä on tyypillisesti kolme tyyppistä arvoja: syötteet, välimuistit ja lopputulokset. Välimuisti- tai lopputuloksia ei välttämättä ole, mutta joitakin esimerkkisyötteitä on välttämätöntä.

Esimerkkien luominen

DSPyssä esimerkit ovat samanlaisia kuin Python-sanakirjat, mutta niissä on hyödyllisiä apuvälineitä:

<p>qa_pair = dspy.Example(kysymys="Tämä on kysymys?", vastaus="Tämä on vastaus.")</p>

<p>print(qa_pair)
print(qa_pair.kysymys)
print(qa_pair.vastaus)</p>

Tuloste:

<p>Example({'kysymys': 'Tämä on kysymys?', 'vastaus': 'Tämä on vastaus.'}) (input_keys=None)
Tämä on kysymys?
Tämä on vastaus.</p>

Syötteiden määrittäminen

DSPyssä Example-olioilla on with_inputs() -menetelmä, jolla voidaan määrittää tiettyjä kenttiä syötteiksi:

<p>print(qa_pair.with_inputs("kysymys"))
print(qa_pair.with_inputs("kysymys", "vastaus"))</p>

Arvoja voidaan käyttää pisteoperaattorin avulla, ja menetelmiä kutsutaan inputs() ja labels() palauttamaan uusia Example-olioita, jotka sisältävät vain syöte- tai ei-syötekenttiä.

Optimoijat DSPyssä

DSPy-optimoija säätää DSPy-ohjelman parametrejä (ohjelmia ja/tai LM-painoja) maksimoimaan määritetyn metriikan. DSPy tarjoaa useita valmiita optimoijia, joista kussakin on erilainen strategia.

Optimoijat

• BootstrapFewShot: Luo vähän esimerkkejä annetuista merkityistä syöte- ja tulostiedoista.
• BootstrapFewShotWithRandomSearch: Soveltaa BootstrapFewShot useita kertoja satunnaisella haulla luoduista esimerkeistä.
• COPRO: Luo ja hienosäätää uusia ohjeita kussakin vaiheessa, optimoimalla ne koordinaattien nousulla.
• MIPRO: Optimoi ohjeita ja vähän esimerkkejä Bayesilaisen optimoinnin avulla.

Optimoijan valinta

Jos et tiedä, mihin ryhtää, käytä BootstrapFewShotWithRandomSearch:

Jos sinulla on vain vähän dataa (10 esimerkkiä), käytä BootstrapFewShot.
Jos sinulla on hieman enemmän dataa (50 esimerkkiä), käytä BootstrapFewShotWithRandomSearch.
Jos sinulla on suurempi aineisto (300+ esimerkkiä), käytä MIPRO.

Tässä on esimerkki BootstrapFewShotWithRandomSearchin käytöstä:

<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=METRIIKKASI_TÄSSÄ, **config)
optimized_program = teleprompter.compile(OHJELMASI_TÄSSÄ, trainset=KOULUTUSJOUKKOSI_TÄSSÄ)</p>

Optimoidun ohjelman tallentaminen ja lataaminen

Optimoinnin jälkeen voit tallentaa ohjelman tulevaan käyttöön:

optimized_program.save(POLKU_TALLENNUSKOHTIIN)

Lataa tallennettu ohjelma:

<p>loaded_program = OHJELMALUOKKASI()
loaded_program.load(polku=POLKU_TALLENNUSKOHTIIN)</p>

Edistyneet ominaisuudet: DSPy-vakiot

DSPy-vakiot automaattisesti pakottavat laskennallisia rajoituksia LLM: lle, parantaen LLM-tulosteen luotettavuutta, ennustettavuutta ja oikeellisuutta.

Vakioden käyttäminen

Määritä validointifunktiot ja julista vakiot mallin luomisen jälkeen. Esimerkiksi:

<p>dspy.Suggest(
len(kysymys) &lt;= 100,
&quot;Kysymys pitäisi olla lyhyt ja alle 100 merkkiä&quot;,
)</p>

<p>dspy.Suggest(
validate_query_distinction_local(edelliset_kysymykset, kysymys),
"Kysymys pitäisi olla erilainen kuin: " + "; ".join(f"{i+1}) {q}" for i, q in enumerate(edelliset_kysymykset)),
)</p>

Ohjelmien muuntaminen vakioiden avulla

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

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

Alternatiivisesti voit aktivoida vakiot suoraan ohjelmassa:

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

Vakio-ohjattu optimointi

DSPy-vakiot toimivat DSPy-optimoinnin kanssa, erityisesti BootstrapFewShotWithRandomSearchin kanssa, mukaan lukien asetukset kuten:

• Käännös vakioiden kanssa
• Käännös + Inferenssi vakioiden kanssa

Johtopäätös

DSPy tarjoaa voimakkaan ja systemaattisen lähestymistavan kielen mallien ja ohjelmien optimointiin. Seuraamalla näitä esimerkeissä kuvattuja vaiheita voit rakentaa, optimoida ja arvioida monimutkaisia AI-järjestelmiä helposti. DSPyn modulaarinen suunnittelu ja edistyneet optimoijat mahdollistavat tehokkaan ja tehokkaan integroinnin erilaisia kielen malleja, mikä tekee siitä arvokkaan työkalun kaikille, jotka työskentelevät NLP: n ja AI: n alalla.

Riippumatta siitä, rakennatko yksinkertaista kysymys-vastaus-järjestelmää vai monimutkaisempaa putkea, DSPy tarjoaa joustavuuden ja luotettavuuden, joita tarvitaan saavuttamaan korkea suorituskyky ja luotettavuus.