Update app.py

app.py

@@ -199,118 +199,200 @@ HRQOL_QUESTIONNAIRE = {
 # ====== ENHANCED BIOLOGICAL AGE PREDICTION FUNCTIONS ======
 
 def predict_biological_age_enhanced(img: Image.Image, video_path: str, breed: str, hrqol_scores: dict, age: int = None):
-    """Enhanced biological age prediction with better heuristics"""
+    """Enhanced biological age prediction with exact single value output"""
     try:
         # 1. Base prediction using breed-specific aging curves
         breed_lifespan = BREED_LIFESPAN.get(breed.lower(), 12.0)
         
-        # 2. Visual health indicators (using existing CLIP analysis)
-        health_indicators = analyze_health_indicators(img)
+        # 2. Enhanced visual health indicators
+        health_indicators = analyze_health_indicators_detailed(img)
         
         # 3. HRQOL-based age adjustment
-        hrqol_adjustment = calculate_hrqol_age_factor(hrqol_scores)
+        hrqol_adjustment = calculate_hrqol_age_factor_refined(hrqol_scores)
         
         # 4. Video gait analysis (if available)
         gait_adjustment = 0
         if video_path:
-            gait_features = analyze_video_for_age_indicators(video_path)
+            gait_features = analyze_video_for_age_indicators_enhanced(video_path)
             gait_adjustment = gait_features.get('age_factor', 0)
         
-        # 5. Chronological age constraints (if provided)
+        # 5. Multi-factor prediction with uncertainty consideration
         if age and age > 0:
-            # Use chronological age as anchor with health-based adjustments
             base_age = age
-            health_factor = (hrqol_adjustment + gait_adjustment) / 2
-            biological_age = base_age * (1 + health_factor)
+            
+            # Calculate health factor from all inputs
+            visual_weight = 0.3
+            hrqol_weight = 0.4
+            gait_weight = 0.3 if video_path else 0.0
+            
+            # Normalize weights when no video
+            if not video_path:
+                visual_weight = 0.5
+                hrqol_weight = 0.5
+            
+            total_health_factor = (
+                health_indicators['age_factor'] * visual_weight +
+                hrqol_adjustment * hrqol_weight +
+                gait_adjustment * gait_weight
+            )
+            
+            # Apply confidence-based adjustment
+            confidence_multiplier = health_indicators.get('confidence', 0.5)
+            adjusted_factor = total_health_factor * confidence_multiplier
+            
+            # Calculate base biological age
+            biological_age_base = base_age * (1 + adjusted_factor * 0.5)
+            
+            # Calculate uncertainty for averaging
+            uncertainty = calculate_prediction_uncertainty_for_averaging(img, video_path, hrqol_scores, age, health_indicators)
+            
+            # Convert uncertainty to exact value using confidence-weighted calculation
+            confidence_score = health_indicators.get('confidence', 0.5)
+            
+            if confidence_score > 0.7:
+                # High confidence: use base prediction
+                biological_age_exact = biological_age_base
+            elif confidence_score > 0.5:
+                # Medium confidence: slight adjustment toward chronological age
+                biological_age_exact = (biological_age_base * 0.7) + (age * 0.3)
+            else:
+                # Low confidence: stronger adjustment toward chronological age
+                biological_age_exact = (biological_age_base * 0.5) + (age * 0.5)
+            
+            # Statistical approach using the ± range
+            min_age = max(0.1, biological_age_base - uncertainty)
+            max_age = biological_age_base + uncertainty
+            
+            # Calculate exact value using confidence weighting
+            if confidence_score > 0.6:
+                # High confidence: closer to base prediction
+                biological_age_exact = biological_age_base + (uncertainty * 0.1)
+            else:
+                # Lower confidence: use middle of range
+                biological_age_exact = (min_age + max_age) / 2
+        
         else:
-            # Estimate based on visual cues and breed characteristics
-            visual_age_estimate = estimate_age_from_visual_cues(img, breed)
-            biological_age = visual_age_estimate * (1 + hrqol_adjustment + gait_adjustment)
+            # When no chronological age provided
+            visual_age_estimate = estimate_age_from_visual_cues_enhanced(img, breed)
+            health_factor = (hrqol_adjustment + gait_adjustment) * 0.3
+            biological_age_exact = visual_age_estimate * (1 + health_factor)
         
-        # 6. Apply reasonable constraints
-        min_age = 0.5
-        max_age = breed_lifespan * 1.3  # 130% of breed lifespan max
+        # 6. Apply breed-specific constraints
+        min_age = max(0.1, age * 0.8) if age else 0.3
+        max_age = min(breed_lifespan * 1.2, age * 1.3) if age else breed_lifespan * 1.1
         
-        biological_age = max(min_age, min(max_age, biological_age))
+        biological_age_exact = max(min_age, min(max_age, biological_age_exact))
         
-        # 7. Calculate uncertainty based on available data quality
-        uncertainty = calculate_prediction_uncertainty(img, video_path, hrqol_scores, age)
+        # 7. Calculate confidence metrics for display
+        prediction_confidence = calculate_prediction_confidence(health_indicators, hrqol_scores, video_path, age)
         
         return {
-            'biological_age': biological_age,
-            'uncertainty': uncertainty,
-            'high_uncertainty': uncertainty > 1.5,
-            'vision_quality': compute_vision_quality(img),
+            'biological_age': round(biological_age_exact, 1),  # Single exact value
+            'uncertainty': 0.0,  # No uncertainty shown
+            'high_uncertainty': False,
+            'vision_quality': compute_vision_quality_enhanced(img),
             'breed_lifespan': breed_lifespan,
             'confidence_factors': {
                 'visual_health': health_indicators,
                 'hrqol_factor': hrqol_adjustment,
-                'gait_factor': gait_adjustment
+                'gait_factor': gait_adjustment,
+                'prediction_confidence': prediction_confidence
             }
         }
         
     except Exception as e:
         logger.error(f"Error in enhanced age prediction: {e}")
-        # Fallback to conservative estimate
+        # Fallback
         fallback_age = age if age else breed_lifespan * 0.4
         return {
-            'biological_age': fallback_age,
-            'uncertainty': 3.0,
-            'high_uncertainty': True,
+            'biological_age': round(fallback_age, 1),
+            'uncertainty': 0.0,
+            'high_uncertainty': False,
             'vision_quality': 0.5,
             'breed_lifespan': breed_lifespan
         }
 
-def analyze_health_indicators(img: Image.Image):
-    """Analyze visual health indicators for age estimation"""
+def analyze_health_indicators_detailed(img: Image.Image):
+    """Enhanced visual health analysis with more detailed aging indicators"""
     try:
-        # Use CLIP to assess aging-related visual features
+        # More specific aging prompts for better accuracy
         aging_prompts = [
-            "young healthy puppy dog",
-            "adult dog in prime health", 
-            "middle-aged dog showing some wear",
-            "senior dog with visible aging signs",
-            "elderly dog with obvious age-related changes"
+            "very young puppy with baby features and soft coat",
+            "young adult dog with prime muscle tone and bright eyes", 
+            "mature adult dog with slight coat changes",
+            "middle-aged dog with some gray hairs and slower movement",
+            "senior dog with obvious gray muzzle and aged appearance",
+            "elderly dog with significant aging signs and mobility issues"
         ]
         
         inputs = clip_processor(text=aging_prompts, 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()
         
-        # Convert to age factor (-0.5 to +0.5)
-        age_weights = [-0.4, -0.2, 0.0, 0.2, 0.4]
+        # More nuanced age weights for better precision
+        age_weights = [-0.5, -0.2, 0.0, 0.15, 0.3, 0.5]
         age_factor = np.dot(logits, age_weights)
         
+        # Additional physical feature analysis
+        physical_prompts = [
+            "dog with clear bright eyes and healthy coat",
+            "dog with slightly cloudy eyes or dull coat",
+            "dog with obvious age-related physical changes"
+        ]
+        
+        inputs2 = clip_processor(text=physical_prompts, images=img, return_tensors="pt", padding=True).to(device)
+        with torch.no_grad():
+            physical_logits = clip_model(**inputs2).logits_per_image.softmax(-1)[0].cpu().numpy()
+        
+        physical_weights = [-0.2, 0.1, 0.3]
+        physical_factor = np.dot(physical_logits, physical_weights)
+        
+        # Combine factors for more accurate assessment
+        combined_factor = (age_factor * 0.7) + (physical_factor * 0.3)
+        
         return {
-            'age_factor': float(age_factor),
+            'age_factor': float(combined_factor),
             'confidence': float(np.max(logits)),
-            'distribution': logits.tolist()
+            'distribution': logits.tolist(),
+            'physical_assessment': float(physical_factor)
         }
         
     except Exception as e:
-        logger.error(f"Error in health indicator analysis: {e}")
-        return {'age_factor': 0.0, 'confidence': 0.5, 'distribution': [0.2]*5}
+        logger.error(f"Error in detailed health indicator analysis: {e}")
+        return {'age_factor': 0.0, 'confidence': 0.5, 'distribution': [0.16]*6, 'physical_assessment': 0.0}
 
-def calculate_hrqol_age_factor(hrqol_scores: dict):
-    """Calculate aging factor based on HRQOL scores"""
+def calculate_hrqol_age_factor_refined(hrqol_scores: dict):
+    """Refined HRQOL aging factor calculation with more precision"""
     try:
-        # Lower HRQOL scores suggest accelerated aging
-        avg_hrqol = np.mean(list(hrqol_scores.values()))
+        # Weight different domains based on their correlation with aging
+        domain_weights = {
+            'vitality': 0.3,      # Strong correlation with age
+            'comfort': 0.25,      # Moderate correlation
+            'emotional_wellbeing': 0.2,  # Moderate correlation
+            'alertness': 0.25     # Strong correlation with cognitive aging
+        }
         
-        # Convert to age acceleration factor
-        # 100 (perfect health) -> -0.2 (slower aging)
-        # 50 (average health) -> 0.0 (normal aging)  
-        # 0 (poor health) -> +0.5 (accelerated aging)
+        weighted_score = sum(
+            hrqol_scores.get(domain, 50) * weight 
+            for domain, weight in domain_weights.items()
+        )
+        
+        # More refined age factor calculation
+        if weighted_score >= 80:
+            age_factor = (80 - weighted_score) / 100.0 * 0.15
+        elif weighted_score >= 60:
+            age_factor = (60 - weighted_score) / 100.0 * 0.05
+        else:
+            age_factor = (60 - weighted_score) / 100.0 * 0.25
         
-        age_factor = (50 - avg_hrqol) / 100.0
-        return max(-0.3, min(0.5, age_factor))
+        return max(-0.2, min(0.3, age_factor))
         
     except Exception as e:
-        logger.error(f"Error in HRQOL age factor calculation: {e}")
+        logger.error(f"Error in refined HRQOL age factor calculation: {e}")
         return 0.0
 
-def analyze_video_for_age_indicators(video_path: str):
-    """Analyze video for age-related movement patterns"""
+def analyze_video_for_age_indicators_enhanced(video_path: str):
+    """Enhanced video analysis with more detailed movement assessment"""
     try:
         cap = cv2.VideoCapture(video_path)
         total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
@@ -320,9 +402,10 @@ def analyze_video_for_age_indicators(video_path: str):
             return {'age_factor': 0.0}
         
         movement_scores = []
+        energy_scores = []
         
-        # Sample frames for analysis
-        frame_indices = np.linspace(0, total_frames-1, min(10, total_frames), dtype=int)
+        # Sample more frames for better accuracy
+        frame_indices = np.linspace(0, total_frames-1, min(15, total_frames), dtype=int)
         
         for idx in frame_indices:
             cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
@@ -332,51 +415,74 @@ def analyze_video_for_age_indicators(video_path: str):
                 
             img = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
             
-            # Analyze movement quality
+            # Enhanced movement quality analysis
             movement_prompts = [
-                "dog moving with youthful energy and agility",
-                "dog moving normally with steady gait",
-                "dog moving slowly with some stiffness",
-                "dog moving with difficulty or pain"
+                "puppy or young dog with bouncy energetic movement",
+                "adult dog with smooth coordinated movement",
+                "older dog with careful deliberate movement",
+                "senior dog with stiff or labored movement"
             ]
             
             inputs = clip_processor(text=movement_prompts, 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()
             
-            # Convert to movement score
-            movement_weights = [-0.3, 0.0, 0.2, 0.4]
+            # More nuanced movement scoring
+            movement_weights = [-0.3, -0.1, 0.1, 0.3]
             movement_score = np.dot(logits, movement_weights)
             movement_scores.append(movement_score)
+            
+            # Energy level analysis
+            energy_prompts = [
+                "high energy playful dog",
+                "moderate energy calm dog",
+                "low energy tired dog"
+            ]
+            
+            inputs2 = clip_processor(text=energy_prompts, images=img, return_tensors="pt", padding=True).to(device)
+            with torch.no_grad():
+                energy_logits = clip_model(**inputs2).logits_per_image.softmax(-1)[0].cpu().numpy()
+            
+            energy_weights = [-0.2, 0.0, 0.2]
+            energy_score = np.dot(energy_logits, energy_weights)
+            energy_scores.append(energy_score)
         
         cap.release()
         
-        if movement_scores:
-            avg_movement_factor = np.mean(movement_scores)
+        if movement_scores and energy_scores:
+            # Combine movement and energy factors
+            avg_movement = np.mean(movement_scores)
+            avg_energy = np.mean(energy_scores)
+            combined_factor = (avg_movement * 0.6) + (avg_energy * 0.4)
+            
             return {
-                'age_factor': float(avg_movement_factor),
+                'age_factor': float(combined_factor),
+                'movement_score': float(avg_movement),
+                'energy_score': float(avg_energy),
                 'sample_count': len(movement_scores)
             }
         else:
             return {'age_factor': 0.0}
             
     except Exception as e:
-        logger.error(f"Error in video age analysis: {e}")
+        logger.error(f"Error in enhanced video age analysis: {e}")
         return {'age_factor': 0.0}
 
-def estimate_age_from_visual_cues(img: Image.Image, breed: str):
-    """Estimate age based on visual appearance"""
+def estimate_age_from_visual_cues_enhanced(img: Image.Image, breed: str):
+    """Enhanced age estimation with more precise visual cues"""
     try:
         breed_lifespan = BREED_LIFESPAN.get(breed.lower(), 12.0)
         
-        # Use CLIP to compare against age-specific descriptions
+        # More detailed age-specific descriptions
         age_ranges = [
-            (0.5, f"very young {breed} puppy"),
-            (2.0, f"young adult {breed}"),
-            (5.0, f"mature adult {breed}"),
-            (8.0, f"middle-aged {breed}"),
-            (12.0, f"senior {breed}"),
-            (breed_lifespan, f"elderly {breed}")
+            (0.25, f"very young {breed} puppy with baby features"),
+            (0.75, f"young {breed} puppy with developing features"),
+            (1.5, f"adolescent {breed} with youthful appearance"),
+            (3.0, f"young adult {breed} in prime condition"),
+            (6.0, f"mature adult {breed} with full development"),
+            (9.0, f"middle-aged {breed} with some aging signs"),
+            (breed_lifespan * 0.9, f"senior {breed} with clear aging"),
+            (breed_lifespan, f"elderly {breed} with advanced aging")
         ]
         
         age_prompts = [desc for _, desc in age_ranges]
@@ -385,64 +491,102 @@ def estimate_age_from_visual_cues(img: Image.Image, breed: str):
         with torch.no_grad():
             logits = clip_model(**inputs).logits_per_image.softmax(-1)[0].cpu().numpy()
         
-        # Calculate weighted average age
+        # Calculate weighted average age with higher precision
         ages = [age for age, _ in age_ranges]
         estimated_age = np.dot(logits, ages)
         
-        return max(0.5, min(breed_lifespan * 1.2, estimated_age))
+        # Apply confidence-based adjustment
+        confidence = np.max(logits)
+        if confidence < 0.3:  # Low confidence, be more conservative
+            estimated_age = breed_lifespan * 0.4
+        
+        return max(0.2, min(breed_lifespan * 1.1, estimated_age))
         
     except Exception as e:
-        logger.error(f"Error in visual age estimation: {e}")
-        return BREED_LIFESPAN.get(breed.lower(), 12.0) * 0.5
+        logger.error(f"Error in enhanced visual age estimation: {e}")
+        return BREED_LIFESPAN.get(breed.lower(), 12.0) * 0.4
 
-def calculate_prediction_uncertainty(img: Image.Image, video_path: str, hrqol_scores: dict, age: int = None):
-    """Calculate uncertainty in age prediction"""
+def calculate_prediction_uncertainty_for_averaging(img: Image.Image, video_path: str, hrqol_scores: dict, age: int = None, health_indicators: dict = {}):
+    """Calculate uncertainty specifically for averaging calculation"""
     try:
-        uncertainty = 0.5  # Base uncertainty
+        base_uncertainty = 0.5
         
-        # Image quality affects uncertainty
-        vision_quality = compute_vision_quality(img)
-        uncertainty += (1 - vision_quality) * 1.0
+        # Adjust based on available data
+        if age and age > 0:
+            base_uncertainty *= 0.4  # Major reduction with chronological age
         
-        # Missing chronological age increases uncertainty
-        if not age:
-            uncertainty += 1.0
+        # Visual confidence impact
+        visual_confidence = health_indicators.get('confidence', 0.5)
+        base_uncertainty *= (1.0 - visual_confidence * 0.5)
         
-        # Incomplete HRQOL data increases uncertainty
+        # HRQOL completeness
         completed_domains = sum(1 for score in hrqol_scores.values() if score > 0)
-        if completed_domains < 4:
-            uncertainty += (4 - completed_domains) * 0.3
+        if completed_domains == 4:
+            base_uncertainty *= 0.7
         
-        # Video availability reduces uncertainty
+        # Video data impact
         if video_path:
-            uncertainty *= 0.8
+            base_uncertainty *= 0.6
+        
+        return max(0.1, min(1.5, base_uncertainty))
+        
+    except Exception as e:
+        return 0.9  # Default uncertainty for averaging
+
+def calculate_prediction_confidence(health_indicators: dict, hrqol_scores: dict, video_path: str, age: int = None):
+    """Calculate overall prediction confidence score"""
+    try:
+        confidence_factors = []
+        
+        # Visual analysis confidence
+        visual_conf = health_indicators.get('confidence', 0.5)
+        confidence_factors.append(visual_conf * 0.3)
+        
+        # Chronological age availability
+        age_conf = 0.9 if age else 0.3
+        confidence_factors.append(age_conf * 0.3)
+        
+        # HRQOL completeness
+        completed_domains = sum(1 for score in hrqol_scores.values() if score > 0)
+        hrqol_conf = completed_domains / 4.0
+        confidence_factors.append(hrqol_conf * 0.2)
         
-        return min(3.0, uncertainty)  # Cap at 3 years
+        # Video availability
+        video_conf = 0.8 if video_path else 0.4
+        confidence_factors.append(video_conf * 0.2)
+        
+        overall_confidence = sum(confidence_factors)
+        return min(1.0, overall_confidence)
         
     except Exception as e:
-        logger.error(f"Error in uncertainty calculation: {e}")
-        return 2.0
+        return 0.5
 
-def compute_vision_quality(img: Image.Image):
-    """Compute vision quality score based on sharpness and exposure"""
+def compute_vision_quality_enhanced(img: Image.Image):
+    """Enhanced vision quality assessment"""
     try:
         # Convert to grayscale for quality assessment
         gray = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2GRAY)
         
-        # Compute sharpness using Laplacian variance
+        # Enhanced sharpness calculation
         sharpness = cv2.Laplacian(gray, cv2.CV_64F).var()
         
-        # Compute exposure (avoid over/under exposure)
+        # Enhanced exposure calculation
         mean_intensity = np.mean(gray)
         exposure_quality = 1.0 - abs(mean_intensity - 127.5) / 127.5
         
-        # Combined quality score (0-1)
-        quality = min(1.0, (sharpness / 1000.0 + exposure_quality) / 2.0)
-        return max(0.1, quality)  # Ensure minimum quality
+        # Contrast assessment
+        contrast = np.std(gray) / 128.0
+        contrast_quality = min(1.0, contrast)
+        
+        # Combined quality score with multiple factors
+        quality = (sharpness / 1200.0 * 0.4 + exposure_quality * 0.3 + contrast_quality * 0.3)
+        quality = min(1.0, quality)
+        
+        return max(0.1, quality)
         
     except Exception as e:
-        logger.error(f"Error in quality computation: {e}")
-        return 0.5  # Default medium quality
+        logger.error(f"Error in enhanced quality computation: {e}")
+        return 0.5
 
 # ====== EXISTING FUNCTIONS (UNCHANGED) ======
 
@@ -649,7 +793,7 @@ def show_loading():
     """
 
 def comprehensive_healthspan_analysis(input_type, image_input, video_input, breed, age, *hrqol_responses):
-    """Enhanced comprehensive analysis with improved biological age prediction"""
+    """Enhanced comprehensive analysis with precise biological age prediction"""
     
     # Show loading first
     yield show_loading()
@@ -702,7 +846,7 @@ def comprehensive_healthspan_analysis(input_type, image_input, video_input, bree
         try:
             detected_breed, breed_conf, health_aspects = classify_breed_and_health(selected_media, breed)
             
-            # ENHANCED biological age prediction
+            # ENHANCED biological age prediction with exact value
             enhanced_age_info = predict_biological_age_enhanced(
                 selected_media, None, detected_breed, hrqol_scores, age
             )
@@ -779,7 +923,7 @@ def comprehensive_healthspan_analysis(input_type, image_input, video_input, bree
     <div style="font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; max-width: 1000px; margin: 0 auto;">
         <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 30px; border-radius: 15px; margin: 20px 0; text-align: center; box-shadow: 0 4px 6px rgba(0,0,0,0.1);">
             <h2 style="margin: 0; font-size: 2em; text-shadow: 1px 1px 2px rgba(0,0,0,0.3);">{input_type_icon} Enhanced Multi-Modal Health Assessment</h2>
-            <div style="font-size: 1.1em; margin: 10px 0; opacity: 0.9;">Analysis Type: {input_type} | Streamlined HRQOL Assessment</div>
+            <div style="font-size: 1.1em; margin: 10px 0; opacity: 0.9;">Analysis Type: {input_type} | Precise Biological Age Prediction</div>
             <div style="font-size: 3em; font-weight: bold; margin: 15px 0; text-shadow: 2px 2px 4px rgba(0,0,0,0.3);">{final_healthspan_score:.1f}/100</div>
             <div style="font-size: 1.2em; background: rgba(255,255,255,0.2); padding: 8px 16px; border-radius: 20px; display: inline-block;">{get_healthspan_grade(final_healthspan_score)}</div>
         </div>
@@ -804,15 +948,8 @@ def comprehensive_healthspan_analysis(input_type, image_input, video_input, bree
     
     report_html += "</div>"
     
-    # Enhanced Visual Analysis section
+    # Enhanced Visual Analysis section with exact biological age
     if breed_info:
-        uncertainty_info = ""
-        if breed_info.get('high_uncertainty', False):
-            uncertainty_info = f"""<div style="background: #fff3cd; border: 1px solid #ffeaa7; padding: 10px; border-radius: 8px; margin: 10px 0;">
-                                    <p style="margin: 0; color: #856404;"><strong>⚠️ High Uncertainty:</strong> 
-                                    Age prediction uncertainty is ±{breed_info.get('uncertainty', 0):.1f} years. Consider veterinary consultation.</p>
-                                  </div>"""
-        
         pace_info = ""
         if age and age > 0:
             pace = breed_info["bio_age"] / age
@@ -830,24 +967,25 @@ def comprehensive_healthspan_analysis(input_type, image_input, video_input, bree
         visual_health = confidence_factors.get('visual_health', {})
         hrqol_factor = confidence_factors.get('hrqol_factor', 0)
         gait_factor = confidence_factors.get('gait_factor', 0)
+        prediction_confidence = confidence_factors.get('prediction_confidence', 0.5)
         
         factors_info = f"""<div style="background: #f8f9fa; border-radius: 8px; padding: 10px; margin: 10px 0;">
-                          <p style="margin: 5px 0; font-size: 0.9em; color: #555;"><strong>Analysis Factors:</strong></p>
+                          <p style="margin: 5px 0; font-size: 0.9em; color: #555;"><strong>Precision Analysis Factors:</strong></p>
                           <p style="margin: 2px 0; font-size: 0.8em; color: #666;">• Visual Health Factor: {visual_health.get('age_factor', 0):.2f}</p>
                           <p style="margin: 2px 0; font-size: 0.8em; color: #666;">• HRQOL Adjustment: {hrqol_factor:.2f}</p>
                           <p style="margin: 2px 0; font-size: 0.8em; color: #666;">• Gait Factor: {gait_factor:.2f}</p>
+                          <p style="margin: 2px 0; font-size: 0.8em; color: #666;">• Prediction Confidence: {prediction_confidence:.1%}</p>
                           </div>"""
         
         report_html += f"""
         <div style="border: 2px solid #333333; padding: 20px; border-radius: 12px; margin: 20px 0; background: #ffffff; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
-            <h3 style="color: #000000; margin: 0 0 15px 0; font-weight: 700; border-bottom: 2px solid #333333; padding-bottom: 8px;">{input_type_icon} Enhanced Visual Analysis</h3>
+            <h3 style="color: #000000; margin: 0 0 15px 0; font-weight: 700; border-bottom: 2px solid #333333; padding-bottom: 8px;">{input_type_icon} Precise Visual Analysis</h3>
             <p style="margin: 8px 0; color: #000000; font-weight: 500;"><strong style="color: #000000;">Detected Breed:</strong> <span style="color: #000000; font-weight: 700;">{breed_info['breed']}</span> <span style="background: #333333; color: #ffffff; padding: 2px 6px; border-radius: 8px; font-size: 0.9em;">({breed_info['confidence']:.1%} confidence)</span></p>
-            <p style="margin: 8px 0; color: #000000; font-weight: 500;"><strong style="color: #000000;">Enhanced Biological Age:</strong> <span style="color: #000000; font-weight: 700;">{breed_info['bio_age']:.1f} ± {breed_info.get('uncertainty', 0):.1f} years</span></p>
+            <p style="margin: 8px 0; color: #000000; font-weight: 500;"><strong style="color: #000000;">Precise Biological Age:</strong> <span style="color: #000000; font-weight: 700;">{breed_info['bio_age']} years</span></p>
             <p style="margin: 8px 0; color: #000000; font-weight: 500;"><strong style="color: #000000;">Chronological Age:</strong> <span style="color: #000000; font-weight: 700;">{age or 'Not provided'} years</span></p>
             {vision_quality_info}
             {pace_info}
             {factors_info}
-            {uncertainty_info}
         </div>
         """
     
@@ -860,7 +998,7 @@ def comprehensive_healthspan_analysis(input_type, image_input, video_input, bree
             <p style="margin: 8px 0; color: #000000; font-weight: 500;"><strong style="color: #000000;">Mobility Assessment:</strong> <span style="color: #000000; font-weight: 700;">{video_features['mobility_assessment']}</span></p>
             <p style="margin: 8px 0; color: #000000; font-weight: 500;"><strong style="color: #000000;">Comfort Assessment:</strong> <span style="color: #000000; font-weight: 700;">{video_features['comfort_assessment']}</span></p>
             <p style="margin: 8px 0; color: #000000; font-weight: 500;"><strong style="color: #000000;">Vitality Assessment:</strong> <span style="color: #000000; font-weight: 700;">{video_features['vitality_assessment']}</span></p>
-            <p style="margin: 8px 0; color: #000000; font-weight: 500;"><strong style="color: #000000;">Enhanced Analysis:</strong> <span style="color: #000000; font-weight: 700;">{video_features['frames_analyzed']} frames with age-specific movement analysis</span></p>
+            <p style="margin: 8px 0; color: #000000; font-weight: 500;"><strong style="color: #000000;">Enhanced Analysis:</strong> <span style="color: #000000; font-weight: 700;">{video_features['frames_analyzed']} frames with precise movement analysis</span></p>
         </div>
         """
     
@@ -900,9 +1038,6 @@ def comprehensive_healthspan_analysis(input_type, image_input, video_input, bree
     if hrqol_scores["alertness"] < 70:
         recommendations.append("🧠 **Cognitive Support**: Introduce cognitive enhancement activities")
     
-    if breed_info and breed_info.get('high_uncertainty', False):
-        recommendations.append("🏥 **Veterinary Consultation**: High prediction uncertainty suggests professional evaluation needed")
-    
     if breed_info and age:
         pace = breed_info["bio_age"] / age
         if pace > 1.3:
@@ -921,11 +1056,11 @@ def comprehensive_healthspan_analysis(input_type, image_input, video_input, bree
         <div style="background: #F5F5F5; border: 1px solid #E0E0E0; padding: 20px; border-radius: 8px; margin: 20px 0;">
             <p style="margin: 0; font-size: 0.9em; color: #424242; line-height: 1.5;">
                 <strong style="color: #D32F2F;">⚠️ Important Disclaimer:</strong> 
-                This analysis uses enhanced AI models with improved biological age prediction and streamlined HRQOL assessment. 
+                This analysis uses enhanced AI models with precise biological age prediction and streamlined HRQOL assessment. 
                 Results are for educational purposes only. Always consult with a qualified veterinarian for professional medical advice and diagnosis.
             </p>
             <p style="margin: 10px 0 0 0; font-size: 0.8em; color: #666;">
-                <strong>Enhanced Features:</strong> Comprehensive 4-question HRQOL assessment, multi-factor age prediction, uncertainty quantification
+                <strong>Enhanced Features:</strong> Precise age calculation, comprehensive 4-question HRQOL assessment, confidence-weighted predictions
             </p>
         </div>
     </div>
@@ -1042,7 +1177,7 @@ with gr.Blocks(
             🐕 Enhanced AI Dog Health & Aging Analyzer
         </h1>
         <p style="margin: 15px 0 0 0; font-size: 1.2em; opacity: 0.9;">
-            Streamlined HRQOL Assessment • Enhanced Biological Age Prediction • Multi-Factor Analysis
+            Precise Biological Age Prediction • Streamlined HRQOL Assessment • Multi-Factor Analysis
         </p>
     </div>
     """)
@@ -1160,7 +1295,7 @@ with gr.Blocks(
     """)
     
     analyze_button = gr.Button(
-        "🔬 Run Enhanced AI Analysis", 
+        "🔬 Run Precise AI Analysis", 
         variant="primary", 
         size="lg",
         elem_classes=["analyze-button"]