היתרונות של FPGA על CPU בבינה מלאכותית ואיך זה משפיע על TOPS
כאשר מריצים מודל Artificial Intelligence (AI), אפשר להריץ אותו על כמה סוגי חומרה:
|
1 2 3 4 5 6 7 |
CPU GPU FPGA NPU TPU ASIC AI Accelerator |
במאמר הזה נתמקד בעיקר בהבדל בין:
|
1 2 |
CPU לעומת FPGA |
ונראה איך FPGA משנה את חישוב ה-TOPS.
מה זה CPU?
CPU הוא מעבד כללי.
הוא מתאים להרבה סוגי תוכנות:
|
1 2 3 4 5 6 7 8 |
Windows / Linux Python C / C++ תוכנות רגילות אלגוריתמים כלליים בקרה תקשורת |
היתרון הגדול של CPU הוא גמישות.
קל לתכנת אותו, קל להריץ עליו קוד, והוא מתאים להרבה משימות שונות.
אבל החיסרון שלו הוא שבחישובי בינה מלאכותית הוא לא תמיד יעיל, כי רשת נוירונים דורשת הרבה פעולות שחוזרות על עצמן:
|
1 2 3 4 5 6 |
multiply add MAC matrix multiplication convolution |
מה זה FPGA?
FPGA הוא קיצור של:
|
1 2 |
Field Programmable Gate Array |
כלומר רכיב לוגי שניתן לתכנות כחומרה.
ב-CPU כותבים תוכנה.
ב-FPGA בונים חומרה.
אפשר לבנות בתוך FPGA:
|
1 2 3 4 5 6 7 8 9 |
יחידות כפל יחידות MAC pipeline memory controller parallel processing blocks CNN accelerator ANN accelerator signal processing blocks |
לכן FPGA מתאים מאוד למשימות שבהן החישוב קבוע וחוזר על עצמו.
ההבדל המרכזי: CPU מריץ פקודות, FPGA בונה חומרה
ב-CPU החישוב מתבצע על ידי רצף פקודות.
לדוגמה:
|
1 2 3 4 5 6 |
load data multiply add store result repeat |
ב-FPGA אפשר לבנות מעגל שמבצע את כל זה במקביל.
לדוגמה:
|
1 2 3 4 5 |
64 multipliers עובדים באותו clock 64 adders עובדים באותו clock המידע זורם דרך pipeline כל clock נכנסת דגימה חדשה |
לכן FPGA יכול להיות מהיר מאוד גם אם התדר שלו נמוך יותר מ-CPU.
למה FPGA יכול לנצח CPU למרות שהתדר נמוך יותר?
CPU יכול לעבוד בתדר גבוה:
|
1 2 3 4 |
2 GHz 3 GHz 4 GHz |
FPGA בדרך כלל עובד בתדר נמוך יותר:
|
1 2 3 4 5 |
100 MHz 150 MHz 200 MHz 300 MHz |
אבל FPGA יכול לבצע הרבה פעולות במקביל.
כלומר:
|
1 2 3 |
CPU = תדר גבוה + פחות מקביליות FPGA = תדר נמוך יותר + הרבה מקביליות אמיתית |
זו נקודה חשובה מאוד.
בבינה מלאכותית, הרבה מהחישוב הוא חישוב מקבילי:
|
1 2 3 4 5 |
Matrix multiplication Vector multiplication Convolution MAC operations |
ולכן FPGA יכול להתאים מאוד לחלק ממודלי AI.
מה זה TOPS?
TOPS הוא קיצור של:
|
1 2 |
Tera Operations Per Second |
כלומר:
|
1 2 |
Trillion Operations Per Second |
במספרים:
|
1 2 3 |
1 TOPS = 1,000,000,000,000 operations per second 1 TOPS = 10^12 ops/sec |
אם שבב מבצע 1 TOPS, הוא מבצע בערך טריליון פעולות בשנייה.
מה זה MAC?
בבינה מלאכותית משתמשים הרבה בפעולת:
|
1 2 |
MAC = Multiply Accumulate |
כלומר:
|
1 2 |
sum = sum + x * w |
הפעולה כוללת:
|
1 2 3 |
1 multiplication 1 addition |
לכן יש שתי שיטות ספירה:
|
1 2 |
1 MAC = 1 operation |
או:
|
1 2 |
1 MAC = 2 operations |
במאמר הזה נחשב לפי:
|
1 2 |
1 MAC = 2 operations |
איך מחשבים TOPS ב-FPGA?
ב-FPGA ה-TOPS לא קבוע מראש כמו במעבד רגיל.
הוא תלוי במה שבנינו בתוך ה-FPGA:
|
1 2 3 4 5 6 7 |
כמה MAC units יש מה התדר כמה פעולות כל יחידה עושה בכל clock באיזה precision משתמשים כמה טוב ה-pipeline האם הזיכרון מספיק מהיר |
הנוסחה:
|
1 2 |
TOPS = operations_per_clock × clock_frequency / 10^12 |
אם יש לנו MAC units:
|
1 2 |
operations_per_clock = number_of_MAC_units × 2 |
ולכן:
|
1 2 |
TOPS = number_of_MAC_units × 2 × frequency / 10^12 |
דוגמה 1: FPGA עם 64 יחידות MAC
נניח שבנינו בתוך FPGA:
|
1 2 |
64 MAC units |
התדר:
|
1 2 |
150 MHz |
כל MAC עושה:
|
1 2 |
1 multiply + 1 add = 2 operations |
לכן בכל clock:
|
1 2 |
64 × 2 = 128 operations per clock |
עכשיו נכפיל בתדר:
|
1 2 |
128 × 150,000,000 = 19,200,000,000 operations/sec |
כלומר:
|
1 2 |
19.2 GOPS |
המרה ל-TOPS:
|
1 2 |
19,200,000,000 / 1,000,000,000,000 = 0.0192 TOPS |
כלומר:
|
1 2 |
0.0192 TOPS |
זה נשמע קטן, אבל למודלי ANN קטנים זה הרבה מאוד.
דוגמה 2: FPGA עם 512 יחידות MAC
נניח FPGA חזק יותר עם:
|
1 2 |
512 MAC units |
התדר:
|
1 2 |
200 MHz |
כל MAC:
|
1 2 |
2 operations |
חישוב פעולות בכל clock:
|
1 2 |
512 × 2 = 1024 operations per clock |
חישוב פעולות בשנייה:
|
1 2 |
1024 × 200,000,000 = 204,800,000,000 operations/sec |
המרה ל-TOPS:
|
1 2 |
204,800,000,000 / 1,000,000,000,000 = 0.2048 TOPS |
כלומר:
|
1 2 |
0.2048 TOPS |
דוגמה 3: חישוב ANN קטן על FPGA
נניח רשת ANN פשוטה:
|
1 2 |
14 → 14 → 28 → 14 → 1 |
כלומר:
|
1 2 3 4 5 6 |
Input: 14 Hidden layer 1: 14 Hidden layer 2: 28 Hidden layer 3: 14 Output: 1 |
זו רשת Fully Connected.
חישוב MAC לרשת
שכבה ראשונה:
|
1 2 |
14 × 14 = 196 MAC |
שכבה שנייה:
|
1 2 |
14 × 28 = 392 MAC |
שכבה שלישית:
|
1 2 |
28 × 14 = 392 MAC |
שכבת פלט:
|
1 2 |
14 × 1 = 14 MAC |
סה"כ:
|
1 2 |
196 + 392 + 392 + 14 = 994 MAC |
אם סופרים כל MAC כשתי פעולות:
|
1 2 |
994 × 2 = 1,988 operations |
בקירוב:
|
1 2 |
≈ 2,000 operations לכל inference |
כמה זמן FPGA צריך כדי להריץ את הרשת?
נניח FPGA עם:
|
1 2 |
64 MAC units |
הרשת דורשת:
|
1 2 |
994 MAC |
בכל clock אפשר לבצע:
|
1 2 |
64 MAC |
מספר clocks:
|
1 2 |
994 / 64 = 15.53 |
מעגלים למעלה:
|
1 2 |
16 clock cycles |
אם התדר הוא:
|
1 2 |
150 MHz |
זמן clock אחד:
|
1 2 |
1 / 150,000,000 = 6.67 ns |
לכן זמן חישוב אידיאלי:
|
1 2 |
16 × 6.67 ns = 106.7 ns |
כלומר:
|
1 2 |
בערך 0.000000106 שניות |
כמה inference בשנייה?
|
1 2 |
1 / 106.7 ns ≈ 9,370,000 inference/sec |
כלומר בתיאוריה:
|
1 2 |
כ-9.3 מיליון הרצות בשנייה |
בפועל יהיה פחות בגלל:
|
1 2 3 4 5 6 7 |
זיכרון טעינת קלט שמירת פלט activation function control logic pipeline overhead |
אבל עדיין מדובר בביצועים גבוהים מאוד לרשת קטנה.
למה CPU פחות יעיל כאן?
CPU יכול להיות חזק מאוד, אבל הוא כללי.
הוא צריך להריץ:
|
1 2 3 4 5 6 |
מערכת הפעלה זיכרון cache interrupts תהליכים נוספים קוד כללי |
בנוסף, CPU לא תמיד מבצע 64 או 512 MAC אמיתיים בכל clock עבור המודל שלך.
FPGA לעומת זאת יכול להיבנות בדיוק למודל:
|
1 2 3 4 5 |
קלט נכנס המשקלים כבר מסודרים החישוב עובר ב-pipeline הפלט יוצא בזמן קבוע |
לכן FPGA חזק במיוחד כאשר צריך:
|
1 2 3 4 5 6 |
latency נמוך זמן תגובה קבוע חיבור ישיר לחיישנים עיבוד בזמן אמת צריכת חשמל נמוכה |
יתרונות FPGA על CPU בבינה מלאכותית
1. מקביליות אמיתית
FPGA יכול לבצע הרבה פעולות באותו clock.
לדוגמה:
|
1 2 3 4 |
64 MAC במקביל 128 MAC במקביל 512 MAC במקביל |
ב-CPU זה קשה יותר, כי המעבד בנוי להרבה משימות כלליות.
2. Latency נמוך
ב-FPGA אפשר לקבל זמן תגובה קצר מאוד.
לדוגמה:
|
1 2 3 4 |
כניסת אות מחיישן חישוב AI יציאת החלטה |
בלי לעבור דרך הרבה שכבות תוכנה.
3. זמן תגובה קבוע
במערכת real-time חשוב שהתגובה תהיה קבועה.
ב-CPU לפעמים מערכת ההפעלה או interrupt יכולים לגרום לעיכובים.
ב-FPGA אפשר לבנות מערכת דטרמיניסטית:
|
1 2 3 4 |
כל clock ידוע כל pipeline ידוע כל latency ידוע |
4. צריכת חשמל טובה
למשימות מסוימות FPGA יכול לבצע חישוב AI בצריכת חשמל נמוכה יותר מ-CPU חזק.
זה חשוב במיוחד במערכות:
|
1 2 3 4 5 6 |
רחפנים חיישני שטח מצלמות edge מערכות אודיו מערכות battery powered |
5. חיבור ישיר לחיישנים
FPGA יכול להתחבר ישירות ל:
|
1 2 3 4 5 6 7 8 9 10 |
מצלמות מיקרופונים ADC DAC I2S PDM LVDS MIPI Ethernet |
זה יתרון גדול במערכות זמן אמת.
6. התאמה אישית למודל
ב-CPU אתה מתאים את המודל למעבד.
ב-FPGA אתה יכול להתאים את החומרה למודל.
זו נקודה חזקה מאוד.
חסרונות FPGA לעומת CPU
FPGA לא תמיד עדיף.
החסרונות:
|
1 2 3 4 5 6 7 8 |
פיתוח מורכב יותר צריך Verilog / VHDL / HLS צריך להבין timing צריך לתכנן זיכרון debug קשה יותר זמן קומפילציה ארוך לא כל מודל AI מתאים ל-FPGA |
CPU עדיף כאשר צריך:
|
1 2 3 4 5 6 |
פיתוח מהיר הרצת Python מודל משתנה כל הזמן מערכת כללית גמישות תוכנה |
חברות FPGA מרכזיות בעולם
יש כמה חברות FPGA חשובות בעולם.
חלקן מערביות, וחלקן סיניות.
חברות מערביות מוכרות:
|
1 2 3 4 5 6 |
AMD Xilinx Altera / Intel FPGA Lattice Semiconductor Microchip / Microsemi Efinix |
חברות סיניות מוכרות:
|
1 2 3 4 |
Gowin Semiconductor Anlogic Pango Micro |
בנוסף, יש חברות סיניות שאינן FPGA קלאסי, אבל חשובות בעולם מאיצי AI:
|
1 2 3 4 5 6 |
Huawei Ascend Cambricon Rockchip Kendryte Sophgo |
טבלת השוואה בין חברות FPGA ומאיצי AI
| חברה | מדינה | סוג חומרה | תחום חזק | התאמה ל-AI | הערה חשובה |
|---|---|---|---|---|---|
| AMD Xilinx | ארה"ב | FPGA / Adaptive SoC | ביצועים גבוהים, תקשורת, תעשייה, ביטחון | גבוהה מאוד | משפחת Versal כוללת AI Engines לעיבוד DSP ו-AI |
| Altera / Intel FPGA | ארה"ב | FPGA / SoC FPGA | דאטה סנטר, תעשייה, edge | גבוהה | FPGA AI Suite מאפשר לבנות מאיצי inference על FPGA |
| Lattice | ארה"ב | Low-power FPGA | edge, מצלמות קטנות, צריכת חשמל נמוכה | בינונית-גבוהה | מתאים ל-AI קטן ו-TinyML קרוב לחיישן |
| Microchip / Microsemi | ארה"ב | FPGA / SoC FPGA | אמינות, תעשייה, Aerospace, צריכת חשמל | בינונית-גבוהה | VectorBlox מיועד ל-AI/ML inference על PolarFire |
| Efinix | ארה"ב | FPGA | embedded, edge, TinyML | בינונית | מציעה משפחות Trion, Topaz, Titanium |
| Gowin | סין | FPGA | FPGA קטן/בינוני, dev boards, cost effective | בינונית | מציעה FPGA chips, design tools, IP cores ו-development kits |
| Anlogic | סין | FPGA / FPSoC | FPGA סיני מקומי, תעשייה ותקשורת | בינונית | חברה סינית ל-FPGA, FPSoC, EDA ותוכנות פיתוח |
| Pango Micro | סין | FPGA / Programmable SoC | FPGA סיני, SoC programmable platform | בינונית | מתמקדת בשבבי programmable system platform וכלי EDA |
| Huawei Ascend | סין | NPU / AI Accelerator | אימון והרצת מודלי AI גדולים | גבוהה מאוד | לא FPGA, אלא מאיץ AI ייעודי |
| Cambricon | סין | AI Accelerator | שבבי AI ושרתים | גבוהה מאוד | לא FPGA, אלא ASIC/NPU ל-AI |
| Rockchip | סין | SoC עם NPU | מצלמות, edge AI, embedded Linux | בינונית | מתאים למוצרים כמו RK3588 עם NPU מובנה |
| Kendryte | סין | RISC-V AIoT chip | TinyML, מצלמה קטנה, edge | בינונית | מתאים למערכות AI קטנות בצריכת חשמל נמוכה |
מקורות כלליים לחברות ולכלים
AMD מציגה את AI Engine כמשאב חישובי ל-DSP ול-AI בתוך משפחת Versal adaptive SoC.
Altera מציגה FPGA AI Suite כפלטפורמה לבניית inference accelerators על FPGAs.
Lattice מציגה את sensAI כפתרון AI/ML ל-FPGA בצריכת חשמל נמוכה ולמכשירי edge.
Microchip מציגה את VectorBlox SDK כפתרון AI/ML inference עבור PolarFire FPGAs ו-SoCs.
Gowin מציגה פורטפוליו הכולל FPGA chips, design tools, IP cores ו-development kits.
Anlogic מציגה את עצמה כספקית FPGA סינית העוסקת ב-FPGA, FPSoC, EDA וכלי פיתוח.
Pango Micro מציגה עצמה כחברה סינית המתמחה ב-programmable system platform chips ובכלי EDA.
השוואה קצרה: CPU מול FPGA
| נושא | CPU | FPGA |
|---|---|---|
| גמישות | גבוהה מאוד | בינונית |
| קלות פיתוח | קלה | קשה יותר |
| ביצוע מקבילי | מוגבל יחסית | חזק מאוד |
| latency | משתנה | נמוך וקבוע |
| צריכת חשמל | בינונית-גבוהה | יכולה להיות נמוכה מאוד |
| התאמה לחיישנים | דרך דרייברים וממשקים | ישירה מאוד |
| התאמה ל-AI קטן | טובה | מצוינת |
| התאמה ל-AI גדול | מוגבלת | תלוי FPGA וזיכרון |
| TOPS | נקבע לפי המעבד | נקבע לפי התכנון שלך |
| שימוש מומלץ | תוכנה כללית | real-time, חיישנים, pipeline, AI קבוע |
השוואה קצרה: FPGA מול NPU
| נושא | FPGA | NPU |
|---|---|---|
| גמישות חומרה | גבוהה | נמוכה יותר |
| קלות שימוש | קשה יותר | קלה יותר |
| ביצועים ב-AI נפוץ | טובים | טובים מאוד |
| תמיכה במודלים | תלוי תכנון | תלוי SDK |
| latency | נמוך מאוד | נמוך |
| צריכת חשמל | טובה מאוד | טובה מאוד |
| שינוי ארכיטקטורה | אפשרי | כמעט לא אפשרי |
| מתאים לחיישנים מיוחדים | מאוד | פחות |
| מתאים לייצור מוצר המוני | כן, אבל פיתוח יקר | כן |
כאשר מריצים מודל Artificial Intelligence (AI), אפשר להריץ אותו על כמה סוגי חומרה:
|
1 2 3 4 5 6 |
CPU GPU FPGA NPU TPU ASIC AI Accelerator |
במאמר הזה נתמקד בעיקר בהבדל בין:
|
1 |
CPU לעומת FPGA |
ונראה איך FPGA משנה את חישוב ה-TOPS, ובנוסף נציג השוואה הנדסית מלאה בין כל סוגי החומרה.
טבלת השוואה בין סוגי חומרה להרצת AI
| פרמטר | CPU | GPU | FPGA | NPU | TPU | ASIC AI Accelerator |
|---|---|---|---|---|---|---|
| סוג ארכיטקטורה | General Purpose | SIMD / Massive Parallel | Reconfigurable Hardware | Fixed AI Engine | Tensor Optimized | Fixed Hardware |
| גמישות | גבוהה מאוד | גבוהה | בינונית-גבוהה | נמוכה | נמוכה | נמוכה מאוד |
| קלות פיתוח | קלה מאוד | בינונית | קשה | קלה יחסית | קלה (דרך framework) | קשה מאוד |
| ביצוע מקבילי | נמוך-בינוני | גבוה מאוד | גבוה מאוד (מותאם אישית) | גבוה מאוד | גבוה מאוד | מקסימלי |
| latency | גבוה יחסית | בינוני | נמוך מאוד | נמוך | נמוך | נמוך מאוד |
| throughput | נמוך | גבוה מאוד | תלוי תכנון | גבוה מאוד | גבוה מאוד | מקסימלי |
| צריכת חשמל | גבוהה | גבוהה מאוד | נמוכה-בינונית | נמוכה | בינונית | נמוכה מאוד |
| התאמה ל-AI קטן | טובה | טובה | מצוינת | מצוינת | פחות | פחות |
| התאמה ל-AI גדול | מוגבלת | מצוינת | תלוי משאבים | מצוינת | מצוינת | מצוינת |
| זמן פיתוח | קצר | בינוני | ארוך | קצר | קצר | ארוך מאוד |
| התאמה ל-real-time | בינונית | טובה | מצוינת | מצוינת | טובה | מצוינת |
| TOPS | קבוע לפי CPU | גבוה מאוד | תלוי תכנון | גבוה מאוד | גבוה מאוד | מקסימלי |
הסבר הנדסי: איך סוג החומרה משפיע על הרצת מודל
1. CPU – גמישות על חשבון ביצועים
CPU מריץ קוד סדרתי יחסית:
|
1 |
load → compute → store → repeat |
השפעה על מודל:
- מתאים למודלים קטנים או ניסויים
- latency גבוה יחסית
- לא מנצל היטב מקביליות של רשתות נוירונים
- bottleneck בזיכרון וב-cache
שימוש טיפוסי:
|
1 2 3 4 |
debug prototype control logic pre/post processing |
2. GPU – מקביליות רחבה
GPU בנוי להריץ אלפי threads במקביל:
|
1 2 3 |
matrix multiply convolution vector operations |
השפעה על מודל:
- מצוין ל-CNN, Transformer, LLM
- throughput גבוה מאוד
- latency בינוני (kernel launch overhead)
- דורש memory bandwidth גבוה
שימוש טיפוסי:
|
1 2 3 4 |
training large inference computer vision deep learning |
3. FPGA – חומרה מותאמת למודל
FPGA מאפשר לבנות pipeline מותאם:
|
1 |
input → MAC array → activation → output |
השפעה על מודל:
- latency נמוך מאוד
- deterministic timing
- ניתן להתאים בדיוק למודל
- יעיל במיוחד ל-AI קטן/בינוני
יתרון קריטי:
|
1 |
אפשר לבנות בדיוק את מספר ה-MAC הדרוש |
חיסרון:
|
1 |
פיתוח מורכב |
4. NPU – מאיץ AI ייעודי
NPU הוא יחידת חישוב שמיועדת ל-AI בלבד:
|
1 2 3 |
optimized MAC arrays tensor operations quantized inference |
השפעה על מודל:
- ביצועים גבוהים מאוד ל-inference
- latency נמוך
- תלוי ב-SDK ובתמיכה במודל
שימוש טיפוסי:
|
1 2 3 |
mobile AI edge devices embedded systems |
5. TPU – אופטימיזציה ל-TensorFlow
TPU (של Google) מותאם ל:
|
1 2 3 |
matrix multiplication tensor operations deep learning workloads |
השפעה על מודל:
- ביצועים גבוהים מאוד ל-Transformer ו-CNN
- מתאים ל-training ו-inference
- פחות גמיש מחומרה כללית
6. ASIC AI Accelerator – ביצועים מקסימליים
ASIC הוא שבב שתוכנן במיוחד למודל או סוג מודלים:
|
1 2 3 |
fixed datapath optimized memory maximum efficiency |
השפעה על מודל:
- ביצועים מקסימליים
- צריכת חשמל מינימלית
- אין גמישות
חיסרון:
|
1 |
אי אפשר לשנות אחרי ייצור |
איך זה משפיע על מודל ספציפי?
ניקח דוגמה:
|
1 2 |
ANN קטן: 14 → 14 → 28 → 14 → 1 ≈ 2,000 operations |
CPU
|
1 2 3 |
הרצה סדרתית יחסית latency גבוה לא מנצל מקביליות |
GPU
|
1 2 |
overkill latency לא אופטימלי למודל קטן |
FPGA
|
1 2 3 |
אפשר לבנות 64 MAC במקביל latency נמוך מאוד (~100ns) יעילות גבוהה |
NPU
|
1 2 3 |
יעיל מאוד אם נתמך latency נמוך קל לשימוש |
TPU
|
1 2 |
לא אידיאלי למודל קטן מיועד ל-scale גדול |
ASIC
|
1 2 |
הכי יעיל אם תוכנן בדיוק למודל אבל לא גמיש |
השפעה על TOPS לפי סוג חומרה
CPU
|
1 |
TOPS מוגבל לפי SIMD וליבות |
GPU
|
1 2 |
TOPS גבוה מאוד (מאות עד אלפי) אבל לא תמיד מנוצל 100% |
FPGA
|
1 |
TOPS = פונקציה של התכנון שלך |
NPU / TPU / ASIC
|
1 2 |
TOPS גבוה מאוד מותאם ל-AI בלבד |
מסקנה הנדסית למהנדסים
בחירת חומרה להרצת מודל AI תלויה ב:
|
1 2 3 4 5 6 |
גודל המודל latency דרוש throughput צריכת חשמל גמישות זמן פיתוח |
כללי אצבע
|
1 2 3 4 5 6 |
CPU → פיתוח, שליטה, מודלים קטנים GPU → מודלים גדולים, training FPGA → real-time, latency נמוך, התאמה אישית NPU → inference יעיל ב-edge TPU → deep learning בקנה מידה גדול ASIC → מוצר סופי עם דרישות קבועות |
סיכום
אין חומרה אחת "הכי טובה".
יש התאמה בין:
|
1 2 3 4 5 |
מודל דרישות מערכת צריכת חשמל latency עלות |
איך זה משנה את TOPS בפועל?
ב-CPU ה-TOPS הוא תוצאה של המעבד:
|
1 2 3 4 5 |
כמה ליבות יש מה התדר איזה SIMD יש כמה פעולות כל instruction עושה |
ב-FPGA ה-TOPS הוא תוצאה של התכנון:
|
1 2 3 4 5 6 |
כמה MAC units בנית מה התדר שסגרת כמה pipeline stages יש כמה זיכרון פנימי יש כמה נתונים נכנסים בכל clock |
לכן ב-FPGA לא נכון לשאול רק:
|
1 2 |
כמה TOPS יש לרכיב? |
אלא צריך לשאול:
|
1 2 |
כמה TOPS אפשר לבנות על הרכיב עבור המודל שלי? |
זו שאלה הרבה יותר נכונה.
דוגמה מעשית: ANN קטן
רשת:
|
1 2 |
14 → 14 → 28 → 14 → 1 |
דורשת בערך:
|
1 2 3 |
994 MAC ≈ 2,000 operations |
אם נשתמש ב-FPGA עם:
|
1 2 3 |
64 MAC units 150 MHz |
נקבל:
|
1 2 |
0.0192 TOPS |
וזמן חישוב אידיאלי:
|
1 2 |
≈ 106.7 ns |
כלומר:
|
1 2 |
כ-9.3 מיליון inference/sec |
לכן לרשת ANN קטנה אין צורך ב-10 TOPS או 100 TOPS.
מה שחשוב יותר הוא:
|
1 2 3 4 5 6 7 |
latency חיבור לחיישן pipeline צריכת חשמל דיוק אמינות |
דוגמה מעשית: CNN קטן
מודל CNN קטן יכול לדרוש מאות מיליוני פעולות לכל תמונה.
לדוגמה:
|
1 2 |
450M operations לכל inference |
אם רוצים 30 FPS:
|
1 2 |
450M × 30 = 13.5B operations/sec |
המרה ל-TOPS:
|
1 2 |
13.5B / 1T = 0.0135 TOPS |
כלומר:
|
1 2 |
0.0135 TOPS |
אבל בפועל צריך יותר בגלל:
|
1 2 3 4 5 6 7 |
גישה לזיכרון overhead activation pooling data movement לא כל MAC מנוצל 100% |
לכן במציאות בוחרים רכיב עם מרווח ביטחון.
מסקנה הנדסית
TOPS הוא מספר חשוב, אבל הוא לא מספר מספיק.
במערכת אמיתית צריך לבדוק:
|
1 2 3 4 5 6 7 8 9 10 11 |
TOPS latency memory bandwidth power consumption toolchain model support precision IO cost availability |
למערכת AI קטנה עם חיישנים, FPGA יכול להיות בחירה מעולה.
למערכת AI גדולה כמו LLM או YOLO כבד, בדרך כלל GPU או NPU יהיו פשוטים וחזקים יותר.
למערכת real-time עם חיישנים, latency נמוך ותגובה קבועה, FPGA יכול להיות עדיף מ-CPU.
סיכום
CPU הוא מעבד כללי, קל לתכנות וגמיש.
FPGA הוא חומרה ניתנת לתכנות, קשה יותר לפיתוח, אבל חזק מאוד בעיבוד מקבילי וזמן אמת.
ב-CPU ה-TOPS מגיע מהמעבד.
ב-FPGA ה-TOPS מגיע מהארכיטקטורה שאתה בונה.
לכן FPGA יכול להיות מצוין לבינה מלאכותית כאשר המודל ידוע, החישוב חוזר על עצמו, וצריך זמן תגובה נמוך וקבוע.
המשפט החשוב לזכור:
|
1 2 3 4 5 |
CPU מריץ תוכנה. FPGA בונה חומרה. NPU מריץ AI ייעודי. GPU מריץ חישוב מקבילי גדול. |
ובמערכת הנדסית טובה לא בוחרים רק לפי TOPS.
בוחרים לפי:
|
1 2 3 4 5 6 7 8 |
ביצועים אמיתיים צריכת חשמל latency עלות כלי פיתוח זמינות רכיבים התאמה למודל |
בינה מלאכותית