Update analysis.py

analysis.py

@@ -2,8 +2,9 @@ import os
 import json
 import time
 import hashlib
+import numpy as np
 from datetime import datetime
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, List
 
 from google import genai
 from google.genai.types import Part
@@ -16,6 +17,10 @@ from mimetypes import guess_type
 API_KEY = os.getenv("GEMINI_API_KEY")
 MODEL_COMBINED = "models/gemini-2.5-flash"
 
+# Consistency settings
+ENABLE_MULTI_PASS = True  # Set to False to disable multi-pass validation
+VALIDATION_PASSES = 3     # Number of analyses to run for averaging
+MAX_VARIANCE_THRESHOLD = 0.15  # Maximum allowed variance before warning
 
 _analysis_cache = {}
 _usage_log = []
@@ -74,34 +79,137 @@ def retry_with_backoff(func, max_retries: int = 3, initial_delay: float = 2.0):
 
 
 # =========================
-# MAIN GEMINI SKIN ANALYSIS
+# NORMALIZATION FUNCTIONS
 # =========================
-def analyze_skin_complete(
-    image_path: str,
-    use_cache: bool = True,
-    max_retries: int = 3
-):
+def normalize_score(value: float, threshold: float = 0.05) -> float:
+    """
+    Normalize a score to reduce noise and improve consistency.
+    
+    Args:
+        value: Raw score between 0.0 and 1.0
+        threshold: Values below this are set to 0.0
+    
+    Returns:
+        Normalized score rounded to 2 decimal places
+    """
+    if value < threshold:
+        return 0.0
+    elif value > (1.0 - threshold):
+        return 1.0
+    
+    # Round to 2 decimal places for consistency
+    return round(value, 2)
+
+
+def normalize_category_scores(category_data: dict, threshold: float = 0.05) -> dict:
+    """Apply normalization to all scores in a category."""
+    normalized = {}
+    for key, value in category_data.items():
+        if isinstance(value, (int, float)):
+            normalized[key] = normalize_score(float(value), threshold)
+        else:
+            normalized[key] = value
+    return normalized
 
-    # Cache key based on image hash
-    cache_key = f"complete_v2_{get_image_hash(image_path)}"
-    if use_cache and cache_key in _analysis_cache:
-        print("✓ Using cached analysis results")
-        return _analysis_cache[cache_key]
 
-    def _call():
-        client = load_client()
-
-        # Read image bytes
-        with open(image_path, "rb") as f:
-            image_bytes = f.read()
+# =========================
+# AVERAGING FUNCTIONS
+# =========================
+def average_analyses(results: List[dict]) -> dict:
+    """
+    Average multiple analysis results for improved consistency.
+    
+    Args:
+        results: List of analysis dictionaries
+    
+    Returns:
+        Averaged analysis dictionary
+    """
+    if not results:
+        return None
+    
+    if len(results) == 1:
+        return results[0]
+    
+    # Initialize with first result structure
+    averaged = json.loads(json.dumps(results[0]))  # Deep copy
+    
+    # Average each numeric field in main categories
+    for category in ["hydration", "pigmentation", "acne", "pores", "wrinkles"]:
+        if category in averaged:
+            for field in averaged[category]:
+                if isinstance(averaged[category][field], (int, float)):
+                    values = [
+                        r[category][field] 
+                        for r in results 
+                        if category in r and field in r[category]
+                    ]
+                    if values:
+                        averaged[category][field] = round(sum(values) / len(values), 3)
+    
+    # Average age analysis (integers)
+    if "age_analysis" in averaged:
+        for field in ["eye_age", "skin_age"]:
+            if field in averaged["age_analysis"]:
+                values = [
+                    r["age_analysis"][field] 
+                    for r in results 
+                    if "age_analysis" in r and field in r["age_analysis"]
+                ]
+                if values:
+                    averaged["age_analysis"][field] = round(sum(values) / len(values))
+        
+        # Fitzpatrick type - use mode (most common value)
+        if "fitzpatrick_type" in averaged["age_analysis"]:
+            values = [
+                r["age_analysis"]["fitzpatrick_type"] 
+                for r in results 
+                if "age_analysis" in r and "fitzpatrick_type" in r["age_analysis"]
+            ]
+            if values:
+                averaged["age_analysis"]["fitzpatrick_type"] = max(set(values), key=values.count)
+    
+    return averaged
+
+
+def calculate_variance(results: List[dict], category: str) -> float:
+    """
+    Calculate variance for a specific category across multiple results.
+    
+    Args:
+        results: List of analysis dictionaries
+        category: Category name (e.g., "acne", "wrinkles")
+    
+    Returns:
+        Maximum variance across all fields in the category
+    """
+    if len(results) < 2:
+        return 0.0
+    
+    category_values = []
+    for result in results:
+        if category in result:
+            values = [
+                v for v in result[category].values() 
+                if isinstance(v, (int, float))
+            ]
+            category_values.append(values)
+    
+    if not category_values or len(category_values) < 2:
+        return 0.0
+    
+    # Calculate variance for each field
+    variances = np.var(category_values, axis=0)
+    return float(np.max(variances))
 
-        mime_type, _ = guess_type(image_path)
-        mime_type = mime_type or "image/jpeg"
-        image_part = Part.from_bytes(data=image_bytes, mime_type=mime_type)
 
-        # UPDATED FULL PROMPT FROM SCRIPT #2
-        prompt = """
-You are an advanced AI skin analysis system. Analyze the face in this image comprehensively.
+# =========================
+# ENHANCED PROMPT
+# =========================
+def get_analysis_prompt() -> str:
+    """Returns the enhanced prompt with objective scoring criteria."""
+    return """
+You are an advanced AI skin analysis system. Analyze the face in this image comprehensively using OBJECTIVE, CONSISTENT criteria.
 
 Return STRICT JSON with ALL these fields (use exact field names):
 
@@ -161,26 +269,104 @@ Return STRICT JSON with ALL these fields (use exact field names):
   }
 }
 
-DETAILED ANALYSIS GUIDELINES:
-
-PORES:
-- Assess pore visibility across different facial zones
-- Consider pore size relative to skin type
-- Note if pores appear stretched, enlarged, or clogged
-- T-zone (forehead, nose, chin) typically has more prominent pores
-- Cheeks may show different pore characteristics
-
-WRINKLES:
-- Distinguish between dynamic (expression) and static (at rest) wrinkles
-- Forehead lines: horizontal lines across forehead
-- Frown lines: vertical lines between eyebrows (11 lines)
-- Crow's feet: radiating lines from outer eye corners
-- Nasolabial folds: lines from nose to mouth corners
-- Marionette lines: lines from mouth corners downward
-- Assess depth (superficial vs deep wrinkles)
-- Consider fine lines vs established wrinkles
-
-CRITICAL RULES:
+═══════════════════════════════════════════════════════════════
+ACNE ANALYSIS - OBJECTIVE COUNTING CRITERIA (CRITICAL FOR CONSISTENCY)
+════════════════════════���══════════════════════════════════════
+
+**ACTIVE_ACNE** - Count visible inflamed red/pink lesions (pustules, papules):
+  • 0.00-0.15: 0 lesions (clear skin)
+  • 0.15-0.30: 1-2 small lesions
+  • 0.30-0.50: 3-5 lesions
+  • 0.50-0.70: 6-10 lesions
+  • 0.70-0.85: 11-20 lesions
+  • 0.85-1.00: 20+ lesions or widespread
+
+**COMEDONES** - Count visible blackheads/whiteheads (small dark or white bumps):
+  • 0.00-0.15: 0-3 comedones
+  • 0.15-0.30: 4-8 comedones
+  • 0.30-0.50: 9-15 comedones
+  • 0.50-0.70: 16-25 comedones
+  • 0.70-0.85: 26-40 comedones
+  • 0.85-1.00: 40+ comedones
+
+**CYSTIC_ACNE** - Count deep, large, painful-looking nodules or cysts:
+  • 0.00-0.20: None visible
+  • 0.20-0.40: 1 small nodule
+  • 0.40-0.60: 2-3 nodules or 1 large cyst
+  • 0.60-0.80: 4-6 nodules/cysts
+  • 0.80-1.00: 7+ nodules or very large/multiple cysts
+
+**INFLAMMATION** - Assess redness, swelling around lesions:
+  • 0.00-0.20: No redness, minimal inflammation
+  • 0.20-0.40: Slight pink around 1-2 spots
+  • 0.40-0.60: Moderate redness around several lesions
+  • 0.60-0.80: Strong redness, visible swelling
+  • 0.80-1.00: Severe widespread inflammation
+
+**OILINESS** - Assess visible shine/oily appearance:
+  • 0.00-0.25: Matte, no visible oil
+  • 0.25-0.50: Slight shine in T-zone
+  • 0.50-0.75: Noticeable shine on forehead, nose, chin
+  • 0.75-1.00: Very shiny/greasy appearance overall
+
+**SCARRING** - Count visible acne scars (pitted, raised, or discolored):
+  • 0.00-0.20: No visible scars
+  • 0.20-0.40: 1-3 minor scars
+  • 0.40-0.60: 4-8 visible scars
+  • 0.60-0.80: 9-15 scars
+  • 0.80-1.00: 15+ scars or severe pitting
+
+**CONGESTION** - Overall appearance of clogged, rough texture:
+  • 0.00-0.25: Smooth, clear pores
+  • 0.25-0.50: Some roughness, minor congestion
+  • 0.50-0.75: Noticeable rough texture, many clogged pores
+  • 0.75-1.00: Severely congested, bumpy texture
+
+═══════════════════════════════════════════════════════════════
+CONSISTENCY ENFORCEMENT RULES
+═══════════════════════════════════════════════════════════════
+
+1. **COUNT, DON'T ESTIMATE**: Scan the entire face systematically and COUNT actual visible features
+2. **USE THE SAME SCALE EVERY TIME**: Always use the exact ranges above
+3. **BE CONSERVATIVE**: If uncertain between two ranges, choose the LOWER score
+4. **ZERO MEANS NONE**: Use 0.0 only when a feature is completely absent
+5. **SYSTEMATIC SCANNING**: 
+   - Divide face into zones: forehead, cheeks (left/right), nose, chin
+   - Count features in each zone, then sum
+   - This ensures you don't miss or double-count features
+6. **IGNORE LIGHTING VARIATIONS**: Base assessment on actual skin features, not shadows or highlights
+7. **ONE ANALYSIS = ONE RULESET**: Never change your interpretation mid-analysis
+
+═══════════════════════════════════════════════════════════════
+ADDITIONAL DETAILED GUIDELINES
+═══════════════════════════════════════════════════════════════
+
+**PORES:**
+- Scan T-zone (forehead, nose, chin) separately from cheeks
+- Small pores (barely visible) = 0.0-0.3
+- Medium pores (clearly visible) = 0.3-0.6
+- Large pores (very prominent) = 0.6-1.0
+
+**WRINKLES:**
+- Fine lines (only visible up close) = 0.0-0.3
+- Moderate wrinkles (clearly visible) = 0.3-0.6
+- Deep wrinkles (with visible depth/shadows) = 0.6-1.0
+- Distinguish dynamic (expression) vs static (at rest)
+
+**PIGMENTATION:**
+- Count distinct dark spots
+- Assess overall tone evenness across face
+- Under-eye darkness: compare to surrounding skin tone
+
+**HYDRATION:**
+- Flakiness: visible dry patches or peeling
+- Radiance: natural healthy glow vs dull appearance
+- Fine lines: thin lines from dehydration (not age)
+
+═══════════════════════════════════════════════════════════════
+CRITICAL OUTPUT RULES
+═══════════════════════════════════════════════════════════════
+
 - Return ONLY raw JSON, no markdown formatting
 - No explanations, no text outside JSON
 - All float values must be between 0.0 and 1.0
@@ -189,59 +375,166 @@ CRITICAL RULES:
 - Do NOT guess or infer anything not visible
 - Ensure all fields are present in the response
 - If a feature is not visible or applicable, use 0.0
+- Round all floats to 2 decimal places maximum
 """
 
-        # --- API CALL WITH TIMING ---
-        start_time = time.time()
-        response = client.models.generate_content(
-            model=MODEL_COMBINED,
-            contents=[prompt, image_part],
-            config={"temperature": 0, "top_p": 1, "top_k": 1}
-        )
-        elapsed = time.time() - start_time
 
-        # Clean response text
-        if not response or not response.candidates:
-            raise RuntimeError("Unable to process image at this time")
+# =========================
+# SINGLE ANALYSIS CALL
+# =========================
+def _perform_single_analysis(image_path: str) -> dict:
+    """Perform a single analysis call to Gemini API."""
+    client = load_client()
 
-        parts = response.candidates[0].content.parts
-        text_chunks = [p.text for p in parts if hasattr(p, "text") and p.text]
+    # Read image bytes
+    with open(image_path, "rb") as f:
+        image_bytes = f.read()
+
+    mime_type, _ = guess_type(image_path)
+    mime_type = mime_type or "image/jpeg"
+    image_part = Part.from_bytes(data=image_bytes, mime_type=mime_type)
+
+    prompt = get_analysis_prompt()
+
+    # --- API CALL WITH TIMING ---
+    start_time = time.time()
+    response = client.models.generate_content(
+        model=MODEL_COMBINED,
+        contents=[prompt, image_part],
+        config={
+            "temperature": 0,
+            "top_p": 1,
+            "top_k": 1,
+            # Add seed if/when supported: "seed": 42
+        }
+    )
+    elapsed = time.time() - start_time
 
-        if not text_chunks:
-            raise RuntimeError("Unable to process image at this time")
+    # Clean response text
+    if not response or not response.candidates:
+        raise RuntimeError("Unable to process image at this time")
 
-        clean_text = "\n".join(text_chunks)
-        clean_text = clean_text.replace("```json", "").replace("```", "").strip()
+    parts = response.candidates[0].content.parts
+    text_chunks = [p.text for p in parts if hasattr(p, "text") and p.text]
 
+    if not text_chunks:
+        raise RuntimeError("Unable to process image at this time")
 
-        # Convert to dict
-        try:
-            result = json.loads(clean_text)
-        except json.JSONDecodeError:
-            raise RuntimeError("Unable to process image at this time")
+    clean_text = "\n".join(text_chunks)
+    clean_text = clean_text.replace("```json", "").replace("```", "").strip()
 
+    # Convert to dict
+    try:
+        result = json.loads(clean_text)
+    except json.JSONDecodeError:
+        raise RuntimeError("Unable to process image at this time")
+
+    # Estimate token usage
+    estimated_tokens = len(prompt) / 4 + len(clean_text) / 4 + 1000
+    cost = (estimated_tokens / 1_000_000) * 0.075
 
-        # Estimate token usage
-        estimated_tokens = len(prompt) / 4 + len(clean_text) / 4 + 1000
-        cost = (estimated_tokens / 1_000_000) * 0.075
+    log_api_usage(int(estimated_tokens), cost, success=True)
 
-        log_api_usage(int(estimated_tokens), cost, success=True)
+    print(f"✓ Analysis completed in {elapsed:.2f}s (est. cost: ${cost:.6f})")
 
-        print(f"✓ Analysis completed in {elapsed:.2f}s (est. cost: ${cost:.6f})")
+    return result
 
-        return result
 
-    try:
-        result = retry_with_backoff(_call, max_retries=max_retries)
-    except Exception as e:
-        print(f"❌ Final failure: {e}")
-        log_api_usage(0, 0, success=False)
+# =========================
+# MAIN GEMINI SKIN ANALYSIS WITH MULTI-PASS
+# =========================
+def analyze_skin_complete(
+    image_path: str,
+    use_cache: bool = True,
+    max_retries: int = 3,
+    enable_multipass: bool = None
+):
+    """
+    Perform comprehensive skin analysis with optional multi-pass validation.
+    
+    Args:
+        image_path: Path to image file
+        use_cache: Whether to use cached results
+        max_retries: Maximum retry attempts per API call
+        enable_multipass: Override global ENABLE_MULTI_PASS setting
+    
+    Returns:
+        Analysis dictionary with normalized, consistent scores
+    """
+    # Use global setting if not explicitly overridden
+    if enable_multipass is None:
+        enable_multipass = ENABLE_MULTI_PASS
+
+    # Cache key based on image hash
+    cache_key = f"complete_v3_mp{int(enable_multipass)}_{get_image_hash(image_path)}"
+    if use_cache and cache_key in _analysis_cache:
+        print("✓ Using cached analysis results")
+        return _analysis_cache[cache_key]
+
+    def _call():
+        return _perform_single_analysis(image_path)
+
+    results = []
+    
+    if enable_multipass:
+        # Multi-pass validation
+        print(f"🔄 Running {VALIDATION_PASSES}-pass analysis for consistency...")
+        
+        for i in range(VALIDATION_PASSES):
+            try:
+                result = retry_with_backoff(_call, max_retries=max_retries)
+                if result:
+                    results.append(result)
+                    print(f"  ✓ Pass {i+1}/{VALIDATION_PASSES} completed")
+                
+                # Small delay between passes to avoid rate limiting
+                if i < VALIDATION_PASSES - 1:
+                    time.sleep(0.5)
+                    
+            except Exception as e:
+                print(f"  ⚠️ Pass {i+1} failed: {e}")
+                continue
+        
+        if not results:
+            print(f"❌ All {VALIDATION_PASSES} passes failed")
+            log_api_usage(0, 0, success=False)
+            return None
+        
+        # Calculate variance for acne category
+        acne_variance = calculate_variance(results, "acne")
+        
+        if acne_variance > MAX_VARIANCE_THRESHOLD:
+            print(f"⚠️ High variance detected in acne analysis: {acne_variance:.3f}")
+            print(f"   Averaging {len(results)} results for improved consistency")
+        else:
+            print(f"✓ Low variance detected: {acne_variance:.3f} - Results are consistent")
+        
+        # Average all results
+        final_result = average_analyses(results)
+        
+    else:
+        # Single-pass analysis
+        try:
+            final_result = retry_with_backoff(_call, max_retries=max_retries)
+        except Exception as e:
+            print(f"❌ Analysis failed: {e}")
+            log_api_usage(0, 0, success=False)
+            return None
+
+    if not final_result:
         return None
 
-    if result and use_cache:
-        _analysis_cache[cache_key] = result
+    # Apply normalization to all categories
+    for category in ["hydration", "pigmentation", "acne", "pores", "wrinkles"]:
+        if category in final_result:
+            final_result[category] = normalize_category_scores(final_result[category])
+
+    # Cache the final result
+    if use_cache:
+        _analysis_cache[cache_key] = final_result
+
+    return final_result
 
-    return result
 
 # =========================
 # SCORE FUNCTIONS
@@ -410,6 +703,10 @@ def build_detected_text(category, severity):
 # HIGH-LEVEL ANALYSIS WRAPPER
 # =========================
 def get_comprehensive_analysis(image_path):
+    """
+    Get comprehensive skin analysis with all scores and metadata.
+    This is the main entry point called by the Flask API.
+    """
     raw = analyze_skin_complete(image_path)
     if not raw:
         return None
@@ -473,9 +770,13 @@ def get_comprehensive_analysis(image_path):
         "age_analysis": raw["age_analysis"],
         "metadata": {
             "analyzed_at": datetime.now().isoformat(),
-            "model_used": MODEL_COMBINED
+            "model_used": MODEL_COMBINED,
+            "multipass_enabled": ENABLE_MULTI_PASS,
+            "validation_passes": VALIDATION_PASSES if ENABLE_MULTI_PASS else 1
         }
     }
+
+
 # =========================
 # HTML REPORT GENERATOR
 # =========================
@@ -514,15 +815,49 @@ def generate_html_report(analysis, user_info, output_path="new_report.html"):
 
     html = html.replace("{{hydration_severity_label}}", analysis["severity_info"]["hydration"]["label"])
     html = html.replace("{{hydration_detected_text}}", analysis["severity_info"]["hydration"]["text"])
+    
     # User Info
     html = html.replace("{{full_name}}", str(user_info.get("name", "")))
     html = html.replace("{{age}}", str(user_info.get("age", "")))
     html = html.replace("{{phone}}", str(user_info.get("phone", "")))
     html = html.replace("{{gender}}", str(user_info.get("gender", "")))
 
-
     # Write final HTML
     with open(output_path, "w", encoding="utf-8") as f:
         f.write(html)
 
     return output_path
+
+
+# =========================
+# UTILITY FUNCTIONS
+# =========================
+def get_usage_statistics():
+    """Get API usage statistics."""
+    if not _usage_log:
+        return {
+            "total_calls": 0,
+            "successful_calls": 0,
+            "failed_calls": 0,
+            "total_cost": 0.0,
+            "total_tokens": 0
+        }
+    
+    successful = [log for log in _usage_log if log["success"]]
+    failed = [log for log in _usage_log if not log["success"]]
+    
+    return {
+        "total_calls": len(_usage_log),
+        "successful_calls": len(successful),
+        "failed_calls": len(failed),
+        "total_cost": sum(log["cost"] for log in _usage_log),
+        "total_tokens": sum(log["tokens"] for log in _usage_log),
+        "average_cost_per_call": sum(log["cost"] for log in successful) / len(successful) if successful else 0
+    }
+
+
+def clear_cache():
+    """Clear the analysis cache."""
+    global _analysis_cache
+    _analysis_cache = {}
+    print("✓ Analysis cache cleared")