[PYTHON] Überprüfen Sie die Kniebeugenform mit tiefem Lernen

** Das in diesem Artikel verwendete Video wurde vor langer Zeit aufgenommen und verzichtet derzeit auf Muskeltraining im Fitnessstudio. ** ** **

Einführung

Dies ist das zweite "Muskeltraining x Deep-Learning". Das erste ist hier (Deep Learning hat es einfacher gemacht, den Zeitraffer physischer Veränderungen dramatisch zu sehen). "Form Check" ist eine Gewohnheit vieler Auszubildender (Menschen, die Muskeltraining lieben). Wenn Sie Ihr Smartphone während des Trainings reparieren, ein Selbstporträt aufnehmen und später darauf zurückblicken, können Sie Ihre eigenen Formgewohnheiten kennen und die Qualität des nachfolgenden Trainings verbessern! In diesem Artikel konzentrierte ich mich auf "Squat (König des Muskeltrainings)" beim Muskeltraining und schrieb eine Geschichte über das Überprüfen der Form mithilfe von Deep Learning.

Zuerst aus dem Ergebnis

• Zur Veröffentlichung komprimiert.

Der Quellcode ist in Google Colab-Notizbüchern verfügbar. https://colab.research.google.com/drive/18bFHGZ415T6emBoPHacrMyEckPGW9VCv Sie können es auch mit Ihrem eigenen Video ausführen. Probieren Sie es also aus.

Inhaltsverzeichnis

• [1. Einstellungsschätzung](# 1 Einstellungsschätzung)
• [1-1. Versuch dich zu bewegen](# 1-1 Versuch dich zu bewegen)
• [1-2. Heatmap](# 1-2 Heatmap)
• [1-3. Einstellungsschätzung](# 1-3 Einstellungsschätzung)
• [2. Antrag auf Prüfung des Squat-Formulars](# 2 Antrag auf Prüfung des Squat-Formulars)
• [2-1. Wichtige Faktoren in der Hocke](# 2-1 Wichtige Faktoren in der Hocke)
• [2-2. Lass es wie eine Formularprüfung aussehen](# 2-2 Lass es wie eine Formularprüfung aussehen)
• Zusammenfassung

1. Einstellungsschätzung

Die Haltungsschätzung ist eine Technik zum Schätzen der Haltung eines menschlichen Körpers oder eines Tieres. Zum Beispiel kann im Fall des menschlichen Körpers die Haltung ausgedrückt werden, indem der Hals, der Hintern, das Knie usw. erfasst und verbunden werden. Eine bekannte ist OpenPose.

• Zitiert aus offenem Github *

1-1. Versuchen Sie sich zu bewegen

Dieses Mal bezog ich mich auf "[Lernen während des Machens! Deep Learning von PyTorch entwickeln](https://www.amazon.co.jp/%E3%81%A4%E3%81%8F%E3%82%8A". % E3% 81% AA% E3% 81% 8C% E3% 82% 89% E5% AD% A6% E3% 81% B6% EF% BC% 81PyTorch% E3% 81% AB% E3% 82% 88% E3 % 82% 8B% E7% 99% BA% E5% B1% 95% E3% 83% 87% E3% 82% A3% E3% 83% BC% E3% 83% 97% E3% 83% A9% E3% 83 % BC% E3% 83% 8B% E3% 83% B3% E3% 82% B0-% E5% B0% 8F% E5% B7% 9D-% E9% 9B% 84% E5% A4% AA% E9% 83 % 8E-ebook / dp / B07VPDVNKW /) "GitHub-Seite. Ich wollte es mit PyTorch x Google Colab implementieren, daher war die obige Implementierung sehr hilfreich.

Vorerst werde ich versuchen, die Haltung anhand eines einzelnen Bildes unter Verwendung von freiem Material abzuschätzen. Die Quelle ist eine schematische Version. Weitere Informationen finden Sie im Google Colab-Notizbuch.

def create_model(weight_path):
  """
Erstellen Sie ein Modell.
Der Name der Netzwerkschicht unterscheidet sich zwischen dem trainierten Modell und OpenPoseNet
  (Zum Beispiel Modul.model0.0.Gewicht und Modell0.model.0.weight)Damit
Entsprechen und laden
  """

  #Modelldefinition
  model = OpenPoseNet()

  #Gelernte Parameter laden
  net_weights = torch.load(
      weights_path, map_location={'cuda:0': 'cpu'})
  keys = list(net_weights.keys())

  weights_load = {}

  #Der geladene Inhalt kann auf OpenPoseNet angezeigt werden.
  #Parameternamenmodell.state_dict().keys()Kopieren nach
  for i in range(len(keys)):
    weights_load[list(model.state_dict().keys())[i]
                 ] = net_weights[list(keys)[i]]

  #Geben Sie dem Modell an, was Sie kopiert haben
  state = model.state_dict()
  state.update(weights_load)
  model.load_state_dict(state)
  return model

model = create_model(weights_path)
model.to(device)

model.eval()
with torch.no_grad():
  predicted_outputs, _ = model(img.to(device))
  pafs = predicted_outputs[0][0].cpu().detach().numpy().transpose(1, 2, 0)
  heatmaps = predicted_outputs[1][0].cpu().detach().numpy().transpose(1, 2, 0)

pafs = cv2.resize(
    pafs, (test_img.shape[1], test_img.shape[0]), interpolation=cv2.INTER_CUBIC)
heatmaps = cv2.resize(
    heatmaps, (test_img.shape[1], test_img.shape[0]), interpolation=cv2.INTER_CUBIC)

_, result_img, _, _ = decode_pose(test_img, heatmaps, pafs)

cv2_imshow(result_img)

Die Ergebnisse sind wie folgt.

• [Fotos erstellt von Freepic.diller-jp.freepik.com](https://jp.freepik.com/free-photo/full-length-of-young-concentrated-sportsman-doing-squats-during- Verwenden Sie Workout-Outdoor_2593727.htm # page = 1 & query = squat & position = 17) *

Es fühlt sich ziemlich gut an. Wenn Sie dies für jedes Bild des Videos tun, können Sie das Formular überprüfen. Ich möchte jedoch nicht das ganze gemeinsame Teil, nur das minimal notwendige Teil ist in Ordnung. Diesmal,

• Hals
• Arsch (rechts)
• Knie (rechts)
• Knöchel (rechts)

Ich werde mich genau darauf konzentrieren.

1-2. Wärmekarte

In dem zu verwendenden Modell wird die Lage geschätzt, indem die Wärmekarte ausgegeben und jedes Teil daraus extrahiert wird. Zeichnen wir zunächst eine Wärmekarte des Zielteils.

# 1:Hals, 8:Arsch (rechts), 9:Knie (rechts), 10:Knöchel (rechts)
necessary_parts=[1,8,9,10] 
fig, ax = plt.subplots(2, 2, figsize=(16, 10))

for i, part in enumerate(necessary_parts):
    heat_map = heatmaps[:, :, part]
    heat_map = np.uint8(cm.jet(heat_map)*255)
    heat_map = cv2.cvtColor(heat_map, cv2.COLOR_RGBA2RGB)
    blend_img = cv2.addWeighted(test_img, 0.5, heat_map, 0.5, 0)
    ax[int(i/2), i%2].imshow(blend_img)

plt.show()

Die Ergebnisse sind wie folgt. Ich konnte ein bestimmtes Teil richtig extrahieren.

1-3. Einstellungsschätzung

Identifizieren Sie die Position der Verbindung anhand der Ausgangswärmekarte des jeweiligen Teils. Unter der Voraussetzung, dass nur eine Person auf einem Blatt zu sehen ist, bleibt diesmal nur ein Punkt für jedes Teil übrig, und die angegebenen Teile werden verbunden.

def find_joint_coords(heatmaps, necessary_parts, param = {'thre1': 0.1, 'thre2': 0.05, 'thre3': 0.5}):
  """
Gelenkkoordinaten erkennen
  """
  
  joints = []
  for part in necessary_parts:
      heat_map = heatmaps[:, :, part]
      peaks = find_peaks(param, heat_map)
      if len(peaks) == 0:
        joints.append(img, [np.nan, np.nan], [np.nan, np.nan])
      #Wenn es zwei oder mehr Spitzen gibt, lassen Sie nur die stärkste Stelle
      if peaks.shape[0]>1:
        max_peak = None
        for peak in peaks: 
          val = heat_map[peak[1], peak[0]]
          if max_peak is None or heat_map[max_peak[1], max_peak[0]] < val:
            max_peak = peak
      else:
        max_peak = peaks[0]
      joints.append(max_peak)

  return joints

img = test_img.copy()
joints = find_joint_coords(heatmaps, necessary_parts)
for i in range(len(joints)-1):
  img = cv2.line(img,tuple(joints[i].astype(int)),tuple(joints[i+1].astype(int)),(255,0,0),3)

cv2_imshow(img)

Die Ergebnisse sind wie folgt. wohlfühlen.

2. Antrag auf Prüfung der Kniebeugenform

Jetzt, da ich weiß, dass es verwendet werden kann, werde ich es auf mein Squat-Video anwenden.

2-1. Wichtige Faktoren in der Hocke

Das Skelett, das Schienbein, Oberschenkel und Rumpf bildet, variiert von Person zu Person, sodass die optimale Form von Person zu Person variiert. Ich denke, es wird in der folgenden Abbildung leichter vorstellbar sein.

Mit anderen Worten, die Form, die zu der Person passt, beruht mehr auf Skelettproportionen als auf Flexibilität und Kraftbalance. Wenn Sie dieses Skelettverhältnis selbst erfassen können, können Sie Verletzungen vorbeugen und das Gewicht der Hocke sicher erhöhen. Weitere Informationen finden Sie auf YouTube und auf einer Reihe anderer großartiger Webseiten.

Squats Part 1: Fold-Ability and Proportions

2-2. Lassen Sie es wie eine Formularprüfung aussehen

Da die Koordinaten der Gelenke genommen werden können, finden Sie den Winkel und den Momentarm der Gelenke und ordnen Sie sie in chronologischer Reihenfolge an. Der Winkel der Verbindung ist der Winkel der beiden Vektoren, die die Verbindung einschließen. Der Momentarm simuliert den idealen Schwerpunkt (Mittelfuß) und verwendet ihn als Abstand der senkrechten Linie, die durch das Gelenk verläuft, zu seiner vertikalen Geraden. Berechnen Sie dies für jeden Frame und verbinden Sie sie, um den Vorgang abzuschließen. Zeichnen Sie abschließend den in jedem Frame erzeugten Winkel- und Momentarm mit matplotlib, fügen Sie ihn oben auf dem Bildschirm ein und fügen Sie ein Diagramm hinzu, das so aussieht, als würde es gut analysiert.

** * Der Quellcode wird lang sein, daher werde ich ihn weglassen. Bitte beziehen Sie sich auf das Notizbuch. ** ** **

Das fertige Beispiel lautet wie folgt (der Rahmen wird entsprechend ausgewählt).

Zusammenfassung

Wir haben die Haltungsschätzung mithilfe von Deep Learning angewendet, um eine Überprüfung der Kniebeugenform durchzuführen. Ich glaube, ich konnte die Gelenke mit großer Genauigkeit erkennen. Aufgrund dieses Ergebnisses können Sie möglicherweise die Qualität der Kniebeugen weiter verbessern, indem Sie einen Spieler mit einem Skelett in Ihrer Nähe finden oder die Form mit diesem Spieler vergleichen.

Die Herausforderungen sind wie folgt.

• Mittelfuß (idealer Schwerpunkt) ist fest codiert
• Schwere Verarbeitung
• Unnötiges Erkennen des Teils
• Einfallsreichtum wie Pointwise Convolution
• Lernen muss wiederholt werden
• Kann nicht erkannt werden, wenn die Platte angebracht ist
• Dies ist ein schwerwiegendes Problem, aber ich wollte nicht posten, also tat ich so, als würde ich es nicht sehen. Es tut mir leid.
• Als Antwort lernen wir die Daten über den Zustand des Tragens der Platte. Oder es ist möglich, die Spitze oder das Gesicht der Stange zu erkennen und den Hals daraus abzuschätzen.

Wie oben erwähnt, geht es beim Muskeltraining, das zu Hause durchgeführt werden kann, nicht nur darum, Ihren Körper zu bewegen! Viel Spaß beim Muskeltraining!