Update app.py

app.py

@@ -8,7 +8,7 @@ import numpy as np
 import cv2
 from transformers import (
     CLIPProcessor, CLIPModel,
-    AutoProcessor, AutoModelForImageClassification
+    AutoProcessor, AutoModelForVisionToText
 )
 
 # —————————————————————————————
@@ -20,32 +20,100 @@ device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 # 1. CLIP for breed, age, basic health
 clip_model = CLIPModel.from_pretrained(
     "openai/clip-vit-base-patch16",
-    use_auth_token=HF_TOKEN
+    token=HF_TOKEN
 ).to(device)
 clip_processor = CLIPProcessor.from_pretrained(
     "openai/clip-vit-base-patch16",
-    use_auth_token=HF_TOKEN
+    token=HF_TOKEN
 )
 
-# 2. MedGemma 4B multimodal (public but gated) for medical findings
-medgemma_processor = AutoProcessor.from_pretrained(
-    "google/medgemma-4b-it",
-    use_auth_token=HF_TOKEN
-)
-medgemma_model = AutoModelForImageClassification.from_pretrained(
-    "google/medgemma-4b-it",
-    use_auth_token=HF_TOKEN
-).to(device)
+# 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
+    )
+    medical_model = CLIPModel.from_pretrained(
+        "microsoft/BiomedCLIP-PubMedBERT_256-vit_base_patch16_224",
+        token=HF_TOKEN
+    ).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
 
-# 3. Stanford Dogs & lifespans (abbreviated; expand as needed)
+# 3. Stanford Dogs & lifespans (expanded list)
 STANFORD_BREEDS = [
-    "afghan hound", "beagle", "golden retriever", "yorkshire terrier"
+    "afghan hound", "african hunting dog", "airedale", "american staffordshire terrier",
+    "appenzeller", "australian terrier", "basenji", "basset", "beagle", 
+    "bedlington terrier", "bernese mountain dog", "black-and-tan coonhound",
+    "blenheim spaniel", "bloodhound", "bluetick", "border collie", "border terrier",
+    "borzoi", "boston bull", "bouvier des flandres", "boxer", "brabancon griffon",
+    "briard", "brittany spaniel", "bull mastiff", "cairn", "cardigan",
+    "chesapeake bay retriever", "chihuahua", "chow", "clumber", "cocker spaniel",
+    "collie", "curly-coated retriever", "dandie dinmont", "dhole", "dingo",
+    "doberman", "english foxhound", "english setter", "english springer",
+    "entlebucher", "eskimo dog", "flat-coated retriever", "french bulldog",
+    "german shepherd", "german short-haired pointer", "giant schnauzer",
+    "golden retriever", "gordon setter", "great dane", "great pyrenees",
+    "greater swiss mountain dog", "groenendael", "ibizan hound", "irish setter",
+    "irish terrier", "irish water spaniel", "irish wolfhound", "italian greyhound",
+    "japanese spaniel", "keeshond", "kelpie", "kerry blue terrier", "komondor",
+    "kuvasz", "labrador retriever", "lakeland terrier", "leonberg", "lhasa",
+    "malamute", "malinois", "maltese dog", "mexican hairless", "miniature pinscher",
+    "miniature poodle", "miniature schnauzer", "newfoundland", "norfolk terrier",
+    "norwegian elkhound", "norwich terrier", "old english sheepdog", "otterhound",
+    "papillon", "pekinese", "pembroke", "pomeranian", "pug", "redbone",
+    "rhodesian ridgeback", "rottweiler", "saint bernard", "saluki", "samoyed",
+    "schipperke", "scotch terrier", "scottish deerhound", "sealyham terrier",
+    "shetland sheepdog", "shih tzu", "siberian husky", "silky terrier",
+    "soft-coated wheaten terrier", "staffordshire bullterrier", "standard poodle",
+    "standard schnauzer", "sussex spaniel", "tibetan mastiff", "tibetan terrier",
+    "toy poodle", "toy terrier", "vizsla", "walker hound", "weimaraner",
+    "welsh springer spaniel", "west highland white terrier", "whippet",
+    "wire-haired fox terrier", "yorkshire terrier"
 ]
+
 BREED_LIFESPAN = {
-    "afghan hound": 11.1,
-    "beagle": 12.5,
-    "golden retriever": 13.2,
-    "yorkshire terrier": 13.3
+    "afghan hound": 11.1, "african hunting dog": 10.5, "airedale": 11.5,
+    "american staffordshire terrier": 12.5, "appenzeller": 13.0, "australian terrier": 13.5,
+    "basenji": 12.1, "basset": 12.5, "beagle": 12.5, "bedlington terrier": 13.7,
+    "bernese mountain dog": 10.1, "black-and-tan coonhound": 10.8, "blenheim spaniel": 13.3,
+    "bloodhound": 9.3, "bluetick": 11.0, "border collie": 13.1, "border terrier": 14.2,
+    "borzoi": 12.0, "boston bull": 11.8, "bouvier des flandres": 11.3, "boxer": 11.3,
+    "brabancon griffon": 13.0, "briard": 12.6, "brittany spaniel": 13.5,
+    "bull mastiff": 10.2, "cairn": 14.0, "cardigan": 13.2, "chesapeake bay retriever": 11.6,
+    "chihuahua": 11.8, "chow": 12.1, "clumber": 12.3, "cocker spaniel": 13.3,
+    "collie": 13.3, "curly-coated retriever": 12.2, "dandie dinmont": 12.8,
+    "dhole": 10.0, "dingo": 10.0, "doberman": 11.2, "english foxhound": 13.0,
+    "english setter": 13.1, "english springer": 13.5, "entlebucher": 13.0,
+    "eskimo dog": 11.3, "flat-coated retriever": 11.7, "french bulldog": 9.8,
+    "german shepherd": 11.3, "german short-haired pointer": 13.4, "giant schnauzer": 12.1,
+    "golden retriever": 13.2, "gordon setter": 12.4, "great dane": 10.6,
+    "great pyrenees": 10.9, "greater swiss mountain dog": 10.9, "groenendael": 12.0,
+    "ibizan hound": 13.3, "irish setter": 12.9, "irish terrier": 13.5,
+    "irish water spaniel": 10.8, "irish wolfhound": 9.9, "italian greyhound": 14.0,
+    "japanese spaniel": 13.3, "keeshond": 12.3, "kelpie": 12.0, "kerry blue terrier": 12.4,
+    "komondor": 10.5, "kuvasz": 10.5, "labrador retriever": 13.1, "lakeland terrier": 14.2,
+    "leonberg": 10.0, "lhasa": 14.0, "malamute": 11.3, "malinois": 12.0,
+    "maltese dog": 13.1, "mexican hairless": 13.0, "miniature pinscher": 13.7,
+    "miniature poodle": 14.0, "miniature schnauzer": 13.3, "newfoundland": 11.0,
+    "norfolk terrier": 13.5, "norwegian elkhound": 13.0, "norwich terrier": 14.0,
+    "old english sheepdog": 12.1, "otterhound": 12.0, "papillon": 14.5,
+    "pekinese": 13.3, "pembroke": 13.2, "pomeranian": 12.2, "pug": 11.6,
+    "redbone": 12.0, "rhodesian ridgeback": 12.0, "rottweiler": 10.6,
+    "saint bernard": 9.3, "saluki": 13.3, "samoyed": 13.1, "schipperke": 14.2,
+    "scotch terrier": 12.7, "scottish deerhound": 10.5, "sealyham terrier": 13.1,
+    "shetland sheepdog": 13.4, "shih tzu": 12.8, "siberian husky": 11.9,
+    "silky terrier": 13.3, "soft-coated wheaten terrier": 13.7, "staffordshire bullterrier": 12.0,
+    "standard poodle": 14.0, "standard schnauzer": 13.0, "sussex spaniel": 13.5,
+    "tibetan mastiff": 13.3, "tibetan terrier": 13.8, "toy poodle": 14.0,
+    "toy terrier": 13.0, "vizsla": 13.5, "walker hound": 12.0, "weimaraner": 12.8,
+    "welsh springer spaniel": 14.0, "west highland white terrier": 13.4, "whippet": 13.4,
+    "wire-haired fox terrier": 13.5, "yorkshire terrier": 13.3
 }
 
 # 4. Questionnaire
@@ -73,7 +141,6 @@ QUESTIONNAIRE = [
 ]
 SCALE = ["0","1","2","3","4","5"]
 
-
 def predict_biological_age(img: Image.Image, breed: str) -> int:
     avg = BREED_LIFESPAN.get(breed.lower(), 12)
     prompts = [f"a {age}-year-old {breed}" for age in range(1, int(avg*2)+1)]
@@ -83,17 +150,34 @@ def predict_biological_age(img: Image.Image, breed: str) -> int:
     return int(np.argmax(probs)+1)
 
 def analyze_medical_image(img: Image.Image):
-    inputs = medgemma_processor(images=img, return_tensors="pt").to(device)
-    with torch.no_grad():
-        logits = medgemma_model(**inputs).logits.softmax(-1)[0].cpu().numpy()
-    label = medgemma_model.config.id2label[int(np.argmax(logits))]
-    conf = float(np.max(logits))
+    # Use medical terminology for health assessment
+    health_conditions = [
+        "healthy normal dog",
+        "dog with visible health issues",
+        "dog showing signs of illness",
+        "dog with poor body condition",
+        "dog with excellent health"
+    ]
+    
+    if MEDICAL_MODEL_AVAILABLE:
+        inputs = medical_processor(text=health_conditions, images=img, return_tensors="pt", padding=True).to(device)
+        with torch.no_grad():
+            logits = medical_model(**inputs).logits_per_image.softmax(-1)[0].cpu().numpy()
+    else:
+        inputs = clip_processor(text=health_conditions, images=img, return_tensors="pt", padding=True).to(device)
+        with torch.no_grad():
+            logits = clip_model(**inputs).logits_per_image.softmax(-1)[0].cpu().numpy()
+    
+    idx = int(np.argmax(logits))
+    label = health_conditions[idx]
+    conf = float(logits[idx])
     return label, conf
 
 def classify_breed_and_health(img: Image.Image, override=None):
     inp = clip_processor(images=img, return_tensors="pt").to(device)
     with torch.no_grad():
         feats = clip_model.get_image_features(**inp)
+    
     text_prompts = [f"a photo of a {b}" for b in STANFORD_BREEDS]
     ti = clip_processor(text=text_prompts, return_tensors="pt", padding=True).to(device)
     with torch.no_grad():
@@ -102,6 +186,7 @@ def classify_breed_and_health(img: Image.Image, override=None):
     idx = int(np.argmax(sims))
     breed = override or STANFORD_BREEDS[idx]
     breed_conf = float(sims[idx])
+    
     aspects = {
         "Coat": ("shiny healthy coat","dull patchy fur"),
         "Eyes": ("bright clear eyes","cloudy milky eyes"),
@@ -119,70 +204,117 @@ def classify_breed_and_health(img: Image.Image, override=None):
     return breed, breed_conf, health
 
 def analyze_video(video_path):
-    cap = cv2.VideoCapture(video_path)
-    fps = cap.get(cv2.CAP_PROP_FPS) or 24
-    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    indices = np.linspace(0,total-1,10,dtype=int)
-    scores=[]
-    for i in indices:
-        cap.set(cv2.CAP_PROP_POS_FRAMES,i)
-        ret,frame=cap.read()
-        if not ret: break
-        img=Image.fromarray(cv2.cvtColor(frame,cv2.COLOR_BGR2RGB))
-        _,conf=analyze_medical_image(img)
-        scores.append(conf)
-    cap.release()
-    return {"duration_sec":round(total/fps,1),"avg_gait_conf":float(np.mean(scores))}
+    if not video_path:
+        return {"error": "No video provided"}
+    
+    try:
+        cap = cv2.VideoCapture(video_path)
+        fps = cap.get(cv2.CAP_PROP_FPS) or 24
+        total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        
+        if total == 0:
+            cap.release()
+            return {"error": "Invalid video file"}
+        
+        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()
+            if not ret: 
+                continue
+            img=Image.fromarray(cv2.cvtColor(frame,cv2.COLOR_BGR2RGB))
+            _,conf=analyze_medical_image(img)
+            scores.append(conf)
+        cap.release()
+        
+        if not scores:
+            return {"error": "Could not extract frames from video"}
+        
+        return {
+            "duration_sec": round(total/fps,1),
+            "avg_gait_conf": float(np.mean(scores)),
+            "frames_analyzed": len(scores)
+        }
+    except Exception as e:
+        return {"error": f"Video analysis failed: {str(e)}"}
 
 def compute_q_score(answers):
+    if not answers or all(a is None for a in answers):
+        return {"error": "No answers provided"}
+    
     out={}
     idx=0
     for sec in QUESTIONNAIRE:
         n=len(sec["questions"])
-        vals=list(map(int,answers[idx:idx+n]))
-        idx+=n
-        out[sec["domain"]]=round(sum(vals)/n,2)
+        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)
+        except (ValueError, TypeError):
+            out[sec["domain"]] = 0.0
     return out
 
 with gr.Blocks(title="🐶 Dog Health & Age Analyzer") as demo:
     gr.Markdown("## Upload an Image or Video (10–30 s) or Record Live")
 
-    with gr.Tab("Image"):
-        img = gr.Image(type="pil")
-        br = gr.Textbox(label="Override Breed")
-        ca = gr.Number(label="Chronological Age")
-        btn = gr.Button("Analyze")
+    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):
-            breed,bc,h=classify_breed_and_health(i,o)
-            ml,mc=analyze_medical_image(i)
-            ba=predict_biological_age(i,breed)
-            pace = f"{ba/o:.2f}×" if o else "N/A"
-            rpt = f"**Breed:** {breed} ({bc:.1%})\n\n"
-            rpt+=f"**MedGemma Finding:** {ml} ({mc:.1%})\n\n"
-            rpt+=f"**Bio Age:** {ba} yrs | **Chrono:** {o or 'N/A'} yrs | **Pace:** {pace}\n\n"
-            rpt+="### Health\n"+ "\n".join(f"- **{k}:** {v['assessment']} ({v['confidence']:.1%})" for k,v in h.items())
-            return rpt
+            if i is None:
+                return "Please upload an image first."
+            
+            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)}"
+        
         btn.click(run_i, inputs=[img,br,ca], outputs=md)
 
-    with gr.Tab("Video"):
-        vid=gr.Video()
+    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("Questionnaire"):
+    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)
+                w = gr.Radio(SCALE, label=q, value="0")
                 widgets.append(w)
-        b3=gr.Button("Score")
+        b3=gr.Button("Compute Healthspan Score")
         o3=gr.JSON()
         b3.click(compute_q_score, inputs=widgets, outputs=o3)
 
     with gr.Tab("About"):
-        gr.Markdown("**MedGemma-4B-IT** requires HF auth; set HF_TOKEN.  Uses CLIP & SigLIP for medical insight.")
+        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
+        
+        **Note**: This tool is for educational purposes only and should not replace professional veterinary consultation.
+        """)
 
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()