Rag vs Fine-penalaan: Tutorial yang komprehensif dengan contoh praktikal

Model bahasa yang paling besar (LLM) seperti GPT-4 dilatih pada dataset umum, sering ketinggalan zaman. Walaupun mereka cemerlang untuk menjawab soalan umum, mereka berjuang dengan pertanyaan mengenai berita terkini, perkembangan terkini, dan topik khusus domain. Dalam kes sedemikian, mereka boleh membiayai atau memberikan respons yang tidak tepat. 

Walaupun kemunculan model yang lebih baik seperti Claude 3.5 Sonnet, kita masih perlu sama ada model penalaan yang baik untuk menghasilkan respons tersuai atau menggunakan sistem generasi pengambilan semula (RAG) untuk memberikan konteks tambahan kepada model asas.

Dalam tutorial ini, kami akan meneroka kain dan penalaan halus, dua teknik yang berbeza yang digunakan untuk meningkatkan respons LLM. Kami akan mengkaji perbezaan mereka dan meletakkan teori ke dalam amalan dengan menilai hasil. 

Selain itu, kami akan menyelam ke dalam teknik hibrid yang menggabungkan model-model halus dengan sistem RAG untuk memanfaatkan yang terbaik dari kedua-dua dunia. Akhirnya, kita akan belajar bagaimana memilih antara ketiga -tiga pendekatan ini berdasarkan kes dan keperluan penggunaan tertentu.

Gambaran Keseluruhan RAG dan FINE-TURNE

Teknik RAG dan penalaan halus meningkatkan penjanaan tindak balas untuk pertanyaan khusus domain, tetapi mereka adalah teknik yang sama sekali berbeza. Mari kita pelajari tentang mereka.

Generasi Retrieval-Augmented (RAG)

Generasi pengambilan semula adalah proses di mana model bahasa besar seperti GPT-4O menjadi konteks-menyedari menggunakan sumber data luaran. Ia adalah gabungan dari retriever dan penjana. Retriever mengambil data dari Internet atau pangkalan data vektor dan memberikannya kepada penjana dengan pertanyaan pengguna asal. Penjana menggunakan konteks tambahan untuk menghasilkan respons yang sangat tepat dan relevan.  

Untuk mengetahui lebih lanjut, baca artikel kami, apakah pengambilan semula generasi tambahan (RAG)? Panduan kepada asas -asas dan memahami kerja dalaman aplikasi RAG dan pelbagai kes penggunaan. 

Fine-penalaan

Penalaan halus adalah proses penalaan model pra-terlatih menggunakan dataset khusus domain. Model pra-terlatih dilatih pada pelbagai mayat besar dataset umum yang dibatalkan dari Internet. Mereka baik untuk menjawab soalan umum, tetapi mereka akan berjuang atau bahkan halusinasi sambil menjawab soalan khusus domain. 

Sebagai contoh, model pra-terlatih mungkin mahir dalam kebolehan perbualan umum tetapi boleh menghasilkan jawapan yang salah apabila ditanya mengenai prosedur perubatan yang rumit atau pendahuluan undang-undang. 

Fine-penala di dataset perubatan atau undang-undang membolehkan model memahami dan menjawab soalan-soalan dalam bidang tersebut dengan ketepatan dan kaitan yang lebih tinggi.

Ikuti panduan pengantar untuk tutorial LLMS penalaan halus untuk mengetahui tentang menyesuaikan model pra-terlatih dengan panduan visual. 

RAG vs FINE-TUNING

Kami telah belajar tentang setiap metodologi untuk meningkatkan penjanaan tindak balas LLMS. Mari kita periksa perbezaan untuk memahami mereka dengan lebih baik. 

1. Gaya Pembelajaran

RAG menggunakan gaya pembelajaran dinamik, yang membolehkan model bahasa mengakses dan menggunakan data terkini dan paling tepat dari pangkalan data, Internet, atau API. Pendekatan ini memastikan bahawa respons yang dihasilkan sentiasa terkini dan relevan.

Penalaan halus melibatkan pembelajaran statik, di mana model belajar melalui dataset baru semasa fasa latihan. Walaupun kaedah ini membolehkan model menyesuaikan diri dengan penjanaan tindak balas khusus domain, ia tidak dapat mengintegrasikan maklumat baru selepas latihan tanpa latihan semula.

2. Kesesuaian

RAG adalah yang terbaik untuk generalisasi. Ia menggunakan proses pengambilan untuk menarik maklumat dari sumber data yang berbeza. RAG tidak mengubah tindak balas model; Ia hanya menyediakan maklumat tambahan untuk membimbing model. 

Fine-penalaan menyesuaikan output model dan meningkatkan prestasi model pada domain khas yang dikaitkan rapat dengan dataset latihan. Ia juga mengubah gaya penjanaan tindak balas dan kadang -kadang memberikan jawapan yang lebih relevan daripada sistem RAG. 

3. Intensiti Sumber

RAG adalah sumber yang berintensifkan kerana ia dilakukan semasa kesimpulan model. Berbanding dengan LLM mudah tanpa kain, RAG memerlukan lebih banyak memori dan pengkomputeran. 

Penalaan halus adalah pengiraan-intensif, tetapi ia dilakukan sekali. Ia memerlukan pelbagai GPU dan memori yang tinggi semasa proses latihan, tetapi selepas itu, ia agak mesra sumber berbanding dengan sistem RAG. 

4. Kos

RAG memerlukan model embedding dan LLM yang lebih tinggi untuk penjanaan tindak balas yang lebih baik. Ia juga memerlukan pangkalan data vektor yang cepat. Kos API dan operasi boleh meningkat dengan cepat.

Penalaan halus akan dikenakan biaya besar sekali sahaja semasa proses latihan, tetapi selepas itu, anda akan membayar untuk kesimpulan model, yang lebih murah daripada kain.   

secara keseluruhan, secara purata, kos penalaan lebih daripada kain jika semuanya dipertimbangkan. 

5. Kerumitan pelaksanaan

sistem RAG boleh dibina oleh jurutera perisian dan memerlukan kepakaran teknikal sederhana. Anda dikehendaki mengetahui tentang reka bentuk LLM, pangkalan data vektor, embeddings, jurutera cepat, dan banyak lagi, yang memerlukan masa tetapi mudah dipelajari dalam sebulan. 

Fine-penala model menuntut kepakaran teknikal yang tinggi. Dari menyediakan dataset untuk menetapkan parameter penalaan untuk memantau prestasi model, tahun pengalaman dalam bidang pemprosesan bahasa semulajadi diperlukan. 

Meletakkan teori ke ujian dengan contoh praktikal

mari kita menguji teori kami dengan memberikan petikan yang sama kepada model yang baik, aplikasi RAG, dan pendekatan hibrid dan kemudian menilai hasilnya. Pendekatan hibrid akan menggabungkan model halus dengan aplikasi RAG. Untuk contoh ini, kami akan menggunakan dataset RuslanMV/AI-Medical-Chatbot dari muka yang memeluk, yang mengandungi perbualan antara pesakit dan doktor mengenai pelbagai keadaan kesihatan.

Bangunan Aplikasi Rag menggunakan llama 3

kita akan bermula dengan membina aplikasi RAG menggunakan ekosistem Llama 3 dan Langchain. 

Anda juga boleh belajar membina aplikasi RAG menggunakan LlamAindex dengan mengikuti kod bersama, pengambilan semula generasi tambahan dengan llamaindex.

1. Pasang semua pakej python yang diperlukan.

%%capture
%pip install -U langchain langchainhub langchain_community langchain-huggingface faiss-gpu transformers accelerate

2. Muatkan fungsi yang diperlukan dari perpustakaan Langchain dan Transformers.

from langchain.document_loaders import HuggingFaceDatasetLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import FAISS
from transformers import AutoTokenizer, AutoModelForCausalLM,pipeline
from langchain_huggingface import HuggingFacePipeline
from langchain.chains import RetrievalQA

3. Untuk mengakses model dan dataset terhad, disarankan agar anda log masuk ke hab muka yang memeluk menggunakan kunci API.

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)

4. Muatkan dataset dengan menyediakan nama dataset dan nama lajur kepada HuggingFaceDataSetLoader. Lajur "Doktor" akan menjadi dokumen utama kami, dan seluruh lajur akan menjadi metadata. 

5. Mengehadkan dataset kami ke 1000 baris pertama. Mengurangkan dataset akan membantu kami mengurangkan masa penyimpanan data dalam pangkalan data vektor. 

# Specify the dataset name
dataset_name = "ruslanmv/ai-medical-chatbot"


# Create a loader instance using dataset columns
loader_doctor = HuggingFaceDatasetLoader(dataset_name,"Doctor")

# Load the data
doctor_data = loader_doctor.load()

# Select the first 1000 entries
doctor_data = doctor_data[:1000]

doctor_data[:2]

Seperti yang dapat kita lihat, lajur "Doktor" adalah kandungan halaman, dan selebihnya dianggap metadata. 

6. Muatkan model embedding daripada memeluk muka menggunakan parameter tertentu seperti membolehkan pecutan GPU.

7. Uji model embedding dengan menyediakannya dengan teks sampel.

# Define the path to the embedding model
modelPath = "sentence-transformers/all-MiniLM-L12-v2"

# GPU acceleration
model_kwargs = {'device':'cuda'}

# Create a dictionary with encoding options
encode_kwargs = {'normalize_embeddings': False}

# Initialize an instance of HuggingFaceEmbeddings with the specified parameters
embeddings = HuggingFaceEmbeddings(
    model_name=modelPath,     
    model_kwargs=model_kwargs, 
    encode_kwargs=encode_kwargs
)
text = "Why are you a doctor?"
query_result = embeddings.embed_query(text)
query_result[:3]

8. Tukar data ke dalam embeddings dan simpannya ke dalam pangkalan data vektor.

[-0.059351932257413864, 0.08008933067321777, 0.040729623287916183]

9. Simpan pangkalan data vektor dalam direktori tempatan.

10. Lakukan carian kesamaan menggunakan prompt sampel.

vector_db = FAISS.from_documents(doctor_data, embeddings)
vector_db.save_local("/kaggle/working/faiss_doctor_index")
question = "Hi Doctor, I have a headache, help me."
searchDocs = vector_db.similarity_search(question)
print(searchDocs[0].page_content)

11. Tukar contoh pangkalan data vektor ke retriever. Ini akan membantu kita membuat rantai RAG.

12. Muatkan tokenizer dan model menggunakan model sembang Llama 3 8b.

retriever = vector_db.as_retriever()

13. Gunakannya untuk membuat saluran paip penjanaan ujian.

14. Tukar saluran paip ke klien Langchain LLM.

15. Buat rantaian soalan dan jawapan menggunakan retriever, pertanyaan pengguna, prompt rag, dan llm.

import torch
base_model = "/kaggle/input/llama-3/transformers/8b-chat-hf/1"

tokenizer = AutoTokenizer.from_pretrained(base_model)

model = AutoModelForCausalLM.from_pretrained(
        base_model,
        return_dict=True,
        low_cpu_mem_usage=True,
        torch_dtype=torch.float16,
        device_map="auto",
        trust_remote_code=True,
)

pipe = pipeline(
    "text-generation", 
    model=model, 
    tokenizer=tokenizer,
    max_new_tokens=120
)

llm = HuggingFacePipeline(pipeline=pipe)

16. Uji rantaian Q & A dengan bertanya soalan kepada doktor.

from langchain import hub
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough


rag_prompt = hub.pull("rlm/rag-prompt")




qa_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | rag_prompt
    | llm
    | StrOutputParser()
)

Ia agak serupa dengan dataset, tetapi ia tidak mengambil gaya. Ia telah memahami konteks dan menggunakannya untuk menulis respons dalam gaya sendiri. 

Mari cuba lagi dengan soalan lain. 

%%capture
%pip install -U langchain langchainhub langchain_community langchain-huggingface faiss-gpu transformers accelerate

ini adalah jawapan yang sangat langsung. Mungkin kita perlu menyempurnakan model dan bukannya menggunakan pendekatan RAG untuk doktor dan chatbot pesakit. 

Jika anda menghadapi kesukaran menjalankan kod, sila rujuk buku nota Kaggle: Bangunan Rag Aplikasi menggunakan llama 3.

Ketahui cara meningkatkan prestasi sistem RAG dengan teknik seperti chunking, reranking, dan transformasi pertanyaan dengan mengikuti cara meningkatkan prestasi RAG: 5 teknik utama dengan tutorial contoh.

penalaan halus llama 3 pada data perubatan

Kami tidak akan menyempurnakan model pada Doktor dan dataset pesakit kerana kami telah melakukannya dalam tutorial sebelumnya: penalaan halus Llama 3 dan menggunakannya secara tempatan: panduan langkah demi langkah. Apa yang akan kita lakukan ialah memuatkan model halus dan memberikannya dengan soalan yang sama untuk menilai hasilnya. Model yang disesuaikan boleh didapati di muka dan kaggle yang memeluk.

Jika anda berminat untuk menyempurnakan model GPT-4 menggunakan API OpenAI, anda boleh merujuk kepada tutorial DataCamp yang mudah diikuti dengan GPT-4 OpenAI: Panduan Langkah demi Langkah.

Sumber: KingabzPro/llama-3-8b-chat-Doctor

1. Muatkan tokenizer dan model menggunakan perpustakaan Transformer.

2. Pastikan anda menggunakan parameter yang betul untuk memuatkan model dalam persekitaran Kaggle GPU T4 X2.

3. Sapukan templat sembang ke mesej.

from langchain.document_loaders import HuggingFaceDatasetLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import FAISS
from transformers import AutoTokenizer, AutoModelForCausalLM,pipeline
from langchain_huggingface import HuggingFacePipeline
from langchain.chains import RetrievalQA

4. Buat saluran paip penjanaan teks menggunakan model dan tokenizer.

5. Sediakan objek saluran paip dengan cepat dan menghasilkan respons.

Respons ini agak serupa dengan dataset. Gaya itu sama, tetapi bukannya memberikan jawapan langsung, ia menunjukkan bahawa pesakit menjalani ujian selanjutnya.

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)

6. Mari kita tanya soalan kedua.

Gaya adalah sama, dan tindak balasnya agak empati dan penjelasan. 

# Specify the dataset name
dataset_name = "ruslanmv/ai-medical-chatbot"


# Create a loader instance using dataset columns
loader_doctor = HuggingFaceDatasetLoader(dataset_name,"Doctor")

# Load the data
doctor_data = loader_doctor.load()

# Select the first 1000 entries
doctor_data = doctor_data[:1000]

doctor_data[:2]

Jika anda menghadapi kesukaran menjalankan kod, sila rujuk buku nota Kaggle: kesimpulan Llama 3 HF yang disesuaikan.

Pendekatan Hibrid (Rag Fine-Tuning)

Kami kini akan menyediakan model yang baik dengan konteks tambahan untuk terus menyesuaikan respons dan mencari baki. 

Daripada menulis semua kod lagi, kami akan menyelam terus ke dalam penjanaan tindak balas menggunakan rantai Q & A. Sekiranya anda ingin melihat kod lengkap untuk bagaimana kami telah menggabungkan model yang disesuaikan dengan rantaian Q & A, sila lihatlah Notebook Kagle Pendekatan Hibrid (Rag Fine-Tuning). 

Sediakan rantai dengan soalan yang sama yang kami tanya model kain dan halus.

%%capture
%pip install -U langchain langchainhub langchain_community langchain-huggingface faiss-gpu transformers accelerate

Jawapannya agak tepat, dan tindak balas dihasilkan dalam gaya doktor. 

mari kita tanya soalan kedua.

from langchain.document_loaders import HuggingFaceDatasetLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import FAISS
from transformers import AutoTokenizer, AutoModelForCausalLM,pipeline
from langchain_huggingface import HuggingFacePipeline
from langchain.chains import RetrievalQA

Ini pelik. Kami tidak pernah memberikan konteks tambahan mengenai sama ada jerawat itu penuh dengan nanah atau tidak. Mungkin model hibrid tidak berlaku untuk beberapa pertanyaan. 

Dalam kes chatbot pesakit-pesakit, model yang disesuaikan dengan baik dalam penggunaan dan ketepatan gaya. Walau bagaimanapun, ini mungkin berbeza untuk kes -kes penggunaan lain, sebab itu penting untuk menjalankan ujian yang luas untuk menentukan kaedah terbaik untuk kes penggunaan khusus anda.

Istilah rasmi untuk pendekatan hibrid adalah rakit (pengambilan semula penalaan halus). Ketahui lebih lanjut mengenainya dengan membaca apa itu rakit? Menggabungkan kain dan penalaan halus untuk menyesuaikan LLM ke blog domain khusus.

bagaimana memilih antara kain rag vs penalaan vs rakit

semuanya bergantung pada kes penggunaan dan sumber yang tersedia. Jika anda adalah permulaan dengan sumber yang terhad, maka cuba membina bukti konsep RAG menggunakan rangka AI AI dan Langchain terbuka. Untuk itu, anda akan memerlukan sumber, kepakaran, dan dataset yang terhad. 

Jika anda adalah syarikat peringkat pertengahan dan ingin menyesuaikan diri untuk meningkatkan ketepatan tindak balas dan menggunakan model sumber terbuka di awan, anda perlu mengupah pakar seperti saintis data dan jurutera operasi pembelajaran mesin. Penalaan halus memerlukan GPU kelas atas, memori besar, dataset yang dibersihkan, dan pasukan teknikal yang memahami LLM. 

Penyelesaian hibrid adalah sumber dan mengira intensif. Ia juga memerlukan jurutera LLMOPS yang boleh mengimbangi penalaan dan kain. Anda harus mempertimbangkan ini apabila anda ingin meningkatkan penjanaan respons anda lebih jauh dengan mengambil kesempatan daripada kualiti RAG yang baik dan model yang disempurnakan. 

sila rujuk jadual di bawah untuk gambaran keseluruhan RAG, FINE-TURN, dan RAFT SOLUSI.

3

RAG FINE-TUNING RAFT pemahaman kontekstual, meminimumkan halusinasi, mudah menyesuaikan diri dengan data baru, kos efektif.

			Kelebihan
kepakaran khusus tugas, penyesuaian, ketepatan yang lebih baik, peningkatan keteguhan.	menggabungkan kekuatan kedua-dua kain dan penalaan halus, pemahaman dan konteks yang lebih mendalam.
Kekurangan	Pengurusan Sumber Data, Kerumitan.	Bias data, sumber intensif, kos pengiraan yang tinggi, keperluan memori yang besar, masa & kepakaran yang intensif.	kerumitan dalam pelaksanaan, memerlukan pengimbangan pengambilan semula dan proses penalaan halus.
Kerumitan pelaksanaan	lebih tinggi daripada kejuruteraan segera.	lebih tinggi daripada kain. Memerlukan pakar yang sangat teknikal.	paling kompleks dari tiga.
gaya pembelajaran	Dinamik	static	Dinamik Static
penyesuaian	mudah menyesuaikan diri dengan data baru dan fakta yang berkembang.	Sesuaikan output ke tugas dan domain tertentu.	menyesuaikan diri dengan data masa nyata dan tugas tertentu.
kos	rendah	sederhana	Tinggi
Intensiti Sumber	rendah. Sumber digunakan semasa kesimpulan.	sederhana. Sumber digunakan semasa penalaan halus.	Tinggi

Kesimpulan

Model bahasa yang besar berada di tengah -tengah pembangunan AI hari ini. Syarikat mencari pelbagai cara untuk memperbaiki dan menyesuaikan model ini tanpa membelanjakan berjuta -juta dolar dalam latihan. Mereka bermula dengan pengoptimuman parameter dan kejuruteraan segera. Mereka sama ada memilih kain atau menyempurnakan model untuk mendapatkan tindak balas yang lebih baik dan mengurangkan halusinasi. Walaupun terdapat teknik lain untuk meningkatkan respons, ini adalah pilihan yang paling popular.

Dalam tutorial ini, kita telah belajar tentang perbezaan antara RAG dan penalaan halus melalui kedua-dua teori dan contoh praktikal. Kami juga meneroka model hibrid dan membandingkan kaedah mana yang paling sesuai untuk anda.

Untuk mengetahui lebih lanjut mengenai penggunaan LLM dan pelbagai teknik yang terlibat, lihat kod kami-bersama-sama dengan RAG dengan Llamaindex dan kursus kami untuk menggunakan aplikasi LLM dengan Langchain.

Atas ialah kandungan terperinci Rag vs Fine-penalaan: Tutorial yang komprehensif dengan contoh praktikal. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!