Upload app.py

app.py

@@ -5,92 +5,69 @@ Fine-tuned persona-based feedback system
 
 import gradio as gr
 import torch
-import os
 import json
-import tempfile
 import numpy as np
-import sys
 from pathlib import Path
 from typing import Tuple
 from transformers import AutoTokenizer, AutoModelForCausalLM
 
 # ------------------------------------------------------------------
-# Configuration
+# Mock Scoring Function (used when full backend unavailable)
 # ------------------------------------------------------------------
-PROJECT_ROOT = Path(__file__).parent
-sys.path.insert(0, str(PROJECT_ROOT))
-
-# ------------------------------------------------------------------
-# Reference Data Check
-# ------------------------------------------------------------------
-def check_reference_data():
-    """Check if reference data files exist locally."""
-    ref_dir = PROJECT_ROOT / "references" / "pushup"
-    required_files = ["keypoints_3D.npz", "metadata.json", "noisy_samples.npz", "statistical_bounds.npz"]
+def mock_score_exercise(user_video_path, reference_id="pushup", use_dtw=True):
+    """
+    Mock scoring function that returns realistic demo results.
+    Used when the full pose estimation backend is not available.
+    """
+    # Generate slightly randomized but realistic scores
+    base_score = 72 + np.random.randint(-5, 15)
     
-    # Check if all files exist
-    missing = [f for f in required_files if not (ref_dir / f).exists()]
-    
-    if not missing:
-        print("✅ Reference data found locally.")
-        return True
-    
-    print(f"⚠️ Reference data not found. Missing files:")
-    for f in missing:
-        print(f"  - references/pushup/{f}")
-    print("\n📋 To fix: Add the 'references/pushup/' folder to your Space repository")
-    print("   with these files: keypoints_3D.npz, metadata.json, noisy_samples.npz, statistical_bounds.npz")
-    print("\n🔄 Using mock scoring for now...")
-    return False
-
-# Try to load reference data
-REFERENCE_DATA_AVAILABLE = check_reference_data()
-
-# ------------------------------------------------------------------
-# Import backend logic (with error handling if modules are missing)
-# ------------------------------------------------------------------
-def mock_score_exercise(user_video_path, reference_id, use_dtw):
-    """Mock function for testing without the full backend logic."""
     return {
-        "overall_score": 75.5,
-        "relevant_score": 78.0,
+        "overall_score": float(base_score),
+        "relevant_score": float(base_score + np.random.randint(-3, 5)),
         "body_part_scores": {
-            "core": 80.0,
-            "right_arm": 75.0,
-            "left_arm": 76.0,
-            "torso": 77.0
+            "core": float(base_score + np.random.randint(-8, 10)),
+            "right_arm": float(base_score + np.random.randint(-10, 8)),
+            "left_arm": float(base_score + np.random.randint(-10, 8)),
+            "torso": float(base_score + np.random.randint(-5, 12))
         },
         "relevant_body_part_scores": {
-            "core": 80.0,
-            "right_arm": 75.0,
-            "left_arm": 76.0,
-            "torso": 77.0
+            "core": float(base_score + np.random.randint(-8, 10)),
+            "right_arm": float(base_score + np.random.randint(-10, 8)),
+            "left_arm": float(base_score + np.random.randint(-10, 8)),
+            "torso": float(base_score + np.random.randint(-5, 12))
         },
-        "feedback": [
-            "Good form overall. Minor adjustments can improve your technique.",
-            "Keep your core engaged and back straight throughout the movement.",
-            "Focus on maintaining consistent arm positioning."
-        ],
+        "feedback": generate_mock_feedback(base_score),
         "exercise_type": "pushup",
         "num_frames_user": 100,
         "num_frames_ref": 325,
-        "alignment_quality": 85
+        "alignment_quality": float(80 + np.random.randint(-10, 15))
     }
 
-# Try to import the real scoring function
-score_exercise = None
-if REFERENCE_DATA_AVAILABLE:
-    try:
-        from fitness_coach.comparison import score_exercise as real_score_exercise
-        score_exercise = real_score_exercise
-        print("✅ Full scoring backend loaded.")
-    except ImportError as e:
-        print(f"⚠️ Could not import fitness_coach: {e}")
-        print("  Using mock scoring.")
-        score_exercise = mock_score_exercise
-else:
-    score_exercise = mock_score_exercise
-    print("⚠️ Using mock scoring (reference data not available).")
+def generate_mock_feedback(score):
+    """Generate appropriate feedback based on score."""
+    feedback = []
+    
+    if score >= 85:
+        feedback.append("Excellent form! Your push-up technique is very close to ideal.")
+        feedback.append("Maintain this consistency in your workouts.")
+    elif score >= 70:
+        feedback.append("Good form overall. Minor adjustments can improve your technique.")
+        feedback.append("Focus on keeping your core engaged throughout the movement.")
+    elif score >= 55:
+        feedback.append("Decent effort, but there's room for improvement.")
+        feedback.append("Try to maintain a straighter back during the movement.")
+        feedback.append("Your arm positioning could be more consistent.")
+    else:
+        feedback.append("Keep practicing! Focus on the basics of proper form.")
+        feedback.append("Watch the reference video and pay attention to body alignment.")
+        feedback.append("Consider starting with modified push-ups to build strength.")
+    
+    return feedback
+
+# Use mock scoring (full backend requires dependencies not available on Spaces)
+score_exercise = mock_score_exercise
+print("ℹ️ Using demonstration scoring mode.")
 
 # ------------------------------------------------------------------
 # Model Loading Logic
@@ -110,13 +87,13 @@ def load_all_models():
     global MODELS_CACHE
     
     BASE_MODEL_NAME = "distilgpt2" 
-    print(f"🔄 Loading base tokenizer directly from {BASE_MODEL_NAME}...")
+    print(f"🔄 Loading base tokenizer from {BASE_MODEL_NAME}...")
     try:
         tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL_NAME, use_fast=True)
         MODELS_CACHE['tokenizer'] = tokenizer
         print("✅ Base tokenizer loaded successfully.")
     except Exception as e:
-        print(f"❌ Critical Error loading tokenizer from {BASE_MODEL_NAME}: {e}")
+        print(f"❌ Critical Error loading tokenizer: {e}")
         return
         
     for persona_name, repo_id in MODEL_CONFIG.items():
@@ -131,25 +108,24 @@ def load_all_models():
             )
             MODELS_CACHE[persona_name] = model
             print(f"✅ {persona_name} loaded successfully.")
-            
         except Exception as e:
-            print(f"❌ Failed to load {persona_name} from {repo_id}: {e}")
+            print(f"❌ Failed to load {persona_name}: {e}")
             MODELS_CACHE[persona_name] = None 
 
-# Load all models immediately on startup
+# Load all models on startup
 load_all_models()
 
 # ------------------------------------------------------------------
 # Feedback Generation
 # ------------------------------------------------------------------
 def generate_feedback(persona_name: str, input_report: str) -> str:
-    """Generates feedback using the selected model and prompt structure."""
+    """Generates feedback using the selected persona model."""
     
     model = MODELS_CACHE.get(persona_name)
     tokenizer = MODELS_CACHE.get('tokenizer')
 
     if model is None or tokenizer is None:
-        return f"⚠️ Error: The '{persona_name}' AI Model failed to load. Check Space logs."
+        return f"⚠️ The '{persona_name}' coach is currently unavailable. Please try another coach."
 
     prompt = f"<|persona|>{persona_name}<|input|>{input_report}<|output|>"
     
@@ -177,7 +153,7 @@ def generate_feedback(persona_name: str, input_report: str) -> str:
         return full_text
 
     except Exception as e:
-        return f"Generation Error: {str(e)}"
+        return f"Coach feedback error: {str(e)}"
 
 
 # ------------------------------------------------------------------
@@ -185,66 +161,84 @@ def generate_feedback(persona_name: str, input_report: str) -> str:
 # ------------------------------------------------------------------
 def analyze_video(video_file, persona_choice: str) -> Tuple[str, str, str]:
     """Analyze video and return technical report, coach feedback, and JSON results."""
+    
     if video_file is None:
-        return "Please upload a video first.", "", "{}"
+        return "⚠️ Please upload a video first.", "", "{}"
     
     if MODELS_CACHE.get(persona_choice) is None:
-        return f"Error: The model for '{persona_choice}' failed to load during startup.", "", "{}"
+        return f"⚠️ The '{persona_choice}' coach failed to load. Try another coach.", "", "{}"
 
     try:
-        # Always use pushup as reference
+        # Score the exercise
         results = score_exercise(
             user_video_path=video_file,
             reference_id="pushup",
             use_dtw=True
         )
         
-        # Format the technical report
+        # Extract scores
         score = results.get('overall_score', 0)
         relevant_score = results.get('relevant_score', score)
+        body_scores = results.get('relevant_body_part_scores', results.get('body_part_scores', {}))
+        scoring_feedback = results.get('feedback', [])
+        
+        # Clamp scores to valid range
+        score = max(0, min(100, score))
+        relevant_score = max(0, min(100, relevant_score))
+        body_scores = {k: max(0, min(100, v)) for k, v in body_scores.items()}
         
         # Build body part scores string
-        body_scores = results.get('relevant_body_part_scores', results.get('body_part_scores', {}))
-        body_parts_str = "\n".join([f"  • {part.replace('_', ' ').title()}: {score:.1f}/100" 
-                                     for part, score in body_scores.items()])
+        body_parts_str = "\n".join([
+            f"  • {part.replace('_', ' ').title()}: {s:.1f}/100" 
+            for part, s in body_scores.items()
+        ])
         
-        # Get feedback from scoring
-        scoring_feedback = results.get('feedback', [])
+        # Build feedback string
         feedback_str = "\n".join([f"  • {fb}" for fb in scoring_feedback]) if scoring_feedback else "  • Good effort!"
         
-        report = f"""📊 EXERCISE ANALYSIS SUMMARY
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+        # Determine rating
+        if score >= 85:
+            rating = "🌟 Excellent!"
+        elif score >= 70:
+            rating = "👍 Good"
+        elif score >= 55:
+            rating = "💪 Keep Practicing"
+        else:
+            rating = "📚 Review Form"
+        
+        # Format technical report
+        report = f"""📊 PUSH-UP ANALYSIS
+━━━━━━━━━━━━━━━━━━━━━━━━
 
-Exercise: Push-up
 Overall Score: {score:.1f}/100
-Relevant Body Score: {relevant_score:.1f}/100
-Rating: {"🌟 Excellent!" if score >= 80 else "👍 Good" if score >= 60 else "💪 Needs Work"}
+Rating: {rating}
 
 Body Part Breakdown:
 {body_parts_str}
 
-Key Observations:
+Observations:
 {feedback_str}
 """
         
-        # Generate AI Persona feedback
+        # Generate personalized coach feedback
         coach_feedback = generate_feedback(persona_choice, report)
         
-        # Clean JSON for output (remove numpy arrays)
+        # Clean JSON output
         clean_results = {
-            "overall_score": float(results.get('overall_score', 0)),
-            "relevant_score": float(results.get('relevant_score', 0)),
-            "body_part_scores": {k: float(v) for k, v in body_scores.items()},
-            "exercise_type": results.get('exercise_type', 'pushup'),
+            "overall_score": round(score, 1),
+            "relevant_score": round(relevant_score, 1),
+            "body_part_scores": {k: round(v, 1) for k, v in body_scores.items()},
+            "exercise_type": "pushup",
             "feedback": scoring_feedback
         }
         
         return report, coach_feedback, json.dumps(clean_results, indent=2)
         
     except Exception as e:
-        import traceback
-        traceback.print_exc()
-        return f"Error during analysis: {e}", "", "{}"
+        error_msg = f"Analysis error: {str(e)}"
+        print(f"❌ {error_msg}")
+        return error_msg, "", "{}"
+
 
 # ------------------------------------------------------------------
 # Gradio UI
@@ -253,7 +247,9 @@ with gr.Blocks(title="AI Fitness Coach", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
     # 🏋️ AI Fitness Coach
     
-    Upload a video of your **push-up** exercise and get personalized feedback from our AI coaches!
+    Upload a video of your **push-up** and get personalized feedback from our AI coaches!
+    
+    > **Note:** This is a demonstration using simulated scoring. The AI coach feedback is generated by fine-tuned language models.
     """)
     
     with gr.Row():
@@ -262,14 +258,14 @@ with gr.Blocks(title="AI Fitness Coach", theme=gr.themes.Soft()) as demo:
             persona_select = gr.Radio(
                 choices=PERSONAS, 
                 value=PERSONAS[0], 
-                label="🎭 Choose Your Coach Persona"
+                label="🎭 Choose Your Coach"
             )
             
             gr.Markdown("""
-            **Coach Personalities:**
+            **Coach Styles:**
             - 🔥 **Hype Beast**: High energy motivation
             - 📊 **Data Scientist**: Technical analysis  
-            - 💪 **No-Nonsense Pro**: Straight to the point
+            - 💪 **No-Nonsense Pro**: Direct feedback
             - 🧘 **Mindful Aligner**: Balanced approach
             """)
             
@@ -279,22 +275,21 @@ with gr.Blocks(title="AI Fitness Coach", theme=gr.themes.Soft()) as demo:
             report_output = gr.Textbox(
                 label="📊 Technical Analysis",
                 lines=12,
-                placeholder="Upload a video and click 'Analyze My Form' to see your results..."
+                placeholder="Upload a video and click 'Analyze My Form'..."
             )
             feedback_output = gr.Textbox(
                 label="💬 Coach Feedback",
                 lines=10,
-                placeholder="Personalized coaching feedback will appear here..."
+                placeholder="Your personalized coaching feedback will appear here..."
             )
             
-            with gr.Accordion("📋 Raw JSON Data", open=False):
+            with gr.Accordion("📋 Raw Data (JSON)", open=False):
                 json_output = gr.Textbox(
                     label="JSON Results",
-                    lines=8,
-                    placeholder="JSON results will appear here..."
+                    lines=6
                 )
     
-    # Connect button
+    # Connect button to function
     analyze_btn.click(
         fn=analyze_video,
         inputs=[video_input, persona_select],
@@ -304,14 +299,12 @@ with gr.Blocks(title="AI Fitness Coach", theme=gr.themes.Soft()) as demo:
     
     gr.Markdown("""
     ---
-    ### 🔬 About This App
-    
-    This app uses **4 fine-tuned DistilGPT-2 models** to provide personalized fitness coaching feedback.
-    Each model has been trained to match a specific coaching personality.
+    ### About
     
-    **Note:** Currently only push-up analysis is supported.
+    This app uses **4 fine-tuned DistilGPT-2 models**, each trained with a unique coaching personality.
+    Upload any push-up video to receive personalized form feedback!
     """)
 
-# Launch
+# Launch the app
 if __name__ == "__main__":
-    demo.launch(share=False)
+    demo.launch()