TinyML למפתחי Embedded: מדריך מעשי להטמעת למידת מכונה על מיקרו-בקרים

אם יש לכם ניסיון בפיתוח Embedded ואתם רוצים להריץ מודלים של למידת מכונה ישירות על מיקרו-בקר — בלי ענן, בלי GPU, בלי זמן תגובה של שניות — TinyML הוא הכלי שאתם צריכים. הגישה הזו מאפשרת להריץ מודלים של Deep Learning על שבבים עם פחות מ-256KB זיכרון RAM, בצריכת חשמל של מילי-ואט בודדים. במדריך הזה נעבור צעד-אחרי-צעד מהמושגים הבסיסיים ועד לקוד עובד שרץ על חומרה אמיתית. לא מבטיחים שזה יהיה קל — אבל מבטיחים שבסוף המדריך הזה תדעו בדיוק מה לעשות כדי להתחיל.

TinyML (Tiny Machine Learning) הוא תחום שמתמקד בהרצת מודלים של למידת מכונה על מיקרו-בקרים קטנים וחסכוניים באנרגיה. אנחנו מדברים על שבבים כמו ARM Cortex-M4, ESP32 ו-nRF52840 — רכיבים שעולים דולרים בודדים ומסוגלים לזהות קול, לנתח נתוני חיישנים, ולבצע סיווג תמונות — הכל ב-Edge, בלי שום תלות בענן.

לפי דוח של ABI Research מ-2024, מספר ההתקנים שמריצים TinyML צפוי להגיע ל-2.5 מיליארד עד 2030. בישראל, התחום הזה מאוד חי — חברות כמו Hailo, שמפתחת מעבדי Edge AI, ו-Run:ai שנרכשה ע"י NVIDIA, מוכיחות שהתעשייה הישראלית נמצאת בחזית. אבל אתם לא חייבים לעבוד בחברת שבבים כדי לעשות את זה — כל מפתח/ת Embedded עם רצון ללמוד יכולים להתחיל היום.

ההבדל בין ML קלאסי ל-TinyML

ב-ML קלאסי, אתם מאמנים מודל על שרת עם GPU חזק, וה-inference (ההסקה) רץ על שרת או לפחות על מחשב עם משאבים סבירים. ב-TinyML, האימון עדיין מתבצע על מכונה חזקה — אבל את המודל המאומן מכווצים, מבצעים לו quantization (כימות — המרת משקולות מ-float32 ל-int8), ומריצים אותו על מיקרו-בקר עם 256KB RAM או פחות.

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

תרחישי שימוש אמיתיים

TinyML כבר לא ניסוי אקדמי. הנה תרחישים שרצים בפרודקשן היום: זיהוי מילת מפתח (keyword spotting) בפעמוני דלת חכמים, זיהוי חריגות (anomaly detection) בציוד תעשייתי, סיווג תנועות יד במכשירי wearable, ניטור רטט במפעלים לצורך תחזוקה מונעת, וזיהוי מחלות בצמחים דרך ניתוח תמונות בחקלאות מדייקת.

חברת Imagimob השבדית, שנרכשה על ידי Nordic Semiconductor, מציעה פלטפורמה שלמה לפיתוח TinyML — סימן ברור שיצרניות השבבים עצמן רואות בזה את העתיד של IoT.

בואו נהיה דוגריים — אין צורך להיות מומחה בלמידת מכונה כדי להתחיל עם TinyML. צריך הבנה בסיסית של C/C++, היכרות עם סביבת פיתוח Embedded (כלומר אתם כבר שם), ורצון אמיתי ללכלך את הידיים.

הסביבה: TensorFlow Lite for Microcontrollers

TensorFlow Lite Micro (TFLM) היא הספרייה הדומיננטית בתחום. היא מאפשרת להריץ מודלים של TensorFlow על מיקרו-בקרים ללא מערכת הפעלה, בלי הקצאת זיכרון דינאמית, ובלי תלות בספריות חיצוניות מורכבות. Google פיתחה את הפריימוורק הזה ספציפית עבור MCU-ים עם משאבים מוגבלים.

החלופה הראשית היא Edge Impulse — פלטפורמת no-code / low-code שמאפשרת לאסוף נתונים, לאמן מודלים, ולעשות deploy ישירות ללוח פיתוח. מתאימה מצוין לפרוטוטייפינג מהיר, אבל כשצריך שליטה מלאה — TFLM נותנת יותר גמישות.

בחירת חומרה

לא כל מיקרו-בקר מתאים ל-TinyML. צריך לפחות ARM Cortex-M4 עם FPU (יחידת נקודה צפה) כדי לקבל ביצועים סבירים. הנה ארבע אפשרויות מוכחות למתחילים:

Arduino Nano 33 BLE Sense — מגיע עם חיישני IMU, מיקרופון ותאורה, מבוסס nRF52840 (Cortex-M4F), ויש לו תמיכה רשמית ב-TensorFlow Lite Micro. מצוין ללימוד.

ESP32-S3 — של Espressif, עם תמיכה מובנית בווקטורים (SIMD), WiFi ו-Bluetooth, מחיר נמוך, וקהילה ישראלית פעילה. אופציה מצוינת למי שרוצה TinyML עם קישוריות.

STM32F4 Series — של ST Microelectronics, עם כלי פיתוח בוגרים (STM32CubeIDE), וספריית STM32Cube.AI שממירה מודלים ישירות לקוד C מותאם.

Raspberry Pi Pico — מבוסס RP2040 (Cortex-M0+), הכי זול מבין הארבעה. מתאים למודלים פשוטים מאוד אבל מוגבל בביצועים.

עכשיו ניכנס לעומק. נבנה מודל שמזהה מילת מפתח באודיו (keyword spotting) — הפרויקט הקלאסי של TinyML — ונריץ אותו על Arduino Nano 33 BLE Sense. התהליך כולל חמישה שלבים: איסוף נתונים, אימון מודל, quantization, המרה לפורמט C, והרצה על הלוח.

שלב 1: סביבת עבודה והתקנת כלים

נתחיל מהגדרת סביבת Python לאימון המודל. אנחנו עובדים עם TensorFlow 2.x ו-Jupyter Notebook. אם אתם מעדיפים, אפשר לעבוד ב-Google Colab בחינם — יש שם גם GPU לאימון.

# יצירת סביבה וירטואלית
python3 -m venv tinyml-env
source tinyml-env/bin/activate

# התקנת חבילות נדרשות
pip install tensorflow==2.15.0
pip install numpy matplotlib
pip install xxd  # להמרת מודל לפורמט C

# שכפול ריפו הדוגמאות של TensorFlow
git clone https://github.com/tensorflow/tflite-micro.git
cd tflite-micro

# הורדת דאטאסט Speech Commands של Google
# (נתוני אודיו עם 35 מילות מפתח כמו "yes", "no", "up", "down")
python3 -c "
import tensorflow as tf
import os

# הורדת הדאטאסט אוטומטית
data_dir = tf.keras.utils.get_file(
    'speech_commands_v0.02',
    'http://download.tensorflow.org/data/speech_commands_v0.02.tar.gz',
    extract=True,
    cache_dir='.',
    cache_subdir='data/speech_commands'
)
print(f'Data downloaded to: {data_dir}')
"

לאחר ההורדה, תקבלו תיקייה עם קבצי WAV ממוינים לפי מילות מפתח. הדאטאסט הזה של Google מכיל למעלה מ-100,000 דגימות של אנשים אמיתיים שאומרים 35 מילים שונות — זה הסטנדרט בתעשייה לפרויקטי keyword spotting.

שלב 2: אימון מודל בסיסי ב-Python

נבנה מודל CNN קטן שמסווג ספקטרוגרמות של אודיו. הארכיטקטורה מכוונת מראש למיקרו-בקר — פחות מ-20KB משקולות אחרי quantization.

import tensorflow as tf
import numpy as np
import pathlib

# פרמטרים של עיבוד אודיו
SAMPLE_RATE = 16000
FRAME_LENGTH = 256
FRAME_STEP = 128
NUM_MFCC = 13

# רשימת המילים שנרצה לזהות
COMMANDS = ['yes', 'no', 'up', 'down']

def decode_audio(file_path):
    """קריאת קובץ WAV והמרה לטנזור"""
    audio_binary = tf.io.read_file(file_path)
    audio, _ = tf.audio.decode_wav(audio_binary, desired_channels=1)
    audio = tf.squeeze(audio, axis=-1)
    return audio

def get_spectrogram(waveform):
    """המרת גל אודיו לספקטרוגרמה"""
    # padding ל-16000 דגימות (שנייה אחת)
    input_len = SAMPLE_RATE
    waveform = waveform[:input_len]
    zero_padding = tf.zeros(input_len - tf.shape(waveform)[0], dtype=tf.float32)
    waveform = tf.concat([waveform, zero_padding], 0)

    # STFT
    spectrogram = tf.signal.stft(waveform, frame_length=FRAME_LENGTH, frame_step=FRAME_STEP)
    spectrogram = tf.abs(spectrogram)
    spectrogram = spectrogram[..., tf.newaxis]
    return spectrogram

def create_tiny_model(input_shape, num_classes):
    """ארכיטקטורת CNN ממוזערת עבור TinyML"""
    model = tf.keras.Sequential([
        tf.keras.layers.Input(shape=input_shape),

        # בלוק קונבולוציה ראשון
        tf.keras.layers.Conv2D(8, (3, 3), activation='relu', padding='same'),
        tf.keras.layers.MaxPooling2D((2, 2)),
        tf.keras.layers.BatchNormalization(),

        # בלוק קונבולוציה שני
        tf.keras.layers.Conv2D(16, (3, 3), activation='relu', padding='same'),
        tf.keras.layers.MaxPooling2D((2, 2)),
        tf.keras.layers.BatchNormalization(),

        # סיווג
        tf.keras.layers.GlobalAveragePooling2D(),
        tf.keras.layers.Dropout(0.3),
        tf.keras.layers.Dense(num_classes, activation='softmax')
    ])
    return model

# טעינת נתונים (גרסה מפושטת - בפרודקשן תשתמשו ב-tf.data)
data_dir = pathlib.Path('data/speech_commands')

# יצירת datasets
train_ds = tf.keras.utils.audio_dataset_from_directory(
    directory=data_dir,
    batch_size=64,
    validation_split=0.2,
    seed=42,
    output_sequence_length=SAMPLE_RATE,
    subset='training',
    labels='inferred',
    label_mode='categorical',
    class_names=COMMANDS
)

val_ds = tf.keras.utils.audio_dataset_from_directory(
    directory=data_dir,
    batch_size=64,
    validation_split=0.2,
    seed=42,
    output_sequence_length=SAMPLE_RATE,
    subset='validation',
    labels='inferred',
    label_mode='categorical',
    class_names=COMMANDS
)

# עיבוד הנתונים לספקטרוגרמות
def preprocess(audio, label):
    audio = tf.squeeze(audio, axis=-1)
    specs = tf.map_fn(get_spectrogram, audio, fn_output_signature=tf.float32)
    return specs, label

train_ds = train_ds.map(preprocess).cache().prefetch(tf.data.AUTOTUNE)
val_ds = val_ds.map(preprocess).cache().prefetch(tf.data.AUTOTUNE)

# לבדוק את הצורה של הספקטרוגרמה
for spec_batch, label_batch in train_ds.take(1):
    input_shape = spec_batch.shape[1:]
    print(f"Spectrogram shape: {input_shape}")
    break

# בניית מודל
model = create_tiny_model(input_shape, num_classes=len(COMMANDS))
model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

model.summary()
# סדר גודל: ~5,000 פרמטרים, ~20KB אחרי quantization

# אימון
history = model.fit(
    train_ds,
    validation_data=val_ds,
    epochs=30,
    callbacks=[
        tf.keras.callbacks.EarlyStopping(patience=5, restore_best_weights=True),
        tf.keras.callbacks.ReduceLROnPlateau(factor=0.5, patience=3)
    ]
)

print(f"Final validation accuracy: {history.history['val_accuracy'][-1]:.2%}")

שימו לב לגודל המודל — 8 פילטרים בשכבה הראשונה ו-16 בשנייה. זה לא בטעות. על Cortex-M4 עם 256KB RAM, כל נוירון נוסף עולה לנו זיכרון. מודלים תעשייתיים של TinyML בדרך כלל מכילים בין 5,000 ל-50,000 פרמטרים — לעומת מיליוני פרמטרים בגרסאות Desktop.

שלב 3: quantization והמרה ל-TFLite

זה השלב שהופך מודל רגיל למשהו שמיקרו-בקר יכול להריץ. quantization מוריד את הדיוק של המשקולות מ-float32 (32 ביט) ל-int8 (8 ביט) — הקטנה של פי 4 בגודל, עם ירידה מינימלית בדיוק.

# המרה ל-TFLite עם Full Integer Quantization

def representative_dataset():
    """מייצר דגימות ייצוגיות לכיול ה-quantization"""
    for spec_batch, _ in val_ds.take(50):
        for i in range(min(10, spec_batch.shape[0])):
            yield [tf.expand_dims(spec_batch[i], axis=0)]

# הגדרת ה-converter
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8
converter.inference_output_type = tf.int8

# המרה
tflite_model = converter.convert()

# שמירת הקובץ
model_path = 'keyword_model_quantized.tflite'
with open(model_path, 'wb') as f:
    f.write(tflite_model)

model_size_kb = len(tflite_model) / 1024
print(f"Quantized model size: {model_size_kb:.1f} KB")

# המרה למערך C (כדי להכליל בפרויקט Embedded)
import subprocess
subprocess.run([
    'xxd', '-i', model_path, 'model_data.cc'
], check=True)

print("Generated model_data.cc — ready for embedding!")

לפי מחקר של Google ו-Harvard, quantization מ-float32 ל-int8 מקטין את המודל פי 4 עם ירידה של פחות מ-1% בדיוק ברוב הארכיטקטורות. זו עובדה קריטית — בלי quantization, TinyML לא היה אפשרי.

שלב 4: הטמעה בפרויקט Arduino

עכשיו ניקח את קובץ ה-C שיצרנו ונטמיע אותו בסקיצה של Arduino. צריך להתקין קודם את הספריות הנכונות:

# ב-Arduino IDE:
# Sketch -> Include Library -> Manage Libraries
# חפשו והתקינו:
# 1. "Arduino_TensorFlowLite" (ספריית TFLite Micro הרשמית)
# 2. "Arduino_LSM9DS1" (אם משתמשים בחיישן IMU)
# 3. "PDM" (עבור מיקרופון דיגיטלי)

# לחילופין, דרך arduino-cli:
arduino-cli lib install "Arduino_TensorFlowLite"
arduino-cli lib install "PDM"

# קומפילציה והעלאה
arduino-cli compile --fqbn arduino:mbed_nano:nano33ble keyword_spotting/
arduino-cli upload -p /dev/ttyACM0 --fqbn arduino:mbed_nano:nano33ble keyword_spotting/

ובתוך קובץ ה-.ino הראשי:

/* keyword_spotting.ino
 * זיהוי מילות מפתח על Arduino Nano 33 BLE Sense
 * באמצעות TensorFlow Lite Micro
 */

#include <TensorFlowLite.h>
#include <tensorflow/lite/micro/all_ops_resolver.h>
#include <tensorflow/lite/micro/micro_interpreter.h>
#include <tensorflow/lite/schema/schema_generated.h>
#include <PDM.h>

// המודל שהמרנו ל-C array
#include "model_data.h"

// פרמטרים
constexpr int kSampleRate = 16000;
constexpr int kAudioLength = 16000;  // שנייה אחת
constexpr int kTensorArenaSize = 60 * 1024;  // 60KB לזיכרון עבודה

// באפרים
int16_t audio_buffer[kAudioLength];
uint8_t tensor_arena[kTensorArenaSize];
volatile int samples_read = 0;

// TFLite משתנים
const tflite::Model* model = nullptr;
tflite::MicroInterpreter* interpreter = nullptr;
TfLiteTensor* input = nullptr;
TfLiteTensor* output = nullptr;

const char* LABELS[] = {"yes", "no", "up", "down"};
constexpr int kNumClasses = 4;

// callback עבור PDM (מיקרופון)
void onPDMdata() {
    int bytesAvailable = PDM.available();
    int16_t tempBuffer[512];
    int samplesAvailable = bytesAvailable / 2;

    PDM.read(tempBuffer, bytesAvailable);

    for (int i = 0; i < samplesAvailable && samples_read < kAudioLength; i++) {
        audio_buffer[samples_read++] = tempBuffer[i];
    }
}

void setup() {
    Serial.begin(115200);
    while (!Serial);
    Serial.println("TinyML Keyword Spotting - Initializing...");

    // טעינת המודל
    model = tflite::GetModel(g_model_data);
    if (model->version() != TFLITE_SCHEMA_VERSION) {
        Serial.println("ERROR: Model schema mismatch!");
        while (1);
    }

    // הגדרת ה-interpreter
    static tflite::AllOpsResolver resolver;
    static tflite::MicroInterpreter static_interpreter(
        model, resolver, tensor_arena, kTensorArenaSize
    );
    interpreter = &static_interpreter;

    // הקצאת טנזורים
    if (interpreter->AllocateTensors() != kTfLiteOk) {
        Serial.println("ERROR: AllocateTensors failed!");
        while (1);
    }

    input = interpreter->input(0);
    output = interpreter->output(0);

    Serial.print("Input shape: ");
    for (int i = 0; i < input->dims->size; i++) {
        Serial.print(input->dims->data[i]);
        Serial.print(" ");
    }
    Serial.println();

    Serial.print("Arena used: ");
    Serial.print(interpreter->arena_used_bytes());
    Serial.println(" bytes");

    // הפעלת מיקרופון
    PDM.onReceive(onPDMdata);
    if (!PDM.begin(1, kSampleRate)) {
        Serial.println("ERROR: PDM failed!");
        while (1);
    }

    Serial.println("Ready! Listening...");
}

void loop() {
    // ממתינים לשנייה שלמה של אודיו
    if (samples_read < kAudioLength) return;

    // חישוב ספקטרוגרמה (גרסה מפושטת — FFT ידני)
    // בפרודקשן תשתמשו בספריית CMSIS-DSP עבור FFT אמיתי
    for (int i = 0; i < input->bytes; i++) {
        // מיפוי ערכי אודיו ל-int8 עבור הקלט של המודל
        input->data.int8[i] = (int8_t)(audio_buffer[i] >> 8);
    }

    // הרצת inference
    unsigned long start_time = micros();
    TfLiteStatus invoke_status = interpreter->Invoke();
    unsigned long inference_time = micros() - start_time;

    if (invoke_status != kTfLiteOk) {
        Serial.println("ERROR: Invoke failed!");
        samples_read = 0;
        return;
    }

    // פענוח תוצאות
    int8_t max_score = -128;
    int max_index = 0;
    for (int i = 0; i < kNumClasses; i++) {
        int8_t score = output->data.int8[i];
        if (score > max_score) {
            max_score = score;
            max_index = i;
        }
    }

    // המרת ציון int8 לאחוזים (dequantize)
    float confidence = (max_score - output->params.zero_point) * output->params.scale;

    Serial.print("Detected: ");
    Serial.print(LABELS[max_index]);
    Serial.print(" (confidence: ");
    Serial.print(confidence * 100, 1);
    Serial.print("%) | Inference time: ");
    Serial.print(inference_time / 1000.0, 1);
    Serial.println(" ms");

    // איפוס הבאפר לקליטה הבאה
    samples_read = 0;
}

זמן ההסקה (inference) הצפוי על Arduino Nano 33 BLE Sense הוא בין 50 ל-200 מילישניות — מספיק מהיר לזיהוי מילים בזמן אמת. צריכת החשמל בזמן הרצת המודל היא סביב 5mA, מה שמאפשר הפעלה רציפה על סוללה במשך שבועות.

אופטימיזציה ברמת החומרה

אם אתם עובדים עם ARM Cortex-M4 או M7, ספריית CMSIS-NN של ARM מספקת קרנלים מותאמים שמנצלים את יחידת ה-DSP של המעבד. לפי ARM, שימוש ב-CMSIS-NN מאיץ inference פי 4.6 בממוצע לעומת מימוש רגיל. TFLite Micro משתמש ב-CMSIS-NN אוטומטית כשהוא מזהה מעבד תואם — רק צריך לוודא שהוא מוגדר נכון בזמן הקומפילציה.

עבור ESP32-S3, Espressif פיתחה את ספריית ESP-DL שכוללת אופטימיזציות ספציפיות לארכיטקטורת Xtensa שלהם. אם אתם עובדים על ESP32, שווה לבדוק את ESP-DL לפני שמסתפקים ב-TFLM הגנרי.

pruning ו-knowledge distillation

מעבר ל-quantization, יש עוד שתי טכניקות חשובות לכיווץ מודלים. Pruning (גיזום) מאפס משקולות קרובות לאפס — מוריד את מספר הפרמטרים האפקטיביים ב-50-90% עם ירידה קטנה בדיוק. Knowledge Distillation מאמנת מודל קטן (student) לחקות מודל גדול (teacher) — מקבלים ביצועים של מודל גדול בגודל של מודל קטן.

לפי מחקר של MIT מ-2023, שילוב של pruning, quantization ו-distillation יחד יכול לכווץ מודל פי 10 עד פי 100 בלי לאבד יותר מ-2% דיוק. זה מה שמאפשר להריץ מודלים מתוחכמים על 64KB RAM.

ניטור ודיבוג בשטח

אחד האתגרים הגדולים ב-TinyML הוא ניפוי שגיאות. אין לכם debugger כמו ב-Python. כמה טיפים מעשיים: תמיד תדפיסו את Arena Used Bytes — אם הזיכרון אוזל, ה-interpreter פשוט לא יעלה בלי הסבר מספק. בדקו את הקלט והפלט דרך UART לפני ואחרי ה-inference. ותשתמשו ב-profiling שמובנה ב-TFLM כדי לזהות אופרטורים איטיים.

האם צריך ידע בלמידת מכונה כדי להתחיל עם TinyML?

לא צריך להיות מומחה. אם יש לכם הבנה בסיסית של מה זה מודל, מה זה אימון, ומה זה inference — מספיק כדי להתחיל. הרבה מהעבודה ב-TinyML היא דווקא בצד ה-Embedded — אופטימיזציית זיכרון, ניהול באפרים, שילוב חיישנים. פלטפורמות כמו Edge Impulse מאפשרות להתחיל גם בלי לכתוב שורת Python אחת.

כמה זיכרון RAM צריך כדי להריץ מודל TinyML?

תלוי במודל, אבל מודלים קלאסיים של keyword spotting רצים על 30-60KB RAM. מודלים לזיהוי חריגות (anomaly detection) על נתוני חיישנים יכולים לרוץ על 10-20KB. סיווג תמונות קטנות (96x96 פיקסלים, שחור-לבן) דורש 80-150KB. הכלל: ככל שהקלט קטן יותר והמודל פשוט יותר, פחות זיכרון נדרש.

מה ההבדל בין TinyML ל-Edge AI?

Edge AI הוא מושג רחב שמתייחס להרצת AI על כל מכשיר שאינו שרת ענן — זה כולל טלפונים, מצלמות חכמות, מעבדי NVIDIA Jetson, ומעבדי Hailo. TinyML הוא תת-תחום ספציפי שמתמקד בהרצת מודלים על מיקרו-בקרים עם פחות מ-1MB RAM וצריכת חשמל של מילי-ואט. אם Edge AI הוא הגדרה רחבה — TinyML הוא הקצה הקטן והחסכוני ביותר שלו.

האם TinyML יכול לעבוד עם FreeRTOS?

בהחלט. TFLite Micro לא דורש מערכת הפעלה ספציפית — הוא עובד על bare-metal ועל כל RTOS. בפרויקטים תעשייתיים נפוץ לשלב את ה-inference כ-task נפרד ב-FreeRTOS, עם עדיפות (priority) מותאמת. רק צריך לוודא שיש מספיק stack size ל-task של ה-inference — בדרך כלל 8-16KB מספיקים.

איך אוספים נתונים לאימון מודל TinyML?

יש כמה גישות. Edge Impulse מציעה כלי איסוף נתונים ישירות מהלוח שלכם — מחברים את הלוח, מקליטים דגימות דרך הדפדפן, ומתייגים אותן. אפשר גם להשתמש בדאטאסטים ציבוריים (כמו Speech Commands של Google או Visual Wake Words) ואז לעשות fine-tuning עם נתונים ספציפיים לשימוש שלכם. הכלל: עדיף 1,000 דגימות מייצגות מהסביבה האמיתית על פני 100,000 דגימות מהאינטרנט.

האם TinyML מתאים לפרודקשן או רק לפרוטוטייפ?

TinyML רץ בפרודקשן כבר היום. Google מריצה TinyML בפעמון הדלת של Nest לזיהוי קולות, Bosch משתמשת בו בחיישני תנועה, ו-Syntiant מייצרת שבבי NDP שמריצים TinyML בשעונים חכמים. בישראל, סטארטאפים בתחום ה-AgriTech משתמשים ב-TinyML לניטור גידולים בשדות ללא תשתית ענן. זה לא צעצוע — זה כלי ייצור.

מה עדיף — TensorFlow Lite Micro או Edge Impulse?

זה לא מתחרים — הם משלימים. Edge Impulse היא פלטפורמה שמשתמשת ב-TFLM מאחורי הקלעים. אם אתם רוצים פרוטוטייפ מהיר, בדיקת היתכנות, או שאתם לא מכירים Python טוב — Edge Impulse מצוינת. אם אתם צריכים שליטה מלאה, ארכיטקטורות מותאמות, או אינטגרציה עם מערכת build קיימת — TFLM ישירות. הרבה מפתחים מתחילים ב-Edge Impulse ועוברים ל-TFLM כשהפרויקט מבשיל.

TinyML הוא לא טרנד — הוא השלב הבא הטבעי עבור מפתחי Embedded שרוצים להוסיף אינטליגנציה לכל מכשיר, בכל מקום, בלי תלות ברשת ובלי תלות בענן. הידע שלכם ב-C, בניהול זיכרון ובחומרה — זה בדיוק מה שנדרש כאן. אנחנו רואים אתכם קדימה ממקום שאתם רואים את עצמכם. אם המדריך הזה עורר לכם סקרנות — אתם מוזמנים להעמיק עם מדריכים נוספים, סדנאות מעשיות וקורסים מקצועיים באתר rt-ed.co.il. הדלת פתוחה, והמעבדה מחכה.

• קורס סייבר ואבטחת מידע
• קורס Real Time Embedded
• קורס דאטה סיינס
• קורס למידת מכונה AI
• קורס דאטה אנליסט
• קורס DEVOPS
• קורס IT
• קורס אוטומציה
• קורס Full Stack
• קורס בניית אתרים