מעקב אחר אובייקטים עם AI עבור iOS ואנדרואיד: פיתוח ואופטימיזציה

תארו לעצמכם: אפליקציית המובייל שלכם סופרת מבקרים בחנות, אבל בכל פעם שאדם יוצא מהפריים וחוזר, המערכת סופרת אותו כחדש. זו השגיאה הקלאסית של זיהוי נאיבי ללא מעקב — אובדן זהות האובייקט. קחו מקרה אמיתי: אוטומציה של ספירת מבקרים בקניון באמצעות מצלמות כניסה. ללא מעקב, המערכת ספרה בטעות את אותו אדם מספר פעמים אם הוא עזב לזמן קצר את שדה הראייה. לאחר הטמעת ByteTrack עם פילטר קלמן, התוצאות השגויות ירדו ב-90%. אנחנו פותרים זאת על ידי שילוב מעקב בינה מלאכותית שמקשר בין אובייקטים על פני פריימים ושומר על המזהים הייחודיים שלהם. מלבד החלפות מזהים, עולות בעיות עם חסימות (אובייקט מוסתר זמנית) או תנועה מהירה (אובייקט זז מעבר לקצה הפריים). מההתחלה, חשוב להבין: מעקב הוא לא רק זיהוי על כל פריים, אלא אסוציאציה של אובייקטים לאורך זמן. לפי ByteTrack, שימוש בזיהויים עם ביטחון נמוך מפחית החלפות מזהים ב-30-40%.

למה מעקב קשה יותר מזיהוי?

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

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

אנחנו משתמשים בשתי גישות: SOT (אובייקט יחיד) ו-MOT (אובייקטים מרובים). הבחירה תלויה בתרחיש.

מה הם SOT ו-MOT?

SOT (מעקב אובייקט יחיד)

המשתמש מקיש על אובייקט — האפליקציה עוקבת אחריו. יישומים: שידורי ספורט, מעקב אחר אדם ספציפי בפריים, משחקי AR. אלגוריתמים: SiamFC, OSTrack, STARK. ב-iOS — Vision VNTrackObjectRequest.

MOT (מעקב אובייקטים מרובים)

מעקב בו-זמני אחר כל האובייקטים במחלקה הנדרשת. יישומים: ספירת מבקרים, ניטור תנועה, פסי ייצור. אלגוריתמים: SORT, ByteTrack, StrongSORT, OC-SORT.

למה ByteTrack אמין יותר מ-SORT?

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

// Android: ByteTrack ассоциация
class ByteTracker(
    private val trackThresh: Float = 0.5f,
    private val highThresh: Float = 0.6f,
    private val matchThresh: Float = 0.8f
) {
    private val trackedStracks = mutableListOf<STrack>()
    private val lostStracks = mutableListOf<STrack>()

    fun update(detections: List<Detection>): List<STrack> {
        val highDetections = detections.filter { it.confidence >= highThresh }
        val lowDetections = detections.filter { it.confidence in trackThresh..<highThresh }

        val (matches1, unmatched_tracks1, unmatched_dets1) = linearAssignment(trackedStracks, highDetections, matchThresh)
        val (matches2, _, _) = linearAssignment(unmatched_tracks1, lowDetections, 0.5f)

        val newTracks = unmatched_dets1.map { STrack(it) }
        return (matches1 + matches2).map { it.track } + newTracks
    }
}

ByteTrack מפחית החלפות מזהים ב-30-40% בהשוואה ל-SORT במהלך חסימות תכופות. בינתיים, המורכבות החישובית נשארת נמוכה — העוקב רץ על CPU ללא התחממות ניכרת.

איך עובדת צנרת הגלאי-עוקב ב-iOS?

צנרת סטנדרטית למובייל:

// iOS: YOLOv8 детекция + SORT трекинг
class MultiObjectTracker {
    private let detector: YOLOv8Detector
    private let tracker: SORTTracker

    // SORT параметры — важно подобрать под задачу
    init(targetClass: String,
         maxAge: Int = 10, // кадров без детекции до удаления трека
         minHits: Int = 3, // кадров детекции для подтверждения трека
         iouThreshold: Float = 0.3) {
        self.detector = YOLOv8Detector(targetClass: targetClass)
        self.tracker = SORTTracker(maxAge: maxAge, minHits: minHits, iouThreshold: iouThreshold)
    }

    func processFrame(_ pixelBuffer: CVPixelBuffer) async -> [TrackedObject] {
        let detections = await detector.detect(pixelBuffer)
        let tracks = tracker.update(detections: detections.map { det in
            Detection(bbox: det.boundingBox, confidence: det.confidence)
        })
        return tracks.map { track in
            TrackedObject(
                id: track.trackId,
                boundingBox: track.bbox,
                isConfirmed: track.hitStreak >= tracker.minHits,
                velocity: track.kalmanFilter.velocity
            )
        }
    }
}

maxAge = 10 — המעקב חי 10 פריימים ללא זיהוי (אובייקט מאחורי מכשול). ב-30 FPS, זה 333 אלפיות שנייה — מספיק לחסימות קצרות.

איך ליישם ByteTrack ב-5 שלבים?

1. בחרו מודל זיהוי: YOLOv8-nano (INT8) למובייל — מהיר פי 2, mAP יורד ב-1-2%.
2. כוונו את העוקב: הגדירו trackThresh=0.5, highThresh=0.6, matchThresh=0.8.
3. שלבו צנרת: זיהוי על כל פריים, מעקב אחרי סינון זיהויים עם ביטחון נמוך.
4. עבדו מעקבים: דרך Metal/OpenGL — עד 60 FPS במכשירים בינוניים.
5. בצעו אופטימיזציה: הורידו FPS ל-15-20 אם הדיוק לא קריטי — חוסך 40% אנרגיה.

טעויות נפוצות ואיך להימנע מהן

// iOS: ByteTrack pipeline (упрощённо)
class ByteTrackPipeline {
    private let detector: YOLOv8Detector = .init()
    private var tracker: ByteTracker = .init()

    func process(pixelBuffer: CVPixelBuffer) async -> [Track] {
        let detections = await detector.detect(pixelBuffer)
        let tracks = tracker.update(detections: detections)
        return tracks
    }
}

איך להפחית עומס CPU במהלך מעקב בינה מלאכותית?

השתמשו במודלים מקוונטזים (INT8) לזיהוי — האצה עד פי 2 ללא ירידה ניכרת ב-mAP. העוקבים SORT ו-ByteTrack קלים בעצמם וניתנים להרצה על CPU. עבדו תיבות תחום דרך Metal (iOS) או OpenGL (Android) כדי להקל על ה-thread הראשי. ב-iOS, חברו את Core ML עם Neural Engine; ב-Android, NNAPI. אם הדיוק לא קריטי, הורידו את קצב ה-FPS של זרם הווידאו ל-15-20 — חוסך עד 40% אנרגיה.

מה כלול בעבודת המעקב שלנו

• ניתוח משימה: בחירת גישה (SOT/MOT), מחלקות יעד, תרחישי חסימה.
• אב-טיפוס: אימון או כוונון עדין של מודל הזיהוי, בחירת עוקב.
• פיתוח מודול: שילוב גלאי ועוקב, עיבוד מעקבים, טיפול בכיוון המצלמה.
• אופטימיזציה: צריכת חשמל נמוכה, עבודה ב-30 FPS במכשירים בינוניים.
• בדיקות: 50+ תרחישים (שינויי תאורה, תנועה מהירה, הצלבות).
• תמיכה: תיעוד, קוד מקור, הדרכת צוות.

יש לנו ניסיון של 5+ שנים בפיתוח מובייל ויישמנו מעקב לקמעונאות, לוגיסטיקה וספורט. קבלו ייעוץ מהנדס — נבחן את הפרויקט שלכם ונציע פתרון.

הערכות לוחות זמנים

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