Initial HF Space: Gradio sitting posture demo

Generated with [Claude Code](https://claude.ai/code)
via [Happy](https://happy.engineering)

Co-Authored-By: Claude <noreply@anthropic.com>
Co-Authored-By: Happy <yesreply@happy.engineering>

.gitattributes

@@ -0,0 +1,6 @@
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,126 @@
+---
+title: Sitting Posture Detection
+emoji: 🪑
+colorFrom: yellow
+colorTo: blue
+sdk: gradio
+sdk_version: "4.44.1"
+app_file: app.py
+pinned: false
+---
+
+# Real-Time Lateral Sitting Posture Detection using YOLOv5
+
+<div align="center">
+  <img src="https://raw.githubusercontent.com/itakurah/SittingPostureDetection/main/data/images/posture.webp" width="80%" height="80%" alt="Sitting Posture"> 
+
+  *Source: https://www.youtube.com/watch?v=HNgTLml_Zi4*
+</div>
+
+
+This repository provides an open-source solution for **real-time sitting posture detection** using [YOLOv5](https://github.com/ultralytics/yolov5), a state-of-the-art object detection algorithm. The program is designed to analyze a user’s sitting posture and offer feedback on whether it aligns with ergonomic best practices, aiming to promote healthier sitting habits.
+
+## Key Features
+
+* **YOLOv5**: The program leverages the power of YOLOv5, which is an object detection algorithm, to accurately detect the user’s sitting posture from a webcam.
+* **Real-time Posture Detection**: The program provides real-time feedback on the user's sitting posture, making it suitable for applications in office ergonomics, fitness, and health monitoring.
+* **Good vs. Bad Posture Classification**: The program uses a pre-trained model to classify the detected posture as good or bad, enabling users to improve their posture and prevent potential health issues associated with poor sitting habits.
+* **Open-source**: Released under an open-source license, allowing users to access, modify, and contribute to the project.
+
+
+---
+
+### Built With
+
+![Python]
+
+## IEEE Conference Publication
+
+We are pleased to announce that this project has been published in an IEEE conference paper, which provides a comprehensive overview of our methodology, technical approach, and results in applying YOLOv5 for lateral sitting posture detection. This paper, titled **"Lateral Sitting Posture Detection using YOLOv5,"** was presented at the 2024 IEEE International Conference on Biomedical Robotics and Biomechatronics (BioRob). For more in-depth information, please refer to the full paper available at:
+
+**[Read the IEEE Publication on Xplore](https://doi.org/10.1109/BioRob60516.2024.10719953)**
+
+# Getting Started
+
+### Prerequisites
+
+* Python 3.9.X
+
+### Installation  
+If you have an NVIDIA graphics processor, you can activate GPU acceleration by installing the GPU requirements. Note that without GPU acceleration, the inference will run on the CPU, which can be very slow.  
+#### Windows  
+  
+1. `git clone https://github.com/itakurah/sitting-posture-detection-yolov5.git`  
+2. `python -m venv venv`  
+3. `.\venv\scripts\activate.bat`  
+##### Default/NVIDIA GPU support:  
+4.  `pip install -r ./requirements_windows.txt` **OR** `pip install -r ./requirements_windows_gpu.txt`
+
+#### Linux  
+  
+1. `git clone https://github.com/itakurah/sitting-posture-detection-yolov5.git`  
+2. `python3 -m venv venv`  
+3. `source venv/bin/activate`
+##### Default/NVIDIA GPU support:  
+4. `pip3 install -r requirements_linux.txt` **OR** `pip3 install -r requirements_linux_gpu.txt`
+
+
+### Run the program
+
+`python application.py <optional: model_file.pt>` **OR** `python3 application.py <optional: model_file.pt>`
+
+The default model is loaded if no model file is specified.
+
+# Model Information
+This project uses a custom-trained [YOLOv5s](https://github.com/ultralytics/yolov5/blob/79af1144c270ac7169553d450b9170f9c60f92e4/models/yolov5s.yaml) model fine-tuned on 160 images per class over 146 epochs. It categorizes postures into two classes:
+* `sitting_good`
+* `sitting_bad`
+
+The trained model file is located under the following directory:
+`data/inference_models/small640.pt`
+# Architecture
+The architecture that is used for the model is the standard YOLOv5s architecture:
+
+<img src="https://raw.githubusercontent.com/itakurah/SittingPostureDetection/main/data/images/architecture.png" width=75% height=75%>
+
+
+
+*Fig. 1: YOLOv5s network architecture (based on Liu et al.). The CBS module consists of a Convolutional layer, a Batch Normalization layer, and a Sigmoid Linear Unit (SiLU) activation function. The C3 module consists of three CBS modules and one bottleneck block. The SPPF module consists of two CBS modules and three Max Pooling layers.*
+
+# Model Results
+The validation set contains 80 images (40 sitting_good, 40 sitting_bad). The results are as follows:
+|Class|Images|Instances|Precision|Recall|mAP50|mAP50-95|
+|--|--|--|--|--|--|--|
+|all| 80 | 80 | 0.87 | 0.939 | 0.931 | 0.734 |
+|sitting_good| 40 |  40| 0.884 | 0.954 | 0.908 |0.744  |
+|sitting_bad| 80 | 40 | 0.855 | 0.925 | 0.953 | 0.724 |
+
+F1, Precision, Recall, and Precision-Recall plots:
+
+<p align="middle">
+<img src="https://raw.githubusercontent.com/itakurah/SittingPostureDetection/main/data/images/F1_curve.png" width=40% height=40%>
+<img src="https://raw.githubusercontent.com/itakurah/SittingPostureDetection/main/data/images/P_curve.png" width=40% height=40%>
+<img src="https://raw.githubusercontent.com/itakurah/SittingPostureDetection/main/data/images/R_curve.png" width=40% height=40%>
+<img src="https://raw.githubusercontent.com/itakurah/SittingPostureDetection/main/data/images/PR_curve.png" width=40% height=40%>
+</p>
+
+# About
+
+This project was developed by [Niklas Hoefflin](https://github.com/itakurah), [Tim Spulak](https://github.com/T-Lak),
+Pascal Gerber & Jan Bösch. It was supervised by [André Jeworutzki](https://github.com/AndreJeworutzki) and Jan Schwarzer as part of the [Train Like A Machine](https://csti.haw-hamburg.de/project/TLAM/) module at Hamburg University of Applied Sciences (HAW Hamburg).
+The project is actively maintained by Niklas Hoefflin and Tim Spulak.
+
+# Sources
+
+ - Jocher, G. (2020). YOLOv5 by Ultralytics (Version 7.0). https://doi.org/10.5281/zenodo.3908559
+ - Fig. 1: H. Liu, F. Sun, J. Gu, and L. Deng, “Sf-yolov5: A lightweight small
+object detection algorithm based on improved feature fusion mode,”
+Sensors (Basel, Switzerland), vol. 22, no. 15, pp. 1–14, 2022. https://doi.org/10.3390/s22155817
+
+# License
+
+This project is licensed under the MIT License. See the LICENSE file for details.
+
+<!-- MARKDOWN LINKS & IMAGES -->
+
+[Python]: https://img.shields.io/badge/Python-3776AB?style=for-the-badge&logo=python&logoColor=white

analyze.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""
+analyze.py — 单张图片坐姿检测
+
+用法：
+    python analyze.py <image_path>
+    python analyze.py <image_path> --save
+    python analyze.py <image_path> --save <output_path>
+"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+# 切换到脚本所在目录，确保 load_model.py 里的相对路径（./data/inference_models/）能正确找到模型
+os.chdir(Path(__file__).parent)
+
+import sys
+import types
+
+# yolov5 兼容 shim（新版 huggingface_hub 移除了 utils._errors 子模块）
+try:
+    import huggingface_hub.utils._errors  # noqa: F401
+except (ModuleNotFoundError, ImportError):
+    import huggingface_hub.errors as _hf_errors
+    _shim = types.ModuleType("huggingface_hub.utils._errors")
+    for _name in dir(_hf_errors):
+        setattr(_shim, _name, getattr(_hf_errors, _name))
+    sys.modules["huggingface_hub.utils._errors"] = _shim
+
+import torch
+
+# PyTorch 2.6+ 默认 weights_only=True，旧版 yolov5 模型需要关闭
+_orig_torch_load = torch.load
+def _patched_torch_load(*args, **kwargs):
+    kwargs.setdefault("weights_only", False)
+    return _orig_torch_load(*args, **kwargs)
+torch.load = _patched_torch_load
+
+import cv2
+from app_models.load_model import InferenceModel
+
+
+def draw_result(img, x1, y1, x2, y2, label, conf):
+    """在原图上叠加黄色检测框和标签"""
+    color = (0, 255, 255)  # 黄色 (BGR)
+    cv2.rectangle(img, (x1, y1), (x2, y2), color, 2)
+    text = f"{label} {conf:.2f}"
+    # 标签背景，防止文字看不清
+    (tw, th), _ = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 0.7, 2)
+    cv2.rectangle(img, (x1, y1 - th - 10), (x1 + tw + 4, y1), color, -1)
+    cv2.putText(img, text, (x1 + 2, y1 - 6),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 2)
+    return img
+
+
+def main():
+    parser = argparse.ArgumentParser(description="坐姿检测（YOLOv5）")
+    parser.add_argument("image", help="输入图片路径（JPG / PNG）")
+    parser.add_argument(
+        "--save",
+        nargs="?",
+        const="",          # --save 不带路径时用默认名
+        metavar="OUTPUT",
+        help="保存标注图；不指定路径则存为 <原文件名>_result.jpg",
+    )
+    args = parser.parse_args()
+
+    image_path = Path(args.image).resolve()
+    if not image_path.exists():
+        print(f"错误：找不到图片 {image_path}")
+        sys.exit(1)
+
+    # 读图
+    img = cv2.imread(str(image_path))
+    if img is None:
+        print(f"错误：无法读取图片 {image_path}")
+        sys.exit(1)
+
+    # 加载模型 & 推理
+    model = InferenceModel("small640.pt")
+    results = model.predict(img)
+    x1, y1, x2, y2, cls, conf = InferenceModel.get_results(results)
+
+    # 模型已设 conf=0.50，结果为空说明低于阈值
+    if cls is None:
+        print("未检测到人")
+        return
+
+    label = "good" if cls == 0 else "bad"
+    print(f"姿势：{label}（置信度 {conf:.2f}）")
+    print(f"BBox：[x1={x1}, y1={y1}, x2={x2}, y2={y2}]")
+
+    # 保存标注图（仅在 --save 时）
+    if args.save is not None:
+        if args.save == "":
+            output_path = image_path.parent / (image_path.stem + "_result" + image_path.suffix)
+        else:
+            output_path = Path(args.save)
+        annotated = draw_result(img.copy(), x1, y1, x2, y2, label, conf)
+        cv2.imwrite(str(output_path), annotated)
+        print(f"标注图已保存：{output_path}")
+
+
+if __name__ == "__main__":
+    main()

app.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""
+Gradio demo — 坐姿检测 / Sitting Posture Detection
+HF Spaces 入口：sdk: gradio，app_file: app.py
+"""
+
+import sys
+import types
+
+# yolov5 内部引用了 huggingface_hub.utils._errors，新版 hf_hub 已将这些类移到
+# huggingface_hub.errors。打一个向前兼容的 shim，避免 ImportError。
+try:
+    import huggingface_hub.utils._errors  # noqa: F401
+except (ModuleNotFoundError, ImportError):
+    import huggingface_hub.errors as _hf_errors
+    _shim = types.ModuleType("huggingface_hub.utils._errors")
+    for _name in dir(_hf_errors):
+        setattr(_shim, _name, getattr(_hf_errors, _name))
+    sys.modules["huggingface_hub.utils._errors"] = _shim
+
+import torch
+
+# PyTorch 2.6+ 将 weights_only 默认改为 True，旧版 yolov5 模型需要兼容处理
+_orig_torch_load = torch.load
+def _patched_torch_load(*args, **kwargs):
+    kwargs.setdefault("weights_only", False)
+    return _orig_torch_load(*args, **kwargs)
+torch.load = _patched_torch_load
+
+import cv2
+import gradio as gr
+from app_models.load_model import InferenceModel
+
+# 全局加载模型（避免每次请求重复加载）
+MODEL = InferenceModel("small640.pt")
+
+
+def draw_result(img_bgr, x1, y1, x2, y2, label, conf):
+    """在图上叠加黄色检测框和标签"""
+    color = (0, 255, 255)  # 黄色 BGR
+    cv2.rectangle(img_bgr, (x1, y1), (x2, y2), color, 2)
+    text = f"{label} {conf:.2f}"
+    (tw, th), _ = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 0.7, 2)
+    cv2.rectangle(img_bgr, (x1, y1 - th - 10), (x1 + tw + 4, y1), color, -1)
+    cv2.putText(img_bgr, text, (x1 + 2, y1 - 6),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 2)
+    return img_bgr
+
+
+def analyze(image):
+    """
+    Gradio 推理函数
+    image: numpy array (RGB，Gradio 默认格式)
+    returns: (annotated_image_rgb, result_text)
+    """
+    if image is None:
+        return None, "请上传图片"
+
+    img_bgr = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+
+    results = MODEL.predict(img_bgr)
+    x1, y1, x2, y2, cls, conf = InferenceModel.get_results(results)
+
+    if cls is None:
+        return image, "⚠️ 未检测到人（置信度低于 0.5）\n\n建议：请使用侧面角度的坐姿图片"
+
+    label = "good" if cls == 0 else "bad"
+    emoji = "✅" if label == "good" else "❌"
+    result_text = (
+        f"{emoji} 姿势：{label}（置信度 {conf:.2f}）\n"
+        f"BBox：[x1={x1}, y1={y1}, x2={x2}, y2={y2}]"
+    )
+
+    annotated_bgr = draw_result(img_bgr.copy(), x1, y1, x2, y2, label, conf)
+    annotated_rgb = cv2.cvtColor(annotated_bgr, cv2.COLOR_BGR2RGB)
+
+    return annotated_rgb, result_text
+
+
+demo = gr.Interface(
+    fn=analyze,
+    inputs=gr.Image(type="numpy", label="上传坐姿图片（建议侧面角度）"),
+    outputs=[
+        gr.Image(type="numpy", label="检测结果"),
+        gr.Textbox(label="分析结果", lines=3),
+    ],
+    title="🪑 坐姿检测 / Sitting Posture Detection",
+    description=(
+        "上传一张**侧面坐姿图片**，自动识别好/坏坐姿。\n\n"
+        "基于 YOLOv5s，训练数据为侧面标准座椅场景。"
+    ),
+    examples=[
+        ["examples/bad_1.png"],
+        ["examples/bad_2.png"],
+        ["examples/good_1.png"],
+    ],
+    allow_flagging="never",
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_models/load_model.py

@@ -0,0 +1,68 @@
+import sys
+from pathlib import Path
+
+import torch
+import yolov5
+
+'''Class for loading the Yolo-v5 inference_models
+'''
+
+
+class InferenceModel:
+    def __init__(self, model_name):
+        self.model_name = model_name
+        # path to inference_models
+        self.model_path = Path('./data/inference_models/{}'.format(model_name))
+        print(self.model_name + ' loaded')
+        print('cuda available: ' + str(torch.cuda.is_available()))
+        if torch.cuda.is_available():
+            print('running GPU inference..')
+            device_memory = {}
+            # get gpu with the highest memory
+            for i in range(torch.cuda.device_count()):
+                props = torch.cuda.get_device_properties(i)
+                device_memory[i] = props.total_memory
+            device_idx = max(device_memory, key=device_memory.get)
+            cuda = torch.device('cuda:{}'.format(device_idx))
+            # load inference_models into memory
+            try:
+                self.model = yolov5.load(str(self.model_path), device=str(cuda))
+            except Exception as e:
+                print(e)
+                print('Could not load model')
+                sys.exit(-1)
+        else:
+            print('running CPU inference..')
+            try:
+                self.model = yolov5.load(str(self.model_path), device='cpu')
+            except Exception as e:
+                print(e)
+                print('Could not load model')
+                sys.exit(-1)
+        # inference_models properties
+        self.model.conf = 0.50  # NMS confidence threshold
+        self.model.iou = 0.50  # NMS IoU threshold
+        self.model.classes = [0, 1]  # Only show these classes
+        self.model.agnostic = False  # NMS class-agnostic
+        self.model.multi_label = False  # NMS multiple labels per box
+        self.model.max_det = 1  # maximum number of detections per image
+        self.model.amp = True  # Automatic Mixed Precision (AMP) inference
+
+    # return prediction
+    def predict(self, image):
+        return self.model(image)
+
+    # extract items from results
+    @staticmethod
+    def get_results(results):
+        (bbox_x1, bbox_y1, bbox_x2, bbox_y2, class_name, confidence) = None, None, None, None, None, None
+        results = results.pandas().xyxy[0].to_dict(orient="records")
+        if results:
+            for result in results:
+                confidence = result['confidence']
+                class_name = result['class']
+                bbox_x1 = int(result['xmin'])
+                bbox_y1 = int(result['ymin'])
+                bbox_x2 = int(result['xmax'])
+                bbox_y2 = int(result['ymax'])
+        return bbox_x1, bbox_y1, bbox_x2, bbox_y2, class_name, confidence

app_models/model.py

@@ -0,0 +1,62 @@
+import cv2
+
+from app_controllers.utils import camera_helper
+from app_models.load_model import InferenceModel
+
+
+class Model:
+    def __init__(self, model_name):
+        super().__init__()
+        self.is_fullscreen = False
+        self.fullscreen_window = None
+        self.worker_thread_pause_screen = None
+        self.worker_thread_memory = None
+        self.memory_usage = None
+        self.cpu_usage = None
+        self.confidence = None
+        self.class_name = None
+        self.width = None
+        self.height = None
+        self.fps = None
+        with open('./commit_hash.txt', 'r') as file:
+            self.commit_hash = file.read()
+        # self.inference_models = Model(get_model_name())
+        self.prev_frame_time = 0
+        self.IMAGE_BOX_SIZE = 600
+        self.flag_is_camera_thread_running = True
+        self.camera_mapping = camera_helper.get_camera_mapping(camera_helper.get_connected_camera_alias(),
+                                                               camera_helper.get_connected_camera_ids())
+        self.camera = None
+        self.work_thread_camera = None
+
+        """
+        Load the frame properties
+        """
+        # bounding box options
+        # bbox color
+        self.box_color = (251, 255, 12)
+        # bbox line thickness
+        self.box_thickness = 2
+
+        # text options
+        # confidence color
+        self.text_color_conf = (251, 255, 12)
+        # class color
+        self.text_color_class = (251, 255, 12)
+        # background color
+        self.text_color_bg = (0, 0, 0)
+        # font thickness
+        self.text_thickness = 1
+        # font style
+        self.text_font = cv2.FONT_HERSHEY_SIMPLEX
+        # font scale
+        self.text_font_scale = 0.5
+        self.model_name = model_name
+        self.inference_model = InferenceModel(self.model_name)
+        self.frame_rotation = 0
+        self.frame_orientation_vertical = 0
+        self.frame_orientation_horizontal = 0
+        self.bbox_mode = 1
+
+    def get_commit_hash(self):
+        return self.commit_hash

data/inference_models/small640.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:477a1f6e2d3ebb67301a7ca84876d140774d5131c703a26f23d22c4703af49d1
+size 14404413

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.0.0
+yolov5
+torch
+torchvision
+opencv-python-headless