Upload 11 files

api/alzheimers.py

@@ -0,0 +1,54 @@
+# app/api/alzheimers.py
+from fastapi import APIRouter, UploadFile, File, HTTPException
+from core.utils import preprocess_image_tf, generate_gemini_insights
+from functools import lru_cache
+import numpy as np
+import tensorflow as tf
+import os
+
+router = APIRouter()
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+MODEL_PATH = os.path.join(BASE_DIR, "models", "alzheimers.h5")
+
+CLASS_LABELS = [
+    "Mild Dementia",
+    "Moderate Dementia",
+    "Non Demented",
+    "Very Mild Dementia",
+]
+
+
+@lru_cache(maxsize=1)
+def load_model():
+    return tf.keras.models.load_model(MODEL_PATH)  # type: ignore
+
+
+@router.post(
+    "/analyze", name="smritiyaan", description="Analyze Alzheimer's from MRI images"
+)
+async def analyze(file: UploadFile = File(...)):
+    contents = await file.read()
+    if file.content_type not in ["image/jpeg", "image/png"]:
+        raise HTTPException(status_code=400, detail="Only JPG/PNG supported.")
+
+    if len(contents) > 5 * 1024 * 1024:
+        raise HTTPException(status_code=413, detail="Image too large. Max size 5MB.")
+
+    input_tensor = preprocess_image_tf(contents)
+    model = load_model()
+    predictions = model.predict(input_tensor)
+    confidences = predictions[0].tolist()
+    predicted_class = CLASS_LABELS[np.argmax(confidences)]
+    confidence_dict = {
+        label: float(conf) for label, conf in zip(CLASS_LABELS, confidences)
+    }
+
+    insights = await generate_gemini_insights(
+        predicted_class, confidence_dict, mode="alzheimers"
+    )
+    return {
+        "predictedClass": predicted_class,
+        "confidences": confidence_dict,
+        "insights": insights,
+    }

api/disease.py

@@ -0,0 +1,280 @@
+# app/api/disease.py
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+import numpy as np
+import pandas as pd
+import pickle
+import ast
+import os
+
+router = APIRouter()
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+model_path = os.path.join(BASE_DIR, "models", "svc2.pkl")
+
+# Load models and data
+with open(model_path, "rb") as f:
+    svc = pickle.load(f)
+
+# Load data files
+DATA_DIR = os.path.join(BASE_DIR, "data")
+
+description = pd.read_csv(os.path.join(DATA_DIR, "description.csv"))
+precautions = pd.read_csv(os.path.join(DATA_DIR, "precautions_df.csv"))
+medications = pd.read_csv(os.path.join(DATA_DIR, "medications.csv"))
+diets = pd.read_csv(os.path.join(DATA_DIR, "diets.csv"))
+workout = pd.read_csv(os.path.join(DATA_DIR, "workout_df.csv"))
+
+# Load symptoms dict and disease list
+symptoms_dict = {
+    "itching": 0,
+    "skin_rash": 1,
+    "nodal_skin_eruptions": 2,
+    "continuous_sneezing": 3,
+    "shivering": 4,
+    "chills": 5,
+    "joint_pain": 6,
+    "stomach_pain": 7,
+    "acidity": 8,
+    "ulcers_on_tongue": 9,
+    "muscle_wasting": 10,
+    "vomiting": 11,
+    "burning_micturition": 12,
+    "spotting_ urination": 13,
+    "fatigue": 14,
+    "weight_gain": 15,
+    "anxiety": 16,
+    "cold_hands_and_feets": 17,
+    "mood_swings": 18,
+    "weight_loss": 19,
+    "restlessness": 20,
+    "lethargy": 21,
+    "patches_in_throat": 22,
+    "irregular_sugar_level": 23,
+    "cough": 24,
+    "high_fever": 25,
+    "sunken_eyes": 26,
+    "breathlessness": 27,
+    "sweating": 28,
+    "dehydration": 29,
+    "indigestion": 30,
+    "headache": 31,
+    "yellowish_skin": 32,
+    "dark_urine": 33,
+    "nausea": 34,
+    "loss_of_appetite": 35,
+    "pain_behind_the_eyes": 36,
+    "back_pain": 37,
+    "constipation": 38,
+    "abdominal_pain": 39,
+    "diarrhoea": 40,
+    "mild_fever": 41,
+    "yellow_urine": 42,
+    "yellowing_of_eyes": 43,
+    "acute_liver_failure": 44,
+    "fluid_overload": 45,
+    "swelling_of_stomach": 46,
+    "swelled_lymph_nodes": 47,
+    "malaise": 48,
+    "blurred_and_distorted_vision": 49,
+    "phlegm": 50,
+    "throat_irritation": 51,
+    "redness_of_eyes": 52,
+    "sinus_pressure": 53,
+    "runny_nose": 54,
+    "congestion": 55,
+    "chest_pain": 56,
+    "weakness_in_limbs": 57,
+    "fast_heart_rate": 58,
+    "pain_during_bowel_movements": 59,
+    "pain_in_anal_region": 60,
+    "bloody_stool": 61,
+    "irritation_in_anus": 62,
+    "neck_pain": 63,
+    "dizziness": 64,
+    "cramps": 65,
+    "bruising": 66,
+    "obesity": 67,
+    "swollen_legs": 68,
+    "swollen_blood_vessels": 69,
+    "puffy_face_and_eyes": 70,
+    "enlarged_thyroid": 71,
+    "brittle_nails": 72,
+    "swollen_extremeties": 73,
+    "excessive_hunger": 74,
+    "extra_marital_contacts": 75,
+    "drying_and_tingling_lips": 76,
+    "slurred_speech": 77,
+    "knee_pain": 78,
+    "hip_joint_pain": 79,
+    "muscle_weakness": 80,
+    "stiff_neck": 81,
+    "swelling_joints": 82,
+    "movement_stiffness": 83,
+    "spinning_movements": 84,
+    "loss_of_balance": 85,
+    "unsteadiness": 86,
+    "weakness_of_one_body_side": 87,
+    "loss_of_smell": 88,
+    "bladder_discomfort": 89,
+    "foul_smell_of urine": 90,
+    "continuous_feel_of_urine": 91,
+    "passage_of_gases": 92,
+    "internal_itching": 93,
+    "toxic_look_(typhos)": 94,
+    "depression": 95,
+    "irritability": 96,
+    "muscle_pain": 97,
+    "altered_sensorium": 98,
+    "red_spots_over_body": 99,
+    "belly_pain": 100,
+    "abnormal_menstruation": 101,
+    "dischromic _patches": 102,
+    "watering_from_eyes": 103,
+    "increased_appetite": 104,
+    "polyuria": 105,
+    "family_history": 106,
+    "mucoid_sputum": 107,
+    "rusty_sputum": 108,
+    "lack_of_concentration": 109,
+    "visual_disturbances": 110,
+    "receiving_blood_transfusion": 111,
+    "receiving_unsterile_injections": 112,
+    "coma": 113,
+    "stomach_bleeding": 114,
+    "distention_of_abdomen": 115,
+    "history_of_alcohol_consumption": 116,
+    "fluid_overload.1": 117,
+    "blood_in_sputum": 118,
+    "prominent_veins_on_calf": 119,
+    "palpitations": 120,
+    "painful_walking": 121,
+    "pus_filled_pimples": 122,
+    "blackheads": 123,
+    "scurring": 124,
+    "skin_peeling": 125,
+    "silver_like_dusting": 126,
+    "small_dents_in_nails": 127,
+    "inflammatory_nails": 128,
+    "blister": 129,
+    "red_sore_around_nose": 130,
+    "yellow_crust_ooze": 131,
+}  # Keep your full symptoms_dict here
+
+diseases_list = {
+    15: "Fungal infection",
+    4: "Allergy",
+    16: "GERD",
+    9: "Chronic cholestasis",
+    14: "Drug Reaction",
+    33: "Peptic ulcer diseae",
+    1: "AIDS",
+    12: "Diabetes ",
+    17: "Gastroenteritis",
+    6: "Bronchial Asthma",
+    23: "Hypertension ",
+    30: "Migraine",
+    7: "Cervical spondylosis",
+    32: "Paralysis (brain hemorrhage)",
+    28: "Jaundice",
+    29: "Malaria",
+    8: "Chicken pox",
+    11: "Dengue",
+    37: "Typhoid",
+    40: "hepatitis A",
+    19: "Hepatitis B",
+    20: "Hepatitis C",
+    21: "Hepatitis D",
+    22: "Hepatitis E",
+    3: "Alcoholic hepatitis",
+    36: "Tuberculosis",
+    10: "Common Cold",
+    34: "Pneumonia",
+    13: "Dimorphic hemmorhoids(piles)",
+    18: "Heart attack",
+    39: "Varicose veins",
+    26: "Hypothyroidism",
+    24: "Hyperthyroidism",
+    25: "Hypoglycemia",
+    31: "Osteoarthristis",
+    5: "Arthritis",
+    0: "(vertigo) Paroymsal  Positional Vertigo",
+    2: "Acne",
+    38: "Urinary tract infection",
+    35: "Psoriasis",
+    27: "Impetigo",
+}  # Keep your full diseases_list here
+
+
+display_to_actual = {sym.replace("_", " "): sym for sym in symptoms_dict.keys()}
+
+
+class SymptomsInput(BaseModel):
+    symptoms: list[str]
+
+
+def get_predicted_value(symptom_list):
+    input_vector = np.zeros(len(symptoms_dict))
+    for sym in symptom_list:
+        sym_clean = display_to_actual.get(sym)
+        if sym_clean:
+            input_vector[symptoms_dict[sym_clean]] = 1
+    return diseases_list[svc.predict([input_vector])[0]]
+
+
+def helper(disease):
+    desc = description[description["Disease"] == disease]["Description"]
+    desc = desc.values[0] if not desc.empty else "Description not available."
+
+    pre = precautions[precautions["Disease"] == disease].iloc[:, 1:].dropna(axis=1)
+    pre = (
+        pre.values.flatten().tolist()
+        if not pre.empty
+        else ["Precautions not available."]
+    )
+
+    med = medications[medications["Disease"] == disease]["Medication"]
+    med = (
+        ast.literal_eval(med.values[0])
+        if not med.empty
+        else ["Medications not available."]
+    )
+
+    die = diets[diets["Disease"] == disease]["Diet"]
+    die = (
+        ast.literal_eval(die.values[0])
+        if not die.empty
+        else ["Diet recommendations not available."]
+    )
+
+    wrkout = workout[workout["disease"] == disease]["workout"]
+    wrkout = (
+        wrkout.values.flatten().tolist()
+        if not wrkout.empty
+        else ["Workouts not available."]
+    )
+
+    return desc, pre, med, die, wrkout
+
+
+@router.post(
+    "/predict", name="rog_dristi", description="Predict disease based on symptoms"
+)
+def predict_disease(data: SymptomsInput):
+    if not data.symptoms:
+        raise HTTPException(status_code=400, detail="No symptoms provided.")
+
+    try:
+        predicted_disease = get_predicted_value(data.symptoms)
+        desc, pre, med, die, wrkout = helper(predicted_disease)
+
+        return {
+            "predicted_disease": predicted_disease,
+            "description": desc,
+            "precautions": pre,
+            "medications": med,
+            "diet": die,
+            "workouts": wrkout,
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

api/pneumonia.py

@@ -0,0 +1,84 @@
+# app/api/pneumonia.py
+from fastapi import APIRouter, UploadFile, File, HTTPException
+from core.utils import preprocess_image_pil, generate_gemini_insights
+import torch
+import torch.nn as nn
+import torchvision.models as models
+import torchvision.transforms as T
+import os
+from typing import Tuple
+from PIL import Image
+
+router = APIRouter()
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+class_names = ["NORMAL", "PNEUMONIA"]
+
+transform = T.Compose(
+    [
+        T.Resize((256, 256)),
+        T.CenterCrop(224),
+        T.ToTensor(),
+        T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+    ]
+)
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+MODEL_PATH = os.path.join(BASE_DIR, "models", "pneumonia.pt")
+
+
+def load_model(model_path: str) -> nn.Module:
+    model = models.vgg19(pretrained=False)
+    in_features = (
+        model.classifier[0].in_features
+        if isinstance(model.classifier[0], nn.Linear)
+        else 25088
+    )
+    model.classifier = nn.Sequential(
+        nn.Linear(in_features, 4096),  # type: ignore
+        nn.ReLU(inplace=True),
+        nn.Dropout(0.5),
+        nn.Linear(4096, 4096),
+        nn.ReLU(inplace=True),
+        nn.Dropout(0.5),
+        nn.Linear(4096, 2),
+        nn.LogSoftmax(dim=1),
+    )
+    model.load_state_dict(torch.load(model_path, map_location=device))
+    model.to(device).eval()
+    return model
+
+
+model = load_model(MODEL_PATH)
+
+
+def predict(image: Image.Image) -> Tuple[str, float]:
+    tensor_image: torch.Tensor = transform(image)  # type: ignore
+    input_tensor = tensor_image.unsqueeze(0).to(device)
+    with torch.no_grad():
+        output = model(input_tensor)
+        probs = torch.exp(output)
+        confidence, predicted_idx = torch.max(probs, dim=1)
+        return class_names[predicted_idx.item()], float(confidence.item())  # type: ignore
+
+
+@router.post(
+    "/predict",
+    name="shwaas_veda",
+    description="Predict pneumonia from chest X-ray images",
+)
+async def classify_image(file: UploadFile = File(...)):
+    try:
+        contents = await file.read()
+        image = preprocess_image_pil(contents)
+        label, confidence = predict(image)
+        analysis = await generate_gemini_insights(
+            label, {label: confidence}, mode="pneumonia"
+        )
+        return {
+            "prediction": label,
+            "confidence": round(confidence, 4),
+            "gemini_analysis": analysis,
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")

api/tumor.py

@@ -0,0 +1,57 @@
+# app/api/tumor.py
+from fastapi import APIRouter, UploadFile, File, HTTPException
+from core.utils import preprocess_image_tf, generate_gemini_insights
+from functools import lru_cache
+import numpy as np
+from keras import Sequential
+from keras.layers import TFSMLayer
+import os
+
+router = APIRouter()
+
+CLASS_LABELS = ["glioma", "meningioma", "no_tumor", "pituitary"]
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+MODEL_PATH = os.path.join(BASE_DIR, "models", "tumor_effnet")
+
+
+@lru_cache(maxsize=1)
+def load_model():
+    return Sequential([TFSMLayer(MODEL_PATH, call_endpoint="serving_default")])
+
+
+@router.post(
+    "/classify",
+    name="neuro_setu",
+    description="Classify brain tumor type from MRI images",
+)
+async def classify(file: UploadFile = File(...)):
+    try:
+        contents = await file.read()
+        if file.content_type not in ["image/jpeg", "image/png"]:
+            raise HTTPException(status_code=400, detail="Only JPG/PNG supported.")
+
+        input_tensor = preprocess_image_tf(contents)
+        model = load_model()
+        predictions = model(input_tensor)
+
+        if isinstance(predictions, dict):
+            predictions = list(predictions.values())[0]
+
+        confidences = predictions[0].numpy().tolist()  # type: ignore
+        predicted_class = CLASS_LABELS[np.argmax(confidences)]
+        confidence_dict = {
+            label: round(float(score), 4)
+            for label, score in zip(CLASS_LABELS, confidences)
+        }
+
+        insights = await generate_gemini_insights(
+            predicted_class, confidence_dict, mode="tumor"
+        )
+        return {
+            "predictedClass": predicted_class,
+            "confidences": confidence_dict,
+            "insights": insights,
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Classification failed: {str(e)}")

core/config.py

@@ -0,0 +1,14 @@
+# app/core/config.py
+import os
+from dotenv import load_dotenv
+import google.generativeai as genai
+
+load_dotenv()
+
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+
+if GEMINI_API_KEY:
+    genai.configure(api_key=GEMINI_API_KEY) # type: ignore
+    GEMINI_MODEL = genai.GenerativeModel("gemini-2.5-flash") # type: ignore
+else:
+    raise ValueError("Missing GEMINI_API_KEY in .env file")

core/utils.py

@@ -0,0 +1,58 @@
+# app/core/utils.py
+import numpy as np
+import tensorflow as tf
+import io
+from PIL import Image
+from .config import GEMINI_MODEL
+
+
+def preprocess_image_tf(image_bytes):
+    img = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+    img = img.resize((224, 224))
+    img_array = tf.keras.preprocessing.image.img_to_array(img) # type: ignore
+    return np.expand_dims(img_array / 255.0, axis=0)
+
+
+def preprocess_image_pil(image_bytes):
+    img = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+    return img
+
+
+async def generate_gemini_insights(label, confidences, mode="general"):
+    confidence = confidences[label] * 100
+
+    if mode == "tumor":
+        prompt = f"""
+        You are a medical assistant. Generate a tumor analysis report for diagnosis **{label}** with confidence {confidence:.1f}%.
+        Include:
+        - Description
+        - Common MRI findings
+        - Recommended medical steps
+        - Lifestyle/care suggestions
+        Avoid markdown or HTML.
+        """
+    elif mode == "alzheimers":
+        prompt = f"""
+        Generate Alzheimer’s medical report for type '{label}' with {confidence:.1f}% confidence.
+        Explain:
+        - Symptoms
+        - MRI observations
+        - Next steps
+        - Care strategies
+        Format as plain text only.
+        """
+    elif mode == "pneumonia":
+        prompt = f"""
+        Explain in layman terms the medical condition '{label}' with {confidence:.1f}% confidence.
+        Focus on:
+        - What it is
+        - Symptoms
+        - What the patient should do
+        Format in markdown.
+        """
+    else:
+        prompt = f"Explain medical condition '{label}' with {confidence:.1f}% confidence."
+
+    response = await GEMINI_MODEL.generate_content_async(prompt)
+    return response.text
+

main.py

@@ -0,0 +1,63 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from routes.router import api_router
+from scalar_fastapi import get_scalar_api_reference
+
+app = FastAPI(
+    title="IntelliCure API",
+    description="A unified API for various medical models including Brain Tumor classification, Alzheimer's analysis, Pneumonia detection, and Disease prediction.",
+    version="1.0.0",
+    docs_url=None,
+    redoc_url=None,
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(api_router)
+
+
+@app.get(
+    "/",
+    name="home",
+    description="Welcome to the IntelliCure API!",
+)
+async def root():
+    return {
+        "message": "🧠 Welcome to the IntelliCure API!",
+        "overview": (
+            "This API provides AI-assisted diagnostics for brain tumors, pneumonia, Alzheimer's disease, "
+            "and symptom-based illness detection."
+        ),
+        "available_endpoints": [
+            "/tumor/classify - Brain tumor classification from MRI images",
+            "/pneumonia/predict - Pneumonia prediction from chest X-ray images",
+            "/alzheimers/analyze - Alzheimer's analysis from MRI images",
+            "/disease/predict - Disease prediction based on symptoms",
+            "/health - Health check endpoint",
+        ],
+        "tip": "For request formats, supported fields, and model details, visit /docs.",
+        "disclaimer": (
+            "This API is for educational and experimental use. Predictions should not replace professional medical advice."
+        ),
+    }
+
+
+@app.get("/health", summary="Health Check", description="Check if the API is healthy.")
+async def health_check():
+    return {"status": "healthy"}
+
+
+@app.get("/docs", include_in_schema=False)
+async def scalar_html():
+    return get_scalar_api_reference(
+        openapi_url=app.openapi_url or "/openapi.json",
+        title=app.title,
+        hide_models=True,
+        hide_download_button=True,
+    )

pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "backend"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "fastapi>=0.115.14",
+    "google-generativeai>=0.8.5",
+    "numpy>=2.1.3",
+    "pandas>=2.3.0",
+    "pillow>=11.2.1",
+    "python-dotenv>=1.1.1",
+    "python-multipart>=0.0.20",
+    "scalar-fastapi>=1.0.3",
+    "scikit-learn>=1.7.0",
+    "tensorflow>=2.19.0",
+    "torch>=2.7.1",
+    "torchvision>=0.22.1",
+    "uvicorn>=0.34.3",
+]

requirements.txt

@@ -1,2 +1,15 @@
-fastapi
-uvicorn[standard]
+# requirements.txt
+fastapi
+uvicorn
+tensorflow
+pillow
+numpy
+torch
+torchvision
+python-dotenv
+google-generativeai
+scikit-learn
+pandas
+scalar-fastapi
+python-multipart
+scalar-fastapi

routes/router.py

@@ -0,0 +1,21 @@
+# app/routes/router.py
+from fastapi import APIRouter
+from api import tumor, pneumonia, alzheimers, disease
+
+api_router = APIRouter()
+api_router.include_router(
+    tumor.router,
+    prefix="/tumor",
+)  # Tumor Insight
+api_router.include_router(
+    pneumonia.router,
+    prefix="/pneumonia",
+)  # Pneumonia Insight
+api_router.include_router(
+    alzheimers.router,
+    prefix="/alzheimers",
+)  # Alzheimer Insight
+api_router.include_router(
+    disease.router,
+    prefix="/disease",
+)  # General Disease Classification