AGI dan AI masa depan
Membangun Agen LLM untuk RAG dari Awal hingga Lanjutan: Panduan Lengkap
Tambahkan Unite.AI ke sumber pilihan Anda di Google
LLM seperti GPT-3, GPT-4, dan konterparnya yang open-source sering mengalami kesulitan dengan pengambilan informasi yang mutakhir dan dapat menghasilkan halusinasi atau informasi yang tidak tepat.
Retrieval-Augmented Generation (RAG) adalah teknik yang menggabungkan kekuatan LLM dengan pengambilan pengetahuan eksternal. RAG memungkinkan kita untuk memperkuat respons LLM dengan informasi faktual yang mutakhir, sehingga meningkatkan akurasi dan keandalan konten yang dihasilkan AI.
Dalam posting blog ini, kita akan menjelajahi cara membangun agen LLM untuk RAG dari awal, dengan menyelami arsitektur, detail implementasi, dan teknik lanjutan. Kita akan membahas semua hal, dari dasar RAG hingga menciptakan agen yang canggih yang mampu melakukan penalaran kompleks dan eksekusi tugas.
Sebelum kita memulai membangun agen LLM kita, mari kita pahami apa itu RAG dan mengapa itu penting.
RAG, atau Retrieval-Augmented Generation, adalah pendekatan hibrida yang menggabungkan pengambilan informasi dengan generasi teks. Dalam sistem RAG:
- Sebuah query digunakan untuk mengambil dokumen yang relevan dari basis pengetahuan.
- Dokumen-dokumen tersebut kemudian diberikan ke model bahasa bersama dengan query asli.
- Model menghasilkan respons berdasarkan query dan informasi yang diambil.
RAG
Pendekatan ini memiliki beberapa kelebihan:
- Akurasi yang ditingkatkan: Dengan memperkuat respons dengan informasi yang diambil, RAG mengurangi halusinasi dan meningkatkan akurasi faktual.
- Informasi yang mutakhir: Basis pengetahuan dapat diperbarui secara teratur, sehingga sistem dapat mengakses informasi yang mutakhir.
- Transparansi: Sistem dapat menyediakan sumber untuk informasinya, meningkatkan kepercayaan dan memungkinkan pengecekan fakta.
Mengenal Agen LLM
Ketika Anda menghadapi masalah dengan jawaban yang tidak sederhana, Anda sering perlu mengikuti beberapa langkah, berpikir dengan hati-hati, dan mengingat apa yang telah Anda coba. Agen LLM dirancang untuk situasi seperti itu dalam aplikasi model bahasa. Mereka menggabungkan analisis data yang menyeluruh, perencanaan strategis, pengambilan data, dan kemampuan untuk belajar dari tindakan masa lalu untuk memecahkan masalah yang kompleks.
Apa itu Agen LLM?
Agen LLM adalah sistem AI yang canggih yang dirancang untuk menciptakan teks yang kompleks yang memerlukan penalaran berurutan. Mereka dapat berpikir ke depan, mengingat percakapan masa lalu, dan menggunakan alat yang berbeda untuk menyesuaikan respons mereka berdasarkan situasi dan gaya yang diperlukan.
Contoh pertanyaan di bidang hukum seperti: “Apa hasil hukum yang potensial dari pelanggaran kontrak tertentu di California?” Sebuah LLM dasar dengan sistem RAG dapat mengambil informasi yang diperlukan dari basis data hukum.
Untuk skenario yang lebih rinci: “Dalam cahaya hukum privasi data baru, apa tantangan hukum yang umum dihadapi perusahaan, dan bagaimana pengadilan menangani masalah ini?” Pertanyaan ini lebih dalam daripada hanya mencari fakta. Ini tentang memahami aturan baru, dampaknya pada perusahaan yang berbeda, dan respons pengadilan. Sebuah agen LLM akan memecahkan tugas ini menjadi sub-tugas, seperti mengambil hukum terbaru, menganalisis kasus sejarah, merangkum dokumen hukum, dan memprediksi tren berdasarkan pola.
Komponen Agen LLM
Agen LLM umumnya terdiri dari empat komponen:
- Agen/Otak: Model bahasa inti yang memproses dan memahami bahasa.
- Perencanaan: Kemampuan untuk berpikir, memecahkan tugas, dan mengembangkan rencana yang spesifik.
- Memori: Menjaga catatan interaksi masa lalu dan belajar dari mereka.
- Penggunaan Alat: Mengintegrasikan sumber daya yang berbeda untuk melakukan tugas.
Agen/Otak
Di inti agen LLM adalah model bahasa yang memproses dan memahami bahasa berdasarkan data yang besar yang telah dilatih. Anda memulai dengan memberikan prompt yang spesifik, memandu agen tentang cara merespons, alat yang digunakan, dan tujuan yang dituju. Anda dapat menyesuaikan agen dengan persona yang sesuai untuk tugas atau interaksi tertentu, meningkatkan kinerjanya.
Memori
Komponen memori membantu agen LLM menangani tugas yang kompleks dengan menjaga catatan tindakan masa lalu. Ada dua jenis memori utama:
- Memori Jangka Pendek: Berfungsi seperti notepad, menjaga track percakapan yang sedang berlangsung.
- Memori Jangka Panjang: Berfungsi seperti diary, menyimpan informasi dari interaksi masa lalu untuk belajar pola dan membuat keputusan yang lebih baik.
Dengan menggabungkan jenis memori ini, agen dapat menawarkan respons yang lebih disesuaikan dan mengingat preferensi pengguna dari waktu ke waktu, menciptakan interaksi yang lebih terhubung dan relevan.
Perencanaan
Perencanaan memungkinkan agen LLM untuk berpikir, memecahkan tugas menjadi bagian yang dapat dikelola, dan menyesuaikan rencana saat tugas berkembang. Perencanaan melibatkan dua tahap utama:
- Formulasi Rencana: Memecahkan tugas menjadi sub-tugas yang lebih kecil.
- Refleksi Rencana: Meninjau dan menilai efektivitas rencana, mengintegrasikan umpan balik untuk memperbaiki strategi.
Metode seperti Chain of Thought (CoT) dan Tree of Thought (ToT) membantu dalam proses dekomposisi ini, memungkinkan agen untuk menjelajahi jalur yang berbeda untuk memecahkan masalah.
Untuk mempelajari lebih lanjut tentang agen AI, termasuk kemampuan dan potensi mereka saat ini, pertimbangkan untuk membaca “Auto-GPT & GPT-Engineer: Panduan Mendalam tentang Agen AI Terkemuka Saat Ini”
Mengatur Lingkungan
Untuk membangun agen RAG kita, kita perlu mengatur lingkungan pengembangan kita. Kita akan menggunakan Python dan beberapa perpustakaan kunci:
- LangChain: Untuk mengatur komponen LLM dan pengambilan kita
- Chroma: Sebagai toko vektor untuk penyimpanan dokumen
- Model GPT OpenAI: Sebagai LLM dasar kita (Anda dapat menggantinya dengan model open-source jika diinginkan)
- FastAPI: Untuk membuat API sederhana untuk berinteraksi dengan agen kita
Mari kita mulai dengan mengatur lingkungan kita:
<p># Buat lingkungan virtual baru python -m venv rag_agent_env source rag_agent_env/bin/activate # Pada Windows, gunakan `rag_agent_env\Scripts\activate`</p> <p># Instal paket yang diperlukan pip install langchain chromadb openai fastapi uvicorn
Sekarang, mari kita buat file Python baru yang disebut rag_agent.py dan impor perpustakaan yang diperlukan:
<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># Tetapkan kunci API OpenAI Anda os.environ["OPENAI_API_KEY"] = "kunci-api-anda-here"</p>
Membangun Sistem RAG Sederhana
Sekarang kita telah mengatur lingkungan kita, mari kita membangun sistem RAG sederhana. Kita akan memulai dengan membuat basis pengetahuan dari sekumpulan dokumen, kemudian menggunakan ini untuk menjawab pertanyaan.
Langkah 1: Siapkan Dokumen
Pertama, kita perlu memuat dan menyiapkan dokumen kita. Untuk contoh ini, mari kita asumsikan kita memiliki file teks yang disebut knowledge_base.txt dengan beberapa informasi tentang AI dan pembelajaran mesin.
<p># Muat dokumen loader = TextLoader("knowledge_base.txt") documents = loader.load()</p> <p># Bagi dokumen menjadi potongan text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0) texts = text_splitter.split_documents(documents)</p> <p># Buat penyimpanan vektor vectorstore = Chroma.from_documents(texts, embeddings)</p>
Langkah 2: Buat Rantai QA Berbasis Pengambilan
Sekarang kita telah memiliki toko vektor kita, kita dapat membuat rantai QA berbasis pengambilan:
<p># Buat rantai QA berbasis pengambilan qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=vectorstore.as_retriever())</p>
Langkah 3: Tanyakan Sistem
Kita sekarang dapat menanyakan sistem RAG kita:
<p>query = "Apa aplikasi utama pembelajaran mesin?" result = qa.run(query) print(result)
Langkah 4: Membuat Agen LLM
Sementara sistem RAG sederhana kita berguna, itu sangat terbatas. Mari kita tingkatkan dengan membuat agen LLM yang dapat melakukan tugas yang lebih kompleks dan berpikir tentang informasi yang diambil.
Agen LLM adalah sistem AI yang dapat menggunakan alat dan membuat keputusan tentang tindakan yang harus diambil. Kita akan membuat agen yang dapat tidak hanya menjawab pertanyaan tetapi juga melakukan pencarian web dan perhitungan dasar.
Pertama, mari kita tentukan beberapa alat untuk agen kita:
<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># Tentukan alat kalkulator class CalculatorTool(BaseTool): name = "Kalkulator" description = "Berguna untuk menjawab pertanyaan tentang matematika"</p> <p>def _run(self, query: str) try: return str(eval(query)) except: return "Saya tidak bisa menghitung itu. Pastikan input Anda adalah ekspresi matematika yang valid."</p> <p># Buat contoh alat search = DuckDuckGoSearchRun() calculator = CalculatorTool()</p> <p># Tentukan alat tools = [Tool(name="Pencarian", func=search.run, description="Berguna untuk menjawab pertanyaan tentang peristiwa saat ini"), Tool(name="RAG-QA", func=qa.run, description="Berguna untuk menjawab pertanyaan tentang AI dan pembelajaran mesin"), Tool(name="Kalkulator", func=calculator._run, description="Berguna untuk melakukan perhitungan matematika") ]</p> <p># Inisialisasi agen agent = initialize_agent(tools, OpenAI(temperature=0), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True )</p>
Sekarang kita memiliki agen yang dapat menggunakan sistem RAG kita, melakukan pencarian web, dan melakukan perhitungan. Mari kita uji:
<p>result = agent.run("Apa perbedaan antara pembelajaran mesin yang diawasi dan tidak diawasi? Juga, apa 15% dari 80?") print(result)</p>
Agen ini menunjukkan kelebihan agen LLM: mereka dapat menggabungkan beberapa alat dan langkah penalaran untuk menjawab pertanyaan yang kompleks.
Meningkatkan Agen dengan Teknik RAG Lanjutan
Sementara sistem RAG kita saat ini bekerja dengan baik, ada beberapa teknik lanjutan yang dapat kita gunakan untuk meningkatkan kinerjanya:
a) Pencarian Semantik dengan Dense Passage Retrieval (DPR)
Sebagai gantinya menggunakan pengambilan berbasis penyimpanan sederhana, kita dapat mengimplementasikan DPR untuk pencarian semantik yang lebih akurat:
<p>from transformers import DPRQuestionEncoder, DPRContextEncoder</p> <p>question_encoder = DPRQuestionEncoder.from_pretrained("facebook/dpr-question_encoder-single-nq-base") context_encoder = DPRContextEncoder.from_pretrained("facebook/dpr-ctx_encoder-single-nq-base")</p> <p># Fungsi untuk mengkodekan passage def encode_passages(passages): return context_encoder(passages, max_length=512, return_tensors="pt").pooler_output</p> <p># Fungsi untuk mengkodekan query def encode_query(query): return question_encoder(query, max_length=512, return_tensors="pt").pooler_output</p>
b) Perluasan Query
Kita dapat menggunakan perluasan query untuk meningkatkan kinerja pengambilan:
<p>from transformers import T5ForConditionalGeneration, T5Tokenizer</p>
<p>model = T5ForConditionalGeneration.from_pretrained("t5-small")
tokenizer = T5Tokenizer.from_pretrained("t5-small")</p>
<p>def expand_query(query):
input_text = f"perluas query: {query}"
input_ids = tokenizer.encode(input_text, return_tensors="pt")
outputs = model.generate(input_ids, max_length=50, num_return_sequences=3)
expanded_queries = [tokenizer.decode(output, skip_special_tokens=True) for output in outputs]
return expanded_queries</p>
c) Peningkatan Iteratif
Kita dapat mengimplementasikan proses peningkatan iteratif di mana agen dapat mengajukan pertanyaan lanjutan untuk memperjelas atau memperluas pengambilan awal:
<p>def iterative_retrieval(initial_query, max_iterations=3):
query = initial_query
for _ in range(max_iterations):
result = qa.run(query)
clarification = agent.run(f"Berdasarkan hasil ini: '{result}', apa pertanyaan lanjutan yang harus saya ajukan untuk mendapatkan informasi yang lebih spesifik?")
if clarification.lower().strip() == "none":
break
query = clarification
return result</p>
# Gunakan ini dalam proses agen Anda
Mengimplementasikan Sistem Multi-Agen
Untuk menangani tugas yang lebih kompleks, kita dapat mengimplementasikan sistem multi-agen di mana agen yang berbeda berspesialisasi dalam bidang yang berbeda. Berikut adalah contoh sederhana:
<p>class SpecialistAgent:
def __init__(self, name, tools):
self.name = name
self.agent = initialize_agent(tools, OpenAI(temperature=0), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)</p>
<p>def run(self, query):
return self.agent.run(query)</p>
<p># Buat agen spesialis
research_agent = SpecialistAgent("Penelitian", [Tool(name="RAG-QA", func=qa.run, description="Untuk pertanyaan AI dan ML")])
math_agent = SpecialistAgent("Matematika", [Tool(name="Kalkulator", func=calculator._run, description="Untuk perhitungan")])
general_agent = SpecialistAgent("Umum", [Tool(name="Pencarian", func=search.run, description="Untuk pertanyaan umum")])</p>
<p>class Coordinator:
def __init__(self, agents):
self.agents = agents</p>
<p>def run(self, query):
# Tentukan agen mana yang digunakan
if "hitung" in query.lower() or any(op in query for op in ['+', '-', '*', '/']):
return self.agents['Matematika'].run(query)
elif any(term in query.lower() for term in ['ai', 'pembelajaran mesin', 'pembelajaran dalam']):
return self.agents['Penelitian'].run(query)
else:
return self.agents['Umum'].run(query)</p>
<p>coordinator = Coordinator({'Penelitian': research_agent, 'Matematika': math_agent, 'Umum': general_agent})</p>
<p># Uji sistem multi-agen
result = coordinator.run("Apa perbedaan antara CNN dan RNN? Juga, hitung 25% dari 120.")
print(result)</p>
Sistem multi-agen ini memungkinkan spesialisasi dan dapat menangani berbagai pertanyaan dengan lebih efektif.
Mengevaluasi dan Mengoptimalkan Agen RAG
Untuk memastikan agen RAG kita berkinerja dengan baik, kita perlu mengimplementasikan metrik evaluasi dan teknik optimasi:
a) Evaluasi Relevansi
Kita dapat menggunakan metrik seperti BLEU, ROUGE, atau BERTScore untuk mengevaluasi relevansi dokumen yang diambil:
from bert_score import score <p>def evaluate_relevance(query, retrieved_doc, generated_answer): P, R, F1 = score([generated_answer], [retrieved_doc], lang="en") return F1.mean().item()</p>
b) Evaluasi Kualitas Jawaban
Kita dapat menggunakan evaluasi manusia atau metrik otomatis untuk menilai kualitas jawaban:
<p>from nltk.translate.bleu_score import sentence_bleu</p> <p>def evaluate_answer_quality(reference_answer, generated_answer): return sentence_bleu([reference_answer.split()], generated_answer.split())</p> <p># Gunakan ini untuk mengevaluasi respons agen Anda
Arah Masa Depan dan Tantangan
Ketika kita melihat ke masa depan agen RAG, beberapa arah dan tantangan menarik muncul:
a) RAG Multi-Modal: Memperluas RAG untuk mengintegrasikan data gambar, audio, dan video.
b) RAG Terdistribusi: Mengimplementasikan RAG di atas basis pengetahuan yang terdistribusi dan menjaga privasi.
c) Pembelajaran Berkelanjutan: Mengembangkan metode untuk agen RAG memperbarui basis pengetahuan dan model mereka seiring waktu.
d) Pertimbangan Etis: Mengatasi bias, kesetaraan, dan transparansi dalam sistem RAG.
e) Skalabilitas: Mengoptimalkan RAG untuk aplikasi skala besar dan waktu nyata.
Kesimpulan
Membangun agen LLM untuk RAG dari awal adalah proses yang kompleks tetapi bermanfaat. Kita telah membahas dasar RAG, mengimplementasikan sistem sederhana, membuat agen LLM, meningkatkan dengan teknik lanjutan, menjelajahi sistem multi-agen, dan membahas strategi evaluasi dan optimasi.
