Update app.py

app.py

@@ -1,6 +1,6 @@
 """
-Elderly HealthWatch AI Backend (FastAPI) - Refactored
-Simplified architecture with same API routes for frontend compatibility.
+Elderly HealthWatch AI Backend (FastAPI) - Refactored with Qwen2.5-VL
+Updated to use mrdbourke/Qwen2.5-VL-Instruct-Demo instead of Qwen3-VL
 """
 
 import io
@@ -32,14 +32,21 @@ except Exception:
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("elderly_healthwatch")
 
-GRADIO_VLM_SPACE = os.getenv("GRADIO_SPACE", "developer0hye/Qwen3-VL-8B-Instruct")
+# Updated VLM space to use Qwen2.5-VL
+GRADIO_VLM_SPACE = os.getenv("GRADIO_SPACE", "mrdbourke/Qwen2.5-VL-Instruct-Demo")
+VLM_MODEL_ID = os.getenv("VLM_MODEL_ID", "Qwen/Qwen2.5-VL-7B-Instruct")
 LLM_GRADIO_SPACE = os.getenv("LLM_GRADIO_SPACE", "Tonic/med-gpt-oss-20b-demo")
 HF_TOKEN = os.getenv("HF_TOKEN", None)
 
 DEFAULT_VLM_PROMPT = (
-    "From the provided face/eye images, compute the required screening features "
-    "(pallor, sclera yellowness, redness, mobility metrics, quality checks) "
-    "and output a clean JSON feature vector only."
+    "Analyze this person's face and eyes carefully. Look for signs of: "
+    "1) Pallor (pale skin indicating possible anemia), "
+    "2) Sclera yellowness (yellowing of eye whites indicating possible jaundice), "
+    "3) Eye redness or irritation, "
+    "4) Skin hydration and texture. "
+    "Provide your analysis in JSON format with these keys: "
+    "pallor_score (0-1), sclera_yellowness (0-1), redness (0-1), "
+    "hydration_issue (0-1), overall_quality (0-1), notes."
 )
 
 LLM_SYSTEM_PROMPT = (
@@ -280,7 +287,7 @@ def extract_json_from_llm_output(raw_text: str) -> Dict[str, Any]:
     }
 
 # ============================================================================
-# VLM & LLM Integration
+# VLM & LLM Integration - UPDATED FOR QWEN2.5-VL
 # ============================================================================
 def get_gradio_client(space: str) -> Client:
     """Get Gradio client with optional auth"""
@@ -289,7 +296,10 @@ def get_gradio_client(space: str) -> Client:
     return Client(space, hf_token=HF_TOKEN) if HF_TOKEN else Client(space)
 
 def call_vlm(face_path: str, eye_path: str, prompt: Optional[str] = None) -> Tuple[Optional[Dict], str]:
-    """Call VLM and return (parsed_features, raw_text)"""
+    """
+    Call Qwen2.5-VL and return (parsed_features, raw_text)
+    Updated to use mrdbourke/Qwen2.5-VL-Instruct-Demo API
+    """
     prompt = prompt or DEFAULT_VLM_PROMPT
     
     if not os.path.exists(face_path) or not os.path.exists(eye_path):
@@ -302,69 +312,61 @@ def call_vlm(face_path: str, eye_path: str, prompt: Optional[str] = None) -> Tup
     logger.info("VLM Prompt: %s", prompt[:100])
     
     client = get_gradio_client(GRADIO_VLM_SPACE)
-    message = {"text": prompt, "files": [handle_file(face_path), handle_file(eye_path)]}
     
     try:
-        logger.info("Calling VLM Space: %s with api_name=/chat_fn", GRADIO_VLM_SPACE)
-        result = client.predict(message=message, history=[], api_name="/chat_fn")
-        logger.info("VLM raw result type: %s", type(result))
-        logger.info("VLM raw result: %s", str(result)[:500])
+        logger.info("Calling Qwen2.5-VL Space: %s with api_name=/run_example", GRADIO_VLM_SPACE)
+        
+        # First call with face image
+        result_face = client.predict(
+            image=handle_file(face_path),
+            text_input=prompt + " Focus on the face and overall skin condition.",
+            model_id=VLM_MODEL_ID,
+            api_name="/run_example"
+        )
+        
+        # Second call with eye image
+        result_eye = client.predict(
+            image=handle_file(eye_path),
+            text_input=prompt + " Focus on the eyes, sclera color, and eye health.",
+            model_id=VLM_MODEL_ID,
+            api_name="/run_example"
+        )
+        
+        logger.info("VLM Face result type: %s", type(result_face))
+        logger.info("VLM Eye result type: %s", type(result_eye))
+        
+        # Extract text from tuple results (returns tuple of 2 elements)
+        face_text = result_face[0] if isinstance(result_face, (list, tuple)) and len(result_face) > 0 else str(result_face)
+        eye_text = result_eye[0] if isinstance(result_eye, (list, tuple)) and len(result_eye) > 0 else str(result_eye)
+        
+        # Combine both analyses
+        combined_text = f"Face Analysis:\n{face_text}\n\nEye Analysis:\n{eye_text}"
+        
+        logger.info("VLM combined text (first 500 chars): %s", combined_text[:500])
+        
     except Exception as e:
         logger.exception("VLM call failed")
         raise RuntimeError(f"VLM call failed: {e}")
     
-    # Normalize result - handle different return formats
-    if isinstance(result, (list, tuple)):
-        logger.info("VLM returned list/tuple with %d elements", len(result))
-        if len(result) > 0:
-            out = result[0]
-        else:
-            out = {}
-    elif isinstance(result, dict):
-        logger.info("VLM returned dict with keys: %s", list(result.keys()))
-        out = result
-    else:
-        logger.info("VLM returned unknown type, converting to string")
-        out = {"text": str(result)}
-    
-    # Extract text from various possible formats
-    text_out = None
-    if isinstance(out, dict):
-        text_out = out.get("text") or out.get("output") or out.get("content")
-    
-    if not text_out:
-        # If still no text, try the whole result
-        if isinstance(result, str):
-            text_out = result
-        else:
-            text_out = json.dumps(out)
-    
-    logger.info("VLM extracted text (first 300 chars): %s", text_out[:300] if text_out else "EMPTY")
-    
-    if not text_out or len(text_out.strip()) == 0:
-        logger.warning("VLM returned empty text output!")
-        text_out = "{}"  # Provide empty JSON as fallback
-    
-    # Try to parse JSON
+    # Try to parse JSON from the combined text
     parsed = None
     try:
-        parsed = json.loads(text_out)
+        # Try direct JSON parse first
+        parsed = json.loads(combined_text)
         if not isinstance(parsed, dict):
             logger.warning("VLM JSON parsed but not a dict: %s", type(parsed))
             parsed = None
         else:
             logger.info("VLM successfully parsed JSON with keys: %s", list(parsed.keys()))
-    except Exception as parse_err:
-        logger.info("VLM text is not direct JSON: %s", str(parse_err))
-        # Try to extract JSON from text
+    except Exception:
+        # Try to extract JSON block
         try:
-            first = text_out.find("{")
-            last = text_out.rfind("}")
+            first = combined_text.find("{")
+            last = combined_text.rfind("}")
             if first != -1 and last != -1 and last > first:
-                json_str = text_out[first:last+1]
+                json_str = combined_text[first:last+1]
                 parsed = json.loads(json_str)
                 if not isinstance(parsed, dict):
-                    logger.warning("Extracted JSON is not a dict")
                     parsed = None
                 else:
                     logger.info("Successfully extracted JSON from text with keys: %s", list(parsed.keys()))
@@ -372,7 +374,16 @@ def call_vlm(face_path: str, eye_path: str, prompt: Optional[str] = None) -> Tup
             logger.warning("Could not extract JSON from VLM text: %s", str(extract_err))
             parsed = None
     
-    return parsed, text_out
+    # If no JSON found, create structured data from text
+    if parsed is None:
+        logger.info("No JSON found, creating structured data from text analysis")
+        parsed = {
+            "face_analysis": face_text[:500],
+            "eye_analysis": eye_text[:500],
+            "combined_analysis": combined_text[:1000]
+        }
+    
+    return parsed, combined_text
 
 def get_fallback_risk_assessment(vlm_output: Any, reason: str = "LLM unavailable") -> Dict[str, Any]:
     """Generate basic risk assessment from VLM output when LLM is unavailable"""
@@ -414,7 +425,6 @@ def get_fallback_risk_assessment(vlm_output: Any, reason: str = "LLM unavailable
     neuro_prob = 0.0
     
     # Extract VLM features if available
-    # Look for color indicators
     sclera_yellow = vlm_dict.get("sclera_yellowness", 0)
     pallor = vlm_dict.get("pallor_score", 0)
     redness = vlm_dict.get("redness", 0)
@@ -437,7 +447,7 @@ def get_fallback_risk_assessment(vlm_output: Any, reason: str = "LLM unavailable
         "anemia_probability": round(anemia_prob, 4),
         "hydration_issue_probability": round(hydration_prob, 4),
         "neurological_issue_probability": round(neuro_prob, 4),
-        "confidence": 0.4,  # Low confidence for fallback
+        "confidence": 0.4,
         "summary": "Basic screening completed. Advanced AI analysis temporarily unavailable.",
         "recommendation": "Consider consulting a healthcare professional for a comprehensive assessment.",
         "fallback_mode": True,
@@ -498,7 +508,7 @@ def call_llm(vlm_output: Any, use_fallback_on_error: bool = True) -> Dict[str, A
         parsed = extract_json_from_llm_output(text_out)
         logger.info("LLM parsed JSON:\n%s", json.dumps(parsed, indent=2))
         
-        # Check if LLM returned essentially empty results (all zeros)
+        # Check if LLM returned essentially empty results
         all_zero = all(
             parsed.get(k, 0) == 0 
             for k in ["jaundice_probability", "anemia_probability", 
@@ -516,14 +526,12 @@ def call_llm(vlm_output: Any, use_fallback_on_error: bool = True) -> Dict[str, A
     except Exception as e:
         logger.exception("LLM call failed: %s", str(e))
         
-        # Check if it's a quota error
         error_msg = str(e).lower()
         if "quota" in error_msg or "gpu" in error_msg:
             logger.warning("GPU quota exceeded, using fallback assessment")
             if use_fallback_on_error:
                 return get_fallback_risk_assessment(vlm_output, reason="gpu_quota_exceeded")
         
-        # For other errors, also use fallback if enabled
         if use_fallback_on_error:
             logger.warning("LLM error, using fallback assessment")
             return get_fallback_risk_assessment(vlm_output, reason=f"llm_error: {str(e)[:100]}")
@@ -629,7 +637,7 @@ app.add_middleware(
 
 @app.get("/")
 async def read_root():
-    return {"message": "Elderly HealthWatch AI Backend"}
+    return {"message": "Elderly HealthWatch AI Backend - Using Qwen2.5-VL"}
 
 @app.get("/health")
 async def health_check():
@@ -637,11 +645,9 @@ async def health_check():
     llm_status = "available"
     llm_message = None
     
-    # Quick test of LLM availability
     if GRADIO_AVAILABLE:
         try:
             client = get_gradio_client(LLM_GRADIO_SPACE)
-            # Just checking if we can connect, not running inference
             llm_status = "available"
         except Exception as e:
             error_msg = str(e).lower()
@@ -660,6 +666,7 @@ async def health_check():
         "detector": detector_type or "none",
         "vlm_available": GRADIO_AVAILABLE,
         "vlm_space": GRADIO_VLM_SPACE,
+        "vlm_model": VLM_MODEL_ID,
         "llm_space": LLM_GRADIO_SPACE,
         "llm_status": llm_status,
         "llm_message": llm_message,
@@ -794,18 +801,17 @@ async def debug_spaces():
         "llm": {"available": False, "error": None}
     }
     
-    # Test VLM
     if GRADIO_AVAILABLE:
         try:
             client = get_gradio_client(GRADIO_VLM_SPACE)
             results["vlm"]["available"] = True
             results["vlm"]["space"] = GRADIO_VLM_SPACE
+            results["vlm"]["model"] = VLM_MODEL_ID
         except Exception as e:
             results["vlm"]["error"] = str(e)
     else:
         results["vlm"]["error"] = "Gradio not installed"
     
-    # Test LLM
     if GRADIO_AVAILABLE:
         try:
             client = get_gradio_client(LLM_GRADIO_SPACE)