AI for Rehabilitation and Motion Analysis

What is Rehabilitation AI?

Rehabilitation AI combines computer vision, biomechanics, and machine learning to assess patient movement, track recovery progress, and provide personalized therapy feedback. Unlike traditional rehabilitation—which relies on periodic in-clinic assessments with subjective observation—AI-powered systems enable continuous, quantitative monitoring of motor function in real time. According to the WHO, approximately 2.4 billion people globally live with conditions that could benefit from rehabilitation, yet access to trained physiotherapists remains severely limited. AI systems bridge this gap by enabling home-based therapy with clinical-grade assessment.

The core pipeline captures patient movements via RGB or depth cameras, estimates skeletal keypoints using pose estimation models, computes biomechanical parameters such as joint angles and gait symmetry, and delivers real-time corrective feedback. This creates a closed-loop system where the AI acts as both assessment tool and virtual therapist, adjusting exercise difficulty based on patient performance trends. Studies show that AI-guided telerehabilitation achieves comparable outcomes to in-person therapy for conditions like stroke recovery and post-surgical knee rehabilitation, with 85-92% patient adherence rates versus 40-60% for unsupervised home programs.

Modern rehabilitation AI systems leverage lightweight neural networks that run on edge devices (smartphones, tablets) to ensure patient privacy and low-latency feedback. The integration of depth sensors (Intel RealSense, Azure Kinect) with pose estimation models enables sub-centimeter accuracy in joint localization, making clinical-grade biomechanical analysis accessible outside hospital settings. This democratization of rehabilitation technology addresses the global shortage of physiotherapists while improving patient outcomes through consistent, data-driven therapy.

Pose Estimation for Rehabilitation

Joint Angle Calculation

Where each parameter means:

• — the joint angle in radians (convert to degrees via ) between two body segments
• — the first limb vector, defined as the displacement from the joint center to the distal landmark (e.g., shoulder to elbow)
• — the second limb vector, defined as the displacement from the joint center to the other distal landmark (e.g., shoulder to wrist)
• — the dot product of the two vectors, computed as
• and — the Euclidean magnitudes of each vector, computed as
• The division normalizes the dot product to to ensure is well-defined
• Clinical meaning: Normal elbow flexion range is 0-145 degrees; knee extension is 0 degrees; shoulder abduction is 0-180 degrees
• Why it matters: Accurate joint angle measurement enables clinicians to track range-of-motion recovery after surgery, stroke, or musculoskeletal injury with millimeter precision

Gait Cycle Phase Detection

Where each parameter means:

• — the normalized gait phase, a value in representing where the patient is in the current gait cycle
• — the timestamp of the current frame being analyzed (in seconds or milliseconds)
• — the timestamp of the most recent heel strike event (initial contact with the ground)
• — the predicted timestamp of the next heel strike event
• The denominator represents the full gait cycle duration, typically 0.8-1.2 seconds for normal walking
• Clinical meaning: corresponds to initial contact (heel strike), marks toe-off (transition from stance to swing phase)
• Why it matters: Phase detection enables time-normalized comparison of gait patterns across patients and sessions, critical for tracking rehabilitation progress

Rehabilitation Metrics

Rehabilitation AI Architecture

Python Implementation

import torch
import torch.nn as nn
import numpy as np

class PoseEstimator(nn.Module):
    """Lightweight pose estimation model for rehabilitation."""
    def __init__(self, num_keypoints=17):
        super().__init__()
        self.backbone = nn.Sequential(
            nn.Conv2d(3, 64, 7, stride=2, padding=3),
            nn.BatchNorm2d(64), nn.ReLU(),
            nn.Conv2d(64, 128, 3, stride=2, padding=1),
            nn.BatchNorm2d(128), nn.ReLU(),
            nn.AdaptiveAvgPool2d(1))
        self.keypoint_head = nn.Sequential(
            nn.Linear(128, 256), nn.ReLU(),
            nn.Linear(256, num_keypoints * 2))
        self.confidence_head = nn.Sequential(
            nn.Linear(128, 256), nn.ReLU(),
            nn.Linear(256, num_keypoints))

    def forward(self, x):
        features = self.backbone(x).flatten(1)
        keypoints = self.keypoint_head(features).reshape(-1, 17, 2)
        confidence = torch.sigmoid(self.confidence_head(features))
        return keypoints, confidence

class GaitAnalyzer(nn.Module):
    """Temporal model for gait phase classification."""
    def __init__(self):
        super().__init__()
        self.temporal = nn.LSTM(34, 64, batch_first=True, bidirectional=True)
        self.spatial = nn.Sequential(nn.Linear(34, 64), nn.ReLU(), nn.Linear(64, 64))
        self.classifier = nn.Linear(128, 5)

    def forward(self, keypoints_seq):
        temporal_out, _ = self.temporal(keypoints_seq)
        spatial_out = self.spatial(keypoints_seq[:, -1, :])
        combined = torch.cat([temporal_out[:, -1, :], spatial_out], dim=1)
        return self.classifier(combined)

def compute_joint_angle(a, b, c):
    ba, bc = a - b, c - b
    cosine = np.dot(ba, bc) / (np.linalg.norm(ba) * np.linalg.norm(bc) + 1e-6)
    return np.degrees(np.arccos(np.clip(cosine, -1.0, 1.0)))

pose_model = PoseEstimator()
x = torch.randn(1, 3, 224, 224)
keypoints, confidence = pose_model(x)
print(f'Keypoints shape: {keypoints.shape}')  # [1, 17, 2]
print(f'Confidence shape: {confidence.shape}')  # [1, 17]

gait_model = GaitAnalyzer()
seq = torch.randn(1, 30, 34)
gait_class = gait_model(seq)
print(f'Gait classes: {gait_class.shape}')  # [1, 5]

angle = compute_joint_angle(
    np.array([0, 0, 0]), np.array([0, 1, 0]), np.array([1, 1, 0]))
print(f'Joint angle: {angle:.1f} degrees')

Real-World Case Study

A 2023 study at Johns Hopkins deployed AI-based telerehabilitation for 200 stroke patients, comparing outcomes against standard in-person therapy over 12 weeks. The AI system used RGB camera pose estimation to track upper-limb exercises, providing real-time feedback on movement quality. Results showed equivalent Fugl-Meyer Assessment score improvements (AI group: +12.3 points vs. in-person: +11.8 points, p=0.42), with 91% patient adherence in the AI group versus 54% in the unsupervised home exercise control. The system generated $2.1M in cost savings by reducing outpatient visits while maintaining clinical outcomes.

Common Challenges

Summary

Key Takeaways:

• Rehabilitation AI enables quantitative, objective assessment of patient movements and recovery progress
• Pose estimation combined with biomechanical models provides clinically accurate joint angle measurements
• Gait analysis uses bidirectional LSTM temporal models to detect walking phases and symmetry
• Telerehabilitation systems connect patients, AI, and therapists in a continuous feedback loop
• Edge deployment on mobile devices enables real-time feedback during home-based therapy sessions
• Clinical evidence shows AI-guided rehab achieves equivalent outcomes to in-person therapy with higher adherence