Rakennetaan LLM-agentit RAG:sta alusta alkaen ja sen ympäriltä: kattava opas

LLM:t kuten GPT-3, GPT-4 ja niiden avoimen lähdekoodin vastine voivat kärsiä ajantasaisen tiedon hakemisesta ja joskus luoda virheellistä tietoa tai “hallusinaatioita”.

Hakuvahvistettu luonti (RAG) on tekniikka, joka yhdistää LLM:n voiman ulkoisen tiedon hakemisen kanssa. RAG mahdollistaa LLM-vastauksien perustamisen tosiasialliseen, ajantasaiseen tietoon, mikä parantaa merkittävästi AI-luodun sisällön tarkkuutta ja luotettavuutta.

Tässä blogipostauksessa tutustumme siihen, miten voimme rakentaa LLM-agenteja RAG:sta alusta alkaen, syventyen arkkitehtuuriin, toteutusyksityiskohtiin ja edistyneisiin tekniikoihin. Käymme läpi kaiken RAG:n perusteista sophistikoitiin agentteihin, jotka kykenevät monimutkaiseen päättelyyn ja tehtävien suorittamiseen.

Ennen kuin ryhdymme rakentamaan LLM-agenttimme, tutustukaamme siihen, mitä RAG on ja miksi se on tärkeää.

RAG eli Hakuvahvistettu luonti on hybridiratkaisu, joka yhdistää tiedon hakemisen ja tekstin luontia. RAG-järjestelmässä:

• Kysymys käytetään hakemaan asiaankuuluvia asiakirjoja tietokannasta.
• Nämä asiakirjat syötetään kielen malliin alkuperäisen kysymyksen kanssa.
• Malli luo vastauksen sekä kysymyksen että haetun tiedon perusteella.

RAG

Tämä lähestymistapa tarjoaa useita etuja:

• Parannettu tarkkuus: Vastauksia perustamalla haettuun tietoon, RAG vähentää “hallusinaatioita” ja parantaa faktuaalisen tarkkuuden.
• Ajantasainen tieto: Tietokanta voidaan päivittää säännöllisesti, jolloin järjestelmä pääsee käsiksi ajantasaiseen tietoon.
• Avoinheitettavuus: Järjestelmä voi tarjota lähteitä tietolleen, mikä lisää luottamusta ja mahdollistaa faktantarkistuksen.

Ymmärtäminen LLM-agenteista

LLM Powered Agents

Kun kohtaat ongelman, jolla ei ole yksinkertaista vastausta, sinun usein on seurattava useita vaiheita, ajateltava huolellisesti ja muistettava, mitä olet jo kokeillut. LLM-agenteja on suunniteltu juuri tällaisiin tilanteisiin kielen mallin sovelluksissa. Ne yhdistävät perusteellisen data-analyysin, strategisen suunnittelun, tiedon hakemisen ja kyvyn oppia aiemmista toimista ratkaisemaan monimutkaisia ongelmia.

Mikä ovat LLM-agenteja?

LLM-agenteja ovat edistyneet älykkäät järjestelmät, jotka on suunniteltu monimutkaisen tekstin luomiseen, joka vaatii peräkkäistä päättelyä. Ne voivat ajatella eteenpäin, muistaa aiemmat keskustelut ja käyttää eri työkaluja sovittaakseen vastauksiaan tilanteen ja tarvittavan tyylin mukaan.

Otetaan esimerkki oikeudellisesta kysymyksestä, kuten: “Mitkä ovat potentiaaliset oikeudelliset seuraukset tietynlaisen sopimuksen rikkomisesta Kaliforniassa?” Perussääntöinen LLM RAG-järjestelmällä voidaan hakea tarvittava tieto oikeudellisista tietokannoista.

Tarkemmalle skenaariolle: “Uusien tietosuojalakien valossa, mitkä ovat yleiset oikeudelliset haasteet, joita yritykset kohtaavat, ja miten oikeudet ovat käsitelleet näitä asioita?” Tämä kysymys kaivaa syvemmälle kuin vain faktatietojen hakeminen. Se on ymmärtämistä uusista säännöksistä, niiden vaikutuksesta eri yrityksiin ja oikeuksien vastauksista. LLM-agentti jakaisi tämän tehtävän alitehtäviin, kuten haettaisiin uusimmat lait, analysoitiin historiallisia tapauksia, tiivistettäisiin oikeudellisia asiakirjoja ja ennustettaisiin trendejä perustuen mallien mukaan.

LLM-agentejen komponentit

LLM-agenteja koostuu yleensä neljästä komponentista:

1. Agentti/Aivot: Peruskielen malli, joka prosessoi ja ymmärtää kieltä.
2. Suunnittelu: Kyky päättelyyn, tehtävien jakamiseen ja suunnitelman kehittämiseen.
3. Muisti: Ylläpitää aiempien interaktioiden tietoja ja oppii niistä.
4. Työkalujen käyttö: Integroi eri resursseja tehtävien suorittamiseen.

Agentti/Aivot

LLM-agentin ytimessä on kielen malli, joka prosessoi ja ymmärtää kieltä laajasta koulutusaineistosta. Voit mukauttaa agentin tietyn tehtävän tai interaktion mukaiselle henkilölle parantamalla sen suorituskykyä.

Muisti

Muistikomponentti auttaa LLM-agenteja käsittelemään monimutkaisia tehtäviä ylläpitämällä aiempien toimien tietoja. On kaksi päätyyppiä muistia:

• Lyhytaikainen muisti: Toimii muistikirjana, joka pitää kirjaa meneillään olevista keskusteluista.
• Pitkäaikainen muisti: Toimii päiväkirjana, joka tallentaa aiempien interaktioiden tiedot oppiakseen paremmin ja tekemään parempia päätöksiä.

Yhdistämällä nämä muistityypit agentti voi tarjota sovitettuja vastauksia ja muistaa käyttäjän preferenssejä ajan myötä, luoden siten yhtenäisemmän ja relevantimman interaktion.

Suunnittelu

Suunnittelu mahdollistaa LLM-agenteille päättelyn, tehtävien jakamisen hallitettaviin osiin ja suunnitelman sopeuttamisen tehtävien kehittyessä. Suunnittelussa on kaksi päävaihetta:

• Suunnitelman muodostus: Jakaa tehtävän pienempiin alitehtäviin.
• Suunnitelman reflektointi: Arvioi suunnitelman tehokkuutta, ottaa vastaan palautteen ja hienosäädetään strategioita.

Menetelmiä kuten Chain of Thought (CoT) ja Tree of Thought (ToT) auttavat tässä jakoprosessissa, sallien agentin tutkia eri polkuja ongelman ratkaisemiseksi.

Lisätietoa AI-agenteista, niiden nykyisistä kyvyistä ja potentiaalista, voit lukea “Auto-GPT & GPT-Engineer: An In-Depth Guide to Today’s Leading AI Agents”

Ympäristön määrittäminen

Rakentaaksemme RAG-agenttimme, meidän on määritettävä kehitysympäristömme. Käytämme Pythonia ja useita avainkirjastoja:

• LangChain: Orkestroidaksemme LLM- ja hakukomponenttimme
• Chroma: Dokumenttien upottamisen vektortallena
• OpenAI:n GPT-mallit: Pääkielen mallina (voit korvata tämän avoimen lähdekoodin mallilla, jos haluat)
• FastAPI: Luodaksemme yksinkertaisen API:n agenttimme kanssa vuorovaikuttamiseen

Aloitetaan ympäristön määrittäminen:

<p># Luo uusi virtuaaliympäristö
python -m venv rag_agent_env
source rag_agent_env/bin/activate # Windowsissa käytä `rag_agent_env\Scripts\activate`</p>

<p># Asenna vaaditut paketit
pip install langchain chromadb openai fastapi uvicorn

Nyt luomme uuden Python-tiedoston nimeltä rag_agent.py ja tuomme tarvittavat kirjastot:

<p>from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import CharacterTextSplitter
from langchain.llms import OpenAI
from langchain.chains import RetrievalQA
from langchain.document_loaders import TextLoader
import os</p>

<p># Aseta OpenAI-avain
os.environ[&quot;OPENAI_API_KEY&quot;] = &quot;avain-tänne&quot;</p>

Yksinkertainen RAG-järjestelmä

Nyt kun meillä on ympäristö määritettynä, rakennetaan perus-RAG-järjestelmä. Aloita luomalla tietokanta joukosta asiakirjoja, ja käytä sitä vastaamaan kysymyksiin.

Askelt 1: Asiakirjojen valmistelu

Ensinnäkin on ladattava ja valmisteltava asiakirjamme. Oletetaan, että meillä on tekstifilu nimeltä knowledge_base.txt, jossa on tietoa AI:sta ja koneoppimisesta.

<p># Lataa asiakirja
lataaja = TextLoader(&quot;knowledge_base.txt&quot;)
asiakirjat = lataaja.lataa()</p>

<p># Jaa asiakirjat palasiin
teksti_jaaja = CharacterTextSplitter(palankoko=1000, palan_ylitys=0)
tekstit = teksti_jaaja.jaa_asiakirjat(asiakirjat)</p>

<p># Luo upotukset
upotukset = OpenAIEmbeddings()</p>

<p># Luo vektortalli
vektortalli = Chroma.from_asiakirjoista(tekstit, upotukset)</p>

Askelt 2: Hakupohjaisen QA-ketjun luominen

Nyt kun meillä on vektortalli, voimme luoda hakupohjaisen QA-ketjun:

<p># Luo hakupohjainen QA-ketju
qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type=&quot;stuff&quot;, retriever=vektortalli.as_retriever())</p>

Askelt 3: Järjestelmän kuulustelu

Nyt voimme kuulustella RAG-järjestelmäämme:

<p>kysymys = &quot;Mitkä ovat koneoppimisen tärkeimmät sovellukset?&quot;
tulos = qa.ajo(kysymys)
print(tulos)

Askelt 4: LLM-agentin luominen

Vaikka yksinkertainen RAG-järjestelmämme toimii hyvin, se on melko rajoitettu. Parannetaan sitä luomalla LLM-agentti, joka voi suorittaa monimutkaisempia tehtäviä ja päättelyä.

LLM-agentti on älykäs järjestelmä, joka voi käyttää työkaluja ja tehdä päätöksiä siitä, mitkä toimet suorittaa. Luomme agentin, joka voi vastata kysymyksiin, suorittaa verkkohakuja ja peruslaskutoimituksia.

Määritellään ensin joitain työkaluja agentillemme:

<p>from langchain.agents import Tool
from langchain.tools import DuckDuckGoSearchRun
from langchain.tools import BaseTool
from langchain.agents import initialize_agent
from langchain.agents import AgentType</p>

<p># Määritellään laskin-työkalu
class LaskinTyokalu(BaseTool):
nimi = &quot;Laskin&quot;
kuvaus = &quot;Hyödyllinen, kun tarvitset matemaattista apua&quot;</p>

<p>def _ajo(self, kysymys: str)
try:
return str(eval(kysymys))
except:
return &quot;En pysty laskeamaan. Varmista, että syöte on kelvollinen matemaattinen lauseke.&quot;</p>

<p># Luo työkalu-instanssit
haku = DuckDuckGoSearchRun()
laskin = LaskinTyokalu()</p>

<p># Määritellään työkalut
tyokalut = [Tool(nimi=&quot;Haku&quot;, funktio=haku.ajo, kuvaus=&quot;Hyödyllinen, kun tarvitset tietoa ajankohtaisista asioista&quot;),
Tool(nimi=&quot;RAG-QA&quot;, funktio=qa.ajo, kuvaus=&quot;Hyödyllinen, kun tarvitset tietoa AI:sta ja koneoppimisesta&quot;),
Tool(nimi=&quot;Laskin&quot;, funktio=laskin._ajo, kuvaus=&quot;Hyödyllinen, kun tarvitset suorittaa matemaattisia laskutoimituksia&quot;)
]</p>

<p># Alkoi agentti
agentti = initialize_agent(tyokalut, OpenAI(temperatuuri=0), agentti=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)</p>

Nyt meillä on agentti, joka voi käyttää RAG-järjestelmäämme, suorittaa verkkohakuja ja tehdä peruslaskutoimituksia. Testataan se:

<p>tulos = agentti.ajo(&quot;Mitä on ero supervoidun ja unsupervoidun oppimisen välillä? Mitä on 15% 80:sta?&quot;)
print(tulos)</p>

Tämä agentti osoittaa yhden LLM-agenttien avainetujen: ne voivat yhdistää useita työkaluja ja päättelyaskelia monimutkaisten kysymysten ratkaisemiseen.

Agentin parantaminen edistyneillä RAG-tekniikoilla

Vaikka nykyinen RAG-järjestelmämme toimii hyvin, on useita edistyneitä tekniikoita, joilla voimme parantaa sen suorituskykyä:

a) Semanttinen haku tiivisteiden hakemisella (DPR)

Voimme toteuttaa DPR:n tarkemman semanttisen haun:

<p>from transformers import DPRQuestionEncoder, DPRContextEncoder</p>

<p>kysymys_koodari = DPRQuestionEncoder.from_pretrained(&quot;facebook/dpr-question_encoder-single-nq-base&quot;)
konteksti_koodari = DPRContextEncoder.from_pretrained(&quot;facebook/dpr-ctx_encoder-single-nq-base&quot;)</p>

<p># Funktio asiakirjojen koodaamiseen
def koodaa_asiakirjat(asiakirjat):
return konteksti_koodari(asiakirjat, max_pituus=512, return_tensors=&quot;pt&quot;).pooler_output</p>

<p># Funktio kysymyksen koodaamiseen
def koodaa_kysymys(kysymys):
return kysymys_koodari(kysymys, max_pituus=512, return_tensors=&quot;pt&quot;).pooler_output</p>

b) Kysymyksen laajennus

Voimme käyttää kysymyksen laajennusta hakutoiminnon parantamiseen:

<p>from transformers import T5ForConditionalGeneration, T5Tokenizer</p>

<p>malli = T5ForConditionalGeneration.from_pretrained(&quot;t5-small&quot;)
tokinator = T5Tokenizer.from_pretrained(&quot;t5-small&quot;)</p>

<p>def laajenna_kysymys(kysymys):
input_teksti = f&quot;laajenna kysymys: {kysymys}&quot;
input_id = tokinator.encode(input_teksti, return_tensors=&quot;pt&quot;)
tulokset = malli.generate(input_id, max_pituus=50, num_return_sequences=3)
laajennetut_kysymykset = [tokinator.decode(tulos, skip_special_tokens=True) for tulos in tulokset]
return laajennetut_kysymykset</p>

c) Iteratiivinen hienosäätö

Voimme toteuttaa iteratiivisen hienosäätöprosessin, jossa agentti voi esittää seuraavat kysymykset selventääkseen tai laajentaakseen alkuperäistä hakua:

<p>def iteratiivinen_hakeminen(alkuperainen_kysymys, max_iteraatiot=3):
kysymys = alkuperainen_kysymys
for _ in range(max_iteraatiot):
tulos = qa.ajo(kysymys)
selvennys = agentti.ajo(f&quot;Perustuen tähän tulokseen: &#039;{tulos}&#039;, mitä seuraavaa kysymystä minun pitäisi esittää saadakseni tarkemman tiedon?&quot;)
if selvennys.lower().strip() == &quot;ei mitään&quot;:
break
kysymys = selvennys
return tulos</p>

# Käytä tätä agentin prosessissa

Moni-agentti-järjestelmän toteutus

Monimutkaisempien tehtävien käsittelyyn voimme toteuttaa moni-agentti-järjestelmän, jossa eri agentit erikoistuvat eri aihealueisiin. Tässä on yksinkertainen esimerkki:

<p>class ErikoistunutAgentti:
def __init__(self, nimi, tyokalut):
self.nimi = nimi
self.agentti = initialize_agent(tyokalut, OpenAI(temperatuuri=0), agentti=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)</p>

<p>def ajo(self, kysymys):
return self.agentti.ajo(kysymys)</p>

<p># Luo erikoistuneita agenteja
tutkimus_agentti = ErikoistunutAgentti(&quot;Tutkimus&quot;, [Tool(nimi=&quot;RAG-QA&quot;, funktio=qa.ajo, kuvaus=&quot;AI- ja ML-kysymyksiin&quot;)])
matemaattinen_agentti = ErikoistunutAgentti(&quot;Matematiikka&quot;, [Tool(nimi=&quot;Laskin&quot;, funktio=laskin._ajo, kuvaus=&quot;Laskutoimituksiin&quot;)])
yleinen_agentti = ErikoistunutAgentti(&quot;Yleinen&quot;, [Tool(nimi=&quot;Haku&quot;, funktio=haku.ajo, kuvaus=&quot;Yleisiin kysymyksiin&quot;)])</p>

<p>class Koordinaattori:
def __init__(self, agentit):
self.agentit = agentit</p>

<p>def ajo(self, kysymys):
# Määritä, kuka agentti käytetään
if &quot;lasketa&quot; in kysymys.lower() or any(op in kysymys for op in [&#039;+&#039;, &#039;-&#039;, &#039;*&#039;, &#039;/&#039;]):
return self.agentit[&#039;Matematiikka&#039;].ajo(kysymys)
elif any(term in kysymys.lower() for term in [&#039;ai&#039;, &#039;koneoppiminen&#039;, &#039;syväoppiminen&#039;]):
return self.agentit[&#039;Tutkimus&#039;].ajo(kysymys)
else:
return self.agentit[&#039;Yleinen&#039;].ajo(kysymys)</p>

<p>koordinaattori = Koordinaattori({&#039;Tutkimus&#039;: tutkimus_agentti, &#039;Matematiikka&#039;: matemaattinen_agentti, &#039;Yleinen&#039;: yleinen_agentti})</p>

<p># Testaa moni-agentti-järjestelmää
tulos = koordinaattori.ajo(&quot;Mitä on ero CNN ja RNN? Laske myös 25% 120:sta.&quot;)
print(tulos)</p>

Tämä moni-agentti-järjestelmä sallii erikoistumisen ja pystyy käsittelemään laajemman kysymysvalikoiman tehokkaammin.

RAG-agenttien arviointi ja optimointi

Varmistaaksemme, että RAG-agenttimme toimii hyvin, on toteutettava arviointimittareita ja optimointitekniikoita:

a) Relevanttiusarviointi

Voimme käyttää mittareita kuten BLEU, ROUGE tai BERTScore arvioidaksemme haettujen asiakirjojen relevanttisuutta:

<p>from bert_score import score</p>

<p>def arvioi_relevanttisuus(kysymys, haettu_asiakirja, luotu_vastaus):
P, R, F1 = score([luotu_vastaus], [haettu_asiakirja], lang=&quot;en&quot;)
return F1.mean().item()</p>

b) Vastauslaatu-arviointi

Voimme käyttää ihmisten arviointia tai automaattisia mittareita arvioidaksemme vastauslaatua:

<p>from nltk.translate.bleu_score import sentence_bleu</p>

<p>def arvioi_vastauslaatu(viite_vastaus, luotu_vastaus):
return sentence_bleu([viite_vastaus.split()], luotu_vastaus.split())</p>

<p># Käytä tätä agentin vastausten arviointiin

Tulevaisuuden suunnat ja haasteet

Kun tarkastelemme RAG-agenttien tulevaisuutta, useita mielenkiintoisia suuntia ja haasteita ilmenee:

a) Monimodaalinen RAG: RAG:n laajentaminen käsittämään kuvaa, ääntä ja videota.

b) Jaettu RAG: RAG:n toteuttaminen jaettuina, yksityisyyttä suojelevina tietokantoina.

c) Jatkuva oppiminen: Kehittäminen menetelmiä RAG-agenttien tietokantojen ja mallien päivittämiseen ajan myötä.

d) Etiset kysymykset: Käsittely harhaa, reiluutta ja avoimuutta RAG-järjestelmissä.

e) Skalattavuus: RAG:n optimointi suurten, reaaliaikaisen sovellusten tarpeisiin.

Johtopäätös

RAG:sta alusta alkaen rakentaminen on monimutkainen mutta palkitseva prosessi. Olemme käyneet läpi RAG:n perusteita, toteuttaneet yksinkertaisen järjestelmän, luoneet LLM-agentin, parantaneet sitä edistyneillä tekniikoilla, tutkineet moni-agentti-järjestelmiä ja keskustelleet arviointi- ja optimointistrategioista.