Panduan muktamad untuk Retrieval-Augmented Generation (RAG)

Evolusi pesat model AI generatif seperti OpenAI's ChatGPT telah merevolusikan pemprosesan bahasa semula jadi, membolehkan sistem ini menjana tindak balas yang koheren dan berkaitan kontekstual. Walau bagaimanapun, walaupun model terkini menghadapi had apabila menangani pertanyaan khusus domain atau memberikan maklumat yang sangat tepat. Ini selalunya membawa kepada cabaran seperti halusinasi — contoh di mana model menghasilkan butiran yang tidak tepat atau rekaan.

Retrieval-Augmented Generation (RAG), rangka kerja inovatif yang direka untuk merapatkan jurang ini. Dengan menyepadukan sumber data luaran dengan lancar, RAG memperkasakan model generatif untuk mendapatkan maklumat masa nyata, khusus, meningkatkan ketepatan dan kebolehpercayaan dengan ketara.

Dalam artikel ini, kita akan menyelami mekanik RAG, meneroka seni binanya dan membincangkan batasan model generatif tradisional yang memberi inspirasi kepada penciptaannya. Kami juga akan menyerlahkan pelaksanaan praktikal, teknik lanjutan dan kaedah penilaian, mempamerkan cara RAG mengubah cara AI berinteraksi dengan data khusus.

Bermula

Jadual kandungan

• Apa itu RAG
• Seni bina RAG
• Aliran Proses RAG
• RAG lwn Penalaan halus
• Jenis RAG
• Aplikasi RAG
• Membina sistem sembang PDF dengan RAG
• Sumber

Apa itu RAG

Retrieval-Augmented Generation (RAG) ialah rangka kerja lanjutan yang meningkatkan keupayaan model AI generatif dengan menyepadukan pengambilan semula masa nyata data luaran. Walaupun model generatif cemerlang dalam menghasilkan teks seperti manusia yang koheren, mereka boleh goyah apabila diminta memberikan maklumat yang tepat, terkini atau khusus domain. Di sinilah RAG melangkah masuk, memastikan bahawa respons bukan sahaja kreatif tetapi juga berasaskan sumber yang boleh dipercayai dan berkaitan.

RAG beroperasi dengan menyambungkan model generatif dengan mekanisme perolehan semula, biasanya dikuasakan oleh pangkalan data vektor atau sistem carian. Apabila pertanyaan diterima, komponen perolehan mencari melalui set data luaran yang luas untuk mendapatkan maklumat yang berkaitan. Model generatif kemudiannya mensintesis data ini, menghasilkan output yang tepat dan berwawasan kontekstual.

Dengan menangani cabaran utama seperti halusinasi dan pengetahuan domain terhad, RAG membuka potensi model generatif untuk cemerlang dalam bidang khusus. Aplikasinya merangkumi pelbagai industri, daripada mengautomasikan sokongan pelanggan dengan jawapan yang tepat, membolehkan penyelidik mengakses pengetahuan yang dipilih susun atas permintaan. RAG mewakili satu langkah ke hadapan yang penting dalam menjadikan sistem AI lebih pintar, boleh dipercayai dan berguna dalam senario dunia sebenar.

Seni bina RAG

Pemahaman yang jelas tentang seni bina RAG adalah penting untuk membuka kunci potensi dan faedah penuhnya. Pada terasnya, rangka kerja ini dibina pada dua komponen utama: Retriever dan Generator, bekerja bersama dalam aliran pemprosesan maklumat yang lancar.

Proses keseluruhan ini digambarkan di bawah:

sumber: https://weaviate.io/blog/introduction-to-rag

• Pendapatan semula — Peringkat inferens dalam RAG bermula dengan perolehan semula, di mana data yang berkaitan dengan pertanyaan pengguna diambil daripada sumber pengetahuan luaran. Dalam persediaan RAG asas, carian persamaan biasanya digunakan, membenamkan pertanyaan dan data luaran ke dalam ruang vektor yang sama untuk mengenal pasti padanan terdekat. Retriever memainkan peranan penting dalam mengambil dokumen, menggunakan kaedah seperti Retrieval Jarang dan Retrieval Padat. Pendapatan Jarang, menggunakan teknik seperti TF-IDF atau BM25, bergantung pada padanan perkataan yang tepat tetapi bergelut dengan sinonim dan parafrasa manakala Pendapatan Padat memanfaatkan model pengubah seperti BERT atau RoBERTa untuk mencipta perwakilan vektor semantik, membolehkan padanan yang lebih tepat dan bernuansa.
• Pembesaran — Selepas mendapatkan titik data yang paling berkaitan daripada sumber luaran, proses pembesaran menggabungkan maklumat ini dengan membenamkannya ke dalam templat gesaan yang dipratentukan.
• Penjanaan — Dalam fasa penjanaan, model menggunakan gesaan tambahan untuk menghasilkan respons yang koheren dan tepat dari segi konteks dengan menggabungkan pemahaman bahasa dalamannya dengan data luaran yang diperoleh semula. Walaupun penambahan menyepadukan fakta luaran, penjanaan mengubah maklumat yang diperkaya ini menjadi teks semula jadi seperti manusia yang disesuaikan dengan pertanyaan pengguna.

Aliran proses RAG

Semua peringkat dan komponen penting aliran proses RAG, digambarkan dalam rajah di bawah.

sumber: https://www.griddynamics.com/blog/retrieval-augmented-generation-llm

• Pemuatan Dokumen: Langkah pertama dalam proses RAG melibatkan penyediaan data, yang termasuk memuatkan dokumen daripada storan, mengekstrak, menghuraikan, membersihkan dan memformat teks untuk pemisahan dokumen. Data teks boleh datang dalam pelbagai format, seperti teks biasa, PDF, dokumen Word, CSV, JSON, HTML, Markdown atau kod pengaturcaraan. Menyediakan pelbagai sumber untuk LLM ini biasanya memerlukan menukarnya kepada teks biasa melalui pengekstrakan, penghuraian dan pembersihan.
• Pembahagian Dokumen: Dokumen dibahagikan kepada segmen yang lebih kecil dan boleh diurus melalui pemisahan teks atau penggumpalan, yang penting untuk mengendalikan dokumen besar dan mematuhi had token dalam LLM (cth., token 2048 GPT-3). Strategi termasuk pemotongan saiz tetap atau sedar kandungan, dengan pendekatan bergantung pada struktur dan keperluan data.

Membahagikan dokumen kepada bahagian yang lebih kecil mungkin kelihatan mudah, tetapi ia memerlukan pertimbangan semantik yang teliti untuk mengelakkan pembahagian ayat secara tidak wajar, yang boleh menjejaskan langkah seterusnya seperti menjawab soalan. Pendekatan chunking bersaiz tetap yang naif boleh mengakibatkan maklumat tidak lengkap dalam setiap bongkah. Kebanyakan algoritma pembahagian dokumen menggunakan saiz bongkah dan bertindih, dengan saiz bongkah ditentukan oleh aksara, perkataan atau kiraan token, dan bertindih memastikan kesinambungan dengan berkongsi teks antara bongkah bersebelahan. Strategi ini mengekalkan konteks semantik merentas bahagian.

• Pembenaman Teks: Potongan teks diubah menjadi pembenaman vektor, yang mewakili setiap bongkah dengan cara yang membolehkan perbandingan mudah persamaan semantik. Pembenaman vektor memetakan data kompleks, seperti teks, ke dalam ruang matematik di mana titik data yang serupa berkumpul bersama. Proses ini menangkap makna semantik teks, jadi ayat dengan makna yang sama, walaupun perkataan berbeza, dipetakan rapat dalam ruang vektor. Contohnya, "Kucing mengejar tikus" dan "Kucing mengejar tikus" akan dipetakan ke titik berdekatan walaupun perkataannya berbeza.

sumber: https://www.griddynamics.com/blog/retrieval-augmented-generation-llm

• Kedai vektor: Selepas dokumen dibahagikan dan ditukarkan kepada pembenaman vektor, ia disimpan dalam stor vektor, pangkalan data khusus untuk menyimpan dan mengurus vektor. Stor vektor membolehkan carian cekap untuk vektor serupa, yang penting untuk pelaksanaan model RAG. Pemilihan stor vektor bergantung pada faktor seperti skala data dan sumber pengiraan yang tersedia.

Beberapa pangkalan data vektor yang penting ialah:

• FAISS: Dibangunkan oleh Facebook AI, FAISS menguruskan koleksi besar vektor dimensi tinggi dengan cekap dan melakukan carian persamaan dan pengelompokan dalam persekitaran dimensi tinggi. Ia mengoptimumkan penggunaan memori dan tempoh pertanyaan, menjadikannya sesuai untuk mengendalikan berbilion-bilion vektor.
• Chroma: Pangkalan data vektor dalam memori sumber terbuka, Chroma direka untuk aplikasi LLM, menawarkan platform berskala untuk penyimpanan, carian dan pengambilan vektor. Ia menyokong penggunaan awan dan di premis serta serba boleh dalam mengendalikan pelbagai jenis dan format data.
• Weaviate: Pangkalan data vektor sumber terbuka yang boleh dihoskan sendiri atau diurus sepenuhnya. Ia menumpukan pada prestasi tinggi, kebolehskalaan dan fleksibiliti, menyokong pelbagai jenis data dan aplikasi. Ia membenarkan penyimpanan kedua-dua vektor dan objek, membolehkan gabungan teknik carian berasaskan vektor dan kata kunci.
• Pinecone: Pangkalan data vektor terurus berasaskan awan yang direka untuk memudahkan pembangunan dan penggunaan aplikasi ML berskala besar. Tidak seperti kebanyakan pangkalan data vektor, Pinecone menggunakan proprietari, kod sumber tertutup. Ia cemerlang dalam mengendalikan vektor berdimensi tinggi dan sesuai untuk aplikasi seperti carian persamaan, sistem pengesyoran, pemperibadian dan carian semantik. Pinecone juga mempunyai keupayaan penapisan satu peringkat.
• Pendapatan dokumen: Proses mendapatkan semula dalam sistem perolehan maklumat, seperti carian dokumen atau menjawab soalan, bermula apabila pertanyaan diterima dan diubah menjadi vektor menggunakan model pembenaman yang sama seperti pengindeksan dokumen. Matlamatnya adalah untuk mengembalikan ketulan dokumen yang berkaitan dengan membandingkan vektor pertanyaan dengan vektor ketulan yang disimpan dalam indeks (kedai vektor). Peranan retriever adalah untuk mengenal pasti dan mengembalikan ID ketulan dokumen yang berkaitan, tanpa menyimpan dokumen. Pelbagai kaedah carian boleh digunakan, seperti carian persamaan (berdasarkan kesamaan kosinus) dan perolehan semula berasaskan ambang, yang hanya mengembalikan dokumen yang melebihi skor persamaan tertentu. Selain itu, perolehan semula bantuan LLM berguna untuk pertanyaan yang melibatkan penapisan kandungan dan metadata.

sumber: https://www.griddynamics.com/blog/retrieval-augmented-generation-llm

• Penjanaan jawapan: Dalam proses mendapatkan semula, ketulan dokumen yang berkaitan digabungkan dengan pertanyaan pengguna untuk menjana konteks dan gesaan untuk LLM. Pendekatan yang paling mudah, yang dipanggil kaedah "Stuff" dalam LangChain, melibatkan penyaluran semua bahagian ke dalam tetingkap konteks yang sama untuk jawapan yang langsung dan mudah. Walau bagaimanapun, kaedah ini bergelut dengan volum dokumen yang besar dan pertanyaan kompleks disebabkan oleh had tetingkap konteks. Untuk menangani perkara ini, kaedah alternatif seperti Map-reduce, Refine, dan Map-rerank digunakan. Map-reduce menghantar dokumen secara berasingan ke LLM, kemudian menggabungkan respons. Tapis secara berulang mengemas kini gesaan untuk memperhalusi jawapan, manakala Map-rerank menyusun dokumen berdasarkan perkaitan, sesuai untuk berbilang jawapan yang menarik.

RAG vs Penalaan halus

RAG (Retrieval-Augmented Generation) dan penalaan halus ialah dua kaedah utama untuk melanjutkan keupayaan LLM, setiap satunya sesuai dengan senario yang berbeza. Penalaan halus melibatkan latihan semula LLM pada data khusus domain untuk melaksanakan tugas khusus, sesuai untuk kes penggunaan statik dan sempit seperti penjenamaan atau penulisan kreatif yang memerlukan nada atau gaya tertentu. Walau bagaimanapun, ia mahal, memakan masa dan tidak sesuai untuk data dinamik yang kerap dikemas kini.

Sebaliknya, RAG meningkatkan LLM dengan mendapatkan semula data luaran secara dinamik tanpa mengubah suai berat model, menjadikannya kos efektif dan sesuai untuk persekitaran terdorong data masa nyata seperti undang-undang, kewangan atau aplikasi perkhidmatan pelanggan. RAG membolehkan LLM mengendalikan korpora dokumen dalaman yang besar dan tidak berstruktur, menawarkan kelebihan ketara berbanding kaedah tradisional untuk menavigasi repositori data yang tidak kemas.

Penalaan halus cemerlang dalam menghasilkan keluaran yang bernuansa dan konsisten manakala RAG menyediakan maklumat yang terkini dan tepat dengan memanfaatkan pangkalan pengetahuan luaran. Dalam amalan, RAG selalunya menjadi pilihan pilihan untuk aplikasi yang memerlukan respons masa nyata yang boleh disesuaikan, terutamanya dalam perusahaan yang menguruskan data yang luas dan tidak berstruktur.

Jenis RAG

Terdapat beberapa jenis pendekatan Retrieval-Augmented Generation (RAG), setiap satu disesuaikan dengan kes penggunaan dan objektif tertentu. Jenis utama termasuk:

sumber: https://x.com/weaviate_io/status/1866528335884325070

• RAG Asli: Merujuk kepada pendekatan bersepadu yang ketat di mana komponen perolehan semula dan penjanaan sistem Penjanaan Dipertingkatkan Semula direka bentuk untuk berfungsi dengan lancar dalam seni bina yang sama. Tidak seperti pelaksanaan tradisional yang bergantung pada alat luaran atau API, RAG asli mengoptimumkan interaksi antara mekanisme perolehan semula dan model generatif, membolehkan pemprosesan lebih pantas dan perkaitan kontekstual yang dipertingkatkan. Pendekatan ini selalunya menggunakan pemprosesan dalam memori atau pangkalan data tempatan yang sangat dioptimumkan, mengurangkan kependaman dan overhed sumber. Sistem RAG asli biasanya disesuaikan untuk kes penggunaan tertentu, memberikan kecekapan, ketepatan dan keberkesanan kos yang dipertingkatkan dengan menghapuskan pergantungan pada perkhidmatan pihak ketiga.
• Dapatkan dan Susun Semula RAG: Memfokuskan pada memperhalusi proses mendapatkan semula untuk meningkatkan ketepatan dan perkaitan. Dalam kaedah ini, set awal dokumen atau ketulan diambil berdasarkan persamaan semantik pertanyaan, biasanya ditentukan oleh persamaan kosinus dalam ruang benam. Selepas itu, model penarafan semula menyusun semula dokumen yang diambil berdasarkan kaitan kontekstualnya dengan pertanyaan. Langkah penyusunan semula ini selalunya memanfaatkan model pembelajaran mendalam atau transformer, membenarkan kedudukan yang lebih bernuansa melangkaui metrik persamaan asas. Dengan mengutamakan dokumen yang paling berkaitan, pendekatan ini memastikan model generatif menerima input yang diperkaya secara kontekstual, meningkatkan kualiti tindak balas dengan ketara.
• RAG Berbilang Modal: Memperluaskan paradigma RAG tradisional dengan menggabungkan berbilang modaliti data, seperti teks, imej, audio atau video, ke dalam saluran paip penjanaan dipertingkatkan semula. Ia membolehkan sistem untuk mendapatkan semula dan menjana respons yang menyepadukan pelbagai bentuk data. Sebagai contoh, dalam senario yang melibatkan pertanyaan berasaskan imej, sistem mungkin mendapatkan semula imej yang berkaitan bersama kandungan teks untuk mencipta jawapan yang lebih komprehensif. Multimodal RAG amat berguna dalam domain seperti e-dagang, pengimejan perubatan dan analisis kandungan multimedia, di mana cerapan sering bergantung pada gabungan maklumat teks dan visual.
• Graph RAG: Memanfaatkan struktur data berasaskan graf untuk memodelkan dan mendapatkan maklumat berdasarkan perhubungan dan hubungan antara entiti. Dalam pendekatan ini, pengetahuan disusun sebagai graf yang mana nod mewakili entiti (mis., konsep, dokumen atau objek), dan tepi menangkap perhubungan mereka (cth., semantik, hierarki atau temporal). Pertanyaan diproses untuk mengenal pasti subgraf atau laluan yang berkaitan dengan input, dan subgraf ini kemudiannya dimasukkan ke dalam model generatif. Kaedah ini amat berharga dalam domain seperti penyelidikan saintifik, rangkaian sosial dan pengurusan pengetahuan, di mana cerapan hubungan adalah kritikal.
• RAG Hibrid: Menggabungkan berbilang teknik perolehan semula, seperti perolehan padat dan jarang, untuk meningkatkan prestasi merentas pelbagai jenis pertanyaan. Pendapatan padat menggunakan pembenaman vektor untuk menangkap persamaan semantik, manakala perolehan jarang bergantung pada kaedah berasaskan kata kunci, seperti BM25, untuk padanan yang tepat. Dengan menyepadukan kaedah ini, RAG Hibrid mengimbangi ketepatan dan ingatan semula, menjadikannya serba boleh merentas senario di mana pertanyaan mungkin sangat spesifik atau abstrak. Ia amat berkesan dalam persekitaran dengan data heterogen, memastikan kedua-dua semantik peringkat tinggi dan kata kunci khusus dipertimbangkan semasa pengambilan semula.
• Agentic RAG (Router): Menggunakan lapisan pembuat keputusan untuk menghalakan pertanyaan secara dinamik ke modul perolehan dan penjanaan yang sesuai berdasarkan ciri-cirinya. Penghala menganalisis pertanyaan masuk untuk menentukan laluan pemprosesan optimum, yang mungkin melibatkan kaedah perolehan semula yang berbeza, sumber data atau model generatif khusus. Pendekatan ini memastikan sistem menyesuaikan operasinya dengan keperluan khusus setiap pertanyaan, meningkatkan kecekapan dan ketepatan dalam pelbagai aplikasi.
• Agentic RAG (Multi-Agent RAG): Multi-Agent RAG melibatkan rangka kerja kolaboratif di mana berbilang ejen khusus mengendalikan aspek yang berbeza dalam proses perolehan dan penjanaan. Setiap ejen bertanggungjawab untuk tugas tertentu, seperti mendapatkan semula data daripada domain tertentu, menyusun semula hasil atau menjana respons dalam gaya tertentu. Ejen-ejen ini berkomunikasi dan bekerjasama untuk menyampaikan output yang padu. RAG Berbilang Ejen amat berkuasa untuk pertanyaan berbilang domain yang kompleks, kerana ia membolehkan sistem memanfaatkan kepakaran ejen yang berbeza untuk memberikan respons yang komprehensif dan bernuansa.

Aplikasi RAG

Rangka kerja Retrieval-Augmented Generation (RAG) mempunyai pelbagai aplikasi merentas pelbagai industri kerana keupayaannya untuk menyepadukan pengetahuan luaran secara dinamik ke dalam model bahasa generatif. Berikut ialah beberapa aplikasi yang menonjol:

• Sokongan dan Perkhidmatan Pelanggan: Sistem RAG digunakan secara meluas dalam sokongan pelanggan untuk mencipta bot sembang pintar yang mampu menjawab pertanyaan rumit dengan mendapatkan semula data yang berkaitan daripada manual produk, pangkalan pengetahuan dan dokumen dasar syarikat. Ini memastikan pelanggan menerima maklumat yang tepat dan terkini, meningkatkan pengalaman mereka.
• Analisis Dokumen Undang-undang: Dalam bidang undang-undang, RAG boleh menghuraikan, mendapatkan semula dan menjana ringkasan atau jawapan daripada korpora besar undang-undang kes, kontrak dan dokumen undang-undang. Ia amat berguna untuk menjalankan penyelidikan undang-undang, merangka kontrak dan memastikan pematuhan terhadap peraturan.
• Analisis Kewangan: RAG digunakan dalam perkhidmatan kewangan untuk menganalisis laporan pendapatan, arah aliran pasaran dan dokumen kawal selia. Dengan mendapatkan semula data kewangan yang berkaitan, ia boleh membantu penganalisis menjana cerapan, laporan atau jawapan masa nyata untuk pertanyaan tentang prestasi pasaran.
• Penjagaan Kesihatan dan Diagnostik Perubatan: Dalam penjagaan kesihatan, RAG digunakan untuk mendapatkan dan mensintesis maklumat daripada literatur perubatan, rekod pesakit dan garis panduan rawatan. Ia membantu dalam sokongan diagnostik, penemuan ubat dan cadangan rawatan yang diperibadikan, memastikan doktor mempunyai akses kepada data terkini dan paling berkaitan.
• Pendidikan dan E-Pembelajaran: Alat berkuasa RAG membantu dalam pendidikan diperibadikan dengan mendapatkan semula bahan kursus dan menjana jawapan atau panduan belajar yang disesuaikan. Mereka boleh meningkatkan platform pembelajaran dengan menyediakan penjelasan kontekstual dan kandungan dinamik berdasarkan pertanyaan pengguna.
• E-Dagang dan Runcit: Dalam e-dagang, sistem RAG memperbaik enjin carian dan pengesyoran produk dengan mendapatkan semula data daripada katalog dan ulasan pelanggan. Mereka juga mendayakan pembantu beli-belah perbualan yang menyediakan cadangan produk yang diperibadikan berdasarkan pilihan pengguna.
• Pembantu Maya Pintar: RAG mempertingkat pembantu maya seperti Alexa atau Siri dengan memberikan respons yang tepat dan berkaitan kontekstual, terutamanya untuk pertanyaan yang memerlukan pengetahuan luaran, seperti kemas kini cuaca masa nyata atau maklumat perniagaan setempat.

Membina sistem sembang PDF menggunakan RAG

Dalam bahagian ini, kami akan membangunkan aplikasi strim yang mampu memahami kandungan PDF dan menjawab pertanyaan pengguna berdasarkan kandungan tersebut menggunakan Retrieval-Augmented Generation (RAG). Pelaksanaan itu memanfaatkan platform LangChain untuk memudahkan interaksi dengan LLM dan kedai vektor. Kami akan menggunakan LLM OpenAI dan model benamnya untuk membina stor vektor FAISS untuk mendapatkan maklumat yang cekap.

Memasang kebergantungan

• Buat dan aktifkan persekitaran maya dengan melaksanakan arahan berikut.

python -m venv venv
source venv/bin/activate #for ubuntu
venv/Scripts/activate #for windows

• Pasang langchain, langchain_community, openai, faiss-cpu, PyPDF2, streamlit, python-dotenv, perpustakaan tiktoken menggunakan pip.

pip install langchain langchain_community openai faiss-cpu PyPDF2 streamlit python-dotenv tiktoken

Menyediakan persekitaran dan kelayakan

• Buat fail bernama .env. Fail ini akan menyimpan pembolehubah persekitaran anda, termasuk kunci OpenAI, model dan benam.
• Buka fail .env dan tambah kod berikut untuk menentukan kelayakan OpenAI anda:

OPENAI_API_KEY=sk-proj-xcQxBf5LslO62At...
OPENAI_MODEL_NAME=gpt-3.5-turbo
OPENAI_EMBEDDING_MODEL_NAME=text-embedding-3-small

Mengimport pembolehubah persekitaran

• Buat fail bernama app.py.
• Tambah bukti kelayakan OpenAI pada pembolehubah persekitaran.

from dotenv import load_dotenv
import os
load_dotenv()
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
OPENAI_MODEL_NAME = os.getenv("OPENAI_MODEL_NAME")
OPENAI_EMBEDDING_MODEL_NAME = os.getenv("OPENAI_EMBEDDING_MODEL_NAME")

Mengimport perpustakaan yang diperlukan

Import perpustakaan penting untuk membina apl, mengendalikan PDF seperti langchain, streamlit, pyPDF.

import streamlit as st
from PyPDF2 import PdfReader
from langchain.text_splitter import CharacterTextSplitter
from langchain.prompts import PromptTemplate
from langchain_community.embeddings import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationalRetrievalChain
from langchain_community.chat_models import ChatOpenAI
from htmlTemplates import bot_template, user_template, css

Mentakrifkan fungsi untuk mengekstrak teks daripada PDF

• Gunakan PyPDF2 untuk mengekstrak teks daripada fail PDF yang dimuat naik.

def get_pdf_text(pdf_files):
    text = ""
    for pdf_file in pdf_files:
        reader = PdfReader(pdf_file)
        for page in reader.pages:
            text += page.extract_text()
    return text

Membahagikan teks yang diekstrak kepada ketulan

Bahagikan teks besar kepada ketulan yang lebih kecil dan boleh diurus menggunakan CharacterTextSplitter LangChain.

def get_chunk_text(text):
    text_splitter = CharacterTextSplitter(
        separator="\n",
        chunk_size=1000,
        chunk_overlap=200,
        length_function=len
    )
    chunks = text_splitter.split_text(text)
    return chunks

Mencipta kedai vektor untuk pembenaman teks

Janakan pembenaman untuk ketulan teks dan simpannya dalam pangkalan data vektor menggunakan FAISS.

def get_vector_store(text_chunks):
    embeddings = OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY, model=OPENAI_EMBEDDING_MODEL_NAME)
    vectorstore = FAISS.from_texts(texts=text_chunks, embedding=embeddings)
    return vectorstore

Membina rantaian pencarian semula perbualan

Tentukan rantaian yang mendapatkan semula maklumat daripada stor vektor dan berinteraksi dengan pengguna melalui LLM.

def get_conversation_chain(vector_store):
    llm = ChatOpenAI(openai_api_key=OPENAI_API_KEY, model_name=OPENAI_MODEL_NAME, temperature=0)
    memory = ConversationBufferMemory(memory_key='chat_history', return_messages=True)
    system_template  =  """
    Use  the following pieces of context and chat history to answer the question at the end. 
    If you don't know the answer, just say that you don't know, don't try to make up an answer.

    Context: {context}

    Chat history: {chat_history}

    Question: {question}
    Helpful Answer:
    """
    prompt = PromptTemplate(
        template=system_template,
        input_variables=["context", "question",  "chat_history"],
    )
    conversation_chain = ConversationalRetrievalChain.from_llm(
        verbose = True,
        llm=llm,
        retriever=vector_store.as_retriever(),
        memory=memory,
        combine_docs_chain_kwargs={"prompt": prompt}
    )
    return conversation_chain

Mengendalikan pertanyaan pengguna

Proses input pengguna, hantarkannya ke rantai perbualan dan kemas kini sejarah sembang.

def handle_user_input(question):
    try:
        response = st.session_state.conversation({'question': question})
        st.session_state.chat_history = response['chat_history']
    except Exception as e:
        st.error('Please select PDF and click on Process.')

Mencipta templat HTML tersuai untuk sembang strim

Untuk mencipta antara muka sembang tersuai untuk kedua-dua mesej pengguna dan bot menggunakan CSS, reka templat tersuai dan gayakannya dengan CSS.

• Buat fail bernama htmlTemplates.py dan tambahkan kod berikut padanya.

css = '''
<style>
.chat-message {
    padding: 1rem; border-radius: 0.5rem; margin-bottom: 1rem; display: flex
}
.chat-message.user {
    background-color: #2b313e
}
.chat-message.bot {
    background-color: #475063
}
.chat-message .avatar {
  width: 10%;
}
.chat-message .avatar img {
  max-width: 30px;
  max-height: 30px;
  border-radius: 50%;
  object-fit: cover;
}
.chat-message .message {
  width: 90%;
  padding: 0 1rem;
  color: #fff;
}
'''

bot_template = '''
<div>



<h3>
  
  
  Displaying chat history
</h3>

<p>Show the user and AI conversation history in a reverse order with HTML templates for formatting.<br>
</p>

<pre class="brush:php;toolbar:false">def display_chat_history():
    if st.session_state.chat_history:
        reversed_history = st.session_state.chat_history[::-1]

        formatted_history = []
        for i in range(0, len(reversed_history), 2):
            chat_pair = {
                "AIMessage": reversed_history[i].content,
                "HumanMessage": reversed_history[i + 1].content
            }
            formatted_history.append(chat_pair)

        for i, message in enumerate(formatted_history):
            st.write(user_template.replace("{{MSG}}", message['HumanMessage']), unsafe_allow_html=True)
            st.write(bot_template.replace("{{MSG}}", message['AIMessage']), unsafe_allow_html=True)

Membina antara muka aplikasi Streamlit

Sediakan antara muka apl utama untuk muat naik fail, input soalan dan paparan sejarah sembang.

def main():
    st.set_page_config(page_title='Chat with PDFs', page_icon=':books:')
    st.write(css, unsafe_allow_html=True)

    if "conversation" not in st.session_state:
        st.session_state.conversation = None
    if "chat_history" not in st.session_state:
        st.session_state.chat_history = None

    st.header('Chat with PDFs :books:')

    question = st.text_input("Ask anything to your PDF:")
    if question:
        handle_user_input(question)

    if st.session_state.chat_history is not None:
        display_chat_history()

    with st.sidebar:
        st.subheader("Upload your Documents Here: ")
        pdf_files = st.file_uploader("Choose your PDF Files and Press Process button", type=['pdf'], accept_multiple_files=True)

        if pdf_files and st.button("Process"):
            with st.spinner("Processing your PDFs..."):
                try:
                    # Get PDF Text
                    raw_text = get_pdf_text(pdf_files)
                    # Get Text Chunks
                    text_chunks = get_chunk_text(raw_text)
                    # Create Vector Store
                    vector_store = get_vector_store(text_chunks)
                    st.success("Your PDFs have been processed successfully. You can ask questions now.")
                    # Create conversation chain
                    st.session_state.conversation = get_conversation_chain(vector_store)
                except Exception as e:
                    st.error(f"An error occurred: {e}")

if __name__ == '__main__':
    main()

Kod Lengkap untuk Aplikasi Sembang PDF

Berikut ialah pelaksanaan kod lengkap untuk Aplikasi Sembang PDF. Ia menyepadukan persediaan pembolehubah persekitaran, pengekstrakan teks, storan vektor dan ciri RAG ke dalam penyelesaian yang diperkemas:

from dotenv import load_dotenv
import os
load_dotenv()
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
OPENAI_MODEL_NAME = os.getenv("OPENAI_MODEL_NAME")
OPENAI_EMBEDDING_MODEL_NAME = os.getenv("OPENAI_EMBEDDING_MODEL_NAME")

import streamlit as st
from PyPDF2 import PdfReader
from langchain.text_splitter import CharacterTextSplitter
from langchain.prompts import PromptTemplate
from langchain_community.embeddings import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationalRetrievalChain
from langchain_community.chat_models import ChatOpenAI
from htmlTemplates import bot_template, user_template, css

def get_pdf_text(pdf_files):
    text = ""
    for pdf_file in pdf_files:
        reader = PdfReader(pdf_file)
        for page in reader.pages:
            text += page.extract_text()
    return text

def get_chunk_text(text):
    text_splitter = CharacterTextSplitter(
        separator="\n",
        chunk_size=1000,
        chunk_overlap=200,
        length_function=len
    )
    chunks = text_splitter.split_text(text)
    return chunks

def get_vector_store(text_chunks):
    embeddings = OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY, model=OPENAI_EMBEDDING_MODEL_NAME)
    vectorstore = FAISS.from_texts(texts=text_chunks, embedding=embeddings)
    return vectorstore

def get_conversation_chain(vector_store):
    llm = ChatOpenAI(openai_api_key=OPENAI_API_KEY, model_name=OPENAI_MODEL_NAME, temperature=0)
    memory = ConversationBufferMemory(memory_key='chat_history', return_messages=True)
    system_template  =  """
    Use  the following pieces of context and chat history to answer the question at the end. 
    If you don't know the answer, just say that you don't know, don't try to make up an answer.

    Context: {context}

    Chat history: {chat_history}

    Question: {question}
    Helpful Answer:
    """
    prompt = PromptTemplate(
        template=system_template,
        input_variables=["context", "question",  "chat_history"],
    )
    conversation_chain = ConversationalRetrievalChain.from_llm(
        verbose = True,
        llm=llm,
        retriever=vector_store.as_retriever(),
        memory=memory,
        combine_docs_chain_kwargs={"prompt": prompt}
    )
    return conversation_chain

def handle_user_input(question):
    try: 
        response = st.session_state.conversation({'question': question})
        st.session_state.chat_history = response['chat_history']
    except Exception as e:
        st.error('Please select PDF and click on OK.')

def display_chat_history():
    if st.session_state.chat_history:
        reversed_history = st.session_state.chat_history[::-1]

        formatted_history = []
        for i in range(0, len(reversed_history), 2):
            chat_pair = {
                "AIMessage": reversed_history[i].content,
                "HumanMessage": reversed_history[i + 1].content
            }
            formatted_history.append(chat_pair)

        for i, message in enumerate(formatted_history):
            st.write(user_template.replace("{{MSG}}", message['HumanMessage']), unsafe_allow_html=True)
            st.write(bot_template.replace("{{MSG}}", message['AIMessage']), unsafe_allow_html=True)

def main():
    st.set_page_config(page_title='Chat with PDFs', page_icon=':books:')
    st.write(css, unsafe_allow_html=True)

    if "conversation" not in st.session_state:
        st.session_state.conversation = None
    if "chat_history" not in st.session_state:
        st.session_state.chat_history = None

    st.header('Chat with PDFs :books:')

    question = st.text_input("Ask anything to your PDF:")
    if question:
        handle_user_input(question)

    if st.session_state.chat_history is not None:
        display_chat_history()

    with st.sidebar:
        st.subheader("Upload your Documents Here: ")
        pdf_files = st.file_uploader("Choose your PDF Files and Press Process button", type=['pdf'], accept_multiple_files=True)

        if pdf_files and st.button("Process"):
            with st.spinner("Processing your PDFs..."):
                try:
                    # Get PDF Text
                    raw_text = get_pdf_text(pdf_files)
                    # Get Text Chunks
                    text_chunks = get_chunk_text(raw_text)
                    # Create Vector Store
                    vector_store = get_vector_store(text_chunks)
                    st.success("Your PDFs have been processed successfully. You can ask questions now.")
                    # Create conversation chain
                    st.session_state.conversation = get_conversation_chain(vector_store)
                except Exception as e:
                    st.error(f"An error occurred: {e}")

if __name__ == '__main__':
    main()

Jalankan Aplikasi

Laksanakan apl dengan Streamlit menggunakan arahan berikut.

streamlit run app.py

Anda akan mendapat output seperti berikut,

Terima kasih kerana membaca artikel ini !!

Terima kasih Gowri M Bhatt kerana menyemak kandungan.

Jika anda menyukai artikel ini, sila klik pada butang hati ♥ dan kongsi untuk membantu orang lain menemuinya!

Kod sumber penuh untuk tutorial ini boleh didapati di sini,

codemaker2015/pdf-chat-using-RAG | github.com

Sumber

• Automasi proses perniagaan RAG dan LLM: Strategi teknikal - Grid Dynamics | www.griddynamics.com
• Pengenalan kepada Retrieval Augmented Generation (RAG) | Tenunan
• Teknik, Cabaran dan Masa Depan Model Bahasa Ditambah - Aliran Kecerunan
• Retrieval Augmented Generation di Planet Scale | Arcus

Atas ialah kandungan terperinci Panduan muktamad untuk Retrieval-Augmented Generation (RAG). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!