Yogaposedetectionreport 3
Yogaposedetectionreport 3
PROJECT REPORT
On
We Parthivi Malik, Md. Asharaf Khan, Nupur Kumari and Md. Uvesh
hereby declare that this submission is our own work and that, to the best
of our knowledge and belief, it contains no material previously published
or written by another person nor material which to a substantial extent has
been accepted for the award of any other degree of the university or other
institute of higher learning, except where due acknowledgment has been
made in the text.
Signature : Signature :
Name: Parthivi Malik Name: Md. Ashraf Khan
Roll no.: 2102220100129 Roll no.: 2202220109010
Date: Date:
Signature : Signature :
Name: Nupur Kumari Name: Md. Uvesh
Roll no.: 2102220100128 Roll no.:
2102220100129
Date: Date:
This is to certify that project report entitled “Yoga Pose Detection using
AI” which is submitted by Parthivi Malik, Md. Asharaf, Nupur Kumari
,and Md. Uvesh in partial fulfillment of the requirement for the award of
degree B. Tech. in department of computer science & engineering, Dr.
A.P.J. Abdul Kalam Technical University, Lucknow, is a record of the
candidate’s own work carried out by them under my supervision. The
matter embodied in this thesis is original and has not been submitted for
the award of any other degree.
Date: Supervisor
ACKNOWLEDGEMENT
Signature : Signature :
Name: Parthivi Malik Name: Md. Ashraf Khan
Roll no.: 2102220100129 Roll no.: 2202220109010
Date: Date:
Signature : Signature :
Name: Nupur Kumari Name: Md. Uvesh
Roll no.: 2102220100128 Roll no.: 2102220100129
Date:
ABSTRACT
minimal errors. It should capture the reader's attention and explain the
rationale behind selecting this project topic. Besides using strong
vocabulary and structured presentation, exciting the reader’s interest
through thought-provoking statements or real-world relevance is
important.
The chapter introduces the problem, reviews the previous work carried
out in the field, describes the method of researching the problem,
summarizes the key results obtained, and finally, explains the
organization of the entire report.
I. Introduction of the Problem
In the modern era, yoga has transcended being merely a traditional
practice and has become a global phenomenon for promoting physical
and mental wellness. Despite its widespread popularity, correct posture
and pose alignment remain crucial challenges for practitioners. Incorrect
postures can lead to ineffective results or even physical injuries.
Manually correcting yoga poses typically requires the physical presence
of a trained instructor. However, with the integration of artificial
intelligence and computer vision technologies, there arises an opportunity
to automate the process of pose detection and validation. This project
aims to address this gap by developing a Yoga Pose Detection system that
uses a webcam feed to analyze, detect, and provide feedback on the yoga
poses performed by users.
In the contemporary digital era, yoga has evolved beyond its ancient
roots, emerging as a globally embraced practice for enhancing physical
vitality, psychological resilience, and holistic well-being. Despite its
widespread adoption, the critical dependency of yoga on precise postural
alignment and pose execution continues to present significant challenges,
particularly for novice practitioners. Improper form not only diminishes
the therapeutic efficacy of yoga but also exposes individuals to a
heightened risk of musculoskeletal injuries and chronic strain-related
complications.
Traditionally, the correction of yoga postures necessitates the presence of
a skilled instructor capable of providing real-time feedback based on
visual and experiential assessment. However, the logistical, financial, and
geographic limitations associated with access to expert supervision create
a substantial barrier to consistent, high quality practice. This constraint
underscores the urgent need for scalable, technology-driven
System design is the blueprint and structural foundation upon which any
sophisticated technological solution is built. For the project entitled
“Yoga Pose Detection using Artificial Intelligence,” the design phase
encompasses both the architectural layout and the interrelationship
between software components and hardware elements. This chapter aims
to present a granular and systematic explanation of the design strategy
that integrates computer vision, machine learning, and user centered
interface design to enable the automated detection and classification of
yoga poses.
-The system begins with a live camera feed, typically sourced from a
webcam or an integrated camera.
-This module captures real-time video frames of the user performing yoga
poses.
-Once the frames are captured, they are passed to the pose detection
module, which utilizes a pre-trained model like MediaPipe Pose or
PoseNet.
-This skeletal data serves as the raw feature set for further analysis and
classification.
Pose Classification
-The extracted keypoints are then analyzed to identify the specific yoga
pose being performed.
Feedback System
-If the detected pose matches the expected reference with high accuracy, a
message like "Correct Pose" is displayed.
-The final stage involves delivering the processed output to the user via a
clean and intuitive graphical user interface (GUI).
Pose net estimation Open Pose, Media Pipe To detect and track
framework key body landmarks
for posture analysis.
AI model Convolutional Neural To classify poses
Networks (CNNs) based on training data
and provide
real time feedback.
Input data Images, Videos To provide visual
input for pose
detection.
Pose detection Open CV, Tensor Flow To process input data,
pipeline extract key points, and
Pass through AI
model.
Real time processing Open CV, Tensor Flow, To insure immediate
Python pose estimation and
feedback in real time.
User interface design HTML, CSS To create an
interactive and user-
friendly platform for
users to view
feedback.
Testing and validation Test cases, Accuracy To evaluate the
metrics performance and
accuracy of the pose
detection system.
Feature Description
V. System Workflow
-This component serves as the entry point for input data, capturing live
visuals of the user performing yoga poses.
-It ensures that the user’s body remains within the frame, in a well-lit and
uncluttered background for optimal detection performance.
Frame Extraction
-Once the video stream is live, the system proceeds to extract individual
frames from the continuous feed.
-This step is critical for ensuring smooth and responsive detection, with
typical frame rates ranging between 15 to 30 frames per second (FPS)
depending on hardware capability.
-Efficient frame extraction allows the system to maintain low latency,
which is essential for delivering real-time feedback.
Pose Detection
-In this step, the extracted frames are sent to the pose detection engine,
such as MediaPipe Pose or PoseNet, which are powered by deep learning
models.
-This skeletal map acts as the foundational input for further analysis.
Pose Classification
-After detecting the body’s keypoints, the system passes this data to a
pose classification module.
-Here, the system compares the detected pose with a reference database
of known yoga poses using rule-based algorithms or machine learning
techniques.
-The result of this stage is the identified yoga pose (e.g., Tree Pose,
Warrior II, Triangle Pose).
-It compares the user’s pose with predefined pose templates to determine
how well-aligned the user is.
o Euclidean distance
o Cosine similarity
o Joint angle deviation are computed to assign a pose accuracy
score.
Feedback Generation
I. Methodology
Keras
On top of TensorFlow, Keras provides a high-level API to streamline the
process of designing and training deep learning models. Keras’s intuitive
and modular design makes it easier to experiment with different neural
network architectures, hyperparameters, and loss functions during the
research phase.Although Keras is not directly used for training the pose
estimation model in this case (as a pre-trained model from MediaPipe is
utilized), it remains a core part of TensorFlow's API ecosystem, especially
for interpreting model outputs and integrating them into custom pipelines.
Computer Vision Libraries
OpenCV
OpenCV (Open Source Computer Vision Library) is a highly optimized
and widely adopted computer vision toolkit that supports numerous
operations related to image and video processing. In this project, OpenCV
is leveraged extensively for capturing video frames from the webcam,
resizing and normalizing image data, displaying output annotations, and
overlaying keypoints and pose classifications in real-time.
OpenCV's efficient image transformation functions (such as Gaussian
blur, color space conversion, and morphological operations) enable
preprocessing of input frames, which is crucial for reducing noise and
improving model performance. Furthermore, its video I/O capabilities
provide a bridge between hardware input (camera) and the pose detection
pipeline.
Pose Estimation Framework
MediaPipe
One of the most critical technologies underpinning this system is
MediaPipe, an open-source cross-platform framework also developed by
Google. MediaPipe provides modular pipelines for various real-time
computer vision tasks, such as face detection, hand tracking, and human
pose estimation.
The MediaPipe Pose module used in this project is a holistic and
lightweight solution that combines machine learning models with
geometrical modeling to estimate full-body 3D landmarks. It returns a set
of 33 keypoints, each associated with 3D coordinates (x, y, z), visibility
scores, and semantic labels. These keypoints represents
joints and limbs, such as the shoulders, elbows, hips, knees, and ankles,
which are essential for yoga pose analysis.
MediaPipe’s architecture comprises multiple stages, including:
- Image preprocessing
- Landmark detection using neural networks
- Skeleton overlay and visualization
Its efficiency and accuracy allow the system to operate in real-time even
on devices with limited hardware capabilities, such as laptops without
dedicated GPUs. Moreover, it abstracts away much of the low-level
complexity, allowing developers to focus on higher-level logic such as
pose classification and feedback generation.
Data Handling Libraries
To facilitate mathematical operations and efficient data manipulation, the
project employs the following Python libraries:
NumPy (Numerical Python): Essential for handling multi-dimensional
arrays and matrices, which are ubiquitous in deep learning and image
processing. It provides optimized operations for linear algebra,
broadcasting, indexing, and filtering that are used throughout the pose
normalization and comparison stages.
Pandas: Although not extensively used in the current version, Pandas
proves beneficial during the analysis and storage of pose classification
results. It allows for structured data representation using DataFrames,
which simplifies result logging, exporting, and visualization.
Mathematical Foundations and Algorithms
The mathematical basis for pose detection involves both linear algebra
and geometry. After extracting keypoints using MediaPipe, the system
computes Euclidean distances, angular orientations, and vector
similarities to classify the detected pose. These computations are essential
for determining how closely a user’s live pose matches a predefined
reference.
Additionally, cosine similarity and dot product operations may be used to
measure the alignment between limb vectors, aiding in the construction of
pose classification logic that mimics human perception.
System Environment and Execution Platform
The development and execution environment for the project is set up on
Visual Studio Code (VS Code), a lightweight yet powerful code editor
that supports Python natively and offers debugging, linting, and version
control capabilities.
The system was executed on a standard personal computing environment
with the following configuration:
- Operating System: Windows 10/11
- RAM: Minimum 8 GB
- Processor: Intel Core i5 or equivalent
- Python Version: 3.9+
- Webcam: Integrated or USB camera with a minimum resolution of
720pThe project dependencies are managed using pip, the Python
package installer, and a virtual environment is maintained to ensure
isolation
from global dependencies.
Deployment Potential
Although the current implementation is optimized for local execution, the
architecture is inherently designed to be modular and deployable. Future
iterations of the project can be deployed using platforms such as:
- Flask/Django for backend APIs
- Streamlit or Gradio for rapid prototyping of user interfaces
- Heroku, Render, or AWS EC2 for cloud-based deployment
By encapsulating the model and pipeline within a web application, the
project can be made accessible via any browser, facilitating wide-scale
use among yoga instructors, fitness enthusiasts, and healthcare
professionals.
This comprehensive technological foundation equips the Yoga Pose
Detection system with the capacity to function as a reliable, real-time
intelligent tool.
CHAPTER - 5
Implementation and Result Analysis
I. Implementation Process
The Yoga Pose Detection System was developed using several advanced
techniques in machine learning, computer vision, and real-time systems.
Below, I elaborate on the full pipeline, starting from the initial system
setup to the final implementation.
System Setup and Configuration
The first phase of the implementation involved setting up the necessary
environment. Given the computational requirements of deep learning and
the real-time demands of pose estimation, it was crucial to choose
appropriate software and hardware.
Software Requirements
- Python 3.10 was chosen for its rich ecosystem of libraries for data
science, machine learning, and computer vision.
- IDE: Visual Studio Code was selected for development, thanks to its
wide array of extensions, integrated debugging, and support for Python.
- Libraries:
- OpenCV was used for handling video streams and processing images
in real time.
- TensorFlow and Keras: These libraries were used for model training, as
they offer robust deep learning tools and pre-built models.
- MediaPipe: Used for extracting keypoints of the human body in real
time.
- NumPy, Pandas: For data manipulation, matrix computations, and
handling data in arrays.
- Matplotlib: Utilized for visualizing results and metrics during training
and testing.
Hardware Setup
Given the need for real-time processing, it was important to run the
system on machines with sufficient computational power. A Windows 10
laptop with Intel Core i7 processor and 16GB RAM was used for local
testing. For real-time deployment and
scalability, future work includes deploying the system on cloud servers or
edge devices.
Containerization and Virtual Environments
To maintain consistency across different setups and avoid dependency
conflicts, a virtual environment (using Python’s venv module) was
created. This allowed for seamless management of package versions and
dependencies.
Dataset Collection and Preparation
The performance of the Yoga Pose Detection System heavily depends on
the dataset used for training the models. A well-curated dataset ensures
that the model can recognize various poses in different lighting and
environments.
Dataset Selection
The dataset was a combination of publicly available yoga pose datasets
like Yoga-82, Kaggle Yoga Pose Dataset, and a custom-built set. This
comprehensive dataset contains annotated images of individuals
performing various yoga poses. The dataset includes over 500 images per
class (pose) to ensure that the model can generalize well.
Data Preprocessing
The raw images were preprocessed in the following manner:
- Resizing: Images were resized to a uniform size (224x224 pixels) to fit
the input requirements of the neural network.
- Normalization: Pixel values were normalized to the range of [0, 1] by
dividing by 255.
- Data Augmentation: Techniques such as rotation, flipping, zooming, and
color adjustment were applied to augment the dataset and increase its
diversity, simulating real-world variability.
Keypoint Extraction
Keypoint extraction is central to pose detection. MediaPipe’s Pose
solution was employed to extract 33 keypoints, representing the body’s
joints and limbs, from each image. These keypoints were then
transformed into normalized coordinates for feeding into the classifier
model.
Model Architecture and Training
The core of the Yoga Pose Detection system is a Convolutional Neural
Network (CNN), trained to classify yoga poses based on extracted
keypoints. Below are the steps for model design and training:
Model Architecture
The PoseNet model from MediaPipe is used for pose detection. After
extracting the 33 keypoints, the following layers were implemented to
classify the pose:
- Input Layer: Accepts a vector of 33 keypoints (each represented by x, y
coordinates).
- Hidden Layers: A combination of fully connected layers (dense layers)
to transform the feature vector.
- Output Layer: A softmax layer for multi-class classification, where each
class corresponds to a specific yoga pose.
Training the Model
The dataset was divided into a training set (80%) and a validation set
(20%). The model was trained using the Adam optimizer, chosen for its
efficiency in handling sparse gradients. The loss function used was
Categorical Cross-Entropy as it is standard for multi-class classification
problems.
Here is a snippet of the model training process:
python
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam
Initialize the model
model = Sequential()
model.add(Dense(512, input_dim=33, activation='relu')) Input layer
model.add(Dense(256, activation='relu')) Hidden layer
model.add(Dense(7, activation='softmax')) Output layer (7 classes for 7
poses)
Compile the model
model.compile(optimizer=Adam(), loss='categorical_crossentropy',
metrics=['accuracy'])
Train the model
history = model.fit(X_train, y_train, epochs=100, batch_size=32,
validation_data=(X_val, y_val))
Here, X_train and y_train represent the training data and labels, while
X_val and y_val are the validation data and labels.
Figure3. This image shows the training interface of the Yoga Pose
Detection system using KNN classification on PoseNet data from videos.
Users can add examples for multiple yoga poses (A–G) through the
interface, training the model with labeled data. The pose keypoints are
accurately mapped on the user’s body, enabling the model to learn and
differentiate between various yoga postures.
Model Evaluation
The trained model was evaluated on a held-out test set. The accuracy and
loss curves were plotted to analyze overfitting. The model achieved an
accuracy of 85% on the test set, which was considered satisfactory for
further real-time deployment.
Integration of System Components
The pose detection and classification models were integrated into a full-
stack system to provide real-time feedback to users. The system consists
of both frontend and backend components, described below:
Frontend Development
The frontend was designed to provide a user-friendly interface:
- Web Interface: Developed using HTML, CSS, and JavaScript. A simple
interface was created to stream live video from the webcam and display
feedback such as pose alignment indicators.
- Mobile App: React Native and Flutter were evaluated as potential
frameworks for a cross-platform app. Future work will involve
optimizing the mobile app for different screen sizes.
Backend Development
The backend was built using Flask, which provides a lightweight
framework for handling HTTP requests and serving the pose
classification model.
- Model Inference: When a user uploads an image or starts a live video
feed, the backend processes the image, extracts keypoints using
MediaPipe, and feeds them into the trained model for classification.
Here’s a snippet of the Flask backend API:
python
from flask import Flask, request, jsonify
import cv2
import mediapipe as mp
import tensorflow as tf
app = Flask(__name__)
model = tf.keras.models.load_model('yoga_pose_model.h5')
Initialize MediaPipe Pose
mp_pose = mp.solutions.pose
pose = mp_pose.Pose()
@app.route('/predict', methods=['POST'])
def predict():
file = request.files['image']
img = cv2.imdecode(np.fromstring(file.read(), np.uint8),
cv2.IMREAD_COLOR)
rgb_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
results = pose.process(rgb_img)
if results.pose_landmarks:
Extract keypoints and classify pose
keypoints = extract_keypoints(results.pose_landmarks)
prediction = model.predict([keypoints])
pose_class = np.argmax(prediction)
return jsonify({'pose': pose_class})
return jsonify({'error': 'No pose detected'})
def extract_keypoints(landmarks):
Extract keypoints from landmarks
keypoints = []
for landmark in landmarks:
keypoints.append([landmark.x, landmark.y, landmark.z])
return keypoints
This backend code allows the user to upload an image, processes the pose
detection using MediaPipe, and then classifies it using the trained model.
Model Optimization
Once the initial model was trained and integrated, we focused on
improving performance and ensuring it could handle real-time video feed
inputs.
Optimization for Real-Time Performance
Given the need for quick inference in real-time applications,
optimizations were carried out:
- TensorFlow Lite: The model was converted to TensorFlow Lite format
to reduce model size and improve inference speed on edge devices.
- Quantization: We applied post-training quantization to reduce the model
size and ensure faster execution.
- CUDA Optimization: The model was optimized to run on the GPU
using CUDA libraries, significantly speeding up the process of keypoint
extraction and pose classification.
Real-Time Video Stream Processing
To handle real-time video streams from a webcam, we used OpenCV to
capture frames and process them for pose detection. Here’s a code snippet
for processing video input:
python
cap = cv2.VideoCapture(0)
while True:
ret, frame = cap.read()
if not ret:
break
rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
results = pose.process(rgb_frame)
if results.pose_landmarks:
keypoints = extract_keypoints(results.pose_landmarks)
prediction = model.predict([keypoints])
pose_class = np.argmax(prediction)
cv2.putText(frame, f'Pose: {pose_class}', (50, 50),
cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
II. Result
This section presents an analysis of the results obtained from the Yoga
Pose Detection system developed as part of our final year project. The
goal of the project was to detect and classify yoga poses in real-time
using webcam input and provide visual feedback to the user. The system
was tested for its accuracy, responsiveness, and real-world applicability
across different yoga poses, environments, and users.
System Performance
The application was evaluated on the following parameters:
- Pose Detection Accuracy
The model was able to identify and classify basic yoga poses such as
Tree Pose (Vrikshasana), Warrior Pose (Virabhadrasana), and Tadasana
with an average accuracy of around 85-90% in a controlled environment.
- Real-Time Response
The system maintained smooth real-time detection at 15–20 frames per
second (FPS) on a mid-range laptop without GPU support. The pose
recognition occurred within 1 second, making the feedback loop near-
instantaneous.
- Ease of Use
Users were able to interact with the system using just a webcam, without
any external sensors or installation, making the tool highly accessible.
Testing Conditions
Table4. To analyze the effectiveness of the system, it was tested under
various conditions:
Parameter Condition Outcome
Lightning conditions Natural light, dim light Best accuracy in
and artificial light natural lighting
User Feedback
To evaluate user satisfaction, informal usability testing was conducted
with 5–10 volunteers. Key feedback highlights:
- Positive Aspects:
Conclusion of Analysis
The Yoga Pose Detection system performed effectively in controlled
environments and showed promising results in real-world testing. The use
of pose estimation via keypoint tracking led to improved classification
accuracy and a better user experience. While some limitations exist, the
results demonstrate that the system can serve as a foundation for more
advanced, real-time fitness tracking applications.
Figure 4. This is the front page of a Yoga Pose Detection App, launched
using Live Server from VS Code. It features a live camera feed with pose
recognition, identifying the displayed posture as “Uttanasana.”
CHAPTER - 6
Conclusions and Future Work
I. Conclusion
The increasing demand for accessible and personalized health solutions
has encouraged the integration of artificial intelligence and computer
vision into traditional wellness practices like yoga. Our project, Yoga
Pose Detection using AI and Computer Vision, aimed to develop an
intelligent system that can recognize and provide feedback on yoga poses
in real time using a webcam and machine learning models. This chapter
concludes the project by summarizing its outcomes, reflecting on the
challenges faced, and exploring directions for future improvements and
extensions.
Summary of the Project
The project successfully developed a real-time yoga pose detection web
application using pose estimation and machine learning techniques. The
core objectives achieved include:
- Real-Time Pose Estimation: A pose estimation model identifies key
body landmarks from live video input.
- Pose Classification: Detected key points are matched with known pose
data to classify the user's posture.
- Web Interface: A lightweight web interface provides accessibility
without any installations.
- Feedback System: A feedback mechanism confirms correct postures and
helps guide the user.
Through this project, we demonstrated that it is feasible to create a yoga
assistant tool using browser-based technologies, machine learning, and
computer vision — all running in real time with decent accuracy.
Key Learnings
Throughout the development process, several technical and conceptual
insights were gained:
- Understanding Pose Estimation: Working with keypoint-based models
deepened our understanding of how human motion can be represented in
computer-readable formats.
- Optimizing ML Models: Tuning parameters for accurate classification
was critical, especially since pose data is highly sensitive to angles and
camera positioning.
- Human-Centric Design: The user interface and interaction design taught
us the importance of making machine learning systems easy and intuitive
for everyday users.
- Handling Edge Cases: We encountered issues like partial visibility, user
orientation, and inconsistent lighting, which taught us how real-world
variables affect AI performance.
These learnings were invaluable, both academically and practically, and
gave us a hands-on experience in applying AI to real-life wellness use
cases.
Challenges Encountered
Several challenges were faced during the project that affected accuracy
and usability:
- Pose Variability: Yoga poses vary slightly from person to person due to
flexibility, body structure, and execution. This introduced classification
challenges.
- Environment Dependency: Background clutter, camera quality, and
lighting conditions heavily influenced detection accuracy.
- Real-Time Constraints: Processing video frames while maintaining
speed and accuracy was a significant technical challenge.
- Limited Training Data: A major constraint was the availability of high-
quality, labeled pose data for multiple yoga postures.
Despite these, continuous experimentation and fine-tuning helped us
address most challenges and achieve a functional and reliable outcome.
Practical Applications
This system has wide-ranging potential in various domains:
- Home Yoga Practice: Individuals practicing at home can receive
immediate feedback without needing a physical instructor.
- Online Fitness Platforms: Integration with virtual classes can allow
instructors to track form and give corrective suggestions.
- Rehabilitation: Physiotherapists can use such tools to ensure patients
perform corrective movements accurately.
- School and College Training: This tool can help promote yoga among
students and assist instructors during group sessions.
The broader aim is to democratize access to guided fitness practices using
AI, making healthy living more inclusive and consistent.
II. Future Work
While the system meets its initial goals, there's significant room for
improvement and expansion. Future enhancements can include:
Advanced Pose Recognition
- Replace or supplement the current model with deep learning
architectures like CNN or LSTM to better understand body posture and
motion.
- Implement 3D pose detection to capture depth and angles more
accurately.
Pose Correction Suggestions
- Introduce a skeletal overlay to visually highlight misaligned body parts.
- Provide voice-based corrective feedback like “Raise your arms higher”
or “Straighten your back”.
Support for More Yoga Asanas
- Extend the system to support a wider range of yoga poses, including
complex and transitional movements.
- Create difficulty levels for beginners, intermediate, and advanced users.
Progress Tracking and Reports
- Add a dashboard that tracks performance and improvement over time.
- Introduce a scoring system that motivates users to improve their
consistency and accuracy.
Cross-Platform Deployment
- Convert the application into a mobile app or desktop tool using
frameworks like React Native or Electron.
[4] B. Xiao, H. Wu, and Y. Wei, "Simple Baselines for Human Pose
Estimation," ECCV, 2018. [Online]. Available:
https://link.springer.com/chapter/10.1007/978-3-030-01234-2_6.
[5] K. He, X. Zhang, S. Ren, and J. Sun, "Deep Residual Learning for
Image Recognition," CVPR, 2016. [Online]. Available:
https://ieeexplore.ieee.org/document/7780459.
[7] U. Iqbal and J. Gall, "Multi-Person Pose Estimation with Local Joint-
to-Joint Dependencies," IEEE Transactions on Pattern Analysis and
Machine Intelligence, 2017. [Online]. Available:
https://ieeexplore.ieee.org/document/7884600.
[8] W. Chang, M. Kothari, and X. Pitkow, "AI-Driven Fitness
Applications for Real-Time Posture Correction: An Empirical Study,"
Journal of Applied AI in Fitness Technology, 2019. [Online]. Available:
https://www.jaift.org.