Update app.py

app.py

@@ -1,292 +1,120 @@
-# app.py
+# app.py and requirements.txt for Hugging Face Space: Acne Type Classifier
 
-```python
-# app.py
-# Hugging Face Space (Gradio) for Acne Type Classification + Explainability + Mistral Chatbot
+---
 
-import os
-import io
-import requests
-from PIL import Image
-import numpy as np
-import matplotlib.pyplot as plt
-import gradio as gr
+## app.py
 
+```python
+import gradio as gr
+import requests
 import torch
-from torchvision import transforms, models
-from transformers import pipeline
-
-# Optional: Grad-CAM
-from pytorch_grad_cam import GradCAM
-from pytorch_grad_cam.utils.image import show_cam_on_image
-
-# -----------------------------
-# Config / Models
-# -----------------------------
-
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+from PIL import Image
+from transformers import CLIPProcessor, CLIPModel
+import os
+import io
 
-# Zero-shot candidate labels: many acne types (try to cover maximum common types)
-ACNE_LABELS = [
-    "Acne vulgaris",
-    "Comedonal acne",
-    "Inflammatory acne",
-    "Papular acne",
-    "Pustular acne",
-    "Nodulocystic acne",
-    "Nodular acne",
-    "Cystic acne",
-    "Conglobate acne",
-    "Acne rosacea",
-    "Hormonal acne",
-    "Acne mechanica",
-    "Acne keloidalis",
-    "Acneiform eruption",
-    "Post-inflammatory hyperpigmentation",
-    "Milia",
-    "Folliculitis",
-    "Perioral dermatitis",
-    "Seborrheic dermatitis",
-    "Other skin lesion"
+# Initialize model and processor for zero-shot acne classification
+model_id = "openai/clip-vit-base-patch32"
+model = CLIPModel.from_pretrained(model_id)
+processor = CLIPProcessor.from_pretrained(model_id)
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model.to(device)
+
+# Define acne types for classification
+acne_types = [
+    "blackheads",
+    "whiteheads",
+    "papules",
+    "pustules",
+    "nodules",
+    "cysts",
+    "fungal acne",
+    "acne scars",
+    "mild acne",
+    "moderate acne",
+    "severe acne"
 ]
 
-# Zero-shot pipeline using CLIP (open-source)
-print("Loading zero-shot CLIP pipeline...")
-try:
-    zsl_pipe = pipeline("zero-shot-image-classification", model="openai/clip-vit-base-patch32")
-except Exception as e:
-    print("Failed to load CLIP pipeline:", e)
-    zsl_pipe = None
-
-# A pretrained CNN for Grad-CAM (ResNet50)
-print("Loading ResNet50 for Grad-CAM...")
-resnet_model = models.resnet50(pretrained=True)
-resnet_model.eval()
-resnet_model.to(DEVICE)
-
-# We will use the final conv layer of resnet50
-CAM_TARGET_LAYER = resnet_model.layer4[-1]
-
-# Preprocessing for ResNet
-resnet_transforms = transforms.Compose([
-    transforms.Resize((224, 224)),
-    transforms.ToTensor(),
-    transforms.Normalize(mean=[0.485, 0.456, 0.406],
-                         std=[0.229, 0.224, 0.225])
-])
-
-# Preprocessing for CLIP pipeline (it accepts PIL images directly)
-
-# -----------------------------
-# Utilities
-# -----------------------------
-
-def load_image_from_url(url_or_path):
-    # Accepts either a URL or a local file path
+# Function to classify acne type from image URL
+def classify_acne(image_url):
     try:
-        if url_or_path.startswith("http://") or url_or_path.startswith("https://"):
-            resp = requests.get(url_or_path, timeout=10)
-            resp.raise_for_status()
-            img = Image.open(io.BytesIO(resp.content)).convert("RGB")
-        else:
-            img = Image.open(url_or_path).convert("RGB")
-        return img
-    except Exception as e:
-        raise RuntimeError(f"Could not load image: {e}")
+        response = requests.get(image_url)
+        image = Image.open(io.BytesIO(response.content)).convert("RGB")
+        inputs = processor(text=acne_types, images=image, return_tensors="pt", padding=True).to(device)
+        outputs = model(**inputs)
+        logits_per_image = outputs.logits_per_image
+        probs = logits_per_image.softmax(dim=1).cpu().detach().numpy()[0]
+        result_idx = probs.argmax()
+        detected_type = acne_types[result_idx]
+        confidence = probs[result_idx]
+
+        explanation = f"Detected acne type: **{detected_type}** (confidence: {confidence:.2f}).\\n\\n"
+        explanation += explain_acne(detected_type)
+        return image, explanation
 
-
-def run_zero_shot(pil_img, candidate_labels=ACNE_LABELS, top_k=3):
-    if zsl_pipe is None:
-        return [("Model not loaded", 0.0)]
-    results = zsl_pipe(pil_img, candidate_labels)
-    # pipeline returns list of dicts or single dict depending on version
-    if isinstance(results, list):
-        res = results[0]
-    else:
-        res = results
-    # Keep top_k
-    out = list(zip(res.get("labels", []), res.get("scores", [])))[:top_k]
-    return out
-
-
-def make_gradcam(pil_img):
-    # returns overlayed cam image as PIL
-    try:
-        img_np = np.array(pil_img).astype(np.float32) / 255.0
-        input_tensor = resnet_transforms(pil_img).unsqueeze(0).to(DEVICE)
-
-        cam = GradCAM(model=resnet_model, target_layer=CAM_TARGET_LAYER, use_cuda=(DEVICE=="cuda"))
-        grayscale_cam = cam(input_tensor=input_tensor, targets=None)
-        grayscale_cam = grayscale_cam[0, :]
-
-        visualization = show_cam_on_image(img_np, grayscale_cam, use_rgb=True)
-        vis_pil = Image.fromarray(visualization)
-        return vis_pil
     except Exception as e:
-        print("Grad-CAM failed:", e)
-        return None
-
+        return None, f"Error: {str(e)}"
 
-def explain_acne_label(label):
-    # Simple rule-based explanations for acne types. You can later replace with richer medical text
+# Function to give acne explanation
+def explain_acne(acne_type):
     explanations = {
-        "Acne vulgaris": "Common acne characterized by comedones (blackheads/whiteheads), papules, pustules; seen on face, chest, back.",
-        "Comedonal acne": "Non-inflammatory acne featuring comedones (blackheads and whiteheads).",
-        "Inflammatory acne": "Inflammatory lesions such as papules and pustules, often red and tender.",
-        "Papular acne": "Small red raised bumps (papules) often from inflammation of follicles.",
-        "Pustular acne": "Pus-filled lesions (pustules) — typically inflammatory.",
-        "Nodulocystic acne": "Severe form with deep nodules and cysts; may cause scarring and requires clinical care.",
-        "Nodular acne": "Large, painful lumps beneath the skin surface (nodules).",
-        "Cystic acne": "Deep, inflamed cysts filled with pus that can be painful and lead to scarring.",
-        "Conglobate acne": "Severe, widespread acne with interconnected nodules and abscesses — needs specialist treatment.",
-        "Acne rosacea": "Rosacea-related acne-like bumps often with facial redness and flushing.",
-        "Hormonal acne": "Flare-ups linked to hormonal changes; often in lower face and jawline.",
-        "Acne mechanica": "Triggered by friction, pressure, or occlusion (e.g., helmets, masks).",
-        "Acne keloidalis": "Keloid-like papules typically on the back of the neck — more common in men of African descent.",
-        "Acneiform eruption": "Acne-like lesions caused by medications or other triggers.",
-        "Post-inflammatory hyperpigmentation": "Dark spots left after acne lesions heal; common in darker skin tones.",
-        "Milia": "Small white cysts often mistaken for closed comedones.",
-        "Folliculitis": "Infection/inflammation of hair follicles that can look like acne.",
-        "Perioral dermatitis": "Rash around the mouth that may resemble acne but has different causes.",
-        "Seborrheic dermatitis": "Greasy scales and redness that can coexist or be mistaken for acne.",
-        "Other skin lesion": "Lesion not typical for acne; consider dermatology consultation."
+        "blackheads": "Blackheads are open clogged pores with oxidized oil, often caused by excess sebum and dead skin.",
+        "whiteheads": "Whiteheads are closed clogged pores that form small white bumps on the skin.",
+        "papules": "Papules are small red bumps caused by inflamed hair follicles.",
+        "pustules": "Pustules are pimples with visible pus, indicating bacterial infection.",
+        "nodules": "Nodules are large, painful acne lesions deep under the skin.",
+        "cysts": "Cystic acne involves pus-filled lesions beneath the skin, often leading to scars.",
+        "fungal acne": "Fungal acne is caused by yeast infection and appears similar to whiteheads.",
+        "acne scars": "Scars are skin indentations or pigmentation left after acne heals.",
+        "mild acne": "Mild acne includes occasional blackheads or small pimples.",
+        "moderate acne": "Moderate acne has more inflamed pimples and occasional nodules.",
+        "severe acne": "Severe acne includes numerous inflamed cysts and nodules, often painful."
     }
-    return explanations.get(label, "No explanation available for this label.")
+    return explanations.get(acne_type, "No explanation available.")
 
-
-# -----------------------------
-# Gradio Interface
-# -----------------------------
-
-def classify_and_explain(image_input, image_url):
-    # image_input is from file uploader, image_url is optional
-    pil_img = None
-    try:
-        if image_input is not None:
-            pil_img = Image.fromarray(image_input).convert("RGB")
-        elif image_url:
-            pil_img = load_image_from_url(image_url)
-        else:
-            return "No image provided", None, None
-    except Exception as e:
-        return f"Error loading image: {e}", None, None
-
-    # Run zero-shot classification
-    try:
-        zsl = run_zero_shot(pil_img, ACNE_LABELS, top_k=3)
-    except Exception as e:
-        zsl = [("Error", 0.0)]
-        print("ZSL error:", e)
-
-    top_label, top_score = zsl[0]
-    explanation = explain_acne_label(top_label)
-
-    # Grad-CAM image
-    cam_img = make_gradcam(pil_img)
-
-    # Prepare textual output + simple suggestion
-    suggestion = "This result is for informational purposes only and does not substitute a medical diagnosis. For severe or persistent acne, consult a dermatologist."
-
-    text_out = f"**Detected:** {top_label} (score: {top_score:.2f})\n\n**Explanation:** {explanation}\n\n{suggestion}"
-
-    return text_out, pil_img, cam_img
-
-
-# Simple Mistral chat wrapper — this will attempt to call a Mistral-style API if configured
+# Chatbot section using Mistral API
 MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY")
-MISTRAL_API_URL = os.getenv("https://api.mistral.ai/v1/chat/completions")  # e.g., set to your model endpoint
-
-
-def mistral_chat(user_message, context_summary=None):
-    # If no API configured, return a fallback response
-    if not MISTRAL_API_KEY or not MISTRAL_API_URL:
-        fallback = (
-            "[Local fallback] I don't have a Mistral API key configured in the environment.\n"
-            "You can set MISTRAL_API_KEY and MISTRAL_API_URL in the Space secrets.\n"
-            "Meanwhile, here's a simple suggestion: maintain gentle skincare, avoid aggressive scrubs, consult a dermatologist for nodulocystic acne."
-        )
-        return fallback
-
-    headers = {
-        "Authorization": f"Bearer {MISTRAL_API_KEY}",
-        "Content-Type": "application/json",
-    }
-
-    prompt = (
-        "You are a helpful dermatology assistant. Answer user queries about acne types, treatments, risks, and when to seek a doctor. "
-        f"Context: {context_summary}\nUser: {user_message}\nAssistant:"
-    )
-
-    payload = {
-        "prompt": prompt,
-        "max_tokens": 300,
-        "temperature": 0.2
-    }
+API_URL = "https://api.mistral.ai/v1/chat/completions"
 
+def chat_with_bot(message, history):
     try:
-        r = requests.post(MISTRAL_API_URL, json=payload, headers=headers, timeout=20)
-        r.raise_for_status()
-        jr = r.json()
-        # Different Mistral endpoints return different shapes — attempt to extract text
-        text = jr.get("text") or jr.get("generated_text") or jr.get("output") or str(jr)
-        return text
+        headers = {"Authorization": f"Bearer {MISTRAL_API_KEY}", "Content-Type": "application/json"}
+        payload = {
+            "model": "mistral-small",
+            "messages": [{"role": "system", "content": "You are a dermatologist assistant chatbot."}] + 
+                        [{"role": "user", "content": message}],
+        }
+        response = requests.post(API_URL, headers=headers, json=payload)
+        data = response.json()
+        reply = data["choices"][0]["message"]["content"]
+        return reply
     except Exception as e:
-        print("Mistral API call failed:", e)
-        return "Mistral API call failed or returned an unexpected response. Check logs and your MISTRAL_API_URL/MISTRAL_API_KEY."
-
+        return f"Error communicating with chatbot: {str(e)}"
 
-with gr.Blocks(title="DermaBot - Acne Type Classifier") as demo:
-    gr.Markdown("# DermaBot — Acne Type Classification (Zero-shot)\nUpload an image or provide a URL. The app will try to classify acne subtype using a CLIP zero-shot model and show a Grad-CAM heatmap from ResNet50. Use the chat box for follow-up questions (Mistral API optional).")
-
-    with gr.Row():
-        with gr.Column(scale=1):
-            image_input = gr.Image(type="numpy", label="Upload image (face/chest/back)")
-            image_url = gr.Textbox(label="Or provide an image URL (http://...)")
-            classify_btn = gr.Button("Classify & Explain")
-            output_text = gr.Markdown()
-        with gr.Column(scale=1):
-            image_display = gr.Image(label="Input Image", interactive=False)
-            cam_display = gr.Image(label="Grad-CAM Overlay", interactive=False)
-
-    classify_btn.click(fn=classify_and_explain, inputs=[image_input, image_url], outputs=[output_text, image_display, cam_display])
+# Gradio Interface
+def main_app():
+    with gr.Blocks() as demo:
+        gr.Markdown("# 🧴 AI-Powered Acne Type Classifier")
+        gr.Markdown("Enter an image URL of your face or acne region to detect the acne type.")
 
-    gr.Markdown("---")
-    gr.Markdown("## Ask about the detected acne (Chatbot) — optional Mistral API")
+        with gr.Row():
+            image_url = gr.Textbox(label="Image URL")
+            classify_btn = gr.Button("Classify Acne Type")
 
-    with gr.Row():
-        chat_input = gr.Textbox(label="Your question to the assistant")
-        chat_btn = gr.Button("Send")
-    chat_output = gr.Textbox(label="Assistant reply", lines=6)
+        image_display = gr.Image(label="Input Image")
+        output_text = gr.Markdown()
 
-    def chat_with_context(user_q, txt_out):
-        # We pass the last detection summary as context to the chatbot to make answers specific
-        context_summary = txt_out if txt_out else "No prior detection available."
-        return mistral_chat(user_q, context_summary=context_summary)
+        classify_btn.click(classify_acne, inputs=image_url, outputs=[image_display, output_text])
 
-    chat_btn.click(fn=chat_with_context, inputs=[chat_input, output_text], outputs=chat_output)
+        gr.Markdown("---")
+        gr.Markdown("### 💬 Chat with Dermatologist Assistant")
 
-    gr.Markdown("\n---\n**Notes:** Set `MISTRAL_API_KEY` and `MISTRAL_API_URL` in Space secrets to enable the chatbot. The app uses zero-shot CLIP classification and a ResNet50 Grad-CAM visualization for explainability. Results are informational only.")
+        chatbot = gr.ChatInterface(fn=chat_with_bot, title="Acne Query Chatbot")
 
+    return demo
 
 if __name__ == "__main__":
-    demo.launch()
-```
-
----
-
-# requirements.txt
-
-```text
-gradio
-transformers
-torch
- torchvision
-pillow
-requests
-pytorch-grad-cam
-matplotlib
-timm
-\# Optional but useful
-scikit-learn
+    app = main_app()
+    app.launch()
 
-```