Başla

Ultralytics YOLO26 ile Antrenman İzleme

Open Workouts Monitoring In Colab

Ultralytics YOLO26 ile poz tahmini aracılığıyla antrenmanları izlemek, önemli vücut işaret noktalarını ve eklemleri gerçek zamanlı olarak doğru biçimde takip ederek egzersiz değerlendirmesini iyileştirir. Bu teknoloji, egzersiz formu hakkında anında geri bildirim sunar, antrenman rutinlerini takip eder ve performans ölçümlerini hesaplayarak hem kullanıcılar hem de antrenörler için antrenman seanslarını optimize eder.



İzle: Ultralytics YOLO ile Antrenman Egzersizleri Nasıl İzlenir | Squat, Bacak Açma, Şınav ve Daha Fazlası

Antrenman İzlemenin Avantajları#

  • Performans Optimizasyonu: Daha iyi sonuçlar için antrenmanları izleme verilerine göre kişiselleştirme.
  • Hedeflere Ulaşma: Ölçülebilir ilerleme için fitness hedeflerini izle ve ayarla.
  • Kişiselleştirme: Etkililiği artırmak için kişisel verilere dayalı özel antrenman planları.
  • Sağlık Farkındalığı: Sağlık sorunlarına veya aşırı antrenmana işaret eden örüntüleri erken tespit etme.
  • Bilinçli Kararlar: Rutinleri ayarlamak ve gerçekçi hedefler belirlemek için veriye dayalı kararlar.

Gerçek Dünya Uygulamaları#

Antrenman İzlemeAntrenman İzleme
Poz tahminiyle YOLO şınav sayımıPoz tahminiyle YOLO barfiks sayımı
Şınav SayımıBarfiks Sayımı

YOLO26 ile Antrenmanları İzle#

AIGym çözümü, poz tahminini YOLO26n-pose gibi bir modelle çalıştırır ve uzuv up_angle ile down_angle eşikleri arasında hareket ederken üç anahtar noktanın oluşturduğu açıyı ölçerek tekrarları sayar. kpts ile izlemek istediğin egzersizin anahtar noktalarını seç, ardından çözümü Python API'si veya CLI ile videonda çalıştır.

Ultralytics YOLO ile Antrenman İzleme
# Run a workout example
yolo solutions workout show=True

# Pass a source video
yolo solutions workout source="path/to/video.mp4"

# Use keypoints for pushups
yolo solutions workout kpts="[6, 8, 10]"

Anahtar Nokta Haritası#

YOLO poz tahmini temel noktalarının sıralama şeması

AIGym Bağımsız Değişkenleri#

Aşağıda AIGym bağımsız değişkenlerini içeren bir tablo bulabilirsin:

Bağımsız değişkenTürVarsayılanAçıklama
modelstrNoneUltralytics YOLO model dosyasının yolu.
up_anglefloat145.0'Yukarı' pozu için açı eşiği.
down_anglefloat90.0'Aşağı' pozu için açı eşiği.
kptslist[int][6, 8, 10]Antrenmanları izlemek için kullanılan üç anahtar nokta indeksinin listesi. Bu anahtar noktalar; şınav, barfiks, squat ve karın egzersizleri gibi hareketlerde omuz, dirsek ve bilek gibi vücut eklemlerine veya bölümlerine karşılık gelir.
line_widthint2Çözümün çizdiği kutular, anahtar noktalar ve sayılar için çizgi kalınlığı.
verboseboolTrueÇözümün her kare için girdi şekli, sınıf sayıları ve işleme hızına ilişkin günlüğünü etkinleştirir. İzleme çağrısının kendisi her zaman sessizdir.

AIGym çözümü çeşitli nesne izleme parametrelerini de destekler:

Bağımsız değişkenTürVarsayılanAçıklama
trackerstr'tracktrack.yaml'Kullanılacak izleme algoritmasını belirtir. Yerleşik seçenekler: botsort.yaml, bytetrack.yaml, ocsort.yaml, deepocsort.yaml, fasttrack.yaml, tracktrack.yaml.
conffloat0.25Algılamalar için güven eşiğini belirler; düşük değerler daha fazla nesnenin izlenmesine olanak tanır ancak yanlış pozitifleri de içerebilir.
ioufloat0.5Çakışan algılamaları filtrelemek için Kesişim-Birleşim Oranı (IoU) eşiğini belirler.
classeslistNoneSonuçları sınıf dizinine göre filtreler. Örneğin, classes=[0, 2, 3] yalnızca belirtilen sınıfları izler.
devicestrNoneÇıkarım için kullanılacak cihazı belirtir (ör. cpu, cuda:0 veya 0). Kullanıcıların model yürütme için CPU, belirli bir GPU veya başka hesaplama cihazları arasında seçim yapmasına olanak tanır.
imgszint or tuple640Hedef çıkarım görüntü boyutu: kare görüntüler için bir tam sayı veya bir (height, width) çifti. Boyutlar model adım değerine göre ayarlanır.
max_detint300Yoğun sahnelerde bir çözümün işleyeceği nesne sayısını sınırlamak için izleme öncesinde kare başına tutulan en yüksek algılama sayısı.
quantizeint or strNoneÇıkarım hassasiyeti: CPU dışında PyTorch ve TorchScript modelleri için 16 (FP16) veya 32/unset (FP32); diğer biçimler, model yapıtının ve çalışma zamanının seçtiği hassasiyeti kullanır. Kullanımdan kaldırılan half argümanının yerini alır.

Ayrıca aşağıdaki görselleştirme ayarları da uygulanabilir:

Bağımsız değişkenTürVarsayılanAçıklama
showboolFalseTrue ise açıklama eklenmiş görüntüleri veya videoları bir pencerede gösterir. Geliştirme veya test sırasında anında görsel geri bildirim almak için kullanışlıdır.
show_labelsboolTrueGörsel çıktıda her algılama için etiketleri gösterir. Algılanan nesnelerin hemen anlaşılmasını sağlar.

Sık Sorulan Sorular#

  • Antrenmanlarını Ultralytics YOLO26 ile izlemek için poz tahmini özelliklerinden yararlanarak önemli vücut işaret noktalarını ve eklemleri gerçek zamanlı olarak takip edip analiz edebilirsin. Böylece egzersiz formun hakkında anında geri bildirim alabilir, tekrarları sayabilir ve performans ölçümlerini hesaplayabilirsin. Başlangıç olarak aşağıda gösterildiği gibi şınav, barfiks veya karın egzersizleri için sunulan örnek kodu kullanabilirsin:

    import cv2
    
    from ultralytics import solutions
    
    cap = cv2.VideoCapture("path/to/video.mp4")
    assert cap.isOpened(), "Error reading video file"
    w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
    
    gym = solutions.AIGym(
        line_width=2,
        show=True,
        kpts=[6, 8, 10],
    )
    
    while cap.isOpened():
        success, im0 = cap.read()
        if not success:
            print("Video frame is empty or processing is complete.")
            break
        results = gym(im0)
    
    cap.release()
    cv2.destroyAllWindows()
  • Antrenman izleme için Ultralytics YOLO26 kullanmanın birkaç önemli avantajı vardır:

    • Performans Optimizasyonu: Antrenmanları izleme verilerine göre kişiselleştirerek daha iyi sonuçlar elde edebilirsin.
    • Hedeflere Ulaşma: Ölçülebilir ilerleme için fitness hedeflerini kolayca izleyip ayarlayabilirsin.
    • Kişiselleştirme: En iyi sonuçlar için kişisel verilerine dayalı özel antrenman planları alabilirsin.
    • Sağlık Farkındalığı: Olası sağlık sorunlarına veya aşırı antrenmana işaret eden örüntüleri erken tespit edebilirsin.
    • Bilinçli Kararlar: Rutinlerini ayarlamak ve gerçekçi hedefler belirlemek için veriye dayalı kararlar alabilirsin.

    Bu avantajları uygulamada görmek için bir YouTube video gösterimini izleyebilirsin.

  • Ultralytics YOLO26 poz modelleri, önemli vücut işaret noktalarını ve eklemleri gerçek zamanlı olarak doğru biçimde takip ederek egzersiz formu ve tekrar sayıları hakkında güvenilir geri bildirim sağlar. Uygulamada doğruluk; kamera açısına, aydınlatmaya, örtülmeye ve her egzersiz için uygun kpts, up_angle ve down_angle değerlerinin seçilmesine de bağlıdır.

  • Evet, Ultralytics YOLO26 özel antrenman rutinlerine uyarlanabilir. AIGym sınıfı, egzersiz tekrarlarını up_angle, down_angle ve kpts argümanlarını kullanarak algılar. Belirli egzersizleri algılamak için anahtar noktaları ve açıları belirtebilirsin. Örnek bir ayar:

    from ultralytics import solutions
    
    gym = solutions.AIGym(
        line_width=2,
        show=True,
        kpts=[6, 8, 10],  # Şınav için — diğer egzersizlere göre özelleştirilebilir
    )

    Bu esneklik, çeşitli egzersizleri izlemene ve rutinleri fitness hedeflerine göre özelleştirmene olanak tanır.

  • Antrenman izleme çıktısını kaydetmek için işlenmiş kareleri kaydeden bir video yazıcı ekleyerek kodu değiştirebilirsin. Örnek:

    import cv2
    
    from ultralytics import solutions
    
    cap = cv2.VideoCapture("path/to/video.mp4")
    assert cap.isOpened(), "Error reading video file"
    w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
    
    video_writer = cv2.VideoWriter("workouts.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
    
    gym = solutions.AIGym(
        line_width=2,
        show=True,
        kpts=[6, 8, 10],
    )
    
    while cap.isOpened():
        success, im0 = cap.read()
        if not success:
            print("Video frame is empty or processing is complete.")
            break
        results = gym(im0)
        video_writer.write(results.plot_im)
    
    cap.release()
    video_writer.release()
    cv2.destroyAllWindows()

    Bu kurulum, izlenen videoyu bir çıktı dosyasına yazar; böylece antrenman performansını daha sonra inceleyebilir veya ek geri bildirim almaları için antrenörlerle paylaşabilirsin.

Yorumlar41

Bir soru sor, sonuçlarını paylaş veya başka birine yardım et.

  1. 流川疯

    May I ask how to obtain the value of step and perform some logical operations, such as counting to 10 times for pop-up reminders,many thanks

    1
    1. Glenn JocherUltralytics(düzenlendi)

      @wynshiter the AIGym solution counts repetitions for you: call results = gym_object(frame) and read results.workout_count (one entry per tracked person). Add your own logic on top, for example if any(c >= 10 for c in results.workout_count): to trigger a pop-up reminder. For further details, please refer to the documentation on workouts monitoring.

    2. nel-mvGitHub

      Thanks for your answer, Glenn. And the documentation on workouts monitoring is just this same page (https://docs.ultralytics.com/guides/workouts-monitoring) we are commenting on?

      And from the comments you gave above, we know that we can get the angles from the gym object: im0, angle_data = gym_object.start_counting(im0, results)

      I was expecting we could get the 'step' value similarly via a return variable.

      Do you know where we could see a list of return variables that the gym object gives?

    3. Glenn JocherUltralytics(düzenlendi)

      The AIGym results provide workout_count, workout_stage and workout_angle for each tracked person (results = gym_object(frame)), so repetitions are counted for you. To act on them, add your own logic in your processing loop, for example when workout_count reaches a target. For further details, please refer to the Workouts Monitoring documentation.

    4. Glenn JocherUltralytics(düzenlendi)

      @DanishkhanOp the pose model (yolo26n-pose.pt by default) is downloaded automatically the first time AIGym is initialized, or you can download it manually from the Ultralytics YOLO26 Model Documentation. You can also specify model="yolo26n-pose.pt" in your AIGym() constructor as shown in the workout monitoring examples.

  2. AhmedMostafa3mGitHub

    hello, i guess i came a little late , it ssems that start_counting method is not available any more i want to know how can i use the code above after updating. results = model.predict(frame, verbose=False) frame = gym_object.start_counting(frame, results) thanks alot

    1. Glenn JocherUltralytics(düzenlendi)

      @AhmedMostafa3m start_counting has been replaced: the solution is now called directly on the frame and runs pose tracking itself, so no separate model.track call is needed:

      from ultralytics import solutions
      
      gym = solutions.AIGym(model="yolo26n-pose.pt")  # Initialize once
      results = gym(frame)
      frame = results.plot_im

      For full implementation details, see the AIGym documentation.

    1. Glenn JocherUltralytics(düzenlendi)

      @DanishkhanOp the pose estimation model is used automatically when you initialize the AIGym class as shown in the code examples. By default it is yolo26n-pose.pt, which you can also set with model="yolo26n-pose.pt" in your solutions.AIGym() call; it will be downloaded from our servers if not already cached. For more details on pose models, visit our Keypoint Estimation Docs.

  3. AdadAlShababGitHub

    Hi. Suppose I'm detecting the angle between [8, 6, 12] and I wanna show text something like: "The angle between Shoulder and Wrist : {detected angle}" using cv2.putText. How3 can I do that?

    1. Glenn JocherUltralytics

      @AdadAlShabab to display the angle using cv2.putText, you can calculate the angle between the keypoints and then overlay the text on the image. Here's a minimal example:

      import cv2
      import numpy as np
      
      # Assuming you have the coordinates of the keypoints
      shoulder = np.array([x1, y1])
      elbow = np.array([x2, y2])
      wrist = np.array([x3, y3])
      
      # Calculate the angle
      angle = np.degrees(np.arctan2(wrist[1] - elbow[1], wrist[0] - elbow[0]) - 
                         np.arctan2(shoulder[1] - elbow[1], shoulder[0] - elbow[0]))
      
      # Display the angle
      cv2.putText(im0, f"Angle: {angle:.2f}", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)

      This will show the angle between the shoulder, elbow, and wrist on your video frame. Adjust the coordinates and text position as needed.

      1
    2. AdadAlShababGitHub

      Hi Glenn. Thanks for your wonderful reply. Can you please tell the about the keypoints [x1, y1]? Like : "shoulder = np.array([x1, y1]) elbow = np.array([x2, y2]) wrist = np.array([x3, y3]" What values should I put here?

    3. Glenn JocherUltralytics

      @AdadAlShabab to determine the values for keypoints like [x1, y1], you need to extract them from the model's output. When you run the model, it provides coordinates for each keypoint. For example, results[0].keypoints will give you the keypoints, and you can access specific ones using their indices. Adjust these based on your specific use case.

    4. AdadAlShababGitHub

      This code: " if result[0].keypoints is not None: keypoints = result[0].keypoints.data.cpu().numpy() # Access the actual keypoints data

                      # Debugging: Print keypoints shape to understand the issue
                      print(f"Keypoints shape: {keypoints.shape}")"

      Providing me results for each frame: 0: 384x640 1 person, 45.3ms Speed: 2.0ms preprocess, 45.3ms inference, 0.0ms postprocess per image at shape (1, 3, 384, 640) Keypoints shape: (1, 17, 3) Person keypoints shape: (17, 3) Keypoint 0: (x=1086.50, y=456.84), Confidence=0.97 Keypoint 1: (x=1098.32, y=446.95), Confidence=0.95 Keypoint 2: (x=1077.20, y=450.47), Confidence=0.90 Keypoint 3: (x=1121.03, y=453.73), Confidence=0.87 Keypoint 4: (x=1068.29, y=461.00), Confidence=0.64 Keypoint 5: (x=1147.66, y=499.11), Confidence=0.99 Keypoint 6: (x=1054.84, y=529.72), Confidence=0.98 Keypoint 7: (x=1192.78, y=521.58), Confidence=0.98 Keypoint 8: (x=1061.91, y=577.40), Confidence=0.90 Keypoint 9: (x=1161.27, y=528.25), Confidence=0.95 Keypoint 10: (x=1100.56, y=558.10), Confidence=0.86 Keypoint 11: (x=1189.49, y=611.80), Confidence=0.99 Keypoint 12: (x=1134.91, y=632.54), Confidence=0.98 Keypoint 13: (x=1234.99, y=644.81), Confidence=0.97 Keypoint 14: (x=1194.94, y=665.07), Confidence=0.94 Keypoint 15: (x=1295.68, y=737.43), Confidence=0.88 Keypoint 16: (x=1300.56, y=750.85), Confidence=0.85

      Are these the values you were talking about?

    5. Glenn JocherUltralytics(düzenlendi)

      Yes, those are the keypoint values. You can use them to calculate angles between specific joints. For example, use the coordinates of keypoints 8 (elbow), 6 (shoulder), and 12 (hip) to compute the angle and display it with cv2.putText. If you need further assistance, feel free to ask!

  4. actionTurtleGitHub

    If I wanted to count how many steps you took running. Would you just set the pose type to "running"? Or do I need to make my own model for running? Thank you

    1. Glenn JocherUltralytics

      @actionTurtle to count steps for running, you'll need to customize the model since "running" isn't a predefined pose type like "pushup" or "pullup." You can adapt the existing model by training it with running-specific keypoints. For more details, please refer to the workouts monitoring guide.

    2. actionTurtleGitHub

      "You can adapt the existing model by training it with running-specific keypoints."

      Sorry, I still don't understand. Is there a walk though of how I would do that?

    3. Glenn JocherUltralytics

      @actionTurtle to create a custom model for running, you'll need to train it with running-specific keypoints. Unfortunately, there's no built-in "running" pose type, so you'll need to gather a dataset of running poses and train the model accordingly. For a detailed guide on training custom models, please refer to the Ultralytics documentation.

  5. AdadAlShababGitHub

    Hi. The model is working pretty fine. But when I'm running the python file the detected angle data are shown in box. But I want to have the data stored in variable or maybe a list so that I can use them use outside or print in console. Please help.

    1. Glenn JocherUltralytics(düzenlendi)

      @AdadAlShabab to store the detected angle data in a list, read workout_angle from the results the solution returns for each frame. Here's a basic example:

      import cv2
      
      from ultralytics import solutions
      
      cap = cv2.VideoCapture("path/to/video/file.mp4")
      assert cap.isOpened(), "Error reading video file"
      
      gym_object = solutions.AIGym(model="yolo26n-pose.pt", kpts=[6, 8, 10], show=True)
      
      angles = []
      
      while cap.isOpened():
          success, im0 = cap.read()
          if not success:
              break
          results = gym_object(im0)
          angles.append(results.workout_angle)  # one angle per tracked person
      
      cap.release()
      cv2.destroyAllWindows()
      print(angles)

      This will store the angle data in the angles list for further use.

      2
    2. AdadAlShababGitHub

      Hi. I want detect angle of two hands simultaneously. So I wrote the code : gym_object = solutions.AIGym( line_thickness=2, view_img=True, pose_type="pushup", kpts_to_check={[8, 6, 12,],[5, 7, 9]}, )

      But it giving me error: TypeError: unhashable type: 'list'

      How to solve? Please let me know. TIA

    3. Glenn JocherUltralytics(düzenlendi)

      kpts must be a flat list of three keypoint indices, written with square brackets, for example kpts=[6, 8, 10]. Curly braces raise the "unhashable type" error, and nested lists such as [[8, 6, 12], [5, 7, 9]] are not supported. To track two sets of keypoints, create one AIGym instance for each:

      gym_left = solutions.AIGym(kpts=[5, 7, 9])
      gym_right = solutions.AIGym(kpts=[6, 8, 10])
    4. AdadAlShababGitHub

      Hi Glenn! Still it throwing error: im0 = gym_object.start_counting(im0, results) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "E:\Bass fish streamlit.venv\Lib\site-packages\ultralytics\solutions\ai_gym.py", line 85, in start_counting k[int(self.kpts_to_check[0])].cpu(), ^^^^^^^^^^^^^^^^^^^^^^^^^^ TypeError: int() argument must be a string, a bytes-like object or a real number, not 'list'

    5. Glenn JocherUltralytics(düzenlendi)

      The error occurs because kpts should be a flat list of three integers, not nested lists. To track both hands, create a separate AIGym instance for each set of keypoints and run both on every frame. If you need further assistance, please check the latest documentation or update your package to the latest version.

    1. Glenn JocherUltralytics

      @Shengguang-Zhou yes, you can train extra classes for pose prediction by customizing the AIGym class and specifying the keypoints and angles for the exercises you want to monitor. For more details, please refer to the Workouts Monitoring Guide.

  6. MarserHKGitHub

    Hello, I would like to ask if there are any examples of using YOLOv8 for behavior recognition in electrical power field scenarios?

    1. Glenn JocherUltralytics

      @MarserHK currently, we don't have specific examples for behavior recognition in electrical power field scenarios. However, you can adapt the pose estimation capabilities of YOLOv8 for such tasks by training on relevant datasets. For more details on pose estimation, you can refer to the workouts monitoring guide here.

  7. duncanwaughGitHub

    Hello, it seems like it has to be setup for a specific type of workout eg. pushups and then it would track pushups, but if you started squatting it wouldn't track your squats. I'm curious if there is a way where U can have a live video feed where lets say you do 10 pushups, then 10 pullups, it will identify how its a different exercise and count it. Thanks.

    1. Glenn JocherUltralytics(düzenlendi)

      Hello,

      Thank you for your insightful question! You're correct that the current setup of the AIGym solution in Ultralytics YOLOv8 is designed to track specific types of workouts like pushups, pullups, and ab workouts individually. However, your idea of dynamically identifying and counting different exercises in a single session is quite intriguing and can be approached with some modifications.

      Dynamic Workout Detection and Counting

      To achieve dynamic detection and counting of different exercises, you would need to implement a mechanism that can:

      1. Identify the type of exercise being performed: This could be done by analyzing the keypoint movements and angles to classify the exercise type.
      2. Switch the counting logic based on the identified exercise: Once the exercise type is identified, the corresponding counting logic can be applied.

      Here's a conceptual approach to get you started:

      1. Exercise Classification: Use a simple heuristic or a machine learning model to classify the exercise based on keypoint movements.
      2. Dynamic Counting: Switch between different AIGym configurations based on the classified exercise.
      Example Code

      Below is a basic example to illustrate this concept. Note that this is a starting point and may require further refinement based on your specific requirements.

      import cv2
      from ultralytics import YOLO, solutions
      
      # Load the pose estimation model
      model = YOLO("yolo26n-pose.pt")
      cap = cv2.VideoCapture("path/to/video/file.mp4")
      assert cap.isOpened(), "Error reading video file"
      w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
      
      # Initialize video writer if needed
      video_writer = cv2.VideoWriter("workouts.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
      
      # Define a function to classify the exercise type
      def classify_exercise(keypoints):
          # Placeholder logic for exercise classification
          # Replace with actual logic based on keypoint analysis
          if some_condition_based_on_keypoints:
              return "pushup"
          elif some_other_condition_based_on_keypoints:
              return "pullup"
          else:
              return "unknown"
      
      # Initialize the AIGym object
      gym_objects = {
          "pushup": solutions.AIGym(show=True, kpts=[6, 8, 10]),
          "pullup": solutions.AIGym(show=True, kpts=[6, 8, 10]),
          # Add other exercises as needed
      }
      
      frame_count = 0
      current_exercise = "unknown"
      while cap.isOpened():
          success, im0 = cap.read()
          if not success:
              print("Video frame is empty or video processing has been successfully completed.")
              break
          frame_count += 1
          results = model.track(im0, verbose=False)  # Tracking recommended
      
          # Classify the exercise based on keypoints
          keypoints = results[0].keypoints
          exercise_type = classify_exercise(keypoints)
      
          if exercise_type in gym_objects:
              gym_object = gym_objects[exercise_type]
              im0 = gym_object(im0).plot_im  # AIGym runs its own pose tracking
          
          video_writer.write(im0)
      
      cv2.destroyAllWindows()
      video_writer.release()
      Next Steps
      1. Refine Exercise Classification: Develop a robust method to classify exercises based on keypoint data. This could involve machine learning models trained on labeled exercise data.
      2. Expand Exercise Types: Add more exercises to the gym_objects dictionary and their corresponding keypoint checks.
      3. Optimize Performance: Ensure the solution runs efficiently in real-time, especially if processing live video feeds.

      For more detailed guidance and advanced configurations, you can refer to our Workouts Monitoring Guide.

      Feel free to experiment with this approach and let us know how it works for you! If you encounter any issues or have further questions, don't hesitate to reach out.

    2. Glenn JocherUltralytics(düzenlendi)

      @duncanwaugh hello,

      Thank you for your insightful question! You're correct that the current setup of Ultralytics YOLOv8 for workout monitoring is designed to track specific exercises like pushups, pullups, and ab workouts individually. However, your idea of having a live video feed that can dynamically identify and count different exercises in sequence is fascinating and certainly feasible with some modifications.

      Dynamic Exercise Recognition

      To achieve dynamic exercise recognition, you would need to implement a mechanism that can classify the type of exercise being performed in real-time and then switch to the matching AIGym counter. Here's a high-level approach to how you might achieve this:

      1. Exercise Classification: Use a classification model to identify the type of exercise being performed. This model can be trained to recognize different exercises based on the input video frames.

      2. Counter Switching: Once the exercise type is identified, switch to the AIGym instance (keypoints kpts) for that exercise. This can be done dynamically within the video processing loop.

      Example Implementation

      Below is a simplified example to illustrate this concept. This example assumes you have a model for exercise classification; AIGym runs its own pose model.

      import cv2
      from ultralytics import YOLO, solutions
      
      # Load models
      classification_model = YOLO("exercise_classification_model.pt")
      cap = cv2.VideoCapture("path/to/video/file.mp4")
      assert cap.isOpened(), "Error reading video file"
      w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
      
      gym_objects = {
          "pushup": solutions.AIGym(show=True, kpts=[6, 8, 10]),
          "pullup": solutions.AIGym(show=True, kpts=[6, 8, 10]),
          "squat": solutions.AIGym(show=True, kpts=[12, 14, 16])
      }
      
      current_exercise = None
      frame_count = 0
      
      while cap.isOpened():
          success, im0 = cap.read()
          if not success:
              print("Video frame is empty or video processing has been successfully completed.")
              break
      
          frame_count += 1
      
          # Classify exercise type every few frames
          if frame_count % 30 == 0:  # Adjust frequency as needed
              classification_results = classification_model.predict(im0)
              current_exercise = classification_model.names[classification_results[0].probs.top1]  # class name of the top-1 prediction
      
          if current_exercise:
              gym_object = gym_objects[current_exercise]
              im0 = gym_object(im0).plot_im  # AIGym runs its own pose tracking
      
          cv2.imshow("Workout Monitoring", im0)
          if cv2.waitKey(1) & 0xFF == ord("q"):
              break
      
      cap.release()
      cv2.destroyAllWindows()
      Key Points:
      • Exercise Classification: The classification_model predicts the type of exercise.
      • Counter Switching: Based on the predicted exercise, the corresponding AIGym object is used.
      • Dynamic Processing: This setup allows for dynamic switching between different exercises during a workout session.

      This approach provides a flexible and scalable solution for monitoring multiple types of exercises in a single session. For more detailed guidance and advanced configurations, you can refer to our Workouts Monitoring Guide.

      Feel free to experiment with this setup and adjust it to better fit your specific use case. If you encounter any issues or have further questions, don't hesitate to reach out!

    3. Glenn JocherUltralytics(düzenlendi)

      @duncanwaugh hello,

      Thank you for your enthusiasm! 😊

      To address your query about dynamically identifying and counting different exercises within a single workout session, such as transitioning from pushups to pullups, you would need to implement a mechanism that can classify the type of exercise being performed in real-time and then switch to the matching AIGym counter.

      Dynamic Exercise Recognition

      Here's a high-level approach to achieve this:

      1. Exercise Classification: Use a classification model to identify the type of exercise being performed. This model can be trained to recognize different exercises based on the input video frames.
      2. Counter Switching: Once the exercise type is identified, switch to the AIGym instance (keypoints kpts) for that exercise. This can be done dynamically within the video processing loop.
      Example Implementation

      Below is a simplified example to illustrate this concept. This example assumes you have a model for exercise classification; AIGym runs its own pose model.

      import cv2
      from ultralytics import YOLO, solutions
      
      # Load models
      classification_model = YOLO("exercise_classification_model.pt")
      cap = cv2.VideoCapture("path/to/video/file.mp4")
      assert cap.isOpened(), "Error reading video file"
      w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
      
      gym_objects = {
          "pushup": solutions.AIGym(show=True, kpts=[6, 8, 10]),
          "pullup": solutions.AIGym(show=True, kpts=[6, 8, 10]),
          "squat": solutions.AIGym(show=True, kpts=[12, 14, 16])
      }
      
      current_exercise = None
      frame_count = 0
      
      while cap.isOpened():
          success, im0 = cap.read()
          if not success:
              print("Video frame is empty or video processing has been successfully completed.")
              break
      
          frame_count += 1
      
          # Classify exercise type every few frames
          if frame_count % 30 == 0:  # Adjust frequency as needed
              classification_results = classification_model.predict(im0)
              current_exercise = classification_model.names[classification_results[0].probs.top1]  # class name of the top-1 prediction
      
          if current_exercise:
              gym_object = gym_objects[current_exercise]
              im0 = gym_object(im0).plot_im  # AIGym runs its own pose tracking
      
          cv2.imshow("Workout Monitoring", im0)
          if cv2.waitKey(1) & 0xFF == ord("q"):
              break
      
      cap.release()
      cv2.destroyAllWindows()
      Key Points:
      • Exercise Classification: The classification_model predicts the type of exercise.
      • Counter Switching: Based on the predicted exercise, the corresponding AIGym object is used.
      • Dynamic Processing: This setup allows for dynamic switching between different exercises during a workout session.

      This approach provides a flexible and scalable solution for monitoring multiple types of exercises in a single session. For more detailed guidance and advanced configurations, you can refer to our Workouts Monitoring Guide.

      Feel free to experiment with this setup and adjust it to better fit your specific use case. If you encounter any issues or have further questions, don't hesitate to reach out!

      1
    1. Paula DerrengerUltralytics(düzenlendi)

      Hello,

      Yes, you can monitor workouts using the CLI with the workout solution:

      yolo solutions workout source=path/to/video/file.mp4 kpts="[6, 8, 10]"

      The kpts argument selects the three keypoints whose angle is counted ([6, 8, 10] is for pushups). For more detailed information, please refer to the documentation.

      Happy training! 💪