הערכת תנוחה בזמן אמת מווידאו ב-Python עם YOLOv7

מבוא

זיהוי אובייקטים הוא תחום גדול בראייה ממוחשבת, ואחד היישומים החשובים יותר של ראייה ממוחשבת "בטבע". ממנו הוצא זיהוי נקודות מפתח (לעיתים קרובות משמש להערכת תנוחה).

נקודות מפתח יכולות להיות נקודות שונות - חלקי פנים, גפיים של גוף וכו'. הערכת תנוחה היא מקרה מיוחד של זיהוי נקודות מפתח - שבו הנקודות הן חלקים מגוף אנושי.

הערכת תנוחה היא שימוש מדהים, מהנה ומעשי במיוחד בראייה ממוחשבת. בעזרתו, אנו יכולים לבטל את החומרה המשמשת להערכת תנוחות (חליפות לכידת תנועה), שהן יקרות ומסורבלות. בנוסף, אנו יכולים למפות את תנועת בני האדם לתנועת רובוטים במרחב האוקלידי, מה שמאפשר תנועה מוטורית דיוק עדין ללא שימוש בבקרים, שבדרך כלל אינם מאפשרים רמות גבוהות יותר של דיוק. ניתן להשתמש באומדן נקודת מפתח כדי לתרגם את התנועות שלנו למודלים תלת מימדיים ב-AR ו-VR, ויותר ויותר נעשה שימוש לשם כך עם מצלמת אינטרנט בלבד. לבסוף - הערכת תנוחה יכולה לעזור לנו בספורט ובביטחון.

במדריך זה, אנו נבצע הערכת פוזות בזמן אמת מתוך סרטון ב-Python, תוך שימוש במודל YOLOv7 המתקדם.

באופן ספציפי, נעבוד עם סרטון מאולימפיאדת החורף 2018, שהתקיימה ב-PyeongChang של דרום קוריאה:

אלג'ונה סבצ'נקו וברונו מאסו עשו הופעה מדהימה, כולל גופים חופפים מול המצלמה, תנועה מהירה של נוזלים וסיבובים באוויר. זו תהיה הזדמנות מדהימה לראות איך הדוגמנית מתמודדת עם מצבים שקשה להסיק!

הערכת YOLO ופוזה

YOLO (אתה מסתכל רק פעם אחת) היא מתודולוגיה, כמו גם משפחה של מודלים שנבנו לזיהוי אובייקטים. מאז היווסדה בשנת 2015, YOLOv1, YOLOv2 (YOLO9000) ו-YOLOv3 הוצעו על ידי אותם מחבר/ים - וקהילת הלמידה העמוקה המשיכה בהתקדמות בקוד פתוח בשנים הבאות.

YOLOv5 של Ultralytics הוא מאגר זיהוי אובייקטים ברמה תעשייתית, שנבנה על גבי שיטת YOLO. הוא מיושם ב-PyTorch, בניגוד ל-C++ עבור דגמי YOLO קודמים, הוא קוד פתוח לחלוטין, ויש לו API פשוט וחזק להפליא המאפשר לך להסיק, לאמן ולהתאים אישית את הפרויקט בצורה גמישה. זהו מרכיב בסיסי שרוב הניסיונות החדשים לשיפור שיטת YOLO מתבססים עליו.

כך YOLOR (אתה לומד רק ייצוג אחד) ו-YOLOv7 שנבנה על גבי YOLOR (אותו מחבר) נוצרו גם כן!

YOLOv7 היא לא רק ארכיטקטורת זיהוי אובייקטים - היא מספקת ראשי מודלים חדשים, שיכולים להוציא נקודות מפתח (שלדים) ולבצע פילוח מופעים מלבד רק רגרסיה תוחמת, שלא הייתה סטנדרטית במודלים קודמים של YOLO. זה לא מפתיע, מכיוון שארכיטקטורות זיהוי אובייקטים רבות שונו מחדש, למשל משימות פילוח וזיהוי נקודות מפתח, גם קודם לכן, בשל הארכיטקטורה הכללית המשותפת, עם פלטים שונים בהתאם למשימה.

למרות שזה לא מפתיע - תמיכה בפילוח מופעים וזיהוי נקודות מפתח יהפוך ככל הנראה לסטנדרט החדש עבור דגמים מבוססי YOLO, שהתחילו להעלות על כל שאר הגלאים הדו-שלביים לפני כמה שנים הן מבחינת דיוק והן מבחינת מהירות.

זה הופך את פילוח המופעים וזיהוי נקודות המפתח למהירים יותר לביצוע מאי פעם, עם ארכיטקטורה פשוטה יותר מאשר גלאים דו-שלביים.

המודל עצמו נוצר באמצעות שינויים ארכיטקטוניים, כמו גם אופטימיזציה של היבטי האימון, שכונו "תיק-של-חינם", אשר הגדילו את הדיוק מבלי להגדיל את עלות ההסקה.

התקנת YOLOv7

נתחיל בשיבוט המאגר כדי להשיג את קוד המקור:

! git clone https://github.com/WongKinYiu/yolov7.git

עכשיו, בואו נעבור ל- yolov7 ספרייה, המכילה את הפרויקט, ותסתכל על התוכן:

%cd yolov7
!ls

/content/yolov7
cfg	   figure      output.mp4	 test.py       
data	   hubconf.py  paper		 tools
deploy	   inference   README.md	 train_aux.py
detect.py  LICENSE.md  requirements.txt  train.py
export.py  models      scripts		 utils

כעת, YOLO נועד להיות גלאי אובייקטים, ואינו נשלח עם משקלי הערכת פוזות כברירת מחדל. נרצה להוריד את המשקולות ולטעון מהם מופע דגם קונקרטי. המשקולות זמינות באותו מאגר GitHub, וניתן להוריד אותן בקלות גם דרך ה-CLI:

! curl -L https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-w6-pose.pt -o yolov7-w6-pose.pt

 % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
100  153M  100  153M    0     0  23.4M      0  0:00:06  0:00:06 --:--:-- 32.3M

לאחר ההורדה, נוכל לייבא את הספריות ושיטות העזר שבהן נשתמש:

import torch
from torchvision import transforms

from utils.datasets import letterbox
from utils.general import non_max_suppression_kpt
from utils.plots import output_to_keypoint, plot_skeleton_kpts

import matplotlib.pyplot as plt
import cv2
import numpy as np

גדול! בוא נמשיך בטעינת המודל ויצירת סקריפט המאפשר לך להסיק פוזות מסרטונים עם YOLOv7 ו-OpenCV.

הערכת תנוחה בזמן אמת עם YOLOv7

תחילה ניצור שיטה לטעינת המודל מהמשקולות שהורדת. אנו נבדוק איזה מכשיר יש לנו (CPU או GPU):

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

def load_model():
    model = torch.load('yolov7-w6-pose.pt', map_location=device)['model']
    
    model.float().eval()

    if torch.cuda.is_available():
        
        
        model.half().to(device)
    return model

model = load_model()

תלוי אם יש לנו GPU או לא, נפעיל חצי דיוק (באמצעות float16 במקום float32 בפעולות), מה שהופך את ההסקה למהירה משמעותית. שים לב שמומלץ מאוד לבצע זאת על GPU במהירויות בזמן אמת, מכיוון שלמעבדים סביר להניח שלא יהיה כוח לעשות זאת אלא אם כן יפעלו על סרטונים קטנים.

בואו נכתוב שיטת נוחות להפעלת הסקת מסקנות. נקבל תמונות כמערכי NumPy (כיוון שזה מה שנעביר אותן מאוחר יותר בזמן קריאת הסרטון). ראשית, שימוש ב- letterbox() function – נשנה את גודל הסרטון ונרפד לצורה שהדגם יכול לעבוד איתה. זו לא צריכה להיות ולא תהיה הצורה (רזולוציה) של הסרטון שהתקבל!

לאחר מכן, נחיל את ההמרה, נמיר את התמונה לחצי דיוק (אם GPU זמין), נקבץ אותה ונפעיל אותה דרך המודל:

def run_inference(image):
    
    image = letterbox(image, 960, stride=64, auto=True)[0] 
    
    image = transforms.ToTensor()(image) 
    if torch.cuda.is_available():
      image = image.half().to(device)
    
    image = image.unsqueeze(0) 
    with torch.no_grad():
      output, _ = model(image)
    return output, image

נחזיר את התחזיות של המודל, כמו גם את התמונה כטנזור. אלו הן תחזיות "גסות" - הן מכילות הפעלות רבות החופפות, ונרצה "לנקות אותן" באמצעות Non-Max Supression, ולתכנן את השלדים החזויים על התמונה עצמה:

def draw_keypoints(output, image):
  output = non_max_suppression_kpt(output, 
                                     0.25, 
                                     0.65, 
                                     nc=model.yaml['nc'], 
                                     nkpt=model.yaml['nkpt'], 
                                     kpt_label=True)
  with torch.no_grad():
        output = output_to_keypoint(output)
  nimg = image[0].permute(1, 2, 0) * 255
  nimg = nimg.cpu().numpy().astype(np.uint8)
  nimg = cv2.cvtColor(nimg, cv2.COLOR_RGB2BGR)
  for idx in range(output.shape[0]):
      plot_skeleton_kpts(nimg, output[idx, 7:].T, 3)

  return nimg

עם אלה במקום, הזרימה הכללית שלנו תיראה כך:

img = read_img()
outputs, img = run_inference(img)
keypoint_img = draw_keypoints(output, img)

כדי לתרגם את זה להגדרת וידאו בזמן אמת - נשתמש ב-OpenCV כדי לקרוא סרטון, ונפעיל את התהליך הזה עבור כל פריים. על כל פריים, נכתוב את המסגרת גם לקובץ חדש, מקודד כסרטון. זה בהכרח יאט את התהליך בזמן שאנו מריצים את ההסקה, מציגים אותה וכותבים - כך שתוכל להאיץ את ההסקה והתצוגה על ידי הימנעות מיצירת קובץ חדש וכתיבה אליו בלולאה:

def pose_estimation_video(filename):
    cap = cv2.VideoCapture(filename)
    
    fourcc = cv2.VideoWriter_fourcc(*'MP4V')
    out = cv2.VideoWriter('ice_skating_output.mp4', fourcc, 30.0, (int(cap.get(3)), int(cap.get(4))))
    while cap.isOpened():
        (ret, frame) = cap.read()
        if ret == True:
            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            output, frame = run_inference(frame)
            frame = draw_keypoints(output, frame)
            frame = cv2.resize(frame, (int(cap.get(3)), int(cap.get(4))))
            out.write(frame)
            cv2.imshow('Pose estimation', frame)
        else:
            break

        if cv2.waitKey(10) & 0xFF == ord('q'):
            break

    cap.release()
    out.release()
    cv2.destroyAllWindows()

השמיים VideoWriter מקבל מספר פרמטרים - שם קובץ הפלט, FourCC (ארבעה קודי קודקים, המציינים את ה-codec המשמש לקידוד הווידאו), קצב הפריימים והרזולוציה כ-tuple. כדי לא לנחש או לשנות את גודל הסרטון - השתמשנו ברוחב ובגובה של הסרטון המקורי, שהושגו באמצעות VideoCapture מופע שמכיל נתונים על הסרטון עצמו, כגון הרוחב, הגובה, המספר הכולל של פריימים וכו'.

כעת, אנו יכולים לקרוא לשיטה בכל סרטון קלט:

pose_estimation_video('../ice_skating.mp4')

זה יפתח חלון OpenCV, המציג את ההסקה בזמן אמת. וגם, זה יכתוב קובץ וידאו ב- yolov7 ספרייה (מאז שיש לנו cdנכנסתי לזה):

סיכום

במדריך זה, בדקנו את שיטת YOLO, YOLOv7 ואת הקשר בין YOLO וזיהוי אובייקטים, הערכת פוזות ופילוח מופעים. לאחר מכן, בדקנו כיצד ניתן להתקין ולעבוד בקלות עם YOLOv7 באמצעות ה-API התוכנותי, ויצרנו מספר שיטות נוחות כדי להקל על הסקת מסקנות והצגת תוצאות.

לבסוף, פתחנו סרטון באמצעות OpenCV, הרצנו מסקנות עם YOLOv7, ויצרנו פונקציה לביצוע הערכת פוזות בזמן אמת, תוך שמירת הווידאו שנוצר ברזולוציה מלאה וב-30FPS בדיסק המקומי שלך.

הולך רחוק יותר - למידה עמוקה מעשית לראייה ממוחשבת

האופי הסקרן שלך גורם לך לרצות ללכת רחוק יותר? אנו ממליצים לבדוק את שלנו קורס: "למידה עמוקה מעשית עבור ראייה ממוחשבת עם Python".

עוד קורס ראיית מחשב?

לא נעשה סיווג של ספרות MNIST או אופנת MNIST. הם שירתו את תפקידם מזמן. משאבי למידה רבים מדי מתמקדים במערך נתונים בסיסיים ובארכיטקטורות בסיסיות לפני שהם מאפשרים לארכיטקטורות מתקדמות של קופסאות שחורות לשאת בנטל הביצועים.

אנחנו רוצים להתמקד דה-מיסטיפיקציה, מעשיות, הבנה, אינטואיציה ו פרויקטים אמיתיים. רוצה ללמוד אֵיך אתה יכול לעשות שינוי? ניקח אותך לסיבוב מהאופן שבו המוח שלנו מעבד תמונות לכתיבת סיווג למידה עמוקה לסרטן השד בדרגת מחקר לרשתות למידה עמוקה ש"הזויה", מלמדת אותך את העקרונות והתיאוריה באמצעות עבודה מעשית, ומציידה אותך ב ידע וכלים כדי להפוך למומחה ביישום למידה עמוקה לפתרון ראייה ממוחשבת.

מה יש בפנים?

• העקרונות הראשונים של חזון וכיצד ניתן ללמד מחשבים "לראות"
• משימות ויישומים שונים של ראייה ממוחשבת
• כלי המקצוע שיקלו עליכם את העבודה
• מציאת, יצירה וניצול של מערכי נתונים עבור ראייה ממוחשבת
• התיאוריה והיישום של רשתות עצביות קונבולוציונליות
• טיפול בהסטת תחום, התרחשות משותפת והטיות אחרות במערך נתונים
• העבר למידה וניצול זמן ההדרכה ומשאבי החישוב של אחרים לטובתך
• בנייה והדרכה של סיווג סרטן שד חדיש
• כיצד ליישם מנה בריאה של ספקנות על רעיונות מיינסטרים ולהבין את ההשלכות של טכניקות מאומצות באופן נרחב
• הדמיית "מרחב הקונספט" של ConvNet באמצעות t-SNE ו-PCA
• תיאורי מקרה של האופן שבו חברות משתמשות בטכניקות ראייה ממוחשבת כדי להשיג תוצאות טובות יותר
• הערכת מודל נכונה, הדמיית מרחב סמוי וזיהוי תשומת הלב של המודל
• ביצוע מחקר תחום, עיבוד מערכי נתונים משלך והקמת בדיקות מודל
• ארכיטקטורות חדשניות, התקדמות רעיונות, מה מייחד אותם וכיצד ליישם אותם
• KerasCV – ספריית WIP ליצירת צינורות ודגמים מתקדמים
• כיצד לנתח ולקרוא מאמרים וליישם אותם בעצמך
• בחירת דגמים בהתאם ליישום שלך
• יצירת צינור למידת מכונה מקצה לקצה
• נוף ואינטואיציה על זיהוי אובייקטים עם R-CNN מהירים יותר, RetinaNets, SSDs ו-YOLO
• מופע ופילוח סמנטי
• זיהוי אובייקטים בזמן אמת עם YOLOv5
• הכשרת גלאי אובייקטים של YOLOv5
• עבודה עם רובוטריקים באמצעות KerasNLP (ספריית WIP בעלת חוזק בתעשייה)
• שילוב רובוטריקים עם ConvNets ליצירת כיתובים של תמונות
• חלום עמוק
• אופטימיזציה של מודל Deep Learning לראייה ממוחשבת