Orkestrasi agen LLM mengacu pada proses mengelola dan mengoordinasikan interaksi antara model bahasa besar (LLM) dan berbagai alat, API atau proses untuk melakukan berbagai tugas kompleks dalam sistem AI. Ini melibatkan penataan alur kerja di mana agen AI, yang didukung oleh kecerdasan buatan, bertindak sebagai pembuat keputusan atau mesin penalaran pusat, mengatur tindakannya berdasarkan input, konteks, dan output dari sistem eksternal. Menggunakan kerangka kerja orkestrasi, LLM dapat dengan lancar berintegrasi dengan API, basis data, dan aplikasi AI lainnya, yang memungkinkan fungsionalitas seperti chatbot dan alat otomatisasi. Kerangka kerja agen sumber terbuka semakin meningkatkan fleksibilitas sistem ini, membuat LLM lebih efektif dalam skenario dunia nyata.
Banyak orang salah memahami perbedaan antara orkestrasi LLM dan orkestrasi agen LLM. Ilustrasi berikut menyoroti perbedaan utama:
Dalam tutorial ini, Anda akan mempelajari cara membangun agen otonom yang didukung oleh model bahasa besar (LLM) menggunakan model IBM® Granite dan LangChain. Kita akan menjelajahi bagaimana agen memanfaatkan komponen kunci seperti memori, perencanaan, dan tindakan untuk melakukan berbagai tugas cerdas. Anda juga akan menerapkan sistem praktis yang memproses teks dari buku, menjawab kueri secara dinamis dan mengevaluasi kinerjanya menggunakan metrik akurasi seperti BLEU, presisi, recall, dan skor F1.
Kerangka kerja yang disajikan dalam gambar-1 memberikan desain holistik untuk agen otonom berbasis model bahasa besar (LLM), menekankan interaksi antara komponen utama: profil, memori, perencanaan, dan tindakan. Setiap komponen mewakili tahap penting dalam membangun agen otonom yang dapat menggunakan nalar, mengambil keputusan, dan berinteraksi dengan lingkungan dinamis.1
Kerangka kerja untuk agen otonom berbasis LLM
1. Profil: menentukan identitas agen
Profil memberikan identitas kepada agen dengan menanamkan informasi seperti data demografis, ciri kepribadian, dan konteks sosial. Proses ini memastikan bahwa agen dapat berinteraksi dengan cara yang dipersonalisasi. Profil dapat dibuat secara manual, dihasilkan oleh model gen AI seperti model Granite IBM atau GPT dari OpenAI (transformator generatif yang dilatih sebelumnya), atau diselaraskan dengan kumpulan data tertentu untuk memenuhi persyaratan tugas. Memanfaatkan rekayasa prompt, profil dapat disempurnakan secara dinamis untuk mengoptimalkan respons. Selain itu, dalam orkestrasi multiagen, profil membantu menentukan peran dan perilaku, memastikan koordinasi yang mulus di seluruh algoritma AI dan sistem pengambilan keputusan.
2. Memori: menyimpan dan menggunakan konteks
Memori membantu agen mempertahankan dan mengambil interaksi masa lalu yang memungkinkan respons kontekstual. Memori dapat disatukan (semua data di satu tempat) atau hybrid (terstruktur dan tidak terstruktur). Operasi yang meliputi membaca, menulis, dan merenung memungkinkan agen untuk belajar dari pengalaman dan memberikan output yang konsisten dan tepat. Memori yang terstruktur dengan baik meningkatkan orkestrasi multiagen dengan memastikan bahwa agen yang berbeda, termasuk agen khusus yang dirancang untuk tugas tertentu, dapat berbagi dan mengambil data yang relevan secara efisien. Dalam kerangka kerja seperti AutoGen dan Crew AI, memori memainkan peran penting dalam menjaga kontinuitas dalam ekosistem agen yang berkolaborasi, memastikan koordinasi yang mulus dan eksekusi tugas yang dioptimalkan.
3. Perencanaan: menyusun strategi tindakan
Komponen perencanaan memungkinkan agen menyusun strategi untuk mencapai tujuan. Komponen ini dapat mengikuti langkah-langkah yang telah ditentukan atau beradaptasi secara dinamis berdasarkan masukan dari lingkungan, manusia, atau LLM itu sendiri. Dengan mengintegrasikan algoritma AI dan memanfaatkan basis pengetahuan, perencanaan dapat dioptimalkan untuk meningkatkan efisiensi penalaran dan akurasi pemecahan masalah. Dalam aplikasi LLM, perencanaan memainkan peran penting dalam memastikan natural language understanding dan bahwa proses pengambilan keputusan selaras dengan tujuan agen. Selain itu, teknik pengambilan informasi yang ditingkatkan memperbaiki kemampuan agen untuk mengakses informasi yang relevan secara dinamis, sehingga meningkatkan akurasi respons. Fleksibilitas ini memastikan bahwa agen tetap efektif dalam skenario yang berubah-ubah, terutama dalam orkestrasi multiagen, di mana berbagai agen mengoordinasikan rencana mereka untuk mencapai tujuan kompleks sekaligus mempertahankan skalabilitas untuk menangani berbagai tugas besar dan beragam.
4. Tindakan: melaksanakan keputusan
Tindakan adalah cara agen berinteraksi dengan dunia, baik dengan menyelesaikan tugas, mengumpulkan informasi, atau berkomunikasi. Sistem ini menggunakan memori dan perencanaan untuk memandu eksekusi, menggunakan berbagai alat jika perlu, dan menyesuaikan keadaan internalnya berdasarkan hasil untuk perbaikan berkelanjutan. Mengoptimalkan algoritma eksekusi tindakan memastikan efisiensi, terutama ketika mengintegrasikan model penalaran yang didukung GPT dan teknik gen AI untuk pengambilan keputusan secara real-time.
Dengan menggabungkan semua komponen ini, kerangka kerja mengubah LLM menjadi agen yang dapat beradaptasi dan mampu menggunakan nalar, belajar, dan melakukan tugas secara mandiri. Desain modular ini membuatnya sangat cocok untuk aplikasi seperti layanan pelanggan, bantuan penelitian, dan pemecahan masalah kreatif.
Tutorial ini menunjukkan pembuatan agen pengetahuan yang dapat ditanya, yang dirancang untuk memproses dokumen teks besar (seperti buku) dan menjawab kueri pengguna dengan akurat. Menggunakan model IBM Granite dan LangChain, agen dibangun mengikuti prinsip yang diuraikan dalam kerangka kerja untuk agen otonom berbasis LLM. Komponen kerangka kerja ini selaras dengan lancar dengan alur kerja agen untuk memastikan adaptabilitas dan respons cerdas.
Mari kita pahami bagaimana kerangka kerja berlaku dalam contoh penggunaan kita.
Profil: Agen ini dirancang dengan profil "asisten pengetahuan", berfokus pada tugas perangkuman, menjawab pertanyaan, dan penalaran. Konteksnya dipersonalisasi untuk memproses dokumen tertentu (misalnya, The Adventures of Sherlock Holmes).
Memori: Agen menggunakan memori hybrid dengan menanamkan potongan buku ke dalam penyimpanan vektor FAISS. Kemampuan ini memungkinkannya untuk mengambil konteks yang relevan secara dinamis selama kueri diajukan. Operasi memori seperti membaca (pengambilan) dan menulis (memperbarui penanaman) memastikan bahwa agen dapat beradaptasi dengan kueri baru dari waktu ke waktu.
Perencanaan: Penyelesaian kueri melibatkan penalaran jalur tunggal. Agen mengambil potongan teks yang relevan, menghasilkan jawaban menggunakan Granite LLM dari IBM, dan mengevaluasi output untuk akurasi. Perencanaan tanpa masukan memastikan kesederhanaan, sementara modularitas sistem memungkinkan siklus masukan untuk diintegrasikan dalam iterasi mendatang.
Tindakan: Agen melaksanakan penyelesaian kueri dengan mengintegrasikan pengambilan memori dan pemrosesan LLM. Agen menyelesaikan berbagai tugas seperti menghasilkan jawaban, menghitung metrik akurasi (BLEU, presisi, recall, dan skor F1), dan memvisualisasikan hasil untuk ditafsirkan pengguna. Output ini mencerminkan kemampuan agen untuk bertindak cerdas berdasarkan penalaran dan perencanaan.
Anda memerlukan akun IBM® Cloud untuk membuat proyek watsonx.ai .
Langkah 1. Siapkan lingkungan Anda
Meskipun terdapat pilihan beberapa alat, tutorial ini akan memandu Anda untuk menyiapkan akun IBM menggunakan Jupyter Notebook.
- Masuk ke watsonx.ai menggunakan akun IBM Cloud Anda.
- 2. Buat proyek watsonx.ai. Anda bisa mendapatkan ID proyek dari dalam proyek Anda. Klik tab Kelola. Kemudian, salin ID proyek dari bagian Detail di halaman Umum. Anda memerlukan ID ini untuk tutorial ini.
- 3. Buat Jupyter Notebook.
Langkah ini akan membuka lingkungan notebook tempat Anda dapat menyalin kode dari tutorial ini. Atau, Anda dapat mengunduh aplikasi notebook ini ke sistem lokal Anda dan mengunggahnya ke proyek watsonx.ai sebagai aset. Untuk melihat tutorial Granite lain, lihat Komunitas Granite IBM. Tutorial ini juga tersedia di GitHub.
Langkah 2. Siapkan layanan waktu proses watsonx.ai dan kunci API
- Buat instans layanan Waktu Proses watsonx.ai (pilih paket Lite, yang merupakan instans gratis).
- Buat Kunci antarmuka pemrograman aplikasi (API).
- Kaitkan layanan Waktu Proses watsonx.ai ke proyek yang Anda buat di watsonx.ai.
Langkah 3. Penginstalan paket
Untuk bekerja dengan kerangka kerja LangChain dan mengintegrasikan IBM WatsonXLLM, kita perlu menginstal beberapa pustaka penting. Mari kita mulai dengan menginstal paket yang diperlukan:
Catatan: Jika Anda menggunakan versi lama
!pip install langchain faiss-cpu pandas sentence-transformers
%pip install langchain
!pip install langchain-ibm
Di sel kode sebelumnya,
LangChain adalah kerangka kerja inti untuk membangun aplikasi dengan model bahasa.faiss-cpu untuk pencarian kesamaan yang efisien, digunakan dalam membuat dan menanyakan indeks vektor.panda untuk manipulasi dan analisis data.sentence-transformers untuk menghasilkan menanamkan untuk pencarian semantik.langchain-ibm untuk mengintegrasikan IBM WatsonXLLM (dalam tutorial ini adalah granite-3-8b-instruct) dengan LangChain.
Langkah ini memastikan bahwa lingkungan Anda siap untuk berbagai tugas selanjutnya.
Langkah 4. Impor pustaka yang diperlukan
Sekarang setelah menginstal pustaka yang diperlukan, mari kita impor modul yang diperlukan untuk tutorial ini:
from langchain_ibm import WatsonxLLM
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import FAISS
from langchain.text_splitter import RecursiveCharacterTextSplitter
import pandas as pd
import getpass
Di sel kode sebelumnya,
os memberikan cara untuk berinteraksi dengan sistem operasi (misalnya, mengakses variabel lingkungan).langchain_ibm.WatsonxLLM memungkinkan kita untuk menggunakan IBM Watson Granite LLM dengan lancar dalam kerangka kerja LangChain.langchain.embeddings.HuggingFaceEmbeddings menghasilkan penanaman untuk teks menggunakan model HuggingFace, penting untuk pencarian semantik.langchain.vectorstores.FAISS adalah pustaka untuk penyimpanan vektor yang efisien dan pencarian kemiripan, memungkinkan kita untuk membangun dan menanyakan indeks vektor.RecursiveCharacterTextSplitter membantu membagi blok teks besar menjadi potongan lebih kecil, yang sangat penting untuk memproses dokumen secara efisien.panda adalah pustaka yang tangguh untuk analisis dan manipulasi data, digunakan di sini untuk menangani data tabular.getpass adalah cara aman untuk menangkap input sensitif seperti kunci API tanpa menampilkannya di layar.
Langkah ini menyiapkan semua alat dan modul yang kita butuhkan untuk memproses teks, membuat penanaman, menyimpannya dalam basis data vektor, dan berinteraksi dengan WatsonxLLM dari IBM.
Langkah 5. Siapkan kredensial
Kode ini menyiapkan kredensial untuk mengakses API IBM Watson machine learning (WML) dan memastikan bahwa ID proyek dikonfigurasi dengan benar.
- Kamus
kredensial dibuat denganURL layanan WML danKunci API . Kunci API dikumpulkan dengan aman menggunakan `getpass.getpass` untuk menghindari mengekspos informasi sensitif. - Kode mencoba mengambil
PROJECT_ID dari variabel lingkungan menggunakanos.environ . JikaPROJECT_ID tidak ditemukan, pengguna diminta untuk memasukkannya secara manual melalui input.
credentials = {
"url": "https://us-south.ml.cloud.ibm.com", # Replace with the correct region if needed
"apikey": getpass.getpass("Please enter your WML API key (hit enter): ")
}
# Set up project_id
try:
project_id = os.environ["PROJECT_ID"]
except KeyError:
project_id = input("Please enter your project_id (hit enter): ")
Langkah 6. Awali model bahasa besar
Kode ini mengawali IBM WatsonXLLM untuk digunakan dalam aplikasi:
- Kode ini membuat instans
WatsonxLLM menggunakanmodel ibm/granite-3-8b-instruct, yang dirancang untuk tugas AI generatif berbasis instruksi. - Kemampuan
URL ,kunci api danproject_id nilai dari kredensial yang telah disiapkan sebelumnya diteruskan untuk melakukan autentikasi dan terhubung ke layanan IBM WatsonXLLM. - Mengonfigurasi parameter
max_new_tokens untuk membatasi jumlah token yang dihasilkan oleh model di setiap respons (150 token dalam hal ini).
Langkah ini mempersiapkan WatsonXLLM untuk menghasilkan respons dalam alur kerja.
llm = WatsonxLLM(
model_id="ibm/granite-3-8b-instruct",
url=credentials["url"],
apikey=credentials["apikey"],
project_id=project_id,
params={
"max_new_tokens": 150
}
)
Langkah 7. Tentukan fungsi untuk mengekstrak teks dari file
Untuk memproses teks dari dokumen, kita memerlukan fungsi yang dapat membaca dan mengekstrak isinya. Fungsi berikut dirancang untuk menangani file teks biasa:
"""Extracts text from a plain text file."""
with open(file_path, "r", encoding="utf-8") as file:
text = file.read()
return text
Fungsi ini,
Seluruh konten file dibaca menjadi variabel bernama
Fungsi ini memungkinkan kita untuk memproses file input (The Adventures of Sherlock Holmes) dan mengekstrak kontennya untuk operasi lebih lanjut seperti pemotongan teks dan penanaman. Ini memastikan bahwa teks mentah tersedia untuk dianalisis.
Langkah 8. Pisahkan teks menjadi berbagai potongan
Untuk memproses dan mengindeks blok teks besar secara efisien, kita perlu membagi teks menjadi potongan yang lebih kecil dan dapat dikelola. Fungsi berikut menangani tugas ini:
"""Splits text into smaller chunks for indexing."""
splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
return splitter.split_text(text)
Kemampuan
Fungsi ini memastikan kelangsungan kontekstual di seluruh potongan. Fungsi ini memanfaatkan
Hal ini sangat penting saat bekerja dengan dokumen besar, karena model bahasa sering kali memiliki batasan token dan tidak dapat memproses teks yang panjang secara langsung.
Langkah 9: Buat indeks vektor
Untuk memungkinkan pencarian semantik yang efisien, kita perlu mengubah potongan teks menjadi penanaman vektor dan menyimpannya dalam indeks yang dapat dicari. Langkah ini menggunakan penanaman FAISS dan HuggingFace untuk membuat indeks vektor, yang menjadi dasar untuk mengambil informasi relevan berdasarkan kueri.
"""Creates a FAISS vector index from text chunks."""
embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
vector_store = FAISS.from_texts(chunks, embeddings)
return vector_store
Kemampuan
Pertama, awali model HuggingFaceEmbeddings
Fungsi tersebut kemudian menggunakan
Hasil penyimpanan vektor ditampilkan dan akan digunakan untuk menemukan potongan yang relevan berdasarkan kueri pengguna, menjadi fondasi bagi proses pencarian dan pengambilan data oleh agen.
Langkah 10. Kueri indeks vektor dengan Granite
Langkah ini melibatkan meminta indeks vektor untuk mengambil informasi yang relevan dan menggunakan Granite LLM IBM untuk menghasilkan respons yang disempurnakan. Dengan mengintegrasikan pencarian kemiripan dan penalaran LLM, fungsi ini menyediakan proses penyelesaian kueri yang dinamis dan cerdas.
"""Searches the vector index, uses Granite to refine the response, and returns all components."""
# Perform similarity search
print("\n> Entering new AgentExecutor chain...")
thought = f"The query '{query}' requires context from the book to provide an accurate response."
print(f" Thought: {thought}")
action = "Search FAISS Vector Store"
print(f" Action: {action}")
action_input = query
print(f" Action Input: \"{action_input}\"")
# Retrieve context
results = vector_store.similarity_search(query, k=3)
observation = "\n".join([result.page_content for result in results])
print(f" Observation:\n{observation}\n")
# Generate response with Granite
prompt = f"Context:\n{observation}\n\nQuestion: {query}\nAnswer:"
print(f" Thought: Combining retrieved context with the query to generate a detailed answer.")
final_answer = llm(prompt)
print(f" Final Answer: {final_answer.strip()}")
print("\n> Finished chain.")
# Return all components as a dictionary
return {
"Thought": thought,
"Action": action,
"Action Input": action_input,
"Observation": observation,
"Final Answer": final_answer.strip()
}
Kemampuan
Pencarian kemiripan akan dilakukan terlebih dahulu pada indeks vektor untuk mengambil potongan teks yang paling relevan. Semua potongan ini yang disebut sebagai
Fungsi kemudian membuat prompt dengan menggabungkan kueri dan konteks yang diambil. Prompt ini diteruskan ke
Sepanjang proses, langkah-langkah perantara seperti
Akhirnya, fungsi ini menampilkan sebuah kamus yang berisi semua komponen, termasuk proses berpikir, tindakan yang dilakukan, pengamatan yang diambil, dan jawaban akhir.
Langkah ini penting untuk mengubah pengambilan data mentah menjadi insight yang dapat ditindaklanjuti dan bermakna dengan menggunakan kemampuan penalaran LLM.
Langkah 11. Buat 'DataFrame' untuk hasil kueri
Langkah ini secara dinamis memproses beberapa kueri, mengambil informasi yang relevan, dan menyimpan hasil dalam format terstruktur untuk dianalisis. Fungsi ini mengintegrasikan kemampuan kueri, penyusunan data, dan ekspor.
"""Generates a DataFrame dynamically for multiple queries and saves it as a CSV file."""
# List to store all query outputs
output_data = []
# Process each query
for query in queries:
# Capture the output dynamically
output = query_index_with_granite_dynamic(vector_store, query, llm)
output_data.append(output)
# Convert the list of dictionaries into a DataFrame
df = pd.DataFrame(output_data)
# Display the DataFrame
print("\nFinal DataFrame:")
print(df)
# Save the DataFrame as a CSV file
df.to_csv(csv_filename, index=False)
print(f"\nOutput saved to {csv_filename}")
Kemampuan
Untuk setiap kueri menggunakan
Setelah semua kueri diproses, daftar hasil diubah menjadi panel data DataFrame. Format tabel ini memungkinkan analisis dan visualisasi hasil kueri yang mudah. DataFrame dicetak untuk ditinjau dan disimpan sebagai file CSV untuk digunakan pada masa mendatang.
Langkah ini sangat penting untuk menata output dalam format yang mudah digunakan, sehingga memudahkan berbagai tugas selanjutnya seperti evaluasi akurasi dan visualisasi.
Langkah 12: Jalankan alur kerja utama
Langkah ini menggabungkan semua langkah sebelumnya ke dalam satu alur kerja untuk memproses file teks, menjawab kueri pengguna, dan menyimpan hasil dalam format terstruktur. Fungsi
# Replace with your text file
file_path = "aosh.txt"
# Extract text from the text file
text = extract_text_from_txt(file_path)
# Split the text into chunks
chunks = split_text_into_chunks(text)
# Create a vector index
vector_store = create_vector_index(chunks)
# Define queries
queries = [
"What is the plot of 'A Scandal in Bohemia'?",
"Who is Dr. Watson, and what role does he play in the stories?",
"Describe the relationship between Sherlock Holmes and Irene Adler.",
"What methods does Sherlock Holmes use to solve cases?"
]
# Generate and save output dynamically
dynamic_output_to_dataframe(vector_store, queries, llm)
Mari kita pahami bagaimana alur kerja ini dijalankan:
Masukkan file teks:
Ekstraksi teks:
Pemotongan teks: Teks yang diekstrak dibagi menjadi potongan yang lebih kecil menggunakan
Buat indeks vektor: Potongan teks diubah menjadi penanaman dan disimpan dalam
Tetapkan kueri: Daftar sampel kueri disediakan, masing-masing dirancang untuk mengambil informasi spesifik dari teks. Kueri ini akan dijawab oleh agen.
Proses kueri: Fungsi
Langkah ini mengintegrasikan semua komponen tutorial ke dalam alur kerja yang kohesif. Langkah ini mengotomatiskan proses dari ekstraksi teks ke penyelesaian kueri, sehingga Anda dapat menguji kemampuan agen dan memeriksa hasil dalam format terstruktur.
Untuk menjalankan alur kerja, cukup panggil
main_workflow()
Output
> Entering new AgentExecutor chain... Thought: The query 'What is the plot of 'A Scandal in Bohemia'?' requires context from the book to provide an accurate response. Action: Search FAISS Vector Store Action Input: "What is the plot of 'A Scandal in Bohemia'?" Observation: I. A SCANDAL IN BOHEMIA I. “I was aware of it,” said Holmes dryly. “The circumstances are of great delicacy, and every precaution has to be taken to quench what might grow to be an immense scandal and seriously compromise one of the reigning families of Europe. To speak plainly, the matter implicates the great House of Ormstein, hereditary kings of Bohemia.” “I was also aware of that,” murmured Holmes, settling himself down in his armchair and closing his eyes. Contents I. A Scandal in Bohemia II. The Red-Headed League III. A Case of Identity IV. The Boscombe Valley Mystery V. The Five Orange Pips VI. The Man with the Twisted Lip VII. The Adventure of the Blue Carbuncle VIII. The Adventure of the Speckled Band IX. The Adventure of the Engineer’s Thumb X. The Adventure of the Noble Bachelor XI. The Adventure of the Beryl Coronet XII. The Adventure of the Copper Beeches Thought: Combining retrieved context with the query to generate a detailed answer. /var/folders/4w/smh16qdx6l98q0534hr9v52r0000gn/T/ipykernel_2648/234523588.py:23: LangChainDeprecationWarning: The method `BaseLLM.__call__` was deprecated in langchain-core 0.1.7 and will be removed in 1.0. Use :meth:`~invoke` instead. final_answer = llm(prompt) Final Answer: Step 1: Identify the main characters and their roles. - Sherlock Holmes: The detective who is approached by a client with a delicate matter. - An unnamed client: A representative of the great House of Ormstein, hereditary kings of Bohemia, who seeks Holmes' help to prevent a potential scandal. Step 2: Understand the main issue or conflict. - The main issue is a delicate matter that, if exposed, could lead to a massive scandal and compromise one of the reigning families of Europe, specifically the House of Ormstein. Step 3: Ident > Finished chain. > Entering new AgentExecutor chain... Thought: The query 'Who is Dr. Watson, and what role does he play in the stories?' requires context from the book to provide an accurate response. Action: Search FAISS Vector Store Action Input: "Who is Dr. Watson, and what role does he play in the stories?" Observation: “Sarasate plays at the St. James’s Hall this afternoon,” he remarked. “What do you think, Watson? Could your patients spare you for a few hours?” “I have nothing to do to-day. My practice is never very absorbing.” “Try the settee,” said Holmes, relapsing into his armchair and putting his fingertips together, as was his custom when in judicial moods. “I know, my dear Watson, that you share my love of all that is bizarre and outside the conventions and humdrum routine of everyday life. You have shown your relish for it by the enthusiasm which has prompted you to chronicle, and, if you will excuse my saying so, somewhat to embellish so many of my own little adventures.” “My God! It’s Watson,” said he. He was in a pitiable state of reaction, with every nerve in a twitter. “I say, Watson, what o’clock is it?” “Nearly eleven.” “Of what day?” “Of Friday, June 19th.” “Good heavens! I thought it was Wednesday. It is Wednesday. What d’you want to frighten a chap for?” He sank his face onto his arms and began to sob in a high treble key. “I tell you that it is Friday, man. Your wife has been waiting this two days for you. You should be ashamed of yourself!” Thought: Combining retrieved context with the query to generate a detailed answer. Final Answer: Dr. Watson is a character in the Sherlock Holmes stories, written by Sir Arthur Conan Doyle. He is a former military surgeon who becomes the narrator and chronicler of Holmes' adventures. Watson is a close friend and confidant of Holmes, often accompanying him on cases and providing a more human perspective to the stories. He is known for his enthusiasm for the bizarre and unconventional, as well as his skill in recording the details of their investigations. Watson's role is crucial in presenting the narrative and offering insights into Holmes' character and methods. > Finished chain. Final DataFrame: Thought \ 0 The query 'What is the plot of 'A Scandal in B... 1 The query 'Who is Dr. Watson, and what role do... 2 The query 'Describe the relationship between S... 3 The query 'What methods does Sherlock Holmes u... Action \ 0 Search FAISS Vector Store 1 Search FAISS Vector Store 2 Search FAISS Vector Store 3 Search FAISS Vector Store Action Input \ 0 What is the plot of 'A Scandal in Bohemia'? 1 Who is Dr. Watson, and what role does he play ... 2 Describe the relationship between Sherlock Hol... 3 What methods does Sherlock Holmes use to solve... Observation \ 0 I. A SCANDAL IN BOHEMIA\n\n\nI.\n“I was aware ... 1 “Sarasate plays at the St. James’s Hall this a... 2 “You have really got it!” he cried, grasping S... 3 to learn of the case was told me by Sherlock H... Final Answer 0 Step 1: Identify the main characters and their... 1 Dr. Watson is a character in the Sherlock Holm... 2 Sherlock Holmes and Irene Adler have a profess... 3 Sherlock Holmes uses a variety of methods to s... Output saved to output.csv
Setelah menjalankan
- Pemikiran menggambarkan penalaran di balik kueri dan konteks yang diperlukan untuk menjawabnya dengan akurat.
- Tindakan menunjukkan langkah yang diambil, dalam hal ini melakukan pencarian kemiripan menggunakan indeks vektor FAISS.
- Input tindakan adalah kueri spesifik yang diproses dalam satu iterasi.
- Pengamatan adalah potongan teks yang diambil dari indeks vektor yang relevan dengan kueri.
- Jawaban akhir adalah respons terperinci yang dihasilkan oleh Granite LLM IBM dengan menggunakan konteks yang diambil.
Selain itu, hasil untuk semua kueri telah disusun menjadi DataFrame dan disimpan sebagai
Dalam proses ini, kami menggabungkan pengambilan teks dengan penalaran LLM untuk menjawab pertanyaan kompleks tentang buku tersebut. Agen mengambil informasi yang relevan secara dinamis, menggunakan konteks untuk menghasilkan jawaban yang akurat, dan menyusun output dalam format terstruktur untuk memudahkan analisis.
Dengan output yang dibuat, kita sekarang akan melanjutkan untuk memvisualisasikan hasil kueri dan metrik akurasi terkait sehingga memberikan insight yang lebih dalam tentang kinerja agen.
Di sel kode berikut, kita memuat hasil kueri yang disimpan dari
df = pd.read_csv("output.csv")
print(df.head()) # Display the first few rows
OUTPUT
Thought \ 0 The query 'What is the plot of 'A Scandal in B... 1 The query 'Who is Dr. Watson, and what role do... 2 The query 'Describe the relationship between S... 3 The query 'What methods does Sherlock Holmes u... Action \ 0 Search FAISS Vector Store 1 Search FAISS Vector Store 2 Search FAISS Vector Store 3 Search FAISS Vector Store Action Input \ 0 What is the plot of 'A Scandal in Bohemia'? 1 Who is Dr. Watson, and what role does he play ... 2 Describe the relationship between Sherlock Hol... 3 What methods does Sherlock Holmes use to solve... Observation \ 0 I. A SCANDAL IN BOHEMIA\n\n\nI.\n“I was aware ... 1 “Sarasate plays at the St. James’s Hall this a... 2 “You have really got it!” he cried, grasping S... 3 to learn of the case was told me by Sherlock H... Final Answer 0 Step 1: Identify the main characters and their... 1 Dr. Watson is a character in the Sherlock Holm... 2 Sherlock Holmes and Irene Adler have a profess... 3 Sherlock Holmes uses a variety of methods to s...
Dalam kode ini, DataFrame menyertakan komponen utama seperti
Impor pustaka visualisasi
Untuk membuat visualisasi hasil kueri, kita mengimpor pustaka yang diperlukan:
from wordcloud import WordCloud
Catatan penting: Jika Anda menemui kesalahan
Visualisasikan pengamatan dan panjang jawaban
Kode ini membuat diagram batang horizontal untuk membandingkan panjang pengamatan (konteks yang diambil) dan jawaban (tanggapan yang dihasilkan) untuk setiap kueri. Visualisasi ini memberikan insight tentang seberapa banyak konteks yang digunakan agen dibandingkan dengan panjang jawaban yang dibuat.
"""Visualizes the lengths of observations and answers with queries on the y-axis."""
df["Observation Length"] = df["Observation"].apply(len)
df["Answer Length"] = df["Final Answer"].apply(len)
# Extract relevant data
queries = df["Action Input"]
observation_lengths = df["Observation Length"]
answer_lengths = df["Answer Length"]
# Create a horizontal bar chart
plt.figure(figsize=(10, 6))
bar_width = 0.4
y_pos = range(len(queries))
plt.barh(y_pos, observation_lengths, bar_width, label="Observation Length", color="skyblue", edgecolor="black")
plt.barh([y + bar_width for y in y_pos], answer_lengths, bar_width, label="Answer Length", color="lightgreen", edgecolor="black")
plt.yticks([y + bar_width / 2 for y in y_pos], queries, fontsize=10)
plt.xlabel("Length (characters)", fontsize=14)
plt.ylabel("Queries", fontsize=14)
plt.title("Observation and Answer Lengths by Query", fontsize=16)
plt.legend(fontsize=12)
plt.tight_layout()
plt.show()
visualize_lengths_with_queries(df)
Fungsi ini,
Fungsi ini menghitung panjang karakter dari pengamatan dan jawaban, menambahkannya sebagai kolom baru (
Grafik batang ini menggunakan kode warna untuk membedakan antara durasi pengamatan dan panjang jawaban, serta dilengkapi dengan label, legenda, dan judul untuk kejelasan.
Visualisasi ini membantu menganalisis keseimbangan antara ukuran konteks yang diambil dan tingkat detail dalam respons yang dibuat, memberikan insight tentang cara agen memproses dan merespons kueri.
Visualisasikan proporsi teks yang digunakan dalam pengamatan
Langkah ini menggambarkan berapa banyak teks total yang diproses oleh agen yang digunakan dalam pengamatan (konteks yang diambil) dibandingkan dengan teks yang tersisa. Diagram lingkaran dibuat untuk memberikan representasi intuitif dari proporsi.
"""Visualizes the proportion of text used in observations."""
total_text_length = sum(df["Observation"].apply(len)) + sum(df["Final Answer"].apply(len))
observation_text_length = sum(df["Observation"].apply(len))
sizes = [observation_text_length, total_text_length - observation_text_length]
labels = ["Observation Text", "Remaining Text"]
colors = ["#66b3ff", "#99ff99"]
plt.figure(figsize=(4, 4))
plt.pie(sizes, labels=labels, colors=colors, autopct="%1.1f%%", startangle=140)
plt.title("Proportion of Text Used in Observations", fontsize=16)
plt.show()
visualize_text_proportion(df)
Kemampuan
Data ini divisualisasikan dalam diagram lingkaran dengan label yang jelas untuk
Visualisasi ini memberikan gambaran umum tingkat tinggi tentang berapa banyak teks yang digunakan agen sebagai konteks selama pemrosesan kueri, sehingga memberikan insight tentang efisiensi dan fokus proses pengambilan informasi.
Buat awan kata untuk pengamatan dan jawaban akhir
Kode ini menghasilkan dua awan kata untuk menampilkan secara visual kata-kata yang paling sering muncul dalam
"""Generates and displays word clouds for Observations and Final Answers side by side."""
# Combine text for Observations and Final Answers
observation_text = " ".join(df["Observation"])
final_answer_text = " ".join(df["Final Answer"])
# Create word clouds
observation_wordcloud = WordCloud(width=800, height=400, background_color="white").generate(observation_text)
final_answer_wordcloud = WordCloud(width=800, height=400, background_color="white").generate(final_answer_text)
# Create a side-by-side visualization
plt.figure(figsize=(16, 8))
# Plot the Observation word cloud
plt.subplot(1, 2, 1)
plt.imshow(observation_wordcloud, interpolation="bilinear")
plt.axis("off")
plt.title("Word Cloud of Observations", fontsize=16)
# Plot the Final Answer word cloud
plt.subplot(1, 2, 2)
plt.imshow(final_answer_wordcloud, interpolation="bilinear")
plt.axis("off")
plt.title("Word Cloud of Final Answers", fontsize=16)
plt.tight_layout()
plt.show()
generate_wordclouds_side_by_side(df)
Kode ini menghasilkan dua awan kata untuk menampilkan secara visual kata-kata yang paling sering muncul dalam
Untuk membuat visualisasi berdampingan, subplot digunakan: subplot pertama menampilkan awan kata untuk
Di bagian ini, kita mengevaluasi kinerja agen menggunakan beberapa metrik akurasi:
Impor pustaka yang diperlukan
Sebelum memulai pengujian, kita mengimpor pustaka yang diperlukan untuk mengevaluasi akurasi.
from nltk.translate.bleu_score import sentence_bleu
from sklearn.metrics import precision_score, recall_score
Pustaka ini mencakup alat untuk pencocokan kata kunci, perhitungan skor BLEU, evaluasi presisi dan recall. Pastikan Anda telah menginstal pustaka ini di lingkungan Anda untuk menghindari kesalahan pengimporan.
Akurasi pencocokan kata kunci
Tes ini mengevaluasi seberapa baik jawaban yang dibuat menyertakan kata kunci dari kueri. Tes ini menggunakan
"""Checks if key phrases from the query are present in the final answer."""
vectorizer = CountVectorizer(stop_words='english')
def check_keywords(query, answer):
query_keywords = set(vectorizer.build_tokenizer()(query.lower()))
answer_keywords = set(vectorizer.build_tokenizer()(answer.lower()))
common_keywords = query_keywords & answer_keywords
return len(common_keywords) / len(query_keywords) # Proportion of matched keywords
df["Keyword Match Score"] = df.apply(lambda row: check_keywords(row["Action Input"], row["Final Answer"]), axis=1)
df["Is Accurate"] = df["Keyword Match Score"] >= 0.5 # Set a threshold for accuracy
return df
df = keyword_matching_accuracy(df)
df.to_csv("output_with_accuracy.csv", index=False)
df
Perhitungan skor BLEU
Pengujian ini mengukur sejauh mana jawaban yang dibuat cocok dengan pengamatan yang diambil.
"""Calculates BLEU scores for answers against observations."""
df["BLEU Score"] = df.apply(
lambda row: sentence_bleu([row["Observation"].split()], row["Final Answer"].split()),
axis=1
)
return df
df = calculate_bleu_scores(df)
df.to_csv("output_with_bleu.csv", index=False)
Presisi dan recall
Presisi dan recall dihitung untuk mengevaluasi relevansi dan kelengkapan jawaban. Presisi mengukur proporsi kata-kata diambil yang relevan dalam jawaban, sementara recall mengukur proporsi kata-kata relevan dalam pengamatan yang muncul dalam jawaban.
Metrik ini ditambahkan ke DataFrame di bawah
"""Calculates precision and recall for extractive answers."""
def precision_recall(observation, answer):
observation_set = set(observation.lower().split())
answer_set = set(answer.lower().split())
precision = len(observation_set & answer_set) / len(answer_set) if answer_set else 0
recall = len(observation_set & answer_set) / len(observation_set) if observation_set else 0
return precision, recall
df[["Precision", "Recall"]] = df.apply(
lambda row: pd.Series(precision_recall(row["Observation"], row["Final Answer"])),
axis=1
)
return df
df = calculate_precision_recall(df)
df.to_csv("output_with_precision_recall.csv", index=False)
df
Perhitungan skor F1
Skor F1 menggabungkan presisi dan recall menjadi satu metrik tunggal, memberikan evaluasi yang seimbang atas relevansi dan kelengkapan. Rumus untuk skor F1 adalah:
Skor
"""Calculates F1 scores based on precision and recall."""
df["F1 Score"] = 2 * (df["Precision"] * df["Recall"]) / (df["Precision"] + df["Recall"])
df["F1 Score"].fillna(0, inplace=True) # Handle divide by zero
return df
df = calculate_f1(df)
df.to_csv("output_with_f1.csv", index=False)
df
Rangkum metrik akurasi
Terakhir, fungsi ringkasan mengonsolidasikan semua metrik untuk memberikan gambaran umum tentang kinerja agen. Fungsi ini menghitung jumlah total kueri, jumlah dan persentase respons yang akurat, serta skor rata-rata BLEU dan F1.
"""Summarizes overall accuracy metrics."""
total_entries = len(df)
accurate_entries = df["Is Accurate"].sum()
average_bleu = df["BLEU Score"].mean()
average_f1 = df["F1 Score"].mean()
print(f"Total Entries: {total_entries}")
print(f"Accurate Entries: {accurate_entries} ({accurate_entries / total_entries * 100:.2f}%)")
print(f"Average BLEU Score: {average_bleu:.2f}")
print(f"Average F1 Score: {average_f1:.2f}")
summarize_accuracy_metrics(df)
OUTPUT
Total Entries: 4 Accurate Entries: 4 (100.00%) Average BLEU Score: 0.04 Average F1 Score: 0.24
Tes akurasi ini menawarkan evaluasi terperinci tentang kemampuan agen untuk membuat respons yang relevan dan akurat. Setiap tes berfokus pada aspek tertentu, mulai dari penyertaan kata kunci hingga kemiripan teks dan kelengkapan respons. Ringkasan mengonsolidasikan metrik ini untuk memberikan cuplikan kinerja secara keseluruhan.
Tutorial ini memandu Anda untuk membangun agen otonom yang didukung oleh Granite LLM dan LangChain IBM. Mulai dari ekstraksi teks hingga vektorisasi dan penyelesaian kueri, kami telah mencakup seluruh proses desain dan implementasi agen berbasis LLM yang berfungsi. Langkah-langkah utama termasuk manajemen memori dengan penyimpanan vektor, pemrosesan kueri, dan pembuatan respons menggunakan Granite.
Kita mengevaluasi kinerja agen dengan menggunakan metrik akurasi seperti pencocokan kata kunci, skor BLEU, presisi, recall, dan skor F1. Visualisasi seperti diagram batang, diagram lingkaran, dan awan kata memberikan insight tambahan mengenai perilaku dan efektivitas agen.
Dengan menyelesaikan tutorial ini, Anda mempelajari cara merancang, menguji, dan memvisualisasikan kinerja agen LLM. Fondasi ini dapat diperluas untuk menangani kumpulan data yang lebih kompleks, meningkatkan akurasi, dan menjelajahi berbagai fitur canggih seperti sistem multiagen.
Sumber daya
Bangun, terapkan, dan kelola asisten dan agen AI yang kuat yang mengotomatiskan alur kerja dan proses dengan AI generatif.
Bangun masa depan bisnis Anda dengan solusi AI yang dapat Anda percaya.
Layanan IBM Consulting AI membantu merancang ulang cara kerja bisnis dengan AI untuk transformasi.