מה זה TOPS בבינה מלאכותית וב-FPGA?
כאשר מדברים על שבבים שמריצים Artificial Intelligence, הרבה פעמים רואים נתון בשם TOPS.
TOPS הוא קיצור של:
Tera Operations Per Second
כלומר:
Trillion Operations Per Second
במספרים:
|
1 2 |
1 TOPS = 1,000,000,000,000 operations per second |
כלומר, אם כתוב על שבב שהוא יודע לבצע 1 TOPS, הכוונה היא שהוא מסוגל לבצע בערך טריליון פעולות חישוב בכל שנייה.
למה TOPS חשוב בבינה מלאכותית?
רשת נוירונים מלאכותית, כמו ANN, CNN או Transformer, מבצעת הרבה מאוד חישובים פשוטים.
החישוב הנפוץ ביותר הוא:
|
1 2 |
multiply + add |
לדוגמה:
|
1 2 |
y = x * w + b |
כאשר:
|
1 2 3 4 5 |
x = input w = weight b = bias y = output |
ברשת נוירונים יש הרבה מאוד weights, ולכן יש הרבה מאוד פעולות multiply ו-add.
בגלל זה מודדים את הכוח של שבבי AI ביחידות כמו TOPS.
מה זה MAC?
בבינה מלאכותית משתמשים הרבה במושג:
|
1 2 |
MAC = Multiply Accumulate |
הכוונה היא:
|
1 2 |
multiply ואז add |
לדוגמה:
|
1 2 |
sum = sum + x * w |
חשוב לדעת:
חלק מהחברות סופרות MAC אחד כ-operation אחת.
חלק מהחברות סופרות MAC אחד כשתי operations:
|
1 2 |
1 multiply + 1 add = 2 operations |
לכן, כאשר משווים TOPS בין שבבים, צריך לבדוק איך החברה ספרה את ה-operations.
TOPS תלוי בדיוק המספרים
אותו שבב יכול לתת ביצועים שונים לפי סוג המספרים:
|
1 2 3 4 5 |
INT8 INT16 FP16 FP32 |
לדוגמה:
|
1 2 |
4 TOPS INT8 |
לא אומר בהכרח:
|
1 2 |
4 TOPS FP32 |
בדרך כלל:
|
1 2 3 4 |
INT8 = very fast ומתאים להרבה models קטנים FP16 = יותר חזק ויותר מדויק FP32 = הכי מדויק אבל יותר איטי |
לכן תמיד צריך לבדוק באיזה data type נמדד ה-TOPS.
הקשר בין FPGA ל-TOPS?
במעבד רגיל או בשבב AI מוכן, היצרן נותן מספר TOPS קבוע.
אבל ב-FPGA המצב שונה.
FPGA הוא רכיב שניתן לבנות בו hardware לפי הצורך.
לכן ה-TOPS של FPGA תלוי במה שתכננת בתוך ה-FPGA:
אז מה זה TOPS בבינה מלאכותית וב-FPGA?
כאשר מדברים על שבבים שמריצים Artificial Intelligence, הרבה פעמים רואים נתון בשם TOPS.
TOPS הוא קיצור של:
Tera Operations Per Second
כלומר:
Trillion Operations Per Second
במספרים:
|
1 2 |
1 TOPS = 1,000,000,000,000 operations per second |
כלומר, אם כתוב על שבב שהוא יודע לבצע 1 TOPS, הכוונה היא שהוא מסוגל לבצע בערך טריליון פעולות חישוב בכל שנייה.
למה TOPS חשוב בבינה מלאכותית?
רשת נוירונים מלאכותית, כמו ANN, CNN או Transformer, מבצעת הרבה מאוד חישובים פשוטים.
החישוב הנפוץ ביותר הוא:
|
1 2 |
multiply + add |
לדוגמה:
|
1 2 |
y = x * w + b |
כאשר:
|
1 2 3 4 5 |
x = input w = weight b = bias y = output |
בצורה כללית יותר, עבור נוירון:
|
1 2 |
y = Σ (xi * wi) + b |
כלומר:
|
1 2 |
y = x1*w1 + x2*w2 + ... + xn*wn + b |
ברשת נוירונים יש הרבה מאוד weights, ולכן יש הרבה מאוד פעולות multiply ו-add.
בגלל זה מודדים את הכוח של שבבי AI ביחידות כמו TOPS.
מה זה MAC?
בבינה מלאכותית משתמשים הרבה במושג:
|
1 2 |
MAC = Multiply Accumulate |
הכוונה היא:
|
1 2 |
multiply ואז add |
לדוגמה:
|
1 2 |
sum = sum + x * w |
בצורה כללית:
|
1 2 |
sum_new = sum_old + (x * w) |
חשוב לדעת:
חלק מהחברות סופרות MAC אחד כ-operation אחת.
חלק מהחברות סופרות MAC אחד כשתי operations:
|
1 2 |
1 multiply + 1 add = 2 operations |
כלומר:
|
1 2 |
operations = MAC × 2 |
לכן, כאשר משווים TOPS בין שבבים, צריך לבדוק איך החברה ספרה את ה-operations.
TOPS תלוי בדיוק המספרים
אותו שבב יכול לתת ביצועים שונים לפי סוג המספרים:
|
1 2 3 4 5 |
INT8 INT16 FP16 FP32 |
לדוגמה:
|
1 2 |
4 TOPS INT8 |
לא אומר בהכרח:
|
1 2 |
4 TOPS FP32 |
בדרך כלל:
|
1 2 3 4 |
INT8 = very fast ומתאים להרבה models קטנים FP16 = יותר חזק ויותר מדויק FP32 = הכי מדויק אבל יותר איטי |
לכן תמיד צריך לבדוק באיזה data type נמדד ה-TOPS.
מה הקשר בין FPGA ל-TOPS?
במעבד רגיל או בשבב AI מוכן, היצרן נותן מספר TOPS קבוע.
אבל ב-FPGA המצב שונה.
FPGA הוא רכיב שניתן לבנות בו hardware לפי הצורך.
לכן ה-TOPS של FPGA תלוי במה שתכננת בתוך ה-FPGA:
|
1 2 3 4 5 6 7 |
כמה multipliers עובדים במקביל מה clock frequency כמה operations מתבצעות בכל clock האם משתמשים ב-DSP blocks האם משתמשים ב-INT8 או FP16 כמה internal memory יש |
נוסחה כללית:
|
1 2 |
TOPS = (operations_per_clock × clock_frequency) / 1,000,000,000,000 |
כאשר:
|
1 2 3 |
operations_per_clock = מספר הפעולות בכל מחזור שעון clock_frequency = תדר העבודה (Hz) |
לדוגמה:
אם FPGA מבצע:
|
1 2 3 |
operations_per_clock = 1000 clock_frequency = 200 MHz = 200,000,000 Hz |
אז:
|
1 2 |
operations_per_second = 1000 × 200,000,000 |
|
1 2 |
operations_per_second = 200,000,000,000 |
ולכן:
|
1 2 |
TOPS = 200,000,000,000 / 1,000,000,000,000 |
|
1 2 |
TOPS = 0.2 |
האם TOPS לבד מספיק?
לא.
TOPS הוא מספר חשוב, אבל הוא לא מספר שמספר את כל האמת.
צריך לבדוק גם:
|
1 2 3 4 5 6 7 8 9 10 11 |
model size memory speed memory bandwidth latency power consumption numeric precision INT8 support DSP count BRAM size development complexity |
לדוגמה:
שבב עם TOPS גבוה אבל memory איטי יכול לעבוד לאט.
לעומת זאת, FPGA עם TOPS נמוך יותר יכול לתת latency נמוך מאוד אם ה-model קטן ומתוכנן טוב.
דוגמה פשוטה: כמה TOPS צריך לרשת ANN קטנה?
נניח שיש לנו רשת ANN פשוטה.
המבנה שלה הוא:
|
1 2 3 4 5 6 |
input: 14 values hidden layer 1: 14 neurons hidden layer 2: 28 neurons hidden layer 3: 14 neurons output: 1 neuron |
כלומר:
|
1 2 |
14 → 14 → 28 → 14 → 1 |
זו רשת Fully Connected.
כל neuron מחובר לכל ה-neurons בשכבה הקודמת.
חישוב מספר הפעולות
שכבה ראשונה
נוסחה:
|
1 2 |
MAC_layer1 = inputs × neurons |
חישוב:
|
1 2 |
MAC_layer1 = 14 × 14 = 196 |
שכבה שנייה
נוסחה:
|
1 2 |
MAC_layer2 = inputs × neurons |
חישוב:
|
1 2 |
MAC_layer2 = 14 × 28 = 392 |
שכבה שלישית
נוסחה:
|
1 2 |
MAC_layer3 = inputs × neurons |
חישוב:
|
1 2 |
MAC_layer3 = 28 × 14 = 392 |
שכבת הפלט
נוסחה:
|
1 2 |
MAC_output = inputs × neurons |
חישוב:
|
1 2 |
MAC_output = 14 × 1 = 14 |
סכימה כוללת
נוסחה:
|
1 2 |
Total_MAC = MAC1 + MAC2 + MAC3 + MAC_output |
חישוב:
|
1 2 |
Total_MAC = 196 + 392 + 392 + 14 |
|
1 2 |
Total_MAC = 994 |
כלומר:
|
1 2 |
994 MAC per inference |
המרה ל-operations
נוסחה:
|
1 2 |
operations = MAC × 2 |
חישוב:
|
1 2 |
operations = 994 × 2 = 1,988 |
נוסיף bias ו-activation:
|
1 2 |
operations ≈ 2,000 per inference |
כמה TOPS זה באמת?
נוסחה כללית:
|
1 2 |
TOPS = operations_per_second / 1,000,000,000,000 |
מקרה 1: הרצה אחת בשנייה
|
1 2 |
operations_per_second = 2,000 × 1 |
|
1 2 |
operations_per_second = 2,000 |
|
1 2 |
TOPS = 2,000 / 1,000,000,000,000 |
|
1 2 |
TOPS = 0.000000002 |
מקרה 2: 1,000 הרצות בשנייה
|
1 2 |
operations_per_second = 2,000 × 1,000 |
|
1 2 |
operations_per_second = 2,000,000 |
|
1 2 |
TOPS = 2,000,000 / 1,000,000,000,000 |
|
1 2 |
TOPS = 0.000002 |
מקרה 3: 1,000,000 הרצות בשנייה
|
1 2 |
operations_per_second = 2,000 × 1,000,000 |
|
1 2 |
operations_per_second = 2,000,000,000 |
|
1 2 |
TOPS = 2,000,000,000 / 1,000,000,000,000 |
|
1 2 |
TOPS = 0.002 |
טבלה קצרה
|
1 2 3 4 5 6 7 |
inference rate operations/sec required TOPS 1 per second 2,000 0.000000002 TOPS 1,000 per second 2,000,000 0.000002 TOPS 10,000 per second 20,000,000 0.00002 TOPS 100,000 per second 200,000,000 0.0002 TOPS 1,000,000 per sec 2,000,000,000 0.002 TOPS |
מסקנה מהדוגמה
רשת ANN קטנה בגודל:
|
1 2 |
14 → 14 → 28 → 14 → 1 |
לא באמת צריכה שבב של TOPS גבוה.
היא צריכה רק כמה אלפי operations לכל inference.
רשת כזאת יכולה לרוץ גם על:
|
1 2 3 4 5 6 |
small CPU strong microcontroller ESP32 (in some cases) small FPGA small NPU |
היתרון של FPGA במקרה כזה הוא לא בהכרח TOPS גבוה, אלא:
|
1 2 3 4 5 6 7 |
low latency fast response parallel processing low power consumption full hardware control ability to run multiple sensors in parallel |
מתי באמת צריך TOPS גבוה?
TOPS גבוה חשוב יותר כאשר מריצים models גדולים כמו:
|
1 2 3 4 5 6 7 8 9 |
CNN for image recognition YOLO Transformer Large Language Models models with millions of weights real-time video processing multiple cameras multiple audio streams |
לדוגמה, object detection עם YOLO דורש הרבה יותר computation מאשר ANN קטן.
שם כבר TOPS, memory, bandwidth ו-hardware efficiency הופכים להיות חשובים מאוד.
סיכום עד כה
TOPS הוא מדד שמראה כמה operations שבב יכול לבצע בשנייה.
בבינה מלאכותית רוב הפעולות הן multiply ו-add.
ב-FPGA ה-TOPS תלוי בתכנון שאתה בונה בתוך הרכיב.
אבל TOPS לבד לא מספיק כדי לדעת אם מערכת טובה.
צריך לבדוק גם latency, memory, power consumption, numeric precision וגודל ה-model.
בדוגמה של רשת ANN קטנה בגודל:
|
1 2 |
14 → 14 → 28 → 14 → 1 |
צריך בערך:
|
1 2 |
2,000 operations per inference |
ולכן גם אם מריצים אותה אלפי פעמים בשנייה, היא עדיין לא דורשת TOPS גבוה.
המסקנה החשובה היא:
לא כל מערכת בינה מלאכותית צריכה שבב חזק של עשרות TOPS. לפעמים תכנון נכון של model קטן, מדויק ומהיר הרבה יותר חשוב ממספר TOPS גדול.
Artificial Intelligence
חישוב מתקדם שלב ב
דוגמה: חישוב TOPS לאימון רשת ANN (Training)
מבנה הרשת:
|
1 |
14 → 14 → 28 → 14 → 1 |
שלב 1: חישוב פעולות ל-Inference
כמו קודם:
|
1 |
≈ 2,000 operations per inference |
שלב 2: חישוב פעולות ל-Training
באימון יש:
|
1 2 3 |
Forward pass Backward pass (Backpropagation) Gradient update |
בקירוב:
|
1 |
training ≈ 4 × inference |
לכן:
|
1 |
training_per_sample ≈ 2,000 × 4 = 8,000 operations |
שלב 3: Batch Processing
|
1 |
batch_size = 32 |
|
1 |
operations_per_batch = 32 × 8,000 |
|
1 |
operations_per_batch = 256,000 |
שלב 4: מספר batches
|
1 |
total_samples = 1000 |
|
1 |
batches_per_epoch = ceil(1000 / 32) = 32 |
|
1 |
total_batches = 32 × 10 epochs = 320 |
שלב 5: חישוב כולל
|
1 |
total_operations = 320 × 256,000 |
|
1 |
total_operations = 81,920,000 ≈ 8.2 × 10^7 |
שלב 6: זמן ריצה על CPU
|
1 |
CPU frequency = 2 GHz = 2 × 10^9 cycles/sec |
נניח:
|
1 |
1 operation ≈ 1 cycle |
חישוב זמן
|
1 |
time = total_operations / operations_per_second |
|
1 |
time = (8.2 × 10^7) / (2 × 10^9) |
|
1 |
time ≈ 0.041 sec |
שלב 7: חישוב TOPS בפועל
|
1 |
ops/sec = total_operations / time |
|
1 |
ops/sec ≈ 2 × 10^9 |
|
1 |
TOPS = (2 × 10^9) / (10^12) |
|
1 |
TOPS = 0.002 |
מסקנה מהחישוב
האימון של הרשת:
|
1 |
14 → 14 → 28 → 14 → 1 |
עם:
|
1 2 3 4 |
1000 samples batch size = 32 10 epochs CPU 2GHz |
דורש:
|
1 2 |
≈ 82 million operations ≈ 0.002 TOPS |
מסקנה כללית
גם כאשר מוסיפים:
|
1 2 3 |
batch processing multi-step training CPU מהיר |
עדיין:
|
1 |
required TOPS is very low |
למה זה חשוב?
זה מראה ש:
|
1 |
לא כל מודל AI דורש hardware חזק |
רשת קטנה יכולה לרוץ על:
|
1 2 3 4 5 |
CPU רגיל Embedded system Microcontroller (במקרים מסוימים) Small FPGA Low-power NPU |
סיכום
TOPS הוא מדד שמראה כמה operations שבב יכול לבצע בשנייה.
אבל:
|
1 |
TOPS ≠ performance מלא |
צריך להבין גם:
|
1 2 3 4 |
algorithm complexity data movement memory bottlenecks parallelism |
מסקנה חשובה
|
1 |
Small model + good design > huge TOPS |
כלומר:
|
1 |
מודל קטן ומתוכנן נכון יכול להיות יעיל יותר משבב חזק מאוד |
חישוב TOPS להרצת מודל CNN / YOLO על מעבד (CPU)
עכשיו נבצע דוגמה יותר מתקדמת על מודל אמיתי יותר:
|
1 |
CNN / YOLO-like model (object detection) |
הנחות בסיס (Assumptions)
|
1 2 3 4 |
Input image = 224 × 224 × 3 Model = simplified CNN CPU frequency = 2 GHz Precision = INT8 |
שלב 1: חישוב פעולות בשכבת Convolution
נניח שכבה:
|
1 2 3 4 |
Input: 224 × 224 × 3 Kernel: 3 × 3 Filters: 32 Stride = 1 |
חישוב output size
|
1 |
Output = 224 × 224 × 32 |
חישוב MAC לכל פיקסל
|
1 |
Kernel size = 3 × 3 × 3 = 27 multiplications |
כל פיקסל דורש:
|
1 |
27 MAC |
חישוב כולל לשכבה
|
1 |
Total pixels = 224 × 224 × 32 = 1,605,632 |
|
1 |
Total MAC = 1,605,632 × 27 |
|
1 |
Total MAC ≈ 43,352,064 |
המרה ל-operations
|
1 |
operations = MAC × 2 |
|
1 |
operations ≈ 86,704,128 |
שלב 2: שכבות נוספות (Approximation)
נניח שיש:
|
1 |
5 convolution layers |
בקירוב:
|
1 |
total_operations ≈ 5 × 86M |
|
1 |
total_operations ≈ 430M operations |
שלב 3: Fully Connected + Activation
נוסיף:
|
1 |
≈ 20M operations |
סה"כ פעולות ל-Inference אחד
|
1 |
total ≈ 450M operations |
שלב 4: חישוב זמן ריצה על CPU
|
1 |
CPU = 2 GHz = 2 × 10^9 ops/sec |
זמן להרצה אחת
|
1 |
time = operations / ops_per_sec |
|
1 |
time = 450 × 10^6 / (2 × 10^9) |
|
1 |
time ≈ 0.225 sec |
שלב 5: Frames Per Second (FPS)
|
1 |
FPS = 1 / time |
|
1 |
FPS ≈ 4.4 |
שלב 6: חישוב TOPS בפועל
|
1 |
ops/sec ≈ 2 × 10^9 |
|
1 |
TOPS = (2 × 10^9) / (10^12) |
|
1 |
TOPS = 0.002 |
שלב 7: אם רוצים 30 FPS (Real-Time)
|
1 |
required_ops = 450M × 30 |
|
1 |
required_ops = 13.5 × 10^9 ops/sec |
המרה ל-TOPS
|
1 |
TOPS = 13.5 × 10^9 / 10^12 |
|
1 |
TOPS = 0.0135 |
מסקנה מהדוגמה
|
1 2 |
CNN / YOLO קטן דורש: ~0.01 TOPS עבור real-time (30 FPS) |
השוואה ל-ANN קטן
|
1 2 |
ANN קטן → ~2,000 operations CNN → מאות מיליונים operations |
תובנה חשובה
|
1 |
Model complexity ↑ → operations ↑ → TOPS ↑ |
סיכום
|
1 2 |
ANN קטן → כמעט לא דורש TOPS CNN / YOLO → דורש הרבה יותר חישוב |
אבל עדיין:
|
1 |
Optimization חשוב יותר מ-TOPS בלבד |
היתרונות של FPGA על CPU בבינה מלאכותית
איך זה משנה את TOPS ?
כאשר מריצים מודל בינה מלאכותית, אפשר להריץ אותו על כמה סוגי חומרה:
|
1 2 3 4 5 |
CPU GPU FPGA NPU / AI Accelerator |
במאמר הזה נתמקד בהבדל בין:
|
1 2 |
CPU לעומת FPGA |
מה ההבדל הבסיסי בין CPU ל-FPGA?
CPU
מעבד CPU הוא מעבד כללי.
הוא יודע להריץ כמעט כל תוכנה:
|
1 2 3 4 5 6 |
מערכת הפעלה Python C תוכנות רגילות אלגוריתמים כלליים |
אבל CPU עובד בדרך כלל בצורה סדרתית יותר.
כלומר, הוא מבצע פקודות אחת אחרי השנייה, גם אם יש לו כמה ליבות.
היתרון של CPU:
|
1 2 3 4 5 |
קל לתכנות גמיש מאוד מתאים להרבה משימות תדר עבודה גבוה |
החיסרון של CPU:
|
1 2 3 4 5 |
פחות יעיל לחישובים מקביליים גדולים צריכת חשמל גבוהה יותר לכל פעולת AI latency פחות קבוע לא תמיד מתאים לזמן אמת קשיח |
FPGA
FPGA הוא רכיב לוגי שניתן לבנות בתוכו חומרה מותאמת אישית.
במקום להריץ תוכנה בלבד, אנחנו בונים ממש מעגל חישוב.
לדוגמה, אפשר לבנות בתוך FPGA:
|
1 2 3 4 5 6 |
100 יחידות כפל 500 יחידות MAC pipeline לחישוב רשת נוירונים עיבוד מקבילי של כמה חיישנים מערכת real-time עם latency קבוע |
היתרון של FPGA:
|
1 2 3 4 5 6 7 |
מקביליות גבוהה latency נמוך מאוד תגובה דטרמיניסטית צריכת חשמל טובה ביחס לביצועים שליטה מלאה במבנה החומרה מתאים לעיבוד אותות, מצלמות, אודיו וחיישנים |
החיסרון של FPGA:
|
1 2 3 4 5 6 |
פיתוח מורכב יותר צריך Verilog / VHDL / HLS צריך להבין timing צריך לתכנן זיכרון וזרימת נתונים לא כל מודל AI מתאים ישירות ל-FPGA |
למה FPGA יכול להיות מהיר למרות שהתדר שלו נמוך יותר?
CPU יכול לעבוד בתדר גבוה, לדוגמה:
|
1 2 3 4 |
2 GHz 3 GHz 4 GHz |
FPGA בדרך כלל עובד בתדר נמוך יותר, לדוגמה:
|
1 2 3 4 |
100 MHz 200 MHz 300 MHz |
אבל FPGA יכול לבצע הרבה פעולות במקביל.
כלומר:
|
1 2 3 |
CPU = תדר גבוה, פחות מקביליות FPGA = תדר נמוך יותר, הרבה מקביליות |
זו נקודה חשובה מאוד.
איך FPGA משנה את חישוב ה-TOPS?
ב-CPU מספר הפעולות בכל clock מוגבל לפי הארכיטקטורה של המעבד.
אבל ב-FPGA אתה בונה את הארכיטקטורה.
לכן ב-FPGA אפשר להחליט:
|
1 2 3 4 5 |
כמה MAC units יהיו במקביל כמה pipeline stages יהיו כמה נתונים ייכנסו בכל clock באיזה precision משתמשים |
הנוסחה הבסיסית היא:
|
1 2 |
TOPS = operations_per_clock × clock_frequency / 10^12 |
אם משתמשים ב-MAC:
|
1 2 |
1 MAC = multiply + add |
ואם סופרים MAC כשתי פעולות:
|
1 2 |
operations_per_clock = number_of_MAC_units × 2 |
לכן:
|
1 2 |
TOPS = number_of_MAC_units × 2 × frequency / 10^12 |
דוגמה פשוטה לחישוב TOPS ב-FPGA
נניח שבנינו בתוך FPGA:
|
1 2 |
512 MAC units |
וכל MAC עובד בכל clock.
נניח שהתדר הוא:
|
1 2 |
200 MHz |
כל MAC מבצע:
|
1 2 |
1 multiply + 1 add = 2 operations |
לכן בכל clock יש:
|
1 2 |
512 × 2 = 1024 operations per clock |
עכשיו נכפיל בתדר:
|
1 2 |
1024 × 200,000,000 = 204,800,000,000 operations/sec |
כלומר:
|
1 2 |
204.8 GOPS |
המרה ל-TOPS:
|
1 2 |
204,800,000,000 / 1,000,000,000,000 = 0.2048 TOPS |
כלומר:
|
1 2 |
FPGA כזה נותן בערך 0.205 TOPS |
דוגמה עם FPGA קטן יותר
נניח FPGA קטן יותר עם:
|
1 2 |
64 MAC units |
בתדר:
|
1 2 |
150 MHz |
חישוב:
|
1 2 |
operations_per_clock = 64 × 2 = 128 operations |
|
1 2 |
ops/sec = 128 × 150,000,000 |
|
1 2 |
ops/sec = 19,200,000,000 |
המרה ל-TOPS:
|
1 2 |
19.2 × 10^9 / 10^12 = 0.0192 TOPS |
כלומר:
|
1 2 |
0.0192 TOPS |
זה נשמע קטן, אבל לרשתות קטנות זה הרבה מאוד.
דוגמה על רשת ANN קטנה
נחזור לרשת:
|
1 2 |
14 → 14 → 28 → 14 → 1 |
חישבנו קודם שהיא דורשת בערך:
|
1 2 |
994 MAC |
או בערך:
|
1 2 |
2,000 operations |
לכל inference אחד.
הרצה על FPGA עם 64 MAC units
אם יש ב-FPGA:
|
1 2 |
64 MAC units |
אז בכל clock אפשר לבצע:
|
1 2 |
64 MAC |
הרשת דורשת:
|
1 2 |
994 MAC |
מספר מחזורי clock בקירוב:
|
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 |
inference_per_second = 1 / 106.7 ns |
|
1 2 |
≈ 9,370,000 inference/sec |
כלומר, בתיאוריה:
|
1 2 |
כ-9.3 מיליון הרצות בשנייה |
בפועל יהיה פחות בגלל:
|
1 2 3 4 5 6 7 |
גישה לזיכרון טעינת input שמירת output activation function pipeline overhead בקרת מערכת |
אבל עדיין זו כמות עצומה לרשת קטנה.
השוואה פשוטה מול CPU
נניח CPU מבצע את החישוב בצורה פחות מקבילית.
אם CPU מבצע רק כמה MAC בכל clock, הוא צריך יותר מחזורי clock.
CPU חזק יכול להיות מהיר מאוד, אבל הוא מריץ גם:
|
1 2 3 4 5 6 |
מערכת הפעלה זיכרון cache interrupts תהליכים נוספים קוד כללי ולא חומרה ייעודית |
FPGA, לעומת זאת, יכול להיות בנוי רק למטרה אחת:
|
1 2 3 4 |
לקבל input להריץ ANN להוציא output |
לכן היתרון הגדול של FPGA הוא לא רק TOPS.
היתרון הגדול הוא:
|
1 2 3 4 5 6 |
latency נמוך זמן תגובה קבוע מקביליות אמיתית עיבוד בזמן אמת יעילות חשמלית |
למה TOPS של FPGA לא תמיד מופיע בדף הנתונים?
ב-CPU או NPU היצרן יכול לכתוב:
|
1 2 3 4 |
1 TOPS 4 TOPS 10 TOPS |
אבל ב-FPGA זה תלוי בתכנון שלך.
אותו FPGA יכול לתת ביצועים שונים מאוד לפי:
|
1 2 3 4 5 6 7 |
כמה DSP blocks השתמשת מה התדר שהצלחת לסגור האם החישוב INT8 או FP16 כמה pipeline בנית כמה זיכרון פנימי יש כמה נתונים מגיעים בכל clock |
לכן ב-FPGA לא שואלים רק:
|
1 2 |
כמה TOPS יש לו? |
אלא שואלים:
|
1 2 |
כמה TOPS אני יכול לבנות עליו עבור המודל שלי? |
מסקנה
FPGA לא תמיד מנצח CPU בכל דבר.
CPU עדיף כאשר צריך:
|
1 2 3 4 5 |
גמישות פיתוח מהיר הרצת תוכנות רגילות מערכת מורכבת עם הרבה לוגיקה משתנה |
FPGA עדיף כאשר צריך:
|
1 2 3 4 5 6 7 |
עיבוד מקבילי latency נמוך זמן אמת צריכת חשמל נמוכה חיבור ישיר לחיישנים חישוב קבוע שחוזר על עצמו |
בבינה מלאכותית, FPGA יכול להיות חזק במיוחד כאשר המודל קטן או בינוני, והחישוב שלו ידוע מראש.
הנקודה החשובה היא:
|
1 2 3 |
ב-CPU אתה מתאים את המודל למעבד. ב-FPGA אתה יכול לבנות חומרה שמתאימה למודל. |
וזה בדיוק מה שיכול לשנות את ה-TOPS בפועל.
בינה מלאכותית