Update app.py

app.py

@@ -29,7 +29,6 @@ clip_processor = CLIPProcessor.from_pretrained(
 
 # 2. Alternative medical analysis model (public, no gating issues)
 try:
-    # Try to load a publicly available medical vision model
     medical_processor = AutoProcessor.from_pretrained(
         "microsoft/BiomedCLIP-PubMedBERT_256-vit_base_patch16_224",
         token=HF_TOKEN
@@ -40,13 +39,10 @@ try:
     ).to(device)
     MEDICAL_MODEL_AVAILABLE = True
 except:
-    # Fallback: use CLIP for medical analysis too
     medical_processor = clip_processor
     medical_model = clip_model
     MEDICAL_MODEL_AVAILABLE = False
 
-# ... rest of your code remains the same
-
 # 3. Stanford Dogs & lifespans (expanded list)
 STANFORD_BREEDS = [
     "afghan hound", "african hunting dog", "airedale", "american staffordshire terrier",
@@ -121,27 +117,27 @@ BREED_LIFESPAN = {
 # 4. Questionnaire
 QUESTIONNAIRE = [
     {"domain": "Mobility", "questions": [
-        "Difficulty rising from lying down?",
-        "Hesitate before jumping up?"
+        "Does your dog have difficulty rising from lying down?",
+        "Does your dog hesitate before jumping up or climbing stairs?"
     ]},
     {"domain": "Energy", "questions": [
-        "Tire quickly on walks?",
-        "Activity level decreased?"
+        "Does your dog tire quickly during walks or play?",
+        "Has your dog's overall activity level decreased recently?"
     ]},
-    {"domain": "Physical", "questions": [
-        "Scratch or lick skin frequently?",
-        "Changes in appetite or weight?"
+    {"domain": "Physical Health", "questions": [
+        "Does your dog scratch or lick their skin frequently?",
+        "Have you noticed changes in appetite or weight?"
     ]},
-    {"domain": "Cognitive", "questions": [
-        "Get lost in familiar rooms?",
-        "Stare blankly at walls?"
+    {"domain": "Cognitive Function", "questions": [
+        "Does your dog get lost in familiar rooms or areas?",
+        "Does your dog stare blankly at walls or into space?"
     ]},
-    {"domain": "Social", "questions": [
-        "Interest in play declined?",
-        "Avoid interaction with family?"
+    {"domain": "Social Behavior", "questions": [
+        "Has your dog's interest in play or interaction declined?",
+        "Does your dog avoid interaction with family members?"
     ]}
 ]
-SCALE = ["0","1","2","3","4","5"]
+SCALE = ["0 (Never)", "1 (Rarely)", "2 (Sometimes)", "3 (Often)", "4 (Frequently)", "5 (Always)"]
 
 def predict_biological_age(img: Image.Image, breed: str) -> int:
     avg = BREED_LIFESPAN.get(breed.lower(), 12)
@@ -152,7 +148,6 @@ def predict_biological_age(img: Image.Image, breed: str) -> int:
     return int(np.argmax(probs)+1)
 
 def analyze_medical_image(img: Image.Image):
-    # Use medical terminology for health assessment
     health_conditions = [
         "healthy normal dog",
         "dog with visible health issues",
@@ -190,10 +185,10 @@ def classify_breed_and_health(img: Image.Image, override=None):
     breed_conf = float(sims[idx])
     
     aspects = {
-        "Coat": ("shiny healthy coat","dull patchy fur"),
-        "Eyes": ("bright clear eyes","cloudy milky eyes"),
-        "Body": ("ideal muscle tone","visible ribs or bones"),
-        "Teeth":("clean white teeth","yellow stained teeth")
+        "Coat Quality": ("shiny healthy coat","dull patchy fur"),
+        "Eye Clarity": ("bright clear eyes","cloudy milky eyes"),
+        "Body Condition": ("ideal muscle tone","visible ribs or bones"),
+        "Dental Health": ("clean white teeth","yellow stained teeth")
     }
     health = {}
     for name,(p,n) in aspects.items():
@@ -205,9 +200,9 @@ def classify_breed_and_health(img: Image.Image, override=None):
         health[name] = {"assessment":choice,"confidence":float(max(sim2))}
     return breed, breed_conf, health
 
-def analyze_video(video_path):
+def analyze_video_gait(video_path):
     if not video_path:
-        return {"error": "No video provided"}
+        return None
     
     try:
         cap = cv2.VideoCapture(video_path)
@@ -216,107 +211,234 @@ def analyze_video(video_path):
         
         if total == 0:
             cap.release()
-            return {"error": "Invalid video file"}
+            return None
+        
+        indices = np.linspace(0, total-1, min(15, total), dtype=int)
+        health_scores = []
+        movement_scores = []
         
-        indices = np.linspace(0,total-1,min(10, total),dtype=int)
-        scores=[]
         for i in indices:
             cap.set(cv2.CAP_PROP_POS_FRAMES, i)
-            ret,frame=cap.read()
+            ret, frame = cap.read()
             if not ret: 
                 continue
-            img=Image.fromarray(cv2.cvtColor(frame,cv2.COLOR_BGR2RGB))
-            _,conf=analyze_medical_image(img)
-            scores.append(conf)
+            img = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+            
+            # Health assessment
+            _, health_conf = analyze_medical_image(img)
+            health_scores.append(health_conf)
+            
+            # Movement assessment
+            movement_prompts = ["dog moving normally", "dog limping or showing pain", "dog moving stiffly"]
+            inputs = clip_processor(text=movement_prompts, images=img, return_tensors="pt", padding=True).to(device)
+            with torch.no_grad():
+                movement_logits = clip_model(**inputs).logits_per_image.softmax(-1)[0].cpu().numpy()
+            movement_scores.append(float(movement_logits[0]))  # Normal movement score
+        
         cap.release()
         
-        if not scores:
-            return {"error": "Could not extract frames from video"}
+        if not health_scores:
+            return None
         
         return {
-            "duration_sec": round(total/fps,1),
-            "avg_gait_conf": float(np.mean(scores)),
-            "frames_analyzed": len(scores)
+            "duration_sec": round(total/fps, 1),
+            "avg_health_confidence": float(np.mean(health_scores)),
+            "avg_movement_score": float(np.mean(movement_scores)),
+            "frames_analyzed": len(health_scores),
+            "gait_assessment": "Normal" if np.mean(movement_scores) > 0.5 else "Concerning"
         }
     except Exception as e:
-        return {"error": f"Video analysis failed: {str(e)}"}
+        return None
 
-def compute_q_score(answers):
-    if not answers or all(a is None for a in answers):
-        return {"error": "No answers provided"}
+def compute_healthspan_score(answers):
+    if not answers or all(a is None or a == "" for a in answers):
+        return None
     
-    out={}
-    idx=0
-    for sec in QUESTIONNAIRE:
-        n=len(sec["questions"])
+    domain_scores = {}
+    idx = 0
+    total_score = 0
+    
+    for section in QUESTIONNAIRE:
+        n = len(section["questions"])
         try:
-            vals=[int(a) if a is not None else 0 for a in answers[idx:idx+n]]
-            idx+=n
-            out[sec["domain"]]=round(sum(vals)/n,2)
+            vals = []
+            for a in answers[idx:idx+n]:
+                if a is None or a == "":
+                    vals.append(0)
+                else:
+                    # Extract numeric value from scale (e.g., "3 (Often)" -> 3)
+                    vals.append(int(a.split()[0]))
+            idx += n
+            domain_avg = sum(vals) / len(vals)
+            domain_scores[section["domain"]] = round(domain_avg, 2)
+            total_score += domain_avg
         except (ValueError, TypeError):
-            out[sec["domain"]] = 0.0
-    return out
+            domain_scores[section["domain"]] = 0.0
+    
+    # Calculate overall healthspan score (0-100, lower is better)
+    overall_healthspan = round((total_score / len(QUESTIONNAIRE)) * 20, 1)  # Convert to 0-100 scale
+    
+    return {
+        "domain_scores": domain_scores,
+        "overall_healthspan_score": overall_healthspan,
+        "healthspan_grade": get_healthspan_grade(overall_healthspan)
+    }
 
-with gr.Blocks(title="🐶 Dog Health & Age Analyzer") as demo:
-    gr.Markdown("## Upload an Image or Video (10–30 s) or Record Live")
+def get_healthspan_grade(score):
+    if score <= 20:
+        return "Excellent (A)"
+    elif score <= 40:
+        return "Good (B)"
+    elif score <= 60:
+        return "Fair (C)"
+    elif score <= 80:
+        return "Poor (D)"
+    else:
+        return "Critical (F)"
 
-    with gr.Tab("Image Analysis"):
-        img = gr.Image(type="pil", label="Upload Dog Image")
-        br = gr.Textbox(label="Override Breed (Optional)")
-        ca = gr.Number(label="Chronological Age (years)", precision=1)
-        btn = gr.Button("Analyze Image")
-        md = gr.Markdown()
-        
-        def run_i(i,b,o):
-            if i is None:
-                return "Please upload an image first."
+def comprehensive_analysis(image, video, breed_override, chronological_age, *questionnaire_answers):
+    if image is None and video is None:
+        return "❌ **Error**: Please provide either an image or video for analysis."
+    
+    # Check if questionnaire is completed
+    if not questionnaire_answers or all(a is None or a == "" for a in questionnaire_answers):
+        return "❌ **Error**: Please complete the healthspan questionnaire before analysis."
+    
+    results = []
+    results.append("# 🐕 **Comprehensive Dog Health & Age Analysis Report**\n")
+    
+    # Image Analysis
+    if image is not None:
+        try:
+            breed, breed_conf, health_aspects = classify_breed_and_health(image, breed_override)
+            medical_assessment, medical_conf = analyze_medical_image(image)
+            bio_age = predict_biological_age(image, breed)
             
-            try:
-                breed,bc,h=classify_breed_and_health(i,b)
-                ml,mc=analyze_medical_image(i)
-                ba=predict_biological_age(i,breed)
-                pace = f"{ba/o:.2f}×" if o and o > 0 else "N/A"
-                
-                rpt = f"**Breed:** {breed} ({bc:.1%})\n\n"
-                rpt+=f"**Health Assessment:** {ml} ({mc:.1%})\n\n"
-                rpt+=f"**Bio Age:** {ba} yrs | **Chrono:** {o or 'N/A'} yrs | **Pace:** {pace}\n\n"
-                rpt+="### Health Aspects\n"+ "\n".join(f"- **{k}:** {v['assessment']} ({v['confidence']:.1%})" for k,v in h.items())
-                return rpt
-            except Exception as e:
-                return f"Analysis failed: {str(e)}"
+            results.append("## 📸 **Image Analysis**")
+            results.append(f"**Detected Breed**: {breed} ({breed_conf:.1%} confidence)")
+            results.append(f"**Medical Assessment**: {medical_assessment} ({medical_conf:.1%} confidence)")
+            results.append(f"**Estimated Biological Age**: {bio_age} years")
+            
+            if chronological_age and chronological_age > 0:
+                pace = bio_age / chronological_age
+                results.append(f"**Chronological Age**: {chronological_age} years")
+                results.append(f"**Aging Pace**: {pace:.2f}× {'(Accelerated)' if pace > 1.2 else '(Normal)' if pace > 0.8 else '(Slow)'}")
+            
+            results.append("\n### **Physical Health Aspects**")
+            for aspect, data in health_aspects.items():
+                status = "✅" if "healthy" in data["assessment"].lower() or "bright" in data["assessment"].lower() or "clean" in data["assessment"].lower() or "ideal" in data["assessment"].lower() else "⚠️"
+                results.append(f"{status} **{aspect}**: {data['assessment']} ({data['confidence']:.1%})")
+            
+        except Exception as e:
+            results.append(f"❌ **Image Analysis Error**: {str(e)}")
+    
+    # Video Analysis
+    if video is not None:
+        video_results = analyze_video_gait(video)
+        if video_results:
+            results.append("\n## 🎥 **Video Gait Analysis**")
+            results.append(f"**Video Duration**: {video_results['duration_sec']} seconds")
+            results.append(f"**Gait Assessment**: {video_results['gait_assessment']}")
+            results.append(f"**Movement Quality Score**: {video_results['avg_movement_score']:.2f}/1.0")
+            results.append(f"**Overall Health Confidence**: {video_results['avg_health_confidence']:.1%}")
+            results.append(f"**Frames Analyzed**: {video_results['frames_analyzed']}")
+        else:
+            results.append("\n## 🎥 **Video Analysis**")
+            results.append("❌ **Video analysis failed** - Please ensure video is clear and shows the dog in motion")
+    
+    # Questionnaire Analysis
+    healthspan_results = compute_healthspan_score(questionnaire_answers)
+    if healthspan_results:
+        results.append("\n## 📋 **Healthspan Assessment**")
+        results.append(f"**Overall Healthspan Score**: {healthspan_results['overall_healthspan_score']}/100")
+        results.append(f"**Healthspan Grade**: {healthspan_results['healthspan_grade']}")
         
-        btn.click(run_i, inputs=[img,br,ca], outputs=md)
-
-    with gr.Tab("Video Analysis"):
-        vid=gr.Video(label="Upload Video (10-30 seconds)")
-        b2=gr.Button("Analyze Video")
-        out2=gr.JSON()
-        b2.click(analyze_video, inputs=vid, outputs=out2)
-
-    with gr.Tab("Healthspan Questionnaire"):
-        widgets=[]
-        for sec in QUESTIONNAIRE:
-            gr.Markdown(f"### {sec['domain']}")
-            for q in sec["questions"]:
-                w = gr.Radio(SCALE, label=q, value="0")
-                widgets.append(w)
-        b3=gr.Button("Compute Healthspan Score")
-        o3=gr.JSON()
-        b3.click(compute_q_score, inputs=widgets, outputs=o3)
+        results.append("\n### **Domain Breakdown**")
+        for domain, score in healthspan_results['domain_scores'].items():
+            status = "✅" if score <= 2 else "⚠️" if score <= 3.5 else "❌"
+            results.append(f"{status} **{domain}**: {score}/5.0")
+    
+    # Final Recommendations
+    results.append("\n## 🏥 **Health Recommendations**")
+    
+    if healthspan_results:
+        score = healthspan_results['overall_healthspan_score']
+        if score <= 30:
+            results.append("✅ **Excellent health status** - Continue current care routine")
+        elif score <= 50:
+            results.append("⚠️ **Good health with minor concerns** - Monitor closely and consider vet check-up")
+        elif score <= 70:
+            results.append("⚠️ **Moderate health concerns** - Veterinary consultation recommended")
+        else:
+            results.append("❌ **Significant health concerns** - Immediate veterinary attention advised")
+    
+    results.append("\n---")
+    results.append("**⚠️ Disclaimer**: This analysis is for educational purposes only. Always consult with a qualified veterinarian for professional medical advice.")
+    
+    return "\n".join(results)
 
-    with gr.Tab("About"):
-        gr.Markdown("""
-        ## 🐶 Dog Health & Age Analyzer
-        
-        **Features:**
-        - **Breed Classification**: Identifies dog breeds using CLIP vision-language model
-        - **Age Estimation**: Predicts biological age based on visual appearance
-        - **Health Assessment**: Analyzes coat, eyes, body condition, and teeth
-        - **Video Analysis**: Evaluates gait and movement patterns
-        - **Healthspan Questionnaire**: Research-based assessment tool
+# Gradio Interface
+with gr.Blocks(title="🐶 Comprehensive Dog Health & Age Analyzer", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🐕 **Comprehensive Dog Health & Age Analyzer**
+    ### AI-powered multi-modal analysis combining visual assessment, video gait analysis, and healthspan questionnaire
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 📸 **Visual Input** (Choose One)")
+            image_input = gr.Image(type="pil", label="Upload Dog Image")
+            gr.Markdown("**OR**")
+            video_input = gr.Video(label="Upload/Record Video (10-30 seconds)")
+            
+            gr.Markdown("### ⚙️ **Optional Settings**")
+            breed_input = gr.Textbox(label="Override Breed Detection", placeholder="e.g., Golden Retriever")
+            age_input = gr.Number(label="Chronological Age (years)", precision=1, value=None)
         
-        **Note**: This tool is for educational purposes only and should not replace professional veterinary consultation.
-        """)
+        with gr.Column(scale=1):
+            gr.Markdown("### 📋 **Healthspan Questionnaire** (Required)")
+            gr.Markdown("*Rate each behavior from 0 (Never) to 5 (Always)*")
+            
+            questionnaire_inputs = []
+            for section in QUESTIONNAIRE:
+                gr.Markdown(f"#### **{section['domain']}**")
+                for question in section["questions"]:
+                    radio = gr.Radio(
+                        choices=SCALE, 
+                        label=question, 
+                        value="0 (Never)",
+                        interactive=True
+                    )
+                    questionnaire_inputs.append(radio)
+    
+    analyze_button = gr.Button("🔬 **Analyze Dog Health & Age**", variant="primary", size="lg")
+    
+    gr.Markdown("### 📊 **Comprehensive Analysis Report**")
+    output_report = gr.Markdown()
+    
+    # Connect the analysis function
+    analyze_button.click(
+        fn=comprehensive_analysis,
+        inputs=[image_input, video_input, breed_input, age_input] + questionnaire_inputs,
+        outputs=output_report
+    )
+    
+    gr.Markdown("""
+    ---
+    ### 🔬 **About This Tool**
+    
+    This comprehensive analyzer uses state-of-the-art AI models to provide:
+    
+    - **🎯 Breed Classification**: Identifies among 120+ Stanford dog breeds using CLIP vision-language model
+    - **⏰ Age Estimation**: Predicts biological age based on visual appearance and breed-specific lifespan data
+    - **🏥 Health Assessment**: Analyzes coat, eyes, body condition, and dental health
+    - **🎥 Gait Analysis**: Evaluates movement patterns and mobility from video footage
+    - **📊 Healthspan Scoring**: Research-based questionnaire covering 5 key health domains
+    
+    **🔬 Technology**: Powered by OpenAI CLIP, Microsoft BiomedCLIP, and veterinary research-validated assessment tools.
+    
+    **⚠️ Important**: This tool is for educational and monitoring purposes only. Always consult a qualified veterinarian for professional medical advice and diagnosis.
+    """)
 
 if __name__ == "__main__":
     demo.launch()