llm

README.md

@@ -1,3 +1,13 @@
+---
+title: Par-ity Project
+emoji: ⛳
+colorFrom: blue
+colorTo: green
+sdk: streamlit
+app_file: app/streamlit_app.py
+pinned: false
+---
+
 # Golf Swing Analysis
 
 A tool for analyzing golf swings using computer vision and AI.

app/main.py

@@ -33,8 +33,8 @@ def main():
         "\nEnable GPT analysis? (y/n, default: y): ").lower() != 'n'
 
     sample_rate_input = input(
-        "\nFrame skip rate for YOLO (1-10, default: 5, auto-adjusts for videos shorter than 5 seconds): ")
-    sample_rate = 5  # Default value
+        "\nFrame processing rate for YOLO (1-10, default: 1 for all frames): ")
+    sample_rate = 1  # Default value - process all frames
     if sample_rate_input.isdigit():
         sample_rate = max(1, min(10, int(sample_rate_input)))
 

app/models/llm_analyzer.py

@@ -61,15 +61,14 @@ def generate_swing_analysis(pose_data, swing_phases, trajectory_data):
         trajectory_data (dict): Dictionary mapping frame indices to trajectory data
         
     Returns:
-        str: Detailed swing analysis and coaching tips
+        str: Detailed swing analysis and coaching tips, or error message
     """
     # Check available services
     services = check_llm_services()
 
-    # If no services are available, return sample analysis
-    if not services['ollama']['available'] and not services['openai'][
-            'available']:
-        return get_sample_analysis()
+    # If no services are available, return error message
+    if not services['ollama']['available'] and not services['openai']['available']:
+        return "Error: No AI services available. Please ensure either Ollama is running or OpenAI API key is configured."
 
     # Prepare data for LLM
     analysis_data = prepare_data_for_llm(pose_data, swing_phases,
@@ -84,7 +83,7 @@ def generate_swing_analysis(pose_data, swing_phases, trajectory_data):
             if analysis:
                 return analysis
         except Exception as e:
-            print(f"Error with Ollama: {str(e)}. Falling back to OpenAI...")
+            print(f"Error with Ollama: {str(e)}")
 
     # Try OpenAI if available
     if services['openai']['available']:
@@ -94,11 +93,10 @@ def generate_swing_analysis(pose_data, swing_phases, trajectory_data):
             if analysis:
                 return analysis
         except Exception as e:
-            print(
-                f"Error with OpenAI: {str(e)}. Using sample analysis instead.")
+            print(f"Error with OpenAI: {str(e)}")
 
-    # If both services failed, return sample analysis
-    return get_sample_analysis()
+    # If both services failed, return error message
+    return "Error: All AI services failed. Please check your API keys and service configurations."
 
 
 def call_ollama_service(prompt, config):
@@ -164,7 +162,7 @@ def call_openai_service(prompt, config):
         try:
             # Try with GPT-4 first
             response = client.chat.completions.create(
-                model="gpt-4-turbo",
+                model="gpt-4o-mini",
                 messages=[{
                     "role":
                     "system",
@@ -211,57 +209,6 @@ def call_openai_service(prompt, config):
         return None
 
 
-def get_sample_analysis():
-    """
-    Return sample analysis when no LLM services are available
-    
-    Returns:
-        str: Sample swing analysis
-    """
-    return """
-## Swing Analysis Summary
-
-Based on the video analysis, here are some observations about your swing:
-
-### Setup Phase
-- Your stance appears slightly wider than shoulder-width, which can provide good stability
-- Your posture shows a good spine angle, though you could bend slightly more from the hips
-- The ball position looks appropriate for the club you're using
-
-### Backswing
-- Your takeaway is smooth with good tempo
-- Your wrist hinge develops appropriately in the backswing
-- Your right elbow could be kept a bit closer to your body for better consistency
-
-### Downswing
-- Good weight transfer from back foot to front foot during the transition
-- Your hips are rotating well through impact
-- The swing plane looks consistent throughout the downswing
-
-### Impact
-- Club face alignment at impact appears slightly open
-- Your head position is stable through impact
-- The club path is on a good line toward the target
-
-### Follow Through
-- Good balance maintained through the finish
-- Full extension of arms after impact
-- Complete rotation of the body toward the target
-
-## Areas for Improvement
-
-1. **Club Face Control**: The slightly open club face at impact suggests you may be prone to slicing the ball. Focus on maintaining a square club face through impact.
-
-2. **Right Elbow Position**: Keeping your right elbow closer to your body during the backswing will help create a more consistent swing plane.
-
-3. **Hip Rotation**: While your hip rotation is good, increasing the speed of rotation could generate more power in your swing.
-
-4. **Wrist Release**: Your wrist release could be more active through impact to generate additional club head speed.
-
-These adjustments should help improve both consistency and distance in your swing.
-"""
-
-
 def prepare_data_for_llm(pose_data, swing_phases, trajectory_data):
     """
     Prepare swing data for LLM analysis
@@ -390,12 +337,6 @@ I've analyzed a golf swing and extracted the following data:
     for phase, data in analysis_data["swing_phases"].items():
         prompt += f"- {phase.capitalize()}: Frame {data['frame_index']}, Duration: {data['duration_frames']} frames\n"
 
-    # Add trajectory information
-    prompt += "\n## Trajectory Data\n"
-    if "trajectory" in analysis_data and "club_speed_mph" in analysis_data[
-            "trajectory"]:
-        prompt += f"- Club Speed: {analysis_data['trajectory']['club_speed_mph']:.1f} mph\n"
-
     # Add detailed biomechanical metrics
     prompt += "\n## Swing Mechanics\n"
 
@@ -440,20 +381,6 @@ I've analyzed a golf swing and extracted the following data:
         int(analysis_data["metrics"].get("ground_force_efficiency", 0.7) *
             100))
 
-    # Swing path and clubface metrics
-    prompt += "\n### Club Path & Face Metrics\n"
-    prompt += "- Swing Path (degrees): {} ({})\n".format(
-        analysis_data["metrics"].get("swing_path", 2.5), "Out-to-In"
-        if analysis_data["metrics"].get("swing_path", 0) > 0 else "In-to-Out")
-    prompt += "- Clubface Angle (degrees): {} ({})\n".format(
-        analysis_data["metrics"].get("clubface_angle", 2.1), "Open"
-        if analysis_data["metrics"].get("clubface_angle", 0) > 0 else "Closed")
-    prompt += "- Attack Angle (degrees): {} ({})\n".format(
-        analysis_data["metrics"].get("attack_angle", -4.2), "Descending" if
-        analysis_data["metrics"].get("attack_angle", 0) < 0 else "Ascending")
-    prompt += "- Club Path Consistency: {}%\n".format(
-        int(analysis_data["metrics"].get("club_path_consistency", 0.78) * 100))
-
     # Tempo and timing metrics
     prompt += "\n### Tempo & Timing\n"
     prompt += "- Transition Smoothness: {}%\n".format(
@@ -492,21 +419,6 @@ Based on this detailed biomechanical data, please provide:
    - Physical limitations
    - Technical flaws
 
-3. Prioritized recommendations for improvement:
-   - Top 3-5 most impactful changes to make
-   - Root cause analysis (why these issues are occurring)
-   - Expected improvement in performance from each change
-
-4. Specific drills and exercises addressing each issue:
-   - Technical drills for swing mechanics
-   - Physical exercises to address any biomechanical limitations
-   - Feel-based drills to develop proper movement patterns
-   - Practice routine recommendations
-
-5. Long-term development plan:
-   - Sequential order of what to work on
-   - Benchmarks for measuring progress
-   - Timeline for improvement
 
 Please be specific, detailed, and actionable in your feedback, providing the kind of analysis a professional golf coach would give after a thorough assessment.
 """

app/models/swing_analyzer.py

@@ -23,7 +23,7 @@ def find_top_of_backswing(pose_data):
     return top_frame
 
 
-def detect_impact_frame(pose_data, detections, sample_rate=2):
+def detect_impact_frame(pose_data, detections, sample_rate=1):
     """
     Simple impact detection: ball movement first, wrist speed fallback
     """
@@ -42,12 +42,29 @@ def detect_impact_frame(pose_data, detections, sample_rate=2):
         ball_detections = [d for d in detections if d.class_name == "sports ball"]
         ball_positions = {}
         
+        # Create a mapping from original video frame indices to processed frame indices
+        original_to_processed = {}
+        for processed_idx in frame_indices:
+            original_frame_idx = processed_idx * sample_rate
+            original_to_processed[original_frame_idx] = processed_idx
+        
         for detection in ball_detections:
-            frame_idx = detection.frame_idx // sample_rate
-            if frame_idx > top_backswing:
+            original_frame_idx = detection.frame_idx
+            # Find the closest processed frame index
+            processed_frame_idx = None
+            if original_frame_idx in original_to_processed:
+                processed_frame_idx = original_to_processed[original_frame_idx]
+            else:
+                # Find closest processed frame
+                closest_original = min(original_to_processed.keys(), 
+                                     key=lambda x: abs(x - original_frame_idx))
+                if abs(closest_original - original_frame_idx) <= sample_rate:
+                    processed_frame_idx = original_to_processed[closest_original]
+            
+            if processed_frame_idx and processed_frame_idx > top_backswing:
                 x1, y1, x2, y2 = detection.bbox
                 center_x, center_y = (x1 + x2) / 2, (y1 + y2) / 2
-                ball_positions[frame_idx] = (center_x, center_y)
+                ball_positions[processed_frame_idx] = (center_x, center_y)
         
         # Find first significant ball movement
         if len(ball_positions) >= 2:
@@ -58,7 +75,7 @@ def detect_impact_frame(pose_data, detections, sample_rate=2):
                 movement = np.sqrt((curr_pos[0] - prev_pos[0])**2 + (curr_pos[1] - prev_pos[1])**2)
                 
                 if movement > 15:  # Significant movement threshold
-                    print(f"Impact detected via ball movement at frame {sorted_frames[i]}")
+                    print(f"Impact detected via ball movement at processed frame {sorted_frames[i]} (original frame {sorted_frames[i] * sample_rate})")
                     return sorted_frames[i]
     
     # Method 2: Wrist speed fallback (simple and reliable)
@@ -80,11 +97,11 @@ def detect_impact_frame(pose_data, detections, sample_rate=2):
             max_wrist_speed = wrist_speed
             impact_frame = curr_frame
     
-    print(f"Impact detected via wrist speed at frame {impact_frame}")
+    print(f"Impact detected via wrist speed at processed frame {impact_frame} (original frame {impact_frame * sample_rate if impact_frame else 'N/A'})")
     return impact_frame or downswing_frames[len(downswing_frames) // 3]
 
 
-def segment_swing_pose_based(pose_data, detections=None, sample_rate=2):
+def segment_swing_pose_based(pose_data, detections=None, sample_rate=1):
     """
     Simple swing segmentation with clean impact detection
     """
@@ -117,7 +134,7 @@ def segment_swing_pose_based(pose_data, detections=None, sample_rate=2):
         downswing_frames = [f for f in frame_indices if f > top_backswing]
         impact_frame = downswing_frames[len(downswing_frames) // 3] if downswing_frames else top_backswing + 1
 
-    print(f"Swing phases: Setup end={setup_end}, Top backswing={top_backswing}, Impact={impact_frame}")
+    print(f"Swing phases: Setup end={setup_end} (orig {setup_end * sample_rate}), Top backswing={top_backswing} (orig {top_backswing * sample_rate}), Impact={impact_frame} (orig {impact_frame * sample_rate if impact_frame else 'N/A'})")
 
     # 4. Assign phases
     for idx in frame_indices:
@@ -136,14 +153,14 @@ def segment_swing_pose_based(pose_data, detections=None, sample_rate=2):
 
 
 # Wrapper function to maintain compatibility with existing Streamlit app
-def segment_swing(pose_data, detections, sample_rate=2):
+def segment_swing(pose_data, detections, sample_rate=1):
     """
     Main swing segmentation function (wrapper for pose-based approach)
     """
     return segment_swing_pose_based(pose_data, detections, sample_rate)
 
 
-def analyze_trajectory(frames, detections, swing_phases, sample_rate=2):
+def analyze_trajectory(frames, detections, swing_phases, sample_rate=1):
     """
     Analyze ball trajectory and calculate club speed
     """

app/streamlit_app.py

@@ -161,14 +161,14 @@ def main():
     else:
         st.sidebar.info("Using sample analysis mode (no LLM required)")
 
-    # Frame skip rate for YOLO
+    # Frame processing rate for YOLO
     sample_rate = st.sidebar.slider(
-        "Frame Skip Rate (YOLO)",
+        "Frame Processing Rate (YOLO)",
         min_value=1,
         max_value=10,
-        value=2,
+        value=1,
         help=
-        "Process every Nth frame. Higher values = faster but less accurate.")
+        "Process every Nth frame. 1 = all frames (most accurate), higher values = faster but less accurate.")
         
     # Pro reference toggle
     enable_pro_comparison = st.sidebar.checkbox(

app/utils/comparison.py

@@ -162,6 +162,7 @@ def extract_key_swing_frames(video_path, frames, swing_phases=None):
         impact_idx = len(frames) // 2
     
     print(f"Key frame indices (relative to processed frames) - Setup: {setup_idx}, Backswing: {backswing_idx}, Impact: {impact_idx}")
+    print(f"These correspond to original video frames (approx) - Setup: ~{setup_idx * 1}, Backswing: ~{backswing_idx * 1}, Impact: ~{impact_idx * 1} (assuming sample_rate=1)")
     
     # Get rotation angle from the original video file
     rotation_angle = 0

app/utils/video_processor.py

@@ -20,13 +20,13 @@ class Detection:
         self.confidence = confidence
 
 
-def process_video(video_path, sample_rate=5):
+def process_video(video_path, sample_rate=1):
     """
     Process video and detect golfer, club, and ball
     
     Args:
         video_path (str): Path to the video file
-        sample_rate (int): Process every nth frame
+        sample_rate (int): Process every nth frame (default: 1 for all frames)
         
     Returns:
         tuple: (frames, detections)
@@ -50,10 +50,7 @@ def process_video(video_path, sample_rate=5):
 
     frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
 
-    if frame_count < 150:
-        print(f"Short video detected ({frame_count} frames). Processing all frames.")
-        sample_rate = 1
-
+    # Process all frames by default
     frames = []
     detections = []
 

app/utils/visualizer.py

@@ -38,7 +38,7 @@ def create_annotated_video(video_path,
                            swing_phases,
                            trajectory_data,
                            output_dir="downloads",
-                           sample_rate=5):
+                           sample_rate=1):
     """
     Create an annotated video with swing analysis visualizations