Ollama : Chatbot pour assurances PME au Maroc Prompt

Introduction :

Dans un monde où l’information est abondante et souvent dispersée, la capacité à extraire rapidement des réponses pertinentes à partir de documents volumineux est devenue primordiale. Le code présenté ici propose une solution efficace en créant un système de questions-réponses spécifiquement conçu pour les documents PDF. Grâce à des outils tels que FAISS pour l’indexation, OllamaEmbeddings pour la représentation numérique des textes, et le modèle de conversation Phi 3 d’Ollama, cette solution permet d’interroger rapidement et précisément les documents, offrant des réponses ciblées basées uniquement sur le contexte pertinent. Cette approche intègre également un modèle d’invite personnalisé pour garantir que les réponses générées restent contextuellement pertinentes. En utilisant Google Colab et ses puissantes ressources GPU, la solution devient encore plus rapide, rendant l’analyse et l’extraction d’informations beaucoup plus accessibles et efficaces pour les PME et autres organisations cherchant à optimiser leur processus décisionnel.

Technologies Utilisées

Langage de programmations :

Le langage de programmation utilisé est python.

Chargement et Préparation des Documents

• PyPDFLoader : Pour charger le fichier PDF et en extraire le contenu sous forme de documents.
• CharacterTextSplitter : Pour diviser le document en petits morceaux de texte de taille gérable.

Embeddings et Indexation

• OllamaEmbeddings : Pour transformer les morceaux de texte en représentations numériques (embeddings).
• FAISS (Facebook AI Similarity Search) : Pour créer un index des embeddings et faciliter la recherche rapide des morceaux pertinents.

Modèle d’Invite et Langage

• ChatOllama : Pour charger et interroger le modèle de conversation Phi 3 d’Ollama.
• Modèle Phi 3 : Un modèle de conversation développé par Ollama pour répondre aux questions des utilisateurs.

Environnement d’Exécution

• Google Colab : Pour utiliser les GPU et accélérer le traitement et l’inférence des modèles

Comment ça marche ?

Partie Desktop :

Télécharger Ollama :

En visitant le site suivant : https://ollama.com/download , on peut à présent télécharger ollama pour MacOs , Linux et Windows

Télécharger un modèle

Par l’intermédiaire de l’invite de commandes cmd on peut télécharger un modèle Llm ou d’embeddings

Téléchargement LLM :

Téléchargement embeddings :

Pour visualiser tous les modèle téléchargé via cmd

Le code :

from langchain_community.chat_models import ChatOllama
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import CharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

# Load and process the PDF
loader = PyPDFLoader("GUIDE D’ASSURANCE DE LA PME.pdf")
documents = loader.load()
print("Le fichier a été uploadé")
text_splitter = CharacterTextSplitter(chunk_size=200, chunk_overlap=20)
texts = text_splitter.split_documents(documents)
print("Le fichier divisé en plusieurs sous documents")

# Generate embeddings and initialize a retriever
embeddings = OllamaEmbeddings(model="mxbai-embed-large", show_progress=True)
db = FAISS.from_documents(texts, embeddings)
retriever = db.as_retriever()

# Create a prompt template
template = """Répondez à la question uniquement sur la base du contexte suivant:

    {context}

    Question: {question}
    """
prompt = ChatPromptTemplate.from_template(template)

# Define the LLM and the full chain
model = ChatOllama(model="phi3", num_predict=2000)

def format_docs(docs):
    return "\\n\\n".join([d.page_content for d in docs])

chain = (
    {
        "context": retriever | format_docs,
        "question": RunnablePassthrough()
    }
    | prompt
    | model
    | StrOutputParser()
)

question = input("Votre question : ")
response=chain.invoke({"question": question})
print(response)

Explication

1. Importations
   • ChatOllama et OllamaEmbeddings : Modèles de langage spécialisés de langchain_community.
   • PyPDFLoader : Chargeur de documents pour les PDF.
   • CharacterTextSplitter : Divise les documents en plus petits morceaux.
   • FAISS : Base vectorielle pour des recherches de similarité efficaces.
   • ChatPromptTemplate : Définit un modèle qui garantit que les réponses sont basées uniquement sur le contexte pertinent.
   • StrOutputParser : Analyse les sorties du modèle sous forme de chaînes de caractères.
   • RunnablePassthrough : Transfère les données sans modification.
2. Chargement et Division du Document PDF
   • loader = PyPDFLoader("GUIDE D’ASSURANCE DE LA PME.pdf") : Charge le PDF spécifié.
   • documents = loader.load() : Charge toutes les pages du PDF en tant que documents.
   • text_splitter = CharacterTextSplitter(chunk_size=200, chunk_overlap=20) : Initialise un diviseur de texte pour diviser le document en morceaux de 200 caractères avec un chevauchement de 20 caractères.
   • texts = text_splitter.split_documents(documents) : Divise le PDF chargé en plus petits morceaux.
3. Création et Initialisation des Embeddings et d’un Retriever
   • embeddings = OllamaEmbeddings(model="mxbai-embed-large", show_progress=True) : Charge un modèle d’embedding pour convertir le texte en représentations numériques (embeddings).
   • db = FAISS.from_documents(texts, embeddings) : Crée un index FAISS à partir des morceaux de texte.
   • retriever = db.as_retriever() : Prépare un retriever pour rechercher les morceaux pertinents dans l’index FAISS.
4. Définition du Modèle d’Invite
   • template = """Répondez à la question uniquement sur la base du contexte suivant:\\n\\n {context}\\n\\n Question: {question}\\n """ : Définit un modèle qui garantit que les réponses sont basées uniquement sur le contexte pertinent.
5. Initialisation du Modèle de Langage et de la Chaîne
   • model = ChatOllama(model="phi3", num_predict=2000) : Charge le modèle de conversation Phi 3 à partir d’Ollama.
   • def format_docs(docs): : Fonction pour formater les documents récupérés en texte brut.
   • chain = ({"context": retriever | format_docs, "question": RunnablePassthrough()} | prompt | model | StrOutputParser()) : Met en place une chaîne de traitement qui :
     1. Récupère les documents pertinents à l’aide du retriever.
     2. Les formate en texte.
     3. Passe le texte formaté et la question au modèle d’invite.
     4. Fournit l’invite au modèle de conversation pour la génération.
     5. Analyse la sortie pour renvoyer une réponse propre.
6. Entrée de la Question et Génération de la Réponse
   • question = input("Votre question : ") : Prend une question de l’utilisateur en entrée.
   • response = chain.invoke({"question": question}) : Invoque la chaîne pour obtenir une réponse basée sur la question de l’utilisateur.
   • print(response) : Affiche la réponse générée.

Résumé

Ce code crée un système de questions-réponses pour les documents PDF en :

1. Chargeant un document PDF.
2. Divisant le document en morceaux gérables.
3. Indexant ces morceaux en utilisant FAISS et en les représentant avec un modèle spécialisé.
4. Créant un modèle d’invite pour les questions-réponses.
5. Utilisant un modèle de langage pour répondre aux questions sur la base des morceaux pertinents récupérés dans le PDF.
6. Invoquant la chaîne de traitement pour générer des réponses aux questions des utilisateurs.

Résultat :

La partie Desktop nécessite malheureusement des ressources matérielles performantes. L’utilisation sur CPU est très lente : l’indexation du texte a pris 8 minutes, et la réponse du modèle environ 6 minutes. De plus, il n’est pas possible d’utiliser des modèles d’embedding pour l’indexation via des API, comme c’est le cas avec OpenAI. Ollama n’utilise que les éléments téléchargeables via Ollama.

Partie Colab :

Avec Google Colab on peut utiliser des GPU performants pour pouvoir utiliser Ollama

!curl -fsSL <https://ollama.com/install.sh> | sh

Par la suite sur l’invite de Google Colab , on tape les syntaxe suivantes :

ollama serve : démarrez ensuite le serveur Ollama

ollama pull phi3 : télécharger modèle phi 3

znbang/bge:large-en-v1.5-f16 : télécharger modèle embeddings BGE ( meilleur retour au niveau du RAG)

Le reste du code est le même

Conclusion :

En résumé, ce système de questions-réponses basé sur des documents PDF représente une avancée significative dans le domaine de l’extraction d’informations. En combinant le pouvoir des embeddings spécialisés, l’indexation par FAISS, et la flexibilité des modèles de langage avancés, cette solution répond efficacement aux besoins des utilisateurs en leur fournissant des réponses précises et contextuelles. Malgré les limitations matérielles sur les ordinateurs de bureau, l’utilisation de Google Colab permet d’exploiter pleinement le potentiel des modèles Ollama et FAISS, rendant la recherche d’informations beaucoup plus rapide et précise. Cette solution illustre parfaitement comment les avancées récentes en IA peuvent être appliquées de manière pratique pour répondre aux défis quotidiens de l’accès à l’information.

4-Colab_RAG_with_Langchain_%26_Ollama_Phi3.ipynb

GUIDE.PDF

3-Desktop_langchain_Ollama_Phi3.py