עיצוב ויישום של מסגרת זיהוי הולכי רגל מבוססת מערך שערים מתוכנתת בשטח ליישום נהיגה אוטונומית

Summary

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

Abstract

נהיגה אוטונומית מציעה דרך מבטיחה להתמודד עם העלייה במספר ההרוגים מתאונות דרכים. רכב אוטונומי כולל תכונות רבות, אך היכולת לזהות הולכי רגל היא קריטית, מאתגרת ורלוונטית למצבים בזמן אמת כמו מעקב, מעקב אחרי אנשים ומעקב. זיהוי מדויק של הולכי רגל הוא קשה כי הם יכולים להופיע בצורות, תנוחות ותנוחות שונות. הם יכולים ללבוש סוגים שונים של בגדים ולעיתים מוסתרים חלקית או משתלבים עם חפצים סמוכים. מאמר זה מתמקד בזיהוי בזמן אמת של הולכי רגל עבור רכבים אוטונומיים באמצעות פלטפורמת חומרה פופולרית: מערך שערים מתוכנת שדה (FPGA), Ultra 96 v2. המחקר מיישם שיטה לזיהוי הולכי רגל המבוססת על היסטוגרמה של גרדיאנטים מכוונים (HOG) בשילוב מסווג מכונת וקטור תמיכה (SVM) לזיהוי פרטים בלוח FPGA, תוך ניצול כלי סינתזה ברמה גבוהה (HLS). יעילות המערכת נבדקה הן בתמונות סטילס והן בווידאו חי. התוצאות מראות שלוחות FPGA מתקדמים כמו Ultra 96 v2 משפרים משמעותית את מדדי הביצועים. המערכת פועלת בתדר שעון של 150 מגה-הרץ, תוך שימוש בפחות ממחצית מהמשאבים הזמינים וצריכת כ-2.5 וואט של חשמל. כמו כן, המערכת מדווחת על דיוק זיהוי הולכי רגל קרוב ל-95% ומדדים יעילים נוספים להערכת גילוי, כמו דיוק (78.6%), קריאה (88.3%) וציון F1 (83.1%). לסיכום, המערכת המפותחת יכולה לזהות הולכי רגל בזמן אמת ויש לה פוטנציאל לשפר משמעותית פיתוח סביבה תחבורתית חכמה ובטוחה.

Introduction

פיתוח עירוני והופעת ערים חכמות הם נושאים מעניינים ברחבי העולם. כל המדינות פועלות לפיתוח עריהן שניתן לבנות כך שיהיו בטוחות ונוחות לאנשים החיים בהן ^1,2. אך במצב הנוכחי, נצפה שככל שהאוכלוסייה גדלה והעומס בכבישים גובר, שיעור ההרוגים כתוצאה מתאונות דרכים עקב רשלנות נהיגה ובעיות ראות לקויה עולה באופן מדאיג. פתרון מבטיח לבעיות אלו הוא הופעתם של כלי רכב אוטונומיים ברחבי העולם, שהובילו לחדשנות 1,2,3,4 וחוקרים משקיעים מאמצים לפתח רכבים אוטונומיים לחלוטין שיאפשרו לנוסעים להירגע ללא חששות. הצורך בפיתוח רכבים אוטונומיים נובע מהעובדה שגם נהגים מנוסים עלולים להתמודד עם לחץ, דילמות, עייפות או קשיים בזיהוי סביבתם עקב מזג אוויר גרוע, וכל הבעיות הללו מובילות לתאונות דרכים. רכב אוטונומי תוכנן למנוע תאונות במהלך הנסיעה, לייעל את השימוש במשאבי המנוע, ולעמוד בחוקי התנועה, מה שישפרו ללא ספק את התחבורה ^2,4. רכב אוטונומי מצויד במספר תכונות, חיישנים ופונקציות שמאפשרים לו לחוש את סביבתו בדיוק רב, ולמנוע התנגשות ותאונות, ולכן הוא הפך לפתרון מבטיח להפיכת התחבורה לבטוחה ^{ומאובטחת} 1,2,3,4.

מבין כל התכונות המשולבות ברכב אוטונומי, אחת החשובות ביותר היא זיהוי הולכי רגל. מערכת זיהוי הולכי רגל חזקה יכולה לסייע משמעותית בהפחתת מספר ההרוגים בתאונות דרכים ב-5,6,7,8, שכן רוב הנפגעים בתאונות אלו הם הולכי רגל. זיהוי הולכי רגל כולל זיהוי אנשים בכביש ומניעת התנגשות איתם. תכונה זו לא מועילה רק לרכבים אוטונומיים, אלא גם לתחומים נוספים כמו ניטור קהל, זיהוי אדם ומעקב ^9,10,11. ההיבט המרכזי בתהליך הגילוי הזה הוא המהירות והדיוק של הגילוי. חשוב לזהות הולכי רגל בדיוק ומהיר, כדי שזמן התגובה יהיה מינימלי. יש אתגר עצום שמציב גילוי הולכי רגל. הולכי רגל על הכביש יכולים להיות בכל בגדים, מראה או יציבה, ועלולים להיות בלתי נראים עקב מזג אוויר גרוע או חסימה 10,11,12,13,14. יתרה מזאת, ייתכן מאוד שהולכי רגל לא יפעלו לפי הכללים בעצמם, ואי אפשר לשלוט בטבע האדם, ולכן הגישה הטובה ביותר היא לצייד את הרכב באינטליגנציה כדי להתמודד עם כל פעולה לא נכונה ולמנוע מקרי מוות. הזרימה המלאה של העבודה במחקר זה והמוטיבציה מאחורי יישום החומרה של זיהוי הולכי רגל ניתנים להבנה בקלות מאיור 1 למטה, שמסביר את הצורך בזיהוי הולכי רגל, תחומי היישום השונים שלו, האתגרים הכרוכים בכך, והיישום ב-FPGA כדי לנצל את היתרונות המוצעים.

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

כדי לזהות הולכי רגל בכביש, קיימים אלגוריתמים רבים. המשימה הכוללת הזו ניתנת לחלוקה בעיקר לשתי תת-משימות עיקריות: השלב הראשוני מחלץ תכונות מתמונת קלט, תוך שמירה רק על אלו המשמעותיות שמעבירותן מידע רלוונטי, תוך התעלמות מהמיותרות. לזיהוי יעיל של בני אדם או הולכי רגל בתמונה, חיוני שתכונות אלו יצייטו על נוכחות דמות אנושית בסצנה^13,14. לאחר חילוץ זה, יש לשלוח את התכונות למסווג שיכול לקבוע האם התכונות שזוהו תואמות לאדם. לכן, האלגוריתם דורש שלב חילוץ תכונות ותיאור, ואחריו שלב סיווג לקביעת נוכחות הולכי הרגל בסצנת הקלט. קיימים אלגוריתמים שונים למטרה זו. עם זאת, השיטה המקובלת ביותר עד כה לזיהוי הולכי רגל היא השילוב של היסטוגרמה של שיפועים מכוונים (HoG) עם מסווג מכונת וקטור התמיכה (SVM) 12,13,14,15. קיימות דוגמאות רבות להתקדמות תוכנה, אך בסופו של דבר המטרה היא להעביר את היישום לפלטפורמת חומרה תואמת, שניתן לשלב אותה במערכת היישום לשימוש בזמן אמת. לכן, הדגש הנוכחי הוא על מימוש חומרה. לכן ניתן לומר שיש לפתח יישום חומרתי מתאים של מערכות זיהוי הולכי רגל, שבו מצלמות המצוידות בחומרה מתאימה יוכלו להציב על כלי רכב ולזהות הולכי רגל בכביש. כאשר בוחנים איזו חומרה מתאימה ליישומים כאלה, אחת האפשרויות הנפוצות ביותר היא מערך שערים מתוכנת בשדה (FPGA) בשל יתרונותיו הרבים, כולל זמן תכנון קצר, יכולת הרחבה, קלות שינויים, יכולת תצורה מחדש, וצריכת אנרגיה ואנרגיה נמוכה יותר 15,16,17,18,19,20,21,²².

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

למעלה מעשור פורסמו פרסומים משמעותיים המבוססים על יישום זיהוי הולכי רגל באמצעות שיטת HoG ו-SVM בפלטפורמות FPGA שונות. טבלה 1 מסכמת את המאמרים בתחום זה בתקופה שבין 2015 ל-2025: 15,16,17,18,19,20,21,22,23,24, ומתמקדת בגורמים המרכזיים כמו רזולוציית התמונה, קצב התפוקה, או הפריימים לשנייה (FPS), סוג המסווג, והדגשים המרכזיים או התרומות של נייר.

מקור	פלטפורמת FPGA	רזולוציית תמונה	מסווג	הדגשים / תרומות מרכזיות
15	זילינקס זינק	640×480	AdaBoost	יישום FPGA בזמן אמת; יעילות משאבים; משתמש בבינריזציה לאופטימיזציה; דיוק זיהוי טוב.
16	לוח DE1-SOC של טראסיק	640×480	SVM	מחלץ HOG בעל ביצועים גבוהים; אינטגרציה של SVM; גילוי בקנה מידה יחיד; צינור עם השהיה נמוכה.
17	אלטרה DE2-115	640×480	AdaBoost	מעריך ביצועים מנקודות מבט שונות; מימוש FPGA של HOG+AdaBoost; זיהוי הולכי רגל בזמן אמת.
18	אינטל סטרטיקס V	640×480	SVM	זיהוי הולכי רגל בקנה מידה רב; צינור HOG+SVM הידידותי ל-FPGA; מדגיש את הפשרות בין דיוק ליעילות חומרה.
19	Zynq UltraScale+ MPSoC	3840×2160	SVM	עיבוד UHD בזמן אמת; HOG+SVM בצינור צינור; יישום SoC FPGA; אופטימיזציה בנקודה קבועה; ארכיטקטורה ניתנת להרחבה.
20	לא צוין	לא צוין	SVM	משיג >95% דיוק גילוי; יישום FPGA בזמן אמת; מנצל מקביליות; עיצוב FPGA מפורט של HOG+SVM לזיהוי הולכי רגל.
21	Zync 7000 FPGA	1920×1080	SVM	ארכיטקטורת זרמים בתפוקה גבוהה עבור HOG+SVM; תומך ברזולוציית HD; צינור יעיל להאצת FPGA.
22	אולטרה-96 (גרסה 1)	240×320	SVM	יישום FPGA באמצעות HLS; מזהה רמזורים אדומים; מחשב הסתברויות ב-891 אזורים; ההשהיה נעה בין 153,838 ל-19 מחזורים.
23	Xilinx Zynq-7000 FPGA	640 × 480	HOG + SVM	יישמו זיהוי הולכי רגל באמצעות HOG-SVM ב-FPGA, והשיגו ביצועים בזמן אמת עם צריכת חשמל מופחתת בהשוואה לעיבוד מעבד. הדגים צינור חילוץ תכונות אופטימלי המתאים ליישומי ראייה משובצת.
24	Xilinx Virtex-6 FPGA	640 × 480	גלאי עצמים בנקודה קבועה (תכונות דמויות האר)	הצעת האצת FPGA בתפוקה גבוהה לזיהוי עצמים באמצעות חשבון נקודה קבועה, תוך הפחתת עלות חישובית תוך שמירה על דיוק. הראה האצה של 15× לעומת מימושי CPU עם ניצול יעיל של משאבי חומרה.

טבלה 1: סקירת ספרות של מחקר המבוסס על זיהוי הולכי רגל ב-FPGA (2015–2025).

טבלה 1 מסכמת כי קיימת ספרות נרחבת בתחום גילוי הולכי רגל, ויישום חומרה הוא תחום העניין של החוקרים. ברור גם שיש טכניקות מתקדמות של למידה עמוקה ולמידת מכונה, כגון גלאים מבוססי רשתות עצביות קונבולוציונליות (CNNs) כמו YOLO, ארכיטקטורות מבוססות טרנספורמרים ועוד, למטרת זיהוי הולכי רגל. הם אף עולים על האלגוריתם המסורתי של HoG מבחינת דיוק, אך כאשר בוחנים יישום חומרה, האלגוריתמים המתקדמים מובילים לניצול משאבים עצום^23,24 בשל המורכבות של האלגוריתם, מה שעשוי להשפיע גם על פרמטרי ביצועים אחרים, ונצפה שבגלל המורכבויות הנוספות המהירות מעט טובה יותר במקרה של אלגוריתם HoG המסורתי ^{24. 25}. נצפה גם כי הטכניקות המתקדמות צורכות יותר חשמל כאשר הן מיושמות על חומרה^24,26. לפיכך, מטרת העבודה המיושמת במאמר זה היא לבצע זיהוי הולכי רגל באמצעות מסגרת HoG ו-SVM המסורתית על חומרת FPGA ולהשיג שוורת דיוק, מהירות, משאב ועוצמה נוחים להטמעה בזמן אמת. מטבלה 1 ברור היטב שכאשר מנתחים את העבודה מבוססת HoG ו-SVM, נצפה כי ישנם פרסומים מוגבלים שהשתמשו לאחרונה בלוח פיתוח FPGA²⁷ המבוסס על Zynq UltraScale+ MPSoC (Multi-Processor System On Chip) כדי לבחון את יכולות הלוחות הללו, שכן מבחינת הארכיטקטורה הלוחות הללו התפתחו, ומציעים פוטנציאל רב מבחינת יישום מתקדם לראיית מחשב בזמן אמת. ישנם פרסומים מוגבלים שמימשו את כל מערכת זיהוי הולכי הרגל בזמן אמת על לוחות FPGA. עם זאת, הם התמקדו ביישום יעיל או שיפור של המשימות הבינוניות. יתרה מזאת, רוב המימושים הללו מבוססים על מימוש כל המערכת על לוח FPGA באמצעות שפות תיאור חומרה. מעטים ניצלו את היתרונות של כלי סינתזה ברמה גבוהה (HLS) כדי להאיץ את מחזור התכנון. מאמר זה מדגים את העיצוב והיישום של זיהוי הולכי רגל בזמן אמת על לוח FPGA המוקדש ליישום נהיגה אוטונומית. המאמר עושה שימוש במסגרת HoG ו-SVM לצורך זיהוי הולכי רגל בתמונות סטילס, וידאו או קלט מצלמה אמיתי. החומרה שבה נעשה שימוש היא לוח FPGA חדשני שיצא לאחרונה, Ultra96 v2, שהוא ארכיטקטורת FPGA מתקדמת ומהווה פלטפורמה עוצמתית לראיית מחשב, עיבוד תמונה, למידת מכונה, מחשוב קצה ^ועוד. ה-Ultra96 v2 הוא לוח פיתוח הכולל מערכת AMD Xilinx Zynq UltraScale+ MPSoC²⁷ מבוססת Arm. לוח זה כולל את מקטע מערכת העיבוד (PS), המורכב מליבות מעבד מבוססות ARM שמנהלות את היבטי התוכנה של הפרויקט, ואת מקטע הלוגיקה המתוכנתת (PL) שמאפשר האצת חומרה מותאמת אישית 20,21,22. יחד, רכיבים אלו משפרים את הפונקציונליות של מערכת היברידית, שבה חלק ה-PS מנהל שליטה ואינטראקציה עם רכיבים חיצוניים, בעוד שחלק ה-PL מטפל בלוגיקת העיבוד עצמה.

Protocol

הליך היישום במחקר זה, המבוסס על זיהוי הולכי רגל עם HoG + SVM על לוח FPGA, תוך ניצול היתרונות של סינתזה ברמה גבוהה, מוצג באיור 2 למטה.

איור 2: הליך תכנון ליישום זיהוי הולכי רגל על לוח FPGA. שלב 1: אלגוריתם זיהוי הולכי רגל באמצעות HoG+SVM בכלי HLS ויצירת בלוק IP. שלב 2: אלגוריתם זיהוי הולכי רגל המשתמש ב-HoG+SVM ליישום FPGA בפועל ויצירת קובץ הסיביות. שלב 3: תכנות הלוח עם קובץ הביט שנוצר. אנא לחצו כאן כדי לצפות בגרסה מוגדלת של הדמות הזו.

1. זיהוי הולכי רגל באמצעות HoG ו-SVM בכלי HLS

1. הורד את סביבת הפיתוח המשולבת של פייתון (IDE) בהתאם למאפייני המערכת שעליהם מתבצעת ההורדה.
   הערה: בעבודה זו נעשה שימוש בגרסת פייתון 3.10.
2. הרצת סקריפט פייתון להרצת מודל אימון באמצעות אלגוריתם HoG ומסווג SVM. התחל את הסקריפט בטעינת הדגימות החיוביות והשליליות ממאגר הנתונים.
   הערה: השתמש במאגר הנתונים INRIA¹¹.
3. חלץ את תכונות HoG עבור גודל חלון של 64 על 128.
4. חלק את נתוני האימון והבדיקות ממאגר הנתונים של INRIA ליחס של 80/20 עם ערבוב אקראי לצורך שחזוריות.
   הערה: מערך הנתונים מתערבב באקראי באמצעות פונקציית פייתון לפני חלוקת הנתונים. כדי להבטיח שחזוריות כך שאותו פיצול יתבצע בכל פעם שערך זרע נקבע בקוד.
5. לאמן באמצעות סיווג וקטורי תמיכה C (SVC) SVM עם גרעין ליניארי.
6. חלץ את וקטורי המשקל וההטיה.
7. שמור את משקלי ה-SVM וההטיה בפורמט Q8.8 נקודה קבועה למימוש FPGA.
   הערה: ההמרה מתבצעת על ידי קנה מידה של כל ערך נקודה צפה המקוריות שנוצרת לפי 256 (2⁸) והטלת התוצאה למספר שלם.
8. בדקו את המודל המאומן דרך סקריפט פייתון אחר והתאימו את פרמטר הרגולריזציה C, עד שהדיוק מחושב ליותר מ-95%.
   הערה: פרמטר רגולריזציה אופטימלי שהושג: C = 0.05.
9. פתח את כלי HLS ויצר פרויקט חדש עם מספר החלק שנבחר כ-xczu3eg-sbva484-1-e.
10. כתוב קוד זיהוי הולכי רגל בכלי הסינתזה ברמה גבוהה באמצעות שפות ברמה גבוהה כמו C++.
11. בקוד, כתוב שלושה סקריפטים שונים ב-C++: אחד עבור מתאר התכונה HoG ומסווג SVM, אחר עבור testbench שמספק קלט לתמונות הבדיקה ושומר את תמונות הפלט, והשלישי לקובץ כותרת שמצהיר את הפרמטרים שבהם השתמשו בקוד.
12. בקוד לחישוב תכונות HoG, שנו את גודל התמונה ל-640 על 480 והחלו ארכיטקטורת חלונות מחליקים בגודל חלון של 64 על 128. לכל חלון, חשב את גודל הגרדיאנט והכיוון עבור כל בלוק חופף בגודל 8 על 8.
    הערה: חשוב לסרוק את כל התמונה דרך מושג החלון הנגרר כך שכל אזור בתמונה מכוסה ויזהו הולכי רגל בכל גודל אפשרי.
13. בחלק השני של אותו קוד עבור מתאר התכונות HoG, העבר את המדרונות המחושבים למסווג SVM. כתוב את הקוד להתאמת התכונות למשקלי המסווג והשווה עם הסף כדי לסווג את התכונה שזוהתה כשל אדם או לא.
14. לחץ על Run C Simulation בכלי HLS כדי לדמות את הקוד בעזרת שולחן בדיקה ולבדוק את נכונות הפונקציונליות של הקוד.
15. ספק תמונות קלט שונות לקוד ובדוק את תמונות הפלט עם הולכי הרגל שזוהו.
16. לחץ על Run C Synthesis כדי לסנתז את הקוד ולמפות את הקוד לשפות חומרה על ידי הכלי וליצור דוחות על תזמון ושימוש.
    הערה: הכלי פותח אוטומטית את דוחות הסינתזה של HLS. דוח זה מציג את ההערכה של תדר השעון הנדרש ליישום המשימה המקודדת בפלטפורמת FPGA נבחרה, ומספק גם הערכה של המשאבים שנוצלו. הערכים המדווחים הללו הם רק הערכות והפרמטרים בפועל מחושבים רק לאחר היישום בלוח FPGA.
17. לחצו על ייצוא RTL לייצא את בלוק הקניין הרוחני (IP) עבור אלגוריתם HoG לזיהוי הולכי רגל.
    הערה: IP זה מיועד לשימוש בשלבים המאוחרים של היישום.

2. תכנות לוח FPGA

1. פתח את הכלי לתכנות FPGA ויצר פרויקט חדש. בחר את מספר החלק כ-xczu3eg-sbva484-1-e וצור עיצוב בלוק חדש.
   הערה: דיאגרמת הבלוקים הזו נוצרה כדי ליצור אינטגרציה בין ה-PS לחלק PL של לוח ה-FPGA. פרוטוקול התקשורת בו משתמשים הוא פרוטוקול Advanced EXtensible Interface (AXI).
2. חפש את קטלוג ה-IP בכלי וכשאתה מצא, פתח אותו.
3. צור מאגר משתמש על ידי הוספת נתיב כתובת ה-IP של RTL המיוצאת בשלב 1.17.
4. בחלון עיצוב הבלוק החדש , עכשיו לחץ ימני ובחר להוסיף כתובת IP. כל כתובות ה-IP יהיו גלויות, כולל אלו שמסופקות על ידי הכלי וכן מאגרים שהוסיפו על ידי המשתמש.
5. הוסף את בלוק ה-PS Zync Ultrascale מהמאגר.
   הערה: בלוק זה משקף את חלק ה-PS במערכת, שאחראי ליצירת השעונים הנדרשים, ויש בו גם את פורטי הראשי והמעבד לחיבור לכתובת ה-IP המיובאת HoG דרך בלוק החיבור AXI, שרץ על יסודות פרוטוקול AXI.
6. הוסף 8 כתובות IP של HoG כי המערכת תעבד 8 חלונות בו-זמנית כדי לנצל את היתרון של מקביליות שמציע לוח FPGA.
7. הוסף בלוק איפוס מערכת מעבד , שגם שולט בשעון ובאספקת איפוס לכל בלוק בדיאגרמה.
8. הוסף שני בלוקים axi_smart connect לחיבור כתובות ה-IP של HoG לבלוק ה-PS של Zync. כל דיאגרמת הבלוקים עם כל החיבורים מוצגת באיור 3.
   הערה: כפי שמוצג באיור 3, כל הבלוקים שצריך להוסיף לעיצוב הוצגו בבירור. איור 3 נתפס מהכלי ומציג את היציאות הפנימיות של כל בלוק וכן את הקשרים בין היציאות של בלוקים שונים. בלוק זה הוא העיצוב הראשי שכן הוא אחראי להקמת הממשק בין ה-PS לחלק PL של לוח FPGA.
9. לאחר השלמת החיבורים כפי שמופיע באיור 3, לחץ על אימות עיצוב.
   הערה: האימות בעצם בודק את החיבורים החסרים או השבורים, מה שעלול להוביל לבעיות בשלבים מאוחרים יותר.
10. לחץ על סינתזה ואז מיישם עיצוב ב-tool לאחר שהאימות של דיאגרמת הבלוקים הצליח.
    הערה: סינתזה ממפה את דיאגרמת הבלוקים המתוכננת וממפה אותה על לוח ה-FPGA. שלב זה ידווח על כל הפרה שעשויות להצביע על כך שהעיצוב אינו ניתן ליישום על חומרה.
11. הכלי גם יפיק דוחות הקשורים לתזמון, ניצול משאבים וצריכת חשמל. בדקו בקפידה את הדוחות כדי לבדוק אם יש הפרות תזמון ולנתח את ביצועי המערכת המתוכננת.
12. לחץ על 'יצירת קובץ זרם הביטים ' שייצור את קובץ ה-.bit הנדרש לתכנות לוח ה-FPGA.

איור 3: דיאגרמת בלוקים לזיהוי הולכי רגל באמצעות כתובת IP מיובאת HoG + SVM. אנא לחצו כאן לצפייה בגרסה גדולה יותר של איור זה.

3. היישום הסופי בלוח FPGA

1. קח את לוח ה-FPGA והכנס את כרטיס ה-SD עם קובץ התמונה המתאים בחריץ על הלוח.
2. חבר גם את הלוח למחשב.
3. הפעל את לוח ה-FPGA במצב כרטיס ה-SD כדי להפעיל עליו תכנות בפייתון^21,22.
4. תיגש לפלטפורמת Jupyter על הלוח אחרי שחיברו אותה ל-WiFi.
5. חבר מצלמת רשת ללוח.
6. כתוב קוד פייתון לייבוא קובץ הביטים שנוצר ולבצע את המשימה של גישה לתמונות המצלמה.
7. בקוד, כתוב את הסקריפט כך שהתמונה תיכתב בזיכרון של לוח ה-FPGA דרך חלק ה-PS ותועבר לחלק PL לעיבוד.
   הערה: החלק PL של הלוח שמתאים ל-IPs של HoG ניגש לפיקסלים של התמונה דרך מיקומי הזיכרון הללו ומעבד אותם ומספק את הניקוד כפלט.
8. כתוב קוד מתאים באותו סקריפט פייתון כדי לקרוא את התמונות המעובדות ולהציג אותן על מסך המחשב.
   הערה: זה משלים את כל התכנון והמערכת מוכנה כעת לפריסה ביישומים אמיתיים. כל הקודים בהם השתמשו במחקר זה מועלים כקבצי קידוד משלימים (קובץ משלים 1 [Script_1_train_test.py], קובץ משלים 2 [Script_2_HLS_hog.cpp], קובץ משלים 3 [Script_3_HLS_test_bench.cpp], קובץ משלים 4 [Script_4_HLS_consts.h], קובץ משלים 5 [Script_5_jupyter_code.txt]).

Results

מימוש זיהוי הולכי רגל ב-HLS
איור 4 מציג את תוצאות הסימולציה בכלי HLS לזיהוי הולכי רגל באמצעות HoG + SVM. תמונת קלט עם הולך רגל מוזנת כקלט הבדיקה לקוד, והפלט עם הולכי הרגל שזוהו מוצג. יש שני חלקים בתמונה. בגילוי הראשון יש תיבות גבול רבות סביב אותו הולך רגל שוב ושוב, ובתמונה השנייה הקופסאות החופפות מוסרות והן מדוכאים, ונשארות רק תיבות הזיהוי הראשיות.

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

כלי HLS מספק גם דוחות סינתזה לתזמון ולניצול משאבים. סיכום התזמון מדגיש את תקופת הזמן הנדרשת על ידי העיצוב ומספק את ערכי ההשהיה המקסימליים והמינימליים במונחים של מספר המחזורים. מידע זה שימושי להערכת כמה זמן העיצוב דורש לביצוע ומה צריך להיות תדר השעון בעת המעבר ליישום החומרה בפועל. טבלה 2 למטה מציגה את דוח התזמון לאחר סינתזת HLS, שמראה בבירור שתקופת השעון היעד הייתה 6 ננו-שניות והעיצוב לקח 5.25 ננו-שניות, שזה פחות מהיעד, ולכן תקופת הזמן יכולה להיות 6 ננו-שניות ומעלה אך לא מתחת ל-5 ננו-שניות.

סיכום תזמון
שעון	מטרה	הערכה
	6.00 ננו-שניות	5.250 ננו-שניות
סיכום השימוש
	סך הכל / זמין	אחוז ניצול
BRAM18K	22 / 432	5%
DSP48E	13 / 360	3%
FF	5611/ 141120	3%
LUT	9904/ 70560	14%
URAM	0	0

טבלה 2: דוח מוערך של תזמון וניצול משאבים מכלי HLS לזיהוי הולכי רגל באמצעות HoG-SVM.

טבלה 2 מציגה גם את דוח השימוש. הוא מציג את אחוז השימוש במשאבי FPGA חשובים על הספינה בהתאם ללוח היעד שנבחר. לעיצוב זיהוי הולכי רגל זה, דוח השימוש מראה שהעיצוב צורך 14% מטבלאות החיפוש (LUTs), 3% מ-Flip Flops (FFs), 3% מעיבוד אותות דיגיטליים (DSP), ו-5% מזיכרון גישה אקראית (BRAM). הערכות אלו אינן דוחות השימוש המדויקים, אך הדוחות עצמם קרובים להערכות אלו. אלו רק ההערכות שניתן לחשב באמצעות כלי ה-HLS. היישום בפועל בדרך כלל שונה מאוד מהערכות אלו.

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

סיכום תזמון העיצוב
הכנה	המתן	רוחב פולס
הגרוע ביותר של סלאק 4.073 ננו-נו.	הגרוע ביותר ב-Hold Slack 0.010 ns.	רוחב הפולס הגרוע ביותר Slack 3.500 ns

טבלה 3: סיכום תזמון אמיתי לזיהוי הולכי רגל בלוח FPGA.

בנוסף, הכלי מציג את דוחות ניצול המשאבים, שהם השימוש בפועל במשאבים המובנים לפי לוח ה-FPGA שנבחר. במקרה זה, הכרטיס הנבחר הוא לוח פיתוח FPGA מבוסס Zynq UltraScale+ MPSoC (Multi-Processor System On Chip)²⁷. טבלה 4 למטה מציגה את ניצול המשאבים ואיור 5 מציג את הייצוג הדיאגרמטי של ניצול המשאבים.

סיכום השימוש מצביע על הצריכה האמיתית של המשאבים שעל הסיפון, בהתחשב בכך שיש 8 HoG IPS במקביל, וההערכות שדווחו על ידי סינתזת HLS היו עבור IP יחיד של HoG. אבל גם לאחר שימוש נרחב כזה, השימוש במשאבים בכל משאב הוא פחות מ-50%. טבלה 4 מציינת בבירור את השימוש ביחס למשאבים השונים ולאחוז השימוש בהם, כפי שמוצג בתמונה באיור 5.

משאב	שימוש	זמין	אחוז ניצול
LUT	40536	70560	57.45%
לוטטרם	7304	28800	25.36%
FF	33342	141120	23.63%
BRAM	68	216	31.48%
DSP	128	360	35.56%
BUFG	2	196	1.02%

טבלה 4: דוח ניצול בפועל לזיהוי הולכי רגל בלוח FPGA.

איור 5: ניצול משאבים לזיהוי הולכי רגל בלוח FPGA לאחר יישום בפועל. חפש טבלאות (LUT): 57%, LUTRAM: 25%, Flipflops (FF): 24%, בלוק RAM (BRAM): 31%, מעבדי אותות דיגיטליים (DSP): 36%, מאפרי אות: 1%. אנא לחצו כאן כדי לצפות בגרסה מוגדלת של הדמות הזו.

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

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

ניתוח נוסף נעשה כדי להבין את היתרון בשימוש ב-8 כתובות IP של HoG במקום כתובת IP אחת של HoG או יותר מ-8 בדיאגרמת הבלוקים שנוצרה, כפי שמוצג באיור 3. מדדי הביצועים הקשורים לחומרה חושבו הן עבור כתובת IP אחת של HoG והן עבור 8 כתובות IP של HoG במקביל. טבלה 5 למטה מציגה את ההשוואה.

מדד ביצוע	1 IP	8 קניינים רוחניים
תזמון (ns)	5.312	~5.25
תדר (MHz)	188	150
כוח (W)	1.9	2.43
LUTs	4998	40536
FF / רגיסטרים	4,031	33,342
DSP	16	128
BRAM	8.5	68
FPS	~10–11	83

טבלה 5: השוואת מדדי ביצועים באמצעות IP יחיד מול מספר של HoG.

טבלה 5 מציינת בבירור שכאשר המשאבים מתחשבים כמו LUTs, FFs, DSPs ו-BRAM, אז עם כתובת IP בודדת של HoG ו-8 IPs של HoG, הסקאלה היא ליניארית עם כמעט פי 8 עלייה במשאבים המנוצלים. זה צפוי בבירור, שכן יותר קניין רוחני יוביל לצריכת משאבים נוספים. כמו כן, אם נצפים התדר, התדר המרבי יורד במעט ב-20% מ-188 מגה-הרץ ל-150 מגה-הרץ. זה צפוי גם כאשר יותר בלוקים מובילים ליותר חיבורים וכך למסלולים ארוכים יותר, מה שגורם לעלייה במסלולים הקריטיים. אך הגורמים החיוביים כמו פריימים לשנייה (FPS) משתפרים מ-10 ל-83, ומדגימים קנה מידה לא ליניארי במקרה של FPS בעקבות מושג המקביליות שהוכנס, בעקבות 8 IPs של HoG. בנוסף, ההספק נע בין 1.9 וואט ל-2.4 וואט, מה שמעיד על שיפור ביעילות האנרגטית באמצעות צינור. לכן, ניתוח זה מצביע בבירור כי הכנסת 8 קנייני HoG מועילה לעיצוב, והגדלה מעבר ל-8 עלולה לגרום לצריכת משאבים מופרזת; לכן, מספר הבלוקים מעבר ל-8 אינו נחשב לטוב.

תוצאות זיהוי הולכי רגל לאחר יישום FPGA
לבסוף, כל המערכת משולבת על לוח FPGA, וקובץ זרם הסיביות נוצר, אשר מתוכנת על הלוח דרך כרטיס ה-SD שמופעל עם יכולת תכנות פייתון. לאחר שהלוח מופעל עם כרטיס ה-SD, ניתן לגשת לממשק ה-jupyter ולכתוב ולהריץ קוד פייתון על הפלטפורמה. קוד הפייתון רץ ונבדק לזיהוי הולכי רגל על תמונות קלט שונות. התוצאה של כמה תמונות מוצגת באיור 7 למטה. תמונות אלו מנוצלות ממאגר הנתונים של INRIA וכן מתמונות אקראיות של הולכי רגל שהושגו ממקורות מקוונים בקוד פתוח^26,27.

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

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

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

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

הערכת מדדי ביצועים
כדי לחשב את היעילות ולנתח את ביצועי העיצוב שהושם לעיל, חיוני לחשב מדדי ביצועים שימושיים להערכת הביצועים. מדדי הביצועים לזיהוי יעילות של אלגוריתם זיהוי תלויים בעיקר בערכים של חיוביים אמיתיים (TP), שליליים אמיתיים (TN), חיוביים שגויים (FP) ושליליים שגויים (FN). מהערכים הללו ניתן לחשב את מדדי הביצועים כמו דיוק, שחזור, ציון F1, חיובי שגוי לכל תמונה ודיוק לפי המשוואות המוצגות להלן. נצפה כי רוב מאמרי המחקר מדווחים על ביצועי הגילוי שלהם דרך פרמטר הדיוק. אך נצפה כי חישוב הדיוק הכולל שימוש ב-TN יכול להיות פרמטר מטעה, שכן ערך TN אינו ניתן לחישוב נכון במובן האמיתי, שכן הוא כולל מציאת מספר כל חלונות הזיהוי בתמונה שאין בה בפועל הולך רגל, והאלגוריתם המיושם גם מדווח על כך כללא זיהויים. מספר זה בדרך כלל גדול מאוד, שכן מספר חלונות הזיהוי הכולל בתמונה גדול, והאזורים הרקעים בכל תמונה בדרך כלל תואמים לאזורים ללא הולכי רגל. על ידי התבוננות מקרוב בנוסחת הדיוק המוצגת במשוואות [1] – [5], ניתן להבין שכיוון שערך TN יהיה גבוה יחסית ל-TP+FP+FN, לפרמטר הדיוק בדרך כלל יש ערך גבוה. כדי להעריך באמת את הביצועים, עדיף לדווח על מדדים כמו דיוק, זיכרון וציון F1 שאינם תלויים ב-TN ולכן הם הרבה יותר מדויקים.

[1]

[2]

[3]

[4]

[5]

כדי למצוא את הערכים של TP, TN ו-FN עבור מאמר זה, הניסוי על תמונות הסטילס חזר על מספר עצום של תמונות. מתוצאות כל תמונה, ערך החיוביים האמיתיים, כלומר מספר הולכי הרגל שזוהו נכון, חיוביים שגויים, מספר הולכי הרגל שזוהו בטעות, והשליליים השגויים, שהם הולכי הרגל האמיתיים שלא זוהו. הערכים הבאים דווחו לאחר הניסויים שבוצעו ומוצגים בטבלה 6 למטה.

מדד ביצועים	ערך
TP	143
FP	39
FN	19
פרסיסון	0.786 (78.6%)
זימון מחדש	0.883 (88.3%)
ציון פורמולה 1	0.831 (83.1%)
FPPI	0.867

טבלה 6: מדדי ביצועים לאלגוריתם זיהוי הולכי רגל מבוסס FPGA המיושמים.

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

השוואת ביצועים עם יישומי HoG מבוססי FPGA קיימים
לבסוף, ניתן להשוות את העבודה שבוצעה לספרות הקודמת כדי לציין תרומות משמעותיות של מחקר זה. השוואה זו מוצגת בטבלה 7 15,16,17,21,24 למטה. המאמרים שבהם מתבצעת ההשוואה מבוססים כולם על יישומי זיהוי הולכי רגל שמיושמים בפלטפורמות FPGA, והאלגוריתמים לזיהוי אלו זהים גם לכולם, כלומר HoG בשילוב עם מסווג, שהוא או מסווג Adaboost או SVM. גודל התמונה זהה גם לכל אחד (640 × 480). ההשוואה מבוססת על פרמטרים כמו תדר השעון שמשפיעים על המהירות, מספר הפריימים לשנייה, צריכת החשמל וצריכת המשאבים במונחים של LUTs, DSPs, זיכרון, Slices ו-Registers. כדי לעודד השוואה הוגנת, מאמרי המחקר שנבדקו להשוואה הם בעלי רזולוציית תמונה דומה, וכדי לנרמל את השוואת המשאבים, כל ניצול משאבים מנורמל על ידי חלוקת מספר המשאבים שנצרכו במספר המשאבים הזמינים לפי לוח FPGA שבו משתמשים.

מקור	גודל תמונה	דירקטוריון FPGA	תדר שעון	פריימים לשנייה (FPS)	כוח	פיקסלים / שעון	LUTs (%)	DSP48s (%)	BRAMs / ביטי זיכרון (%)	רגיסטרים/FF (%)
15	640×480	זילינקס זינק	82.2 מגה-הרץ	40	-	1	40	2	0	-
24	640×480	Virtex 6	150 מגה-הרץ	10	19 W		39	53	22	-
16	640×480	ציקלון V	162 מגה-הרץ	526	9 W	0.99	21	86	100	21
17	640×480	אלטרה DE2-115	50 מגה-הרץ	129	3.6 W	-	73	-	72	60
21	640×480	Zync 7000	100 מגה-הרץ	240	1.6 W	-	13	3	1	10
עבודה זו	640 על 480	אולטרה 96 v2	150 מגה-הרץ	83	2.435W	0.0632	57	35	31	24

טבלה 7: השוואת פרמטרים וביצועים ליישום זיהוי הולכי רגל ב-FPGA

כפי שניתן לראות בטבלה 7 למעלה, ניתן להבחין שכאשר היישום במחקר זה משווים לעבודות הקודמות, ההשוואות מציגות שיפורים משמעותיים במהירות. לוח ה-FPGA מסוגל לפעול בתדר שעון של 150 מגה-הרץ, מה שמעיד שתקופת הזמן להשלמת כל המשימה היא פחות מ-6 ננו-שניות. למרות שחלק מהעבודות הקודמות מדווחות על FPS גבוה משמעותית, ניתן לנתח שהיתרון הזה בא על חשבון צריכת חשמל גבוהה יותר וכן ניצול כמעט מלא של משאבים מסוימים. אם לוקחים בחשבון את צריכת החשמל מאשר בעבודה זו, ההספק המדווח גם הוא בצד הנמוך יותר, וניצולי המשאבים מצביעים על כך שצריכת כל משאב מעט גבוהה יותר ממימושים מסוימים, אך שווה או פחות מ-50% (57% LUTs, 35% DSP ו-31% BRAM), מה שמראה מקום משמעותי ליישום משימות נוספות בעיצוב זה. בסך הכול, ניתן לומר שהעבודה המיושמת במאמר זה משיגת איזון בין ביצועים, אנרגיה וניצול משאבים. בנוסף, העבודה שהוצגה הציגה מקביליות ניתנת להרחבה דרך בלוקי IP מרובים מבלי להשפיע באופן דרסטי על פרמטרי הביצוע.

תיק משלים 1: Script_1_train_test.py.אנא לחצו כאן להורדת הקובץ הזה.

תיק משלים 2: Script_2_HLS_hog.cpp. אנא לחצו כאן להורדת הקובץ הזה.

תיק משלים 3: Script_3_HLS_test_bench.cpp. אנא לחצו כאן להורדת הקובץ הזה.

תיק משלים 4: Script_4_HLS_consts.h.אנא לחצו כאן להורדת הקובץ הזה.

קובץ משלים 5: Script_5_jupyter_code.txt.אנא לחצו כאן להורדת הקובץ הזה.

Discussion

מחקר זה מיישם ביעילות מערכת זיהוי הולכי רגל בזמן אמת תוך שימוש באלגוריתם HoG + SVM על חומרת FPGA מתקדמת המבוססת על לוח פיתוח Zynq UltraScale+ MPSoC²⁴. התוצאות מצביעות על כך שאלגוריתם HoG המסורתי לזיהוי אנושי¹¹ משיג דיוק קרוב ל-95% ומשתמש רק במחצית ממשאבי ה-FPGA המובנים (LUTs, FFs, BRAM, DSPs), מה שמשאיר יכולת עצומה לכלול עיבוד רב יותר לביצוע משימות שונות. כאשר מנתחים את כל גישת המימוש, נצפים כי ישנם שלבים קריטיים שונים המעורבים. שלב מרכזי הוא לאמן את דגם SVM 18,19,24 עם מאגר נתונים מתאים לזיהוי הולכי רגל יעיל, כך שהמשקלים יופקו וישמשו בתכנות FPGA. קוד האימון יציין את דיוק הביצועים, וסף הגילוי צריך להיות מכוון בקפידה דרך פרמטר הרגולריזציה כדי להגיע לדיוק הקרוב ל-95%. הפרמטרים שנבחרו באימון הם תיאורי HoG מותאמים אישית עם גודל חלון של 64 על 128, גודל בלוק 16 על 16, גודל תא 8 על 8, ומספר תאים שנבחר כ-9. כיום, ההכשרה מתבצעת על מאגר הנתונים^{INRIA 11} עם 2416 תמונות חיוביות ו-1218 תמונות שליליות. ההרחבה כוללת סיבוב התמונות כדי לספק את הגרסה האופקית והמראה. הכללות מרכזיות נוספות, כמו הערכת המודל בתנאי נראות לקויה או שינויים בקנה מידה, יטופלו בעבודה עתידית כדי להבטיח שחזוריות ועמידות. מאגר הנתונים שנבחן להכשרה חייב לכלול תמונות של הולכי רגל בתנוחות שונות, והוא חייב לכלול גם תמונות שאין בהן הולכי רגל^18,19.

השלב הקריטי הנוסף הוא ליצור את דיאגרמת הבלוקים לכל המערכת, כך שחלק ה-PS של לוח ה-FPGA יוכל לתקשר עם חלק ה-PL. בשלב זה, יש לוודא שכל בלוק מפרמטרי עם היציאות הנכונות ושהוא מחובר כראוי לבלוקים האחרים. הכלי גם מציע ניתוב אוטומטי עם המלצות לסיוע למעצב. שלב קריטי מאוד הוא הקצאת כתובות לאחר השלמת דיאגרמת הבלוקים. כתובות ה-IP המיובאות של HoG צריכות להיות מוקצות לפי העומק שלהן, וכתובות אלו לא צריכות להיות זהות לשני כתובות IP. כתובות אלו נדרשות בקוד הפייתון שעל כרטיס ה-SD שיעזור לחלק ה-PS בלוח ה-FPGA להבין את מיקום הכתובת ב-PL שהוא צריך לגשת אליו כדי לקרוא/לכתוב את הנתונים. לכן השלב המאתגר הוא פיתוח הממשק בפלטפורמת פייתון, שמאפשר למשתמש להזין את תמונות/סרטונים/שידור חי ל-FPGA ולהציג את תמונת הפלט עם הולכי הרגל שזוהו לאחר קבלת התמונות המעובדות מה-FPGA. קוד פייתון צריך להיכתב עם הודעות דיבוג שונות כדי שהמתכנן יוכל לראות תוצאות ביניים, ובמקרה של כשלות, ניתן לאבחן ולתקן את השגיאות. הושקע זמן רב במחקר זה ביצירת ממשק נכון בין ה-PS לחלק PL. סקריפט פייתון לממשק זה הצליח לגשת לנתוני כתובות ה-IP של HoG לאחר מספר איטרציות, והכללת מספר הצהרות להצגת התוצאות הביניים הייתה מועילה מאוד בפתרון תקלות ותיקון השגיאות.

מגבלה שנצפתה של השיטה היא השימוש בחלק הפייתון ליצירת הממשק בין ה-PS לחלק PL של FPGA. בעוד שפלטפורמת פייתון קיצצה משמעותית את זמן העיצוב, היא מוסיפה הוצאות נוספות שמשפיעות על הביצועים בזמן אמת. מערכת זיהוי הולכי הרגל המואצת בחומרה דיווחה על קצב העברה של 83 FPS, אך ביצועי המערכת הכוללים הושפעו עקב השהיה או הפכו לבלתי מגיבים במהלך בדיקות מצלמה חיה עקב עיכובים שנגרמו מהעברת נתונים בין ה-PS לחלק PL. הפרספקטיבה העתידית טומנת בחובה אפשרות לפתח מערכת חומרתית מואצת שלמה ללא תלות בתוכנה.

למרות שיש מגבלות כפי שתואר לעיל, המחקר תורם משמעותית, שכן המערכת המפותחת יכולה להיות מותאמת בצורה חלקה לזיהוי הולכי רגל בתמונות סטילס, שידורים חיים או קלטי וידאו. שלוש השיטות דורשות רק שינויים קלים בקוד הפייתון בפלטפורמת Jupyter, המדגימים את ההתאמה המהירה של המערכת לתרחישים שונים. התוצאות מצביעות על כך שהיישום בארכיטקטורות FPGA מתקדמות מניב תוצאות מעודדות, שכן פרמטרי הביצועים מותאמים מאוד, מה שמוביל לערכים טובים ומקובלים. תדר השעון שהושג דומה לספרות הקודמת 14,15,16,20,23, מה שמצביע על כך שהמהירות אינה נפגעת, בעוד שצריכת החשמל המינימלית מרמזת שאין בעיות חימום. בנוסף, ניצול המשאבים מראה שכל המשאבים מנוצלים בפחות מ-50%, מה שמעיד על פוטנציאל משמעותי לשיפורים עיצוביים נוספים.

המערכת המפותחת יכולה לשמש בכל יישום שדורש את המשימה של גילוי בני אדם וניתן להתאים אותה ליישומים בזמן אמת. כמו כן, מאמצים עתידיים עשויים להתמקד בהסרת המגבלות שהוזכרו על ידי פיתוח כל המערכת, או בחלק ה-PL, או לגרום ללוגיקת ה-FPGA לקרוא את תמונות הקלט ולהציג את תמונות הפלט המעובדות, שכן כמעט 50% מהמשאבים הפנימיים עדיין זמינים. כמו כן, אם יש להשתמש באינטגרציה של PS ו-PL, ניתן לבצע פיתוח ממשקים באמצעות כלי SDK (ערכת פיתוח תוכנה). הרחבות נוספות יכולות להיות זיהוי הולכי רגל בתנאי מזג אוויר קשים בהרבה או בתנאי ראות נמוכים, או זיהוי הולכי רגל חסומים שמוסתרים מאחורי אובייקטים אחרים, מה שמחייב שינויים באלגוריתם. השינוי היחיד הנדרש במקרים אלו יהיה החלפת המשקולות המאומנות על ידי SVM לאחר אימון נכון בהתאם לאתגר שנבחר, ושאר המערכת אינה דורשת שינויים נוספים. לכן, המערכת המיושמת מתאימה להסתגלות בקלות לתרחישים מאתגרים אחרים. פרספקטיבה עתידית נוספת יכולה להיות להתמקד בשילוב תכונות נוספות במערכת ליצירת רכב אוטונומי מלא באמצעות לוח FPGA מתקדם.

Materials

List of materials used in this article

Name	Company	Catalog Number	Comments
פייתון	פייתון	גרסה 3.10
לוח FPGA Ultra 96 V2	Xilinx	הוצג ב-2018	פלטפורמת יישום חומרה המשמשת ליישום אלגוריתם זיהוי הולכי רגל
Vivado	AMD	2019.2	כלי תכנות FPGA המשמש לתכנות לוח FPGA Ultra 96 v2 עם אלגוריתם זיהוי הולכי רגל
Vivado HLS	AMD	2019.2	כלי סינתזה ברמה גבוהה המשמש לתכנות ברמה גבוהה של קוד זיהוי הולכי הרגל במאמר לייצוא קניין רוחני (IP)