Create app.py

app.py

@@ -0,0 +1,454 @@
+import streamlit as st
+from PIL import Image
+import torch
+import torch.nn as nn
+from torchvision import transforms
+from torchvision.models import vit_b_16, ViT_B_16_Weights
+import pandas as pd
+import io
+import os
+import base64
+from fpdf import FPDF
+from sqlalchemy import create_engine
+from langchain.chains import RetrievalQA
+from langchain.prompts import PromptTemplate
+from qdrant_client import QdrantClient
+from qdrant_client.http.models import Distance, VectorParams
+from sentence_transformers import SentenceTransformer
+from langchain_community.vectorstores.pgvector import PGVector
+from langchain_postgres import PGVector
+from langchain_openai import OpenAIEmbeddings, ChatOpenAI
+from langchain_community.vectorstores import Qdrant
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_community.embeddings import SentenceTransformerEmbeddings
+import streamlit as st
+import torchvision.transforms as transforms
+import torch
+import torch.nn as nn
+import numpy as np
+from PIL import Image
+import torch.nn.functional as F
+from evo_vit import EvoViTModel
+import io
+import os
+from fpdf import FPDF
+from openai import OpenAI
+from sqlalchemy import create_engine
+from langchain_community.vectorstores.pgvector import PGVector
+from langchain_postgres import PGVector
+from langchain_openai import OpenAIEmbeddings, ChatOpenAI
+from langchain.chains import RetrievalQA
+from langchain.prompts import PromptTemplate
+from torchvision.models import resnet50
+import nest_asyncio
+from sentence_transformers import SentenceTransformer
+
+# model = SentenceTransformer("Alibaba-NLP/gte-Qwen2-1.5B-instruct", trust_remote_code=True)
+
+nest_asyncio.apply()
+device='cuda' if torch.cuda.is_available() else 'cpu'
+
+st.set_page_config(page_title="DermBOT", page_icon="🧬", layout="centered")
+
+# os.environ["PGVECTOR_CONNECTION_STRING"] = "postgresql+psycopg2://postgres:postgres@localhost:5432/VectorDB"
+
+# === Model Selection ===
+available_models = ["OpenAI GPT-4o", "LLaMA 3", "Gemini Pro"]
+st.session_state["selected_model"] = st.sidebar.selectbox("Select LLM Model", available_models)
+
+# === Qdrant DB Setup ===
+qdrant_client = QdrantClient(
+    url="https://2715ddd8-647f-40ee-bca4-9027d193e8aa.us-east-1-0.aws.cloud.qdrant.io",
+    api_key="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhY2Nlc3MiOiJtIn0.HXzezXdWMFeeR16F7zvqgjzsqrcm8hqa-StXdToFP9Q"
+)
+collection_name = "ks_collection_1.5BE"
+# embedding_model = SentenceTransformer("D:\DR\RAG\gte-Qwen2-1.5B-instruct", trust_remote_code=True)
+# embedding_model.max_seq_length = 8192
+# local_embedding = SentenceTransformerEmbeddings(model=embedding_model)
+
+model = SentenceTransformer("Alibaba-NLP/gte-Qwen2-1.5B-instruct", trust_remote_code=True)
+
+
+local_embedding = HuggingFaceEmbeddings(
+    model_name="Alibaba-NLP/gte-Qwen2-1.5B-instruct",
+    model_kwargs={"trust_remote_code": True, "device": "cuda" if torch.cuda.is_available() else "cpu"}
+)
+print(" Qwen2-1.5B local embedding model loaded.")
+
+vector_store = Qdrant(
+    client=qdrant_client,
+    collection_name=collection_name,
+    embeddings=local_embedding
+)
+retriever = vector_store.as_retriever()
+
+'''
+# === Init LLM and Vector DB ===
+
+CONNECTION_STRING = "postgresql+psycopg2://postgres:postgres@localhost:5432/VectorDB"
+engine = create_engine(CONNECTION_STRING)
+embedding_model = OpenAIEmbeddings(api_key=OPENAI_API_KEY)
+'''
+# Dynamically initialize LLM based on selection
+OPENAI_API_KEY = st.secrets["OPENAI_API_KEY"]
+selected_model = st.session_state["selected_model"]
+if "OpenAI" in selected_model:
+    llm = ChatOpenAI(model="gpt-4o", temperature=0.2, api_key=OPENAI_API_KEY)
+elif "LLaMA" in selected_model:
+    st.warning("LLaMA integration is not implemented yet.")
+    st.stop()
+elif "Gemini" in selected_model:
+    st.warning("Gemini integration is not implemented yet.")
+    st.stop()
+else:
+    st.error("Unsupported model selected.")
+    st.stop()
+
+'''
+vector_store = PGVector.from_existing_index(
+    embedding=embedding_model,
+    connection=engine,
+    collection_name="documents"
+)
+'''
+# retriever = vector_store.as_retriever()
+
+AI_PROMPT_TEMPLATE = """You are an AI-assisted Dermatology Chatbot, specializing in diagnosing and educating users about skin diseases.
+You provide accurate, compassionate, and detailed explanations while using correct medical terminology.
+
+Guidelines:
+1. Symptoms - Explain in simple terms with proper medical definitions.
+2. Causes - Include genetic, environmental, and lifestyle-related risk factors.
+3. Medications & Treatments - Provide common prescription and over-the-counter treatments.
+4. Warnings & Emergencies - Always recommend consulting a licensed dermatologist.
+5. Emergency Note - If symptoms worsen or include difficulty breathing, **advise calling 911 immediately.
+
+Query: {question}
+Relevant Information: {context}
+Answer:
+"""
+prompt_template = PromptTemplate(template=AI_PROMPT_TEMPLATE, input_variables=["question", "context"])
+
+rag_chain = RetrievalQA.from_chain_type(
+    llm=llm,
+    retriever=retriever,
+    chain_type="stuff",
+    chain_type_kwargs={"prompt": prompt_template, "document_variable_name": "context"}
+)
+
+
+''''
+Load My models
+'''
+
+def load_model(model_path):
+    model = EvoViTModel(img_size=224, patch_size=16, in_channels=3, embed_dim=768, num_classes=2, hidden_dim=512)
+    model.classifier = nn.Linear(512, 1)
+    state_dict = torch.load(model_path, map_location=device)
+    new_state_dict = {}
+    for key, value in state_dict.items():
+        if key.startswith("backbone."):
+            new_key = key[len("backbone."):]
+        else:
+            new_key = key
+        new_state_dict[new_key] = value
+
+    if "classifier.weight" in new_state_dict:
+        original_weight = new_state_dict["classifier.weight"]
+        new_state_dict["classifier.weight"] = original_weight[0:1, :]
+    if "classifier.bias" in new_state_dict:
+        original_bias = new_state_dict["classifier.bias"]
+        new_state_dict["classifier.bias"] = original_bias[0:1]
+    model.load_state_dict(new_state_dict, strict=False)
+    model.to(device)
+    model.eval()
+    return model
+
+def load_binary_models():
+    base_models = []
+    class_models_mapping = {
+        "Acne and Rosacea Photos": 'santhosh/10fold_model_acne.pth',
+        "Actinic Keratosis Basal Cell Carcinoma and other Malignant Lesions": 'santhosh/5fold_model_actinic.pth',
+        "Atopic Dermatitis Photos": 'keerthi/Atopic/best_global_model_5fold.pth',
+        "Bullous Disease Photos": 'santhosh/10fold_model_bullous.pth',
+        "Cellulitis Impetigo and other Bacterial Infections": 'santhosh/10fold_model_cellulitis.pth',
+        "Eczema Photos": 'santhosh/5fold_model_eczema.pth',
+        "ExanthemsandDrugEruptions": 'santhosh/10fold_model_exantherms.pth',
+        "Hair Loss Photos Alopecia and other Hair Diseases": 'keerthi/HairLoss/best_global_model_5fold.pth',
+        "Herpes HPV and other STDs Photos": 'keerthi/Herpes/best_global_model_5fold.pth',
+        "Light Diseases and Disorders of Pigmentation": 'santhosh/5fold_model_light.pth',
+        "Lupus and other Connective Tissue diseases": 'keerthi/Lupus/best_global_model_5fold.pth',
+        "Melanoma Skin Cancer Nevi and Moles": 'keerthi/Melanoma/best_global_model_10fold.pth',
+        "Nail Fungus and other Nail Disease": 'santhosh/5fold_model_nail.pth',
+        "Poison Ivy Photos and other Contact Dermatitis": 'santhosh/5fold_model_poison.pth',
+        "Psoriasis pictures Lichen Planus and related diseases": 'santhosh/10fold_model_psoriasis.pth',
+        "Scabies Lyme Disease and other Infestations and Bites": 'santhosh/5fold_model_scabies.pth',
+        "Seborrheic Keratoses and other Benign Tumors": 'santhosh/10fold_model_seboh.pth',
+        "Systemic Disease": 'keerthi/Systemic/best_global_model_5fold.pth',
+        "Tinea Ringworm Candidiasis and other Fungal Infections": 'santhosh/10fold_model_tinea.pth',
+        "Urticaria Hives": 'keerthi/Urticaria/best_global_model_10fold.pth',
+        "Vascular Tumors": 'keerthi/Vascular/best_global_model_5fold.pth',
+        "Vasculitis Photos": 'keerthi/Vasculitis/best_global_model_10fold.pth',
+        "Warts Molluscum and other Viral Infections": 'santhosh/10fold_model_warts.pth'
+    }
+    for class_name, rel_path in class_models_mapping.items():
+        model_path = os.path.join("best_models_overall", rel_path)
+        model = load_model(model_path)
+        base_models.append(model)
+    return base_models
+
+
+class DynamicCNN(nn.Module):
+    def __init__(self, input_channels, fc_layers, num_classes, dropout_rate=0.3):
+        super(DynamicCNN, self).__init__()
+        fc_layers_list = []
+        in_dim = input_channels
+
+        for fc_dim in fc_layers:
+            fc_layers_list.append(nn.Linear(in_dim, fc_dim))
+            fc_layers_list.append(nn.BatchNorm1d(fc_dim))
+            fc_layers_list.append(nn.ReLU())
+            fc_layers_list.append(nn.Dropout(dropout_rate))
+            in_dim = fc_dim
+
+        fc_layers_list.append(nn.Linear(in_dim, num_classes))
+        self.fc = nn.Sequential(*fc_layers_list)
+
+    def forward(self, x):
+        x = self.fc(x)
+        return x
+
+
+class SkinDiseaseClassifier:
+    def __init__(self, device='cuda' if torch.cuda.is_available() else 'cpu'):
+        self.device = torch.device(device)
+        self.class_names = [
+            "Acne and Rosacea Photos",
+            "Actinic Keratosis Basal Cell Carcinoma and other Malignant Lesions",
+            "Atopic Dermatitis Photos",
+            "Bullous Disease Photos",
+            "Cellulitis Impetigo and other Bacterial Infections",
+            "Eczema Photos",
+            "ExanthemsandDrugEruptions",
+            "Hair Loss Photos Alopecia and other Hair Diseases",
+            "Herpes HPV and other STDs Photos",
+            "Light Diseases and Disorders of Pigmentation",
+            "Lupus and other Connective Tissue diseases",
+            "Melanoma Skin Cancer Nevi and Moles",
+            "Nail Fungus and other Nail Disease",
+            "Poison Ivy Photos and other Contact Dermatitis",
+            "Psoriasis pictures Lichen Planus and related diseases",
+            "Scabies Lyme Disease and other Infestations and Bites",
+            "Seborrheic Keratoses and other Benign Tumors",
+            "Systemic Disease",
+            "Tinea Ringworm Candidiasis and other Fungal Infections",
+            "Urticaria Hives",
+            "Vascular Tumors",
+            "Vasculitis Photos",
+            "Warts Molluscum and other Viral Infections"
+        ]
+
+        # Initialize models (they'll be loaded when needed)
+        self.base_models = None
+        self.meta_model = None
+        self.resnet_feature_extractor = None
+
+        # Image transformations
+        self.transform = transforms.Compose([
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ])
+
+    def load_models(self):
+        """Load all required models"""
+        # Load binary models
+        self.base_models = load_binary_models()
+        for model in self.base_models:
+            model.to(self.device)
+            model.eval()
+
+        # Load ResNet feature extractor
+        model = resnet50(pretrained=True)
+        layers = [model.layer1, model.layer2, model.layer3, model.layer4]
+        self.resnet_feature_extractor = nn.Sequential(
+            model.conv1, model.bn1, model.relu, model.maxpool, *layers
+        )
+        self.resnet_feature_extractor.to(self.device)
+        self.resnet_feature_extractor.eval()
+
+        # Load meta model
+        meta_model_path = 'best_meta_model_two_layer_version4.pth'
+        checkpoint = torch.load(meta_model_path, map_location=self.device)
+        correct_input_size = checkpoint['state_dict']['fc.0.weight'].shape[1]
+        input_size = 23 + 4 + 7168  # Adjust based on your actual feature size
+        fc_layers = [1024, 512, 256]  # Use whatever was in your best model
+
+        self.meta_model = DynamicCNN(
+            input_channels=correct_input_size,
+            fc_layers=fc_layers,
+            num_classes=23,
+            dropout_rate=0.5
+        )
+
+        self.meta_model.load_state_dict(checkpoint['state_dict'])
+        self.meta_model.to(self.device)
+        self.meta_model.eval()
+
+    def extract_image_features(self, image_tensor):
+        """Extract features using ResNet"""
+        with torch.no_grad():
+            features = []
+            x = image_tensor
+            for layer in self.resnet_feature_extractor.children():
+                x = layer(x)
+                if isinstance(layer, nn.Sequential):  # For residual blocks
+                    # features.append(F.adaptive_avg_pool2d(x, (1, 1)).flatten(1))
+                    # features = torch.cat(features, dim=1)
+                    pooled = F.adaptive_avg_pool2d(x, (1, 1)).flatten(1)
+                    features.append(pooled)
+            features = torch.cat(features, dim=1)
+        return features.cpu().numpy()
+
+    def predict(self, image, top_k=3):
+        """Make prediction for a single image"""
+        if self.base_models is None or self.meta_model is None:
+            self.load_models()
+
+        # Load and preprocess image
+        try:
+            # image = Image.open(image_path).convert('RGB')
+            image = image.convert('RGB')
+        except:
+            raise ValueError("Could not load image from path")
+
+        image_tensor = self.transform(image).unsqueeze(0).to(self.device)
+
+        # Extract features
+        with torch.no_grad():
+            # Get probabilities from each binary model
+            binary_probs = []
+            for model in self.base_models:
+                outputs = model(image_tensor)
+                probs = torch.sigmoid(outputs).squeeze(1)
+                binary_probs.append(probs)
+
+            binary_features = torch.stack(binary_probs, dim=1)
+
+            # Get image features
+            image_features = self.extract_image_features(image_tensor)
+            image_features = torch.from_numpy(image_features).float().to(self.device)
+
+            # Calculate probability statistics
+            top3_probs = torch.topk(binary_features, 3, dim=1).values
+            prob_stats = torch.stack([
+                binary_features.mean(dim=1, keepdim=True),
+                binary_features.std(dim=1, keepdim=True),
+                top3_probs.mean(dim=1, keepdim=True),
+                (top3_probs[:, 0] - top3_probs[:, 2]).unsqueeze(1)  # Confidence gap
+            ], dim=1).squeeze(-1)
+
+            # Combine all features
+            combined_features = torch.cat([
+                binary_features,
+                image_features,
+                prob_stats
+            ], dim=1)
+
+        # Make prediction with meta-model
+        with torch.no_grad():
+            outputs = self.meta_model(combined_features)
+            probabilities = torch.softmax(outputs, dim=1).squeeze().cpu().numpy()
+
+        # Get top predictions
+        top_indices = np.argsort(probabilities)[-top_k:][::-1]
+        top_predictions = [
+            (self.class_names[i], float(probabilities[i]))
+            for i in top_indices
+        ]
+
+        return {
+            "top_predictions": top_predictions,
+            "all_probabilities": {name: float(prob) for name, prob in zip(self.class_names, probabilities)}
+        }
+
+
+classifier = SkinDiseaseClassifier()
+
+
+# === Session Init ===
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+
+# === Image Processing Function ===
+def run_inference(image):
+
+    result = classifier.predict(image, top_k=1)
+
+    # Display results
+    print("Top Predictions:")
+    for name, prob in result["top_predictions"]:
+        print(f"{name}: {prob:.2%}")
+
+    print("\nYou can also access all probabilities:")
+    print(result["all_probabilities"])
+
+    predicted_label = result["top_predictions"][0][0]
+    return predicted_label
+
+
+# === PDF Export ===
+def export_chat_to_pdf(messages):
+    pdf = FPDF()
+    pdf.add_page()
+    pdf.set_font("Arial", size=12)
+    for msg in messages:
+        role = "You" if msg["role"] == "user" else "AI"
+        pdf.multi_cell(0, 10, f"{role}: {msg['content']}\n")
+    buf = io.BytesIO()
+    pdf.output(buf)
+    buf.seek(0)
+    return buf
+
+
+# === App UI ===
+
+st.title("🧬 DermBOT — Skin AI Assistant")
+st.caption(f"🧠 Using model: {selected_model}")
+uploaded_file = st.file_uploader("Upload a skin image", type=["jpg", "jpeg", "png"])
+
+if uploaded_file:
+    st.image(uploaded_file, caption="Uploaded image", use_column_width=True)
+    image = Image.open(uploaded_file).convert("RGB")
+
+    predicted_label = run_inference(image)
+
+    # Show predictions clearly to the user
+    st.markdown(f" Most Likely Diagnosis : {predicted_label}")
+
+    query = f"What are my treatment options for {predicted_label}?"
+    st.session_state.messages.append({"role": "user", "content": query})
+
+    with st.spinner("Analyzing the image and retrieving response..."):
+        response = rag_chain.invoke(query)
+        st.session_state.messages.append({"role": "assistant", "content": response['result']})
+
+    with st.chat_message("assistant"):
+        st.markdown(response['result'])
+
+# === Chat Interface ===
+if prompt := st.chat_input("Ask a follow-up..."):
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    response = llm.invoke([{"role": m["role"], "content": m["content"]} for m in st.session_state.messages])
+    st.session_state.messages.append({"role": "assistant", "content": response.content})
+    with st.chat_message("assistant"):
+        st.markdown(response.content)
+
+# === PDF Button ===
+if st.button("📄 Download Chat as PDF"):
+    pdf_file = export_chat_to_pdf(st.session_state.messages)
+    st.download_button("Download PDF", data=pdf_file, file_name="chat_history.pdf", mime="application/pdf")