Upload 3 files

RAG Mistral AI (testé sur un corpus de 86 des 200 textes sélectionnés, soucis de graph TNSE à la fin du code #comment) & RAG Open AI (à tester).
Pas de fichier requirements mais toutes les librairies utilisées sont les maj les plus récentes disponibles.
MAJ Test_API_GenAI

RAG_Mistral.py

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Feb 24 15:51:34 2025
+
+@author: MIPO10053340
+
+C:/Users/MIPO10053340/OneDrive - Groupe Avril/Bureau/Salon_Agriculture_2024/Micka_API_Call/Docs_pdf/Docs_pdf/
+
+"""
+
+# -*- coding: utf-8 -*-
+"""
+Optimisation du RAG avec MistralAI - Embeddings en batch
+"""
+import os
+import numpy as np
+import fitz  # PyMuPDF pour extraction PDF
+import faiss
+import matplotlib.pyplot as plt
+from mistralai import Mistral
+from sklearn.manifold import TSNE
+from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
+from dotenv import load_dotenv
+
+# Charger les variables d'environnement
+load_dotenv()
+MISTRAL_API_KEY = os.getenv('MISTRAL_API_KEY_static')
+
+# 📌 Initialisation du client Mistral
+client = Mistral(api_key=MISTRAL_API_KEY)
+model_embedding = "mistral-embed"
+model_chat = "mistral-large-latest"
+temperature = 0.1  # Réduction de la température pour privilégier la RAG
+probability = 0.9  # Ajustement de la probabilité pour plus de contrôle
+
+# 📌 Paramètres de segmentation
+chunk_size = 256  # Réduction du chunk size pour un meilleur contrôle du contexte
+chunk_overlap = 15
+
+# 📌 Extraction et segmentation des PDF
+def extract_and_chunk_pdfs(pdf_folder):
+    """Extrait et segmente les textes des PDF en chunks optimisés pour Mistral."""
+    documents = SimpleDirectoryReader(pdf_folder).load_data()
+    chunked_docs = [doc.text for doc in documents]
+    return chunked_docs
+
+# 📌 Génération des embeddings par batch
+def get_embeddings_in_batches(text_chunks, batch_size=5):
+    """Génère les embeddings en batch pour éviter les dépassements de tokens."""
+    embeddings = []
+    for i in range(0, len(text_chunks), batch_size):
+        batch = text_chunks[i:i + batch_size]
+        embeddings_batch_response = client.embeddings.create(
+            model=model_embedding,
+            inputs=batch,
+        )
+        batch_embeddings = [data.embedding for data in embeddings_batch_response.data]
+        embeddings.extend(batch_embeddings)
+    
+    return np.array(embeddings).astype('float32')
+
+# 📌 Chargement et embedding des documents
+pdf_folder = 'C:/Users/MIPO10053340/OneDrive - Groupe Avril/Bureau/Salon_Agriculture_2024/Micka_API_Call/Docs_pdf/'
+chunked_docs = extract_and_chunk_pdfs(pdf_folder)
+embeddings = get_embeddings_in_batches(chunked_docs)
+
+# 📌 Indexation des embeddings avec FAISS
+dimension = embeddings.shape[1]
+index = faiss.IndexFlatL2(dimension)
+index.add(embeddings)
+
+# 📌 Récupération des chunks les plus pertinents
+def retrieve_relevant_chunks(question, k=5):
+    """Recherche les chunks les plus pertinents en fonction de la similarité des embeddings."""
+    question_embedding_response = client.embeddings.create(
+        model=model_embedding,
+        inputs=[question],
+    )
+    question_embedding = np.array(question_embedding_response.data[0].embedding).astype('float32').reshape(1, -1)
+    distances, indices = index.search(question_embedding, k)
+    return [chunked_docs[i] for i in indices[0]]
+
+# 📌 Génération de réponse avec MistralAI
+def generate_response(context, question):
+    """Génère une réponse basée sur le contexte extrait du corpus avec une basse température et un contrôle de probabilité."""
+    messages = [
+        {"role": "system", "content": f"Voici des informations contextuelles à utiliser avec priorité : {context}"},
+        {"role": "user", "content": question}
+    ]
+    
+    response = client.chat.complete(model=model_chat, messages=messages, temperature=temperature, probability=probability)
+    return response.choices[0].message.content
+
+# 📌 Exécuter une requête utilisateur
+user_question = "Quelles sont les souches de poulets ou poules présentent dans les publications de notre corpus utilisé pour la RAG"
+relevant_chunks = retrieve_relevant_chunks(user_question)
+context = "\n".join(relevant_chunks)
+answer = generate_response(context, user_question)
+
+# 📊 Affichage de la réponse
+print("\n🔹 Réponse Mistral :")
+print(answer)
+
+# # 📊 Visualisation des embeddings avec t-SNE
+# tsne = TSNE(n_components=2, perplexity=min(30, max(2, embeddings.shape[0] - 1)), random_state=42)
+# embeddings_2d = tsne.fit_transform(embeddings)
+
+# plt.figure(figsize=(10, 8))
+# plt.scatter(embeddings_2d[:, 0], embeddings_2d[:, 1], alpha=0.5)
+# plt.title('Visualisation des embeddings avec t-SNE')
+# plt.xlabel('Dimension 1')
+# plt.ylabel('Dimension 2')
+# plt.show()
+
+# 💾 Sauvegarde des résultats
+with open("mistral_response.txt", "w", encoding="utf-8") as f:
+    f.write(f"Question : {user_question}\n")
+    f.write(f"Réponse :\n{answer}\n")
+
+print("\n✅ Réponse enregistrée dans 'mistral_response.txt'")

RAG_OpenAI.py

@@ -0,0 +1,95 @@
+import os
+import numpy as np
+import fitz  # PyMuPDF pour extraction PDF
+import faiss
+import openai
+from sklearn.manifold import TSNE
+from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
+from dotenv import load_dotenv
+
+# Charger les variables d'environnement
+load_dotenv()
+OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
+
+# 📌 Initialisation du client OpenAI
+openai.api_key = OPENAI_API_KEY
+model_embedding = "text-embedding-ada-002"
+model_chat = "gpt-4-turbo"
+
+# 📌 Paramètres de segmentation
+chunk_size = 256
+chunk_overlap = 10
+
+# 📌 Extraction et segmentation des PDF
+def extract_and_chunk_pdfs(pdf_folder):
+    """Extrait et segmente les textes des PDF en chunks optimisés pour OpenAI."""
+    documents = SimpleDirectoryReader(pdf_folder).load_data()
+    chunked_docs = [doc.text for doc in documents]
+    return chunked_docs
+
+# 📌 Génération des embeddings par batch
+def get_embeddings_in_batches(text_chunks, batch_size=5):
+    """Génère les embeddings en batch pour éviter les dépassements de tokens."""
+    embeddings = []
+    for i in range(0, len(text_chunks), batch_size):
+        batch = text_chunks[i:i + batch_size]
+        response = openai.Embedding.create(
+            input=batch,
+            model=model_embedding
+        )
+        batch_embeddings = [data['embedding'] for data in response['data']]
+        embeddings.extend(batch_embeddings)
+    
+    return np.array(embeddings).astype('float32')
+
+# 📌 Chargement et embedding des documents
+pdf_folder = 'C:/Users/MIPO10053340/OneDrive - Groupe Avril/Bureau/Salon_Agriculture_2024/Micka_API_Call/Docs_pdf/'
+chunked_docs = extract_and_chunk_pdfs(pdf_folder)
+embeddings = get_embeddings_in_batches(chunked_docs)
+
+# 📌 Indexation des embeddings avec FAISS
+dimension = embeddings.shape[1]
+index = faiss.IndexFlatL2(dimension)
+index.add(embeddings)
+
+# 📌 Récupération des chunks les plus pertinents
+def retrieve_relevant_chunks(question, k=5):
+    """Recherche les chunks les plus pertinents en fonction de la similarité des embeddings."""
+    response = openai.Embedding.create(
+        input=[question],
+        model=model_embedding
+    )
+    question_embedding = np.array(response['data'][0]['embedding']).astype('float32').reshape(1, -1)
+    distances, indices = index.search(question_embedding, k)
+    return [chunked_docs[i] for i in indices[0]]
+
+# 📌 Génération de réponse avec OpenAI
+def generate_response(context, question):
+    """Génère une réponse basée sur le contexte extrait du corpus."""
+    messages = [
+        {"role": "system", "content": f"Voici des informations contextuelles : {context}"},
+        {"role": "user", "content": question}
+    ]
+    
+    response = openai.ChatCompletion.create(
+        model=model_chat,
+        messages=messages
+    )
+    return response["choices"][0]["message"]["content"]
+
+# 📌 Exécuter une requête utilisateur
+user_question = "Quelles souches de poulet et poules se trouvent dans ce corpus de texte ?"
+relevant_chunks = retrieve_relevant_chunks(user_question)
+context = "\n".join(relevant_chunks)
+answer = generate_response(context, user_question)
+
+# 📊 Affichage de la réponse
+print("\n🔹 Réponse OpenAI :")
+print(answer)
+
+# 💾 Sauvegarde des résultats
+with open("openai_response.txt", "w", encoding="utf-8") as f:
+    f.write(f"Question : {user_question}\n")
+    f.write(f"Réponse :\n{answer}\n")
+
+print("\n✅ Réponse enregistrée dans 'openai_response.txt'")

Tests_API_GenAI.py

@@ -14,21 +14,18 @@ import pandas as pd
 from scipy.stats import entropy
 
 # API Clients
-from mistralai.client import MistralClient
-from mistralai.models.chat_completion import ChatMessage
+from mistralai import Mistral
+from openai import OpenAI
 
-import openai
-from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
-import transformers_stream_generator
-import einops 
+# from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
 
-HF_TOKEN = "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"
 
 # ⚙️ Configurations API (remplace par tes clés API)
 MISTRAL_API_KEY = os.getenv('MISTRAL_API_KEY_static')
 OPENAI_API_KEY = os.getenv('OPENAI_API_KEY_static')
-ANTHROPIC_API_KEY = os.getenv('ANTHROPIC_API_KEY_static')
-LLAMA_API_KEY = os.getenv('LLAMA_API_KEY_static')
+# ANTHROPIC_API_KEY = os.getenv('ANTHROPIC_API_KEY_static')
+# LLAMA_API_KEY = os.getenv('LLAMA_API_KEY_static')
+# HUGGINGFACE_TOKEN =os.getenv('HUGGINGFACE_TOKEN_static')
 
 # 📌 Choix des modèles à utiliser
 USE_MODELS = {
@@ -39,6 +36,7 @@ USE_MODELS = {
     "deepseek": False
 }
 
+
 # 📊 Fonction pour calculer l'entropie des réponses
 def calculate_entropy(text):
     tokens = text.split()
@@ -49,53 +47,64 @@ def calculate_entropy(text):
 def get_model_responses(question):
     responses = {}
 
-    # 🔹 MISTRAL
+    # # 🔹 MISTRAL
     if USE_MODELS["mistral"]:
-        mistral_client = MistralClient(api_key=MISTRAL_API_KEY)
-        messages = [ChatMessage(role="user", content=question)]
-        response = mistral_client.chat(model="mistral-medium", messages=messages)
-        text_response = response.choices[0].message.content
-        responses["mistral"] = {"response": text_response, "entropy": calculate_entropy(text_response)}
+        # Initialisation du client Mistral
+        client = Mistral(api_key=MISTRAL_API_KEY)
+        
+        # Créer une complétion de chat
+        response = client.chat.complete(
+            model="mistral-medium",
+            messages=[
+                {"role": "user", "content": question}
+            ]
+        )
+        # Extraire et afficher la réponse
+        text_response = response.choices[0].message.content    
+        responses["mistral-medium"] = {"response": text_response, "entropy": calculate_entropy(text_response)}
 
     # 🔹 GPT-4 (OpenAI)
     if USE_MODELS["gpt-4"]:
-        #  openai>=1.0.0 
-        client = openai.OpenAI(api_key=OPENAI_API_KEY)
+        # Initialisation du client OpenAI
+        client = OpenAI(api_key=OPENAI_API_KEY)
         
+        # Créer une complétion de chat
         response = client.chat.completions.create(
-            model="gpt-4",
-            messages=[{"role": "user", "content": question}]
+            model="gpt-4-turbo",
+            messages=[
+                {"role": "user", "content": question}
+            ]
         )
-        
-        text_response = response.choices[0].message.content
-        responses["gpt-4"] = {"response": text_response, "entropy": calculate_entropy(text_response)}
-
-    # 🔹 LLAMA (Hugging Face)
-    if USE_MODELS["llama"]:
-        model_id = "meta-llama/Llama-2-7b-chat-hf"
-        tokenizer = AutoTokenizer.from_pretrained(model_id)
-        model = AutoModelForCausalLM.from_pretrained(model_id)
-        pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
-        text_response = pipe(question, max_length=300)[0]["generated_text"]
-        responses["llama"] = {"response": text_response, "entropy": calculate_entropy(text_response)}
-
-    # 🔹 QWEN (Hugging Face)
-    if USE_MODELS["qwen"]:
-        model_id = "Qwen/Qwen-7B-Chat"
-        tokenizer = AutoTokenizer.from_pretrained(model_id, token=HF_TOKEN, trust_remote_code=True)
-        model = AutoModelForCausalLM.from_pretrained(model_id, token=HF_TOKEN, trust_remote_code=True)
-        pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
-        text_response = pipe(question, max_length=300)[0]["generated_text"]
-        responses["qwen"] = {"response": text_response, "entropy": calculate_entropy(text_response)}
-
-    # 🔹 DEEPSEEK (Hugging Face)
-    if USE_MODELS["deepseek"]:
-        model_id = "deepseek-ai/deepseek-7b-chat"
-        tokenizer = AutoTokenizer.from_pretrained(model_id)
-        model = AutoModelForCausalLM.from_pretrained(model_id)
-        pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
-        text_response = pipe(question, max_length=300)[0]["generated_text"]
-        responses["deepseek"] = {"response": text_response, "entropy": calculate_entropy(text_response)}
+        # Extraire et afficher la réponse
+        text_response = response.choices[0].message.content    
+        responses["gpt-4-turbo"] = {"response": text_response, "entropy": calculate_entropy(text_response)}
+
+    # # 🔹 LLAMA (Hugging Face)
+    # if USE_MODELS["llama"]:
+    #     model_id = "meta-llama/Llama-2-7b-chat-hf"
+    #     tokenizer = AutoTokenizer.from_pretrained(model_id, use_auth_token=HUGGINGFACE_TOKEN)
+    #     model = AutoModelForCausalLM.from_pretrained(model_id, use_auth_token=HUGGINGFACE_TOKEN)
+    #     pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
+    
+    #     text_response = pipe(question, max_length=300)[0]["generated_text"]
+    #     responses["llama"] = {"response": text_response, "entropy": calculate_entropy(text_response)}
+    # # 🔹 QWEN (Hugging Face)
+    # if USE_MODELS["qwen"]:
+    #     model_id = "Qwen/Qwen-7B-Chat"
+    #     tokenizer = AutoTokenizer.from_pretrained(model_id, token=HUGGINGFACE_TOKEN, trust_remote_code=True)
+    #     model = AutoModelForCausalLM.from_pretrained(model_id, token=HUGGINGFACE_TOKEN, trust_remote_code=True)
+    #     pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
+    #     text_response = pipe(question, max_length=300)[0]["generated_text"]
+    #     responses["qwen"] = {"response": text_response, "entropy": calculate_entropy(text_response)}
+
+    # # 🔹 DEEPSEEK (Hugging Face)
+    # if USE_MODELS["deepseek"]:
+    #     model_id = "deepseek-ai/deepseek-7b-chat"
+    #     tokenizer = AutoTokenizer.from_pretrained(model_id)
+    #     model = AutoModelForCausalLM.from_pretrained(model_id)
+    #     pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
+    #     text_response = pipe(question, max_length=300)[0]["generated_text"]
+    #     responses["deepseek"] = {"response": text_response, "entropy": calculate_entropy(text_response)}
 
     return responses