Update app.py

app.py

@@ -1,106 +1,134 @@
-import gradio as gr
-import fitz  # PyMuPDF
-import re
-import numpy as np
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from sentence_transformers import SentenceTransformer
+import fitz  # PyMuPDF pour extraction du texte PDF
 import faiss
-from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.preprocessing import normalize
-import google.generativeai as gemini
+import os
+import numpy as np
+import requests
+import gradio as gr
 
-# Step 1: Configure Gemini API
-GEMINI_API_KEY = "AIzaSyDiyT3x5563LM3k277sR8qQ2wAwWIpb-lQ"  
+# Configuration de l'API Gemini
+GEMINI_API_KEY = "AIzaSyArbgg_p_HlmpgrcjVYemdSJeMCP9OTj3E"
 GEMINI_API_URL = "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-latest:generateContent"
 
-
-# Step 2: Define Medical Knowledge Base
-medical_knowledge = [
-    "Normal hemoglobin levels are 13.8 to 17.2 g/dL for men and 12.1 to 15.1 g/dL for women.",
-    "Low hemoglobin levels indicate anemia, causing fatigue and weakness.",
-    "High hemoglobin levels may suggest polycythemia or dehydration.",
-    "Normal fasting blood glucose levels are 70 to 99 mg/dL.",
-    "Elevated glucose levels indicate diabetes or prediabetes and require further testing.",
-]
-
-# Step 3: Build FAISS Index
-vectorizer = TfidfVectorizer()
-knowledge_vectors = vectorizer.fit_transform(medical_knowledge).toarray()
-knowledge_vectors = normalize(knowledge_vectors)  # Normalize vectors for cosine similarity
-
-# Initialize FAISS Index
-dimension = knowledge_vectors.shape[1]
-faiss_index = faiss.IndexFlatL2(dimension)
-faiss_index.add(knowledge_vectors)
-
-def retrieve_medical_knowledge(parameter):
-    """Retrieve relevant knowledge using FAISS."""
-    query_vector = vectorizer.transform([parameter]).toarray()
-    query_vector = normalize(query_vector)  # Normalize the query vector
-    _, indices = faiss_index.search(query_vector, 1)  # Retrieve top 1 result
-    return medical_knowledge[indices[0][0]]
-
-# Step 4: Extract Text from PDF
-def extract_text_from_pdf(pdf_file):
-    """Extract text from the uploaded PDF file."""
-    text = ""
-    with fitz.open(pdf_file.name) as pdf:  # Use file path directly
-        for page in pdf:
-            text += page.get_text()
-    return text
-
-# Step 5: Parse Blood Test Results
-def parse_blood_test_results(text):
-    """Parse blood test results from extracted PDF text."""
-    results = {}
-
-    # Regular expression to match the table format: Component, Value, Min, Max, Units, State
-    pattern = r"(?P<component>\w+)\s+(?P<value>[\d.]+)\s+(?P<min>[\d.]+)\s+(?P<max>[\d.]+)\s+(?P<units>\w+/?.*)\s+(?P<state>\w+)"
-
-    matches = re.finditer(pattern, text, re.IGNORECASE)
-
-    for match in matches:
-        component = match.group("component")
-        value = float(match.group("value"))
-        state = match.group("state")
-        results[component] = {"value": value, "state": state}
-
+# Configuration des embeddings et FAISS
+EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+model = SentenceTransformer(EMBEDDING_MODEL)
+INDEX_PATH = "medical_faiss_index"
+documents = []  # Liste pour stocker les textes indexés
+
+# Chargement ou création de l'index FAISS
+if os.path.exists(INDEX_PATH):
+    index = faiss.read_index(INDEX_PATH)
+    print("Index FAISS chargé avec succès.")
+else:
+    index = faiss.IndexFlatL2(model.get_sentence_embedding_dimension())
+    print("Nouvel index FAISS créé.")
+
+# Fonction pour extraire le texte des fichiers PDF
+def extract_text_from_pdf(file_content: bytes):
+    pdf = fitz.open(stream=file_content, filetype="pdf")
+    paragraphs = []
+    for page in pdf:
+        text = page.get_text()
+        if text.strip():
+            paragraphs.extend([p.strip() for p in text.split("\n\n") if p.strip()])
+    return paragraphs
+
+# Ajouter des documents médicaux à l'index FAISS
+def add_medical_reference(file_content: bytes):
+    global index, documents
+    paragraphs = extract_text_from_pdf(file_content)
+    embeddings = model.encode(paragraphs)
+    index.add(np.array(embeddings, dtype="float32"))
+    documents.extend(paragraphs)
+    faiss.write_index(index, INDEX_PATH)
+
+# Recherche dans FAISS pour trouver les documents pertinents
+def search_faiss(query, k=5):
+    query_embedding = model.encode([query])
+    distances, indices = index.search(np.array(query_embedding, dtype="float32"), k)
+    results = [documents[i] for i in indices[0] if i < len(documents)]
     return results
 
+# Appel à l'API Gemini
+def call_gemini_api(prompt):
+    headers = {"Content-Type": "application/json"}
+    payload = {
+        "contents": [
+            {
+                "parts": [
+                    {"text": prompt}
+                ]
+            }
+        ]
+    }
+    try:
+        response = requests.post(f"{GEMINI_API_URL}?key={GEMINI_API_KEY}", json=payload, headers=headers)
+        response.raise_for_status()
+        response_json = response.json()
+        candidates = response_json.get("candidates", [])
+        if candidates:
+            return candidates[0]["content"]["parts"][0]["text"]
+        return "Pas de réponse disponible depuis Gemini."
+    except requests.exceptions.RequestException as e:
+        return f"Erreur API Gemini : {str(e)}"
+
+# Ajouter un PDF de référence médicale
+def upload_reference(file):
+    file_content = file.read()
+    add_medical_reference(file_content)
+    return "Référence médicale ajoutée avec succès."
+
+# Analyser un PDF d'analyse de sang
+def analyze_blood_test(file):
+    file_content = file.read()
+    test_results = extract_text_from_pdf(file_content)
 
-# Step 6: Generate Personalized Advice
-def generate_advice(test_results):
-    """Generate personalized health advice using Gemini API."""
-    advice = {}
-    for parameter, value in test_results.items():
-        medical_info = retrieve_medical_knowledge(parameter)
-        prompt = (
-            f"The patient's {parameter} level is {value}. {medical_info} "
-            "Provide a clear, concise health recommendation."
-        )
-        response = gemini.generate_text(prompt=prompt)  # Fixed API call
-        advice[parameter] = response.result
-    return advice
-
-
-# Step 7: Main Function for Gradio Interface
-def analyze_blood_test(pdf_file):
-    """Main function to analyze the uploaded blood test PDF."""
-    text = extract_text_from_pdf(pdf_file)
-    test_results = parse_blood_test_results(text)
     if not test_results:
-        return {"error": "No recognizable blood test results found in the PDF."}  # Always return a dictionary
-    advice = generate_advice(test_results)
-    return advice  # This is a dictionary
-
-
-# Gradio Interface
-iface = gr.Interface(
-    fn=analyze_blood_test,
-    inputs=gr.File(label="Upload Blood Test PDF"),
-    outputs=gr.JSON(label="Health Advice"),  # Ensure valid JSON is returned
-    title="Blood Test Analysis with RAG and Gemini (FAISS)",
-    description="Upload a PDF with blood test results to receive personalized health advice."
-)
-
-
-if __name__ == "__main__":
-    iface.launch()
+        return "Aucun texte valide extrait du fichier d'analyse."
+
+    # Combine tous les résultats d'analyse dans un seul texte
+    query = "\n".join(test_results)
+
+    # Recherche dans l'index FAISS
+    relevant_docs = search_faiss(query, k=5)
+    context = "\n".join(relevant_docs)
+
+    # Enrichir le prompt avec les informations pertinentes
+    enriched_prompt = f"Voici les résultats d'analyse :\n{query}\n\nContexte pertinent :\n{context}"
+    gemini_response = call_gemini_api(enriched_prompt)
+
+    return {
+        "Réponse générée": gemini_response,
+        "Documents pertinents": relevant_docs
+    }
+
+# Interface Gradio
+def gradio_upload_reference(file):
+    return upload_reference(file)
+
+def gradio_analyze_blood_test(file):
+    response = analyze_blood_test(file)
+    if isinstance(response, dict):
+        return f"Réponse générée :\n{response['Réponse générée']}\n\nDocuments pertinents :\n{response['Documents pertinents']}"
+    return response
+
+# Lancer l'application Gradio
+with gr.Blocks() as demo:
+    gr.Markdown("## Analyse Médicale avec RAG et Gemini")
+    
+    with gr.Tab("Ajouter Références Médicales"):
+        ref_file = gr.File(label="Téléchargez un fichier PDF de référence médicale")
+        ref_output = gr.Textbox(label="Résultat")
+        ref_button = gr.Button("Ajouter")
+        ref_button.click(gradio_upload_reference, inputs=ref_file, outputs=ref_output)
+    
+    with gr.Tab("Analyser un Résultat d'Analyse"):
+        test_file = gr.File(label="Téléchargez un fichier PDF d'analyse de sang")
+        analysis_output = gr.Textbox(label="Résultat")
+        analyze_button = gr.Button("Analyser")
+        analyze_button.click(gradio_analyze_blood_test, inputs=test_file, outputs=analysis_output)
+
+demo.launch()