Upload folder using huggingface_hub

.env.example

@@ -0,0 +1,11 @@
+# ============================================================
+# Gait Analysis API — Environment Variables
+# ============================================================
+# Copy this file to .env and fill in your values.
+# .env is gitignored and must NEVER be committed.
+
+# Optional: HuggingFace token (for private model downloads via huggingface_hub)
+# HF_TOKEN=hf_xxxxxxxxxxxxxxxxxxxx
+
+# Optional: Override the YOLO model filename used at startup
+# MODEL_NAME=yolo11n-pose.pt

Dockerfile

@@ -0,0 +1,39 @@
+# Dockerfile for Gait Analysis Microservice
+FROM python:3.10-slim
+
+# Install system dependencies required by OpenCV and YOLO
+RUN apt-get update && apt-get install -y \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgl1-mesa-glx \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file into the container
+COPY requirements.txt .
+
+# Install ALL Python dependencies in a single layer for efficiency
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the backend files into the container
+COPY . /app
+
+# ---- Download YOLO model at BUILD time ----
+# This avoids a cold-start penalty on every container restart.
+# The model (~6 MB) is baked into the image layer.
+RUN python download_model.py
+
+# HuggingFace Spaces requires the app to run as a non-root user
+RUN useradd -m -u 1000 appuser && chown -R appuser /app
+USER appuser
+
+# Expose the port that HuggingFace Spaces routes to
+EXPOSE 7860
+
+# Command to run the application using Uvicorn
+CMD ["uvicorn", "api:app", "--host", "0.0.0.0", "--port", "7860"]

api.py

@@ -0,0 +1,177 @@
+import os
+import shutil
+import tempfile
+from typing import List, Dict, Any, Optional
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+
+# Import your existing analyzer logic
+from gait_analysis import EnhancedGaitAnalyzer
+
+app = FastAPI(
+    title="Gait Analysis Inference Microservice",
+    description="Microservice to process video with YOLO11 and return gait metrics. Upload a video to extract clinical gait analysis features including stability, symmetry, and developmental observations.",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# Standard CORS configuration
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], 
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# --- Pydantic Models for Swagger Documentation ---
+
+class HealthResponse(BaseModel):
+    status: str = Field(..., example="ok")
+    message: str = Field(..., example="Gait Analysis Inference Service is running.")
+
+class GaitSummary(BaseModel):
+    stability_score: float = Field(..., description="Calculated stability score (out of 100). Higher is better.")
+    symmetry_score: float = Field(..., description="Calculated symmetry score (out of 100). Higher is better.")
+    weight_shift_score: float = Field(..., description="Calculated weight shift score (out of 100). Higher is better.")
+    strength_score: float = Field(..., description="Calculated strength score (out of 100). Higher is better.")
+    phase_asymmetry_percent: float = Field(..., description="Percentage of asymmetry between left and right stance times")
+    overall_gait_quality: str = Field(..., description="Overall assessment of gait quality (e.g. acceptable, concerning)")
+    walking_condition: str = Field(..., description="E.g., Independent or Assisted")
+
+class GaitObservations(BaseModel):
+    trunk: str = Field(..., description="Observation of trunk movement (e.g. 'Neutral', 'Rotated')")
+    head_neck: str = Field(..., description="Observation of head and neck (e.g. 'Neutral & mobile')")
+    arms_hands: str = Field(..., description="Observation of arms and hands (e.g. 'Free arm swing')")
+    lower_limbs: str = Field(..., description="Observation of lower limbs")
+    symmetry: str = Field(..., description="General symmetry observation")
+    weight_distribution: str = Field(..., description="Observation of weight distribution")
+    postural_control: str = Field(..., description="Observation of postural control")
+
+class WeightDistribution(BaseModel):
+    overall_imbalance_percent: float = Field(..., description="Percentage of imbalance")
+    primary_weight_side: str = Field(..., description="Primary weight side (left/right/balanced)")
+    weight_shift_issues: List[str] = Field(..., description="Identified weight shift issues")
+    hip_drop_analysis: List[Dict[str, str]] = Field(..., description="Hip drop analysis")
+
+class PosturalStrength(BaseModel):
+    trunk_sway_severity: str = Field(..., description="Severity of trunk sway")
+    shoulder_stability: str = Field(..., description="Shoulder stability observation")
+    forward_lean: str = Field(..., description="Forward lean observation")
+    knee_stability: str = Field(..., description="Knee stability observation")
+    overall_strength_assessment: str = Field(..., description="Overall strength assessment")
+
+class GaitPhases(BaseModel):
+    stance_time_l: int = Field(..., description="Number of frames the left foot is in stance phase")
+    stance_time_r: int = Field(..., description="Number of frames the right foot is in stance phase")
+    swing_time_l: int = Field(..., description="Number of frames the left foot is in swing phase")
+    swing_time_r: int = Field(..., description="Number of frames the right foot is in swing phase")
+    double_support_frames: int = Field(..., description="Number of frames where both feet are in stance phase")
+    phase_asymmetry: float = Field(..., description="Phase asymmetry percentage")
+
+class GaitAnalysisData(BaseModel):
+    frames: List[Dict[str, Any]] = Field(..., description="List of processed frame data including keypoints and angles")
+    summary: GaitSummary = Field(..., description="Summary metrics of the gait analysis")
+    weight_distribution: WeightDistribution = Field(..., description="Weight distribution analysis")
+    postural_strength: PosturalStrength = Field(..., description="Postural strength assessment")
+    gait_phases: GaitPhases = Field(..., description="Gait phase breakdown")
+    risk_indicators: List[str] = Field(..., description="List of identified risk factors")
+    flags: Dict[str, Any] = Field(..., description="Specific flags or markers triggered during analysis")
+    observations: GaitObservations = Field(..., description="Clinical observations of body segments")
+    compensatory_strategies: List[str] = Field(..., description="Identified compensatory movement strategies")
+    reflex_influence: str = Field(..., description="Notes on primitive reflex influence")
+    safety_note: str = Field(..., description="Any constraints or limitations of the analysis")
+    clinical_notes: List[str] = Field(..., description="Clinical notes on findings")
+
+class AnalyzeResponse(BaseModel):
+    status: str = Field(..., example="success")
+    data: GaitAnalysisData = Field(..., description="The complete gait analysis results")
+
+# --------------------------------------------------
+
+# We initialize the analyzer globally so the YOLO model is loaded into memory ONCE on startup.
+# This prevents "cold starts" where the heavy model has to reload for every single request.
+analyzer = None
+
+@app.on_event("startup")
+async def startup_event():
+    global analyzer
+    print("Initializing YOLO framework and loading model into memory...")
+    # Initialize with default placeholders; we dynamically update context per request
+    analyzer = EnhancedGaitAnalyzer(model_name="yolo11n-pose.pt")
+    print("Model initialized and ready for inference!")
+
+@app.get(
+    "/", 
+    response_model=HealthResponse,
+    tags=["System"],
+    summary="Health Check",
+    description="Simple health check endpoint to ping from the main backend."
+)
+def health_check():
+    return {"status": "ok", "message": "Gait Analysis Inference Service is running."}
+
+@app.post(
+    "/analyze",
+    response_model=AnalyzeResponse,
+    tags=["Analysis"],
+    summary="Analyze Video",
+    description="Upload a video to perform full gait analysis. This endpoint loads the video, detects poses, and calculates clinical gait metrics."
+)
+async def analyze_video(
+    file: UploadFile = File(..., description="The highly compressed video file (e.g., .mp4, .mov)"),
+    age: Optional[int] = Form(None, description="Age of the patient for developmental benchmarks (determines expected normative values). Defaults to 4 if not provided."),
+    independent_walking: bool = Form(True, description="Whether the patient is walking independently")
+):
+    if not file.filename:
+        raise HTTPException(status_code=400, detail="No file uploaded")
+        
+    if age is not None and age > 11:
+        raise HTTPException(status_code=400, detail="OVER_AGE: Patient age exceeds the supported range (maximum 11 years) for this analysis.")
+        
+    # Default age to 4 if not provided
+    process_age = age if age is not None else 4
+        
+    # Create a temporary directory to store the incoming video
+    temp_dir = tempfile.mkdtemp()
+    temp_video_path = os.path.join(temp_dir, file.filename)
+    
+    try:
+        # 1. Save the incoming stream to a temporary disk file
+        with open(temp_video_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+            
+        print(f"Received video: {file.filename} (Age: {process_age}, Independent: {independent_walking})")
+            
+        # 2. Update the analyzer's dynamic properties for this specific request
+        analyzer.age = process_age
+        analyzer.independent_walking = independent_walking
+        
+        # 3. Process the video
+        results = analyzer.process_video(temp_video_path)
+        
+        # 4. Return the massive JSON payload back to the main backend server
+        # We use JSONResponse directly to avoid Pydantic serialization overhead for 'frames' list,
+        # but the Swagger documentation is still powered by the AnalyzeResponse model.
+        return JSONResponse(content={"status": "success", "data": results})
+        
+    except ValueError as ve:
+        print(f"Validation Error: {ve}")
+        # Return a 400 Bad Request since this is a client/input issue
+        raise HTTPException(status_code=400, detail=str(ve))
+    except Exception as e:
+        print(f"Error running inference: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+        
+    finally:
+        # 5. Cleanup memory/disk: delete the video so the server doesn't run out of storage
+        if os.path.exists(temp_dir):
+            shutil.rmtree(temp_dir, ignore_errors=True)
+
+if __name__ == "__main__":
+    import uvicorn
+    # Use standard uvicorn runner for local testing
+    uvicorn.run("api:app", host="0.0.0.0", port=8000, reload=True)

download_model.py

@@ -0,0 +1,14 @@
+from ultralytics import YOLO
+import os
+
+def download_yolo_model():
+    print("Checking and downloading YOLO11 model...")
+    try:
+        # This will automatically download the model if not present
+        model = YOLO("yolo11n-pose.pt")
+        print("Model yolo11n-pose.pt is ready!")
+    except Exception as e:
+        print(f"Error initializing YOLO model: {e}")
+
+if __name__ == "__main__":
+    download_yolo_model()

gait_analysis.py

@@ -0,0 +1,527 @@
+import cv2
+import numpy as np
+import os
+from ultralytics import YOLO
+from collections import deque
+
+class EnhancedGaitAnalyzer:
+    def __init__(self, model_name="yolo11n-pose.pt", age=4, independent_walking=True):
+        """
+        Enhanced Gait Analyzer with weight shifting, postural strength, AND original gait analysis.
+        """
+        self.model = YOLO(model_name)
+        self.age = age
+        self.independent_walking = independent_walking
+        
+        # COCO 17-Keypoint Mapping
+        self.KEYPOINT_MAP = {
+            0: "Nose", 1: "LEye", 2: "REye", 3: "LEar", 4: "REar",
+            5: "LShoulder", 6: "RShoulder", 7: "LElbow", 8: "RElbow",
+            9: "LWrist", 10: "RWrist", 11: "LHip", 12: "RHip",
+            13: "LKnee", 14: "RKnee", 15: "LAnkle", 16: "RAnkle"
+        }
+        
+        # Thresholds
+        self.WEIGHT_SHIFT_THRESHOLD = 0.15
+        self.HIP_DROP_THRESHOLD = 10
+        self.POSTURE_SWAY_THRESHOLD = 20
+        
+    def process_video(self, video_path):
+        """Process video and extract gait analysis metrics."""
+        if not os.path.exists(video_path):
+            raise FileNotFoundError(f"Video file not found: {video_path}")
+
+        results = self.model(video_path, stream=True, verbose=False)
+        frames_data = []
+        
+        for i, r in enumerate(results):
+            if r.keypoints is None or r.keypoints.data.shape[0] == 0:
+                frames_data.append({"frame": i, "keypoints": []})
+                continue
+
+            kpts = r.keypoints.data[0].cpu().numpy()
+            points = []
+            for kp in kpts:
+                x, y, conf = kp
+                if conf > 0.3:
+                    points.append((float(x), float(y)))
+                else:
+                    points.append(None)
+
+            frames_data.append({"frame": int(i), "keypoints": points})
+
+        return self._make_serializable(self.analyze_gait(frames_data))
+
+    def _make_serializable(self, obj):
+        """Recursively convert numpy data types to native python types for JSON serialization."""
+        if isinstance(obj, dict):
+            return {k: self._make_serializable(v) for k, v in obj.items()}
+        elif isinstance(obj, list):
+            return [self._make_serializable(v) for v in obj]
+        elif isinstance(obj, tuple):
+            return tuple(self._make_serializable(v) for v in obj)
+        elif isinstance(obj, (np.integer, int)):
+            return int(obj)
+        elif isinstance(obj, (np.floating, float)):
+            return float(obj)
+        elif isinstance(obj, np.ndarray):
+            return self._make_serializable(obj.tolist())
+        else:
+            return obj
+
+    def calculate_angle(self, p1, p2, p3):
+        """Calculate angle between three points."""
+        if p1 is None or p2 is None or p3 is None:
+            return None
+            
+        a = np.array(p1)
+        b = np.array(p2)
+        c = np.array(p3)
+        
+        ba = a - b
+        bc = c - b
+        
+        norm_ba = np.linalg.norm(ba)
+        norm_bc = np.linalg.norm(bc)
+        
+        if norm_ba == 0 or norm_bc == 0:
+            return None
+            
+        cosine_angle = np.dot(ba, bc) / (norm_ba * norm_bc)
+        angle = np.arccos(np.clip(cosine_angle, -1.0, 1.0))
+        
+        return np.degrees(angle)
+
+    def calculate_weight_distribution(self, left_ankle, right_ankle, left_hip, right_hip):
+        """Calculate weight distribution based on hip and ankle positions."""
+        if not all([left_ankle, right_ankle, left_hip, right_hip]):
+            return None, None, None
+        
+        left_hip_y = left_hip[1]
+        right_hip_y = right_hip[1]
+
+        # In image coordinates, Y increases downward.
+        # A higher hip (lower Y value) = stance/weight-bearing side.
+        # So if left_hip_y < right_hip_y, the LEFT hip is higher → weight on LEFT.
+        weight_on_left = (left_hip_y - right_hip_y)
+        total_weight = abs(weight_on_left) + 1
+        weight_ratio = (weight_on_left + total_weight) / (2 * total_weight)
+        weight_ratio = np.clip(weight_ratio, 0, 1)
+
+        imbalance_percent = abs(weight_ratio - 0.5) * 200
+
+        if imbalance_percent < 10:
+            primary_side = "balanced"
+        elif weight_ratio > 0.5:
+            primary_side = "left"
+        else:
+            primary_side = "right"
+        
+        return weight_ratio, primary_side, imbalance_percent
+
+    def detect_hip_drop(self, left_hip, right_hip):
+        """Detect Trendelenburg gait (hip drop on swing side)."""
+        if not left_hip or not right_hip:
+            return None, None
+        
+        hip_height_diff = abs(left_hip[1] - right_hip[1])
+        
+        if hip_height_diff > self.HIP_DROP_THRESHOLD:
+            if left_hip[1] > right_hip[1]:
+                return "left_hip_drop", "right_side_weakness"
+            else:
+                return "right_hip_drop", "left_side_weakness"
+        
+        return None, None
+
+    def assess_postural_strength(self, frames_data):
+        """Assess postural strength."""
+        trunk_sway = []
+        shoulder_heights = []
+        head_forward_lean = []
+        knee_stability = []
+        
+        for frame_data in frames_data:
+            kps = frame_data.get("keypoints", [])
+            if not kps or len(kps) < 17:
+                continue
+            
+            if kps[5] and kps[6]:
+                shoulder_center = (kps[5][0] + kps[6][0]) / 2
+                trunk_sway.append(shoulder_center)
+                shoulder_diff = abs(kps[5][1] - kps[6][1])
+                shoulder_heights.append(shoulder_diff)
+            
+            if kps[0] and kps[5] and kps[6]:
+                nose_to_shoulder = kps[0][0] - (kps[5][0] + kps[6][0]) / 2
+                head_forward_lean.append(nose_to_shoulder)
+            
+            if "angles" in frame_data:
+                lk = frame_data["angles"].get("left_knee")
+                rk = frame_data["angles"].get("right_knee")
+                if lk and rk:
+                    if lk < 120 and rk < 120:
+                        knee_stability.append("weak")
+                    elif lk > 160 and rk > 160:
+                        knee_stability.append("stiff")
+                    else:
+                        knee_stability.append("normal")
+        
+        return {
+            "trunk_sway": np.std(trunk_sway) if trunk_sway else 0,
+            "shoulder_hiking": np.mean(shoulder_heights) if shoulder_heights else 0,
+            "forward_lean": np.mean(np.abs(head_forward_lean)) if head_forward_lean else 0,
+            "knee_stability": knee_stability
+        }
+
+    def analyze_gait(self, frames_data):
+        """Complete gait analysis with all features."""
+        
+        # Validation for visibility and person detection
+        total_frames = len(frames_data)
+        
+        # Check minimum video length — need at least ~5 seconds (150 frames at 30fps)
+        # for enough gait cycles to compute meaningful metrics.
+        if total_frames < 150:
+            raise ValueError("VIDEO_TOO_SHORT: Video is too short for meaningful analysis. Please provide a longer video.")
+            
+        valid_frames = 0
+        for frame_data in frames_data:
+            kps = frame_data.get("keypoints", [])
+            # A valid frame has enough confident keypoints (at least 8 keypoints)
+            if kps and len([kp for kp in kps if kp is not None]) >= 8:
+                valid_frames += 1
+                
+        if valid_frames == 0:
+            raise ValueError("NO_PERSON_DETECTED: No person could be detected in the video.")
+            
+        visibility_ratio = valid_frames / total_frames
+        if visibility_ratio < 0.3:
+            raise ValueError("POOR_VISIBILITY: Unable to detect clear movement in most frames. This may be due to bad video quality, loose clothing, bad recording angle, or the subject not being clearly visible.")
+
+        analysis_results = {
+            "frames": [],
+            "summary": {},
+            "weight_distribution": {
+                "overall_imbalance_percent": 0,
+                "primary_weight_side": "unknown",
+                "weight_shift_issues": [],
+                "hip_drop_analysis": []
+            },
+            "postural_strength": {
+                "trunk_sway_severity": "normal",
+                "shoulder_stability": "normal",
+                "forward_lean": "normal",
+                "knee_stability": "normal",
+                "overall_strength_assessment": "adequate"
+            },
+            "gait_phases": {
+                "stance_time_l": 0,
+                "stance_time_r": 0,
+                "swing_time_l": 0,
+                "swing_time_r": 0,
+                "double_support_frames": 0,
+                "phase_asymmetry": 0
+            },
+            "risk_indicators": [],
+            "flags": {},
+            "observations": {
+                "trunk": "Neutral",
+                "head_neck": "Neutral & mobile",
+                "arms_hands": "Free arm swing",
+                "lower_limbs": "Not observed",
+                "symmetry": "Symmetrical",
+                "weight_distribution": "Equal",
+                "postural_control": "Good"
+            },
+            "compensatory_strategies": [],
+            "reflex_influence": "None observed",
+            "safety_note": "",
+            "clinical_notes": []
+        }
+        
+        left_knee_angles = []
+        right_knee_angles = []
+        left_hip_angles = []
+        right_hip_angles = []
+        left_ankle_heights = []
+        right_ankle_heights = []
+        weight_distributions = []
+        hip_drops = []
+        trunk_rotations = []
+        arm_heights = []
+        nose_positions = []
+        
+        # First Pass: Calculate angles, weights, and collect gait phase data
+        for frame_data in frames_data:
+            kps = frame_data["keypoints"]
+            if not kps or len(kps) < 17:
+                analysis_results["frames"].append(frame_data)
+                continue
+
+            # Angles
+            l_knee = self.calculate_angle(kps[11], kps[13], kps[15])
+            r_knee = self.calculate_angle(kps[12], kps[14], kps[16])
+            l_hip = self.calculate_angle(kps[5], kps[11], kps[13])
+            r_hip = self.calculate_angle(kps[6], kps[12], kps[14])
+            
+            frame_data["angles"] = {
+                "left_knee": l_knee,
+                "right_knee": r_knee,
+                "left_hip": l_hip,
+                "right_hip": r_hip
+            }
+            
+            if l_knee: left_knee_angles.append(l_knee)
+            if r_knee: right_knee_angles.append(r_knee)
+            if l_hip: left_hip_angles.append(l_hip)
+            if r_hip: right_hip_angles.append(r_hip)
+            
+            # Weight Distribution Analysis
+            weight_ratio, primary_side, imbalance = self.calculate_weight_distribution(
+                kps[15], kps[16], kps[11], kps[12]
+            )
+            
+            if weight_ratio is not None:
+                weight_distributions.append({
+                    "ratio": weight_ratio,
+                    "primary_side": primary_side,
+                    "imbalance_percent": imbalance
+                })
+                frame_data["weight_distribution"] = {
+                    "ratio": weight_ratio,
+                    "primary_side": primary_side,
+                    "imbalance_percent": imbalance
+                }
+            
+            # Hip Drop Detection
+            hip_drop, weakness = self.detect_hip_drop(kps[11], kps[12])
+            if hip_drop:
+                hip_drops.append({"type": hip_drop, "weakness": weakness})
+            
+            # Trunk rotation
+            if kps[5] and kps[6]:
+                trunk_rotations.append(abs(kps[5][0] - kps[6][0]))
+            
+            # Arm height for guarding
+            if kps[5] and kps[9]:
+                arm_heights.append(kps[5][1] - kps[9][1])
+            
+            # Ankle heights for gait phase detection
+            if kps[15]:
+                left_ankle_heights.append(kps[15][1])
+            else:
+                left_ankle_heights.append(None)
+                
+            if kps[16]:
+                right_ankle_heights.append(kps[16][1])
+            else:
+                right_ankle_heights.append(None)
+            
+            # Nose position for head stability
+            if kps[0]:
+                nose_positions.append(kps[0][1])
+            
+            analysis_results["frames"].append(frame_data)
+        
+        # Gait Phase Detection
+        def detect_phases(heights):
+            phases = []
+            if not heights: return phases
+            valid_heights = [h for h in heights if h is not None]
+            if not valid_heights: return [None] * len(heights)
+            ground_threshold = np.percentile(valid_heights, 80)
+            for h in heights:
+                if h is None: phases.append(None)
+                elif h >= ground_threshold: phases.append("stance")
+                else: phases.append("swing")
+            return phases
+
+        l_phases = detect_phases(left_ankle_heights)
+        r_phases = detect_phases(right_ankle_heights)
+        
+        stance_time_l = l_phases.count("stance")
+        swing_time_l = l_phases.count("swing")
+        stance_time_r = r_phases.count("stance")
+        swing_time_r = r_phases.count("swing")
+        
+        double_support_frames = 0
+        for lp, rp in zip(l_phases, r_phases):
+            if lp == "stance" and rp == "stance":
+                double_support_frames += 1
+        
+        phase_asymmetry = 0
+        if max(stance_time_l, stance_time_r) > 0:
+            phase_asymmetry = (abs(stance_time_l - stance_time_r) / max(stance_time_l, stance_time_r)) * 100
+        
+        analysis_results["gait_phases"] = {
+            "stance_time_l": stance_time_l,
+            "stance_time_r": stance_time_r,
+            "swing_time_l": swing_time_l,
+            "swing_time_r": swing_time_r,
+            "double_support_frames": double_support_frames,
+            "phase_asymmetry": phase_asymmetry
+        }
+        
+        # Postural Strength Assessment
+        strength_assessment = self.assess_postural_strength(frames_data)
+        
+        # Analyze Weight Distribution
+        overall_imbalance = 0
+        primary_side = "balanced"
+        
+        if weight_distributions:
+            imbalances = [w["imbalance_percent"] for w in weight_distributions]
+            overall_imbalance = np.mean(imbalances)
+            primary_sides = [w["primary_side"] for w in weight_distributions]
+            primary_side = max(set([s for s in primary_sides if s != "balanced"]), 
+                             key=primary_sides.count, default="balanced")
+            
+            analysis_results["weight_distribution"]["overall_imbalance_percent"] = overall_imbalance
+            analysis_results["weight_distribution"]["primary_weight_side"] = primary_side
+            
+            if overall_imbalance > self.WEIGHT_SHIFT_THRESHOLD * 100:
+                analysis_results["weight_distribution"]["weight_shift_issues"].append(
+                    f"Significant weight shift ({overall_imbalance:.1f}% imbalance) - "
+                    f"predominantly loading {primary_side} side"
+                )
+                analysis_results["observations"]["weight_distribution"] = f"Asymmetrical - favoring {primary_side}"
+                analysis_results["clinical_notes"].append(
+                    f"WEIGHT DISTRIBUTION: Child shows {overall_imbalance:.1f}% weight shift toward {primary_side} side. "
+                    f"Suggests pain avoidance, weakness, or motor planning issue on opposite side."
+                )
+            
+            if hip_drops:
+                for drop in hip_drops:
+                    analysis_results["weight_distribution"]["hip_drop_analysis"].append(drop)
+                    analysis_results["clinical_notes"].append(
+                        f"HIP DROP: {drop['type']} indicates {drop['weakness']} - "
+                        f"weakness in hip abductors or gluteus medius"
+                    )
+        
+        # Postural Strength Scoring
+        trunk_sway = strength_assessment["trunk_sway"]
+        if trunk_sway > self.POSTURE_SWAY_THRESHOLD:
+            analysis_results["postural_strength"]["trunk_sway_severity"] = "excessive"
+            analysis_results["observations"]["postural_control"] = "Weak - excessive sway"
+            analysis_results["clinical_notes"].append(
+                f"TRUNK SWAY: Significant lateral sway (std: {trunk_sway:.1f}px). "
+                f"Suggests weak core stability."
+            )
+        
+        shoulder_hike = strength_assessment["shoulder_hiking"]
+        if shoulder_hike > 5:
+            analysis_results["postural_strength"]["shoulder_stability"] = "hiking"
+            analysis_results["compensatory_strategies"].append("Shoulder hiking for stability")
+            analysis_results["clinical_notes"].append(
+                f"SHOULDER HIKING: Upper trapezius compensation for core/trunk weakness."
+            )
+        
+        forward_lean = strength_assessment["forward_lean"]
+        if forward_lean > 15:
+            analysis_results["postural_strength"]["forward_lean"] = "excessive"
+            analysis_results["clinical_notes"].append(
+                f"FORWARD HEAD POSTURE: Head forward {forward_lean:.1f}px. "
+                f"Weak neck/shoulder stabilizers or balance compensation."
+            )
+        
+        knee_issues = strength_assessment["knee_stability"]
+        if knee_issues.count("weak") > len(knee_issues) * 0.5:
+            analysis_results["postural_strength"]["knee_stability"] = "weak"
+            analysis_results["clinical_notes"].append(
+                f"KNEE WEAKNESS: Insufficient extension/flexion control. "
+                f"Quad weakness or motor planning issues."
+            )
+        
+        weakness_indicators = sum([
+            trunk_sway > self.POSTURE_SWAY_THRESHOLD,
+            shoulder_hike > 5,
+            forward_lean > 15,
+            knee_issues.count("weak") > len(knee_issues) * 0.5
+        ])
+        
+        if weakness_indicators >= 2:
+            analysis_results["postural_strength"]["overall_strength_assessment"] = "inadequate"
+            analysis_results["observations"]["postural_control"] = "Floppy/weak - multiple issues"
+            analysis_results["clinical_notes"].append(
+                f"POSTURAL ASSESSMENT: Low muscle tone/weakness ({weakness_indicators} issues detected). "
+                f"Recommend strength assessment."
+            )
+        
+        # Original Observations Logic
+        # Trunk
+        if trunk_rotations:
+            sway = np.std(trunk_rotations)
+            if sway > 15: 
+                analysis_results["observations"]["trunk"] = "Stiff / reduced rotation"
+                analysis_results["compensatory_strategies"].append("Trunk used for balance")
+            elif sway > 10: 
+                analysis_results["observations"]["trunk"] = "Rotated"
+                analysis_results["compensatory_strategies"].append("Trunk rotation")
+
+        # Head & Neck (vertical stability)
+        if nose_positions:
+            neck_stiffness = np.std(nose_positions)
+            if neck_stiffness < 2: 
+                analysis_results["observations"]["head_neck"] = "Fixed / stiff"
+                analysis_results["compensatory_strategies"].append("Neck stiffness for stability")
+
+        # Arms
+        if arm_heights:
+            avg_arm_h = np.mean(arm_heights)
+            if avg_arm_h < -10:
+                analysis_results["observations"]["arms_hands"] = "Hands guarded"
+                analysis_results["compensatory_strategies"].append("Hands used for security")
+
+        # Reflex Influence Detection
+        signs = []
+        if analysis_results["observations"]["trunk"] == "Rotated": 
+            signs.append("ATNR influence")
+        if "Hands guarded" in analysis_results["observations"]["arms_hands"]: 
+            signs.append("Palmar influence")
+        if "Neck stiffness" in str(analysis_results["compensatory_strategies"]): 
+            signs.append("Fear Paralysis influence")
+        
+        if len(signs) >= 2:
+            analysis_results["reflex_influence"] = "Movement patterns suggest immature postural and protective responses consistent with incomplete primitive reflex integration."
+            analysis_results["observations"]["symmetry"] = "Mild asymmetry"
+        else:
+            analysis_results["reflex_influence"] = ""
+
+        # Numerical Safety Checks
+        num_steps = stance_time_l // 10
+        is_safe = self.independent_walking and num_steps >= 5 and len(frames_data) > 90
+        
+        if not is_safe:
+            analysis_results["safety_note"] = "Numerical interpretation limited due to context."
+        
+        # Stability: measures trunk steadiness only. Weight imbalance has its own score.
+        # Cap the trunk sway penalty at 50 points so the score stays meaningful.
+        trunk_sway_penalty = min(50, np.std(trunk_rotations) * 2 if trunk_rotations else 0)
+        stability_score = max(0, 100 - trunk_sway_penalty)
+
+        # Symmetry: based on gait phase asymmetry. Each 1% asymmetry = 1 point deducted.
+        sym_score = max(0, 100 - phase_asymmetry)
+
+        # Strength: each weakness indicator costs 25 points
+        strength_score = max(0, 100 - (weakness_indicators * 25))
+
+        # Weight shift: overall_imbalance is already 0-100% so maps directly
+        weight_shift_score = max(0, 100 - overall_imbalance) if weight_distributions else 100
+        
+        analysis_results["summary"] = {
+            "stability_score": stability_score,
+            "symmetry_score": sym_score,
+            "weight_shift_score": weight_shift_score,
+            "strength_score": strength_score,
+            "phase_asymmetry_percent": phase_asymmetry,
+            "overall_gait_quality": "concerning" if weakness_indicators >= 2 else "acceptable",
+            "walking_condition": "Independent" if self.independent_walking else "Assisted"
+        }
+        
+        return analysis_results
+
+
+if __name__ == "__main__":
+    analyzer = EnhancedGaitAnalyzer(age=10)
+    print("Enhanced Gait Analyzer initialized with all features.")

generate_report.py

@@ -0,0 +1,123 @@
+from gait_analysis import EnhancedGaitAnalyzer
+import os
+from datetime import datetime
+
+def generate_markdown_report(results, video_path, output_path):
+    """
+    Generate a strictly structured gait analysis report.
+    """
+    summary = results.get("summary", {})
+    observations = results.get("observations", {})
+    strategies = results.get("compensatory_strategies", [])
+    reflex_influence = results.get("reflex_influence", "None observed")
+    safety_note = results.get("safety_note", "")
+    weight_dist = results.get("weight_distribution", {})
+    postural_strength = results.get("postural_strength", {})
+    clinical_notes = results.get("clinical_notes", [])
+    
+    # 1. Walking Condition
+    walking_condition = summary.get("walking_condition", "Not specified")
+    
+    # 2. Observed Movement Patterns
+    patterns = f"""### Observed Movement Patterns
+
+- **Trunk:** {observations.get('trunk', 'N/A')}
+- **Head & Neck:** {observations.get('head_neck', 'N/A')}
+- **Arms & Hands:** {observations.get('arms_hands', 'N/A')}
+- **Lower Limbs:** {observations.get('lower_limbs', 'N/A')}
+- **Symmetry:** {observations.get('symmetry', 'N/A')}
+- **Weight Distribution:** {observations.get('weight_distribution', 'N/A')}
+- **Postural Control:** {observations.get('postural_control', 'N/A')}"""
+
+    # 3. Compensatory Strategies
+    comp_strategies = "None identified"
+    if strategies:
+        comp_strategies = "\n".join([f"- {s}" for s in strategies])
+        
+    # 4. Clinical Notes
+    clinical_notes_text = "None noted"
+    if clinical_notes:
+        clinical_notes_text = "\n".join([f"- {n}" for n in clinical_notes])
+    
+    # 5. Integrated Movement Summary
+    # Combine stats into a summary
+    asymmetry = summary.get("phase_asymmetry_percent", 0)
+    stability = summary.get("stability_score", 0)
+    strength = summary.get("strength_score", 0)
+    weight_shift = summary.get("weight_shift_score", 0)
+    gait_quality = summary.get("overall_gait_quality", "unknown")
+    
+    integrated_summary = f"""### Integrated Movement Summary
+
+The subject demonstrates a **{walking_condition.lower()}** walking pattern with a stability score of **{stability:.0f}/100**, strength score of **{strength:.0f}/100**, and weight shift score of **{weight_shift:.0f}/100**.
+Overall gait quality appears **{gait_quality}**.
+Movement symmetry shows a **{asymmetry:.1f}%** phase variance.
+
+{reflex_influence}
+
+{safety_note}"""
+
+    # Final Report Assembly
+    report = f"""# Gait Analysis Report
+
+## Walking Condition
+**{walking_condition}**
+
+{patterns}
+
+### Compensatory Strategies
+{comp_strategies}
+
+### Clinical Notes
+{clinical_notes_text}
+
+{integrated_summary}
+
+---
+*Generated by Gait Analysis System v3.0*
+"""
+
+    # Write to file
+    with open(output_path, 'w', encoding='utf-8') as f:
+        f.write(report)
+    
+    print(f"✅ Strict Report generated successfully: {output_path}")
+    return output_path
+
+
+def main():
+    # Path to test.mp4
+    video_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "test.mp4"))
+    
+    print(f"Looking for video at: {video_path}")
+    if not os.path.exists(video_path):
+        print("Error: test.mp4 not found!")
+        return
+
+    print("Initializing EnhancedGaitAnalyzer...")
+    analyzer = EnhancedGaitAnalyzer(age=4)
+    
+    print("Processing video... this might take a moment.")
+    try:
+        results = analyzer.process_video(video_path)
+        
+        # Generate report filename with timestamp
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        report_filename = f"gait_analysis_report_{timestamp}.md"
+        report_path = os.path.join(os.path.dirname(video_path), report_filename)
+        
+        # Generate markdown report
+        generate_markdown_report(results, video_path, report_path)
+        
+        print(f"\n{'='*60}")
+        print(f"Report saved to: {report_path}")
+        print(f"{'='*60}\n")
+        
+    except Exception as e:
+        print(f"An error occurred during processing: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    main()

main.py

@@ -0,0 +1,54 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+import shutil
+import os
+import uuid
+from gait_analysis import EnhancedGaitAnalyzer
+import uvicorn
+
+app = FastAPI()
+
+# Allow CORS for frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize Analyzer
+analyzer = EnhancedGaitAnalyzer()
+
+UPLOAD_DIR = "uploads"
+if not os.path.exists(UPLOAD_DIR):
+    os.makedirs(UPLOAD_DIR)
+
+@app.get("/")
+def read_root():
+    return {"message": "Gait Analysis API with OpenPose is running"}
+
+@app.post("/analyze")
+async def analyze_video(file: UploadFile = File(...)):
+    try:
+        # Save uploaded file
+        file_ext = file.filename.split(".")[-1]
+        filename = f"{uuid.uuid4()}.{file_ext}"
+        file_path = os.path.join(UPLOAD_DIR, filename)
+        
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+            
+        # Process video
+        results = analyzer.process_video(file_path)
+        
+        # Cleanup
+        # os.remove(file_path) # Keep for debugging for now or serve back
+        
+        return {"filename": filename, "results": results}
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

models/pose_deploy.prototxt

@@ -0,0 +1,2332 @@
+name: "OpenPose - BODY_25"
+input: "image"
+input_dim: 1 # This value will be defined at runtime
+input_dim: 3
+input_dim: 16 # This value will be defined at runtime
+input_dim: 16 # This value will be defined at runtime
+layer {
+  name: "conv1_1"
+  type: "Convolution"
+  bottom: "image"
+  top: "conv1_1"
+  convolution_param {
+    num_output: 64
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "relu1_1"
+  type: "ReLU"
+  bottom: "conv1_1"
+  top: "conv1_1"
+}
+layer {
+  name: "conv1_2"
+  type: "Convolution"
+  bottom: "conv1_1"
+  top: "conv1_2"
+  convolution_param {
+    num_output: 64
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "relu1_2"
+  type: "ReLU"
+  bottom: "conv1_2"
+  top: "conv1_2"
+}
+layer {
+  name: "pool1_stage1"
+  type: "Pooling"
+  bottom: "conv1_2"
+  top: "pool1_stage1"
+  pooling_param {
+    pool: MAX
+    kernel_size: 2
+    stride: 2
+  }
+}
+layer {
+  name: "conv2_1"
+  type: "Convolution"
+  bottom: "pool1_stage1"
+  top: "conv2_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "relu2_1"
+  type: "ReLU"
+  bottom: "conv2_1"
+  top: "conv2_1"
+}
+layer {
+  name: "conv2_2"
+  type: "Convolution"
+  bottom: "conv2_1"
+  top: "conv2_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "relu2_2"
+  type: "ReLU"
+  bottom: "conv2_2"
+  top: "conv2_2"
+}
+layer {
+  name: "pool2_stage1"
+  type: "Pooling"
+  bottom: "conv2_2"
+  top: "pool2_stage1"
+  pooling_param {
+    pool: MAX
+    kernel_size: 2
+    stride: 2
+  }
+}
+layer {
+  name: "conv3_1"
+  type: "Convolution"
+  bottom: "pool2_stage1"
+  top: "conv3_1"
+  convolution_param {
+    num_output: 256
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "relu3_1"
+  type: "ReLU"
+  bottom: "conv3_1"
+  top: "conv3_1"
+}
+layer {
+  name: "conv3_2"
+  type: "Convolution"
+  bottom: "conv3_1"
+  top: "conv3_2"
+  convolution_param {
+    num_output: 256
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "relu3_2"
+  type: "ReLU"
+  bottom: "conv3_2"
+  top: "conv3_2"
+}
+layer {
+  name: "conv3_3"
+  type: "Convolution"
+  bottom: "conv3_2"
+  top: "conv3_3"
+  convolution_param {
+    num_output: 256
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "relu3_3"
+  type: "ReLU"
+  bottom: "conv3_3"
+  top: "conv3_3"
+}
+layer {
+  name: "conv3_4"
+  type: "Convolution"
+  bottom: "conv3_3"
+  top: "conv3_4"
+  convolution_param {
+    num_output: 256
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "relu3_4"
+  type: "ReLU"
+  bottom: "conv3_4"
+  top: "conv3_4"
+}
+layer {
+  name: "pool3_stage1"
+  type: "Pooling"
+  bottom: "conv3_4"
+  top: "pool3_stage1"
+  pooling_param {
+    pool: MAX
+    kernel_size: 2
+    stride: 2
+  }
+}
+layer {
+  name: "conv4_1"
+  type: "Convolution"
+  bottom: "pool3_stage1"
+  top: "conv4_1"
+  convolution_param {
+    num_output: 512
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "relu4_1"
+  type: "ReLU"
+  bottom: "conv4_1"
+  top: "conv4_1"
+}
+layer {
+  name: "conv4_2"
+  type: "Convolution"
+  bottom: "conv4_1"
+  top: "conv4_2"
+  convolution_param {
+    num_output: 512
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "prelu4_2"
+  type: "PReLU"
+  bottom: "conv4_2"
+  top: "conv4_2"
+}
+layer {
+  name: "conv4_3_CPM"
+  type: "Convolution"
+  bottom: "conv4_2"
+  top: "conv4_3_CPM"
+  convolution_param {
+    num_output: 256
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "prelu4_3_CPM"
+  type: "PReLU"
+  bottom: "conv4_3_CPM"
+  top: "conv4_3_CPM"
+}
+layer {
+  name: "conv4_4_CPM"
+  type: "Convolution"
+  bottom: "conv4_3_CPM"
+  top: "conv4_4_CPM"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "prelu4_4_CPM"
+  type: "PReLU"
+  bottom: "conv4_4_CPM"
+  top: "conv4_4_CPM"
+}
+layer {
+  name: "Mconv1_stage0_L2_0"
+  type: "Convolution"
+  bottom: "conv4_4_CPM"
+  top: "Mconv1_stage0_L2_0"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu1_stage0_L2_0"
+  type: "PReLU"
+  bottom: "Mconv1_stage0_L2_0"
+  top: "Mconv1_stage0_L2_0"
+}
+layer {
+  name: "Mconv1_stage0_L2_1"
+  type: "Convolution"
+  bottom: "Mconv1_stage0_L2_0"
+  top: "Mconv1_stage0_L2_1"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu1_stage0_L2_1"
+  type: "PReLU"
+  bottom: "Mconv1_stage0_L2_1"
+  top: "Mconv1_stage0_L2_1"
+}
+layer {
+  name: "Mconv1_stage0_L2_2"
+  type: "Convolution"
+  bottom: "Mconv1_stage0_L2_1"
+  top: "Mconv1_stage0_L2_2"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu1_stage0_L2_2"
+  type: "PReLU"
+  bottom: "Mconv1_stage0_L2_2"
+  top: "Mconv1_stage0_L2_2"
+}
+layer {
+  name: "Mconv1_stage0_L2_concat"
+  type: "Concat"
+  bottom: "Mconv1_stage0_L2_0"
+  bottom: "Mconv1_stage0_L2_1"
+  bottom: "Mconv1_stage0_L2_2"
+  top: "Mconv1_stage0_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv2_stage0_L2_0"
+  type: "Convolution"
+  bottom: "Mconv1_stage0_L2_concat"
+  top: "Mconv2_stage0_L2_0"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu2_stage0_L2_0"
+  type: "PReLU"
+  bottom: "Mconv2_stage0_L2_0"
+  top: "Mconv2_stage0_L2_0"
+}
+layer {
+  name: "Mconv2_stage0_L2_1"
+  type: "Convolution"
+  bottom: "Mconv2_stage0_L2_0"
+  top: "Mconv2_stage0_L2_1"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu2_stage0_L2_1"
+  type: "PReLU"
+  bottom: "Mconv2_stage0_L2_1"
+  top: "Mconv2_stage0_L2_1"
+}
+layer {
+  name: "Mconv2_stage0_L2_2"
+  type: "Convolution"
+  bottom: "Mconv2_stage0_L2_1"
+  top: "Mconv2_stage0_L2_2"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu2_stage0_L2_2"
+  type: "PReLU"
+  bottom: "Mconv2_stage0_L2_2"
+  top: "Mconv2_stage0_L2_2"
+}
+layer {
+  name: "Mconv2_stage0_L2_concat"
+  type: "Concat"
+  bottom: "Mconv2_stage0_L2_0"
+  bottom: "Mconv2_stage0_L2_1"
+  bottom: "Mconv2_stage0_L2_2"
+  top: "Mconv2_stage0_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv3_stage0_L2_0"
+  type: "Convolution"
+  bottom: "Mconv2_stage0_L2_concat"
+  top: "Mconv3_stage0_L2_0"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu3_stage0_L2_0"
+  type: "PReLU"
+  bottom: "Mconv3_stage0_L2_0"
+  top: "Mconv3_stage0_L2_0"
+}
+layer {
+  name: "Mconv3_stage0_L2_1"
+  type: "Convolution"
+  bottom: "Mconv3_stage0_L2_0"
+  top: "Mconv3_stage0_L2_1"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu3_stage0_L2_1"
+  type: "PReLU"
+  bottom: "Mconv3_stage0_L2_1"
+  top: "Mconv3_stage0_L2_1"
+}
+layer {
+  name: "Mconv3_stage0_L2_2"
+  type: "Convolution"
+  bottom: "Mconv3_stage0_L2_1"
+  top: "Mconv3_stage0_L2_2"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu3_stage0_L2_2"
+  type: "PReLU"
+  bottom: "Mconv3_stage0_L2_2"
+  top: "Mconv3_stage0_L2_2"
+}
+layer {
+  name: "Mconv3_stage0_L2_concat"
+  type: "Concat"
+  bottom: "Mconv3_stage0_L2_0"
+  bottom: "Mconv3_stage0_L2_1"
+  bottom: "Mconv3_stage0_L2_2"
+  top: "Mconv3_stage0_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv4_stage0_L2_0"
+  type: "Convolution"
+  bottom: "Mconv3_stage0_L2_concat"
+  top: "Mconv4_stage0_L2_0"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu4_stage0_L2_0"
+  type: "PReLU"
+  bottom: "Mconv4_stage0_L2_0"
+  top: "Mconv4_stage0_L2_0"
+}
+layer {
+  name: "Mconv4_stage0_L2_1"
+  type: "Convolution"
+  bottom: "Mconv4_stage0_L2_0"
+  top: "Mconv4_stage0_L2_1"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu4_stage0_L2_1"
+  type: "PReLU"
+  bottom: "Mconv4_stage0_L2_1"
+  top: "Mconv4_stage0_L2_1"
+}
+layer {
+  name: "Mconv4_stage0_L2_2"
+  type: "Convolution"
+  bottom: "Mconv4_stage0_L2_1"
+  top: "Mconv4_stage0_L2_2"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu4_stage0_L2_2"
+  type: "PReLU"
+  bottom: "Mconv4_stage0_L2_2"
+  top: "Mconv4_stage0_L2_2"
+}
+layer {
+  name: "Mconv4_stage0_L2_concat"
+  type: "Concat"
+  bottom: "Mconv4_stage0_L2_0"
+  bottom: "Mconv4_stage0_L2_1"
+  bottom: "Mconv4_stage0_L2_2"
+  top: "Mconv4_stage0_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv5_stage0_L2_0"
+  type: "Convolution"
+  bottom: "Mconv4_stage0_L2_concat"
+  top: "Mconv5_stage0_L2_0"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu5_stage0_L2_0"
+  type: "PReLU"
+  bottom: "Mconv5_stage0_L2_0"
+  top: "Mconv5_stage0_L2_0"
+}
+layer {
+  name: "Mconv5_stage0_L2_1"
+  type: "Convolution"
+  bottom: "Mconv5_stage0_L2_0"
+  top: "Mconv5_stage0_L2_1"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu5_stage0_L2_1"
+  type: "PReLU"
+  bottom: "Mconv5_stage0_L2_1"
+  top: "Mconv5_stage0_L2_1"
+}
+layer {
+  name: "Mconv5_stage0_L2_2"
+  type: "Convolution"
+  bottom: "Mconv5_stage0_L2_1"
+  top: "Mconv5_stage0_L2_2"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu5_stage0_L2_2"
+  type: "PReLU"
+  bottom: "Mconv5_stage0_L2_2"
+  top: "Mconv5_stage0_L2_2"
+}
+layer {
+  name: "Mconv5_stage0_L2_concat"
+  type: "Concat"
+  bottom: "Mconv5_stage0_L2_0"
+  bottom: "Mconv5_stage0_L2_1"
+  bottom: "Mconv5_stage0_L2_2"
+  top: "Mconv5_stage0_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv6_stage0_L2"
+  type: "Convolution"
+  bottom: "Mconv5_stage0_L2_concat"
+  top: "Mconv6_stage0_L2"
+  convolution_param {
+    num_output: 256
+    pad: 0
+    kernel_size: 1
+  }
+}
+layer {
+  name: "Mprelu6_stage0_L2"
+  type: "PReLU"
+  bottom: "Mconv6_stage0_L2"
+  top: "Mconv6_stage0_L2"
+}
+layer {
+  name: "Mconv7_stage0_L2"
+  type: "Convolution"
+  bottom: "Mconv6_stage0_L2"
+  top: "Mconv7_stage0_L2"
+  convolution_param {
+    num_output: 52
+    pad: 0
+    kernel_size: 1
+  }
+}
+layer {
+  name: "concat_stage1_L2"
+  type: "Concat"
+  bottom: "conv4_4_CPM"
+  bottom: "Mconv7_stage0_L2"
+  top: "concat_stage1_L2"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv1_stage1_L2_0"
+  type: "Convolution"
+  bottom: "concat_stage1_L2"
+  top: "Mconv1_stage1_L2_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu1_stage1_L2_0"
+  type: "PReLU"
+  bottom: "Mconv1_stage1_L2_0"
+  top: "Mconv1_stage1_L2_0"
+}
+layer {
+  name: "Mconv1_stage1_L2_1"
+  type: "Convolution"
+  bottom: "Mconv1_stage1_L2_0"
+  top: "Mconv1_stage1_L2_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu1_stage1_L2_1"
+  type: "PReLU"
+  bottom: "Mconv1_stage1_L2_1"
+  top: "Mconv1_stage1_L2_1"
+}
+layer {
+  name: "Mconv1_stage1_L2_2"
+  type: "Convolution"
+  bottom: "Mconv1_stage1_L2_1"
+  top: "Mconv1_stage1_L2_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu1_stage1_L2_2"
+  type: "PReLU"
+  bottom: "Mconv1_stage1_L2_2"
+  top: "Mconv1_stage1_L2_2"
+}
+layer {
+  name: "Mconv1_stage1_L2_concat"
+  type: "Concat"
+  bottom: "Mconv1_stage1_L2_0"
+  bottom: "Mconv1_stage1_L2_1"
+  bottom: "Mconv1_stage1_L2_2"
+  top: "Mconv1_stage1_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv2_stage1_L2_0"
+  type: "Convolution"
+  bottom: "Mconv1_stage1_L2_concat"
+  top: "Mconv2_stage1_L2_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu2_stage1_L2_0"
+  type: "PReLU"
+  bottom: "Mconv2_stage1_L2_0"
+  top: "Mconv2_stage1_L2_0"
+}
+layer {
+  name: "Mconv2_stage1_L2_1"
+  type: "Convolution"
+  bottom: "Mconv2_stage1_L2_0"
+  top: "Mconv2_stage1_L2_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu2_stage1_L2_1"
+  type: "PReLU"
+  bottom: "Mconv2_stage1_L2_1"
+  top: "Mconv2_stage1_L2_1"
+}
+layer {
+  name: "Mconv2_stage1_L2_2"
+  type: "Convolution"
+  bottom: "Mconv2_stage1_L2_1"
+  top: "Mconv2_stage1_L2_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu2_stage1_L2_2"
+  type: "PReLU"
+  bottom: "Mconv2_stage1_L2_2"
+  top: "Mconv2_stage1_L2_2"
+}
+layer {
+  name: "Mconv2_stage1_L2_concat"
+  type: "Concat"
+  bottom: "Mconv2_stage1_L2_0"
+  bottom: "Mconv2_stage1_L2_1"
+  bottom: "Mconv2_stage1_L2_2"
+  top: "Mconv2_stage1_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv3_stage1_L2_0"
+  type: "Convolution"
+  bottom: "Mconv2_stage1_L2_concat"
+  top: "Mconv3_stage1_L2_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu3_stage1_L2_0"
+  type: "PReLU"
+  bottom: "Mconv3_stage1_L2_0"
+  top: "Mconv3_stage1_L2_0"
+}
+layer {
+  name: "Mconv3_stage1_L2_1"
+  type: "Convolution"
+  bottom: "Mconv3_stage1_L2_0"
+  top: "Mconv3_stage1_L2_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu3_stage1_L2_1"
+  type: "PReLU"
+  bottom: "Mconv3_stage1_L2_1"
+  top: "Mconv3_stage1_L2_1"
+}
+layer {
+  name: "Mconv3_stage1_L2_2"
+  type: "Convolution"
+  bottom: "Mconv3_stage1_L2_1"
+  top: "Mconv3_stage1_L2_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu3_stage1_L2_2"
+  type: "PReLU"
+  bottom: "Mconv3_stage1_L2_2"
+  top: "Mconv3_stage1_L2_2"
+}
+layer {
+  name: "Mconv3_stage1_L2_concat"
+  type: "Concat"
+  bottom: "Mconv3_stage1_L2_0"
+  bottom: "Mconv3_stage1_L2_1"
+  bottom: "Mconv3_stage1_L2_2"
+  top: "Mconv3_stage1_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv4_stage1_L2_0"
+  type: "Convolution"
+  bottom: "Mconv3_stage1_L2_concat"
+  top: "Mconv4_stage1_L2_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu4_stage1_L2_0"
+  type: "PReLU"
+  bottom: "Mconv4_stage1_L2_0"
+  top: "Mconv4_stage1_L2_0"
+}
+layer {
+  name: "Mconv4_stage1_L2_1"
+  type: "Convolution"
+  bottom: "Mconv4_stage1_L2_0"
+  top: "Mconv4_stage1_L2_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu4_stage1_L2_1"
+  type: "PReLU"
+  bottom: "Mconv4_stage1_L2_1"
+  top: "Mconv4_stage1_L2_1"
+}
+layer {
+  name: "Mconv4_stage1_L2_2"
+  type: "Convolution"
+  bottom: "Mconv4_stage1_L2_1"
+  top: "Mconv4_stage1_L2_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu4_stage1_L2_2"
+  type: "PReLU"
+  bottom: "Mconv4_stage1_L2_2"
+  top: "Mconv4_stage1_L2_2"
+}
+layer {
+  name: "Mconv4_stage1_L2_concat"
+  type: "Concat"
+  bottom: "Mconv4_stage1_L2_0"
+  bottom: "Mconv4_stage1_L2_1"
+  bottom: "Mconv4_stage1_L2_2"
+  top: "Mconv4_stage1_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv5_stage1_L2_0"
+  type: "Convolution"
+  bottom: "Mconv4_stage1_L2_concat"
+  top: "Mconv5_stage1_L2_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu5_stage1_L2_0"
+  type: "PReLU"
+  bottom: "Mconv5_stage1_L2_0"
+  top: "Mconv5_stage1_L2_0"
+}
+layer {
+  name: "Mconv5_stage1_L2_1"
+  type: "Convolution"
+  bottom: "Mconv5_stage1_L2_0"
+  top: "Mconv5_stage1_L2_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu5_stage1_L2_1"
+  type: "PReLU"
+  bottom: "Mconv5_stage1_L2_1"
+  top: "Mconv5_stage1_L2_1"
+}
+layer {
+  name: "Mconv5_stage1_L2_2"
+  type: "Convolution"
+  bottom: "Mconv5_stage1_L2_1"
+  top: "Mconv5_stage1_L2_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu5_stage1_L2_2"
+  type: "PReLU"
+  bottom: "Mconv5_stage1_L2_2"
+  top: "Mconv5_stage1_L2_2"
+}
+layer {
+  name: "Mconv5_stage1_L2_concat"
+  type: "Concat"
+  bottom: "Mconv5_stage1_L2_0"
+  bottom: "Mconv5_stage1_L2_1"
+  bottom: "Mconv5_stage1_L2_2"
+  top: "Mconv5_stage1_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv6_stage1_L2"
+  type: "Convolution"
+  bottom: "Mconv5_stage1_L2_concat"
+  top: "Mconv6_stage1_L2"
+  convolution_param {
+    num_output: 512
+    pad: 0
+    kernel_size: 1
+  }
+}
+layer {
+  name: "Mprelu6_stage1_L2"
+  type: "PReLU"
+  bottom: "Mconv6_stage1_L2"
+  top: "Mconv6_stage1_L2"
+}
+layer {
+  name: "Mconv7_stage1_L2"
+  type: "Convolution"
+  bottom: "Mconv6_stage1_L2"
+  top: "Mconv7_stage1_L2"
+  convolution_param {
+    num_output: 52
+    pad: 0
+    kernel_size: 1
+  }
+}
+layer {
+  name: "concat_stage2_L2"
+  type: "Concat"
+  bottom: "conv4_4_CPM"
+  bottom: "Mconv7_stage1_L2"
+  top: "concat_stage2_L2"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv1_stage2_L2_0"
+  type: "Convolution"
+  bottom: "concat_stage2_L2"
+  top: "Mconv1_stage2_L2_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu1_stage2_L2_0"
+  type: "PReLU"
+  bottom: "Mconv1_stage2_L2_0"
+  top: "Mconv1_stage2_L2_0"
+}
+layer {
+  name: "Mconv1_stage2_L2_1"
+  type: "Convolution"
+  bottom: "Mconv1_stage2_L2_0"
+  top: "Mconv1_stage2_L2_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu1_stage2_L2_1"
+  type: "PReLU"
+  bottom: "Mconv1_stage2_L2_1"
+  top: "Mconv1_stage2_L2_1"
+}
+layer {
+  name: "Mconv1_stage2_L2_2"
+  type: "Convolution"
+  bottom: "Mconv1_stage2_L2_1"
+  top: "Mconv1_stage2_L2_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu1_stage2_L2_2"
+  type: "PReLU"
+  bottom: "Mconv1_stage2_L2_2"
+  top: "Mconv1_stage2_L2_2"
+}
+layer {
+  name: "Mconv1_stage2_L2_concat"
+  type: "Concat"
+  bottom: "Mconv1_stage2_L2_0"
+  bottom: "Mconv1_stage2_L2_1"
+  bottom: "Mconv1_stage2_L2_2"
+  top: "Mconv1_stage2_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv2_stage2_L2_0"
+  type: "Convolution"
+  bottom: "Mconv1_stage2_L2_concat"
+  top: "Mconv2_stage2_L2_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu2_stage2_L2_0"
+  type: "PReLU"
+  bottom: "Mconv2_stage2_L2_0"
+  top: "Mconv2_stage2_L2_0"
+}
+layer {
+  name: "Mconv2_stage2_L2_1"
+  type: "Convolution"
+  bottom: "Mconv2_stage2_L2_0"
+  top: "Mconv2_stage2_L2_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu2_stage2_L2_1"
+  type: "PReLU"
+  bottom: "Mconv2_stage2_L2_1"
+  top: "Mconv2_stage2_L2_1"
+}
+layer {
+  name: "Mconv2_stage2_L2_2"
+  type: "Convolution"
+  bottom: "Mconv2_stage2_L2_1"
+  top: "Mconv2_stage2_L2_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu2_stage2_L2_2"
+  type: "PReLU"
+  bottom: "Mconv2_stage2_L2_2"
+  top: "Mconv2_stage2_L2_2"
+}
+layer {
+  name: "Mconv2_stage2_L2_concat"
+  type: "Concat"
+  bottom: "Mconv2_stage2_L2_0"
+  bottom: "Mconv2_stage2_L2_1"
+  bottom: "Mconv2_stage2_L2_2"
+  top: "Mconv2_stage2_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv3_stage2_L2_0"
+  type: "Convolution"
+  bottom: "Mconv2_stage2_L2_concat"
+  top: "Mconv3_stage2_L2_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu3_stage2_L2_0"
+  type: "PReLU"
+  bottom: "Mconv3_stage2_L2_0"
+  top: "Mconv3_stage2_L2_0"
+}
+layer {
+  name: "Mconv3_stage2_L2_1"
+  type: "Convolution"
+  bottom: "Mconv3_stage2_L2_0"
+  top: "Mconv3_stage2_L2_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu3_stage2_L2_1"
+  type: "PReLU"
+  bottom: "Mconv3_stage2_L2_1"
+  top: "Mconv3_stage2_L2_1"
+}
+layer {
+  name: "Mconv3_stage2_L2_2"
+  type: "Convolution"
+  bottom: "Mconv3_stage2_L2_1"
+  top: "Mconv3_stage2_L2_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu3_stage2_L2_2"
+  type: "PReLU"
+  bottom: "Mconv3_stage2_L2_2"
+  top: "Mconv3_stage2_L2_2"
+}
+layer {
+  name: "Mconv3_stage2_L2_concat"
+  type: "Concat"
+  bottom: "Mconv3_stage2_L2_0"
+  bottom: "Mconv3_stage2_L2_1"
+  bottom: "Mconv3_stage2_L2_2"
+  top: "Mconv3_stage2_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv4_stage2_L2_0"
+  type: "Convolution"
+  bottom: "Mconv3_stage2_L2_concat"
+  top: "Mconv4_stage2_L2_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu4_stage2_L2_0"
+  type: "PReLU"
+  bottom: "Mconv4_stage2_L2_0"
+  top: "Mconv4_stage2_L2_0"
+}
+layer {
+  name: "Mconv4_stage2_L2_1"
+  type: "Convolution"
+  bottom: "Mconv4_stage2_L2_0"
+  top: "Mconv4_stage2_L2_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu4_stage2_L2_1"
+  type: "PReLU"
+  bottom: "Mconv4_stage2_L2_1"
+  top: "Mconv4_stage2_L2_1"
+}
+layer {
+  name: "Mconv4_stage2_L2_2"
+  type: "Convolution"
+  bottom: "Mconv4_stage2_L2_1"
+  top: "Mconv4_stage2_L2_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu4_stage2_L2_2"
+  type: "PReLU"
+  bottom: "Mconv4_stage2_L2_2"
+  top: "Mconv4_stage2_L2_2"
+}
+layer {
+  name: "Mconv4_stage2_L2_concat"
+  type: "Concat"
+  bottom: "Mconv4_stage2_L2_0"
+  bottom: "Mconv4_stage2_L2_1"
+  bottom: "Mconv4_stage2_L2_2"
+  top: "Mconv4_stage2_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv5_stage2_L2_0"
+  type: "Convolution"
+  bottom: "Mconv4_stage2_L2_concat"
+  top: "Mconv5_stage2_L2_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu5_stage2_L2_0"
+  type: "PReLU"
+  bottom: "Mconv5_stage2_L2_0"
+  top: "Mconv5_stage2_L2_0"
+}
+layer {
+  name: "Mconv5_stage2_L2_1"
+  type: "Convolution"
+  bottom: "Mconv5_stage2_L2_0"
+  top: "Mconv5_stage2_L2_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu5_stage2_L2_1"
+  type: "PReLU"
+  bottom: "Mconv5_stage2_L2_1"
+  top: "Mconv5_stage2_L2_1"
+}
+layer {
+  name: "Mconv5_stage2_L2_2"
+  type: "Convolution"
+  bottom: "Mconv5_stage2_L2_1"
+  top: "Mconv5_stage2_L2_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu5_stage2_L2_2"
+  type: "PReLU"
+  bottom: "Mconv5_stage2_L2_2"
+  top: "Mconv5_stage2_L2_2"
+}
+layer {
+  name: "Mconv5_stage2_L2_concat"
+  type: "Concat"
+  bottom: "Mconv5_stage2_L2_0"
+  bottom: "Mconv5_stage2_L2_1"
+  bottom: "Mconv5_stage2_L2_2"
+  top: "Mconv5_stage2_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv6_stage2_L2"
+  type: "Convolution"
+  bottom: "Mconv5_stage2_L2_concat"
+  top: "Mconv6_stage2_L2"
+  convolution_param {
+    num_output: 512
+    pad: 0
+    kernel_size: 1
+  }
+}
+layer {
+  name: "Mprelu6_stage2_L2"
+  type: "PReLU"
+  bottom: "Mconv6_stage2_L2"
+  top: "Mconv6_stage2_L2"
+}
+layer {
+  name: "Mconv7_stage2_L2"
+  type: "Convolution"
+  bottom: "Mconv6_stage2_L2"
+  top: "Mconv7_stage2_L2"
+  convolution_param {
+    num_output: 52
+    pad: 0
+    kernel_size: 1
+  }
+}
+layer {
+  name: "concat_stage3_L2"
+  type: "Concat"
+  bottom: "conv4_4_CPM"
+  bottom: "Mconv7_stage2_L2"
+  top: "concat_stage3_L2"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv1_stage3_L2_0"
+  type: "Convolution"
+  bottom: "concat_stage3_L2"
+  top: "Mconv1_stage3_L2_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu1_stage3_L2_0"
+  type: "PReLU"
+  bottom: "Mconv1_stage3_L2_0"
+  top: "Mconv1_stage3_L2_0"
+}
+layer {
+  name: "Mconv1_stage3_L2_1"
+  type: "Convolution"
+  bottom: "Mconv1_stage3_L2_0"
+  top: "Mconv1_stage3_L2_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu1_stage3_L2_1"
+  type: "PReLU"
+  bottom: "Mconv1_stage3_L2_1"
+  top: "Mconv1_stage3_L2_1"
+}
+layer {
+  name: "Mconv1_stage3_L2_2"
+  type: "Convolution"
+  bottom: "Mconv1_stage3_L2_1"
+  top: "Mconv1_stage3_L2_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu1_stage3_L2_2"
+  type: "PReLU"
+  bottom: "Mconv1_stage3_L2_2"
+  top: "Mconv1_stage3_L2_2"
+}
+layer {
+  name: "Mconv1_stage3_L2_concat"
+  type: "Concat"
+  bottom: "Mconv1_stage3_L2_0"
+  bottom: "Mconv1_stage3_L2_1"
+  bottom: "Mconv1_stage3_L2_2"
+  top: "Mconv1_stage3_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv2_stage3_L2_0"
+  type: "Convolution"
+  bottom: "Mconv1_stage3_L2_concat"
+  top: "Mconv2_stage3_L2_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu2_stage3_L2_0"
+  type: "PReLU"
+  bottom: "Mconv2_stage3_L2_0"
+  top: "Mconv2_stage3_L2_0"
+}
+layer {
+  name: "Mconv2_stage3_L2_1"
+  type: "Convolution"
+  bottom: "Mconv2_stage3_L2_0"
+  top: "Mconv2_stage3_L2_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu2_stage3_L2_1"
+  type: "PReLU"
+  bottom: "Mconv2_stage3_L2_1"
+  top: "Mconv2_stage3_L2_1"
+}
+layer {
+  name: "Mconv2_stage3_L2_2"
+  type: "Convolution"
+  bottom: "Mconv2_stage3_L2_1"
+  top: "Mconv2_stage3_L2_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu2_stage3_L2_2"
+  type: "PReLU"
+  bottom: "Mconv2_stage3_L2_2"
+  top: "Mconv2_stage3_L2_2"
+}
+layer {
+  name: "Mconv2_stage3_L2_concat"
+  type: "Concat"
+  bottom: "Mconv2_stage3_L2_0"
+  bottom: "Mconv2_stage3_L2_1"
+  bottom: "Mconv2_stage3_L2_2"
+  top: "Mconv2_stage3_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv3_stage3_L2_0"
+  type: "Convolution"
+  bottom: "Mconv2_stage3_L2_concat"
+  top: "Mconv3_stage3_L2_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu3_stage3_L2_0"
+  type: "PReLU"
+  bottom: "Mconv3_stage3_L2_0"
+  top: "Mconv3_stage3_L2_0"
+}
+layer {
+  name: "Mconv3_stage3_L2_1"
+  type: "Convolution"
+  bottom: "Mconv3_stage3_L2_0"
+  top: "Mconv3_stage3_L2_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu3_stage3_L2_1"
+  type: "PReLU"
+  bottom: "Mconv3_stage3_L2_1"
+  top: "Mconv3_stage3_L2_1"
+}
+layer {
+  name: "Mconv3_stage3_L2_2"
+  type: "Convolution"
+  bottom: "Mconv3_stage3_L2_1"
+  top: "Mconv3_stage3_L2_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu3_stage3_L2_2"
+  type: "PReLU"
+  bottom: "Mconv3_stage3_L2_2"
+  top: "Mconv3_stage3_L2_2"
+}
+layer {
+  name: "Mconv3_stage3_L2_concat"
+  type: "Concat"
+  bottom: "Mconv3_stage3_L2_0"
+  bottom: "Mconv3_stage3_L2_1"
+  bottom: "Mconv3_stage3_L2_2"
+  top: "Mconv3_stage3_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv4_stage3_L2_0"
+  type: "Convolution"
+  bottom: "Mconv3_stage3_L2_concat"
+  top: "Mconv4_stage3_L2_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu4_stage3_L2_0"
+  type: "PReLU"
+  bottom: "Mconv4_stage3_L2_0"
+  top: "Mconv4_stage3_L2_0"
+}
+layer {
+  name: "Mconv4_stage3_L2_1"
+  type: "Convolution"
+  bottom: "Mconv4_stage3_L2_0"
+  top: "Mconv4_stage3_L2_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu4_stage3_L2_1"
+  type: "PReLU"
+  bottom: "Mconv4_stage3_L2_1"
+  top: "Mconv4_stage3_L2_1"
+}
+layer {
+  name: "Mconv4_stage3_L2_2"
+  type: "Convolution"
+  bottom: "Mconv4_stage3_L2_1"
+  top: "Mconv4_stage3_L2_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu4_stage3_L2_2"
+  type: "PReLU"
+  bottom: "Mconv4_stage3_L2_2"
+  top: "Mconv4_stage3_L2_2"
+}
+layer {
+  name: "Mconv4_stage3_L2_concat"
+  type: "Concat"
+  bottom: "Mconv4_stage3_L2_0"
+  bottom: "Mconv4_stage3_L2_1"
+  bottom: "Mconv4_stage3_L2_2"
+  top: "Mconv4_stage3_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv5_stage3_L2_0"
+  type: "Convolution"
+  bottom: "Mconv4_stage3_L2_concat"
+  top: "Mconv5_stage3_L2_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu5_stage3_L2_0"
+  type: "PReLU"
+  bottom: "Mconv5_stage3_L2_0"
+  top: "Mconv5_stage3_L2_0"
+}
+layer {
+  name: "Mconv5_stage3_L2_1"
+  type: "Convolution"
+  bottom: "Mconv5_stage3_L2_0"
+  top: "Mconv5_stage3_L2_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu5_stage3_L2_1"
+  type: "PReLU"
+  bottom: "Mconv5_stage3_L2_1"
+  top: "Mconv5_stage3_L2_1"
+}
+layer {
+  name: "Mconv5_stage3_L2_2"
+  type: "Convolution"
+  bottom: "Mconv5_stage3_L2_1"
+  top: "Mconv5_stage3_L2_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu5_stage3_L2_2"
+  type: "PReLU"
+  bottom: "Mconv5_stage3_L2_2"
+  top: "Mconv5_stage3_L2_2"
+}
+layer {
+  name: "Mconv5_stage3_L2_concat"
+  type: "Concat"
+  bottom: "Mconv5_stage3_L2_0"
+  bottom: "Mconv5_stage3_L2_1"
+  bottom: "Mconv5_stage3_L2_2"
+  top: "Mconv5_stage3_L2_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv6_stage3_L2"
+  type: "Convolution"
+  bottom: "Mconv5_stage3_L2_concat"
+  top: "Mconv6_stage3_L2"
+  convolution_param {
+    num_output: 512
+    pad: 0
+    kernel_size: 1
+  }
+}
+layer {
+  name: "Mprelu6_stage3_L2"
+  type: "PReLU"
+  bottom: "Mconv6_stage3_L2"
+  top: "Mconv6_stage3_L2"
+}
+layer {
+  name: "Mconv7_stage3_L2"
+  type: "Convolution"
+  bottom: "Mconv6_stage3_L2"
+  top: "Mconv7_stage3_L2"
+  convolution_param {
+    num_output: 52
+    pad: 0
+    kernel_size: 1
+  }
+}
+layer {
+  name: "concat_stage0_L1"
+  type: "Concat"
+  bottom: "conv4_4_CPM"
+  bottom: "Mconv7_stage3_L2"
+  top: "concat_stage0_L1"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv1_stage0_L1_0"
+  type: "Convolution"
+  bottom: "concat_stage0_L1"
+  top: "Mconv1_stage0_L1_0"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu1_stage0_L1_0"
+  type: "PReLU"
+  bottom: "Mconv1_stage0_L1_0"
+  top: "Mconv1_stage0_L1_0"
+}
+layer {
+  name: "Mconv1_stage0_L1_1"
+  type: "Convolution"
+  bottom: "Mconv1_stage0_L1_0"
+  top: "Mconv1_stage0_L1_1"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu1_stage0_L1_1"
+  type: "PReLU"
+  bottom: "Mconv1_stage0_L1_1"
+  top: "Mconv1_stage0_L1_1"
+}
+layer {
+  name: "Mconv1_stage0_L1_2"
+  type: "Convolution"
+  bottom: "Mconv1_stage0_L1_1"
+  top: "Mconv1_stage0_L1_2"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu1_stage0_L1_2"
+  type: "PReLU"
+  bottom: "Mconv1_stage0_L1_2"
+  top: "Mconv1_stage0_L1_2"
+}
+layer {
+  name: "Mconv1_stage0_L1_concat"
+  type: "Concat"
+  bottom: "Mconv1_stage0_L1_0"
+  bottom: "Mconv1_stage0_L1_1"
+  bottom: "Mconv1_stage0_L1_2"
+  top: "Mconv1_stage0_L1_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv2_stage0_L1_0"
+  type: "Convolution"
+  bottom: "Mconv1_stage0_L1_concat"
+  top: "Mconv2_stage0_L1_0"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu2_stage0_L1_0"
+  type: "PReLU"
+  bottom: "Mconv2_stage0_L1_0"
+  top: "Mconv2_stage0_L1_0"
+}
+layer {
+  name: "Mconv2_stage0_L1_1"
+  type: "Convolution"
+  bottom: "Mconv2_stage0_L1_0"
+  top: "Mconv2_stage0_L1_1"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu2_stage0_L1_1"
+  type: "PReLU"
+  bottom: "Mconv2_stage0_L1_1"
+  top: "Mconv2_stage0_L1_1"
+}
+layer {
+  name: "Mconv2_stage0_L1_2"
+  type: "Convolution"
+  bottom: "Mconv2_stage0_L1_1"
+  top: "Mconv2_stage0_L1_2"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu2_stage0_L1_2"
+  type: "PReLU"
+  bottom: "Mconv2_stage0_L1_2"
+  top: "Mconv2_stage0_L1_2"
+}
+layer {
+  name: "Mconv2_stage0_L1_concat"
+  type: "Concat"
+  bottom: "Mconv2_stage0_L1_0"
+  bottom: "Mconv2_stage0_L1_1"
+  bottom: "Mconv2_stage0_L1_2"
+  top: "Mconv2_stage0_L1_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv3_stage0_L1_0"
+  type: "Convolution"
+  bottom: "Mconv2_stage0_L1_concat"
+  top: "Mconv3_stage0_L1_0"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu3_stage0_L1_0"
+  type: "PReLU"
+  bottom: "Mconv3_stage0_L1_0"
+  top: "Mconv3_stage0_L1_0"
+}
+layer {
+  name: "Mconv3_stage0_L1_1"
+  type: "Convolution"
+  bottom: "Mconv3_stage0_L1_0"
+  top: "Mconv3_stage0_L1_1"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu3_stage0_L1_1"
+  type: "PReLU"
+  bottom: "Mconv3_stage0_L1_1"
+  top: "Mconv3_stage0_L1_1"
+}
+layer {
+  name: "Mconv3_stage0_L1_2"
+  type: "Convolution"
+  bottom: "Mconv3_stage0_L1_1"
+  top: "Mconv3_stage0_L1_2"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu3_stage0_L1_2"
+  type: "PReLU"
+  bottom: "Mconv3_stage0_L1_2"
+  top: "Mconv3_stage0_L1_2"
+}
+layer {
+  name: "Mconv3_stage0_L1_concat"
+  type: "Concat"
+  bottom: "Mconv3_stage0_L1_0"
+  bottom: "Mconv3_stage0_L1_1"
+  bottom: "Mconv3_stage0_L1_2"
+  top: "Mconv3_stage0_L1_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv4_stage0_L1_0"
+  type: "Convolution"
+  bottom: "Mconv3_stage0_L1_concat"
+  top: "Mconv4_stage0_L1_0"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu4_stage0_L1_0"
+  type: "PReLU"
+  bottom: "Mconv4_stage0_L1_0"
+  top: "Mconv4_stage0_L1_0"
+}
+layer {
+  name: "Mconv4_stage0_L1_1"
+  type: "Convolution"
+  bottom: "Mconv4_stage0_L1_0"
+  top: "Mconv4_stage0_L1_1"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu4_stage0_L1_1"
+  type: "PReLU"
+  bottom: "Mconv4_stage0_L1_1"
+  top: "Mconv4_stage0_L1_1"
+}
+layer {
+  name: "Mconv4_stage0_L1_2"
+  type: "Convolution"
+  bottom: "Mconv4_stage0_L1_1"
+  top: "Mconv4_stage0_L1_2"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu4_stage0_L1_2"
+  type: "PReLU"
+  bottom: "Mconv4_stage0_L1_2"
+  top: "Mconv4_stage0_L1_2"
+}
+layer {
+  name: "Mconv4_stage0_L1_concat"
+  type: "Concat"
+  bottom: "Mconv4_stage0_L1_0"
+  bottom: "Mconv4_stage0_L1_1"
+  bottom: "Mconv4_stage0_L1_2"
+  top: "Mconv4_stage0_L1_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv5_stage0_L1_0"
+  type: "Convolution"
+  bottom: "Mconv4_stage0_L1_concat"
+  top: "Mconv5_stage0_L1_0"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu5_stage0_L1_0"
+  type: "PReLU"
+  bottom: "Mconv5_stage0_L1_0"
+  top: "Mconv5_stage0_L1_0"
+}
+layer {
+  name: "Mconv5_stage0_L1_1"
+  type: "Convolution"
+  bottom: "Mconv5_stage0_L1_0"
+  top: "Mconv5_stage0_L1_1"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu5_stage0_L1_1"
+  type: "PReLU"
+  bottom: "Mconv5_stage0_L1_1"
+  top: "Mconv5_stage0_L1_1"
+}
+layer {
+  name: "Mconv5_stage0_L1_2"
+  type: "Convolution"
+  bottom: "Mconv5_stage0_L1_1"
+  top: "Mconv5_stage0_L1_2"
+  convolution_param {
+    num_output: 96
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu5_stage0_L1_2"
+  type: "PReLU"
+  bottom: "Mconv5_stage0_L1_2"
+  top: "Mconv5_stage0_L1_2"
+}
+layer {
+  name: "Mconv5_stage0_L1_concat"
+  type: "Concat"
+  bottom: "Mconv5_stage0_L1_0"
+  bottom: "Mconv5_stage0_L1_1"
+  bottom: "Mconv5_stage0_L1_2"
+  top: "Mconv5_stage0_L1_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv6_stage0_L1"
+  type: "Convolution"
+  bottom: "Mconv5_stage0_L1_concat"
+  top: "Mconv6_stage0_L1"
+  convolution_param {
+    num_output: 256
+    pad: 0
+    kernel_size: 1
+  }
+}
+layer {
+  name: "Mprelu6_stage0_L1"
+  type: "PReLU"
+  bottom: "Mconv6_stage0_L1"
+  top: "Mconv6_stage0_L1"
+}
+layer {
+  name: "Mconv7_stage0_L1"
+  type: "Convolution"
+  bottom: "Mconv6_stage0_L1"
+  top: "Mconv7_stage0_L1"
+  convolution_param {
+    num_output: 26
+    pad: 0
+    kernel_size: 1
+  }
+}
+layer {
+  name: "concat_stage1_L1"
+  type: "Concat"
+  bottom: "conv4_4_CPM"
+  bottom: "Mconv7_stage0_L1"
+  bottom: "Mconv7_stage3_L2"
+  top: "concat_stage1_L1"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv1_stage1_L1_0"
+  type: "Convolution"
+  bottom: "concat_stage1_L1"
+  top: "Mconv1_stage1_L1_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu1_stage1_L1_0"
+  type: "PReLU"
+  bottom: "Mconv1_stage1_L1_0"
+  top: "Mconv1_stage1_L1_0"
+}
+layer {
+  name: "Mconv1_stage1_L1_1"
+  type: "Convolution"
+  bottom: "Mconv1_stage1_L1_0"
+  top: "Mconv1_stage1_L1_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu1_stage1_L1_1"
+  type: "PReLU"
+  bottom: "Mconv1_stage1_L1_1"
+  top: "Mconv1_stage1_L1_1"
+}
+layer {
+  name: "Mconv1_stage1_L1_2"
+  type: "Convolution"
+  bottom: "Mconv1_stage1_L1_1"
+  top: "Mconv1_stage1_L1_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu1_stage1_L1_2"
+  type: "PReLU"
+  bottom: "Mconv1_stage1_L1_2"
+  top: "Mconv1_stage1_L1_2"
+}
+layer {
+  name: "Mconv1_stage1_L1_concat"
+  type: "Concat"
+  bottom: "Mconv1_stage1_L1_0"
+  bottom: "Mconv1_stage1_L1_1"
+  bottom: "Mconv1_stage1_L1_2"
+  top: "Mconv1_stage1_L1_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv2_stage1_L1_0"
+  type: "Convolution"
+  bottom: "Mconv1_stage1_L1_concat"
+  top: "Mconv2_stage1_L1_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu2_stage1_L1_0"
+  type: "PReLU"
+  bottom: "Mconv2_stage1_L1_0"
+  top: "Mconv2_stage1_L1_0"
+}
+layer {
+  name: "Mconv2_stage1_L1_1"
+  type: "Convolution"
+  bottom: "Mconv2_stage1_L1_0"
+  top: "Mconv2_stage1_L1_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu2_stage1_L1_1"
+  type: "PReLU"
+  bottom: "Mconv2_stage1_L1_1"
+  top: "Mconv2_stage1_L1_1"
+}
+layer {
+  name: "Mconv2_stage1_L1_2"
+  type: "Convolution"
+  bottom: "Mconv2_stage1_L1_1"
+  top: "Mconv2_stage1_L1_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu2_stage1_L1_2"
+  type: "PReLU"
+  bottom: "Mconv2_stage1_L1_2"
+  top: "Mconv2_stage1_L1_2"
+}
+layer {
+  name: "Mconv2_stage1_L1_concat"
+  type: "Concat"
+  bottom: "Mconv2_stage1_L1_0"
+  bottom: "Mconv2_stage1_L1_1"
+  bottom: "Mconv2_stage1_L1_2"
+  top: "Mconv2_stage1_L1_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv3_stage1_L1_0"
+  type: "Convolution"
+  bottom: "Mconv2_stage1_L1_concat"
+  top: "Mconv3_stage1_L1_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu3_stage1_L1_0"
+  type: "PReLU"
+  bottom: "Mconv3_stage1_L1_0"
+  top: "Mconv3_stage1_L1_0"
+}
+layer {
+  name: "Mconv3_stage1_L1_1"
+  type: "Convolution"
+  bottom: "Mconv3_stage1_L1_0"
+  top: "Mconv3_stage1_L1_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu3_stage1_L1_1"
+  type: "PReLU"
+  bottom: "Mconv3_stage1_L1_1"
+  top: "Mconv3_stage1_L1_1"
+}
+layer {
+  name: "Mconv3_stage1_L1_2"
+  type: "Convolution"
+  bottom: "Mconv3_stage1_L1_1"
+  top: "Mconv3_stage1_L1_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu3_stage1_L1_2"
+  type: "PReLU"
+  bottom: "Mconv3_stage1_L1_2"
+  top: "Mconv3_stage1_L1_2"
+}
+layer {
+  name: "Mconv3_stage1_L1_concat"
+  type: "Concat"
+  bottom: "Mconv3_stage1_L1_0"
+  bottom: "Mconv3_stage1_L1_1"
+  bottom: "Mconv3_stage1_L1_2"
+  top: "Mconv3_stage1_L1_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv4_stage1_L1_0"
+  type: "Convolution"
+  bottom: "Mconv3_stage1_L1_concat"
+  top: "Mconv4_stage1_L1_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu4_stage1_L1_0"
+  type: "PReLU"
+  bottom: "Mconv4_stage1_L1_0"
+  top: "Mconv4_stage1_L1_0"
+}
+layer {
+  name: "Mconv4_stage1_L1_1"
+  type: "Convolution"
+  bottom: "Mconv4_stage1_L1_0"
+  top: "Mconv4_stage1_L1_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu4_stage1_L1_1"
+  type: "PReLU"
+  bottom: "Mconv4_stage1_L1_1"
+  top: "Mconv4_stage1_L1_1"
+}
+layer {
+  name: "Mconv4_stage1_L1_2"
+  type: "Convolution"
+  bottom: "Mconv4_stage1_L1_1"
+  top: "Mconv4_stage1_L1_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu4_stage1_L1_2"
+  type: "PReLU"
+  bottom: "Mconv4_stage1_L1_2"
+  top: "Mconv4_stage1_L1_2"
+}
+layer {
+  name: "Mconv4_stage1_L1_concat"
+  type: "Concat"
+  bottom: "Mconv4_stage1_L1_0"
+  bottom: "Mconv4_stage1_L1_1"
+  bottom: "Mconv4_stage1_L1_2"
+  top: "Mconv4_stage1_L1_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv5_stage1_L1_0"
+  type: "Convolution"
+  bottom: "Mconv4_stage1_L1_concat"
+  top: "Mconv5_stage1_L1_0"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu5_stage1_L1_0"
+  type: "PReLU"
+  bottom: "Mconv5_stage1_L1_0"
+  top: "Mconv5_stage1_L1_0"
+}
+layer {
+  name: "Mconv5_stage1_L1_1"
+  type: "Convolution"
+  bottom: "Mconv5_stage1_L1_0"
+  top: "Mconv5_stage1_L1_1"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu5_stage1_L1_1"
+  type: "PReLU"
+  bottom: "Mconv5_stage1_L1_1"
+  top: "Mconv5_stage1_L1_1"
+}
+layer {
+  name: "Mconv5_stage1_L1_2"
+  type: "Convolution"
+  bottom: "Mconv5_stage1_L1_1"
+  top: "Mconv5_stage1_L1_2"
+  convolution_param {
+    num_output: 128
+    pad: 1
+    kernel_size: 3
+  }
+}
+layer {
+  name: "Mprelu5_stage1_L1_2"
+  type: "PReLU"
+  bottom: "Mconv5_stage1_L1_2"
+  top: "Mconv5_stage1_L1_2"
+}
+layer {
+  name: "Mconv5_stage1_L1_concat"
+  type: "Concat"
+  bottom: "Mconv5_stage1_L1_0"
+  bottom: "Mconv5_stage1_L1_1"
+  bottom: "Mconv5_stage1_L1_2"
+  top: "Mconv5_stage1_L1_concat"
+  concat_param {
+    axis: 1
+  }
+}
+layer {
+  name: "Mconv6_stage1_L1"
+  type: "Convolution"
+  bottom: "Mconv5_stage1_L1_concat"
+  top: "Mconv6_stage1_L1"
+  convolution_param {
+    num_output: 512
+    pad: 0
+    kernel_size: 1
+  }
+}
+layer {
+  name: "Mprelu6_stage1_L1"
+  type: "PReLU"
+  bottom: "Mconv6_stage1_L1"
+  top: "Mconv6_stage1_L1"
+}
+layer {
+  name: "Mconv7_stage1_L1"
+  type: "Convolution"
+  bottom: "Mconv6_stage1_L1"
+  top: "Mconv7_stage1_L1"
+  convolution_param {
+    num_output: 26
+    pad: 0
+    kernel_size: 1
+  }
+}
+layer {
+  name: "net_output"
+  type: "Concat"
+  bottom: "Mconv7_stage1_L1"
+  bottom: "Mconv7_stage3_L2"
+  top: "net_output"
+  concat_param {
+    axis: 1
+  }
+}

requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.115.6
+uvicorn==0.34.0
+numpy==1.26.4
+opencv-python-headless==4.10.0.84
+scipy==1.13.1
+python-multipart==0.0.20
+ultralytics==8.3.50
+huggingface_hub==0.27.1

rules_by_age.json

@@ -0,0 +1,103 @@
+{
+  "description": "Biomechanical gait analysis benchmarks and red flags by age group. Reference: Trupti Didi Clinical Benchmarks.",
+  "age_groups": [
+    {
+      "range": "1-2",
+      "name": "Early Toddlers",
+      "benchmarks": {
+        "heel_strike": "Not expected",
+        "cadence_bpm": "150-180",
+        "swing_knee_flexion": "45-55°",
+        "stance_knee_angle": "> 150°",
+        "asymmetry_threshold_percent": 15,
+        "trunk_sway_threshold": 25
+      },
+      "clinical_notes": "Wide base of support and high-guard arm position are normal at this stage."
+    },
+    {
+      "range": "3-4",
+      "name": "Preschoolers",
+      "benchmarks": {
+        "heel_strike": "Inconsistent/Emerging",
+        "cadence_bpm": "130-150",
+        "swing_knee_flexion": "55-60°",
+        "stance_knee_angle": "> 160°",
+        "asymmetry_threshold_percent": 10,
+        "trunk_sway_threshold": 20
+      },
+      "clinical_notes": "Heel strike should start becoming consistent. Persistent knee flexion in stance (>20deg) after age 3 is a red flag."
+    },
+    {
+      "range": "5-7",
+      "name": "Early School Age",
+      "benchmarks": {
+        "heel_strike": "Expected/Consistent",
+        "cadence_bpm": "110-130",
+        "swing_knee_flexion": "60-65°",
+        "stance_knee_angle": "> 170°",
+        "asymmetry_threshold_percent": 8,
+        "trunk_sway_threshold": 15
+      },
+      "clinical_notes": "Gait pattern should be well-established and similar to adult morphology."
+    },
+    {
+      "range": "8+",
+      "name": "Mature/Adult",
+      "benchmarks": {
+        "heel_strike": "Mandatory",
+        "cadence_bpm": "90-120",
+        "swing_knee_flexion": "60-70°",
+        "stance_knee_angle": "> 175°",
+        "asymmetry_threshold_percent": 8,
+        "trunk_sway_threshold": 12
+      },
+      "clinical_notes": "Adult-like symmetry and stability expected. High trunk sway or lack of heel strike indicates pathology."
+    }
+  ],
+  "global_red_flags": [
+    {
+      "type": "Asymmetrical Loading",
+      "description": "Significant difference between left and right limb metrics.",
+      "severity": "moderate"
+    },
+    {
+      "type": "Instability",
+      "description": "High trunk sway or variable stride patterns.",
+      "severity": "high"
+    },
+    {
+      "type": "Developmental Delay",
+      "description": "Gait markers significantly below age-group benchmarks.",
+      "severity": "moderate"
+    }
+  ],
+  "parameter_thresholds": {
+    "step_length_symmetry": {
+      "typical": 7,
+      "mild": 12,
+      "consistent": 15
+    },
+    "stance_time_symmetry": {
+      "typical": 5,
+      "load_avoidance": 8
+    },
+    "swing_time_symmetry": {
+      "typical": 5,
+      "control_related": 8
+    },
+    "stride_consistency": "High SD indicates instability/immature control"
+  },
+  "primitive_reflex_influence": {
+    "moro": "Difficulty releasing support",
+    "fear_paralysis": "Freezing",
+    "tlr": "Extensor posture",
+    "atnr": "Trunk rotation",
+    "palmar": "Fisted hands"
+  },
+  "safety_rules": {
+    "min_steps": 5,
+    "min_duration_seconds": 3,
+    "requires_independent_walking": true,
+    "limitation_note": "Numerical interpretation limited due to context."
+  }
+}

run_test.py

@@ -0,0 +1,111 @@
+from gait_analysis import EnhancedGaitAnalyzer
+import os
+import json
+from generate_report import generate_markdown_report
+from datetime import datetime
+
+def main():
+    # Path to test.mp4
+    # The script is in backend/, test.mp4 is in root/ (../test.mp4)
+    video_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "atmin.mp4"))
+    
+    print(f"Looking for video at: {video_path}")
+    if not os.path.exists(video_path):
+        print("Error: test.mp4 not found!")
+        return
+
+    print("Initializing EnhancedGaitAnalyzer...")
+    analyzer = EnhancedGaitAnalyzer(age=4) # Assuming age 4 for test
+    
+    print("Processing video... this might take a moment.")
+    try:
+        results = analyzer.process_video(video_path)
+        
+        # Generate report
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        report_filename = f"gait_analysis_report_{timestamp}.md"
+        report_path = os.path.join(os.path.dirname(video_path), report_filename)
+        generate_markdown_report(results, video_path, report_path)
+        
+        # Helper function to safely format numbers
+        def fmt(value, decimals=2):
+            """Format numeric value or return N/A"""
+            if value == 'N/A' or value is None:
+                return 'N/A'
+            try:
+                return f"{float(value):.{decimals}f}"
+            except (ValueError, TypeError):
+                return 'N/A'
+        
+        # Extract new observation outputs
+        summary = results.get("summary", {})
+        observations = results.get("observations", {})
+        strategies = results.get("compensatory_strategies", [])
+        reflex_influence = results.get("reflex_influence", "None observed")
+        safety_note = results.get("safety_note", "")
+        weight_dist = results.get("weight_distribution", {})
+        postural_strength = results.get("postural_strength", {})
+        clinical_notes = results.get("clinical_notes", [])
+        
+        print("\n" + "="*60)
+        print("CLINICAL GAIT ANALYSIS RESULTS")
+        print("="*60)
+        
+        # 1. Walking Condition
+        walking_condition = summary.get("walking_condition", "Not specified")
+        print(f"\n🚶 WALKING CONDITION: {walking_condition.upper()}")
+        
+        # 2. Observed Movement Patterns
+        print(f"\n� OBSERVED MOVEMENT PATTERNS:")
+        print(f"  Trunk: {observations.get('trunk', 'N/A')}")
+        print(f"  Head & Neck: {observations.get('head_neck', 'N/A')}")
+        print(f"  Arms & Hands: {observations.get('arms_hands', 'N/A')}")
+        print(f"  Lower Limbs: {observations.get('lower_limbs', 'N/A')}")
+        print(f"  Symmetry: {observations.get('symmetry', 'N/A')}")
+        
+        # 3. Compensatory Strategies
+        print(f"\n💡 COMPENSATORY STRATEGIES:")
+        if strategies:
+            for strategy in strategies:
+                print(f"  - {strategy}")
+        else:
+            print("  - None identified")
+
+        print(f"\n📝 CLINICAL NOTES:")
+        if clinical_notes:
+            for note in clinical_notes:
+                print(f"  - {note}")
+        else:
+            print("  - None noted")
+
+        # 4. Integrated Movement Summary
+        asymmetry = summary.get("phase_asymmetry_percent", 0)
+        stability = summary.get("stability_score", 0)
+        strength = summary.get("strength_score", 0)
+        weight_shift = summary.get("weight_shift_score", 0)
+        gait_quality = summary.get("overall_gait_quality", "unknown")
+        
+        print(f"\n📋 INTEGRATED MOVEMENT SUMMARY:")
+        print(f"  Walking Condition: {walking_condition.upper()}")
+        print(f"  Overall Gait Quality: {gait_quality.upper()}")
+        print(f"  Stability Score: {stability:.0f}/100 | Strength Score: {strength:.0f}/100 | Weight Shift Score: {weight_shift:.0f}/100")
+        print(f"  Movement symmetry shows a {asymmetry:.1f}% phase variance.")
+        
+        if reflex_influence:
+            print(f"\n  {reflex_influence}")
+            
+        if safety_note:
+            print(f"\n  ⚠️ {safety_note}")
+        
+        print("\n" + "="*60)
+        print("NOTE: This is NOT a medical diagnosis. Consult a healthcare")
+        print("professional for proper assessment and treatment.")
+        print("="*60 + "\n")
+        
+    except Exception as e:
+        print(f"An error occurred during processing: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    main()

save_results.py

@@ -0,0 +1,42 @@
+from gait_analysis import EnhancedGaitAnalyzer
+import os
+import json
+
+def main():
+    # Path to test.mp4
+    video_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "test.mp4"))
+    
+    print(f"Looking for video at: {video_path}")
+    if not os.path.exists(video_path):
+        print("Error: test.mp4 not found!")
+        return
+
+    print("Initializing EnhancedGaitAnalyzer...")
+    analyzer = EnhancedGaitAnalyzer()
+    
+    print("Processing video... this might take a moment.")
+    try:
+        results = analyzer.process_video(video_path)
+        
+        # Save to JSON file
+        output_file = os.path.join(os.path.dirname(video_path), "analysis_results.json")
+        with open(output_file, 'w') as f:
+            json.dump(results, f, indent=2, default=str)
+        
+        print(f"\n✅ Results saved to: {output_file}")
+        
+        # Print summary
+        summary = results.get("summary", {})
+        
+        print("\n" + "="*60)
+        print("SUMMARY")
+        print("="*60)
+        print(json.dumps(summary, indent=2))
+        
+    except Exception as e:
+        print(f"An error occurred during processing: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    main()

yolo11n-pose.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:869e83fcdffdc7371fa4e34cd8e51c838cc729571d1635e5141e3075e9319dc0
+size 6255593