Update for HF Spaces deployment: Add memory management, error handling, and logging

.gitignore

@@ -0,0 +1,43 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Project specific
+static/uploads/
+temp_frame_for_cnn_*.jpg
+*.mp4
+*.avi
+*.mov
+*.mkv
+
+# Logs
+*.log 

Dockerfile

@@ -1,35 +1,29 @@
-# Use a Python version that matches your (keras2env) as closely as possible
-FROM python:3.9-slim 
+FROM python:3.10-slim
 
-WORKDIR /app
+WORKDIR /code
 
 # Install system dependencies
-RUN apt-get update && apt-get install -y --no-install-recommends \
+RUN apt-get update && apt-get install -y \
     libgl1-mesa-glx \
     libglib2.0-0 \
     && rm -rf /var/lib/apt/lists/*
 
+# Copy requirements first to leverage Docker cache
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Fix permissions for mediapipe model files
-RUN chmod -R 755 /usr/local/lib/python3.9/site-packages/mediapipe
+# Copy the rest of the application
+COPY . .
 
-# Copy all necessary application files and folders from HFup/ to /app in the container
-# These paths are relative to the Dockerfile's location (i.e., inside HFup/)
-COPY app.py .
-RUN echo "Listing files:" && ls -la # Debug: List files in the build context root
-COPY bodybuilding_pose_analyzer bodybuilding_pose_analyzer
-COPY external external
-# COPY yolov7 yolov7 
-# COPY yolov7-w6-pose.pt . 
-COPY static static
-COPY templates templates
+# Create necessary directories
+RUN mkdir -p static/uploads
 
-# Ensure the uploads directory within static exists and is writable
-RUN mkdir -p static/uploads && chmod -R 777 static/uploads
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV FLASK_APP=app.py
 
+# Expose the port
 EXPOSE 7860
 
-# Command to run app with Gunicorn
-CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--workers", "1", "--threads", "2", "--timeout", "300", "app:app"] 
+# Run the application
+CMD ["python", "app.py"] 

README.md

@@ -71,6 +71,55 @@ This Space uses a Flask backend with various machine learning models for pose es
 *   The feedback provided is based on predefined angle ranges and may not cover all nuances of perfect form.
 *   Processing time can be significant for longer videos or when using more computationally intensive models.
 
+## Setup
+
+1. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+2. Ensure the model files are in place:
+- CNN model: `external/BodybuildingPoseClassifier/bodybuilding_pose_classifier.h5`
+
+3. Run the application:
+```bash
+python app.py
+```
+
+The application will be available at `http://localhost:7860`
+
+## Usage
+
+1. Open the web interface
+2. Select a video file (supported formats: mp4, avi, mov, mkv)
+3. Choose the model (Gladiator SupaDot or MoveNet)
+4. Upload and wait for processing
+5. View the results with pose detection, angles, and corrections
+
+## Models
+
+- **Gladiator SupaDot**: Custom pose analyzer with detailed angle measurements and form corrections
+- **MoveNet**: Google's pose detection model for basic pose tracking
+
+## Dependencies
+
+- Flask
+- OpenCV
+- TensorFlow
+- MediaPipe
+- NumPy
+- Other dependencies listed in requirements.txt
+
+## Notes
+
+- Maximum video file size: 100MB
+- Processing time depends on video length and available hardware
+- GPU acceleration is automatically enabled if available
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
 ---
 
 *Remember to replace placeholder links and add any other specific information relevant to your project!* 

app.py

@@ -12,6 +12,9 @@ from tensorflow.keras.models import load_model
 from tensorflow.keras.preprocessing import image
 import time
 import tensorflow_hub as hub
+import gc
+import psutil
+import logging
 
 # Check GPU availability
 print("[GPU] Checking GPU availability...")
@@ -32,13 +35,20 @@ sys.path.append('.') # Assuming app.py is at the root of cv.github.io
 from bodybuilding_pose_analyzer.src.movenet_analyzer import MoveNetAnalyzer
 from bodybuilding_pose_analyzer.src.pose_analyzer import PoseAnalyzer
 
-# Add YOLOv7 to path
-# sys.path.append('yolov7')
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-# from yolov7.models.experimental import attempt_load
-# from yolov7.utils.general import check_img_size, non_max_suppression_kpt, scale_coords
-# from yolov7.utils.torch_utils import select_device
-# from yolov7.utils.plots import plot_skeleton_kpts
+def log_memory_usage():
+    """Log current memory usage."""
+    process = psutil.Process()
+    memory_info = process.memory_info()
+    logger.info(f"Memory usage: {memory_info.rss / 1024 / 1024:.2f} MB")
+
+def cleanup_memory():
+    """Force garbage collection and log memory usage."""
+    gc.collect()
+    log_memory_usage()
 
 def wrap_text(text: str, font_face: int, font_scale: float, thickness: int, max_width: int) -> list[str]:
     """Wrap text to fit within max_width."""
@@ -83,25 +93,6 @@ app.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024  # 100MB max file size
 # Ensure upload directory exists
 os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
 
-# Initialize YOLOv7 model
-# device = select_device('')
-# yolo_model = None # Initialize as None
-# stride = None
-# imgsz = None
-
-# try:
-#     yolo_model = attempt_load('yolov7-w6-pose.pt', map_location=device)
-#     stride = int(yolo_model.stride.max())
-#     imgsz = check_img_size(640, s=stride)
-#     print("YOLOv7 Model loaded successfully")
-# except Exception as e:
-#     print(f"Error loading YOLOv7 model: {e}")
-#     traceback.print_exc()
-    # Not raising here to allow app to run if only MoveNet is used. Error will be caught if YOLOv7 is selected.
-
-# YOLOv7 pose model expects 17 keypoints
-# kpt_shape = (17, 3)
-
 # Load CNN model for bodybuilding pose classification
 cnn_model_path = 'external/BodybuildingPoseClassifier/bodybuilding_pose_classifier.h5'
 cnn_model = load_model(cnn_model_path)
@@ -109,31 +100,34 @@ cnn_class_labels = ['side_chest', 'front_double_biceps', 'back_double_biceps', '
 
 def predict_pose_cnn(img_path):
     try:
+        cleanup_memory()  # Clean up before prediction
         if gpus:
-            print("[CNN_DEBUG] Using GPU for CNN prediction")
+            logger.info("[CNN_DEBUG] Using GPU for CNN prediction")
             with tf.device('/GPU:0'):
                 img = image.load_img(img_path, target_size=(150, 150))
                 img_array = image.img_to_array(img)
                 img_array = np.expand_dims(img_array, axis=0) / 255.0
-                predictions = cnn_model.predict(img_array)
+                predictions = cnn_model.predict(img_array, verbose=0)  # Disable progress bar
                 predicted_class = np.argmax(predictions, axis=1)
                 confidence = float(np.max(predictions))
         else:
-            print("[CNN_DEBUG] No GPU found, using CPU for CNN prediction")
+            logger.info("[CNN_DEBUG] No GPU found, using CPU for CNN prediction")
             with tf.device('/CPU:0'):
                 img = image.load_img(img_path, target_size=(150, 150))
                 img_array = image.img_to_array(img)
                 img_array = np.expand_dims(img_array, axis=0) / 255.0
-                predictions = cnn_model.predict(img_array)
+                predictions = cnn_model.predict(img_array, verbose=0)  # Disable progress bar
                 predicted_class = np.argmax(predictions, axis=1)
                 confidence = float(np.max(predictions))
         
-        print(f"[CNN_DEBUG] Prediction successful: {cnn_class_labels[predicted_class[0]]}")
+        logger.info(f"[CNN_DEBUG] Prediction successful: {cnn_class_labels[predicted_class[0]]}")
         return cnn_class_labels[predicted_class[0]], confidence
     except Exception as e:
-        print(f"[CNN_ERROR] Exception during CNN prediction: {e}")
+        logger.error(f"[CNN_ERROR] Exception during CNN prediction: {e}")
         traceback.print_exc()
         raise
+    finally:
+        cleanup_memory()  # Clean up after prediction
 
 @app.route('/static/uploads/<path:filename>')
 def serve_video(filename):
@@ -150,88 +144,6 @@ def after_request(response):
     response.headers.add('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS')
     return response
 
-# def process_video_yolov7(video_path): # Renamed from process_video
-#     global yolo_model, imgsz, stride # Ensure global model is used
-#     if yolo_model is None:
-#         raise RuntimeError("YOLOv7 model failed to load. Cannot process video.")
-#     try:
-#         if not os.path.exists(video_path):
-#             raise FileNotFoundError(f"Video file not found: {video_path}")
-#             
-#         cap = cv2.VideoCapture(video_path)
-#         if not cap.isOpened():
-#             raise ValueError(f"Failed to open video file: {video_path}")
-#             
-#         fps = int(cap.get(cv2.CAP_PROP_FPS))
-#         width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-#         height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-#         
-#         print(f"Processing video: {width}x{height} @ {fps}fps")
-#         
-#         # Create output video writer
-#         output_path = os.path.join(app.config['UPLOAD_FOLDER'], 'output.mp4')
-#         fourcc = cv2.VideoWriter_fourcc(*'avc1')
-#         out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
-#         
-#         frame_count = 0
-#         while cap.isOpened():
-#             ret, frame = cap.read()
-#             if not ret:
-#                 break
-#             
-#             frame_count += 1
-#             print(f"Processing frame {frame_count}")
-#             
-#             # Prepare image
-#             img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-#             img = cv2.resize(img, (imgsz, imgsz))
-#             img = img.transpose((2, 0, 1))  # HWC to CHW
-#             img = np.ascontiguousarray(img)
-#             img = torch.from_numpy(img).to(device)
-#             img = img.float() / 255.0
-#             if img.ndimension() == 3:
-#                 img = img.unsqueeze(0)
-#             
-#             # Inference
-#             with torch.no_grad():
-#                 pred = yolo_model(img)[0] # Use yolo_model
-#                 pred = non_max_suppression_kpt(pred, conf_thres=0.25, iou_thres=0.45, nc=yolo_model.yaml['nc'], kpt_label=True)
-#             
-#             # Draw results
-#             output_frame = frame.copy()
-#             poses_detected = False
-#             for det in pred:
-#                 if len(det):
-#                     poses_detected = True
-#                     det[:, :4] = scale_coords(img.shape[2:], det[:, :4], frame.shape).round()
-#                     for row in det:
-#                         xyxy = row[:4]
-#                         conf = row[4]
-#                         cls = row[5]
-#                         kpts = row[6:]
-#                         kpts = torch.tensor(kpts).view(kpt_shape)
-#                         output_frame = plot_skeleton_kpts(output_frame, kpts, steps=3, orig_shape=output_frame.shape[:2])
-#             
-#             if not poses_detected:
-#                 print(f"No poses detected in frame {frame_count}")
-#             
-#             out.write(output_frame)
-#         
-#         cap.release()
-#         out.release()
-#         
-#         if frame_count == 0:
-#             raise ValueError("No frames were processed from the video")
-#             
-#         print(f"Video processing completed. Processed {frame_count} frames")
-#         # Return URL for the client, using the 'serve_video' endpoint
-#         output_filename = 'output.mp4'
-#         return url_for('serve_video', filename=output_filename, _external=False)
-#     except Exception as e:
-#         print('Error in process_video:', e)
-#         traceback.print_exc()
-#         raise
-
 def process_video_movenet(video_path):
     try:
         print("[DEBUG] Starting MoveNet video processing")
@@ -328,7 +240,8 @@ def process_video_movenet(video_path):
 
 def process_video_mediapipe(video_path):
     try:
-        print(f"[PROCESS_VIDEO_MEDIAPIPE] Called with video_path: {video_path}")
+        cleanup_memory()  # Clean up before processing
+        logger.info(f"[PROCESS_VIDEO_MEDIAPIPE] Called with video_path: {video_path}")
         if not os.path.exists(video_path):
             raise FileNotFoundError(f"Video file not found: {video_path}")
 
@@ -365,7 +278,8 @@ def process_video_mediapipe(video_path):
                 break
             frame_count += 1
             if frame_count % 30 == 0:
-                print(f"Processing frame {frame_count}")
+                logger.info(f"Processing frame {frame_count}")
+                cleanup_memory()  # Clean up periodically
 
             # Process frame with MediaPipe
             processed_frame, current_analysis_results, landmarks = analyzer.process_frame(frame, last_valid_landmarks=last_valid_landmarks)
@@ -379,14 +293,14 @@ def process_video_mediapipe(video_path):
                 cv2.imwrite(temp_img_path, frame)
                 try:
                     cnn_pose_pred, cnn_conf = predict_pose_cnn(temp_img_path)
-                    print(f"[CNN] Frame {frame_count}: Pose: {cnn_pose_pred}, Conf: {cnn_conf:.2f}")
+                    logger.info(f"[CNN] Frame {frame_count}: Pose: {cnn_pose_pred}, Conf: {cnn_conf:.2f}")
                     if cnn_conf >= 0.3:
                         current_pose = cnn_pose_pred # Update current_pose to be displayed
                 except Exception as e:
-                    print(f"[CNN] Error predicting pose on frame {frame_count}: {e}")
+                    logger.error(f"[CNN] Error predicting pose on frame {frame_count}: {e}")
                 finally:
-                if os.path.exists(temp_img_path):
-                    os.remove(temp_img_path)
+                    if os.path.exists(temp_img_path):
+                        os.remove(temp_img_path)
 
             # Create side panel
             panel = np.zeros((height, panel_width, 3), dtype=np.uint8)
@@ -395,33 +309,29 @@ def process_video_mediapipe(video_path):
             current_font = cv2.FONT_HERSHEY_DUPLEX
             
             # Base font scale and reference video height for scaling
-            # Adjust base_font_scale_at_ref_height if text is generally too large or too small
             base_font_scale_at_ref_height = 0.6 
-            reference_height_for_font_scale = 640.0 # e.g., a common video height like 480p, 720p
+            reference_height_for_font_scale = 640.0
             
             # Calculate dynamic font_scale
             font_scale = (height / reference_height_for_font_scale) * base_font_scale_at_ref_height
-            # Clamp font_scale to a min/max range to avoid extremes
             font_scale = max(0.4, min(font_scale, 1.2)) 
 
             # Calculate dynamic thickness
             thickness = 1 if font_scale < 0.7 else 2
 
-            # Calculate dynamic line_height based on actual text height
-            # Using a sample string like "Ag" which has ascenders and descenders
+            # Calculate dynamic line_height
             (_, text_actual_height), _ = cv2.getTextSize("Ag", current_font, font_scale, thickness)
-            line_spacing_factor = 1.8 # Adjust for more or less space between lines
+            line_spacing_factor = 1.8
             line_height = int(text_actual_height * line_spacing_factor)
-            line_height = max(line_height, 15) # Ensure a minimum line height
+            line_height = max(line_height, 15)
 
-            # Initial y_offset for the first line of text
-            y_offset_panel = max(line_height, 20) # Start considering top margin and text height
-            # --- End of Dynamic Text Parameter Calculations ---
+            # Initial y_offset
+            y_offset_panel = max(line_height, 20)
 
             cv2.putText(panel, "Model: Gladiator SupaDot", (10, y_offset_panel), current_font, font_scale, (0, 255, 255), thickness, lineType=cv2.LINE_AA)
             y_offset_panel += line_height
-            if frame_count % 30 == 0: # Print every 30 frames to avoid flooding console
-                print(f"[MEDIAPIPE_PANEL] Frame {frame_count} - Current Pose for Panel: {current_pose}")
+            if frame_count % 30 == 0:
+                logger.info(f"[MEDIAPIPE_PANEL] Frame {frame_count} - Current Pose for Panel: {current_pose}")
             cv2.putText(panel, f"Pose: {current_pose}", (10, y_offset_panel), current_font, font_scale, (255, 0, 0), thickness, lineType=cv2.LINE_AA)
             y_offset_panel += int(line_height * 1.5)
 
@@ -441,10 +351,9 @@ def process_video_mediapipe(video_path):
                         cv2.putText(panel, f"• {correction}", (20, y_offset_panel), current_font, font_scale, (0, 0, 255), thickness, lineType=cv2.LINE_AA)
                         y_offset_panel += line_height
                 
-                # Display notes if any
                 if analysis_results.get('notes'):
                     y_offset_panel += line_height
-                    cv2.putText(panel, "Notes:", (10, y_offset_panel), current_font, font_scale, (200, 200, 200), thickness, lineType=cv2.LINE_AA) # Grey color for notes
+                    cv2.putText(panel, "Notes:", (10, y_offset_panel), current_font, font_scale, (200, 200, 200), thickness, lineType=cv2.LINE_AA)
                     y_offset_panel += line_height
                     for note in analysis_results.get('notes', []):
                         cv2.putText(panel, f"• {note}", (20, y_offset_panel), current_font, font_scale, (200, 200, 200), thickness, lineType=cv2.LINE_AA)
@@ -454,19 +363,22 @@ def process_video_mediapipe(video_path):
                 y_offset_panel += line_height
                 cv2.putText(panel, analysis_results.get('error', 'Unknown error'), (20, y_offset_panel), current_font, font_scale, (0, 0, 255), thickness, lineType=cv2.LINE_AA)
             
-            combined_frame = np.hstack((processed_frame, panel)) # Use processed_frame from analyzer
+            combined_frame = np.hstack((processed_frame, panel))
             out.write(combined_frame)
 
         cap.release()
         out.release()
+        cleanup_memory()  # Clean up after processing
         if frame_count == 0:
             raise ValueError("No frames were processed from the video by MediaPipe")
-        print(f"MediaPipe video processing completed. Processed {frame_count} frames. Output: {output_path}")
+        logger.info(f"MediaPipe video processing completed. Processed {frame_count} frames. Output: {output_path}")
         return url_for('serve_video', filename=output_filename, _external=False)
     except Exception as e:
-        print(f'Error in process_video_mediapipe: {e}')
+        logger.error(f'Error in process_video_mediapipe: {e}')
         traceback.print_exc()
         raise
+    finally:
+        cleanup_memory()  # Clean up in case of error
 
 @app.route('/')
 def index():
@@ -475,55 +387,56 @@ def index():
 @app.route('/upload', methods=['POST'])
 def upload_file():
     try:
+        cleanup_memory()  # Clean up before processing
         if 'video' not in request.files:
-            print("[UPLOAD] No video file in request")
+            logger.error("[UPLOAD] No video file in request")
             return jsonify({'error': 'No video file provided'}), 400
             
         file = request.files['video']
         if file.filename == '':
-            print("[UPLOAD] Empty filename")
+            logger.error("[UPLOAD] Empty filename")
             return jsonify({'error': 'No selected file'}), 400
             
         if file:
             allowed_extensions = {'mp4', 'avi', 'mov', 'mkv'}
             if '.' not in file.filename or file.filename.rsplit('.', 1)[1].lower() not in allowed_extensions:
-                print(f"[UPLOAD] Invalid file format: {file.filename}")
+                logger.error(f"[UPLOAD] Invalid file format: {file.filename}")
                 return jsonify({'error': 'Invalid file format. Allowed formats: mp4, avi, mov, mkv'}), 400
                 
             # Ensure the filename is properly sanitized
             filename = secure_filename(file.filename)
-            print(f"[UPLOAD] Original filename: {file.filename}")
-            print(f"[UPLOAD] Sanitized filename: {filename}")
+            logger.info(f"[UPLOAD] Original filename: {file.filename}")
+            logger.info(f"[UPLOAD] Sanitized filename: {filename}")
             
             # Create a unique filename to prevent conflicts
             base, ext = os.path.splitext(filename)
             unique_filename = f"{base}_{int(time.time())}{ext}"
             filepath = os.path.join(app.config['UPLOAD_FOLDER'], unique_filename)
             
-            print(f"[UPLOAD] Saving file to: {filepath}")
+            logger.info(f"[UPLOAD] Saving file to: {filepath}")
             file.save(filepath)
             
             if not os.path.exists(filepath):
-                print(f"[UPLOAD] File not found after save: {filepath}")
+                logger.error(f"[UPLOAD] File not found after save: {filepath}")
                 return jsonify({'error': 'Failed to save uploaded file'}), 500
                 
-            print(f"[UPLOAD] File saved successfully. Size: {os.path.getsize(filepath)} bytes")
+            logger.info(f"[UPLOAD] File saved successfully. Size: {os.path.getsize(filepath)} bytes")
             
             try:
                 model_choice = request.form.get('model_choice', 'Gladiator SupaDot')
-                print(f"[UPLOAD] Processing with model: {model_choice}")
+                logger.info(f"[UPLOAD] Processing with model: {model_choice}")
                 
                 if model_choice == 'movenet':
                     movenet_variant = request.form.get('movenet_variant', 'lightning')
-                    print(f"[UPLOAD] Using MoveNet variant: {movenet_variant}")
+                    logger.info(f"[UPLOAD] Using MoveNet variant: {movenet_variant}")
                     output_path_url = process_video_movenet(filepath)
                 else:
                     output_path_url = process_video_mediapipe(filepath)
                     
-                print(f"[UPLOAD] Processing complete. Output URL: {output_path_url}")
+                logger.info(f"[UPLOAD] Processing complete. Output URL: {output_path_url}")
                 
                 if not os.path.exists(os.path.join(app.config['UPLOAD_FOLDER'], os.path.basename(output_path_url))):
-                    print(f"[UPLOAD] Output file not found: {output_path_url}")
+                    logger.error(f"[UPLOAD] Output file not found: {output_path_url}")
                     return jsonify({'error': 'Output video file not found'}), 500
                     
                 return jsonify({
@@ -532,22 +445,37 @@ def upload_file():
                 })
                 
             except Exception as e:
-                print(f"[UPLOAD] Error processing video: {str(e)}")
+                logger.error(f"[UPLOAD] Error processing video: {str(e)}")
                 traceback.print_exc()
                 return jsonify({'error': f'Error processing video: {str(e)}'}), 500
                 
             finally:
                 try:
-                if os.path.exists(filepath):
-                    os.remove(filepath)
-                        print(f"[UPLOAD] Cleaned up input file: {filepath}")
+                    if os.path.exists(filepath):
+                        os.remove(filepath)
+                        logger.info(f"[UPLOAD] Cleaned up input file: {filepath}")
                 except Exception as e:
-                    print(f"[UPLOAD] Error cleaning up file: {str(e)}")
+                    logger.error(f"[UPLOAD] Error cleaning up file: {str(e)}")
                     
     except Exception as e:
-        print(f"[UPLOAD] Unexpected error: {str(e)}")
+        logger.error(f"[UPLOAD] Unexpected error: {str(e)}")
         traceback.print_exc()
         return jsonify({'error': 'Internal server error'}), 500
+    finally:
+        cleanup_memory()  # Clean up after processing
+
+# Add error handlers
+@app.errorhandler(413)
+def request_entity_too_large(error):
+    return jsonify({'error': 'File too large. Maximum size is 100MB'}), 413
+
+@app.errorhandler(500)
+def internal_server_error(error):
+    return jsonify({'error': 'Internal server error. Please try again later.'}), 500
+
+@app.errorhandler(404)
+def not_found_error(error):
+    return jsonify({'error': 'Resource not found'}), 404
 
 if __name__ == '__main__':
     # Ensure the port is 7860 and debug is False for HF Spaces deployment

requirements.txt

@@ -78,3 +78,4 @@ tzdata==2025.2
 urllib3==2.4.0
 Werkzeug==3.1.3
 wrapt==1.17.2
+psutil==5.9.8