Update app.py

app.py

@@ -1,75 +1,70 @@
 import gradio as gr
-from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
+from transformers import pipeline
 from PIL import Image
-from PyPDF2 import PdfReader
+import pytesseract
+import json
 from reportlab.lib.pagesizes import letter
 from reportlab.pdfgen import canvas
 
-# Load OCR model for extracting text from images
-ocr_model = pipeline("image-to-text", model="nlpconnect/vit-gpt2-image-captioning")
+# Load BioGPT model for recommendations
+bio_gpt = pipeline("text-generation", model="microsoft/BioGPT")
 
-# Load medical AI model (BioGPT or similar) for prescription validation
-medical_model_name = "microsoft/BioGPT"
-medical_tokenizer = AutoTokenizer.from_pretrained(medical_model_name)
-medical_model = AutoModelForSequenceClassification.from_pretrained(medical_model_name)
+# Load reference ranges from dataset.json
+def load_reference_ranges(file_path="dataset.json"):
+    with open(file_path, "r") as file:
+        reference_ranges = json.load(file)
+    return reference_ranges
 
-# Function to extract text from images or PDFs
-def extract_text(file_path):
+reference_ranges = load_reference_ranges()
+
+# Extract text from uploaded image using OCR
+def extract_text_from_image(image):
     try:
-        # Handle PDFs
-        if file_path.endswith(".pdf"):
-            reader = PdfReader(file_path)
-            text = "".join(page.extract_text() for page in reader.pages)
-            return text.strip()
-        # Handle images
-        result = ocr_model(Image.open(file_path))
-        return result[0]['generated_text']
+        text = pytesseract.image_to_string(Image.open(image))
+        return text
     except Exception as e:
-        return f"Error processing the file: {e}"
-
-# Function to validate prescription using the medical model
-def validate_prescription_with_model(extracted_text):
-    # Tokenize and process with the AI model
-    inputs = medical_tokenizer(extracted_text, return_tensors="pt", truncation=True, padding=True)
-    outputs = medical_model(**inputs)
-    logits = outputs.logits
-    predictions = logits.softmax(dim=-1)
-
-    # Generate model-driven validation results
-    validation_report = "🔍 Prescription Validation Results:\n"
-    for i, score in enumerate(predictions[0]):
-        token = medical_tokenizer.decode([i]).strip()
-        if token not in ["[PAD]", "[unused1]"]:  # Ignore invalid tokens
-            validation_report += f"- {token}: {score.item():.2f}\n"
-    return validation_report
-
-# Main function to handle prescription analysis
-def analyze_prescription(file):
-    try:
-        # Step 1: Extract text
-        extracted_text = extract_text(file)
-        if not extracted_text.strip():
-            return "No readable text found in the uploaded file.", None
+        return f"Error extracting text: {e}"
 
-        # Step 2: Validate prescription using AI model
-        validation_report = validate_prescription_with_model(extracted_text)
+# Analyze extracted text and compare against reference ranges
+def analyze_blood_report(text):
+    abnormalities = []
+    analysis = "Blood Test Analysis Results:\n\n"
 
-        # Combine the extracted text and validation results
-        full_report = f"Extracted Text:\n{extracted_text}\n\n{validation_report}"
+    for param, ranges in reference_ranges.items():
+        if param in text.lower():
+            try:
+                # Mock parsing logic to extract the value
+                value = float(text.split(param)[1].split()[0])  # Extract value after the parameter name
+                if value < ranges["low"]:
+                    abnormalities.append(f"{param.capitalize()} is LOW ({value} {ranges['unit']}).")
+                elif value > ranges["high"]:
+                    abnormalities.append(f"{param.capitalize()} is HIGH ({value} {ranges['unit']}).")
+                else:
+                    analysis += f"{param.capitalize()} is NORMAL ({value} {ranges['unit']}).\n"
+            except Exception:
+                analysis += f"{param.capitalize()} could not be analyzed.\n"
 
-        # Step 3: Generate a PDF report
-        output_pdf = "prescription_validation_report.pdf"
-        create_pdf_report(full_report, output_pdf)
+    # Flag abnormalities
+    if abnormalities:
+        analysis += "\nAbnormalities Detected:\n" + "\n".join(abnormalities) + "\n"
+    else:
+        analysis += "\nNo abnormalities detected.\n"
 
-        return full_report, output_pdf
-    except Exception as e:
-        return f"Error processing file: {e}", None
+    return analysis, abnormalities
 
-# Function to create a PDF report
-def create_pdf_report(content, output_path):
+# Generate recommendations using BioGPT
+def get_recommendations(abnormalities):
+    if not abnormalities:
+        return "No recommendations needed."
+    query = " ".join(abnormalities) + " Provide medical recommendations."
+    recommendations = bio_gpt(query, max_length=100, num_return_sequences=1)[0]["generated_text"]
+    return recommendations
+
+# Create a PDF report
+def create_pdf_report(content, output_path="blood_test_report.pdf"):
     c = canvas.Canvas(output_path, pagesize=letter)
-    c.drawString(100, 750, "Prescription Validation Report")
-    c.drawString(100, 730, "------------------------------")
+    c.drawString(100, 750, "Blood Test Report")
+    c.drawString(100, 730, "-----------------")
     y_position = 700
     for line in content.split("\n"):
         c.drawString(100, y_position, line)
@@ -77,20 +72,59 @@ def create_pdf_report(content, output_path):
     c.save()
     return output_path
 
-# Gradio interface
+# Main function to process blood test image
+def process_blood_test(image):
+    # Step 1: Extract text
+    extracted_text = extract_text_from_image(image)
+    if "Error" in extracted_text:
+        return extracted_text, None
+
+    # Step 2: Analyze extracted text
+    analysis, abnormalities = analyze_blood_report(extracted_text)
+
+    # Step 3: Generate recommendations
+    recommendations = get_recommendations(abnormalities)
+
+    # Step 4: Combine results and create PDF
+    full_report = analysis + "\nRecommendations:\n" + recommendations
+    pdf_path = create_pdf_report(full_report)
+
+    return full_report, pdf_path
+
+# Gradio Interface
 interface = gr.Interface(
-    fn=analyze_prescription,
-    inputs=gr.File(label="Upload your Prescription (PNG, JPG, JPEG, or PDF)"),
+    fn=process_blood_test,
+    inputs=gr.Image(type="file", label="Upload Blood Test Report Image (PNG, JPG, JPEG)"),
     outputs=[
-        gr.Textbox(label="Validation Results"),
-        gr.File(label="Download PDF Report")
+        gr.Textbox(label="Analysis and Recommendations"),
+        gr.File(label="Download PDF Report"),
     ],
-    title="AI-Powered Prescription Validator",
+    title="AI Blood Test Analyzer",
     description=(
-        "Upload your medical prescription in image (PNG, JPG, JPEG) or PDF format. "
-        "The app will extract the text, analyze it using advanced AI models, and validate the prescription. "
-        "Download a comprehensive PDF report of the validation results."
+        "Upload a blood test report image (PNG, JPG, JPEG), and the app will analyze the values, flag abnormalities, "
+        "and provide recommendations using BioGPT. You can also download a PDF report."
     ),
+    theme="compact",
+    css="""
+        body {
+            font-family: 'Arial', sans-serif;
+            background-color: #f9f9f9;
+        }
+        .gradio-container {
+            color: #333;
+            max-width: 800px;
+            margin: 0 auto;
+        }
+        .gradio-container .label {
+            font-weight: bold;
+            font-size: 18px;
+        }
+        .gradio-container .output {
+            background-color: #eef;
+            padding: 10px;
+            border-radius: 10px;
+        }
+    """,
     allow_flagging="never"
 )