Monitorização dos treinos utilizando Ultralytics YOLO11

A monitorização dos treinos através da estimativa de pose com Ultralytics YOLO11 melhora a avaliação do exercício ao seguir com precisão os principais pontos de referência do corpo e as articulações em tempo real. Esta tecnologia fornece feedback instantâneo sobre a forma do exercício, acompanha as rotinas de treino e mede as métricas de desempenho, optimizando as sessões de treino tanto para os utilizadores como para os treinadores.

Ver: Monitorização de exercícios utilizando Ultralytics YOLO11 | Flexões, Pullups, Ab Workouts

Vantagens da monitorização dos treinos?

Desempenho optimizado: Adaptação dos treinos com base nos dados de monitorização para obter melhores resultados.
Cumprimento de objectivos: Acompanhar e ajustar os objectivos de fitness para um progresso mensurável.
Personalização: Planos de treino personalizados com base em dados individuais para eficácia.
Sensibilização para a saúde: Deteção precoce de padrões que indicam problemas de saúde ou excesso de treino.
Decisões informadas: Decisões baseadas em dados para ajustar as rotinas e estabelecer objectivos realistas.

Aplicações no mundo real

Monitorização dos treinos	Monitorização dos treinos

Contagem de flexões	Contagem de PullUps

Exemplo de monitorização de exercícios

CLIPython

# Run a workout example
yolo solutions workout show=True

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

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

import cv2

from ultralytics import solutions

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))

# Video writer
video_writer = cv2.VideoWriter("workouts.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init AIGym
gym = solutions.AIGym(
    show=True,  # Display the frame
    kpts=[6, 8, 10],  # keypoints index of person for monitoring specific exercise, by default it's for pushup
    model="yolo11n-pose.pt",  # Path to the YOLO11 pose estimation model file
    # line_width=2,  # Adjust the line width for bounding boxes and text display
)

# Process video
while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break
    im0 = gym.monitor(im0)
    video_writer.write(im0)

cv2.destroyAllWindows()
video_writer.release()

Mapa de pontos-chave

keyPoints Ordem Ultralytics YOLO11 Pose

Argumentos `AIGym`

Nome	Tipo	Predefinição	Descrição
`kpts`	`list`	`None`	Lista de três índices de pontos-chave, para a contagem de um treino específico, seguida do mapa de pontos-chave
`line_width`	`int`	`2`	Espessura das linhas traçadas.
`show`	`bool`	`False`	Sinalizador para apresentar a imagem.
`up_angle`	`float`	`145.0`	Limiar de ângulo para a pose "para cima".
`down_angle`	`float`	`90.0`	Limiar de ângulo para a pose "para baixo".
`model`	`str`	`None`	Caminho para Ultralytics YOLO Pose Model File

Argumentos `model.predict`

Argumento	Tipo	Predefinição	Descrição
`source`	`str`	`'ultralytics/assets'`	Especifica a fonte de dados para inferência. Pode ser um caminho de imagem, ficheiro de vídeo, diretório, URL ou ID de dispositivo para feeds em direto. Suporta uma vasta gama de formatos e fontes, permitindo uma aplicação flexível em diferentes tipos de entrada.
`conf`	`float`	`0.25`	Define o limite mínimo de confiança para as detecções. Os objectos detectados com confiança inferior a este limite serão ignorados. O ajuste deste valor pode ajudar a reduzir os falsos positivos.
`iou`	`float`	`0.7`	Limiar de Intersecção sobre União (IoU) para Supressão Não Máxima (NMS). Valores mais baixos resultam em menos detecções através da eliminação de caixas sobrepostas, útil para reduzir duplicados.
`imgsz`	`int or tuple`	`640`	Define o tamanho da imagem para inferência. Pode ser um único número inteiro `640` para redimensionamento quadrado ou uma tupla (altura, largura). O dimensionamento correto pode melhorar a deteção exatidão e velocidade de processamento.
`half`	`bool`	`False`	Permite a inferência de meia-precisão (FP16), que pode acelerar a inferência de modelos em GPUs compatíveis com um impacto mínimo na precisão.
`device`	`str`	`None`	Especifica o dispositivo para inferência (por exemplo, `cpu`, `cuda:0` ou `0`). Permite aos utilizadores selecionar entre CPU, um GPU específico, ou outros dispositivos de computação para a execução do modelo.
`batch`	`int`	`1`	Especifica o tamanho do lote para inferência (só funciona quando a fonte é um diretório, ficheiro de vídeo ou `.txt` ficheiro). Uma maior dimensão do lote pode proporcionar um maior rendimento, reduzindo o tempo total necessário para a inferência.
`max_det`	`int`	`300`	Número máximo de detecções permitidas por imagem. Limita o número total de objectos que o modelo pode detetar numa única inferência, evitando resultados excessivos em cenas densas.
`vid_stride`	`int`	`1`	Passagem de fotogramas para entradas de vídeo. Permite saltar fotogramas em vídeos para acelerar o processamento à custa da resolução temporal. Um valor de 1 processa todos os fotogramas, valores mais elevados saltam fotogramas.
`stream_buffer`	`bool`	`False`	Determina se os quadros de entrada devem ser colocados em fila de espera para fluxos de vídeo. Se `False`Se `Verdadeiro', quadros antigos são descartados para acomodar novos quadros (otimizado para aplicações em tempo real). Se `Verdadeiro', enfileira novos quadros em um buffer, garantindo que nenhum quadro seja pulado, mas causará latência se o FPS da inferência for menor que o FPS do fluxo.
`visualize`	`bool`	`False`	Ativa a visualização das caraterísticas do modelo durante a inferência, fornecendo informações sobre o que o modelo está a "ver". Útil para depuração e interpretação de modelos.
`augment`	`bool`	`False`	Permite o aumento do tempo de teste (TTA) para previsões, melhorando potencialmente a robustez da deteção à custa da velocidade de inferência.
`agnostic_nms`	`bool`	`False`	Permite a Supressão Não Máxima (NMS) independente da classe, que funde caixas sobrepostas de classes diferentes. Útil em cenários de deteção multi-classe onde a sobreposição de classes é comum.
`classes`	`list[int]`	`None`	Filtra as previsões para um conjunto de IDs de classe. Apenas as detecções pertencentes às classes especificadas serão retornadas. Útil para se concentrar em objectos relevantes em tarefas de deteção multi-classe.
`retina_masks`	`bool`	`False`	Devolve máscaras de segmentação de alta resolução. As máscaras devolvidas (`masks.data`) corresponderão ao tamanho da imagem original se estiverem activados. Se estiverem desactivados, terão o tamanho de imagem utilizado durante a inferência.
`embed`	`list[int]`	`None`	Especifica as camadas a partir das quais se devem extrair vectores de caraterísticas ou embeddings. Útil para tarefas a jusante como o agrupamento ou a pesquisa de semelhanças.
`project`	`str`	`None`	Nome do diretório do projeto onde são guardados os resultados da previsão, se `save` está ativado.
`name`	`str`	`None`	Nome da execução da previsão. Utilizado para criar um subdiretório dentro da pasta do projeto, onde os resultados da previsão são armazenados se `save` está ativado.

Argumentos `model.track`

Argumento	Tipo	Predefinição	Descrição
`source`	`str`	`None`	Especifica o diretório de origem para imagens ou vídeos. Suporta caminhos de ficheiros e URLs.
`persist`	`bool`	`False`	Permite o rastreio persistente de objectos entre fotogramas, mantendo as IDs nas sequências de vídeo.
`tracker`	`str`	`botsort.yaml`	Especifica o algoritmo de seguimento a utilizar, por exemplo, `bytetrack.yaml` ou `botsort.yaml`.
`conf`	`float`	`0.3`	Define o limiar de confiança para as detecções; valores mais baixos permitem o seguimento de mais objectos, mas podem incluir falsos positivos.
`iou`	`float`	`0.5`	Define o limiar de Intersecção sobre União (IoU) para filtrar detecções sobrepostas.
`classes`	`list`	`None`	Filtra os resultados por índice de classe. Por exemplo, `classes=[0, 2, 3]` só rastreia as classes especificadas.
`verbose`	`bool`	`True`	Controla a apresentação dos resultados do seguimento, fornecendo uma saída visual dos objectos seguidos.

FAQ

Como posso monitorizar os meus treinos utilizando Ultralytics YOLO11 ?

Para monitorizar os seus treinos utilizando Ultralytics YOLO11 , pode utilizar as capacidades de estimativa de pose para seguir e analisar os principais pontos de referência do corpo e as articulações em tempo real. Isto permite-lhe receber feedback instantâneo sobre a sua forma de exercício, contar repetições e medir métricas de desempenho. Pode começar por utilizar o código de exemplo fornecido para flexões, pullups ou exercícios abdominais, conforme ilustrado:

import cv2

from ultralytics import solutions

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 = 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 video processing has been successfully completed.")
        break
    im0 = gym.monitor(im0)

cv2.destroyAllWindows()

Para mais personalizações e definições, pode consultar a secção AIGym na documentação.

Quais são as vantagens de utilizar o Ultralytics YOLO11 para monitorizar os exercícios?

A utilização de Ultralytics YOLO11 para monitorizar o treino proporciona várias vantagens importantes:

Desempenho optimizado: Ao adaptar os treinos com base nos dados de monitorização, é possível obter melhores resultados.
Cumprimento de objectivos: Acompanhe e ajuste facilmente os objectivos de fitness para um progresso mensurável.
Personalização: Obtenha planos de treino personalizados com base nos seus dados individuais para uma eficácia óptima.
Sensibilização para a saúde: Deteção precoce de padrões que indicam potenciais problemas de saúde ou excesso de treino.
Decisões informadas: Tomar decisões baseadas em dados para ajustar as rotinas e definir objectivos realistas.

Pode assistir a um vídeo de demonstração no YouTube para ver estes benefícios em ação.

Qual é a precisão do site Ultralytics YOLO11 na deteção e acompanhamento de exercícios?

Ultralytics YOLO11 é altamente preciso na deteção e seguimento de exercícios devido às suas capacidades de estimação de pose de última geração. Consegue seguir com precisão os principais pontos de referência e articulações do corpo, fornecendo feedback em tempo real sobre a forma do exercício e as métricas de desempenho. Os pesos pré-treinados do modelo e a arquitetura robusta garantem uma elevada precisão e fiabilidade. Para exemplos do mundo real, consulte a secção de aplicações do mundo real na documentação, que apresenta a contagem de flexões e pullups.

Posso utilizar Ultralytics YOLO11 para rotinas de treino personalizadas?

Sim, Ultralytics YOLO11 pode ser adaptado para rotinas de treino personalizadas. O AIGym suporta diferentes tipos de pose, como "pushup", "pullup" e "abworkout". Pode especificar pontos-chave e ângulos para detetar exercícios específicos. Aqui está um exemplo de configuração:

from ultralytics import solutions

gym = solutions.AIGym(
    line_width=2,
    show=True,
    kpts=[6, 8, 10],
)

Para mais pormenores sobre a definição de argumentos, consulte a secção Argumentos AIGym secção. Esta flexibilidade permite-lhe monitorizar vários exercícios e personalizar as rotinas com base nas suas necessidades.

Como posso guardar a saída de monitorização do treino utilizando Ultralytics YOLO11 ?

Para guardar o resultado da monitorização do exercício, pode modificar o código para incluir um gravador de vídeo que guarde os fotogramas processados. Aqui está um exemplo:

import cv2

from ultralytics import solutions

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))

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 video processing has been successfully completed.")
        break
    im0 = gym.monitor(im0)
    video_writer.write(im0)

cv2.destroyAllWindows()
video_writer.release()

Esta configuração grava o vídeo monitorado em um arquivo de saída. Para obter mais detalhes, consulte a secção Monitorização de Workouts com Gravação de Saída.

📅C riado há 1 ano ✏️ Atualizado há 1 mês