fix: HF Spaces import 에러 해결 - self-contained 구조로 변경

- demo_gradio/models/ 디렉토리에 pose_estimator.py, stgcn_classifier.py 복사
- demo_gradio/stgcn/ 디렉토리에 model.py, graph.py 복사
- augmentation.py, visualization.py 복사
- app.py 및 stgcn_classifier.py의 import 경로를 상대 import로 수정
- .gitignore에 pipeline/demo_gradio/models/ 예외 추가

이 변경으로 HF Space에서 pipeline 모듈 없이 독립 실행 가능

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

app.py

@@ -35,9 +35,7 @@ from gradio.themes import Soft
 from gradio.themes.utils import colors, fonts, sizes
 from huggingface_hub import hf_hub_download
 
-# 프로젝트 루트를 Python path에 추가
-PROJECT_ROOT = Path(__file__).parent.parent.parent
-sys.path.insert(0, str(PROJECT_ROOT))
+# HF Spaces 배포용: 프로젝트 루트 설정 불필요 (self-contained)
 
 # Zero GPU 호환 설정
 try:
@@ -192,7 +190,7 @@ def get_pose_estimator():
     """PoseEstimator 싱글톤 반환"""
     global _pose_estimator
     if _pose_estimator is None:
-        from pipeline.models.pose_estimator import PoseEstimator
+        from models.pose_estimator import PoseEstimator
         pose_model_path, _ = download_models()
         _pose_estimator = PoseEstimator(
             model_path=pose_model_path,
@@ -206,7 +204,7 @@ def get_stgcn_classifier():
     """STGCNClassifier 싱글톤 반환"""
     global _stgcn_classifier
     if _stgcn_classifier is None:
-        from pipeline.models.stgcn_classifier import STGCNClassifier
+        from models.stgcn_classifier import STGCNClassifier
         _, stgcn_checkpoint = download_models()
         _stgcn_classifier = STGCNClassifier(
             checkpoint_path=stgcn_checkpoint,
@@ -355,11 +353,8 @@ def _visualize_single_frame(args: tuple) -> Tuple[int, np.ndarray]:
     (frame_idx, frame, keypoints, show_fall_text,
      viz_keypoints, viz_scale) = args
 
-    # 프로젝트 import (워커 프로세스에서)
-    import sys
-    from pathlib import Path
-    sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-    from pipeline.visualization import visualize_fall_simple
+    # HF Spaces 배포용 상대 import (워커 프로세스에서)
+    from visualization import visualize_fall_simple
 
     vis_frame = visualize_fall_simple(
         frame=frame,

augmentation.py

@@ -0,0 +1,725 @@
+#!/usr/bin/env python3
+"""
+Skeleton Data Augmentation for ST-GCN Fall Detection
+
+This module provides augmentation strategies for skeleton sequence data to improve
+model generalization and robustness. All augmentations preserve the spatial-temporal
+structure required by ST-GCN while introducing controlled variations.
+
+Input Format: (C, T, V, M) where
+    C = 3 channels (x, y, confidence)
+    T = 60 frames (temporal window)
+    V = 17 keypoints (COCO skeleton)
+    M = 1 person (max persons tracked)
+
+Augmentation Strategies:
+1. Horizontal Flip: Mirror skeleton across vertical axis with keypoint swapping
+2. Gaussian Noise: Add random noise to x,y coordinates (preserves confidence)
+3. Temporal Crop: Random crop + resize to simulate variable fall speeds
+
+Reference: Issue #34 - ST-GCN Training Dataset Creation
+"""
+
+import numpy as np
+from typing import Tuple, Optional
+
+
+# COCO 17-keypoint left/right pairs for horizontal flip
+# Format: (left_index, right_index)
+COCO_LEFT_RIGHT_PAIRS = [
+    (1, 2),   # left_eye <-> right_eye
+    (3, 4),   # left_ear <-> right_ear
+    (5, 6),   # left_shoulder <-> right_shoulder
+    (7, 8),   # left_elbow <-> right_elbow
+    (9, 10),  # left_wrist <-> right_wrist
+    (11, 12), # left_hip <-> right_hip
+    (13, 14), # left_knee <-> right_knee
+    (15, 16), # left_ankle <-> right_ankle
+]
+
+
+def augment_skeleton(data: np.ndarray, prob: float = 0.5) -> np.ndarray:
+    """
+    Apply random augmentations to skeleton sequence data.
+
+    This function applies three augmentation strategies with probability `prob`:
+    1. Horizontal flip with keypoint swapping
+    2. Gaussian noise injection to x,y coordinates
+    3. Temporal crop and resize
+
+    Mathematical Formulations:
+    -------------------------
+    1. Horizontal Flip:
+        x' = -x
+        For each (left, right) keypoint pair: swap(left, right)
+
+    2. Gaussian Noise:
+        x' = x + N(0, sigma^2)
+        y' = y + N(0, sigma^2)
+        where N(0, sigma^2) ~ Normal(mean=0, std=0.01)
+
+    3. Temporal Crop & Resize:
+        T_crop ~ Uniform(0.8 * T, 1.0 * T)
+        start_frame ~ Uniform(0, T - T_crop)
+        cropped = data[:, start:start+T_crop, :, :]
+        resized = interpolate(cropped, T)
+
+    Args:
+        data: Skeleton data with shape (C, T, V, M) where
+            C = 3 (x, y, confidence)
+            T = 60 (number of frames)
+            V = 17 (number of keypoints)
+            M = 1 (number of persons)
+        prob: Probability of applying each augmentation (default: 0.5)
+
+    Returns:
+        augmented_data: Augmented skeleton data with same shape (C, T, V, M)
+
+    Example:
+        >>> data = np.random.rand(3, 60, 17, 1)
+        >>> augmented = augment_skeleton(data, prob=0.5)
+        >>> augmented.shape
+        (3, 60, 17, 1)
+    """
+    C, T, V, M = data.shape
+    assert C == 3, f"Expected 3 channels (x, y, conf), got {C}"
+    assert V == 17, f"Expected 17 COCO keypoints, got {V}"
+    assert M == 1, f"Expected max 1 person, got {M}"
+
+    # Create a copy to avoid modifying original data
+    augmented_data = data.copy()
+
+    # 1. Horizontal Flip (flip x-coordinate + swap left/right keypoints)
+    if np.random.rand() < prob:
+        augmented_data = _horizontal_flip(augmented_data)
+
+    # 2. Random Noise Injection (add Gaussian noise to x,y only)
+    if np.random.rand() < prob:
+        augmented_data = _add_gaussian_noise(augmented_data)
+
+    # 3. Temporal Crop and Resize (crop 0.8-1.0 of length, resize back)
+    if np.random.rand() < prob:
+        augmented_data = _temporal_crop_resize(augmented_data)
+
+    return augmented_data
+
+
+def _horizontal_flip(data: np.ndarray) -> np.ndarray:
+    """
+    Horizontally flip skeleton by negating x-coordinate and swapping left/right keypoints.
+
+    Mathematical Formulation:
+        x' = -x
+        y' = y
+        conf' = conf
+        For each (left_idx, right_idx) pair: swap keypoints
+
+    Args:
+        data: Skeleton data (C, T, V, M)
+
+    Returns:
+        flipped_data: Horizontally flipped data (C, T, V, M)
+    """
+    flipped_data = data.copy()
+
+    # Flip x-coordinate (channel 0)
+    flipped_data[0] = -flipped_data[0]
+
+    # Swap left/right keypoint pairs
+    for left_idx, right_idx in COCO_LEFT_RIGHT_PAIRS:
+        # Swap all channels (x, y, conf) for the keypoint pair
+        temp = flipped_data[:, :, left_idx, :].copy()
+        flipped_data[:, :, left_idx, :] = flipped_data[:, :, right_idx, :]
+        flipped_data[:, :, right_idx, :] = temp
+
+    return flipped_data
+
+
+def _add_gaussian_noise(data: np.ndarray, std: float = 0.01) -> np.ndarray:
+    """
+    Add Gaussian noise to x,y coordinates (preserves confidence channel).
+
+    Mathematical Formulation:
+        x' = x + N(0, sigma^2)
+        y' = y + N(0, sigma^2)
+        conf' = conf (unchanged)
+        where sigma = 0.01 (default)
+
+    The noise magnitude is calibrated for normalized coordinates in range [-0.5, 0.5].
+    With std=0.01, 99.7% of noise values fall within [-0.03, 0.03] (3-sigma rule).
+
+    Args:
+        data: Skeleton data (C, T, V, M)
+        std: Standard deviation of Gaussian noise (default: 0.01)
+
+    Returns:
+        noisy_data: Data with Gaussian noise added to x,y coordinates
+    """
+    C, T, V, M = data.shape
+    noisy_data = data.copy()
+
+    # Generate Gaussian noise for x,y channels only (not confidence)
+    noise_shape = (2, T, V, M)  # Only x,y channels
+    noise = np.random.normal(0, std, noise_shape).astype(data.dtype)
+
+    # Add noise to x,y channels (0, 1), leave confidence channel (2) unchanged
+    noisy_data[:2] += noise
+
+    return noisy_data
+
+
+def _temporal_crop_resize(data: np.ndarray, crop_ratio_range: Tuple[float, float] = (0.8, 1.0)) -> np.ndarray:
+    """
+    Randomly crop temporal sequence and resize back to original length.
+
+    This augmentation simulates variable fall speeds by compressing or expanding
+    the temporal dimension. A crop ratio of 0.8 means the fall happens 20% faster,
+    while 1.0 means no temporal change.
+
+    Mathematical Formulation:
+        T_crop ~ Uniform(crop_min * T, crop_max * T)
+        start ~ Uniform(0, T - T_crop)
+        cropped = data[:, start:start+T_crop, :, :]
+        resized = interpolate(cropped, T) using linear interpolation
+
+    Args:
+        data: Skeleton data (C, T, V, M)
+        crop_ratio_range: (min_ratio, max_ratio) for crop length (default: (0.8, 1.0))
+
+    Returns:
+        resized_data: Temporally augmented data with original shape (C, T, V, M)
+    """
+    C, T, V, M = data.shape
+    min_ratio, max_ratio = crop_ratio_range
+
+    # Sample random crop ratio
+    crop_ratio = np.random.uniform(min_ratio, max_ratio)
+    crop_length = int(T * crop_ratio)
+    crop_length = max(1, crop_length)  # Ensure at least 1 frame
+
+    # Sample random start position
+    max_start = max(0, T - crop_length)
+    start_frame = np.random.randint(0, max_start + 1) if max_start > 0 else 0
+
+    # Extract cropped window
+    cropped = data[:, start_frame:start_frame + crop_length, :, :]
+
+    # Resize back to original temporal length using linear interpolation
+    resized_data = _temporal_interpolate(cropped, T)
+
+    return resized_data
+
+
+def _temporal_interpolate(data: np.ndarray, target_length: int) -> np.ndarray:
+    """
+    Interpolate temporal dimension to target length using linear interpolation.
+
+    This function performs 1D linear interpolation along the temporal axis (axis=1)
+    for each channel, keypoint, and person independently.
+
+    Args:
+        data: Skeleton data (C, T, V, M)
+        target_length: Target number of frames
+
+    Returns:
+        interpolated_data: Data with temporal dimension resized to target_length
+    """
+    C, T_src, V, M = data.shape
+
+    if T_src == target_length:
+        return data
+
+    # Create target time indices
+    src_indices = np.linspace(0, T_src - 1, T_src)
+    target_indices = np.linspace(0, T_src - 1, target_length)
+
+    # Interpolate each channel, keypoint, person combination
+    interpolated_data = np.zeros((C, target_length, V, M), dtype=data.dtype)
+
+    for c in range(C):
+        for v in range(V):
+            for m in range(M):
+                interpolated_data[c, :, v, m] = np.interp(
+                    target_indices,
+                    src_indices,
+                    data[c, :, v, m]
+                )
+
+    return interpolated_data
+
+
+def _normalize_by_hip_center(data: np.ndarray) -> np.ndarray:
+    """
+    Normalize skeleton by hip center position and skeleton size (ST-GCN standard).
+
+    This is the recommended normalization method for skeleton-based action recognition,
+    following the ST-GCN paper and NTU RGB+D dataset preprocessing.
+
+    Algorithm:
+    ----------
+    1. Calculate hip center from left_hip (11) and right_hip (12)
+    2. If hips have low confidence (<0.3), fallback to shoulder center
+    3. Center all keypoints by subtracting hip center
+    4. Calculate skeleton size as average shoulder-to-hip distance
+    5. Scale all coordinates by skeleton size
+
+    COCO Keypoints Used:
+    - 5: left_shoulder
+    - 6: right_shoulder
+    - 11: left_hip
+    - 12: right_hip
+
+    Args:
+        data: Skeleton data (C, T, V, M) with C=3 (x, y, conf)
+
+    Returns:
+        normalized_data: (C, T, V, M) centered at hip, scaled by skeleton size
+            - x,y channels: relative to hip center, scaled by skeleton size
+            - conf channel: unchanged
+
+    Example:
+        >>> data = np.random.rand(3, 60, 17, 1) * [3840, 2160, 1]
+        >>> normalized = _normalize_by_hip_center(data)
+        >>> # Hip center is now at (0, 0)
+        >>> hip_center_x = (normalized[0, :, 11, :] + normalized[0, :, 12, :]) / 2
+        >>> np.allclose(hip_center_x, 0.0, atol=1e-6)
+        True
+    """
+    C, T, V, M = data.shape
+    normalized_data = data.copy()
+
+    # Extract hip keypoints (COCO: 11=left_hip, 12=right_hip)
+    left_hip_xy = data[:2, :, 11:12, :]    # (2, T, 1, M)
+    right_hip_xy = data[:2, :, 12:13, :]   # (2, T, 1, M)
+    left_hip_conf = data[2:3, :, 11:12, :] # (1, T, 1, M)
+    right_hip_conf = data[2:3, :, 12:13, :]# (1, T, 1, M)
+
+    # Calculate average hip confidence across all frames
+    left_hip_conf_mean = np.mean(left_hip_conf)
+    right_hip_conf_mean = np.mean(right_hip_conf)
+
+    # Determine center point (hip or shoulder fallback)
+    if left_hip_conf_mean >= 0.3 and right_hip_conf_mean >= 0.3:
+        # Normal case: Use hip center
+        center_point = (left_hip_xy + right_hip_xy) / 2.0  # (2, T, 1, M)
+
+        # Calculate skeleton size from shoulder-to-hip distance
+        left_shoulder_xy = data[:2, :, 5:6, :]  # (2, T, 1, M)
+        right_shoulder_xy = data[:2, :, 6:7, :] # (2, T, 1, M)
+
+        # Left torso distance: ||left_shoulder - left_hip||
+        left_torso = left_shoulder_xy - left_hip_xy  # (2, T, 1, M)
+        left_torso_dist = np.sqrt(np.sum(left_torso ** 2, axis=0))  # (T, 1, M)
+
+        # Right torso distance: ||right_shoulder - right_hip||
+        right_torso = right_shoulder_xy - right_hip_xy  # (2, T, 1, M)
+        right_torso_dist = np.sqrt(np.sum(right_torso ** 2, axis=0))  # (T, 1, M)
+
+        # Average skeleton size across frames and left/right
+        skeleton_size = np.mean([left_torso_dist, right_torso_dist])  # scalar
+
+    else:
+        # Fallback: Use shoulder center if hips not detected
+        left_shoulder_xy = data[:2, :, 5:6, :]
+        right_shoulder_xy = data[:2, :, 6:7, :]
+        center_point = (left_shoulder_xy + right_shoulder_xy) / 2.0  # (2, T, 1, M)
+
+        # Use shoulder width as skeleton size estimate
+        shoulder_vector = right_shoulder_xy - left_shoulder_xy  # (2, T, 1, M)
+        shoulder_width = np.sqrt(np.sum(shoulder_vector ** 2, axis=0))  # (T, 1, M)
+        skeleton_size = np.mean(shoulder_width) * 2.0  # Approximate torso height
+
+    # Prevent division by zero
+    skeleton_size = max(skeleton_size, 1e-6)
+
+    # Normalize x,y channels: center and scale
+    normalized_data[:2] = (normalized_data[:2] - center_point) / skeleton_size
+
+    # Confidence channel unchanged
+    # normalized_data[2] remains as is
+
+    return normalized_data
+
+
+def _normalize_by_image_center(
+    data: np.ndarray,
+    img_width: int = 3840,
+    img_height: int = 2160
+) -> np.ndarray:
+    """
+    Legacy normalization by image center (for comparison only).
+
+    This method is NOT recommended for ST-GCN training as it:
+    - Includes absolute position information
+    - Varies with camera angle
+    - Does not normalize body size
+
+    Use this only for comparing with old implementations or specific use cases
+    where absolute position in frame matters.
+
+    Args:
+        data: Skeleton data (C, T, V, M)
+        img_width: Image width in pixels (default: 3840 for AI Hub 4K)
+        img_height: Image height in pixels (default: 2160 for AI Hub 4K)
+
+    Returns:
+        normalized_data: (C, T, V, M) with x,y in [-0.5, 0.5]
+    """
+    C, T, V, M = data.shape
+    normalized_data = data.copy()
+
+    # Normalize x-coordinate (channel 0): [0, img_width] -> [-0.5, 0.5]
+    normalized_data[0] = (normalized_data[0] / img_width) - 0.5
+
+    # Normalize y-coordinate (channel 1): [0, img_height] -> [-0.5, 0.5]
+    normalized_data[1] = (normalized_data[1] / img_height) - 0.5
+
+    # Confidence channel (2) remains unchanged in [0, 1]
+
+    return normalized_data
+
+
+def normalize_skeleton(
+    data: np.ndarray,
+    method: str = 'hip_center',
+    img_width: int = 3840,
+    img_height: int = 2160
+) -> np.ndarray:
+    """
+    Normalize skeleton coordinates using ST-GCN standard method.
+
+    This normalization removes absolute position information and makes the model
+    focus on relative pose patterns, which is critical for fall detection across
+    different camera angles (AI Hub 8-camera setup).
+
+    Methods:
+    --------
+    1. 'hip_center' (default, ST-GCN standard):
+       - Center: Hip center (average of left_hip and right_hip)
+       - Scale: Skeleton size (shoulder-to-hip distance)
+       - Fallback: Shoulder center if hips not detected
+       - Reference: ST-GCN (Yan et al., AAAI 2018), NTU RGB+D normalization
+
+    2. 'image_center' (legacy, not recommended):
+       - Center: Image center
+       - Scale: Image dimensions
+       - Use only for comparison with old implementations
+
+    Mathematical Formulations (hip_center):
+    ----------------------------------------
+    Step 1: Calculate hip center
+        hip_center = (left_hip + right_hip) / 2  # COCO keypoints 11, 12
+
+    Step 2: Center all keypoints
+        x' = x - hip_center_x
+        y' = y - hip_center_y
+
+    Step 3: Scale by skeleton size (shoulder-to-hip distance)
+        skeleton_size = mean(||shoulder - hip||) over left and right
+        x'' = x' / skeleton_size
+        y'' = y' / skeleton_size
+
+    Advantages of hip_center normalization:
+    - Camera angle invariant (critical for 8-camera AI Hub dataset)
+    - Absolute position independent (person can be anywhere in frame)
+    - Body size normalized (tall/short people comparable)
+    - Matches ST-GCN paper and most skeleton action recognition works
+
+    Args:
+        data: Skeleton data with shape (C, T, V, M) where
+            C = 3 (x in pixels, y in pixels, confidence)
+            T = number of frames
+            V = 17 (COCO keypoints)
+            M = 1 (max persons)
+        method: Normalization method - 'hip_center' (default) or 'image_center'
+        img_width: Image width for image_center method (default: 3840 for AI Hub 4K)
+        img_height: Image height for image_center method (default: 2160 for AI Hub 4K)
+
+    Returns:
+        normalized_data: Normalized skeleton data with shape (C, T, V, M)
+            For hip_center: relative coordinates centered at hip, scaled by skeleton size
+            For image_center: x,y in [-0.5, 0.5], conf in [0, 1]
+
+    Example:
+        >>> # ST-GCN standard normalization
+        >>> data = np.random.rand(3, 60, 17, 1) * [3840, 2160, 1]
+        >>> normalized = normalize_skeleton(data, method='hip_center')
+        >>> # Hip is now at origin (0, 0)
+        >>> # Coordinates scaled by skeleton size
+
+        >>> # Legacy image center normalization
+        >>> normalized_legacy = normalize_skeleton(data, method='image_center')
+        >>> normalized_legacy[0].min(), normalized_legacy[0].max()  # x range
+        (-0.5, 0.5)
+    """
+    C, T, V, M = data.shape
+    assert C == 3, f"Expected 3 channels (x, y, conf), got {C}"
+    assert V == 17, f"Expected 17 COCO keypoints, got {V}"
+
+    if method == 'hip_center':
+        return _normalize_by_hip_center(data)
+    elif method == 'image_center':
+        return _normalize_by_image_center(data, img_width, img_height)
+    else:
+        raise ValueError(
+            f"Unknown normalization method: '{method}'. "
+            f"Use 'hip_center' (ST-GCN standard) or 'image_center' (legacy)."
+        )
+
+
+def denormalize_skeleton(
+    data: np.ndarray,
+    method: str = 'hip_center',
+    hip_center: Optional[np.ndarray] = None,
+    skeleton_size: Optional[float] = None,
+    img_width: int = 3840,
+    img_height: int = 2160
+) -> np.ndarray:
+    """
+    Denormalize skeleton coordinates back to original space.
+
+    NOTE: For hip_center method, denormalization requires storing the original
+    hip_center and skeleton_size values during normalization. This function is
+    primarily for visualization purposes.
+
+    For most ST-GCN training workflows, you don't need denormalization since:
+    - Training works directly on normalized coordinates
+    - Model predictions are classification labels (not coordinates)
+
+    Methods:
+    --------
+    1. 'hip_center': Requires hip_center and skeleton_size parameters
+    2. 'image_center': Only requires img_width and img_height
+
+    Args:
+        data: Normalized skeleton data (C, T, V, M)
+        method: Denormalization method - 'hip_center' or 'image_center'
+        hip_center: Original hip center position (2, T, 1, M) - required for hip_center method
+        skeleton_size: Original skeleton size (scalar) - required for hip_center method
+        img_width: Image width for image_center method (default: 3840)
+        img_height: Image height for image_center method (default: 2160)
+
+    Returns:
+        denormalized_data: Skeleton data in original coordinate space
+
+    Example:
+        >>> # Hip center denormalization (requires original values)
+        >>> data_original = np.random.rand(3, 60, 17, 1) * [3840, 2160, 1]
+        >>> normalized = normalize_skeleton(data_original, method='hip_center')
+        >>> # Note: In practice, you need to store hip_center and skeleton_size
+        >>> # during normalization for accurate denormalization
+
+        >>> # Image center denormalization (simpler)
+        >>> normalized = normalize_skeleton(data_original, method='image_center')
+        >>> denormalized = denormalize_skeleton(normalized, method='image_center')
+        >>> np.allclose(data_original[:2], denormalized[:2], atol=1.0)  # Within 1 pixel
+        True
+    """
+    C, T, V, M = data.shape
+    assert C == 3, f"Expected 3 channels (x, y, conf), got {C}"
+
+    if method == 'hip_center':
+        if hip_center is None or skeleton_size is None:
+            raise ValueError(
+                "hip_center denormalization requires 'hip_center' and 'skeleton_size' parameters. "
+                "These values must be saved during normalization. "
+                "For visualization without original values, consider using method='image_center'."
+            )
+        return _denormalize_by_hip_center(data, hip_center, skeleton_size)
+
+    elif method == 'image_center':
+        return _denormalize_by_image_center(data, img_width, img_height)
+
+    else:
+        raise ValueError(
+            f"Unknown denormalization method: '{method}'. "
+            f"Use 'hip_center' or 'image_center'."
+        )
+
+
+def _denormalize_by_hip_center(
+    data: np.ndarray,
+    hip_center: np.ndarray,
+    skeleton_size: float
+) -> np.ndarray:
+    """
+    Reverse hip center normalization.
+
+    Args:
+        data: Normalized skeleton data (C, T, V, M)
+        hip_center: Original hip center (2, T, 1, M) or (2,) for constant
+        skeleton_size: Original skeleton size (scalar)
+
+    Returns:
+        denormalized_data: (C, T, V, M) in original pixel coordinates
+    """
+    C, T, V, M = data.shape
+    denormalized_data = data.copy()
+
+    # Reverse scale and centering: x_original = x_normalized * skeleton_size + hip_center
+    denormalized_data[:2] = denormalized_data[:2] * skeleton_size + hip_center
+
+    # Confidence channel unchanged
+
+    return denormalized_data
+
+
+def _denormalize_by_image_center(
+    data: np.ndarray,
+    img_width: int = 3840,
+    img_height: int = 2160
+) -> np.ndarray:
+    """
+    Reverse image center normalization.
+
+    Args:
+        data: Normalized skeleton data (C, T, V, M) with x,y in [-0.5, 0.5]
+        img_width: Image width in pixels (default: 3840)
+        img_height: Image height in pixels (default: 2160)
+
+    Returns:
+        denormalized_data: (C, T, V, M) with x,y in pixel coordinates
+    """
+    C, T, V, M = data.shape
+    denormalized_data = data.copy()
+
+    # Denormalize x-coordinate: [-0.5, 0.5] -> [0, img_width]
+    denormalized_data[0] = (denormalized_data[0] + 0.5) * img_width
+
+    # Denormalize y-coordinate: [-0.5, 0.5] -> [0, img_height]
+    denormalized_data[1] = (denormalized_data[1] + 0.5) * img_height
+
+    # Confidence channel remains unchanged
+
+    return denormalized_data
+
+
+def test_augmentation():
+    """
+    Test augmentation functions and demonstrate their effects.
+
+    This function creates synthetic skeleton data and applies each augmentation
+    to verify correctness and visualize the transformations.
+    """
+    print("Skeleton Data Augmentation Test")
+    print("=" * 80)
+
+    # Create synthetic skeleton data (C, T, V, M)
+    C, T, V, M = 3, 60, 17, 1
+    np.random.seed(42)
+
+    # Generate synthetic data in pixel coordinates
+    data = np.random.rand(C, T, V, M)
+    data[0] *= 1920  # x in [0, 1920]
+    data[1] *= 1080  # y in [0, 1080]
+    data[2] = np.random.uniform(0.5, 1.0, (T, V, M))  # confidence in [0.5, 1.0]
+
+    print(f"\nOriginal data shape: {data.shape}")
+    print(f"Original x range: [{data[0].min():.2f}, {data[0].max():.2f}] pixels")
+    print(f"Original y range: [{data[1].min():.2f}, {data[1].max():.2f}] pixels")
+    print(f"Original confidence range: [{data[2].min():.3f}, {data[2].max():.3f}]")
+
+    # Test 1: Normalization
+    print("\n" + "-" * 80)
+    print("Test 1: Normalization")
+    print("-" * 80)
+    normalized = normalize_skeleton(data, img_width=1920, img_height=1080)
+    print(f"Normalized x range: [{normalized[0].min():.3f}, {normalized[0].max():.3f}]")
+    print(f"Normalized y range: [{normalized[1].min():.3f}, {normalized[1].max():.3f}]")
+    print(f"Normalized confidence range: [{normalized[2].min():.3f}, {normalized[2].max():.3f}]")
+
+    # Verify denormalization
+    denormalized = denormalize_skeleton(normalized, img_width=1920, img_height=1080)
+    reconstruction_error = np.abs(data - denormalized).max()
+    print(f"Denormalization reconstruction error: {reconstruction_error:.6f} pixels")
+
+    # Test 2: Horizontal Flip
+    print("\n" + "-" * 80)
+    print("Test 2: Horizontal Flip")
+    print("-" * 80)
+    np.random.seed(42)
+    flipped = augment_skeleton(normalized, prob=1.0)  # Force all augmentations
+    print(f"Original x (frame 0, keypoint 0): {normalized[0, 0, 0, 0]:.3f}")
+    print(f"After augmentation x: {flipped[0, 0, 0, 0]:.3f}")
+    print(f"X-coordinate sign flipped: {np.sign(normalized[0].mean()) != np.sign(flipped[0].mean())}")
+
+    # Test 3: Check left/right keypoint swapping
+    print("\n" + "-" * 80)
+    print("Test 3: Keypoint Pair Swapping (Horizontal Flip)")
+    print("-" * 80)
+    # Create data with distinctive values for left/right pairs
+    test_data = np.zeros((3, 60, 17, 1))
+    test_data[0, :, 5, 0] = 100   # left_shoulder x = 100
+    test_data[0, :, 6, 0] = -100  # right_shoulder x = -100
+    flipped_test = _horizontal_flip(test_data)
+    print(f"Original left_shoulder (idx 5) x: {test_data[0, 0, 5, 0]:.1f}")
+    print(f"Original right_shoulder (idx 6) x: {test_data[0, 0, 6, 0]:.1f}")
+    print(f"Flipped left_shoulder (idx 5) x: {flipped_test[0, 0, 5, 0]:.1f}")
+    print(f"Flipped right_shoulder (idx 6) x: {flipped_test[0, 0, 6, 0]:.1f}")
+    print(f"Swap successful: {flipped_test[0, 0, 5, 0] == 100 and flipped_test[0, 0, 6, 0] == -100}")
+
+    # Test 4: Gaussian Noise
+    print("\n" + "-" * 80)
+    print("Test 4: Gaussian Noise")
+    print("-" * 80)
+    np.random.seed(42)
+    noisy = _add_gaussian_noise(normalized, std=0.01)
+    noise_magnitude = np.abs(noisy[:2] - normalized[:2]).max()
+    confidence_unchanged = np.allclose(noisy[2], normalized[2])
+    print(f"Max noise magnitude (x,y): {noise_magnitude:.4f}")
+    print(f"Confidence channel unchanged: {confidence_unchanged}")
+
+    # Test 5: Temporal Crop and Resize
+    print("\n" + "-" * 80)
+    print("Test 5: Temporal Crop and Resize")
+    print("-" * 80)
+    np.random.seed(42)
+    cropped = _temporal_crop_resize(normalized, crop_ratio_range=(0.8, 1.0))
+    print(f"Original temporal length: {normalized.shape[1]}")
+    print(f"Cropped temporal length: {cropped.shape[1]}")
+    print(f"Shape preserved: {cropped.shape == normalized.shape}")
+
+    # Test 6: Full Augmentation Pipeline
+    print("\n" + "-" * 80)
+    print("Test 6: Full Augmentation Pipeline")
+    print("-" * 80)
+    np.random.seed(42)
+    augmented = augment_skeleton(normalized, prob=0.5)
+    print(f"Augmented shape: {augmented.shape}")
+    print(f"Augmented x range: [{augmented[0].min():.3f}, {augmented[0].max():.3f}]")
+    print(f"Augmented y range: [{augmented[1].min():.3f}, {augmented[1].max():.3f}]")
+    print(f"Augmented confidence range: [{augmented[2].min():.3f}, {augmented[2].max():.3f}]")
+
+    # Test 7: Augmentation Statistics (Run 100 times)
+    print("\n" + "-" * 80)
+    print("Test 7: Augmentation Statistics (100 runs with prob=0.5)")
+    print("-" * 80)
+    np.random.seed(42)
+    augmentation_counts = {"flip": 0, "noise": 0, "crop": 0}
+    num_runs = 100
+
+    for _ in range(num_runs):
+        original_copy = normalized.copy()
+        augmented = augment_skeleton(original_copy, prob=0.5)
+
+        # Detect which augmentations were applied (heuristics)
+        x_sign_changed = np.sign(augmented[0].mean()) != np.sign(normalized[0].mean())
+        noise_added = not np.allclose(augmented[:2], normalized[:2], atol=1e-4)
+        # Crop detection is harder, skip for now
+
+        if x_sign_changed:
+            augmentation_counts["flip"] += 1
+        if noise_added and not x_sign_changed:
+            augmentation_counts["noise"] += 1
+
+    print(f"Horizontal flip applied: {augmentation_counts['flip']}/{num_runs} times")
+    print(f"Gaussian noise applied: {augmentation_counts['noise']}/{num_runs} times")
+    print(f"Expected frequency (prob=0.5): ~50 times per augmentation")
+
+    print("\n" + "=" * 80)
+    print("All tests completed successfully")
+    print("=" * 80)
+
+
+if __name__ == "__main__":
+    test_augmentation()

models/__init__.py

@@ -0,0 +1 @@
+# Models package for HF Spaces deployment

models/pose_estimator.py

@@ -0,0 +1,150 @@
+"""
+YOLOv11-Pose 래퍼 클래스
+
+실시간 pose estimation을 위한 YOLOv11-Pose 모델 래퍼입니다.
+"""
+
+import logging
+from typing import Optional
+
+import numpy as np
+import torch
+from ultralytics import YOLO
+
+
+class PoseEstimator:
+    """YOLOv11-Pose 기반 포즈 추정기"""
+
+    def __init__(
+        self,
+        model_path: str = "yolo11m-pose.pt",
+        conf_threshold: float = 0.5,
+        imgsz: int = 640,
+        device: str = "cuda:0",
+        logger: Optional[logging.Logger] = None
+    ):
+        """
+        Args:
+            model_path: YOLOv11-Pose 모델 경로
+            conf_threshold: 감지 신뢰도 임계값
+            imgsz: 입력 이미지 크기
+            device: 디바이스 (cuda:0, cpu 등)
+            logger: 로거 인스턴스
+        """
+        self.device = torch.device(device if torch.cuda.is_available() else "cpu")
+        self.conf_threshold = conf_threshold
+        self.imgsz = imgsz
+        self.logger = logger or logging.getLogger(__name__)
+
+        # 모델 로드
+        self.logger.info(f"[Stage 1] YOLOv11-Pose 로드 중: {model_path}")
+        self.model = YOLO(model_path)
+        self.model.to(self.device)
+        self.logger.info(f"  - Confidence threshold: {conf_threshold}")
+        self.logger.info(f"  - Image size: {imgsz}")
+        self.logger.info(f"  - Device: {self.device}")
+
+    def extract(self, frame: np.ndarray, debug: bool = False) -> Optional[np.ndarray]:
+        """
+        프레임에서 pose keypoints 추출
+
+        Args:
+            frame: OpenCV 이미지 (H, W, 3)
+            debug: 디버그 로그 출력 여부
+
+        Returns:
+            keypoints: (17, 3) numpy array 또는 None (사람이 감지되지 않은 경우)
+                       각 keypoint는 (x, y, confidence) 형태
+        """
+        results = self.model.predict(
+            frame,
+            imgsz=self.imgsz,
+            conf=self.conf_threshold,
+            verbose=False
+        )
+
+        if results and len(results) > 0 and results[0].keypoints is not None:
+            keypoints_data = results[0].keypoints.data.cpu().numpy()
+
+            if len(keypoints_data) > 0:
+                # 가장 신뢰도 높은 사람 선택
+                if results[0].boxes is not None:
+                    confidences = results[0].boxes.conf.cpu().numpy()
+                    best_idx = np.argmax(confidences)
+                    keypoints = keypoints_data[best_idx]  # (17, 3)
+                else:
+                    keypoints = keypoints_data[0]
+
+                if debug:
+                    avg_conf = keypoints[:, 2].mean()
+                    self.logger.debug(f"  Pose detected: avg_conf={avg_conf:.3f}")
+
+                return keypoints
+
+        if debug:
+            self.logger.debug("  No pose detected")
+
+        return None
+
+    def extract_batch(
+        self, frames: list[np.ndarray] | np.ndarray, debug: bool = False
+    ) -> list[Optional[np.ndarray]]:
+        """
+        여러 프레임에서 배치로 pose keypoints 추출 (GPU 활용 극대화)
+
+        Args:
+            frames: OpenCV 이미지 리스트 [(H, W, 3), ...] 또는 numpy 배열 (N, H, W, C)
+            debug: 디버그 로그 출력 여부
+
+        Returns:
+            keypoints_list: [(17, 3) numpy array or None, ...] 각 프레임별 keypoints
+        """
+        # 빈 입력 체크 (리스트와 numpy 배열 모두 지원)
+        if isinstance(frames, np.ndarray):
+            if frames.size == 0:
+                return []
+            # numpy 배열을 리스트로 변환
+            frames = list(frames)
+        elif not frames:
+            return []
+
+        # YOLO 배치 추론
+        results = self.model.predict(
+            frames,
+            imgsz=self.imgsz,
+            conf=self.conf_threshold,
+            verbose=False
+        )
+
+        keypoints_list = []
+        for i, result in enumerate(results):
+            if result.keypoints is not None:
+                keypoints_data = result.keypoints.data.cpu().numpy()
+
+                if len(keypoints_data) > 0:
+                    # 가장 신뢰도 높은 사람 선택
+                    if result.boxes is not None:
+                        confidences = result.boxes.conf.cpu().numpy()
+                        best_idx = np.argmax(confidences)
+                        keypoints = keypoints_data[best_idx]  # (17, 3)
+                    else:
+                        keypoints = keypoints_data[0]
+
+                    if debug:
+                        avg_conf = keypoints[:, 2].mean()
+                        self.logger.debug(
+                            f"  Batch[{i}] Pose detected: avg_conf={avg_conf:.3f}"
+                        )
+
+                    keypoints_list.append(keypoints)
+                    continue
+
+            if debug:
+                self.logger.debug(f"  Batch[{i}] No pose detected")
+            keypoints_list.append(None)
+
+        return keypoints_list
+
+    def get_empty_keypoints(self) -> np.ndarray:
+        """빈 keypoints 배열 반환 (사람이 감지되지 않은 경우 사용)"""
+        return np.zeros((17, 3), dtype=np.float32)

models/stgcn_classifier.py

@@ -0,0 +1,183 @@
+"""
+ST-GCN 낙상 분류기 래퍼 클래스
+
+Spatial-Temporal Graph Convolutional Network을 이용한 낙상 분류기입니다.
+
+Note: HF Spaces 배포용으로 import 경로가 수정되었습니다.
+"""
+
+import logging
+from typing import Optional, Tuple
+
+import numpy as np
+import torch
+
+# HF Spaces 배포용 상대 import
+from augmentation import normalize_skeleton
+from stgcn.model import STGCN
+
+
+class STGCNClassifier:
+    """ST-GCN 기반 낙상 분류기"""
+
+    def __init__(
+        self,
+        checkpoint_path: str = "runs/stgcn_binary_exp2_fixed_graph/best_acc.pth",
+        fall_threshold: float = 0.7,
+        device: str = "cuda:0",
+        in_channels: int = 3,
+        num_classes: int = 2,
+        dropout: float = 0.5,
+        logger: Optional[logging.Logger] = None
+    ):
+        """
+        Args:
+            checkpoint_path: ST-GCN 체크포인트 경로
+            fall_threshold: 낙상 판정 신뢰도 임계값
+            device: 디바이스 (cuda:0, cpu 등)
+            in_channels: 입력 채널 수 (x, y, conf)
+            num_classes: 출력 클래스 수 (Fall, Non-Fall)
+            dropout: 드롭아웃 비율
+            logger: 로거 인스턴스
+        """
+        self.device = torch.device(device if torch.cuda.is_available() else "cpu")
+        self.fall_threshold = fall_threshold
+        self.logger = logger or logging.getLogger(__name__)
+
+        self.logger.info(f"[Stage 2] ST-GCN 로드 중: {checkpoint_path}")
+
+        # 모델 초기화
+        self.model = STGCN(
+            in_channels=in_channels,
+            num_classes=num_classes,
+            graph_cfg={},
+            edge_importance_weighting=True,
+            dropout=dropout
+        )
+
+        # 체크포인트 로드
+        checkpoint = torch.load(checkpoint_path, map_location=self.device)
+        self.model.load_state_dict(checkpoint['model_state_dict'])
+        self.model = self.model.to(self.device)
+        self.model.eval()
+
+        # 체크포인트 정보 로깅
+        epoch = checkpoint.get('epoch')
+        if epoch is not None:
+            self.logger.info(f"  - Checkpoint epoch: {epoch}")
+
+        metrics = checkpoint.get('metrics')
+        if isinstance(metrics, dict):
+            acc = metrics.get('accuracy')
+            f1 = metrics.get('f1')
+            if isinstance(acc, (int, float)):
+                self.logger.info(f"  - Accuracy: {acc:.4f}")
+            if isinstance(f1, (int, float)):
+                self.logger.info(f"  - F1 Score: {f1:.4f}")
+
+        self.logger.info(f"  - Fall threshold: {fall_threshold}")
+        self.logger.info(f"  - Device: {self.device}")
+
+    def predict(
+        self,
+        window: np.ndarray,
+        normalize: bool = True,
+        debug: bool = False
+    ) -> Tuple[int, float]:
+        """
+        ST-GCN으로 낙상 예측
+
+        Args:
+            window: (C, T, V, M) ST-GCN 입력 (C=3, T=60, V=17, M=1)
+            normalize: hip center 정규화 적용 여부
+            debug: 디버그 로그 출력 여부
+
+        Returns:
+            prediction: 0 (Non-Fall) or 1 (Fall)
+            confidence: 예측 신뢰도 (0.0-1.0)
+        """
+        # Normalize skeleton (hip center + skeleton size scaling)
+        if normalize:
+            window_input = normalize_skeleton(window, method='hip_center')
+        else:
+            window_input = window
+
+        # ST-GCN inference
+        window_tensor = torch.from_numpy(window_input).unsqueeze(0).to(self.device)  # (1, C, T, V, M)
+
+        with torch.no_grad():
+            outputs = self.model(window_tensor)
+            probs = torch.softmax(outputs, dim=1)
+            pred = torch.argmax(outputs, dim=1)
+
+            prediction = pred.item()
+            confidence = probs[0, prediction].item()
+
+        if debug:
+            self.logger.debug(f"  ST-GCN prediction: {prediction} (conf={confidence:.3f})")
+
+        return prediction, confidence
+
+    def predict_batch(
+        self,
+        windows: list[np.ndarray],
+        normalize: bool = True,
+        debug: bool = False
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        ST-GCN 배치 낙상 예측 (GPU 활용 극대화)
+
+        Args:
+            windows: [(C, T, V, M), ...] ST-GCN 입력 윈도우 리스트
+            normalize: hip center 정규화 적용 여부
+            debug: 디버그 로그 출력 여부
+
+        Returns:
+            predictions: (N,) numpy array of 0 (Non-Fall) or 1 (Fall)
+            confidences: (N,) numpy array of predicted class confidence (0.0-1.0)
+            fall_probs: (N,) numpy array of Fall class probability (0.0-1.0)
+        """
+        if not windows:
+            return np.array([]), np.array([]), np.array([])
+
+        # 정규화 및 배치 텐서 준비
+        batch_list = []
+        for window in windows:
+            if normalize:
+                window_input = normalize_skeleton(window, method='hip_center')
+            else:
+                window_input = window
+            batch_list.append(torch.from_numpy(window_input).float())
+
+        # 배치 텐서 생성 (N, C, T, V, M)
+        batch_tensor = torch.stack(batch_list).to(self.device)
+
+        with torch.no_grad():
+            outputs = self.model(batch_tensor)
+            probs = torch.softmax(outputs, dim=1)
+            preds = torch.argmax(outputs, dim=1)
+
+            predictions = preds.cpu().numpy()
+            # 각 예측에 대해 해당 클래스의 확률을 신뢰도로 사용
+            confidences = probs[torch.arange(len(preds)), preds].cpu().numpy()
+            # Fall 클래스(class 1)의 확률 - 그래프 표시용
+            fall_probs = probs[:, 1].cpu().numpy()
+
+        if debug:
+            for i, (pred, conf, fall_p) in enumerate(zip(predictions, confidences, fall_probs)):
+                self.logger.debug(f"  Batch[{i}] ST-GCN: pred={pred}, conf={conf:.3f}, fall_prob={fall_p:.3f}")
+
+        return predictions, confidences, fall_probs
+
+    def is_fall(self, prediction: int, confidence: float) -> bool:
+        """
+        낙상 여부 판정
+
+        Args:
+            prediction: 모델 예측 (0 or 1)
+            confidence: 예측 신뢰도
+
+        Returns:
+            True if fall detected with sufficient confidence
+        """
+        return prediction == 1 and confidence >= self.fall_threshold

stgcn/__init__.py

@@ -0,0 +1 @@
+# ST-GCN package for HF Spaces deployment

stgcn/graph.py

@@ -0,0 +1,291 @@
+"""
+COCO Skeleton Graph Definition for ST-GCN
+
+This module defines the skeleton graph structure for COCO 17-keypoint format
+used by YOLOv11-Pose. The graph represents spatial relationships between joints
+as an adjacency matrix for Spatial-Temporal Graph Convolutional Networks.
+
+COCO 17 Keypoints:
+0: nose, 1: left_eye, 2: right_eye, 3: left_ear, 4: right_ear
+5: left_shoulder, 6: right_shoulder, 7: left_elbow, 8: right_elbow
+9: left_wrist, 10: right_wrist, 11: left_hip, 12: right_hip
+13: left_knee, 14: right_knee, 15: left_ankle, 16: right_ankle
+
+References:
+- ST-GCN Paper: https://arxiv.org/abs/1801.07455
+- COCO Dataset: https://cocodataset.org/#keypoints-2020
+"""
+
+import numpy as np
+
+
+class Graph:
+    """COCO skeleton graph for ST-GCN."""
+
+    def __init__(self, labeling_mode='spatial'):
+        """
+        Initialize COCO skeleton graph.
+
+        Args:
+            labeling_mode: Partitioning strategy for skeleton graph
+                - 'spatial': Partition based on spatial distance from center
+                - 'uniform': All edges treated equally (baseline)
+        """
+        self.num_nodes = 17  # COCO keypoints
+        self.labeling_mode = labeling_mode
+
+        # Define skeleton connectivity (parent-child relationships)
+        self.edges = self._get_edges()
+
+        # Create adjacency matrix
+        self.A = self._create_adjacency_matrix()
+
+        # Get partitioning strategy
+        self.A_with_partitions = self._get_partitioned_adjacency()
+
+    def _get_edges(self):
+        """
+        Define COCO skeleton edges (connections between keypoints).
+
+        Returns:
+            List of tuples representing connected joints
+        """
+        # COCO skeleton structure (17 keypoints)
+        edges = [
+            # Head connections
+            (0, 1), (0, 2),  # nose to eyes
+            (1, 3), (2, 4),  # eyes to ears
+
+            # Torso connections
+            (5, 6),   # shoulders
+            (5, 11), (6, 12),  # shoulders to hips
+            (11, 12),  # hips
+
+            # Left arm
+            (5, 7), (7, 9),  # shoulder -> elbow -> wrist
+
+            # Right arm
+            (6, 8), (8, 10),  # shoulder -> elbow -> wrist
+
+            # Left leg
+            (11, 13), (13, 15),  # hip -> knee -> ankle
+
+            # Right leg
+            (12, 14), (14, 16),  # hip -> knee -> ankle
+        ]
+
+        return edges
+
+    def _create_adjacency_matrix(self):
+        """
+        Create adjacency matrix from skeleton edges.
+
+        Returns:
+            A: (V, V) adjacency matrix where V=17 (number of keypoints)
+        """
+        A = np.zeros((self.num_nodes, self.num_nodes))
+
+        # Add edges (bidirectional connections)
+        for i, j in self.edges:
+            A[i, j] = 1
+            A[j, i] = 1
+
+        # Add self-connections
+        A += np.eye(self.num_nodes)
+
+        return A
+
+    def _get_partitioned_adjacency(self):
+        """
+        Partition adjacency matrix based on labeling strategy.
+
+        For spatial labeling, partitions are:
+        - Partition 0: Self-connections (centripetal group)
+        - Partition 1: Joints closer to skeleton center (centripetal group)
+        - Partition 2: Joints farther from skeleton center (centrifugal group)
+
+        Returns:
+            A_partitioned: (num_partitions, V, V) stacked adjacency matrices
+        """
+        if self.labeling_mode == 'uniform':
+            # Uniform labeling: all edges treated equally
+            return self.A[np.newaxis, :, :]
+
+        elif self.labeling_mode == 'spatial':
+            # Spatial labeling: partition based on distance from center
+            # Center joint is defined as the midpoint between shoulders (joints 5, 6)
+            center_joints = [5, 6]  # Left and right shoulders
+
+            # Initialize partition matrices
+            A_partitions = []
+
+            # Partition 0: Self-connections
+            A_self = np.eye(self.num_nodes)
+            A_partitions.append(A_self)
+
+            # Partition 1: Centripetal (moving toward center)
+            # Partition 2: Centrifugal (moving away from center)
+            A_centripetal = np.zeros((self.num_nodes, self.num_nodes))
+            A_centrifugal = np.zeros((self.num_nodes, self.num_nodes))
+
+            # Compute distances from center for each joint
+            distances = self._compute_center_distances(center_joints)
+
+            # Classify edges based on distance change (both directions)
+            for i, j in self.edges:
+                if distances[j] < distances[i]:
+                    # Moving toward center (j is closer than i)
+                    A_centripetal[i, j] = 1
+                    # Reverse direction: moving away from center
+                    A_centrifugal[j, i] = 1
+                elif distances[j] > distances[i]:
+                    # Moving away from center (j is farther than i)
+                    A_centrifugal[i, j] = 1
+                    # Reverse direction: moving toward center
+                    A_centripetal[j, i] = 1
+                else:
+                    # Same distance: treat as centripetal for both directions
+                    A_centripetal[i, j] = 1
+                    A_centripetal[j, i] = 1
+
+            A_partitions.append(A_centripetal)
+            A_partitions.append(A_centrifugal)
+
+            # Stack partitions: (3, V, V)
+            A_partitioned = np.stack(A_partitions, axis=0)
+
+            return A_partitioned
+
+        else:
+            raise ValueError(f"Unknown labeling mode: {self.labeling_mode}")
+
+    def _compute_center_distances(self, center_joints):
+        """
+        Compute graph distance from center joints to all other joints.
+
+        Uses BFS to compute shortest path distance in graph.
+
+        Args:
+            center_joints: List of joint indices considered as center
+
+        Returns:
+            distances: (V,) array of distances from center
+        """
+        from collections import deque
+
+        distances = np.full(self.num_nodes, np.inf)
+        queue = deque()
+
+        # Initialize center joints with distance 0
+        for joint in center_joints:
+            distances[joint] = 0
+            queue.append(joint)
+
+        # BFS to compute distances
+        while queue:
+            current = queue.popleft()
+            current_dist = distances[current]
+
+            # Check all neighbors
+            for neighbor in range(self.num_nodes):
+                if self.A[current, neighbor] > 0 and neighbor != current:
+                    if distances[neighbor] > current_dist + 1:
+                        distances[neighbor] = current_dist + 1
+                        queue.append(neighbor)
+
+        return distances
+
+    def get_adjacency_matrix(self, normalize=True):
+        """
+        Get normalized adjacency matrix for ST-GCN.
+
+        Args:
+            normalize: Whether to apply symmetric normalization (D^-0.5 * A * D^-0.5)
+
+        Returns:
+            A_normalized: Normalized adjacency matrix
+        """
+        if self.labeling_mode == 'spatial':
+            # Return partitioned adjacency matrices
+            A = self.A_with_partitions
+
+            if normalize:
+                # Normalize each partition separately
+                A_normalized = []
+                for partition in A:
+                    A_norm = self._normalize_adjacency(partition)
+                    A_normalized.append(A_norm)
+                return np.stack(A_normalized, axis=0)
+            else:
+                return A
+
+        else:
+            # Return single adjacency matrix
+            A = self.A[np.newaxis, :, :]
+
+            if normalize:
+                A_norm = self._normalize_adjacency(A[0])
+                return A_norm[np.newaxis, :, :]
+            else:
+                return A
+
+    def _normalize_adjacency(self, A):
+        """
+        Apply symmetric normalization: D^-0.5 * A * D^-0.5
+
+        Args:
+            A: (V, V) adjacency matrix
+
+        Returns:
+            A_normalized: (V, V) normalized adjacency matrix
+        """
+        # Compute degree matrix
+        D = np.sum(A, axis=1)
+
+        # Avoid division by zero
+        D[D == 0] = 1
+
+        # Compute D^-0.5
+        D_inv_sqrt = np.power(D, -0.5)
+
+        # Apply normalization: D^-0.5 * A * D^-0.5
+        A_normalized = A * D_inv_sqrt[:, np.newaxis] * D_inv_sqrt[np.newaxis, :]
+
+        return A_normalized
+
+
+def get_coco_graph(labeling_mode='spatial'):
+    """
+    Convenience function to get COCO skeleton graph.
+
+    Args:
+        labeling_mode: Partitioning strategy ('spatial' or 'uniform')
+
+    Returns:
+        Graph object with COCO skeleton structure
+    """
+    return Graph(labeling_mode=labeling_mode)
+
+
+if __name__ == '__main__':
+    # Test graph construction
+    print("Testing COCO Skeleton Graph...")
+
+    # Test uniform labeling
+    graph_uniform = Graph(labeling_mode='uniform')
+    print(f"\nUniform labeling:")
+    print(f"  Adjacency shape: {graph_uniform.A.shape}")
+    print(f"  Partitions shape: {graph_uniform.A_with_partitions.shape}")
+    print(f"  Number of edges: {len(graph_uniform.edges)}")
+
+    # Test spatial labeling
+    graph_spatial = Graph(labeling_mode='spatial')
+    print(f"\nSpatial labeling:")
+    print(f"  Adjacency shape: {graph_spatial.A.shape}")
+    print(f"  Partitions shape: {graph_spatial.A_with_partitions.shape}")
+
+    # Get normalized adjacency
+    A_norm = graph_spatial.get_adjacency_matrix(normalize=True)
+    print(f"\nNormalized adjacency shape: {A_norm.shape}")
+
+    print("\nCOCO skeleton graph construction successful!")

stgcn/model.py

@@ -0,0 +1,391 @@
+"""
+ST-GCN Model for Fall Detection
+
+Spatial-Temporal Graph Convolutional Networks for skeleton-based action recognition.
+Adapted for binary fall detection (Fall vs Non-Fall) and multi-class fall type classification.
+
+References:
+- ST-GCN Paper: https://arxiv.org/abs/1801.07455
+- Official Implementation: https://github.com/yysijie/st-gcn
+- Fall Detection: Keskes & Noumeir (2021)
+
+Input Shape: (N, C, T, V, M)
+- N: Batch size
+- C: Number of channels (3: x, y, confidence)
+- T: Temporal dimension (number of frames)
+- V: Number of vertices (17 COCO keypoints)
+- M: Number of persons (1 for single-person scenarios)
+
+Output: Class logits for Fall/Non-Fall (binary) or BY/FY/SY/N (multi-class)
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from .graph import Graph
+
+
+class STGCNLayer(nn.Module):
+    """
+    Spatial-Temporal Graph Convolutional Layer.
+
+    Combines spatial graph convolution and temporal convolution.
+    """
+
+    def __init__(
+        self,
+        in_channels,
+        out_channels,
+        kernel_size,
+        stride=1,
+        dropout=0.5,
+        residual=True
+    ):
+        """
+        Initialize ST-GCN layer.
+
+        Args:
+            in_channels: Number of input channels
+            out_channels: Number of output channels
+            kernel_size: Tuple (temporal_kernel_size, spatial_kernel_size)
+            stride: Temporal stride for downsampling
+            dropout: Dropout probability
+            residual: Whether to use residual connection
+        """
+        super(STGCNLayer, self).__init__()
+
+        assert len(kernel_size) == 2, "Kernel size must be (temporal, spatial)"
+        assert kernel_size[0] % 2 == 1, "Temporal kernel size must be odd"
+
+        padding = ((kernel_size[0] - 1) // 2, 0)  # Temporal padding only
+
+        # Spatial graph convolution
+        self.gcn = SpatialGraphConv(
+            in_channels,
+            out_channels,
+            kernel_size[1]
+        )
+
+        # Temporal convolution
+        self.tcn = nn.Sequential(
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(
+                out_channels,
+                out_channels,
+                (kernel_size[0], 1),
+                (stride, 1),
+                padding,
+            ),
+            nn.BatchNorm2d(out_channels),
+            nn.Dropout(dropout, inplace=True),
+        )
+
+        # Residual connection
+        if not residual:
+            self.residual = lambda x: 0
+        elif (in_channels == out_channels) and (stride == 1):
+            self.residual = lambda x: x
+        else:
+            self.residual = nn.Sequential(
+                nn.Conv2d(
+                    in_channels,
+                    out_channels,
+                    kernel_size=1,
+                    stride=(stride, 1)
+                ),
+                nn.BatchNorm2d(out_channels),
+            )
+
+        self.relu = nn.ReLU(inplace=True)
+
+    def forward(self, x, A):
+        """
+        Forward pass.
+
+        Args:
+            x: Input tensor (N, C, T, V)
+            A: Adjacency matrix (K, V, V) where K is number of partitions
+
+        Returns:
+            Output tensor (N, C', T', V)
+        """
+        res = self.residual(x)
+        x = self.gcn(x, A)
+        x = self.tcn(x) + res
+
+        return self.relu(x)
+
+
+class SpatialGraphConv(nn.Module):
+    """
+    Spatial graph convolutional layer.
+
+    Applies graph convolution on skeleton graph using adjacency matrix.
+    """
+
+    def __init__(self, in_channels, out_channels, kernel_size, bias=True):
+        """
+        Initialize spatial graph convolution.
+
+        Args:
+            in_channels: Number of input channels
+            out_channels: Number of output channels
+            kernel_size: Number of adjacency matrix partitions (1 or 3)
+            bias: Whether to include bias term
+        """
+        super(SpatialGraphConv, self).__init__()
+
+        self.kernel_size = kernel_size
+
+        # Convolutional weights for each partition
+        self.conv = nn.Conv2d(
+            in_channels,
+            out_channels * kernel_size,
+            kernel_size=1,
+            bias=bias
+        )
+
+    def forward(self, x, A):
+        """
+        Forward pass.
+
+        Args:
+            x: Input tensor (N, C, T, V)
+            A: Adjacency matrix (K, V, V)
+
+        Returns:
+            Output tensor (N, C', T, V)
+        """
+        assert A.size(0) == self.kernel_size, \
+            f"Adjacency matrix size {A.size(0)} != kernel size {self.kernel_size}"
+
+        # Apply convolution
+        x = self.conv(x)  # (N, C'*K, T, V)
+
+        # Split channels for each partition
+        n, kc, t, v = x.size()
+        x = x.view(n, self.kernel_size, kc // self.kernel_size, t, v)  # (N, K, C', T, V)
+
+        # Apply graph convolution with each partition
+        # A: (K, V, V)
+        # x: (N, K, C', T, V)
+        x = torch.einsum('nkctv,kvw->nctw', x, A)  # (N, C', T, V)
+
+        return x.contiguous()
+
+
+class STGCN(nn.Module):
+    """
+    ST-GCN model for fall detection.
+
+    Architecture:
+    - Input: (N, 3, 60, 17, 1) - batch, channels, frames, joints, persons
+    - ST-GCN layers: Extract spatial-temporal features
+    - Global pooling: Aggregate features across time and space
+    - FC layers: Classification (binary or multi-class)
+    """
+
+    def __init__(
+        self,
+        num_classes=2,
+        in_channels=3,
+        edge_importance_weighting=True,
+        graph_cfg=None,
+        dropout=0.5,
+        **kwargs
+    ):
+        """
+        Initialize ST-GCN model.
+
+        Args:
+            num_classes: Number of output classes (2 for binary, 4 for multi-class)
+            in_channels: Number of input channels (3: x, y, confidence)
+            edge_importance_weighting: Whether to learn edge importance weights
+            graph_cfg: Graph configuration (default: spatial labeling)
+            dropout: Dropout probability
+        """
+        super(STGCN, self).__init__()
+
+        # Load graph
+        if graph_cfg is None:
+            graph_cfg = {'labeling_mode': 'spatial'}
+
+        self.graph = Graph(**graph_cfg)
+
+        # Get adjacency matrix (K, V, V) where K=3 for spatial labeling
+        A = torch.tensor(
+            self.graph.get_adjacency_matrix(normalize=True),
+            dtype=torch.float32,
+            requires_grad=False
+        )
+        self.register_buffer('A', A)
+
+        # Number of adjacency matrix partitions
+        spatial_kernel_size = A.size(0)  # 3 for spatial labeling
+
+        # Temporal kernel size (odd numbers for symmetric padding)
+        temporal_kernel_size = 9
+
+        # Build ST-GCN layers
+        kernel_size = (temporal_kernel_size, spatial_kernel_size)
+
+        # Layer configurations: (in_channels, out_channels, stride)
+        self.st_gcn_networks = nn.ModuleList((
+            STGCNLayer(in_channels, 64, kernel_size, 1, dropout, residual=False),
+            STGCNLayer(64, 64, kernel_size, 1, dropout),
+            STGCNLayer(64, 64, kernel_size, 1, dropout),
+            STGCNLayer(64, 64, kernel_size, 1, dropout),
+            STGCNLayer(64, 128, kernel_size, 2, dropout),
+            STGCNLayer(128, 128, kernel_size, 1, dropout),
+            STGCNLayer(128, 128, kernel_size, 1, dropout),
+            STGCNLayer(128, 256, kernel_size, 2, dropout),
+            STGCNLayer(256, 256, kernel_size, 1, dropout),
+            STGCNLayer(256, 256, kernel_size, 1, dropout),
+        ))
+
+        # Edge importance weighting
+        if edge_importance_weighting:
+            self.edge_importance = nn.ParameterList([
+                nn.Parameter(torch.ones(self.A.size()))
+                for _ in self.st_gcn_networks
+            ])
+        else:
+            self.edge_importance = [1] * len(self.st_gcn_networks)
+
+        # Fully connected layer for classification
+        self.fcn = nn.Conv2d(256, num_classes, kernel_size=1)
+
+    def forward(self, x):
+        """
+        Forward pass.
+
+        Args:
+            x: Input tensor (N, C, T, V, M)
+                - N: Batch size
+                - C: Number of channels (3)
+                - T: Number of frames (60)
+                - V: Number of joints (17)
+                - M: Number of persons (1)
+
+        Returns:
+            Output logits (N, num_classes)
+        """
+        # Reshape input: (N, C, T, V, M) -> (N*M, C, T, V)
+        N, C, T, V, M = x.size()
+        x = x.permute(0, 4, 1, 2, 3).contiguous()  # (N, M, C, T, V)
+        x = x.view(N * M, C, T, V)  # (N*M, C, T, V)
+
+        # Forward through ST-GCN layers
+        for gcn, importance in zip(self.st_gcn_networks, self.edge_importance):
+            x = gcn(x, self.A * importance)
+
+        # Global pooling: (N*M, C, T, V) -> (N*M, C)
+        x = F.avg_pool2d(x, x.size()[2:])  # (N*M, C, 1, 1)
+        x = x.view(N, M, -1, 1, 1).mean(dim=1)  # Average across persons: (N, C, 1, 1)
+
+        # Classification
+        x = self.fcn(x)  # (N, num_classes, 1, 1)
+        x = x.view(x.size(0), -1)  # (N, num_classes)
+
+        return x
+
+    def extract_features(self, x):
+        """
+        Extract features before classification layer.
+
+        Args:
+            x: Input tensor (N, C, T, V, M)
+
+        Returns:
+            Feature tensor (N, 256)
+        """
+        # Reshape input
+        N, C, T, V, M = x.size()
+        x = x.permute(0, 4, 1, 2, 3).contiguous()
+        x = x.view(N * M, C, T, V)
+
+        # Forward through ST-GCN layers
+        for gcn, importance in zip(self.st_gcn_networks, self.edge_importance):
+            x = gcn(x, self.A * importance)
+
+        # Global pooling
+        x = F.avg_pool2d(x, x.size()[2:])
+        x = x.view(N, M, -1).mean(dim=1)  # (N, 256)
+
+        return x
+
+
+def stgcn_binary(pretrained=False, **kwargs):
+    """
+    ST-GCN for binary fall detection (Fall vs Non-Fall).
+
+    Args:
+        pretrained: Whether to load pretrained weights (not implemented)
+        **kwargs: Additional model arguments
+
+    Returns:
+        ST-GCN model
+    """
+    model = STGCN(num_classes=2, **kwargs)
+
+    if pretrained:
+        raise NotImplementedError("Pretrained weights not available")
+
+    return model
+
+
+def stgcn_multiclass(pretrained=False, **kwargs):
+    """
+    ST-GCN for multi-class fall detection (BY/FY/SY/N).
+
+    Args:
+        pretrained: Whether to load pretrained weights (not implemented)
+        **kwargs: Additional model arguments
+
+    Returns:
+        ST-GCN model
+    """
+    model = STGCN(num_classes=4, **kwargs)
+
+    if pretrained:
+        raise NotImplementedError("Pretrained weights not available")
+
+    return model
+
+
+if __name__ == '__main__':
+    # Test model construction
+    print("Testing ST-GCN Model...")
+
+    # Binary classification
+    model_binary = stgcn_binary()
+    print(f"\nBinary ST-GCN:")
+    print(f"  Parameters: {sum(p.numel() for p in model_binary.parameters()):,}")
+    print(f"  Trainable: {sum(p.numel() for p in model_binary.parameters() if p.requires_grad):,}")
+
+    # Multi-class classification
+    model_multiclass = stgcn_multiclass()
+    print(f"\nMulti-class ST-GCN:")
+    print(f"  Parameters: {sum(p.numel() for p in model_multiclass.parameters()):,}")
+
+    # Test forward pass
+    batch_size = 4
+    input_tensor = torch.randn(batch_size, 3, 60, 17, 1)
+    print(f"\nInput shape: {input_tensor.shape}")
+
+    # Binary output
+    output_binary = model_binary(input_tensor)
+    print(f"Binary output shape: {output_binary.shape}")
+    print(f"Binary output: {output_binary}")
+
+    # Multi-class output
+    output_multiclass = model_multiclass(input_tensor)
+    print(f"Multi-class output shape: {output_multiclass.shape}")
+
+    # Feature extraction
+    features = model_binary.extract_features(input_tensor)
+    print(f"Feature shape: {features.shape}")
+
+    print("\nST-GCN model construction successful!")

visualization.py

@@ -0,0 +1,973 @@
+"""
+Real-time Fall Detection Visualization Module
+
+이 모듈은 실시간 낙상 감지 파이프라인의 시각화 기능을 제공합니다.
+COCO 17 keypoints 스켈레톤 렌더링, 예측 결과 오버레이, 성능 메트릭 표시 등을 포함합니다.
+
+주요 기능:
+- COCO 17 keypoints 스켈레톤 렌더링
+- Bounding box 렌더링
+- Fall/Non-Fall 라벨 + 신뢰도 표시
+- FPS/Latency 실시간 표시
+- 색상 코딩 (Fall: 빨강, Non-Fall: 초록)
+
+최적화 (Issue #56):
+- NumPy 벡터화로 cv2.circle()/cv2.line() 루프 대체
+- morphological dilation으로 keypoint 원 그리기 (30배 속도 향상)
+- cv2.polylines()로 skeleton 선 일괄 그리기
+- 주요 keypoint만 표시 옵션 (--viz-keypoints major)
+- 출력 해상도 조절 옵션 (--viz-scale 0.5)
+
+Reference:
+- COCO Keypoints: https://cocodataset.org/#keypoints-2017
+"""
+
+import cv2
+import numpy as np
+from typing import Tuple, Optional, List, Literal
+
+
+# COCO 17 keypoints 인덱스
+COCO_KEYPOINT_NAMES = [
+    'nose',           # 0
+    'left_eye',       # 1
+    'right_eye',      # 2
+    'left_ear',       # 3
+    'right_ear',      # 4
+    'left_shoulder',  # 5
+    'right_shoulder', # 6
+    'left_elbow',     # 7
+    'right_elbow',    # 8
+    'left_wrist',     # 9
+    'right_wrist',    # 10
+    'left_hip',       # 11
+    'right_hip',      # 12
+    'left_knee',      # 13
+    'right_knee',     # 14
+    'left_ankle',     # 15
+    'right_ankle',    # 16
+]
+
+# COCO 스켈레톤 연결 정의 (뼈대 구조)
+COCO_SKELETON = [
+    # 얼굴
+    (0, 1),   # nose -> left_eye
+    (0, 2),   # nose -> right_eye
+    (1, 3),   # left_eye -> left_ear
+    (2, 4),   # right_eye -> right_ear
+
+    # 상체
+    (0, 5),   # nose -> left_shoulder
+    (0, 6),   # nose -> right_shoulder
+    (5, 6),   # left_shoulder <-> right_shoulder
+
+    # 왼팔
+    (5, 7),   # left_shoulder -> left_elbow
+    (7, 9),   # left_elbow -> left_wrist
+
+    # 오른팔
+    (6, 8),   # right_shoulder -> right_elbow
+    (8, 10),  # right_elbow -> right_wrist
+
+    # 몸통
+    (5, 11),  # left_shoulder -> left_hip
+    (6, 12),  # right_shoulder -> right_hip
+    (11, 12), # left_hip <-> right_hip
+
+    # 왼다리
+    (11, 13), # left_hip -> left_knee
+    (13, 15), # left_knee -> left_ankle
+
+    # 오른다리
+    (12, 14), # right_hip -> right_knee
+    (14, 16), # right_knee -> right_ankle
+]
+
+# 신체 부위별 색상 정의 (BGR 포맷)
+BODY_PART_COLORS = {
+    'face': (0, 255, 255),        # 노란색
+    'left_arm': (255, 0, 180),    # 분홍색
+    'right_arm': (0, 165, 255),   # 오렌지색
+    'torso': (255, 150, 0),       # 파란색
+    'left_leg': (0, 0, 255),      # 빨간색
+    'right_leg': (180, 0, 255),   # 보라색
+}
+
+# 각 스켈레톤 연결에 대한 신체 부위 매핑
+SKELETON_PART_MAPPING = [
+    'face',      # (0, 1) nose -> left_eye
+    'face',      # (0, 2) nose -> right_eye
+    'face',      # (1, 3) left_eye -> left_ear
+    'face',      # (2, 4) right_eye -> right_ear
+    'face',      # (0, 5) nose -> left_shoulder
+    'face',      # (0, 6) nose -> right_shoulder
+    'torso',     # (5, 6) left_shoulder <-> right_shoulder
+    'left_arm',  # (5, 7) left_shoulder -> left_elbow
+    'left_arm',  # (7, 9) left_elbow -> left_wrist
+    'right_arm', # (6, 8) right_shoulder -> right_elbow
+    'right_arm', # (8, 10) right_elbow -> right_wrist
+    'torso',     # (5, 11) left_shoulder -> left_hip
+    'torso',     # (6, 12) right_shoulder -> right_hip
+    'torso',     # (11, 12) left_hip <-> right_hip
+    'left_leg',  # (11, 13) left_hip -> left_knee
+    'left_leg',  # (13, 15) left_knee -> left_ankle
+    'right_leg', # (12, 14) right_hip -> right_knee
+    'right_leg', # (14, 16) right_knee -> right_ankle
+]
+
+# 예측 결과 색상 정의
+PREDICTION_COLORS = {
+    'Fall': (0, 0, 255),      # 빨강
+    'Non-Fall': (0, 255, 0),  # 초록
+}
+
+# 주요 keypoint 인덱스 (9개: 코, 어깨, 엉덩이, 무릎, 발목)
+# 낙상 감지에 중요한 신체 부위만 선택
+MAJOR_KEYPOINT_INDICES = [
+    0,   # nose - 머리 위치
+    5,   # left_shoulder
+    6,   # right_shoulder
+    11,  # left_hip
+    12,  # right_hip
+    13,  # left_knee
+    14,  # right_knee
+    15,  # left_ankle
+    16,  # right_ankle
+]
+
+# 주요 keypoint용 skeleton 연결 (8개 연결)
+MAJOR_SKELETON = [
+    (5, 6),    # left_shoulder <-> right_shoulder
+    (5, 11),   # left_shoulder -> left_hip
+    (6, 12),   # right_shoulder -> right_hip
+    (11, 12),  # left_hip <-> right_hip
+    (11, 13),  # left_hip -> left_knee
+    (12, 14),  # right_hip -> right_knee
+    (13, 15),  # left_knee -> left_ankle
+    (14, 16),  # right_knee -> right_ankle
+]
+
+# 주요 skeleton 신체 부위 매핑
+MAJOR_SKELETON_PART_MAPPING = [
+    'torso',     # (5, 6)
+    'torso',     # (5, 11)
+    'torso',     # (6, 12)
+    'torso',     # (11, 12)
+    'left_leg',  # (11, 13)
+    'right_leg', # (12, 14)
+    'left_leg',  # (13, 15)
+    'right_leg', # (14, 16)
+]
+
+# Morphological dilation용 커널 캐시 (동일 크기 재사용)
+_KERNEL_CACHE = {}
+
+
+def draw_skeleton(
+    frame: np.ndarray,
+    keypoints: np.ndarray,
+    color: Tuple[int, int, int] = (0, 255, 0),
+    thickness: int = 2,
+    conf_threshold: float = 0.5,
+    keypoint_radius: int = 4,
+    use_body_part_colors: bool = True
+) -> np.ndarray:
+    """
+    COCO 17 keypoints 스켈레톤 렌더링
+
+    Args:
+        frame: OpenCV 이미지 (H, W, 3) BGR 포맷
+        keypoints: (17, 3) numpy array - (x, y, conf)
+        color: BGR 색상 (use_body_part_colors=False일 때 사용)
+        thickness: 선 두께
+        conf_threshold: 최소 신뢰도 임계값 (이 값 이하는 그리지 않음)
+        keypoint_radius: 키포인트 원의 반지름
+        use_body_part_colors: True면 신체 부위별 색상 사용, False면 단일 색상 사용
+
+    Returns:
+        frame: 스켈레톤이 렌더링된 이미지
+    """
+    if keypoints.shape != (17, 3):
+        raise ValueError(f"Expected keypoints shape (17, 3), got {keypoints.shape}")
+
+    frame = frame.copy()
+
+    # 1. 스켈레톤 연결선 그리기
+    for i, (start_idx, end_idx) in enumerate(COCO_SKELETON):
+        x1, y1, conf1 = keypoints[start_idx]
+        x2, y2, conf2 = keypoints[end_idx]
+
+        # 두 키포인트 모두 신뢰도 임계값을 넘어야 선을 그림
+        if conf1 > conf_threshold and conf2 > conf_threshold:
+            # 신체 부위별 색상 또는 단일 색상 선택
+            if use_body_part_colors:
+                part_name = SKELETON_PART_MAPPING[i]
+                line_color = BODY_PART_COLORS[part_name]
+            else:
+                line_color = color
+
+            # 선 그리기
+            pt1 = (int(x1), int(y1))
+            pt2 = (int(x2), int(y2))
+            cv2.line(frame, pt1, pt2, line_color, thickness, cv2.LINE_AA)
+
+    # 2. 키포인트 원 그리기 (선 위에 그려서 더 눈에 띄게)
+    for i, (x, y, conf) in enumerate(keypoints):
+        if conf > conf_threshold:
+            center = (int(x), int(y))
+
+            # 외곽 흰색 테두리
+            cv2.circle(frame, center, keypoint_radius + 2, (255, 255, 255), -1, cv2.LINE_AA)
+
+            # 내부 색상 원 (밝은 하늘색)
+            cv2.circle(frame, center, keypoint_radius, (255, 200, 0), -1, cv2.LINE_AA)
+
+    return frame
+
+
+def _get_ellipse_kernel(radius: int) -> np.ndarray:
+    """
+    캐시된 ellipse 커널 반환 (morphological dilation용)
+
+    Args:
+        radius: 커널 반지름
+
+    Returns:
+        ellipse 커널
+    """
+    if radius not in _KERNEL_CACHE:
+        kernel_size = radius * 2 + 1
+        _KERNEL_CACHE[radius] = cv2.getStructuringElement(
+            cv2.MORPH_ELLIPSE, (kernel_size, kernel_size)
+        )
+    return _KERNEL_CACHE[radius]
+
+
+def draw_skeleton_vectorized(
+    frame: np.ndarray,
+    keypoints: np.ndarray,
+    conf_threshold: float = 0.5,
+    keypoint_radius: int = 4,
+    thickness: int = 2,
+    keypoint_mode: Literal['all', 'major'] = 'all',
+    use_body_part_colors: bool = True,
+    keypoint_color: Tuple[int, int, int] = (255, 200, 0),
+    border_color: Tuple[int, int, int] = (255, 255, 255)
+) -> np.ndarray:
+    """
+    최적화된 skeleton 렌더링
+
+    최적화 전략:
+    - cv2.polylines()로 skeleton 선 일괄 처리 (색상별 그룹화)
+    - 주요 keypoint만 표시 옵션으로 그리기 횟수 감소 (17개 -> 9개)
+    - Anti-aliasing 비활성화 옵션 (cv2.LINE_AA -> cv2.LINE_8)
+
+    Note: morphological dilation은 4K 해상도에서 전체 이미지 마스크 생성으로
+    오히려 느려지므로, keypoint 원은 기존 cv2.circle() 유지
+
+    Args:
+        frame: OpenCV 이미지 (H, W, 3) BGR 포맷
+        keypoints: (17, 3) numpy array - (x, y, conf)
+        conf_threshold: 최소 신뢰도 임계값 (이 값 이하는 그리지 않음)
+        keypoint_radius: 키포인트 원의 반지름
+        thickness: skeleton 선 두께
+        keypoint_mode: 'all'=전체 17개, 'major'=주요 9개만 표시
+        use_body_part_colors: True면 신체 부위별 색상 사용
+        keypoint_color: keypoint 원 색상 (BGR)
+        border_color: keypoint 테두리 색상 (BGR)
+
+    Returns:
+        frame: 스켈레톤이 렌더링된 이미지
+    """
+    if keypoints.shape != (17, 3):
+        raise ValueError(f"Expected keypoints shape (17, 3), got {keypoints.shape}")
+
+    result = frame.copy()
+
+    # keypoint 모드에 따른 인덱스/skeleton 선택
+    if keypoint_mode == 'major':
+        kpt_indices = MAJOR_KEYPOINT_INDICES
+        skeleton = MAJOR_SKELETON
+        skeleton_parts = MAJOR_SKELETON_PART_MAPPING
+    else:
+        kpt_indices = list(range(17))
+        skeleton = COCO_SKELETON
+        skeleton_parts = SKELETON_PART_MAPPING
+
+    # 유효한 keypoints 필터링 (confidence > threshold)
+    valid_mask = keypoints[:, 2] > conf_threshold
+    if keypoint_mode == 'major':
+        # 주요 keypoint 인덱스만 고려
+        major_mask = np.zeros(17, dtype=bool)
+        major_mask[kpt_indices] = True
+        valid_mask = valid_mask & major_mask
+
+    valid_indices = np.where(valid_mask)[0]
+
+    if len(valid_indices) == 0:
+        return result
+
+    # 1. Skeleton 선 그리기 (cv2.polylines 사용 - 배치 처리)
+    if use_body_part_colors:
+        # 색상별로 선 그룹화
+        color_groups = {}
+        for i, (start_idx, end_idx) in enumerate(skeleton):
+            if valid_mask[start_idx] and valid_mask[end_idx]:
+                part_name = skeleton_parts[i]
+                color = BODY_PART_COLORS[part_name]
+                if color not in color_groups:
+                    color_groups[color] = []
+                pt1 = (int(keypoints[start_idx, 0]), int(keypoints[start_idx, 1]))
+                pt2 = (int(keypoints[end_idx, 0]), int(keypoints[end_idx, 1]))
+                color_groups[color].append(np.array([pt1, pt2], dtype=np.int32))
+
+        # 색상별로 일괄 그리기
+        for color, lines in color_groups.items():
+            if lines:
+                cv2.polylines(result, lines, isClosed=False, color=color,
+                             thickness=thickness, lineType=cv2.LINE_AA)
+    else:
+        # 단일 색상으로 모든 선 그리기
+        lines = []
+        for start_idx, end_idx in skeleton:
+            if valid_mask[start_idx] and valid_mask[end_idx]:
+                pt1 = (int(keypoints[start_idx, 0]), int(keypoints[start_idx, 1]))
+                pt2 = (int(keypoints[end_idx, 0]), int(keypoints[end_idx, 1]))
+                lines.append(np.array([pt1, pt2], dtype=np.int32))
+
+        if lines:
+            cv2.polylines(result, lines, isClosed=False, color=(255, 255, 255),
+                         thickness=thickness, lineType=cv2.LINE_AA)
+
+    # 2. Keypoint 원 그리기 (cv2.circle 사용 - 개수가 적어 루프가 효율적)
+    for idx in valid_indices:
+        x, y = int(keypoints[idx, 0]), int(keypoints[idx, 1])
+        center = (x, y)
+
+        # 외곽 테두리
+        cv2.circle(result, center, keypoint_radius + 2, border_color, -1, cv2.LINE_AA)
+
+        # 내부 색상 원
+        cv2.circle(result, center, keypoint_radius, keypoint_color, -1, cv2.LINE_AA)
+
+    return result
+
+
+def draw_prediction(
+    frame: np.ndarray,
+    prediction: str,
+    confidence: float,
+    bbox: Optional[Tuple[int, int, int, int]] = None,
+    fps: Optional[float] = None,
+    latency: Optional[float] = None,
+    position: str = 'top-left'
+) -> np.ndarray:
+    """
+    예측 결과 오버레이 렌더링
+
+    Args:
+        frame: OpenCV 이미지
+        prediction: 'Fall' 또는 'Non-Fall'
+        confidence: 신뢰도 (0.0-1.0)
+        bbox: (x1, y1, x2, y2) 바운딩 박스 (선택)
+        fps: FPS 값 (선택)
+        latency: Latency (ms) (선택)
+        position: 텍스트 위치 ('top-left', 'top-right', 'bottom-left', 'bottom-right')
+
+    Returns:
+        frame: 렌더링된 이미지
+    """
+    frame = frame.copy()
+    h, w = frame.shape[:2]
+
+    # 1. 바운딩 박스 그리기 (있을 경우)
+    if bbox is not None:
+        x1, y1, x2, y2 = bbox
+        pred_color = PREDICTION_COLORS.get(prediction, (255, 255, 255))
+
+        # 박스 두께는 Fall일 때 더 두껍게
+        box_thickness = 4 if prediction == 'Fall' else 2
+        cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), pred_color, box_thickness)
+
+    # 2. 예측 라벨 + 신뢰도 텍스트 준비
+    if confidence is not None:
+        pred_text = f"{prediction}: {confidence:.2%}"
+    else:
+        pred_text = f"{prediction}"
+    pred_color = PREDICTION_COLORS.get(prediction, (255, 255, 255))
+
+    # 3. FPS/Latency 텍스트 준비 (있을 경우)
+    info_texts = []
+    if fps is not None:
+        info_texts.append(f"FPS: {fps:.1f}")
+    if latency is not None:
+        info_texts.append(f"Latency: {latency:.1f}ms")
+
+    # 4. 텍스트 위치 계산
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    font_scale = 0.8
+    font_thickness = 2
+    padding = 10
+    line_height = 35
+
+    # 예측 텍스트 크기
+    (pred_w, pred_h), _ = cv2.getTextSize(pred_text, font, font_scale, font_thickness)
+
+    # 위치별 좌표 계산
+    if position == 'top-left':
+        pred_x, pred_y = padding, padding + pred_h
+    elif position == 'top-right':
+        pred_x, pred_y = w - pred_w - padding, padding + pred_h
+    elif position == 'bottom-left':
+        pred_x, pred_y = padding, h - padding - (len(info_texts) * line_height) - 10
+    elif position == 'bottom-right':
+        pred_x, pred_y = w - pred_w - padding, h - padding - (len(info_texts) * line_height) - 10
+    else:
+        raise ValueError(f"Unknown position: {position}")
+
+    # 5. 배경 박스 그리기 (가독성 향상)
+    bg_x1 = pred_x - 5
+    bg_y1 = pred_y - pred_h - 5
+    bg_x2 = pred_x + pred_w + 5
+    bg_y2 = pred_y + 5
+
+    # 반투명 검은 배경
+    overlay = frame.copy()
+    cv2.rectangle(overlay, (bg_x1, bg_y1), (bg_x2, bg_y2), (0, 0, 0), -1)
+    cv2.addWeighted(overlay, 0.6, frame, 0.4, 0, frame)
+
+    # 6. 예측 텍스트 그리기
+    cv2.putText(frame, pred_text, (pred_x, pred_y), font, font_scale, pred_color, font_thickness, cv2.LINE_AA)
+
+    # 7. FPS/Latency 정보 그리기 (있을 경우)
+    if info_texts:
+        info_y = pred_y + line_height
+        for info_text in info_texts:
+            (info_w, info_h), _ = cv2.getTextSize(info_text, font, font_scale, font_thickness)
+
+            # 배경 박스
+            bg_x1 = pred_x - 5
+            bg_y1 = info_y - info_h - 5
+            bg_x2 = pred_x + info_w + 5
+            bg_y2 = info_y + 5
+
+            overlay = frame.copy()
+            cv2.rectangle(overlay, (bg_x1, bg_y1), (bg_x2, bg_y2), (0, 0, 0), -1)
+            cv2.addWeighted(overlay, 0.6, frame, 0.4, 0, frame)
+
+            # 텍스트 (흰색)
+            cv2.putText(frame, info_text, (pred_x, info_y), font, font_scale, (255, 255, 255), font_thickness, cv2.LINE_AA)
+            info_y += line_height
+
+    return frame
+
+
+def create_info_panel(
+    frame_width: int,
+    frame_height: int,
+    fps: float,
+    latency: float,
+    prediction: str,
+    confidence: float,
+    panel_height: int = 80,
+    position: str = 'top'
+) -> np.ndarray:
+    """
+    정보 패널 생성 (상단 또는 하단 오버레이)
+
+    Args:
+        frame_width: 프레임 너비
+        frame_height: 프레임 높이
+        fps: FPS 값
+        latency: Latency (ms)
+        prediction: 'Fall' 또는 'Non-Fall'
+        confidence: 신뢰도 (0.0-1.0)
+        panel_height: 패널 높이
+        position: 패널 위치 ('top' 또는 'bottom')
+
+    Returns:
+        panel: 정보 패널 이미지 (panel_height, frame_width, 3)
+    """
+    # 패널 생성 (검은 배경)
+    panel = np.zeros((panel_height, frame_width, 3), dtype=np.uint8)
+
+    # 예측 결과 색상
+    pred_color = PREDICTION_COLORS.get(prediction, (255, 255, 255))
+
+    # 폰트 설정
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    font_scale = 0.7
+    font_thickness = 2
+
+    # 텍스트 준비
+    pred_text = f"{prediction}: {confidence:.1%}" if confidence is not None else f"{prediction}"
+    texts = [
+        (f"FPS: {fps:.1f}", (255, 255, 255)),
+        (f"Latency: {latency:.1f}ms", (255, 255, 255)),
+        (pred_text, pred_color),
+    ]
+
+    # 텍스트 균등 배치
+    section_width = frame_width // len(texts)
+    y_pos = panel_height // 2 + 10
+
+    for i, (text, color) in enumerate(texts):
+        # 텍스트 크기 계산
+        (text_w, text_h), _ = cv2.getTextSize(text, font, font_scale, font_thickness)
+
+        # 중앙 정렬
+        x_pos = (i * section_width) + (section_width - text_w) // 2
+
+        # 텍스트 그리기
+        cv2.putText(panel, text, (x_pos, y_pos), font, font_scale, color, font_thickness, cv2.LINE_AA)
+
+    # 구분선 그리기
+    for i in range(1, len(texts)):
+        x_pos = i * section_width
+        cv2.line(panel, (x_pos, 10), (x_pos, panel_height - 10), (80, 80, 80), 1)
+
+    return panel
+
+
+def add_info_panel_to_frame(
+    frame: np.ndarray,
+    fps: float,
+    latency: float,
+    prediction: str,
+    confidence: float,
+    panel_height: int = 80,
+    position: str = 'top'
+) -> np.ndarray:
+    """
+    프레임에 정보 패널 추가
+
+    Args:
+        frame: 원본 프레임
+        fps: FPS 값
+        latency: Latency (ms)
+        prediction: 'Fall' 또는 'Non-Fall'
+        confidence: 신뢰도
+        panel_height: 패널 높이
+        position: 패널 위치 ('top' 또는 'bottom')
+
+    Returns:
+        result: 패널이 추가된 프레임
+    """
+    h, w = frame.shape[:2]
+
+    # 정보 패널 생성
+    panel = create_info_panel(w, h, fps, latency, prediction, confidence, panel_height, position)
+
+    # 패널 위치에 따라 결합
+    if position == 'top':
+        result = np.vstack([panel, frame])
+    elif position == 'bottom':
+        result = np.vstack([frame, panel])
+    else:
+        raise ValueError(f"Unknown position: {position}. Use 'top' or 'bottom'.")
+
+    return result
+
+
+def draw_fall_alert_overlay(
+    frame: np.ndarray,
+    alert_text: str = "FALL DETECTED!",
+    flash: bool = True
+) -> np.ndarray:
+    """
+    낙상 경보 오버레이 그리기 (전체 화면 플래시 효과)
+
+    Args:
+        frame: 원본 프레임
+        alert_text: 경보 텍스트
+        flash: True면 화면 전체에 빨간 반투명 오버레이 추가
+
+    Returns:
+        result: 경보 오버레이가 추가된 프레임
+    """
+    frame = frame.copy()
+    h, w = frame.shape[:2]
+
+    # 1. 플래시 효과 (빨간 반투명 오버레이)
+    if flash:
+        overlay = frame.copy()
+        cv2.rectangle(overlay, (0, 0), (w, h), (0, 0, 255), -1)
+        cv2.addWeighted(overlay, 0.3, frame, 0.7, 0, frame)
+
+    # 2. 중앙에 큰 경고 텍스트
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    font_scale = 2.5
+    font_thickness = 8  # 두꺼운 굵기로 볼드체 효과
+
+    (text_w, text_h), _ = cv2.getTextSize(alert_text, font, font_scale, font_thickness)
+    text_x = (w - text_w) // 2
+    text_y = (h + text_h) // 2
+
+    # 텍스트 그림자 (검은색)
+    cv2.putText(frame, alert_text, (text_x + 3, text_y + 3), font, font_scale, (0, 0, 0), font_thickness + 2, cv2.LINE_AA)
+
+    # 텍스트 본문 (흰색)
+    cv2.putText(frame, alert_text, (text_x, text_y), font, font_scale, (255, 255, 255), font_thickness, cv2.LINE_AA)
+
+    return frame
+
+
+def visualize_fall_simple(
+    frame: np.ndarray,
+    keypoints: Optional[np.ndarray] = None,
+    show_fall_text: bool = False,
+    keypoint_mode: Literal['all', 'major'] = 'all',
+    output_scale: float = 1.0
+) -> np.ndarray:
+    """
+    간소화된 낙상 감지 시각화 (Pose skeleton + FALL DETECTED 텍스트만)
+
+    표시 항목:
+    - Pose skeleton (신체 부위별 색상)
+    - FALL DETECTED 텍스트 (show_fall_text=True일 때)
+
+    제거된 항목:
+    - FPS/Latency 정보
+    - 정보 패널
+    - 빨간 플래시 오버레이
+    - 신뢰도 표시
+
+    Args:
+        frame: 원본 프레임
+        keypoints: (17, 3) pose keypoints (선택)
+        show_fall_text: True면 FALL DETECTED 텍스트 표시
+        keypoint_mode: 'all'=전체 17개, 'major'=주요 9개만 표시
+        output_scale: 출력 해상도 스케일 (0.5=50%, 1.0=100%)
+
+    Returns:
+        result: 시각화된 프레임
+    """
+    # 1. 해상도 조절 (output_scale < 1.0인 경우)
+    original_h, original_w = frame.shape[:2]
+    if output_scale < 1.0:
+        new_w = int(original_w * output_scale)
+        new_h = int(original_h * output_scale)
+        result = cv2.resize(frame, (new_w, new_h), interpolation=cv2.INTER_LINEAR)
+
+        # keypoints 좌표도 스케일 조정
+        if keypoints is not None:
+            keypoints = keypoints.copy()
+            keypoints[:, 0] *= output_scale  # x 좌표
+            keypoints[:, 1] *= output_scale  # y 좌표
+    else:
+        result = frame.copy()
+
+    # 2. 스켈레톤 그리기
+    if keypoints is not None:
+        result = draw_skeleton_vectorized(
+            result, keypoints,
+            keypoint_mode=keypoint_mode,
+            use_body_part_colors=True
+        )
+
+    # 3. FALL DETECTED 텍스트 표시 (플래시 없이)
+    if show_fall_text:
+        h, w = result.shape[:2]
+        alert_text = "FALL DETECTED"
+
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        font_scale = 2.0
+        font_thickness = 6
+
+        (text_w, text_h), _ = cv2.getTextSize(alert_text, font, font_scale, font_thickness)
+        text_x = (w - text_w) // 2
+        text_y = 80  # 화면 상단
+
+        # 텍스트 배경 (반투명 검은색)
+        bg_padding = 15
+        overlay = result.copy()
+        cv2.rectangle(
+            overlay,
+            (text_x - bg_padding, text_y - text_h - bg_padding),
+            (text_x + text_w + bg_padding, text_y + bg_padding),
+            (0, 0, 0),
+            -1
+        )
+        cv2.addWeighted(overlay, 0.6, result, 0.4, 0, result)
+
+        # 텍스트 그림자 (검은색)
+        cv2.putText(result, alert_text, (text_x + 2, text_y + 2),
+                    font, font_scale, (0, 0, 0), font_thickness + 2, cv2.LINE_AA)
+
+        # 텍스트 본문 (빨간색)
+        cv2.putText(result, alert_text, (text_x, text_y),
+                    font, font_scale, (0, 0, 255), font_thickness, cv2.LINE_AA)
+
+    return result
+
+
+def visualize_fall_detection(
+    frame: np.ndarray,
+    keypoints: Optional[np.ndarray] = None,
+    prediction: str = 'Non-Fall',
+    confidence: float = 0.0,
+    bbox: Optional[Tuple[int, int, int, int]] = None,
+    fps: Optional[float] = None,
+    latency: Optional[float] = None,
+    show_skeleton: bool = True,
+    show_info_panel: bool = True,
+    show_alert: bool = False,
+    use_optimized: bool = True,
+    keypoint_mode: Literal['all', 'major'] = 'all',
+    output_scale: float = 1.0
+) -> np.ndarray:
+    """
+    낙상 감지 결과 종합 시각화 (All-in-one 함수)
+
+    Args:
+        frame: 원본 프레임
+        keypoints: (17, 3) pose keypoints (선택)
+        prediction: 'Fall' 또는 'Non-Fall'
+        confidence: 신뢰도
+        bbox: 바운딩 박스 (선택)
+        fps: FPS 값 (선택)
+        latency: Latency (ms) (선택)
+        show_skeleton: True면 스켈레톤 그리기
+        show_info_panel: True면 상단에 정보 패널 추가
+        show_alert: True면 낙상 경보 오버레이 추가 (prediction='Fall'일 때만)
+        use_optimized: True면 벡터화된 그리기 함수 사용 (30배 빠름)
+        keypoint_mode: 'all'=전체 17개, 'major'=주요 9개만 표시
+        output_scale: 출력 해상도 스케일 (0.5=50%, 1.0=100%)
+
+    Returns:
+        result: 시각화된 프레임
+    """
+    # 1. 해상도 조절 (output_scale < 1.0인 경우)
+    original_h, original_w = frame.shape[:2]
+    if output_scale < 1.0:
+        new_w = int(original_w * output_scale)
+        new_h = int(original_h * output_scale)
+        result = cv2.resize(frame, (new_w, new_h), interpolation=cv2.INTER_LINEAR)
+
+        # keypoints 좌표도 스케일 조정
+        if keypoints is not None:
+            keypoints = keypoints.copy()
+            keypoints[:, 0] *= output_scale  # x 좌표
+            keypoints[:, 1] *= output_scale  # y 좌표
+
+        # bbox 좌표도 스케일 조정
+        if bbox is not None:
+            bbox = tuple(int(v * output_scale) for v in bbox)
+    else:
+        result = frame.copy()
+
+    # 2. 스켈레톤 그리기
+    if show_skeleton and keypoints is not None:
+        if use_optimized:
+            result = draw_skeleton_vectorized(
+                result, keypoints,
+                keypoint_mode=keypoint_mode,
+                use_body_part_colors=True
+            )
+        else:
+            result = draw_skeleton(result, keypoints, use_body_part_colors=True)
+
+    # 3. 예측 결과 오버레이
+    if fps is not None or latency is not None:
+        result = draw_prediction(result, prediction, confidence, bbox, fps, latency, position='top-left')
+
+    # 4. 낙상 경보 오버레이 (Fall이고 show_alert=True일 때만)
+    if show_alert and prediction == 'Fall':
+        result = draw_fall_alert_overlay(result, alert_text="FALL DETECTED!", flash=True)
+
+    # 5. 정보 패널 추가 (선택)
+    if show_info_panel and fps is not None and latency is not None:
+        result = add_info_panel_to_frame(result, fps, latency, prediction, confidence, position='bottom')
+
+    return result
+
+
+if __name__ == '__main__':
+    import time
+    import argparse
+
+    parser = argparse.ArgumentParser(description='Visualization module test and benchmark')
+    parser.add_argument('--benchmark', action='store_true', help='Run performance benchmark')
+    parser.add_argument('--resolution', type=str, default='640x480',
+                       help='Test resolution (default: 640x480, options: 640x480, 1920x1080, 3840x2160)')
+    parser.add_argument('--iterations', type=int, default=100, help='Benchmark iterations')
+    args = parser.parse_args()
+
+    # 해상도 파싱
+    res_map = {
+        '640x480': (480, 640),
+        '1920x1080': (1080, 1920),
+        '3840x2160': (2160, 3840),
+        '4k': (2160, 3840),
+        'fhd': (1080, 1920),
+        'vga': (480, 640),
+    }
+    h, w = res_map.get(args.resolution.lower(), (480, 640))
+
+    print(f"Testing visualization module at {w}x{h}...")
+
+    # 1. 더미 프레임 생성
+    frame = np.zeros((h, w, 3), dtype=np.uint8)
+    frame[:, :] = (50, 50, 50)
+
+    # 2. 더미 키포인트 생성 (해상도에 맞게 스케일)
+    scale_x = w / 640
+    scale_y = h / 480
+    keypoints = np.array([
+        [320, 100, 0.9],  # 0: nose
+        [310, 90, 0.9],   # 1: left_eye
+        [330, 90, 0.9],   # 2: right_eye
+        [300, 90, 0.8],   # 3: left_ear
+        [340, 90, 0.8],   # 4: right_ear
+        [300, 150, 0.95], # 5: left_shoulder
+        [340, 150, 0.95], # 6: right_shoulder
+        [280, 200, 0.9],  # 7: left_elbow
+        [360, 200, 0.9],  # 8: right_elbow
+        [270, 250, 0.85], # 9: left_wrist
+        [370, 250, 0.85], # 10: right_wrist
+        [300, 250, 0.95], # 11: left_hip
+        [340, 250, 0.95], # 12: right_hip
+        [300, 350, 0.9],  # 13: left_knee
+        [340, 350, 0.9],  # 14: right_knee
+        [300, 450, 0.85], # 15: left_ankle
+        [340, 450, 0.85], # 16: right_ankle
+    ], dtype=np.float32)
+    keypoints[:, 0] *= scale_x
+    keypoints[:, 1] *= scale_y
+
+    if args.benchmark:
+        print("\n" + "=" * 70)
+        print("BENCHMARK: Visualization Performance Comparison")
+        print("=" * 70)
+        print(f"Resolution: {w}x{h}")
+        print(f"Iterations: {args.iterations}")
+        print("=" * 70)
+
+        # 기존 draw_skeleton 벤치마크
+        print("\n[1] draw_skeleton (original - cv2.circle/line loops)")
+        times_original = []
+        for _ in range(args.iterations):
+            start = time.perf_counter()
+            _ = draw_skeleton(frame.copy(), keypoints, use_body_part_colors=True)
+            times_original.append((time.perf_counter() - start) * 1000)
+        avg_original = np.mean(times_original)
+        std_original = np.std(times_original)
+        print(f"    Average: {avg_original:.2f}ms (+/- {std_original:.2f}ms)")
+
+        # 벡터화 draw_skeleton_vectorized 벤치마크 (all keypoints)
+        print("\n[2] draw_skeleton_vectorized (optimized - all keypoints)")
+        times_vectorized = []
+        for _ in range(args.iterations):
+            start = time.perf_counter()
+            _ = draw_skeleton_vectorized(frame.copy(), keypoints, keypoint_mode='all')
+            times_vectorized.append((time.perf_counter() - start) * 1000)
+        avg_vectorized = np.mean(times_vectorized)
+        std_vectorized = np.std(times_vectorized)
+        speedup_all = avg_original / avg_vectorized
+        print(f"    Average: {avg_vectorized:.2f}ms (+/- {std_vectorized:.2f}ms)")
+        print(f"    Speedup: {speedup_all:.1f}x faster")
+
+        # 벡터화 draw_skeleton_vectorized 벤치마크 (major keypoints)
+        print("\n[3] draw_skeleton_vectorized (optimized - major keypoints only)")
+        times_major = []
+        for _ in range(args.iterations):
+            start = time.perf_counter()
+            _ = draw_skeleton_vectorized(frame.copy(), keypoints, keypoint_mode='major')
+            times_major.append((time.perf_counter() - start) * 1000)
+        avg_major = np.mean(times_major)
+        std_major = np.std(times_major)
+        speedup_major = avg_original / avg_major
+        print(f"    Average: {avg_major:.2f}ms (+/- {std_major:.2f}ms)")
+        print(f"    Speedup: {speedup_major:.1f}x faster")
+
+        # 해상도 스케일 + 벡터화 벤치마크
+        if w > 640:
+            print("\n[4] draw_skeleton_vectorized + 50% scale")
+            times_scaled = []
+            for _ in range(args.iterations):
+                start = time.perf_counter()
+                result = visualize_fall_detection(
+                    frame.copy(), keypoints,
+                    prediction='Fall', confidence=0.9,
+                    fps=30.0, latency=50.0,
+                    use_optimized=True,
+                    keypoint_mode='all',
+                    output_scale=0.5
+                )
+                times_scaled.append((time.perf_counter() - start) * 1000)
+            avg_scaled = np.mean(times_scaled)
+            std_scaled = np.std(times_scaled)
+            print(f"    Average: {avg_scaled:.2f}ms (+/- {std_scaled:.2f}ms)")
+            print(f"    Output size: {result.shape[1]}x{result.shape[0]}")
+
+        print("\n" + "=" * 70)
+        print("SUMMARY")
+        print("=" * 70)
+        print(f"Original:   {avg_original:.2f}ms")
+        print(f"Optimized:  {avg_vectorized:.2f}ms ({speedup_all:.1f}x faster)")
+        print(f"Major only: {avg_major:.2f}ms ({speedup_major:.1f}x faster)")
+        target_met = avg_vectorized < 10.0
+        print(f"\nTarget (<10ms): {'MET' if target_met else 'NOT MET'}")
+        print("=" * 70)
+
+    else:
+        # 기본 기능 테스트
+        print("\n1. Testing draw_skeleton (original)...")
+        result = draw_skeleton(frame.copy(), keypoints, use_body_part_colors=True)
+        print(f"   Output shape: {result.shape}")
+
+        print("\n2. Testing draw_skeleton_vectorized (optimized)...")
+        result = draw_skeleton_vectorized(frame.copy(), keypoints, keypoint_mode='all')
+        print(f"   Output shape: {result.shape}")
+
+        print("\n3. Testing draw_skeleton_vectorized (major only)...")
+        result = draw_skeleton_vectorized(frame.copy(), keypoints, keypoint_mode='major')
+        print(f"   Output shape: {result.shape}")
+
+        print("\n4. Testing draw_prediction...")
+        result = draw_prediction(
+            frame.copy(),
+            prediction='Non-Fall',
+            confidence=0.95,
+            bbox=(int(270*scale_x), int(90*scale_y), int(370*scale_x), int(450*scale_y)),
+            fps=30.0,
+            latency=50.0
+        )
+        print(f"   Output shape: {result.shape}")
+
+        print("\n5. Testing create_info_panel...")
+        panel = create_info_panel(w, h, fps=30.0, latency=50.0, prediction='Non-Fall', confidence=0.95)
+        print(f"   Panel shape: {panel.shape}")
+
+        print("\n6. Testing visualize_fall_detection (optimized=True)...")
+        result = visualize_fall_detection(
+            frame=frame,
+            keypoints=keypoints,
+            prediction='Fall',
+            confidence=0.87,
+            fps=30.0,
+            latency=50.0,
+            show_skeleton=True,
+            show_info_panel=True,
+            show_alert=True,
+            use_optimized=True,
+            keypoint_mode='all'
+        )
+        print(f"   Output shape: {result.shape}")
+
+        print("\n7. Testing visualize_fall_detection (output_scale=0.5)...")
+        result = visualize_fall_detection(
+            frame=frame,
+            keypoints=keypoints,
+            prediction='Non-Fall',
+            confidence=0.95,
+            fps=30.0,
+            latency=50.0,
+            show_skeleton=True,
+            show_info_panel=True,
+            use_optimized=True,
+            output_scale=0.5
+        )
+        print(f"   Output shape: {result.shape}")
+
+        print("\nAll tests passed!")