מדריך לזיהוי פנים ל-iOS

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

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

קוד לדוגמה

הקוד לדוגמה של משימות MediaPipe הוא יישום פשוט של אפליקציית גלאי פנים ל-iOS. בדוגמה הזו, המערכת משתמשת במצלמה במכשיר Android פיזי כדי לזהות פנים בשידור וידאו רציף. האפליקציה יכולה גם לזהות פנים בתמונות ובסרטונים מגלריית המכשיר.

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

הורדת הקוד

בהוראות הבאות מוסבר איך ליצור עותק מקומי של הקוד לדוגמה באמצעות כלי שורת הפקודה git.

כדי להוריד את הקוד לדוגמה:

1. משכפלים את מאגר ה-Git באמצעות הפקודה הבאה:

   git clone https://github.com/google-ai-edge/mediapipe-samples
   

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

   cd mediapipe
   git sparse-checkout init --cone
   git sparse-checkout set examples/face_detector/ios/
   

אחרי שיצרתם גרסה מקומית של הקוד לדוגמה, תוכלו להתקין את ספריית המשימות MediaPipe, לפתוח את הפרויקט באמצעות Xcode ולהריץ את האפליקציה. לקבלת הוראות, תוכלו לעיין במדריך ההגדרה ל-iOS.

רכיבים עיקריים

הקבצים הבאים מכילים את הקוד החיוני לאפליקציה לדוגמה של 'זיהוי פנים':

• FaceDetectorService.swift: מפעיל את הגלאי, מטפל בבחירת המודל ומריץ מסקנות על נתוני הקלט.
• CameraViewController: הטמעת ממשק המשתמש של מצב הקלט של פיד המצלמה בשידור חי והצגה חזותית של תוצאות הזיהוי.
• MediaLibraryViewController.swift: יישום של ממשק המשתמש למצב הקלט של קובץ וידאו ותמונות סטילס והצגה חזותית של תוצאות הזיהוי.

הגדרה

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

יחסי תלות

התכונה 'זיהוי פנים' משתמשת בספריית MediaPipeTasksVision, שאותה צריך להתקין באמצעות CocoaPods. הספרייה תואמת לאפליקציות של Swift וגם לאפליקציות Objective-C, ואין צורך בהגדרות נוספות ספציפיות לשפה.

תוכלו למצוא הוראות להתקנת CocoaPods ב-macOS במדריך ההתקנה של CocoaPods. לשימוש ב-CocoaPods תוכלו למצוא הוראות ליצירת Podfile עם הרפידות הנדרשות לאפליקציה.

מוסיפים את רצף MediaPipeTasksVision ב-Podfile באמצעות הקוד הבא:

target 'MyFaceDetectorApp' do
  use_frameworks!
  pod 'MediaPipeTasksVision'
end

אם האפליקציה שלך כוללת יעדים של בדיקת יחידה, עיין במדריך ההגדרה ל-iOS למידע נוסף על הגדרת ה-Podfile.

מודל

למשימה 'זיהוי פנים של MediaPipe' נדרש מודל מאומן שתואם למשימה הזו. בסקירה הכללית על המשימות קטע על מודלים, תוכלו לקרוא על המודלים הזמינים המאומנים לשימוש בתכונה 'זיהוי פנים'.

בוחרים מודל ומורידים אותו, ומוסיפים אותו לספריית הפרויקט באמצעות Xcode. במאמר ניהול קבצים ותיקיות בפרויקט Xcode מוסבר איך מוסיפים קבצים לפרויקט Xcode.

השתמשו במאפיין BaseOptions.modelAssetPath כדי לציין את הנתיב למודל ב-App Bundle. דוגמה לקוד זמינה בקטע הבא.

יצירת המשימה

אפשר ליצור את המשימה של 'זיהוי פנים' על ידי קריאה לאחד מהמפעילים שלה. המאתחל של FaceDetector(options:) מקבל ערכים לאפשרויות התצורה.

אם אין לכם צורך באתחול של 'מזהה פנים' עם אפשרויות הגדרה מותאמות אישית, תוכלו להשתמש במאתחל FaceDetector(modelPath:) על מנת ליצור 'זיהוי פנים' עם אפשרויות ברירת המחדל. מידע נוסף על אפשרויות ההגדרה זמין במאמר סקירה כללית בנושא הגדרות.

משימת 'זיהוי פנים' תומכת ב-3 סוגים של נתוני קלט: תמונות סטילס, קובצי וידאו ושידורי וידאו בשידור חי. כברירת מחדל, FaceDetector(modelPath:) מפעיל משימה לגבי תמונות סטילס. אם רוצים שהמשימה תאותחל כדי לעבד קובצי וידאו או סטרימינג של וידאו בשידור חי, צריך להשתמש ב-FaceDetector(options:) כדי לציין את מצב ההפעלה של הסרטון או השידור החי. למצב השידור החי נדרשת גם אפשרות ההגדרה הנוספת faceDetectorLiveStreamDelegate, שמאפשרת ל'זיהוי פנים' לשלוח תוצאות של זיהוי פנים לאדם שהוענקה לו גישה באופן אסינכרוני.

בחרו את הכרטיסייה שמתאימה למצב הריצה שלכם כדי לראות איך ליצור את המשימה ולהסיק את ההסקה.

Swift

import MediaPipeTasksVision

let modelPath = Bundle.main.path(forResource: "model",
                                      ofType: "tflite")

let options = FaceDetectorOptions()
options.baseOptions.modelAssetPath = modelPath
options.runningMode = .image

let faceDetector = try FaceDetector(options: options)
    

import MediaPipeTasksVision

let modelPath = Bundle.main.path(forResource: "model",
                                      ofType: "tflite")

let options = FaceDetectorOptions()
options.baseOptions.modelAssetPath = modelPath
options.runningMode = .video

let faceDetector = try FaceDetector(options: options)
    

import MediaPipeTasksVision

// Class that conforms to the `FaceDetectorLiveStreamDelegate` protocol and
// implements the method that the face detector calls once it finishes
// detecting faces in each input frame.
class FaceDetectorResultProcessor: NSObject, FaceDetectorLiveStreamDelegate {

  func faceDetector(
    _ faceDetector: FaceDetector,
    didFinishDetection result: FaceDetectorResult?,
    timestampInMilliseconds: Int,
    error: Error?) {

    // Process the face detection result or errors here.

  }
}

let modelPath = Bundle.main.path(
  forResource: "model",
  ofType: "tflite")

let options = FaceDetectorOptions()
options.baseOptions.modelAssetPath = modelPath
options.runningMode = .liveStream

// Assign an object of the class to the `faceDetectorLiveStreamDelegate`
// property.
let processor = FaceDetectorResultProcessor()
options.faceDetectorLiveStreamDelegate = processor

let faceDetector = try FaceDetector(options: options)
    

Objective-C

@import MediaPipeTasksVision;

NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model"
                                                      ofType:@"tflite"];

MPPFaceDetectorOptions *options = [[MPPFaceDetectorOptions alloc] init];
options.baseOptions.modelAssetPath = modelPath;
options.runningMode = MPPRunningModeImage;

MPPFaceDetector *faceDetector =
      [[MPPFaceDetector alloc] initWithOptions:options error:nil];
    

@import MediaPipeTasksVision;

NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model"
                                                      ofType:@"tflite"];

MPPFaceDetectorOptions *options = [[MPPFaceDetectorOptions alloc] init];
options.baseOptions.modelAssetPath = modelPath;
options.runningMode = MPPRunningModeVideo;

MPPFaceDetector *faceDetector =
      [[MPPFaceDetector alloc] initWithOptions:options error:nil];
    

@import MediaPipeTasksVision;

// Class that conforms to the `MPPFaceDetectorLiveStreamDelegate` protocol
// and implements the method that the face detector calls once it finishes
// detecting faces in each input frame.

@interface APPFaceDetectorResultProcessor : NSObject 

@end

@implementation APPFaceDetectorResultProcessor

-   (void)faceDetector:(MPPFaceDetector *)faceDetector
    didFinishDetectionWithResult:(MPPFaceDetectorResult *)faceDetectorResult
         timestampInMilliseconds:(NSInteger)timestampInMilliseconds
                           error:(NSError *)error {

    // Process the face detector result or errors here.

}

@end

NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model"
                                                      ofType:@"tflite"];

MPPFaceDetectorOptions *options = [[MPPFaceDetectorOptions alloc] init];
options.baseOptions.modelAssetPath = modelPath;
options.runningMode = MPPRunningModeLiveStream;

// Assign an object of the class to the `faceDetectorLiveStreamDelegate`
// property.
APPFaceDetectorResultProcessor *processor = [APPFaceDetectorResultProcessor new];
options.faceDetectorLiveStreamDelegate = processor;

MPPFaceDetector *faceDetector =
      [[MPPFaceDetector alloc] initWithOptions:options error:nil];
    

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

אפשרויות הגדרה

המשימה כוללת את אפשרויות ההגדרה הבאות לאפליקציות ל-iOS:

הגדרת השידור החי

כשמצב הריצה מוגדר לשידור חי, לגלאי הפנים נדרשת אפשרות הגדרה נוספת של faceDetectorLiveStreamDelegate, שמאפשרת לגלאי הפנים לשלוח את תוצאות הזיהוי באופן אסינכרוני. מקבל הגישה מטמיע את השיטה faceDetector(_:didFinishDetection:timestampInMilliseconds:error:), שמזהה הפנים קורא לה אחרי עיבוד תוצאות זיהוי הפנים של כל פריים.

הכנת הנתונים

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

בחר פורמט תמונה של iOS בהתאם לתרחיש לדוגמה שלך ולמצב הריצה הנדרש לאפליקציה.MPImage מקבל את הפורמטים UIImage, CVPixelBuffer ו-CMSampleBuffer של תמונות iOS.

UIImage

הפורמט UIImage מתאים במיוחד למצבי הריצה הבאים:

• תמונות: אפשר להמיר תמונות מ-App Bundle, מגלריית משתמש או ממערכת קבצים בפורמט UIImage של תמונות לאובייקט MPImage.

• סרטונים: כדאי להשתמש ב-AVAssetImageGenerator כדי לחלץ פריימים של סרטון לפורמט CGImage, ואז להמיר אותם לפורמט UIImage תמונות.

// Load an image on the user's device as an iOS `UIImage` object.

// Convert the `UIImage` object to a MediaPipe's Image object having the default
// orientation `UIImage.Orientation.up`.
let image = try MPImage(uiImage: image)
    

// Load an image on the user's device as an iOS `UIImage` object.

// Convert the `UIImage` object to a MediaPipe's Image object having the default
// orientation `UIImageOrientationUp`.
MPImage *image = [[MPPImage alloc] initWithUIImage:image error:nil];
    

הדוגמה הזו מפעילה MPImage עם כיוון ברירת המחדל UIImage.Orientation.Up. אפשר לאתחל MPImage עם כל אחד מהערכים הנתמכים של UIImage.Orientation. בגלאי הפנים אין תמיכה בשיקוף מסך כמו .upMirrored, .downMirrored, .leftMirrored, .rightMirrored.

מידע נוסף על UIImage זמין במסמכי התיעוד למפתחים של UIImage למפתחים של Apple.

CVPixelBuffer

הפורמט CVPixelBuffer מתאים מאוד לאפליקציות שיוצרות פריימים ומשתמשים ב-CoreImage של iOS לעיבוד.

הפורמט CVPixelBuffer מתאים במיוחד למצבי הריצה הבאים:

• תמונות: אפליקציות שיוצרות תמונות CVPixelBuffer לאחר עיבוד מסוים באמצעות CoreImage framework של iOS, יכולות להישלח לגלאי הפנים במצב הרצת תמונה.

• סרטונים: אפשר להמיר פריימים של סרטון לפורמט CVPixelBuffer לעיבוד, ואז לשלוח אותם לגלאי הפנים במצב וידאו.

• בשידור חי: אפליקציות שמשתמשות במצלמת iOS כדי ליצור תמונות עשויות להיות בפורמט CVPixelBuffer לעיבוד, לפני שהן יישלחו ל'גלאי הפנים' במצב סטרימינג בשידור חי.

// Obtain a CVPixelBuffer.

// Convert the `CVPixelBuffer` object to a MediaPipe's Image object having the default
// orientation `UIImage.Orientation.up`.
let image = try MPImage(pixelBuffer: pixelBuffer)
    

// Obtain a CVPixelBuffer.

// Convert the `CVPixelBuffer` object to a MediaPipe's Image object having the
// default orientation `UIImageOrientationUp`.
MPImage *image = [[MPPImage alloc] initWithUIImage:image error:nil];
    

מידע נוסף על CVPixelBuffer זמין במסמכי התיעוד למפתחים של CVPixelBuffer Apple.

CMSampleBuffer

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

// Obtain a CMSampleBuffer.

// Convert the `CMSampleBuffer` object to a MediaPipe's Image object having the default
// orientation `UIImage.Orientation.up`.
let image = try MPImage(sampleBuffer: sampleBuffer)
    

// Obtain a `CMSampleBuffer`.

// Convert the `CMSampleBuffer` object to a MediaPipe's Image object having the
// default orientation `UIImageOrientationUp`.
MPImage *image = [[MPPImage alloc] initWithSampleBuffer:sampleBuffer error:nil];
    

מידע נוסף על CMSampleBuffer זמין במסמכי התיעוד למפתחים של Apple ב-CMSampleBuffer.

מריצים את המשימה.

כדי להפעיל את מזהה הפנים, צריך להשתמש בשיטה detect() הספציפית למצב הריצה שהוקצה:

• תמונת סטילס: detect(image:)
• סרטון: detect(videoFrame:timestampInMilliseconds:)
• צפייה בשידור חי: detectAsync(image:timestampInMilliseconds:)

'מזהה הפנים' מחזיר את הפנים שזוהו בתוך תמונת הקלט או מסגרת הקלט.

דוגמאות הקוד הבאות מציגות דוגמאות פשוטות להפעלת גלאי הפנים במצבי הריצה השונים:

Swift

let result = try faceDetector.detect(image: image)
    

let result = try faceDetector.detect(
  videoFrame: image,
  timestampInMilliseconds: timestamp)
    

try faceDetector.detectAsync(
  image: image,
  timestampInMilliseconds: timestamp)
    

Objective-C

MPPFaceDetectorResult *result = [faceDetector detectInImage:image
                                                      error:nil];
    

MPPFaceDetectorResult *result = [faceDetector detectInVideoFrame:image
                                         timestampInMilliseconds:timestamp
                                                           error:nil];
    

BOOL success = [faceDetector detectAsyncInImage:image
                        timestampInMilliseconds:timestamp
                                          error:nil];
    

בדוגמה של הקוד של מזהה הפנים אפשר לראות את ההטמעה של כל אחד מהמצבים האלה בפירוט רב יותר: detect(image:), detect(videoFrame:timestampInMilliseconds:) ו-detectAsync(image:timestampInMilliseconds:). הקוד לדוגמה מאפשר למשתמשים לעבור בין מצבי עיבוד, שאולי לא נחוצים בתרחיש לדוגמה שלכם.

שימו לב לנקודות הבאות:

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

• כשמפעילים את התכונה במצב תמונה או וידאו, המשימה של 'זיהוי פנים' חוסמת את ה-thread הנוכחי עד לסיום העיבוד של התמונה או המסגרת של הקלט. כדי למנוע את החסימה של ה-thread הנוכחי, צריך להפעיל את העיבוד ב-thread ברקע באמצעות Dispatch של iOS או NSOperation.

• כשמפעילים את התכונה במצב חי, המשימה 'זיהוי פנים' חוזרת מיידית ולא חוסמת את השרשור הנוכחי. אחרי העיבוד של כל פריים קלט, תופעל השיטה faceDetector(_:didFinishDetection:timestampInMilliseconds:error:) עם תוצאת זיהוי הפנים. השיטה 'זיהוי פנים' מפעילה את השיטה הזו באופן אסינכרוני בתור ייעודי לשליחה טורית. כדי להציג תוצאות בממשק המשתמש, צריך לשלוח את התוצאות לתור הראשי אחרי עיבוד התוצאות. אם קוראים לפונקציה detectAsync כשהמשימה של 'זיהוי פנים' עסוקה בעיבוד פריים אחר, 'מזהה הפנים' מתעלם ממסגרת הקלט החדשה.

טיפול בתוצאות והצגתן

לאחר הרצה של הסקת מסקנות, המשימה של 'מזהה הפנים' מחזירה אובייקט FaceDetectorResult שמכיל את התיבות התוחמות של הפנים שזוהו, וציון מהימנות לכל פנים שזוהו.

דוגמה לנתוני הפלט מהמשימה הזאת:

FaceDetectionResult:
  Detections:
    Detection #0:
      BoundingBox:
        origin_x: 126
        origin_y: 100
        width: 463
        height: 463
      Categories:
        Category #0:
          index: 0
          score: 0.9729152917861938
      NormalizedKeypoints:
        NormalizedKeypoint #0:
          x: 0.18298381567001343
          y: 0.2961040139198303
        NormalizedKeypoint #1:
          x: 0.3302789330482483
          y: 0.29289937019348145
        ... (6 keypoints for each face)
    Detection #1:
      BoundingBox:
        origin_x: 616
        origin_y: 193
        width: 430
        height: 430
      Categories:
        Category #0:
          index: 0
          score: 0.9251380562782288
      NormalizedKeypoints:
        NormalizedKeypoint #0:
          x: 0.6151331663131714
          y: 0.3713381886482239
        NormalizedKeypoint #1:
          x: 0.7460576295852661
          y: 0.38825345039367676
        ... (6 keypoints for each face)

התמונה הבאה מציגה המחשה של פלט המשימה:

לגבי התמונה ללא תיבות תוחמות, יש לעיין בתמונה המקורית.

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