Rag vs amende: un tutoriel complet avec des exemples pratiques

La plupart des modèles de langue (LLM) comme GPT-4 sont formés sur des ensembles de données généralisés, souvent obsolètes. Bien qu'ils excellent à répondre aux questions générales, ils ont du mal avec les questions sur les nouvelles récentes, les derniers développements et les sujets spécifiques au domaine. Dans de tels cas, ils peuvent halluciner ou fournir des réponses inexactes. 

Malgré l'émergence de modèles mieux performants comme Claude 3.5 Sonnet, nous devons encore modéliser un réglage fin pour générer des réponses personnalisées ou utiliser des systèmes de génération (RAG) (RAG) de récupération pour fournir un contexte supplémentaire au modèle de base.

Dans ce tutoriel, nous explorerons le chiffon et le réglage fin, deux techniques distinctes utilisées pour améliorer les réponses LLM. Nous examinerons leurs différences et mettrons la théorie en pratique en évaluant les résultats. 

De plus, nous plongerons dans des techniques hybrides qui combinent des modèles affinés avec des systèmes de chiffon pour tirer parti du meilleur des deux mondes. Enfin, nous apprendrons à choisir entre ces trois approches sur la base de cas d'utilisation et d'exigences spécifiques.

Aperçu du chiffon et du réglage fin

Les techniques de chiffon et de réglage fin améliorent la génération de réponse pour les requêtes spécifiques au domaine, mais ce sont des techniques intrinsèquement complètement différentes. Apprenons à leur sujet.

Génération auprès de la récupération (RAG)

La génération auprès de la récupération est un processus où de grands modèles de langue comme GPT-4O deviennent du contexte à l'aide de sources de données externes. Il s'agit d'une combinaison d'un retriever et d'un générateur. Le Retriever récupère les données à partir d'Internet ou d'une base de données vectorielle et la fournit au générateur la requête de l'utilisateur d'origine. Le générateur utilise un contexte supplémentaire pour générer une réponse très précise et pertinente.  

Pour en savoir plus, lisez notre article, qu'est-ce que la génération augmentée (RAG) de la récupération? Un guide sur les bases et comprendre le fonctionnement interne de l'application de chiffon et divers cas d'utilisation. 

Fine-tun

Le réglage fin est le processus de réglage du modèle pré-formé à l'aide de l'ensemble de données spécifique au domaine. Le modèle pré-formé est formé sur plusieurs grands cadavres d'ensembles de données généraux abandonnés d'Internet. Ils sont doués pour répondre aux questions générales, mais ils auront du mal ou même des halluciner tout en répondant aux questions spécifiques au domaine. 

Par exemple, un modèle pré-formé peut être compétent dans les capacités de conversation générales, mais pourrait produire de mauvaises réponses lorsqu'elles sont interrogées sur les procédures médicales complexes ou les précédents juridiques. 

Fonctionner le réglage sur un jeu de données médical ou juridique permet au modèle de comprendre et de répondre aux questions dans ces domaines avec une plus grande précision et pertinence.

Suivez le guide d'introduction au didacticiel LLMS de réglage fin pour découvrir la personnalisation du modèle pré-formé avec des guides visuels. 

Rag vs affinage fin

Nous avons appris chaque méthodologie pour améliorer la génération de réponse des LLMS. Examinons les différences pour mieux les comprendre. 

1. Style d'apprentissage

Rag utilise un style d'apprentissage dynamique, qui permet aux modèles de langue d'accéder et d'utiliser les données les plus récentes et les plus précises des bases de données, d'Internet ou même d'API. Cette approche garantit que les réponses générées sont toujours à jour et pertinentes.

Le réglage fin implique un apprentissage statique, où le modèle apprend à travers un nouvel ensemble de données pendant la phase de formation. Bien que cette méthode permet au modèle de s'adapter à la génération de réponse spécifique au domaine, il ne peut pas intégrer de nouvelles informations après la formation sans recyclage.

2. Adaptabilité

Rag est le meilleur pour les généralisations. Il utilise le processus de récupération pour extraire les informations de différentes sources de données. Le chiffon ne change pas la réponse du modèle; Il fournit simplement des informations supplémentaires pour guider le modèle. 

Fine-Tuning personnalise la sortie du modèle et améliore les performances du modèle sur un domaine spécial qui est étroitement associé à l'ensemble de données de formation. Il modifie également le style de génération de réponse et fournit parfois des réponses plus pertinentes que les systèmes de chiffon. 

3. Intensité des ressources

Rag est à forte intensité de ressources car il est effectué pendant l'inférence du modèle. Par rapport aux LLM simples sans chiffon, RAG nécessite plus de mémoire et de calcul. 

Le réglage fin est à forte intensité de calcul, mais il est effectué une fois. Il nécessite plusieurs GPU et une mémoire élevée pendant le processus de formation, mais après cela, il est assez adapté aux ressources par rapport aux systèmes de chiffon. 

4. Coût

Rag nécessite des modèles d'intégration haut de gamme et des LLM pour une meilleure génération de réponse. Il a également besoin d'une base de données vectorielle rapide. L'API et les coûts d'exploitation peuvent augmenter assez rapidement.

Le réglage fin ne vous coûtera plus qu'une seule fois pendant le processus de formation, mais après cela, vous paierez l'inférence du modèle, ce qui est assez moins cher que le chiffon.   

Dans l'ensemble, en moyenne, le réglage fin coûte plus que le chiffon si tout est considéré. 

5. Complexité de mise en œuvre

Les systèmes de chiffon peuvent être construits par des ingénieurs logiciels et nécessitent une expertise technique moyenne. Vous devez en apprendre davantage sur les conceptions LLM, les bases de données vectorielles, les intégres, les ingénieurs rapides, etc., ce qui nécessite du temps mais est facile à apprendre dans un mois. 

Fonctionner le modèle exige une expertise technique élevée. De la préparation de l'ensemble de données à la définition des paramètres de réglage à la surveillance des performances du modèle, des années d'expérience dans le domaine du traitement du langage naturel sont nécessaires. 

mettre la théorie à l'épreuve avec des exemples pratiques

Testons notre théorie en fournissant la même invite à un modèle affiné, une application de chiffon et une approche hybride, puis en évaluant les résultats. L'approche hybride combinera le modèle affiné avec l'application de chiffon. Pour cet exemple, nous utiliserons l'ensemble de données Ruslanmv / Ai-Medical-Chatbot à partir de l'étreinte Face, qui contient des conversations entre les patients et les médecins sur divers conditions de santé.

Building Rag Application Using Llama 3

Nous allons commencer par construire l'application RAG en utilisant l'écosystème Llama 3 et Langchain. 

Vous pouvez également apprendre à créer une application de chiffon à l'aide de Llamaindex en suivant le code, récupération de la génération augmentée avec Llamaindex.

1. Installez tous les packages Python nécessaires.

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

2. Chargez les fonctions nécessaires des bibliothèques de Langchain et 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. Pour accéder aux modèles et ensembles de données restreints, il est recommandé de vous connecter au centre de face étreint à l'aide de la touche 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. Chargez l'ensemble de données en fournissant le nom de l'ensemble de données et le nom de la colonne à HuggingFaceDataSetLoader. Les colonnes «Doctor» seront notre document principal, et le reste des colonnes sera les métadonnées. 

5. Limiter notre ensemble de données aux 1000 premières lignes. La réduction de l'ensemble de données nous aidera à réduire le temps de stockage des données dans la base de données vectorielle. 

# 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]

Comme nous pouvons le voir, la colonne «Doctor» est le contenu de la page et les autres sont considérés comme des métadonnées. 

6. Chargez le modèle d'intégration à partir de la face de l'étreinte en utilisant des paramètres spécifiques comme l'activation de l'accélération du GPU.

7. Testez le modèle d'incorporation en lui fournissant l'exemple de texte.

# 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]

[-0.059351932257413864, 0.08008933067321777, 0.040729623287916183]

8. Convertissez les données en intégres et enregistrez-les dans la base de données vectorielle.

9. Enregistrez la base de données vectorielle dans le répertoire local.

10. Effectuez une recherche de similitude à l'aide de l'invite d'échantillon.

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. Convertissez l'instance de base de données vectorielle en Retriever. Cela nous aidera à créer la chaîne de chiffons.

retriever = vector_db.as_retriever()

12. Chargez le tokenizer et le modèle à l'aide du modèle de chat Llama 3 8b.

13. Utilisez-les pour créer le pipeline de génération de tests.

14. Convertissez le pipeline en client Langchain 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)

15. Créez une chaîne de questions et réponses à l'aide du retriever, de la requête utilisateur, de l'invite de chiffon et de LLM.

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()
)

16. Testez la chaîne de questions et réponses en posant des questions au médecin.

question = "Hi Doctor, I have a headache, help me."
result = qa_chain.invoke(question)
print(result.split("Answer: ")[1])

Il est assez similaire à l'ensemble de données, mais il ne ramasse pas le style. Il a compris le contexte et l'a utilisé pour écrire la réponse dans son propre style. 

réessayons avec une autre question. 

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

Il s'agit d'une réponse très directe. Peut-être que nous devons affiner le modèle au lieu d'utiliser l'approche RAG pour le médecin et le chatbot patient. 

Si vous rencontrez des difficultés à exécuter le code, veuillez consulter le cahier Kaggle: Créer une application de chiffon à l'aide de Llama 3.

Apprenez à améliorer les performances du système de chiffon avec des techniques telles que le groupe, le rediffusion et les transformations de requête en suivant la façon d'améliorer les performances des chiffons: 5 techniques clés avec des exemples tutoriel.

LALAME FINIGING 3 sur les données médicales

Nous ne devons pas affiner le modèle sur l'ensemble de données Doctor and Patient parce que nous l'avons déjà fait dans un tutoriel précédent: Fine-Tuning Llama 3 et l'utiliser localement: un guide étape par étape. Ce que nous allons faire, c'est charger le modèle affiné et lui fournir la même question pour évaluer les résultats. Le modèle affiné est disponible sur le visage étreint et Kaggle.

Si vous êtes intéressé à affiner le modèle GPT-4 à l'aide de l'API OpenAI, vous pouvez vous référer au didacticiel DataCamp facile à suivre.

Source: Kingabzpro / llama-3-8b-chat-doctor

1. Chargez le tokenizer et le modèle à l'aide de la bibliothèque Transformer.

2. Assurez-vous d'utiliser les paramètres corrects pour charger le modèle dans l'environnement Kaggle GPU T4 X2.

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. Appliquez le modèle de chat aux messages.

4. Créez un pipeline de génération de texte à l'aide du modèle et du tokenzer.

5. Fournissez l'objet pipeline avec une invite et générez la réponse.

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)

La réponse est assez similaire à l'ensemble de données. Le style est le même, mais au lieu de donner une réponse directe, cela suggère que le patient subit d'autres tests.

6. Posons la deuxième question.

# 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]

Le style est le même, et la réponse est assez empathique et explicative. 

Si vous rencontrez des difficultés à exécuter le code, veuillez consulter le cahier Kaggle: inférence Llama 3 HF.

Approche hybride (ragin-réglage)

Nous allons désormais fournir au modèle affiné un contexte supplémentaire pour régler davantage la réponse et trouver l'équilibre. 

Au lieu d'écrire à nouveau tout le code, nous plongerons directement dans la génération de réponse en utilisant la chaîne de questions et réponses. Si vous souhaitez voir le code complet pour la façon dont nous avons combiné un modèle affiné avec une chaîne de questions et réponses, veuillez consulter le cahier Kaggle Approche hybride (Rag Fineding). 

Fournir à la chaîne les mêmes questions que nous avons posée au RAG et au modèle affiné.

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

La réponse est assez précise et la réponse est générée dans le style du médecin. 

Posons la deuxième question.

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

C'est étrange. Nous n'avons jamais fourni un contexte supplémentaire pour savoir si l'acné est remplie de PUS ou non. Peut-être que le modèle hybride ne s'applique pas à certaines requêtes. 

Dans le cas d'un chatbot médecin-patient, le modèle affiné excellent dans l'adoption et la précision de style. Cependant, cela pourrait varier pour d'autres cas d'utilisation, c'est pourquoi il est important de effectuer des tests approfondis pour déterminer la meilleure méthode pour votre cas d'utilisation spécifique.

Le terme officiel pour l'approche hybride est le RAFF (récupération ajustée augmentée). En savoir plus à ce sujet en lisant Qu'est-ce que le radeau? Combinant des chiffons et du réglage fin pour adapter les LLMS au blog des domaines spécialisés.

comment choisir entre le chiffon vs fin à vs radeau

Tout dépend de votre cas d'utilisation et de vos ressources disponibles. Si vous êtes une startup avec des ressources limitées, essayez de créer une preuve de concept de chiffon à l'aide de l'API AI ouverte et du cadre Langchain. Pour cela, vous aurez besoin de ressources, d'expertise et de jeux de données limités. 

Si vous êtes une entreprise de niveau intermédiaire et que vous souhaitez affiner pour améliorer la précision de la réponse et déployer le modèle open source sur le cloud, vous devez embaucher des experts comme les scientifiques des données et les ingénieurs des opérations d'apprentissage automatique. Le réglage fin nécessite des GPU haut de gamme, une grande mémoire, un ensemble de données nettoyé et une équipe technique qui comprennent les LLM. 

Une solution hybride est à la fois des ressources et des calculs. Il nécessite également un ingénieur LLMOPS qui peut équilibrer le réglage fin et le chiffon. Vous devriez considérer cela lorsque vous souhaitez améliorer encore votre génération de réponse en profitant des bonnes qualités de chiffon et d'un modèle affiné. 

Veuillez vous référer au tableau ci-dessous pour un aperçu du chiffon, du réglage fin et des solutions de radeau.

	rag	Fine-tun	radeau
Avantages	compréhension contextuelle, minimise les hallucinations, s'adapte facilement aux nouvelles données, rentable.	Expertise spécifique à la tâche, personnalisation, précision améliorée, robustesse accrue.	combine les forces du chiffon et du réglage fin, une compréhension et un contexte plus profonds.
Inconvénients	Gestion des sources de données, complexité.	biais de données, fortes ressources, coûts de calcul élevés, exigences de mémoire substantielles, temps et expertise à forte intensité.	La complexité de la mise en œuvre, nécessite d'équilibrer les processus de récupération et de réglage fin.
Complexité d'implémentation	supérieur à l'ingénierie rapide.	supérieur à Rag. Nécessite des experts hautement techniques.	le plus complexe des trois.
style d'apprentissage	dynamique	statique	statique dynamique
Adaptabilité	s'adapte facilement aux nouvelles données et à l'évolution des faits.	Personnalisez les sorties vers des tâches et des domaines spécifiques.	s'adapte à la fois aux données en temps réel et aux tâches spécifiques.
Coût	bas	modéré	élevé
Intensité des ressources	bas. Les ressources sont utilisées pendant l'inférence.	modéré. Les ressources sont utilisées pendant le réglage fin.	élevé

Conclusion

Les grands modèles de langue sont au cœur du développement de l'IA aujourd'hui. Les entreprises recherchent différentes façons d'améliorer et de personnaliser ces modèles sans dépenser des millions de dollars en formation. Ils commencent par l'optimisation des paramètres et l'ingénierie rapide. Ils sélectionnent le chiffon ou affinent le modèle pour obtenir une réponse encore meilleure et réduire les hallucinations. Bien qu'il existe d'autres techniques pour améliorer la réponse, ce sont les options les plus populaires disponibles.

Dans ce tutoriel, nous avons appris les différences entre le chiffon et le réglage fin à la fois à la théorie et aux exemples pratiques. Nous avons également exploré des modèles hybrides et comparé la méthode pourrait vous fonctionner le mieux.

Pour en savoir plus sur le déploiement de LLMS et les différentes techniques impliquées, consultez notre code sur RAG avec Llamaindex et notre cours sur le déploiement des applications LLM avec Langchain.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!