> ## Content Index
> Fetch the complete content index at: https://arabroot.io/llms.txt
> Use this file to discover other available public pages before exploring further.

# الذكاء الاصطناعي على الحافة TinyML: كشف الأعطال داخل المتحكم
- URL: https://arabroot.io/articles/الذكاء-الاصطناعي-على-الحافة-tinyml-كشف-الاعطال-داخل-المتحكم-الدقيق/
- Published: 2026-11-20T08:44:43.000Z
- Updated: 2026-11-20T09:41:44.000Z
- Description: ندرب نموذجاً صغيراً على اهتزاز محامل حقيقية، ونكممه إلى int8، ونشغله بـ TFLite Micro على Cortex-M4 في Renode مع CMSIS-NN، ثم نرى لماذا يفشل أمام عطل لم يره وكيف يساعد كشف الشذوذ.
- Author: فريق عرب رووت
- Tags: الأدلة التقنية, الإلكترونيات والطائرات المسيرة والطباعة ثلاثية الأبعاد

المضخة Pump في محطة المياه لا تتعطل فجأة كما يظن من يراها لأول مرة. فقبل أن يتوقف المحرك Motor بأسابيع يبدأ شرخ صغير في أحد المحامل Bearings، ومع كل دورة تمر الكرات فوق هذا الشرخ فتصدر نبضة اهتزاز Vibration صغيرة لا تسمعها الأذن، ثم يكبر الشرخ وتكبر النبضات حتى يسخن المحمل ويتوقف المحرك في أسوأ وقت ممكن. وإذا كنت قد قرأت [مشروع مراقبة خزانات المياه والمضخات](https://arabroot.io/articles/%D9%85%D8%B4%D8%B1%D9%88%D8%B9-%D9%85%D8%B1%D8%A7%D9%82%D8%A8%D8%A9-%D8%AE%D8%B2%D8%A7%D9%86%D8%A7%D8%AA-%D8%A7%D9%84%D9%85%D9%8A%D8%A7%D9%87-%D9%88%D8%A7%D9%84%D9%85%D8%B6%D8%AE%D8%A7%D8%AA/) فأنت تعرف كيف نراقب المستوى وتشغيل المضخة، ولكن السؤال هنا مختلف: كيف نعرف أن المضخة نفسها بدأت تمرض قبل أن تتوقف؟ والإجابة المعروفة في الصيانة التنبؤية Predictive Maintenance هي أن تضع حساس Sensor اهتزاز على جسم المحرك وتحلل الإشارة Signal، والمشكلة أن هذه الإشارة سريعة جداً، فحساس واحد يقرأ آلاف العينات في الثانية، وإرسالها كلها عبر شبكة خلوية Cellular أو LoRa إلى السيرفر Server غير ممكن عملياً، لا في الكلفة ولا في البطارية.

والحل الذي يناقشه هذا المقال هو أن ينتقل القرار إلى داخل الجهاز نفسه: نموذج تعلم آلي Machine Learning Model صغير يعمل على المتحكم الدقيق Microcontroller بجانب الحساس، ينظر إلى كل نافذة من الاهتزاز ويقول «سليم» أو «عطل في الحلقة الداخلية» أو غيرها، ثم يرسل هذه الكلمة فقط. وهذا المجال اسمه التعلم الآلي الصغير TinyML، وهو جزء مما يسمى الذكاء الاصطناعي على الحافة Edge AI، أي تشغيل النموذج في الطرف البعيد من الشبكة حيث تولد البيانات، لا في مركز البيانات Data Center.

وسوف نناقش في هذا المقال ما يلي:

- متى يكون تشغيل النموذج داخل الجهاز هو الخيار الصحيح، ومتى لا يكون، وكم يتسع المتحكم من نموذج.
- لماذا يكشف الاهتزاز أعطال المحامل، وما المسار من الحساس إلى القرار: النوافذ والخصائص والنموذج.
- التكميم int8 Quantization بالمقياس ونقطة الصفر، ولماذا تحتاج بيانات معايرة Representative Dataset.
- كيف يعمل TFLite Micro من الداخل: الساحة Tensor Arena، ومحلل العمليات Op Resolver، ونوى CMSIS-NN.
- المختبر Lab: نموذج حقيقي على بيانات محامل حقيقية من جامعة Case Western Reserve، ثم نفس النموذج على معالج Cortex-M4 في المحاكي Renode، مع القياسات.
- ماذا يحدث إذا صغرت الساحة أو نسيت عملية أو أخطأت في المعايرة، ولماذا يفشل المصنف أمام عطل لم يره، وكيف يساعد كشف الشذوذ Anomaly Detection.
- الأدوات، وجدول القرار، والأخطاء الشائعة.

## لماذا تشغل النموذج داخل الجهاز؟ الحافة Edge مقابل السحابة Cloud

لنبدأ بالحساب البسيط، لأنه يحسم أغلب النقاش. حساس الاهتزاز في المختبر الذي سنستخدمه يقرأ 12,000 عينة في الثانية، وكل عينة من محول ADC بدقة Resolution من 12 أو 16 بت تأخذ بايتين، أي 24,000 بايت في الثانية، وهذا يعني قرابة 2.07 GB في اليوم من حساس واحد على مضخة واحدة. وإذا كان لديك عشرون مضخة فأنت أمام 40 GB في اليوم تمر عبر شبكة خلوية بسعر البيانات، أو عبر شبكة LoRa التي لا تحمل أصلاً أكثر من بضع مئات من البايتات في الرسالة. أما إذا قرر الجهاز بنفسه وأرسل رسالة واحدة كل دقيقة فيها الحالة ودرجة الثقة، فالرسالة 20 بايتاً تقريباً، أي 28.8 KB في اليوم، وهذا فرق يزيد عن سبعين ألف مرة.

![مقارنة بين إرسال الإشارة الخام من حساس الاهتزاز بمعدل 24 كيلوبايت في الثانية أي 2.07 جيجابايت في اليوم، وإرسال القرار فقط برسالة 20 بايت كل دقيقة، وتحتها خمس بطاقات للأسباب: زمن الاستجابة وعرض النطاق والخصوصية والطاقة والعمل بدون اتصال](https://arabroot.io/content/images/2026/11/edge-ai-tinyml-01-why-edge.webp)

إرسال القرار بدل الإشارة: نفس المعلومة المفيدة بجزء صغير جداً من البيانات

والبيانات ليست السبب الوحيد، فهناك خمسة أسباب تتكرر في كل مشروع من هذا النوع:

- **زمن الاستجابة Latency**: القرار يخرج بعد ملي ثوان من القراءة، بدون انتظار الشبكة والسيرفر، وهذا مهم إذا كان القرار سيوقف آلة أو يغير سرعتها.
- **عرض النطاق Bandwidth**: كما رأينا، الإشارة الخام لا تمر في أغلب شبكات إنترنت الأشياء IoT، وقد شرحنا حدود هذه الشبكات في [مقال إنترنت الأشياء IoT](https://arabroot.io/articles/%D8%A7%D9%86%D8%AA%D8%B1%D9%86%D8%AA-%D8%A7%D9%84%D8%A7%D8%B4%D9%8A%D8%A7%D8%A1-iot-%D9%85%D9%86-%D8%A7%D9%84%D8%AD%D8%B3%D8%A7%D8%B3-%D8%A7%D9%84%D9%89-%D9%84%D9%88%D8%AD%D8%A9-%D8%A7%D9%84%D9%85%D8%AA%D8%A7%D8%A8%D8%B9%D8%A9/).
- **الخصوصية Privacy**: في الحساسات التي تسمع الصوت أو ترى الصورة يبقى الصوت والصورة داخل الجهاز، ويخرج القرار فقط، وتوثيق [LiteRT للمتحكمات](https://ai.google.dev/edge/litert/microcontrollers/overview?ref=arabroot.io) من Google يذكر هذا صراحة: لا تخرج البيانات من الجهاز.
- **الطاقة Power**: الراديو في أغلب الأجهزة يستهلك أكثر من المعالج بكثير، فكل بايت لا ترسله يطيل عمر البطارية، وقد رأينا ذلك بالأرقام في [مقال الأجهزة قليلة الاستهلاك Low Power](https://arabroot.io/articles/%D8%AA%D8%B5%D9%85%D9%8A%D9%85-%D8%A7%D9%84%D8%A7%D8%AC%D9%87%D8%B2%D8%A9-%D9%82%D9%84%D9%8A%D9%84%D8%A9-%D8%A7%D9%84%D8%A7%D8%B3%D8%AA%D9%87%D9%84%D8%A7%D9%83-low-power-%D8%B9%D9%85%D8%B1-%D8%A7%D9%84%D8%A8%D8%B7%D8%A7%D8%B1%D9%8A%D8%A9/).
- **العمل بدون اتصال Offline**: المضخة في غرفة تحت الأرض أو في موقع بعيد قد تفقد الشبكة ساعات، والجهاز الذي يقرر بنفسه يستمر في المراقبة ويخزن التنبيه حتى تعود الشبكة.

### متى لا يناسبك TinyML؟

وقد يتساءل البعض: إذا كان التشغيل على الجهاز بهذه الفوائد فلماذا لا نشغل كل شيء عليه؟ والإجابة أن المتحكم الدقيق صغير بشكل لا يتخيله من يعمل على السيرفرات، فورقة [TensorFlow Lite Micro](https://arxiv.org/abs/2010.08678?ref=arabroot.io) المنشورة في مؤتمر MLSys سنة 2021 تذكر أن المعالجات المدمجة أضعف من أقرب معالجات الجوال بمئة إلى ألف مرة في الحساب والذاكرة والطاقة. لذلك لا ينصح بـ TinyML في الحالات التالية:

- إذا كان النموذج كبيراً بطبيعته، مثل نماذج اللغة LLM التي تحتاج جيجابايتات من الذاكرة كما شرحنا في [مقال تشغيل نماذج اللغة على جهازك](https://arabroot.io/articles/%D8%AA%D8%B4%D8%BA%D9%8A%D9%84-%D9%86%D9%85%D8%A7%D8%B0%D8%AC-%D8%A7%D9%84%D9%84%D8%BA%D8%A9-%D8%B9%D9%84%D9%89-%D8%AC%D9%87%D8%A7%D8%B2%D9%83-%D9%84%D9%84%D9%85%D8%A8%D8%AA%D8%AF%D8%A6%D9%8A%D9%86/)، فهذه مكانها الحاسب أو السيرفر وليس المتحكم.
- إذا كان الجهاز متصلاً بالكهرباء والشبكة دائماً، والبيانات قليلة أصلاً، مثل حساس حرارة يرسل قراءة كل دقيقة، فالقرار على السيرفر أسهل في التحديث والمراقبة.
- إذا كان النموذج يتغير كل أسبوع، فكل تغيير على الجهاز يعني تحديثاً عن بعد OTA بكل مخاطره.
- إذا كنت تحتاج أن ترى الإشارة الخام لتفهم المشكلة أولاً، ففي بداية أي مشروع اجمع البيانات الخام إلى السيرفر، وبعد أن تفهمها انقل القرار إلى الجهاز.

## ماذا يدخل في المتحكم MCU؟ ميزانية الفلاش Flash والذاكرة RAM

في الحاسب لا تفكر كثيراً في حجم النموذج، أما في المتحكم فالسؤال الأول دائماً: هل يدخل؟ والإجابة تأتي من رقمين في ورقة البيانات Datasheet: الفلاش Flash، وهي الذاكرة الدائمة التي يحفظ فيها البرنامج والنموذج نفسه، والذاكرة RAM التي يحسب فيها النموذج نتائجه الوسيطة. وقد شرحنا كيف تقرأ هذه الأرقام في مقال قراءة الداتاشيت Datasheet. والجدول التالي يضع بعض الشرائح التي مرت معنا في المسار بجانب أرقام نموذجنا:

| الشريحة                    | المعالج                                                   | الفلاش Flash      | الذاكرة RAM             | المصدر                                                                                                                                                                                     |
| -------------------------- | --------------------------------------------------------- | ----------------- | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| ATmega328P (Arduino Uno)   | AVR بثمانية بتات                                          | 32 KB             | 2 KB                    | [ورقة بيانات Microchip](https://ww1.microchip.com/downloads/aemDocuments/documents/MCU08/ProductDocuments/DataSheets/ATmega48A-PA-88A-PA-168A-PA-328-P-DS-DS40002061B.pdf?ref=arabroot.io) |
| RP2040 (Raspberry Pi Pico) | نواتا Cortex-M0+                                          | 2 MB خارجية       | 264 KB                  | [ورقة بيانات Pico](https://datasheets.raspberrypi.com/pico/pico-datasheet.pdf?ref=arabroot.io)                                                                                             |
| STM32F407                  | Cortex-M4 مع FPU بسرعة 168 MHz                            | 1 MB              | 192 KB (منها 64 KB CCM) | [ورقة بيانات ST DS8626](https://www.st.com/resource/en/datasheet/stm32f407vg.pdf?ref=arabroot.io)                                                                                          |
| ESP32                      | نواتا Xtensa LX6                                          | خارجية حتى 16 MB  | 520 KB                  | [ورقة بيانات Espressif](https://www.espressif.com/sites/default/files/documentation/esp32%5Fdatasheet%5Fen.pdf?ref=arabroot.io)                                                            |
| نموذجنا بعد التكميم int8   | 12,848 بايت للنموذج، و114,684 بايت للبرنامج كله مع المفسر | 6,692 بايت للساحة | المختبر أدناه           |                                                                                                                                                                                            |

لاحظ أن Arduino Uno بذاكرة 2 KB خارج المنافسة تماماً لهذا النوع من النماذج، وأن أغلب مشاريع TinyML تبدأ من معالجات Cortex-M4 فما فوق، لأن فيها تعليمات معالجة الإشارة DSP التي سنرى أثرها بالأرقام. وتوثيق [LiteRT للمتحكمات](https://ai.google.dev/edge/litert/microcontrollers/overview?ref=arabroot.io) يقول إن المفسر الأساسي يدخل في 16 KB على Cortex-M3، وإنه يحتاج معالجاً بـ 32 بت، ولا يحتاج نظام تشغيل Operating System ولا مكتبات C القياسية Standard Library ولا حجز ذاكرة ديناميكي Dynamic Memory Allocation. وهذا آخر شرط مهم جداً، لأن الحجز الديناميكي في الأجهزة المدمجة يسبب التجزئة Fragmentation والأعطال بعد أيام من التشغيل كما ذكرنا في [مقال لغة C للأنظمة المدمجة](https://arabroot.io/articles/%D9%84%D8%BA%D8%A9-c-%D9%84%D9%84%D8%A7%D9%86%D8%B8%D9%85%D8%A9-%D8%A7%D9%84%D9%85%D8%AF%D9%85%D8%AC%D8%A9-embedded-c-%D8%A7%D9%84%D8%B0%D8%A7%D9%83%D8%B1%D8%A9-%D9%88%D8%A7%D9%84%D9%85%D8%B3%D8%AC%D9%84%D8%A7%D8%AA/).

## لماذا يكشف الاهتزاز Vibration عطل المحمل Bearing؟

المحمل الكروي Ball Bearing قطعة تسمح لعمود المحرك أن يدور بأقل احتكاك، وفيه حلقة داخلية Inner Race مثبتة على العمود وتدور معه، وحلقة خارجية Outer Race مثبتة في جسم المحرك، وبينهما كرات Balls تتدحرج. والصورة التالية لمحمل من نفس عائلة المحامل التي سنستخدم بياناتها، لكي ترى الأجزاء الثلاثة:

![محمل كروي معدني من نوع 6203 بحلقته الداخلية والخارجية والكرات بينهما](https://arabroot.io/content/images/2026/11/edge-ai-tinyml-08-bearing.webp)

محمل كروي من نوع 6203، والمحرك في بيانات المختبر يستخدم من نفس العائلة 6205 عند طرف التشغيل Drive End و6203 عند طرف المروحة Fan End. الصورة: R. Henrik Nilsson، الرخصة [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/?ref=arabroot.io)، المصدر: [Wikimedia Commons](https://commons.wikimedia.org/wiki/File:Second%5Fhalf%5Fof%5F20th%5Fcentury%5Fball%5Fbearing%5F6203%5FC3%5FM7%5Fby%5FRKW.jpg?ref=arabroot.io) (تم تصغيرها وتحويلها إلى WebP).

وعندما يحدث شرخ أو نقرة صغيرة في أحد هذه الأجزاء، تصدر نبضة كلما مر عليها جزء آخر، والمهم أن هذه النبضات تتكرر بتردد Frequency يمكن حسابه من هندسة المحمل وسرعة الدوران. وتنشر جامعة Case Western Reserve في [صفحة مواصفات المحامل](https://engineering.case.edu/bearingdatacenter/bearing-information?ref=arabroot.io) هذه الترددات للمحمل 6205-2RS JEM SKF كمضاعفات لسرعة الدوران: 5.4152 للحلقة الداخلية، و3.5848 للحلقة الخارجية، و4.7135 للكرة. فإذا كان المحرك يدور بسرعة 1730 دورة في الدقيقة، أي 28.83 دورة في الثانية، فعطل الحلقة الداخلية يصدر نبضات بقرابة 156 Hz، والخارجية بقرابة 103 Hz، والكرة بقرابة 136 Hz. وهذا ما يجعل الاهتزاز طريقة قديمة ومعروفة في الصيانة: كل عطل له «بصمة» في الإشارة.

والاهتزاز يقاس بمقياس التسارع Accelerometer، وهو حساس يعطي تسارع الجسم الذي ثبت عليه بوحدة g، أي مضاعفات تسارع الجاذبية. وفي المصانع تستخدم حساسات صناعية تثبت بقاعدة مغناطيسية أو ببرغي، أما في التجارب فتجد وحدات صغيرة مثل ADXL345 التي تتصل بالمتحكم عبر I2C أو SPI كما شرحنا في [مقال بروتوكولات الاتصال التسلسلي](https://arabroot.io/articles/%D8%A8%D8%B1%D9%88%D8%AA%D9%88%D9%83%D9%88%D9%84%D8%A7%D8%AA-%D8%A7%D9%84%D8%A7%D8%AA%D8%B5%D8%A7%D9%84-%D8%A7%D9%84%D8%AA%D8%B3%D9%84%D8%B3%D9%84%D9%8A-%D9%85%D9%82%D8%A7%D8%B1%D9%86%D8%A9-i2c-%D8%AB%D9%85-spi-%D9%85%D8%B9-uart/):

![لوحة صغيرة حمراء عليها حساس التسارع ADXL345 وصف من الأرجل للتوصيل](https://arabroot.io/content/images/2026/11/edge-ai-tinyml-09-adxl345.webp)

وحدة مقياس التسارع ADXL345 من SparkFun، مثال على حساس اهتزاز رخيص للتجارب. الصورة: SparkFun Electronics، الرخصة [CC BY 2.0](https://creativecommons.org/licenses/by/2.0/?ref=arabroot.io)، المصدر: [Wikimedia Commons](https://commons.wikimedia.org/wiki/File:SparkFun%5FTriple-Axis-Accelerometer-Breakout%5FADXL345%5F09836-%5F01c.jpg?ref=arabroot.io) (تم تصغيرها وتحويلها إلى WebP).

وانتبه هنا لشرط مهم: لكي ترى نبضات بمئات الهرتز وتوافقياتها Harmonics حتى بضعة كيلوهرتز، يجب أن تقرأ الحساس بسرعة لا تقل عن ضعف أعلى تردد تريده، وهذه قاعدة نايكوست Nyquist المعروفة. ولذلك تقرأ بيانات المختبر بسرعة 12,000 عينة في الثانية، وهذا يحدد نوع الحساس الذي تختاره، فبعض وحدات التسارع الرخيصة لا تتجاوز بضع مئات أو آلاف من العينات في الثانية، فاقرأ ورقة بياناتها قبل أن تبني عليها.

## المسار من الحساس Sensor إلى القرار Decision: خط المعالجة Pipeline

كل نظام TinyML تقريباً يمر بنفس الخطوات، والصورة التالية تبينها لنظامنا بالأرقام التي سنراها في المختبر:

![خمس خطوات من اليمين إلى اليسار: الحساس بسرعة 12 كيلوهرتز، ثم نافذة من 1024 عينة أي 85.3 ملي ثانية، ثم التكميم إلى int8، ثم النموذج بـ 3516 معاملاً، ثم القرار بين أربع فئات، وتحتها التدريب على السيرفر والتشغيل على الجهاز](https://arabroot.io/content/images/2026/11/edge-ai-tinyml-02-pipeline.webp)

المسار كاملاً: التدريب على السيرفر مرة، والتشغيل على الجهاز في كل نافذة

الخطوة الأولى هي النافذة Window، فالنموذج لا ينظر إلى عينة واحدة وإنما إلى مقطع من الإشارة، ونحن نأخذ 1024 عينة متتالية، أي 85.3 ms من الاهتزاز، وفيها عدة دورات للعمود وعشرات النبضات من العطل. وطول النافذة قرار هندسي: نافذة قصيرة تعني ذاكرة أقل وقراراً أسرع، ولكن قد لا تحتوي نبضات كافية، ونافذة طويلة تعني العكس. وفي التدريب نأخذ النوافذ متداخلة Overlapping بخطوة 512 عينة لكي نحصل على أمثلة أكثر من نفس التسجيل، أما في الاختبار فنأخذها بدون تداخل لكي لا نعد نفس المقطع مرتين.

والخطوة الثانية هي السؤال الكبير: هل نعطي النموذج الإشارة الخام Raw Signal، أم نحسب منها خصائص Features أولاً؟ والطريقة التقليدية في الصيانة هي الخصائص، وأشهرها ثلاث:

- **الجذر التربيعي للمتوسط RMS**: مقياس لطاقة الاهتزاز، فالمحمل التالف يهتز أكثر.
- **التفرطح Kurtosis**: يقيس حدة القمم في الإشارة، وقيمته قرابة 3 للإشارة العشوائية الطبيعية، وترتفع عندما تظهر نبضات حادة متكررة من شرخ.
- **معامل القمة Crest Factor**: نسبة أعلى قمة إلى RMS، وترتفع أيضاً مع النبضات.
- **الطيف Spectrum**: تحويل فورييه FFT يحول النافذة إلى طاقة في كل تردد، فترى بصمة العطل عند 156 أو 103 Hz وتوافقياتها.

والمختبر يحسب الخصائص الثلاث الأولى لكل فئة لكي ترى الفرق بنفسك، ثم يعطي النموذج الإشارة الخام. والسبب أن شبكة الالتفاف Convolutional Network تتعلم «مرشحاتها» بنفسها من البيانات، فلا نحتاج أن نكتب كود FFT على المتحكم، وفي نفس الوقت يكون حساب الشبكة أثقل من حساب بضع خصائص. وفي الواقع ستجد الطريقتين: أنظمة تحسب الطيف على المتحكم بمكتبة CMSIS-DSP ثم تعطيه لنموذج صغير جداً، وأنظمة تعطي الإشارة الخام لشبكة التفاف، والقرار بحسب ميزانية الحساب والذاكرة التي رأيناها.

## النموذج الصغير Tiny Model: شبكة التفاف أحادية البعد 1D CNN

شرحنا فكرة الشبكات العصبية Neural Networks والتدريب Training والتقييم Evaluation في [مقال التعلم الآلي Machine Learning للمبتدئين](https://arabroot.io/articles/%D8%A7%D9%84%D8%AA%D8%B9%D9%84%D9%85-%D8%A7%D9%84%D8%A7%D9%84%D9%8A-machine-learning-%D9%84%D9%84%D9%85%D8%A8%D8%AA%D8%AF%D8%A6%D9%8A%D9%86/)، ولن نعيد ذلك هنا، وإنما نركز على ما يجعل النموذج مناسباً للمتحكم. نموذجنا شبكة التفاف أحادية البعد 1D CNN، أي أن المرشح Filter في كل طبقة Layer نافذة صغيرة تنزلق على الإشارة وتحسب في كل موضع مجموع حاصل ضرب أوزانها في العينات، فتبحث عن نفس النمط في أي مكان من النافذة. وهذا مناسب جداً للاهتزاز، لأن نبضة العطل قد تأتي في أي لحظة من النافذة، والمرشح الواحد يكتشفها أينما كانت بنفس الأوزان، وبالتالي نحتاج عدداً صغيراً من المعاملات Parameters مقارنة بطبقة كاملة الاتصال Dense تربط كل عينة بكل خلية.

![طبقات النموذج من اليمين إلى اليسار: المدخل 1024 في 1، ثم التفاف بثمانية مرشحات إلى 256 في 8، ثم تجميع إلى 64 في 8، ثم التفاف إلى 64 في 16، ثم تجميع إلى 16 في 16، ثم التفاف إلى 16 في 32، ثم متوسط إلى 32، ثم طبقة كاملة إلى 4 فئات](https://arabroot.io/content/images/2026/11/edge-ai-tinyml-03-model.webp)

النموذج طبقة طبقة، وعدد المعاملات في كل طبقة كما طبعه TensorFlow في المختبر

وفي الصورة أعلاه لاحظ التالي:

- الطبقة الأولى تأخذ خطوة Stride قدرها 4، فتقلص 1024 عينة إلى 256 موضعاً، وهذا يقلل الحساب في كل ما بعدها.
- طبقات التجميع MaxPooling تأخذ أكبر قيمة من كل أربع، فتقلص الطول مرة أخرى بدون أي معاملات.
- طبقة المتوسط Global Average Pooling تحول كل قناة إلى رقم واحد، فلا يهم أين ظهر النمط في النافذة.
- المجموع 3,516 معاملاً، أي قرابة 14 KB بدقة float32، وهذا رقم صغير جداً مقارنة بنماذج اللغة التي شرحناها في [مقال نماذج اللغة الكبيرة LLM](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D8%AA%D8%B9%D9%85%D9%84-%D9%86%D9%85%D8%A7%D8%B0%D8%AC-%D8%A7%D9%84%D9%84%D8%BA%D8%A9-%D8%A7%D9%84%D9%83%D8%A8%D9%8A%D8%B1%D8%A9-llm-%D8%AE%D8%B7%D9%88%D8%A9-%D8%A8%D8%AE%D8%B7%D9%88%D8%A9/) والتي تعد معاملاتها بالمليارات.

## التكميم int8 Quantization: المقياس Scale ونقطة الصفر Zero Point

النموذج يتدرب بأرقام عشرية float32، وقد شرحنا تمثيلها في مقال الأرقام العشرية Floating Point. وعلى المتحكم هناك ثلاث مشاكل مع هذه الأرقام: كل رقم يأخذ أربعة بايتات، وبعض المتحكمات لا تحتوي وحدة FPU أصلاً، والأهم أن نوى الحساب المحسنة مثل CMSIS-NN مكتوبة للأعداد الصحيحة int8، لأن معالج Cortex-M4 يستطيع أن يضرب ويجمع زوجين من الأعداد الصغيرة في تعليمة واحدة. لذلك نحول النموذج إلى int8، وهذا هو التكميم Quantization، وفكرته في [نماذج اللغة](https://arabroot.io/articles/%D8%AA%D8%B4%D8%BA%D9%8A%D9%84-%D9%86%D9%85%D8%A7%D8%B0%D8%AC-%D8%A7%D9%84%D9%84%D8%BA%D8%A9-%D8%B9%D9%84%D9%89-%D8%AC%D9%87%D8%A7%D8%B2%D9%83-%D9%84%D9%84%D9%85%D8%A8%D8%AA%D8%AF%D8%A6%D9%8A%D9%86/) هي نفسها هنا، ولكن بتفاصيل مختلفة.

والمعادلة كما في [مواصفة التكميم في LiteRT](https://ai.google.dev/edge/litert/models/quantization%5Fspec?ref=arabroot.io) هي: القيمة الحقيقية تساوي المقياس Scale مضروباً في الفرق بين القيمة الصحيحة ونقطة الصفر Zero Point. وكل Tensor في النموذج له مقياس ونقطة صفر خاصة به، والأوزان Weights تكمم بشكل متماثل Symmetric بنقطة صفر تساوي 0، ولكل قناة Channel مقياسها في طبقات الالتفاف، أما النتائج الوسيطة Activations فلها مقياس واحد لكل Tensor ونقطة صفر قد تكون أي رقم بين −128 و127.

![المعادلة x تساوي scale ضرب q ناقص zero_point، ومدخل نموذجنا بمقياس 0.027063 ونقطة صفر سالب 2 يغطي قرابة زائد ناقص 3.46 g، وتحتها خط يقارن هذا المدى بمدى زائد ناقص 0.30 g عندما كانت المعايرة بالمحرك السليم فقط](https://arabroot.io/content/images/2026/11/edge-ai-tinyml-04-quantization.webp)

المقياس يحدد المدى الذي يراه النموذج، والمعايرة الخاطئة تقص الإشارة التي تهمك

والسؤال هنا: كيف يعرف المحول Converter مقياس النتائج الوسيطة وهو لم يشغل النموذج؟ والإجابة أنه يشغله فعلاً على عينة من بياناتك تسمى بيانات المعايرة Representative Dataset، ويسجل أكبر وأصغر قيمة في كل Tensor، ثم يختار المقياس الذي يغطي هذا المدى. وهذا يعني أن جودة التكميم تعتمد على هذه العينة، فإذا كانت لا تمثل كل ما سيراه الجهاز فسوف يقص التكميم القيم الكبيرة، وهذا بالضبط ما سنجربه في قسم «ماذا يحدث إذا…؟». وهذه الطريقة اسمها التكميم بعد التدريب Post-Training Quantization، وهناك طريقة أخرى اسمها التدريب مع مراعاة التكميم Quantization-Aware Training تحاكي التكميم أثناء التدريب، وتستخدم عندما تخسر النماذج دقة كبيرة بالطريقة الأولى، وكلاهما موثق في [صفحة تحسين النماذج في LiteRT](https://ai.google.dev/edge/litert/models/model%5Foptimization?ref=arabroot.io).

## من ملف .tflite إلى المتحكم MCU: كيف يعمل TFLite Micro؟

بعد التكميم يكتب المحول النموذج في ملف بامتداد `.tflite`، وهو بصيغة FlatBuffer، أي صيغة ثنائية مصممة لكي تقرأ في مكانها بدون فك أو نسخ إلى الذاكرة، وهذا مهم في المتحكم لأننا نترك النموذج في الفلاش ونقرأ منه مباشرة. وفي المتحكم لا يوجد نظام ملفات غالباً، فنحول الملف إلى مصفوفة بايتات في كود C، تماماً كما يفعل الأمر `xxd -i`، ونربطها مع البرنامج. ثم يأتي دور المفسر TensorFlow Lite Micro، ويختصر TFLM، وهو مشروع مفتوح المصدر على [GitHub](https://github.com/tensorflow/tflite-micro?ref=arabroot.io) يقرأ النموذج وينفذ عملياته بالترتيب. وورقة [TFLM](https://arxiv.org/abs/2010.08678?ref=arabroot.io) تشرح لماذا اختار الفريق طريقة المفسر Interpreter بدل توليد كود خاص لكل نموذج: نفس البرنامج يشغل أي نموذج، وتستطيع تغيير النموذج بدون إعادة كتابة الكود، ويبقى المفسر نفسه صغيراً.

![عمودان: الفلاش وفيه النموذج g_model بحجم 12848 بايت والمفسر والنوى ونوافذ الاختبار بمجموع 114684 بايت، والذاكرة وفيها ساحة Tensor Arena المستخدم منها 6692 بايت مقسمة إلى رأس للنتائج الوسيطة وذيل للبيانات الدائمة ثم المكدس، وتحتها محلل العمليات بسبع عمليات](https://arabroot.io/content/images/2026/11/edge-ai-tinyml-05-tflm.webp)

ما في الفلاش وما في الذاكرة، بالأحجام التي قسناها في المختبر

ولكي يعمل المفسر يحتاج ثلاثة أشياء منك:

- **ساحة الذاكرة Tensor Arena**: مصفوفة واحدة تحجزها أنت في RAM بحجم ثابت، ويأخذ منها المفسر كل ما يحتاجه. ويقسمها كما في [توثيق إدارة الذاكرة في TFLM](https://github.com/tensorflow/tflite-micro/blob/main/docs/memory%5Fmanagement.md?ref=arabroot.io) إلى رأس Head للنتائج الوسيطة التي يعاد استخدامها بين الطبقات بخطة ذاكرة Memory Plan يحسبها مرة واحدة، وذيل Tail للبيانات الدائمة مثل هياكل العمليات ومعاملات التكميم. فإذا كانت الساحة صغيرة يفشل التحضير بخطأ واضح، وإذا كانت كبيرة جداً فأنت تضيع ذاكرة قد يحتاجها باقي البرنامج، ولذلك تقيس الحجم الحقيقي بالدالة `arena_used_bytes()` ثم تضيف هامشاً صغيراً.
- **محلل العمليات Op Resolver**: قائمة بالعمليات Operators التي يحتاجها النموذج، مثل CONV\_2D وMEAN. والصنف `MicroMutableOpResolver` يجعلك تضيف ما تحتاجه فقط، فلا يدخل الفلاش كود عملية لا يستخدمها نموذجك، وهذه من أكبر طرق توفير الفلاش.
- **النوى Kernels**: الدوال التي تحسب كل عملية فعلاً. وفي TFLM نسخة مرجعية Reference مكتوبة بلغة C++ عادية تعمل على أي معالج، ونسخ محسنة لكل معمارية، وأهمها لمعالجات Arm مكتبة [CMSIS-NN](https://github.com/ARM-software/CMSIS-NN?ref=arabroot.io) التي تستخدم تعليمات DSP في Cortex-M4 وM7، وتعليمات المتجهات Helium في Cortex-M55 وM85\. وورقة [CMSIS-NN](https://arxiv.org/abs/1801.06601?ref=arabroot.io) من Arm تذكر أن هذه النوى حسنت زمن التشغيل 4.6 مرة وكفاءة الطاقة 4.9 مرة مقارنة بالتنفيذ العادي، وسوف نرى في المختبر رقماً قريباً جداً من هذا.

وقد يتساءل البعض: لماذا يكتب النموذج الطبقة Conv1D كعملية CONV\_2D؟ والإجابة أن المحول يضيف بعداً وهمياً للإشارة بعملية EXPAND\_DIMS ثم يستخدم الالتفاف الثنائي الذي له نوى محسنة في كل مكان، ولذلك سترى في قائمة العمليات سبع عمليات وليس خمساً.

## المختبر Lab: كشف أعطال المحامل Bearing Faults من بيانات CWRU

الآن نطبق كل ما سبق على بيانات حقيقية. ومركز بيانات المحامل في جامعة Case Western Reserve، واختصاراً CWRU، ينشر على [موقعه](https://engineering.case.edu/bearingdatacenter?ref=arabroot.io) تسجيلات اهتزاز من محرك Reliance Electric بقدرة 2 حصان، زرع فيه الباحثون أعطالاً بقطر محدد بالتفريغ الكهربائي EDM في الحلقة الداخلية والكرة والحلقة الخارجية، ثم سجلوا الاهتزاز بمقياس تسارع على جسم المحرك بسرعة 12,000 عينة في الثانية، عند أربع حمولات Loads من 0 إلى 3 حصان، وسرعات من 1797 إلى 1730 دورة في الدقيقة، كما في [صفحة الجهاز والإجراءات](https://engineering.case.edu/bearingdatacenter/apparatus-and-procedures?ref=arabroot.io). وهذه البيانات هي الأشهر في أبحاث تشخيص المحامل، ولذلك نبدأ بها، وسنرى لاحقاً حدودها.

ونستخدم من [صفحة الملفات](https://engineering.case.edu/bearingdatacenter/download-data-file?ref=arabroot.io) ستة عشر تسجيلاً: المحرك السليم Normal، وعطل بقطر 0.007 بوصة في كل من الحلقة الداخلية والكرة والحلقة الخارجية، عند الحمولات الأربع، وكلها من الحساس عند طرف التشغيل Drive End. وفيما يلي أرقام الملفات، وتنزيلها كلها قرابة 67 MB:

| الحمولة Load        | السرعة rpm | سليم Normal | الحلقة الداخلية Inner | الكرة Ball | الحلقة الخارجية Outer |
| ------------------- | ---------- | ----------- | --------------------- | ---------- | --------------------- |
| 0 hp                | 1797       | 97          | 105                   | 118        | 130                   |
| 1 hp                | 1772       | 98          | 106                   | 119        | 131                   |
| 2 hp                | 1750       | 99          | 107                   | 120        | 132                   |
| 3 hp (للاختبار فقط) | 1730       | 100         | 108                   | 121        | 133                   |

والمختبر في نصفين، ولكل نصف Docker Image خاص به: النصف الأول في Python للتدريب والتكميم والمقارنة بين المفسرات، والثاني للمتحكم: بناء TFLM بالمترجم Compiler arm-none-eabi-gcc وتشغيله في المحاكي Renode الذي استخدمناه في [مقال تصحيح البرامج المدمجة](https://arabroot.io/articles/%D8%AA%D8%B5%D8%AD%D9%8A%D8%AD-%D8%A7%D9%84%D8%A8%D8%B1%D8%A7%D9%85%D8%AC-%D8%A7%D9%84%D9%85%D8%AF%D9%85%D8%AC%D8%A9-debugging-%D9%85%D8%B9-gdb-%D8%AB%D9%85-renode/). وهذا ملف النصف الأول، مع إصدارات مثبتة لكي تحصل على نفس الأرقام:

```dockerfile
# Training, int8 quantisation and the TFLite Micro interpreter on x86 for the edge-ai-tinyml lab:
#   docker build -t elm-ml-py:1 content/articles/edge-ai-tinyml/lab
FROM python:3.13.18-slim
RUN pip install --no-cache-dir \
      tensorflow-cpu==2.21.0 \
      numpy scipy \
      ai-edge-litert==2.3.0 \
      tflite-micro==0.dev20261119010814 \
 && pip freeze > /pip-freeze.txt
WORKDIR /work
```

والبناء والتشغيل بالأوامر التالية، حيث `DATA` هو المجلد الذي نزلت فيه ملفات `.mat`:

```bash
docker build -t elm-ml-py:1 lab
DATA=$HOME/cwru ./lab/run-ml.sh
```

### التدريب Training مع تقسيم صادق Honest Split

وهذا هو سكربت التدريب كاملاً، وبعده نمشي على المخرج سطراً سطراً:

```python
# Bearing fault classifier for a Cortex-M4: train, quantise to int8, check with LiteRT and TFLite Micro.
#   docker run --rm -v "$PWD:/work" -v "$DATA:/data:ro" elm-ml-py:1 python train.py
# Data: CWRU Bearing Data Center, drive-end accelerometer, 12 kHz, 0.007" faults, motor loads 0-3 hp.
#   https://engineering.case.edu/bearingdatacenter/download-data-file
import os, time
import numpy as np, scipy.io, scipy.stats
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
import tensorflow as tf
from ai_edge_litert.interpreter import Interpreter as LiteRT, OpResolverType
from tflite_micro import runtime as tflm

CLASSES = ["normal", "inner", "ball", "outer"]
FILES = {  # class -> recording number for loads 0, 1, 2, 3 hp
    "normal": [97, 98, 99, 100], "inner": [105, 106, 107, 108],
    "ball": [118, 119, 120, 121], "outer": [130, 131, 132, 133]}
WIN, SAMPLES = 1024, 120_000          # 1024 samples = 85 ms at 12 kHz; same length from every recording

def load(n):
    m = scipy.io.loadmat(f"/data/{n}.mat")
    return m[f"X{n:03d}_DE_time"][:SAMPLES, 0].astype(np.float32)   # the key names the recording

def windows(x, hop):
    return np.stack([x[i:i + WIN] for i in range(0, len(x) - WIN + 1, hop)])

def dataset(loads, hop):
    X, y = [], []
    for c, name in enumerate(CLASSES):
        for load_hp in loads:
            w = windows(load(FILES[name][load_hp]), hop)
            X.append(w); y.append(np.full(len(w), c))
    return np.concatenate(X)[..., None], np.concatenate(y)

def confusion(y, p):
    m = np.zeros((4, 4), int)
    for a, b in zip(y, p): m[a, b] += 1
    print("          " + "".join(f"{c:>8}" for c in CLASSES))
    for i, c in enumerate(CLASSES): print(f"{c:>8}  " + "".join(f"{v:8d}" for v in m[i]))

tf.keras.utils.set_random_seed(7)
tf.config.experimental.enable_op_determinism()
Xtr, ytr = dataset([0, 1, 2], hop=512)        # train: loads 0, 1, 2 hp
Xte, yte = dataset([3], hop=WIN)              # test: load 3 hp, recordings the model never saw
print(f"train windows {len(Xtr)}  test windows {len(Xte)}  window {WIN} samples = {WIN / 12:.1f} ms")

print("\n== features per class (train): RMS, kurtosis, crest factor")
for c, name in enumerate(CLASSES):
    w = Xtr[ytr == c, :, 0]
    rms = np.sqrt((w ** 2).mean(1)); kurt = scipy.stats.kurtosis(w, axis=1, fisher=False)
    crest = np.abs(w).max(1) / rms
    print(f"{name:>8}: rms {rms.mean():.3f} g  kurtosis {kurt.mean():5.2f}  crest {crest.mean():5.2f}")

L = tf.keras.layers
model = tf.keras.Sequential([
    L.Input((WIN, 1)),
    L.Conv1D(8, 32, strides=4, padding="same", activation="relu"),
    L.MaxPooling1D(4),
    L.Conv1D(16, 8, padding="same", activation="relu"),
    L.MaxPooling1D(4),
    L.Conv1D(32, 4, padding="same", activation="relu"),
    L.GlobalAveragePooling1D(),
    L.Dense(4, activation="softmax"),
])
model.compile(optimizer=tf.keras.optimizers.Adam(3e-3), loss="sparse_categorical_crossentropy", metrics=["accuracy"])
print(f"\n== model: {model.count_params()} parameters")
model.summary(line_length=80)
t0 = time.time()
h = model.fit(Xtr, ytr, epochs=25, batch_size=64, validation_split=0.15, shuffle=True, verbose=0)
print(f"trained 25 epochs in {time.time() - t0:.0f} s, last val accuracy {h.history['val_accuracy'][-1]:.4f}")
pf = model.predict(Xte, verbose=0).argmax(1)
print(f"\n== float32 model on load 3 hp: accuracy {(pf == yte).mean():.4f}")
confusion(yte, pf)

model.save("out/model.keras")

# ---- convert: float32 and full-integer int8 -------------------------------------------------------
conv = tf.lite.TFLiteConverter.from_keras_model(model)
f32 = conv.convert()
rng = np.random.default_rng(0)
rep_idx = rng.choice(len(Xtr), 300, replace=False)
def representative():
    for i in rep_idx: yield [Xtr[i:i + 1]]
conv = tf.lite.TFLiteConverter.from_keras_model(model)
conv.optimizations = [tf.lite.Optimize.DEFAULT]
conv.representative_dataset = representative
conv.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
conv.inference_input_type = tf.int8
conv.inference_output_type = tf.int8
i8 = conv.convert()
open("out/model_f32.tflite", "wb").write(f32); open("out/model_int8.tflite", "wb").write(i8)
print(f"\n== .tflite size: float32 {len(f32):,} bytes, int8 {len(i8):,} bytes ({len(f32) / len(i8):.1f}x smaller)")

it = LiteRT(model_content=i8, experimental_op_resolver_type=OpResolverType.BUILTIN_WITHOUT_DEFAULT_DELEGATES)
it.allocate_tensors()   # reference kernels, no XNNPACK, so the op list is the model itself
inp, out = it.get_input_details()[0], it.get_output_details()[0]
s_in, z_in = inp["quantization"]; s_out, z_out = out["quantization"]
print(f"input  {inp['dtype'].__name__} {list(inp['shape'])} scale {s_in:.6f} zero_point {z_in}")
print(f"output {out['dtype'].__name__} {list(out['shape'])} scale {s_out:.6f} zero_point {z_out}")
ops = sorted({d["op_name"] for d in it._get_ops_details()})
print("ops:", ", ".join(ops))

def q(x): return np.clip(np.round(x / s_in + z_in), -128, 127).astype(np.int8)
Xq = q(Xte)
lite_out = []
for w in Xq:
    it.set_tensor(inp["index"], w[None]); it.invoke(); lite_out.append(it.get_tensor(out["index"])[0].copy())
lite_out = np.array(lite_out)
xnn = LiteRT(model_content=i8); xnn.allocate_tensors()      # default: XNNPACK delegate for x86 speed
xnn_out = []
for w in Xq:
    xnn.set_tensor(inp["index"], w[None]); xnn.invoke(); xnn_out.append(xnn.get_tensor(out["index"])[0].copy())
xnn_out = np.array(xnn_out)
pq = lite_out.argmax(1)
print(f"\n== int8 model (LiteRT) on load 3 hp: accuracy {(pq == yte).mean():.4f}, "
      f"same class as float32 in {(pq == pf).sum()}/{len(pf)} windows")
confusion(yte, pq)

# ---- the same int8 model in the TFLite Micro interpreter (the C++ code that runs on the MCU) -----
micro = tflm.Interpreter.from_bytes(i8, arena_size=64 * 1024)
micro_out = []
for w in Xq:
    micro.set_input(w[None], 0); micro.invoke(); micro_out.append(micro.get_output(0)[0].copy())
micro_out = np.array(micro_out)
print(f"\n== TFLite Micro (x86) on the same {len(Xq)} windows: identical int8 outputs to LiteRT in "
      f"{(micro_out == lite_out).all(1).sum()}/{len(Xq)}, max difference {np.abs(micro_out.astype(int) - lite_out).max()}")
print(f"   LiteRT with XNNPACK against reference kernels: identical in {(xnn_out == lite_out).all(1).sum()}/{len(Xq)}, "
      f"max difference {np.abs(xnn_out.astype(int) - lite_out).max()}, same class in {(xnn_out.argmax(1) == pq).sum()}/{len(Xq)}")
micro.print_allocations()

# ---- faults the model never saw: 0.014 inch defects (twice the size), load 3 hp -------------------
X14, y14 = [], []
for c, n in [(1, 172), (2, 188), (3, 200)]:
    w = windows(load(n), WIN); X14.append(w); y14.append(np.full(len(w), c))
X14, y14 = np.concatenate(X14)[..., None], np.concatenate(y14)
p14 = []
for w in q(X14):
    it.set_tensor(inp["index"], w[None]); it.invoke(); p14.append(it.get_tensor(out["index"])[0].argmax())
p14 = np.array(p14)
print(f"\n== int8 model on 0.014 inch faults (not in training), load 3 hp: accuracy {(p14 == y14).mean():.4f}")
confusion(y14, p14)

np.savez("out/test.npz", Xq=Xq, y=yte, lite=lite_out, s_in=s_in, z_in=z_in, s_out=s_out, z_out=z_out)
```

في الكود أعلاه لاحظ التالي:

- التدريب على الحمولات 0 و1 و2، والاختبار على الحمولة 3 فقط، أي على تسجيلات لم ير النموذج منها أي عينة. وهذا هو التقسيم الصادق، فلو خلطنا النوافذ من كل التسجيلات ثم قسمناها عشوائياً لرأى النموذج في التدريب نوافذ متداخلة مع نوافذ الاختبار من نفس الدقيقة، ولخرجت دقة عالية لا تعني شيئاً.
- الدالة `load` تختار المصفوفة برقم الملف نفسه `X{n:03d}_DE_time`، وهذا ليس تفصيلاً، فالملف `99.mat` في هذه البيانات يحتوي مصفوفتين: `X098_DE_time` و`X099_DE_time`، فإذا أخذت أول مصفوفة تنتهي بـ `DE_time` كما تفعل سكربتات كثيرة فأنت تقرأ تسجيل الحمولة 1 مرتين وتظن أنك تقرأ الحمولة 2.
- نأخذ نفس الطول 120,000 عينة من كل تسجيل، لأن تسجيلات المحرك السليم أطول بكثير من تسجيلات الأعطال، وبدون ذلك يتعلم النموذج أن «سليم» هو الجواب الأكثر احتمالاً.
- التحويل إلى int8 يستخدم 300 نافذة عشوائية من بيانات التدريب للمعايرة، ويطلب أن يكون المدخل والمخرج int8 أيضاً، لأن المتحكم سيعطيه بايتات مباشرة.
- نشغل النموذج المكمم في مفسرين: LiteRT بالنوى المرجعية، والمفسر `tflite_micro` وهو نفس كود TFLM الذي سيعمل على المتحكم مترجماً للحاسب، كما في [توثيق واجهة Python في TFLM](https://github.com/tensorflow/tflite-micro/tree/main/python/tflite%5Fmicro?ref=arabroot.io).

والمخرج سوف يكون كما يلي، أولاً البيانات والخصائص:

```text
train windows 2796  test windows 468  window 1024 samples = 85.3 ms
== features per class (train): RMS, kurtosis, crest factor
  normal: rms 0.068 g  kurtosis  2.84  crest  3.11
   inner: rms 0.295 g  kurtosis  5.49  crest  4.69
    ball: rms 0.142 g  kurtosis  2.90  crest  3.28
   outer: rms 0.610 g  kurtosis  7.67  crest  4.81
== model: 3516 parameters
```

لاحظ التالي:

- 2,796 نافذة للتدريب و468 للاختبار، أي 117 نافذة لكل فئة عند الحمولة 3.
- RMS للمحرك السليم 0.068 g، وللحلقة الخارجية 0.610 g، أي قرابة تسعة أضعاف، فالعطل يهتز بقوة واضحة.
- التفرطح Kurtosis للسليم 2.84 قريب من 3 كما يتوقع لإشارة عشوائية، ويرتفع إلى 5.49 للحلقة الداخلية و7.67 للخارجية بسبب النبضات الحادة.
- عطل الكرة هو الأصعب: RMS فيه 0.142 g فقط، والتفرطح 2.90 لا يكاد يختلف عن السليم، وهذا معروف في تشخيص المحامل لأن الكرة تدور وتغير الوجه الذي يلمس الحلقات، فنبضاتها أضعف وأقل انتظاماً. وهنا يظهر فضل النموذج على قاعدة بسيطة بخاصية واحدة.

ثم النموذج والتدريب والنتيجة على الحمولة التي لم يرها:

```text
 Total params: 3,516 (13.73 KB)
 Trainable params: 3,516 (13.73 KB)
 Non-trainable params: 0 (0.00 B)
trained 25 epochs in 41 s, last val accuracy 1.0000
== float32 model on load 3 hp: accuracy 1.0000
            normal   inner    ball   outer
  normal       117       0       0       0
   inner         0     117       0       0
    ball         0       0     117       0
   outer         0       0       0     117
```

التدريب أخذ 41 ثانية على المعالج بدون بطاقة رسومية، والدقة Accuracy على الحمولة 3 كانت 100%: كل نافذة من الـ 468 في فئتها الصحيحة، ومصفوفة الالتباس Confusion Matrix قطرية تماماً. وهذه نتيجة ممتازة، ولكن لا تتحمس لها كثيراً، وسنعرف السبب في قسم كشف الشذوذ.

### التحويل Conversion إلى int8 والمقارنة مع TFLite Micro

بعد ذلك التحويل والمقارنة بين المفسرات:

```text
fully_quantize: 0, inference_type: 6, input_inference_type: INT8, output_inference_type: INT8
== .tflite size: float32 20,912 bytes, int8 12,848 bytes (1.6x smaller)
input  int8 [np.int32(1), np.int32(1024), np.int32(1)] scale 0.027063 zero_point -2
output int8 [np.int32(1), np.int32(4)] scale 0.003906 zero_point -128
ops: CONV_2D, EXPAND_DIMS, FULLY_CONNECTED, MAX_POOL_2D, MEAN, RESHAPE, SOFTMAX
INFO: Created TensorFlow Lite XNNPACK delegate for CPU.
== int8 model (LiteRT) on load 3 hp: accuracy 1.0000, same class as float32 in 468/468 windows
            normal   inner    ball   outer
  normal       117       0       0       0
   inner         0     117       0       0
    ball         0       0     117       0
   outer         0       0       0     117
== TFLite Micro (x86) on the same 468 windows: identical int8 outputs to LiteRT in 468/468, max difference 0
   LiteRT with XNNPACK against reference kernels: identical in 466/468, max difference 2, same class in 468/468
[RecordingMicroAllocator] Arena allocation total 8176 bytes
[RecordingMicroAllocator] Arena allocation head 4096 bytes
[RecordingMicroAllocator] Arena allocation tail 4080 bytes
```

لاحظ التالي:

- ملف float32 حجمه 20,912 بايت، وملف int8 حجمه 12,848 بايت، أي أصغر بـ 1.6 مرة فقط وليس أربع مرات كما قد تتوقع. والسبب أن الأوزان نفسها صغيرة، 3,516 معاملاً، فالجزء الأكبر من الملف هو وصف الرسم البياني Graph ومعاملات التكميم لكل قناة. وفي النماذج الأكبر يقترب الفرق من أربع مرات.
- مقياس المدخل 0.027063 ونقطة الصفر −2، أي أن كل خطوة في البايت تساوي 0.027 g. والمخرج مقياسه 0.003906، أي 1/256، ونقطة صفره −128، فالقيمة −128 تعني احتمال صفر، و127 تعني احتمالاً قريباً من واحد.
- العمليات سبع: CONV\_2D وEXPAND\_DIMS وFULLY\_CONNECTED وMAX\_POOL\_2D وMEAN وRESHAPE وSOFTMAX، وهذه القائمة هي بالضبط ما سنضيفه إلى محلل العمليات في المتحكم.
- نموذج int8 أعطى 100% أيضاً، ونفس فئة نموذج float32 في 468 نافذة من 468، فالتكميم لم يكلفنا أي دقة هنا.
- مفسر TFLM على الحاسب أعطى نفس البايتات تماماً التي أعطاها LiteRT بالنوى المرجعية في كل النوافذ، والفرق الأقصى صفر. وهذا هو الاختبار الذي يجب أن تقوم به قبل أن تنقل أي نموذج إلى المتحكم: إذا اختلف TFLM عن LiteRT على الحاسب فالمشكلة في النموذج أو المفسر، وليس في كود المتحكم.
- أما LiteRT مع المسرع XNNPACK Delegate الذي يعمل افتراضياً على الحاسب فقد اختلف في نافذتين بفرق أقصاه 2 من 256، مع نفس الفئة في كل النوافذ، لأنه يقرب بعض الحسابات بطريقة مختلفة. والمواصفة نفسها تقول إن التطبيقات المختلفة قد لا تتطابق بالبت، فلا تقارن مخرج المتحكم بمخرج حاسب يعمل بمسرع وتتوقع تطابقاً.
- ساحة الذاكرة على الحاسب 8,176 بايت، منها 4,096 للرأس و4,080 للذيل. وهذا الرقم على معالج 64 بت، والمؤشرات فيه بثمانية بايتات، فعلى المتحكم سيكون أصغر كما سنرى.

## المختبر على Cortex-M4: STM32F407 في المحاكي Emulator Renode

الآن ننقل نفس النموذج إلى المتحكم. والهدف لوحة STM32F4 Discovery بشريحة STM32F407 التي استخدمناها في مقالات هذه المرحلة، بمعالج Cortex-M4 مع وحدة FPU وسرعة حتى 168 MHz، وفلاش 1 MB، وذاكرة 192 KB بحسب [ورقة بيانات ST](https://www.st.com/resource/en/datasheet/stm32f407vg.pdf?ref=arabroot.io). وهذه صورة الوجه الخلفي للوحة الحقيقية التي يحاكيها Renode بملف الوصف [stm32f4\_discovery-kit.repl](https://github.com/renode/renode/blob/master/platforms/boards/stm32f4%5Fdiscovery-kit.repl?ref=arabroot.io):

![الوجه الخلفي الأخضر للوحة STM32F4 Discovery بملصق MB997 وصفين طويلين من أرجل التوصيل على الجانبين ومسارات النحاس بينهما](https://arabroot.io/content/images/2026/11/edge-ai-tinyml-10-stm32f4-discovery.webp)

الوجه الخلفي للوحة STM32F4 Discovery (رقم اللوحة MB997)، والشريحة STM32F407 على الوجه الآخر، وصفا الأرجل على الجانبين يوصلان كل أرجلها إلى حساساتك. الصورة: Teardown Central، الرخصة [CC BY-SA 2.0](https://creativecommons.org/licenses/by-sa/2.0/?ref=arabroot.io)، المصدر: [Wikimedia Commons](https://commons.wikimedia.org/wiki/File:STM32F4%5FDiscovery%5F%289067299045%29.jpg?ref=arabroot.io) (تم تصغيرها وتحويلها إلى WebP).

### بناء Build مكتبة TFLite Micro للمتحكم MCU

ملف الأدوات مبني فوق Image الأدوات التي استخدمناها لـ STM32، ويضيف شيئين، وكل منهما جاء من مشكلة حقيقية ستواجهها:

```dockerfile
# Cortex-M build of TFLite Micro for the edge-ai-tinyml lab, on top of the stm32-arm-cortex toolchain image:
#   docker build -t elm-ml-fw:1 content/articles/edge-ai-tinyml/lab/fw
# TFLite Micro is C++, so it needs the C++ standard library headers for arm-none-eabi (not in elm-stm-fw:1).
FROM elm-stm-fw:1
RUN apt-get update && apt-get install -y --no-install-recommends libstdc++-arm-none-eabi-newlib unzip \
    && rm -rf /var/lib/apt/lists/* /usr/share/doc/* \
    && for d in /usr/lib/arm-none-eabi/newlib/thumb /usr/lib/arm-none-eabi/lib/thumb; do \
         [ -d $d ] && (cd $d && rm -rf v7 v7+fp v7-a* v7-r* v7ve* v8-a* v8.1-m.main+pacbti*); done; \
       rm -rf /usr/lib/arm-none-eabi/newlib/arm; true
# The TFLM Makefile fetches CMSIS and CMSIS-NN with wget (curl alone is not enough)
RUN apt-get update && apt-get install -y --no-install-recommends wget && rm -rf /var/lib/apt/lists/*
WORKDIR /work
```

في الملف أعلاه لاحظ التالي:

- TFLM مكتوب بلغة C++، والحزمة `gcc-arm-none-eabi` في Debian تحتوي المترجم `arm-none-eabi-g++` ولكن بدون مكتبة C++ القياسية، فأول ملف يترجمه يتوقف بالخطأ `fatal error: cstdint: No such file or directory`، والحل هو الحزمة `libstdc++-arm-none-eabi-newlib`.
- ملف Makefile في TFLM ينزل مكتبتي CMSIS وCMSIS-NN عند أول بناء بالأداة `wget`، فإذا لم تكن موجودة يتوقف البناء بالرسالة `wget: command not found` ثم `Something went wrong with the CMSIS download`، ووجود `curl` لا يكفي.

ثم نبني مكتبة TFLM مرتين من نفس المصدر، مثبتاً على commit [38a8f0f](https://github.com/tensorflow/tflite-micro/commit/38a8f0f87302817ddfa99e6a995c7b71ef7118fe?ref=arabroot.io) بتاريخ 19 نوفمبر 2026: مرة بالنوى المحسنة CMSIS-NN، ومرة بالنوى المرجعية، وكلاهما لمعالج Cortex-M4 مع FPU، كما يشرح [دليل الهدف cortex\_m\_generic](https://github.com/tensorflow/tflite-micro/blob/main/tensorflow/lite/micro/cortex%5Fm%5Fgeneric/README.md?ref=arabroot.io):

```bash
git init tflite-micro && cd tflite-micro
git fetch --depth 1 https://github.com/tensorflow/tflite-micro.git 38a8f0f87302817ddfa99e6a995c7b71ef7118fe
git checkout FETCH_HEAD
make -j8 -f tensorflow/lite/micro/tools/make/Makefile TARGET=cortex_m_generic TARGET_ARCH=cortex-m4+fp \
     OPTIMIZED_KERNEL_DIR=cmsis_nn BUILD_TYPE=release_with_logs microlite
make -j8 -f tensorflow/lite/micro/tools/make/Makefile TARGET=cortex_m_generic TARGET_ARCH=cortex-m4+fp \
     BUILD_TYPE=release_with_logs microlite
```

والنتيجة ملفان `libtensorflow-microlite.a`، أخذ الأول قرابة ثلاث دقائق والثاني أربع دقائق على جهاز عادي. ولاحظ الخيار `BUILD_TYPE=release_with_logs`، فإذا بنيت بالخيار `release` وهو الأسرع والأصغر سيتوقف الربط Linking بعشرات الأخطاء `undefined reference to 'MicroPrintf(char const*, ...)'`. والسبب أن `release` يعرف `TF_LITE_STRIP_ERROR_STRINGS` فيحذف رسائل الخطأ من المكتبة، بينما برنامجنا يستخدمها. فإما أن تعرف نفس الرمز في برنامجك وتخسر رسائل الخطأ، أو تبني بـ `release_with_logs` كما في المختبر، وننصح بالثاني أثناء التطوير، لأن رسائل الخطأ هي التي ستخبرك أن الساحة صغيرة أو أن عملية ناقصة كما سنرى.

بعد ذلك يحول السكربت `export.py` النموذج وثماني نوافذ اختبار من الحمولة 3 إلى مصفوفات C، ثم يأتي البرنامج نفسه:

```cpp
// Bearing fault classifier on STM32F407 (Cortex-M4F, 168 MHz): TFLite Micro + the int8 model from train.py.
// Prints over USART2: arena use, then for each embedded test window the class, the int8 scores and the
// DWT cycle count of one Invoke(). Build options: ARENA_SIZE=<bytes>, NO_MEAN=1 (leave MEAN out of the resolver).
#include <stdint.h>
#include <string.h>
#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/micro/micro_mutable_op_resolver.h"
#include "tensorflow/lite/micro/micro_log.h"
#include "tensorflow/lite/micro/cortex_m_generic/debug_log_callback.h"
#include "model_data.h"

#define REG(a) (*(volatile uint32_t *)(a))
#define USART2_SR  REG(0x40004400u)
#define USART2_DR  REG(0x40004404u)
#define USART2_BRR REG(0x40004408u)
#define USART2_CR1 REG(0x4000440Cu)
#define DEMCR      REG(0xE000EDFCu)        // bit 24 TRCENA: turn on the DWT and ITM units
#define DWT_CTRL   REG(0xE0001000u)        // bit 0 CYCCNTENA
#define DWT_CYCCNT REG(0xE0001004u)        // counts CPU clock cycles

extern "C" void uart_puts(const char *s) {
    for (; *s; s++) { while (!(USART2_SR & (1u << 7))) { } USART2_DR = (uint8_t)*s; }
}
static void log_to_uart(const char *s) { uart_puts(s); }
// Empty functions the Renode script hooks to count executed instructions around Invoke()
extern "C" __attribute__((noinline)) void mark_start(void) { __asm volatile ("" ::: "memory"); }
extern "C" __attribute__((noinline)) void mark_end(void)   { __asm volatile ("" ::: "memory"); }

#ifndef ARENA_SIZE
#define ARENA_SIZE (16 * 1024)
#endif
alignas(16) static uint8_t tensor_arena[ARENA_SIZE];
static const char *const kClass[] = {"normal", "inner", "ball", "outer"};

int main(void) {
    REG(0x40023830u) |= 1u; REG(0x40023840u) |= 1u << 17;            // clocks: GPIOA, USART2
    USART2_BRR = 0x8B; USART2_CR1 = (1u << 13) | (1u << 3);            // 115200 at 16 MHz, TX on
    RegisterDebugLogCallback(log_to_uart);
    DEMCR |= 1u << 24; DWT_CYCCNT = 0; DWT_CTRL |= 1u;

    const tflite::Model *model = tflite::GetModel(g_model);
    MicroPrintf("model: %u bytes in flash, schema version %u", g_model_len, (unsigned)model->version());
    static tflite::MicroMutableOpResolver<7> resolver;                // only the ops this model uses
    resolver.AddExpandDims(); resolver.AddConv2D(); resolver.AddMaxPool2D(); resolver.AddReshape();
#if !NO_MEAN
    resolver.AddMean();
#endif
    resolver.AddFullyConnected(); resolver.AddSoftmax();

    static tflite::MicroInterpreter interpreter(model, resolver, tensor_arena, ARENA_SIZE);
    if (interpreter.AllocateTensors() != kTfLiteOk) { MicroPrintf("AllocateTensors() failed"); for (;;) { } }
    MicroPrintf("arena: %u of %u bytes used", (unsigned)interpreter.arena_used_bytes(), (unsigned)ARENA_SIZE);

    TfLiteTensor *in = interpreter.input(0), *out = interpreter.output(0);
    int correct = 0, same = 0;
    for (int w = 0; w < 8; w++) {
        memcpy(in->data.int8, g_test_windows[w], 1024);
        uint32_t c0 = DWT_CYCCNT;
        mark_start();
        TfLiteStatus st = interpreter.Invoke();
        mark_end();
        uint32_t cycles = DWT_CYCCNT - c0;
        if (st != kTfLiteOk) { MicroPrintf("Invoke() failed"); for (;;) { } }
        const int8_t *s = out->data.int8;
        int best = 0;
        for (int k = 1; k < 4; k++) if (s[k] > s[best]) best = k;
        int match = memcmp(s, g_expected[w], 4) == 0;
        correct += best == g_test_labels[w]; same += match;
        MicroPrintf("window %d: true %-6s -> %-6s scores [%4d %4d %4d %4d] %s  cycles %u", w,
                    kClass[g_test_labels[w]], kClass[best], s[0], s[1], s[2], s[3],
                    match ? "= LiteRT" : "!= LiteRT", (unsigned)cycles);
    }
    MicroPrintf("result: %d/8 correct, %d/8 identical to LiteRT on x86", correct, same);
    for (;;) { }
}
```

في الكود أعلاه لاحظ التالي:

- `tensor_arena` مصفوفة ثابتة بمحاذاة 16 بايت، وحجمها 16 KB كبداية، وسنعرف الحجم الحقيقي من `arena_used_bytes()`.
- `MicroMutableOpResolver<7>` فيه العمليات السبع فقط، والرقم 7 هو السعة، فإذا أضفت عملية ثامنة بدون تغييره يرفضها.
- `AllocateTensors()` هو الذي يخطط الذاكرة ويجهز كل العمليات، ويفشل هنا وليس أثناء التشغيل، وهذا تصميم جيد: الجهاز يكتشف المشكلة عند الإقلاع.
- نقرأ عداد الدورات `DWT_CYCCNT` قبل `Invoke()` وبعده، وهو عداد في وحدة DWT داخل Cortex-M4 يعد دورات الساعة Clock Cycles، ونستدعي دالتين فارغتين `mark_start` و`mark_end` يراقبهما Renode لكي يعد التعليمات المنفذة Executed Instructions، وسنرى بعد قليل لماذا احتجنا الطريقتين.
- نقارن مخرج المتحكم بالبايتات التي أخرجها LiteRT على الحاسب لنفس النافذة، فالمطلوب تطابق تام وليس فئة صحيحة فقط.

وفي ملف الربط والبداية شيئان تحتاجهما مع C++: أن يشغل `Reset_Handler` دوال البناء Constructors في القسم `.init_array`، وأن يفعل وحدة FPU قبل أي تعليمة عشرية لأننا نترجم بالخيار `-mfloat-abi=hard`. وإذا ظهر لك عند الربط الخطأ `undefined reference to '__dso_handle'` فالسبب أن المترجم يسجل الهادم Destructor للكائن الثابت Static Object بالدالة `__cxa_atexit`، والبرنامج المدمج لا يخرج أبداً، فأضف الخيار `-fno-use-cxa-atexit` كما في ملف Makefile في المختبر.

### التشغيل Run: الفئة Class والذاكرة RAM وعدد التعليمات Instructions

والسكربت `fw/run-fw.sh` يبني البرنامج بالمكتبتين ويشغل كل نسخة في Renode بنفس الطريقة التي شرحناها في المقالات السابقة: يحمل ملف ELF، ويوجه المنفذ التسلسلي USART2 إلى ملف، ويضع خطافاً Hook على الدالتين `mark_start` و`mark_end` يطبع عدد التعليمات المنفذة:

```text
# Renode: STM32F4 Discovery (STM32F407, Cortex-M4F), our ELF, USART2 to a file,
# and a hook on mark_start/mark_end that prints the executed-instruction count around each Invoke()
$elf?=@/tmp/clf.elf
$uart?=@/tmp/uart.txt
mach create "disco"
machine LoadPlatformDescription @platforms/boards/stm32f4_discovery-kit.repl
cpu PerformanceInMips 168
sysbus LoadELF $elf
sysbus.usart2 CreateFileBackend $uart true
cpu AddHook $start "print('INSN start %d' % self.ExecutedInstructions)"
cpu AddHook $end "print('INSN end %d' % self.ExecutedInstructions)"
emulation RunFor "3"
quit
```

والتشغيل بالأمر التالي، حيث `elm-ml-src` هو Volume فيه مصدر TFLM المبني:

```bash
docker run --rm -v elm-ml-src:/src -v "$PWD/lab:/work" elm-ml-fw:1 bash /work/fw/run-fw.sh | tee lab/out-fw.txt
```

والمخرج سوف يكون كما يلي للنسخة بنوى CMSIS-NN:

```text
### 2. CMSIS-NN kernels
   text	   data	    bss	    dec	    hex	filename
 114604	     80	  16952	 131636	  20234	/tmp/nn.elf
[WARNING] sysbus: [cpu: 0x800026C] WriteDoubleWord to non existing peripheral at 0xE0001004, value 0x0.
[WARNING] sysbus: [cpu: 0x800026E] ReadDoubleWord from non existing peripheral at 0xE0001000.
[WARNING] sysbus: [cpu: 0x8000276] WriteDoubleWord to non existing peripheral at 0xE0001000, value 0x1.
[WARNING] sysbus: [cpu: 0x800038A] ReadDoubleWord from non existing peripheral at 0xE0001004.
  renode: 935782 instructions in Invoke()
[WARNING] sysbus: [cpu: 0x800039A] ReadDoubleWord from non existing peripheral at 0xE0001004.
  renode: 935757 instructions in Invoke()
  renode: 935314 instructions in Invoke()
  renode: 935339 instructions in Invoke()
  renode: 935757 instructions in Invoke()
  renode: 935757 instructions in Invoke()
  renode: 935339 instructions in Invoke()
  renode: 935364 instructions in Invoke()
model: 12848 bytes in flash, schema version 3
arena: 6692 of 16384 bytes used
window 0: true normal -> normal scores [ 127 -128 -128 -128] = LiteRT  cycles 0
window 1: true normal -> normal scores [ 127 -128 -128 -128] = LiteRT  cycles 0
window 2: true inner  -> inner  scores [-128  127 -128 -128] = LiteRT  cycles 0
window 3: true inner  -> inner  scores [-128  127 -128 -128] = LiteRT  cycles 0
window 4: true ball   -> ball   scores [-128 -128  127 -128] = LiteRT  cycles 0
window 5: true ball   -> ball   scores [-128 -128  127 -128] = LiteRT  cycles 0
window 6: true outer  -> outer  scores [-128 -128 -128  127] = LiteRT  cycles 0
window 7: true outer  -> outer  scores [-128 -128 -128  127] = LiteRT  cycles 0
result: 8/8 correct, 8/8 identical to LiteRT on x86
```

لاحظ التالي:

- البرنامج كله 114,604 بايت كود وثوابت في الفلاش، و80 بايت بيانات، و16,952 بايت في `bss` أغلبها الساحة 16 KB. أي أن الفلاش المستخدم قرابة 11% من 1 MB، والذاكرة قرابة 13% من 128 KB.
- الساحة المستخدمة فعلاً 6,692 بايت، أقل من 8,176 على الحاسب بسبب المؤشرات بأربعة بايتات. فيمكنك أن تخفض `ARENA_SIZE` إلى 8 KB مثلاً وتوفر 8 KB من الذاكرة.
- النوافذ الثماني في فئاتها الصحيحة، والبايتات مطابقة لما أخرجه LiteRT على الحاسب تماماً، أي أن الطريق من Python إلى المتحكم لم يغير شيئاً.
- عداد الدورات أعطى `cycles 0`، والتحذيرات في السجل تشرح السبب: `non existing peripheral at 0xE0001004`، أي أن Renode 1.17 لا يحاكي وحدة DWT في هذه اللوحة، فالكتابة فيها تهمل والقراءة تعيد صفراً. وعلى اللوحة الحقيقية سيعمل نفس الكود ويعطيك الدورات، أما في المحاكي فاعتمد على عد التعليمات بالخطاف.
- كل استدعاء لـ `Invoke()` نفذ قرابة 935 ألف تعليمة، بفروق صغيرة بين النوافذ لأن بعض الفروع في الكود تعتمد على القيم.

ثم نفس البرنامج بالنوى المرجعية:

```text
### 3. reference kernels
   text	   data	    bss	    dec	    hex	filename
  81336	     80	  16952	  98368	  18040	/tmp/ref.elf
[WARNING] sysbus: [cpu: 0x800026C] WriteDoubleWord to non existing peripheral at 0xE0001004, value 0x0.
[WARNING] sysbus: [cpu: 0x800026E] ReadDoubleWord from non existing peripheral at 0xE0001000.
[WARNING] sysbus: [cpu: 0x8000276] WriteDoubleWord to non existing peripheral at 0xE0001000, value 0x1.
[WARNING] sysbus: [cpu: 0x800038A] ReadDoubleWord from non existing peripheral at 0xE0001004.
  renode: 4335705 instructions in Invoke()
[WARNING] sysbus: [cpu: 0x800039A] ReadDoubleWord from non existing peripheral at 0xE0001004.
  renode: 4335603 instructions in Invoke()
  renode: 4333559 instructions in Invoke()
  renode: 4333634 instructions in Invoke()
  renode: 4333953 instructions in Invoke()
  renode: 4333923 instructions in Invoke()
  renode: 4333802 instructions in Invoke()
  renode: 4333613 instructions in Invoke()
model: 12848 bytes in flash, schema version 3
arena: 6612 of 16384 bytes used
window 0: true normal -> normal scores [ 127 -128 -128 -128] = LiteRT  cycles 0
window 1: true normal -> normal scores [ 127 -128 -128 -128] = LiteRT  cycles 0
window 2: true inner  -> inner  scores [-128  127 -128 -128] = LiteRT  cycles 0
window 3: true inner  -> inner  scores [-128  127 -128 -128] = LiteRT  cycles 0
window 4: true ball   -> ball   scores [-128 -128  127 -128] = LiteRT  cycles 0
window 5: true ball   -> ball   scores [-128 -128  127 -128] = LiteRT  cycles 0
window 6: true outer  -> outer  scores [-128 -128 -128  127] = LiteRT  cycles 0
window 7: true outer  -> outer  scores [-128 -128 -128  127] = LiteRT  cycles 0
result: 8/8 correct, 8/8 identical to LiteRT on x86
```

والفرق كبير: 4,335,705 تعليمة مقابل 935,782، أي أن CMSIS-NN أقل بـ 4.6 مرة، وهو نفس الرقم الذي ذكرته ورقة CMSIS-NN. والسبب أن نواة الالتفاف المرجعية تضرب كل وزن في كل عينة بتعليمة منفصلة، بينما تجمع CMSIS-NN العينات في أزواج من 16 بت وتستخدم تعليمة مثل `SMLAD` التي تضرب زوجين وتجمعهما في تعليمة واحدة، وهذا ما يسمى SIMD أي تعليمة واحدة لبيانات متعددة. وفي المقابل كود CMSIS-NN أكبر: 114,604 بايت مقابل 81,336، أي 33 KB إضافية، وقائمة أكبر الرموز تشرح ذلك:

```text
### 4. where the flash goes (CMSIS-NN build, largest symbols)
080102c0 000009ca T arm_nn_mat_mult_kernel_s4_s16
0800980c 00000d58 T arm_nn_softmax_common_s8
0800cc98 00000e10 T arm_nn_vec_mat_mult_t_s8
0800daa8 00000ea8 T arm_nn_vec_mat_mult_t_per_ch_s8
0800adfc 00001aee T arm_nn_mat_mult_nt_t_s4
080183f8 00002000 T g_test_windows
080151a0 00003230 T g_model
200001e0 00004000 b tensor_arena
```

لاحظ نوى بأسماء تنتهي بـ `s4`، أي للأوزان بأربعة بتات، وهي لا تستخدم في نموذجنا ولكنها دخلت لأن نواة الالتفاف تختار بينها أثناء التشغيل بحسب نوع النموذج. ولاحظ أيضاً أن النموذج `g_model` بحجم `0x3230` أي 12,848 بايت، ونوافذ الاختبار `0x2000` أي 8 KB ستحذفها في الجهاز الحقيقي.

![أعمدة مقارنة: النوى المرجعية 4335705 تعليمة أي 25.81 ملي ثانية، ونوى CMSIS-NN 935782 تعليمة أي 5.57 ملي ثانية، وتحتها بطاقات للفلاش والساحة والنتيجة ونسبة الوقت من النافذة](https://arabroot.io/content/images/2026/11/edge-ai-tinyml-06-cortex-m.webp)

النوى المحسنة: أسرع بـ 4.6 مرة، وأكبر بـ 33 KB في الفلاش، ونفس البايتات في المخرج

### من التعليمات إلى الملي ثانية والطاقة Energy

والآن نحول التعليمات إلى زمن وطاقة. وهنا يجب أن نكون صادقين في حدود القياس: Renode يعد التعليمات ولا يحاكي الدورات بدقة، فهو لا يعرف أن بعض تعليمات القراءة من الذاكرة تأخذ دورتين، ولا أن الفلاش عند 168 MHz يحتاج خمس حالات انتظار Wait States يخفيها مسرع ART في أغلب الوقت، كما تذكر ورقة البيانات. لذلك نفترض تعليمة لكل دورة، ونعتبر الناتج حداً أدنى، والدورات الحقيقية تقيسها على اللوحة بعداد DWT. والسكربت `energy.py` يأخذ تيار المعالج من جداول ورقة البيانات DS8626، وكل رقم فيه مكتوب مع مصدره:

```python
# From instructions per inference (Renode) to milliseconds and millijoules on an STM32F407 at 168 MHz.
#   python3 energy.py
# Datasheet: ST DS8626 Rev 12 (March 2026), STM32F405xx/STM32F407xx, typical values at 25 C and VDD = 3.3 V:
#   Table 20: Run mode, flash with ART accelerator, all peripherals disabled, 168 MHz: 40 mA
#   Table 22: Sleep mode, all peripherals disabled, 168 MHz: 12 mA; note 3: add 1.6 mA per ADC while it is on
#   Table 23: Stop mode, main regulator in low-power mode, flash in Stop mode: 0.31 mA
# Renode counts instructions, not cycles: one instruction = one cycle is the best case, so times are lower bounds.
F_HZ, VDD = 168e6, 3.3
RUN_A, SLEEP_A, ADC_A, STOP_A = 40e-3, 12e-3, 1.6e-3, 0.31e-3
WINDOW_S = 1024 / 12000                         # one window of vibration at 12 kHz = 85.3 ms
INSTR = {"CMSIS-NN": 935_782, "reference": 4_335_705}     # lab/out-fw.txt, first window of each build
BATTERY_MAH = 2600                              # an example cell, change it to yours

for name, n in INSTR.items():
    t = n / F_HZ
    print(f"{name:>9}: {n:>9,} instructions -> {t * 1e3:5.2f} ms at 168 MHz (CPI 1), "
          f"{VDD * RUN_A * t * 1e3:5.2f} mJ, {100 * t / WINDOW_S:4.1f} % of one {WINDOW_S * 1e3:.1f} ms window")

t_inf = INSTR["CMSIS-NN"] / F_HZ
for label, period_s in (("one window every minute", 60.0), ("every window, no pause", WINDOW_S + t_inf)):
    charge = (SLEEP_A + ADC_A) * WINDOW_S + RUN_A * t_inf          # capture in Sleep with the ADC, then infer
    awake = WINDOW_S + t_inf
    avg = (charge + STOP_A * max(period_s - awake, 0)) / period_s
    print(f"\n{label}: capture {(SLEEP_A + ADC_A) * WINDOW_S * 1e3:.3f} mC + inference {RUN_A * t_inf * 1e3:.3f} mC per window")
    print(f"   average current {avg * 1e3:.3f} mA -> {BATTERY_MAH / (avg * 1e3):,.0f} h = {BATTERY_MAH / (avg * 1e3) / 24:,.0f} days "
          f"on {BATTERY_MAH} mAh (MCU only: no sensor, no radio, no self-discharge)")
```

والمخرج سوف يكون كما يلي:

```text
 CMSIS-NN:   935,782 instructions ->  5.57 ms at 168 MHz (CPI 1),  0.74 mJ,  6.5 % of one 85.3 ms window
reference: 4,335,705 instructions -> 25.81 ms at 168 MHz (CPI 1),  3.41 mJ, 30.2 % of one 85.3 ms window
one window every minute: capture 1.161 mC + inference 0.223 mC per window
   average current 0.333 mA -> 7,818 h = 326 days on 2600 mAh (MCU only: no sensor, no radio, no self-discharge)
every window, no pause: capture 1.161 mC + inference 0.223 mC per window
   average current 15.218 mA -> 171 h = 7 days on 2600 mAh (MCU only: no sensor, no radio, no self-discharge)
```

لاحظ التالي:

- استدعاء واحد بنوى CMSIS-NN يأخذ قرابة 5.57 ms على الأقل، أي 6.5% من وقت النافذة، فالمعالج يستطيع أن يحلل كل نافذة وينام 93% من الوقت. والنوى المرجعية تأخذ 25.81 ms، أي 30.2%، وما زالت تلحق بالإشارة، ولكن بطاقة أكبر بأربع مرات ونصف.
- الطاقة 0.74 mJ للاستدعاء، والمفاجأة في السطر التالي الذي يحسب الشحنة Charge بالملي كولوم mC: جمع النافذة نفسها في وضع النوم Sleep مع محول ADC يستهلك 1.161 mC، أي أكثر من خمسة أضعاف الاستدلال Inference الذي يستهلك 0.223 mC. فبعد CMSIS-NN لم يعد النموذج هو المشكلة، وإنما الوقت الذي يبقى فيه المعالج مستيقظاً يجمع العينات.
- إذا حللت نافذة واحدة كل دقيقة ونام المعالج بينها في وضع Stop، يصبح متوسط التيار 0.333 mA، أي قرابة 326 يوماً على بطارية 2600 mAh للمعالج وحده. أما التحليل المستمر لكل نافذة فيرفع المتوسط إلى 15.2 mA، أي أسبوعاً واحداً.
- هذه الأرقام للمعالج فقط، بدون الحساس والراديو، ولكي تكمل الحساب بنفس الطريقة اقرأ [مقال الأجهزة قليلة الاستهلاك](https://arabroot.io/articles/%D8%AA%D8%B5%D9%85%D9%8A%D9%85-%D8%A7%D9%84%D8%A7%D8%AC%D9%87%D8%B2%D8%A9-%D9%82%D9%84%D9%8A%D9%84%D8%A9-%D8%A7%D9%84%D8%A7%D8%B3%D8%AA%D9%87%D9%84%D8%A7%D9%83-low-power-%D8%B9%D9%85%D8%B1-%D8%A7%D9%84%D8%A8%D8%B7%D8%A7%D8%B1%D9%8A%D8%A9/) الذي حسبنا فيه ميزانية الطاقة كاملة.

والدرس العملي من هذا القسم أن السؤال في TinyML ليس «هل يعمل النموذج على المتحكم؟» فقط، وإنما «كم مرة يجب أن يعمل؟»، لأن المضخة لا تحتاج قراراً كل 85 ms، ومراقبة كل دقيقة أو كل خمس دقائق تكفي لعطل يتطور في أسابيع.

## ماذا يحدث إذا…؟ What If

بعد أن عمل كل شيء، نجرب العطل عمداً في أربعة أماكن يخطئ فيها الجميع في أول مشروع، ونقرأ الرسالة التي سيراها القارئ.

### ماذا يحدث إذا كانت الساحة Tensor Arena صغيرة؟

نبني نفس البرنامج بالخيار `ARENA_SIZE=2048` ونشغله في Renode:

```text
### 5. arena too small: ARENA_SIZE=2048
   text	   data	    bss	    dec	    hex	filename
 114604	     80	   2616	 117300	  1ca34	/tmp/small.elf
[WARNING] sysbus: [cpu: 0x800026C] WriteDoubleWord to non existing peripheral at 0xE0001004, value 0x0.
[WARNING] sysbus: [cpu: 0x800026E] ReadDoubleWord from non existing peripheral at 0xE0001000.
[WARNING] sysbus: [cpu: 0x8000276] WriteDoubleWord to non existing peripheral at 0xE0001000, value 0x1.
model: 12848 bytes in flash, schema version 3
Failed to allocate tail memory. Requested: 64, available 0, missing: 64
Failed to allocate temp memory. Requested: 32, available 0, missing: 32
Failed to allocate temp. memory for tensor 0, subgraph 0
tensorflow/lite/micro/kernels/expand_dims.cc:96 input != nullptr was not true.
Node EXPAND_DIMS (number 0) failed to prepare with status 1
AllocateTensors() failed
```

لاحظ أن البرنامج لم يتعطل ولم يكتب فوق ذاكرة أخرى، وإنما رفض المفسر أن يبدأ عند `AllocateTensors()`، وقال بالضبط ما ينقصه: طلب 64 بايتاً في الذيل ولم يجد شيئاً، ثم فشل تحضير أول عملية EXPAND\_DIMS لأن مدخلها لم يجد مكاناً. وسكربت `whatif.py` يجرب نفس الشيء على الحاسب بساحة 4,096 بايت، فتأتي رسالة مختلفة من عملية CONV\_2D، ثم تنجح الساحة 8,192:

```text
== 1. the tensor arena is too small
Failed to allocate temp memory. Requested: 24, available 0, missing: 24
Unable to allocate TfLiteAffineQuantization.
Failed to populate a temp TfLiteTensor struct from flatbuffer data!
tensorflow/lite/micro/kernels/conv_common.cc:102 filter != nullptr was not true.
Node CONV_2D (number 1) failed to prepare with status 1
arena 4096 bytes: RuntimeError: TFLM failed to allocate tensors
arena 8192 bytes: OK
```

والقاعدة: ابدأ بساحة كبيرة، واطبع `arena_used_bytes()` على الجهاز الحقيقي وليس على الحاسب، ثم اضبط الحجم مع هامش. وإذا لم تبن المكتبة مع رسائل الخطأ كما ذكرنا فلن ترى أياً من هذه الأسطر، وسترى فقط أن الجهاز لا يعمل.

### ماذا يحدث إذا نسيت عملية في محلل العمليات Op Resolver؟

نبني البرنامج بالخيار `NO_MEAN=1` فلا يضيف عملية MEAN:

```text
### 6. MEAN missing from the op resolver
   text	   data	    bss	    dec	    hex	filename
 109536	     80	  16952	 126568	  1ee68	/tmp/nomean.elf
[WARNING] sysbus: [cpu: 0x800026C] WriteDoubleWord to non existing peripheral at 0xE0001004, value 0x0.
[WARNING] sysbus: [cpu: 0x800026E] ReadDoubleWord from non existing peripheral at 0xE0001000.
[WARNING] sysbus: [cpu: 0x8000276] WriteDoubleWord to non existing peripheral at 0xE0001000, value 0x1.
model: 12848 bytes in flash, schema version 3
Didn't find op for builtin opcode 'MEAN'
Failed to get registration from op code MEAN
 
AllocateTensors() failed
```

الرسالة واضحة: `Didn't find op for builtin opcode 'MEAN'`. ولاحظ أن الكود صار أصغر بقرابة 5 KB، من 114,604 إلى 109,536 بايت، وهذا هو ثمن العملية الواحدة في الفلاش. وهذا الخطأ يحدث عادة بعد أن يعيد أحد الفريق تدريب النموذج بطبقة جديدة، فيضيف المحول عملية لم تكن في القائمة، ولذلك اطبع قائمة العمليات من ملف `.tflite` في خط CI بعد كل تدريب وقارنها بقائمة البرنامج.

### ماذا يحدث إذا كانت بيانات المعايرة Calibration Data من المحرك السليم فقط؟

هذا الخطأ أخطر من السابقين لأنه لا يعطي أي رسالة. فلنفرض أن الفريق جمع بيانات المعايرة من المضخات في الموقع، وكلها سليمة بطبيعة الحال، وهذا منطقي من أول نظرة. والسكربت `whatif.py` يحول نفس النموذج مرة ثانية بنوافذ سليمة فقط:

```text
== 2. representative data from normal windows only (calibration that never saw a fault)
all four classes in calibration: input scale 0.027063 (covers +-3.46 g), accuracy 1.0000
     normal: 1.0000
      inner: 1.0000
       ball: 1.0000
      outer: 1.0000
/usr/local/lib/python3.13/site-packages/tensorflow/lite/python/convert.py:846: UserWarning: Statistics for quantized inputs were expected, but not specified; continuing anyway.
  warnings.warn(
fully_quantize: 0, inference_type: 6, input_inference_type: INT8, output_inference_type: INT8
normal windows only in calibration: input scale 0.002345 (covers +-0.30 g), accuracy 0.7500
     normal: 1.0000
      inner: 1.0000
       ball: 1.0000
      outer: 0.0000
```

لاحظ التالي:

- المقياس صار 0.002345 بدل 0.027063، أي أصغر بـ 11 مرة، لأن المحول رأى اهتزازاً لا يتجاوز قرابة 0.30 g.
- الدقة نزلت إلى 75%، والسبب كله في فئة واحدة: الحلقة الخارجية صفر. فاهتزاز هذا العطل هو الأقوى، RMS فيه 0.610 g كما رأينا، فكل قمة فيه أكبر من 0.30 g صارت 127 في البايت، أي أن التكميم قص المعلومة التي تميز العطل.
- لم يظهر أي خطأ أو تحذير، والنموذج يعمل ويعطي «إجابات» واثقة.

ولذلك يجب أن تحتوي بيانات المعايرة على كل المدى الذي يمكن أن يراه الجهاز، بما فيه الحالات النادرة، وإذا لم تكن لديك بيانات أعطال من الموقع فاستخدم بيانات المختبر أو حدد مقياس المدخل يدوياً من مواصفات الحساس.

### ماذا يحدث إذا لم تعط المحول Converter بيانات معايرة أصلاً؟

```text
== 3. no representative dataset at all (dynamic range quantisation)
size 12,336 bytes, input float32, ops: CONV_2D, EXPAND_DIMS, FULLY_CONNECTED, MAX_POOL_2D, MEAN, RESHAPE, SOFTMAX
tensor types inside: float32, int32, int8
TFLite Micro: RuntimeError: TFLM failed to allocate tensors
tensorflow/lite/micro/kernels/conv_common.cc Hybrid models are not supported on TFLite Micro.
Node CONV_2D (number 7) failed to prepare with status 1
```

بدون بيانات معايرة يقوم المحول بما يسمى التكميم بالمدى الديناميكي Dynamic Range Quantization: يكمم الأوزان إلى int8 ويترك المدخل والنتائج الوسيطة float32، فيخرج ما تسميه رسالة TFLM نموذجاً هجيناً Hybrid Model. والحجم قريب جداً من نموذجنا، 12,336 بايت، فقد تظن أن كل شيء بخير، ولكن TFLM يرفضه عند التحضير: `Hybrid models are not supported on TFLite Micro`. وهذا النوع مفيد على الجوال والحاسب، أما للمتحكم فالتكميم الكامل بالأعداد الصحيحة Full Integer Quantization هو الطريق الوحيد.

## التصنيف Classification أم كشف الشذوذ Anomaly Detection؟

نعود الآن إلى دقة 100% التي قلنا لا تتحمس لها. فالنموذج الذي بنيناه مصنف Classifier بأربع فئات، أي أنه يجيب دائماً بواحدة من الأربع التي رآها في التدريب، ولا يملك إجابة اسمها «لا أعرف». والسؤال الحقيقي في الموقع: ماذا يفعل أمام عطل لم يره؟ وفي بيانات CWRU أعطال بنفس الأماكن ولكن بقطر 0.014 بوصة، أي ضعف الحجم، في الملفات 172 و188 و200 عند الحمولة 3، ولم يستخدم أي منها في التدريب، فاختبرنا عليها نفس النموذج المكمم في آخر سكربت التدريب:

```text
== int8 model on 0.014 inch faults (not in training), load 3 hp: accuracy 0.2023
            normal   inner    ball   outer
  normal         0       0       0       0
   inner         0       0     117       0
    ball        46       0      71       0
   outer         0       0     117       0
```

الدقة 20.2%، وهذا أسوأ من التخمين العشوائي بين أربع فئات. والتفاصيل أسوأ من الرقم: عطل الحلقة الداخلية كله صنف «كرة»، وعطل الحلقة الخارجية كله صنف «كرة»، و46 نافذة من عطل الكرة صنفت «سليم». أي أن جهازاً في الموقع كان سيرسل «سليم» عن محمل تالف في قرابة 40% من نوافذ عطل الكرة. والسبب أن العطل الأكبر غير شكل الاهتزاز، والمصنف لا يعرف إلا الأشكال الأربعة التي تعلمها، فاختار أقربها.

وهذا يقودنا إلى حقيقة يجب أن تعرفها قبل أي مشروع صيانة تنبؤية: في الموقع لا توجد بيانات أعطال تقريباً. فالمضخات سليمة أغلب عمرها، والأعطال نادرة ومتنوعة، ولن تنتظر عشر سنوات لتجمع عشرة أمثلة من كل نوع. ولذلك تبدأ أغلب الأنظمة الحقيقية بكشف الشذوذ Anomaly Detection: نموذج يتعلم شكل «السليم» فقط، ويطلق إنذاراً عندما يرى شيئاً لا يشبهه، بدون أن يسمي العطل. وتوثيق [LiteRT للمتحكمات](https://ai.google.dev/edge/litert/microcontrollers/overview?ref=arabroot.io) يصف هذا الاستخدام نفسه بحساسات صناعية تعرف الفرق بين المشكلة والتشغيل الطبيعي.

والسكربت `anomaly.py` يبني كاشفين من المحرك السليم فقط عند الحمولات 0 و1 و2:

- **مشفر تلقائي Autoencoder**: شبكة صغيرة بـ 1,220 معاملاً تأخذ طاقة النافذة في 32 نطاقاً ترددياً Frequency Bands من FFT، وتضغطها إلى أربعة أرقام، ثم تحاول إعادة بنائها. فإذا تدربت على السليم فقط، تعيد بناء السليم بخطأ صغير، وتفشل في إعادة بناء ما لم تره فيكبر الخطأ.
- **عتبة RMS**: أبسط كاشف ممكن، طاقة الاهتزاز وحدها.

```python
# Anomaly detection when you have no fault data: learn "normal" only, alarm on what does not look like it.
#   docker run --rm -v "$PWD:/work" -v "$DATA:/data:ro" elm-ml-py:1 python -u anomaly.py
import os, sys
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
import numpy as np, tensorflow as tf
sys.argv = ["train"]; exec(open("train.py").read().split("tf.keras.utils.set_random_seed")[0])  # CLASSES, FILES, load
tf.keras.utils.set_random_seed(7)

BANDS = 32                                   # 512 FFT bins -> 32 bands of 187.5 Hz each
def features(w):                              # w: (n, 1024) -> log energy per band, what the MCU would compute
    spec = np.abs(np.fft.rfft(w * np.hanning(WIN), axis=1))[:, :512] ** 2
    return np.log10(spec.reshape(len(w), BANDS, -1).sum(2) + 1e-6).astype(np.float32)

def rec(n, hop): return windows(load(n), hop)
normal_train = np.concatenate([rec(n, 512) for n in FILES["normal"][:3]])     # loads 0, 1, 2 hp
F = features(normal_train); mu, sd = F.mean(0), F.std(0) + 1e-6
norm = lambda f: (f - mu) / sd

L = tf.keras.layers
ae = tf.keras.Sequential([L.Input((BANDS,)), L.Dense(16, activation="relu"), L.Dense(4, activation="relu"),
                          L.Dense(16, activation="relu"), L.Dense(BANDS)])
ae.compile(optimizer="adam", loss="mse")
ae.fit(norm(F), norm(F), epochs=60, batch_size=32, verbose=0)
err = lambda f: ((ae.predict(norm(f), verbose=0) - norm(f)) ** 2).mean(1)
e_train = err(F)
thr = np.percentile(e_train, 99.5)
rms_thr = np.percentile(np.sqrt((normal_train ** 2).mean(1)), 99.5)
print(f"autoencoder {ae.count_params()} parameters, trained on {len(F)} normal windows (loads 0-2 hp)")
print(f"threshold = 99.5th percentile of normal error = {thr:.3f};  RMS threshold = {rms_thr:.3f} g")

def report(label, w):
    e = err(features(w)); r = np.sqrt((w ** 2).mean(1))
    print(f"{label:<34} windows {len(w):4d}  autoencoder alarms {100 * (e > thr).mean():6.1f} %"
          f"   RMS alarms {100 * (r > rms_thr).mean():6.1f} %   median error {np.median(e):8.2f}")

full100 = scipy.io.loadmat("/data/100.mat")["X100_DE_time"][:, 0].astype(np.float32)   # 485,643 samples
normal3_test = windows(full100[240_000:360_000], WIN)                     # a later part of the load-3 recording
print("\n== load 3 hp, never seen in training")
report("normal (false alarms)", normal3_test)
for name, n in [("inner race 0.007", 108), ("ball 0.007", 121), ("outer race 0.007", 133),
                ("inner race 0.014", 172), ("ball 0.014", 188), ("outer race 0.014", 200)]:
    report(name, rec(n, WIN))

print("\n== update: add 10 s of normal data at load 3 hp (first 120,000 samples) and retrain")
F = features(np.concatenate([normal_train, windows(full100[:120_000], 512)])); mu, sd = F.mean(0), F.std(0) + 1e-6
tf.keras.utils.set_random_seed(7)
ae = tf.keras.Sequential([L.Input((BANDS,)), L.Dense(16, activation="relu"), L.Dense(4, activation="relu"),
                          L.Dense(16, activation="relu"), L.Dense(BANDS)])
ae.compile(optimizer="adam", loss="mse")
ae.fit(norm(F), norm(F), epochs=60, batch_size=32, verbose=0)
thr = np.percentile(err(F), 99.5)
print(f"trained on {len(F)} normal windows, new threshold {thr:.3f}")
report("normal (false alarms)", normal3_test)
for name, n in [("inner race 0.014", 172), ("ball 0.014", 188), ("outer race 0.014", 200)]:
    report(name, rec(n, WIN))
```

والمخرج سوف يكون كما يلي:

```text
autoencoder 1220 parameters, trained on 699 normal windows (loads 0-2 hp)
threshold = 99.5th percentile of normal error = 1.297;  RMS threshold = 0.079 g
== load 3 hp, never seen in training
normal (false alarms)              windows  117  autoencoder alarms   12.8 %   RMS alarms    0.0 %   median error     1.03
inner race 0.007                   windows  117  autoencoder alarms  100.0 %   RMS alarms  100.0 %   median error   143.35
ball 0.007                         windows  117  autoencoder alarms  100.0 %   RMS alarms  100.0 %   median error    72.24
outer race 0.007                   windows  117  autoencoder alarms  100.0 %   RMS alarms  100.0 %   median error   172.83
inner race 0.014                   windows  117  autoencoder alarms  100.0 %   RMS alarms  100.0 %   median error   101.76
ball 0.014                         windows  117  autoencoder alarms  100.0 %   RMS alarms   98.3 %   median error    61.54
outer race 0.014                   windows  117  autoencoder alarms  100.0 %   RMS alarms  100.0 %   median error    77.93
== update: add 10 s of normal data at load 3 hp (first 120,000 samples) and retrain
trained on 932 normal windows, new threshold 1.283
normal (false alarms)              windows  117  autoencoder alarms    0.0 %   RMS alarms    0.0 %   median error     0.63
inner race 0.014                   windows  117  autoencoder alarms  100.0 %   RMS alarms  100.0 %   median error   108.37
ball 0.014                         windows  117  autoencoder alarms  100.0 %   RMS alarms   98.3 %   median error    64.87
outer race 0.014                   windows  117  autoencoder alarms  100.0 %   RMS alarms  100.0 %   median error    82.71
```

لاحظ التالي:

- كشف الشذوذ أطلق إنذاراً في 100% من نوافذ الأعطال الستة، بما فيها الأعطال الأكبر التي فشل فيها المصنف، لأنه لا يسأل «أي عطل؟» وإنما «هل يشبه هذا السليم؟». والخطأ الوسيط للأعطال بين 61 و172، بينما العتبة 1.297، فالفرق كبير جداً.
- عتبة RMS وحدها قامت بعمل قريب: 100% في كل الأعطال ما عدا عطل الكرة الأكبر بـ 98.3%. وهذا درس مهم: في بيانات بهذا الوضوح قد يكفيك رقم واحد يحسبه المتحكم بعشرة أسطر، فجرب الحل البسيط أولاً، واستخدم النموذج عندما تكون الإشارة أصعب أو عندما تحتاج أن تفرق بين أنواع الأعطال.
- المشكلة في السطر الأول: المحرك السليم عند الحمولة 3، التي لم يرها المشفر في التدريب، أطلق إنذاراً في 12.8% من النوافذ، أي إنذار كاذب False Alarm كل ثماني نوافذ تقريباً. والمحرك سليم تماماً، ولكن حمولته تغيرت فتغير شكل اهتزازه قليلاً.

![أربع بطاقات: المصنف بأربع فئات دقته 20.2 بالمئة على الأعطال الأكبر، وكشف الشذوذ أطلق إنذاراً في 100 بالمئة منها، والإنذار الكاذب 12.8 بالمئة عند حمولة جديدة، ثم صفر بالمئة بعد التحديث](https://arabroot.io/content/images/2026/11/edge-ai-tinyml-07-anomaly.webp)

المصنف يعرف ما تعلمه فقط، وكاشف الشذوذ يحتاج أن يعرف كل أشكال «السليم»

### العتبة Threshold والإنذار الكاذب False Alarm

كل كاشف شذوذ ينتهي بعتبة: خطأ أكبر منها يعني إنذاراً. ونحن اخترنا العتبة عند المئين Percentile رقم 99.5 من خطأ نوافذ السليم في التدريب، أي أننا قبلنا مسبقاً أن تطلق نصف نافذة من كل مئة نافذة سليمة إنذاراً. ورقم مثل هذا يبدو صغيراً حتى تحسبه: مع نافذة كل دقيقة في مضخة واحدة يعني ذلك أكثر من سبعة إنذارات كاذبة في اليوم، ومع عشرين مضخة أكثر من مئة وأربعين، وبعد أسبوع سيتجاهل فريق الصيانة كل الإنذارات، بما فيها الحقيقي. ولذلك لا تطلق الأنظمة الحقيقية إنذاراً من نافذة واحدة، وإنما تجمع القرار على عدة نوافذ، مثل «ثماني نوافذ من عشر فوق العتبة»، أو تحسب متوسطاً متحركاً Moving Average للخطأ، وترسل إلى السيرفر الخطأ نفسه وليس الإنذار فقط، لكي ترى الاتجاه على لوحة المتابعة Dashboard كما في [مقال لوحات المتابعة](https://arabroot.io/articles/%D9%84%D9%88%D8%AD%D8%A7%D8%AA-%D8%A7%D9%84%D9%85%D8%AA%D8%A7%D8%A8%D8%B9%D8%A9-%D9%84%D8%A7%D9%86%D8%AA%D8%B1%D9%86%D8%AA-%D8%A7%D9%84%D8%A7%D8%B4%D9%8A%D8%A7%D8%A1-node-red-%D9%85%D8%B9-grafana/). فالمحمل لا يتعطل في نافذة، وإنما يرتفع خطؤه أسبوعاً بعد أسبوع.

### الانجراف Drift وتحديث النموذج عبر OTA

والإنذارات الكاذبة عند الحمولة 3 مثال صغير على مشكلة كبيرة اسمها الانجراف Drift: البيانات في الموقع تختلف مع الوقت عن بيانات التدريب، لأن الحمولة تتغير، أو تركب مضخة من نوع آخر، أو يرتخي برغي الحساس، أو تأتي حرارة الصيف. والحل الذي يطبقه آخر السكربت هو ما ستفعله في الموقع: نضيف عشر ثوان من المحرك السليم عند الحمولة 3، أي 120,000 عينة من بداية التسجيل، إلى بيانات التدريب، ونعيد التدريب، ثم نختبر على جزء آخر من نفس التسجيل لم يدخل التدريب. فينزل الإنذار الكاذب من 12.8% إلى صفر، ويبقى كشف الأعطال الأكبر 100%.

وفي الجهاز الحقيقي يعني هذا أن النموذج جزء من البرنامج الثابت Firmware يجب أن تستطيع تحديثه عن بعد، وقد شرحنا في [مقال التحديث عن بعد OTA](https://arabroot.io/articles/%D8%AA%D8%AD%D8%AF%D9%8A%D8%AB-%D8%A7%D9%84%D8%A7%D8%AC%D9%87%D8%B2%D8%A9-%D8%B9%D9%86-%D8%A8%D8%B9%D8%AF-ota-%D8%AF%D9%88%D9%86-%D8%A7%D9%86-%D8%AA%D8%AA%D8%B9%D8%B7%D9%84/) كيف تحدث الجهاز بنسختين A/B مع التوقيع Signing والرجوع التلقائي Rollback. والنموذج بالذات له ميزة هنا: لأنه مصفوفة بايتات يقرؤها مفسر عام، يمكنك أن تضعه في قسم Partition خاص من الفلاش وتحدثه وحده بـ 12 KB بدل البرنامج كله، بشرط أن يحتوي البرنامج كل العمليات التي قد يحتاجها النموذج الجديد. وقبل أن تقبل أي نموذج جديد، شغله على الحاسب بـ TFLM وقارن مخرجه بـ LiteRT كما فعلنا، ثم أرسله إلى عدد صغير من الأجهزة أولاً.

📚

بيانات CWRU جاءت من محرك واحد على منصة اختبار، بأعطال مزروعة بالتفريغ الكهربائي وليس بأعطال نمت مع الزمن، ولذلك تعطي نتائج عالية جداً لأغلب النماذج. وقد نشر Wade Smith وRobert Randall في مجلة Mechanical Systems and Signal Processing سنة 2015 [دراسة مرجعية Benchmark](https://doi.org/10.1016/j.ymssp.2015.04.021?ref=arabroot.io) حللت تسجيلات CWRU بطرق التشخيص المعروفة، لكي يعرف الباحثون ما الذي يمكن تشخيصه فعلاً في كل تسجيل قبل أن يقارنوا نماذجهم عليها. فاستخدم هذه البيانات لتتعلم المسار وتختبر الكود، ثم اجمع بيانات من مضخاتك أنت قبل أن تعتمد أي رقم.

## الأدوات Tools: من TFLite Micro إلى المنصات الجاهزة

ما فعلناه في المختبر هو الطريق اليدوي الكامل، وهو أفضل طريقة لتفهم ما يحدث، ولكن في المشاريع الحقيقية ستجد أدوات تختصر جزءاً منه، وفيما يلي أشهرها:

- **TensorFlow Lite Micro وLiteRT**: المفسر الذي استخدمناه، مفتوح المصدر برخصة Apache 2.0، ويعمل على Cortex-M وESP32 وغيرها، وأداة التحويل في TensorFlow. نقاط القوة: مجاني ومفتوح ومعروف، ونفس النموذج يعمل على الحاسب والمتحكم. نقاط الضعف: البناء يدوي كما رأيت، والتوثيق موزع بين موقع Google ومستودع GitHub.
- **CMSIS-NN**: مكتبة النوى المحسنة من Arm، ويستخدمها TFLM تلقائياً بالخيار `OPTIMIZED_KERNEL_DIR=cmsis_nn`، ويمكن استخدامها وحدها من C مباشرة، وتوثيقها في [موقع CMSIS-NN](https://arm-software.github.io/CMSIS-NN/latest/?ref=arabroot.io).
- **Edge Impulse**: منصة تجمع البيانات من الجهاز وتدرب وتكمم وتولد مكتبة C جاهزة، وفيها كتل جاهزة لمعالجة الاهتزاز وكشف الشذوذ، كما في [توثيقها](https://docs.edgeimpulse.com/?ref=arabroot.io). نقاط القوة: أسرع طريق من البيانات إلى جهاز يعمل. نقاط الضعف: منصة سحابية لشركة، فبياناتك تمر عبرها، وبعض الخصائص مدفوعة.
- **أدوات الشركات المصنعة**: ST تقدم [ST Edge AI Core](https://www.st.com/en/development-tools/stedgeai-core.html?ref=arabroot.io) الذي يحول النموذج إلى كود محسن لشرائح STM32 ويقدر الذاكرة والزمن قبل أن تشتري اللوحة، وNXP تقدم بيئة [eIQ](https://www.nxp.com/design/design-center/software/eiq-ml-development-environment:EIQ?ref=arabroot.io) لشرائحها. نقاط القوة: تحسين خاص بالشريحة وتقدير مسبق للذاكرة. نقاط الضعف: تربطك بشرائح شركة واحدة.
- **المعالجات الأحدث**: Arm أضافت إلى Cortex-M55 وCortex-M85 تقنية [Helium](https://www.arm.com/technologies/helium?ref=arabroot.io)، وهي امتداد المتجهات M-Profile Vector Extension للمعمارية Armv8.1-M، وتذكر Arm أنها ترفع أداء التعلم الآلي حتى 15 مرة ومعالجة الإشارة حتى 5 مرات، كما توجد شرائح تضيف بجانب المعالج وحدة NPU صغيرة من عائلة Ethos-U. وقد شرحنا الفرق بين CPU وNPU في [مقال GPU وNPU وTPU](https://arabroot.io/articles/gpu-%D9%88-npu-%D9%88-tpu-%D9%84%D9%85%D8%A7%D8%B0%D8%A7-%D9%84%D8%A7-%D9%8A%D9%83%D9%81%D9%8A-cpu-%D9%84%D9%84%D8%B0%D9%83%D8%A7%D8%A1-%D8%A7%D9%84%D8%A7%D8%B5%D8%B7%D9%86%D8%A7%D8%B9%D9%8A/). ونفس كود TFLM الذي كتبناه يعمل على هذه الشرائح، والفرق في النوى التي تختارها عند البناء.

## متى تختار ماذا؟ جدول القرار Decision Table

| الوضع                                         | الخيار الأنسب                         | والسبب                                                |
| --------------------------------------------- | ------------------------------------- | ----------------------------------------------------- |
| بداية المشروع ولا تعرف شكل الإشارة بعد        | اجمع الإشارة الخام إلى السيرفر        | لا يمكنك أن تختار نافذة أو نموذجاً لإشارة لم ترها     |
| العطل واضح في الطاقة أو التفرطح               | عتبة على RMS أو Kurtosis في الكود     | عشرة أسطر C بدون نموذج، وكما رأينا تكشف أغلب الأعطال  |
| لا توجد بيانات أعطال من الموقع                | كشف الشذوذ بمشفر تلقائي على السليم    | يتعلم من السليم فقط ويكشف ما لم يره                   |
| تحتاج أن تعرف نوع العطل وعندك أمثلة كافية منه | مصنف صغير، مع كشف شذوذ بجانبه         | المصنف يسمي العطل، والكاشف يحميك من العطل الذي لم يره |
| الجهاز على بطارية والشبكة ضعيفة               | القرار على الجهاز ورسالة صغيرة        | الراديو أغلى من الحساب، والنافذة كل دقيقة تكفي        |
| معالج Cortex-M4 أو M7                         | TFLM مع CMSIS-NN بتكميم int8 كامل     | أسرع بـ 4.6 مرة في المختبر بنفس البايتات              |
| معالج بدون تعليمات DSP مثل Cortex-M0+         | نموذج أصغر أو خصائص بدل الإشارة الخام | كل عملية ضرب بتعليمة منفصلة، فالحساب أبطأ بكثير       |
| نموذج يتغير كثيراً                            | نموذج في قسم فلاش مستقل يحدث عبر OTA  | تحدث 12 KB بدل البرنامج كله                           |

## أخطاء شائعة Common Mistakes

| الخطأ                                        | ما تراه                                         | الحل                                                     |
| -------------------------------------------- | ----------------------------------------------- | -------------------------------------------------------- |
| تقسيم النوافذ عشوائياً بين التدريب والاختبار | دقة عالية في المختبر وفشل في الموقع             | اقسم بالتسجيل أو الحمولة أو الجهاز، كما فعلنا بالحمولة 3 |
| قراءة أول مصفوفة في ملف .mat                 | تسجيل يتكرر بدل آخر، كما في 99.mat              | اختر المصفوفة باسمها ورقم التسجيل                        |
| بيانات معايرة لا تحتوي الحالات القوية        | فئة كاملة دقتها صفر بدون أي رسالة               | عاير بكل المدى، أو حدد مقياس المدخل من مواصفات الحساس    |
| تحويل بدون بيانات معايرة                     | Hybrid models are not supported on TFLite Micro | تكميم int8 كامل مع مدخل ومخرج int8                       |
| ساحة صغيرة أو بدون قياس                      | Failed to allocate tail memory                  | اطبع arena\_used\_bytes() على الجهاز وأضف هامشاً         |
| عملية ناقصة في محلل العمليات                 | Didn't find op for builtin opcode               | قارن عمليات .tflite بقائمة البرنامج في CI                |
| بناء المكتبة بـ BUILD\_TYPE=release          | undefined reference to MicroPrintf أو جهاز صامت | release\_with\_logs أثناء التطوير                        |
| مقارنة مخرج المتحكم بمخرج حاسب يعمل بمسرع    | فروق صغيرة تبدو كخطأ                            | قارن بـ LiteRT بالنوى المرجعية أو بـ TFLM على الحاسب     |
| الوثوق بعداد DWT في المحاكي                  | cycles 0 وتحذير non existing peripheral         | عد التعليمات في Renode، والدورات على اللوحة              |
| إنذار من نافذة واحدة                         | إنذارات كاذبة يومية يتجاهلها الفريق             | قرار على عدة نوافذ، وإرسال الخطأ نفسه لمتابعة الاتجاه    |
| نموذج لا يحدث بعد التركيب                    | إنذارات كاذبة تزيد مع تغير الحمولة والفصول      | جمع بيانات سليمة من كل جهاز وتحديث عبر OTA               |

## تدريب عملي Practice

- غير طول النافذة في `train.py` إلى 512 عينة، وعدل الطبقة الأولى بحسب ذلك، ثم قارن الدقة وعدد التعليمات في Renode وحجم الساحة.
- أضف إلى `anomaly.py` قراراً على عدة نوافذ: إنذار فقط إذا كانت ست نوافذ من ثماني متتالية فوق العتبة، وقس الإنذار الكاذب عند الحمولة 3 قبل التحديث.
- حول المشفر التلقائي إلى int8 بنفس طريقة المصنف، وشغله في TFLM على الحاسب، وقارن حجمه وساحته بالمصنف.
- ابن البرنامج للهدف `TARGET_ARCH=cortex-m0plus` بالنوى المرجعية، وشغله على لوحة تحاكيها Renode بمعالج Cortex-M0+، وقارن عدد التعليمات بنتيجة Cortex-M4.

## حذف المختبر Cleanup

المختبر يترك Docker Image بحجم كبير بسبب TensorFlow، وVolume فيه مصدر TFLM المبني، ولحذفها:

```bash
docker rmi elm-ml-py:1 elm-ml-fw:1
docker volume rm elm-ml-src
```

## الخلاصة Summary

وصلنا لنهاية الموضوع، وأهم ما فيه:

- TinyML ينقل القرار إلى الجهاز، فبدل 2.07 GB في اليوم من حساس اهتزاز واحد ترسل رسالة صغيرة كل دقيقة، ومعها زمن استجابة أقل وخصوصية وعمل بدون شبكة.
- المتحكم أصغر بمئات المرات من الجوال، فالنموذج يجب أن يصمم للفلاش والذاكرة من البداية: نموذجنا 3,516 معاملاً و12,848 بايتاً بعد التكميم، وساحته 6,692 بايتاً على Cortex-M4.
- التكميم int8 الكامل يحتاج بيانات معايرة تمثل كل المدى، والمعايرة بالمحرك السليم فقط أسقطت فئة كاملة إلى صفر بدون أي رسالة.
- TFLM مفسر يقرأ النموذج من الفلاش ويحسب في ساحة ثابتة بعمليات تختارها، وأعطى على المتحكم نفس البايتات التي أعطاها LiteRT على الحاسب.
- نوى CMSIS-NN كانت أسرع بـ 4.6 مرة من المرجعية، 935,782 تعليمة مقابل 4,335,705، مقابل 33 KB إضافية في الفلاش، وبعدها صار جمع النافذة أغلى من الاستدلال نفسه.
- المصنف بدقة 100% على الحمولة الجديدة سقط إلى 20.2% أمام عطل أكبر لم يره، وكشف الشذوذ على السليم فقط كشف كل الأعطال، ولكنه أطلق إنذارات كاذبة عند حمولة جديدة حتى أضفنا بياناتها، وهذا هو الانجراف الذي يجعل التحديث عبر OTA جزءاً من التصميم.

وبهذا تكتمل مرحلة [البرمجيات المدمجة Firmware](https://arabroot.io/start/#stage-elec-firmware). وهذه مقالات تكمل ما بنينا عليه، من المعالج الذي شغلنا عليه النموذج إلى طرق نقل القرار من الجهاز:

[![](https://arabroot.io/content/images/2026/11/stm32-arm-cortex-cover-cover-2.webp)دليلمن Arduino إلى STM32: معالجات Arm Cortex-M في الصناعةما الذي يتغير عندما تنتقل من Arduino إلى STM32: الترخيص وعائلة Cortex-M والساعات وRCC وNVIC وطبقات HAL وLL وlibopencm3، مع مختبر في Renode يقيس الحجم ويدخل إلى المقاطعة بـ GDB.](https://arabroot.io/articles/%D8%A7%D9%84%D8%A7%D9%86%D8%AA%D9%82%D8%A7%D9%84-%D9%85%D9%86-arduino-%D8%A7%D9%84%D9%89-stm32-%D9%88%D9%85%D8%B9%D8%A7%D9%84%D8%AC%D8%A7%D8%AA-arm-cortex-m/)[![](https://arabroot.io/content/images/2026/11/low-power-design-cover-cover-1.webp)دليلتصميم الأجهزة قليلة الاستهلاك Low Power: عمر البطاريةنقيس في Renode متى ينام المعالج ومتى يستيقظ، ثم نحول القياس إلى عمر بطارية بأرقام أوراق بيانات TI، ونرى كيف ينقل سطر واحد عمر الجهاز من سنوات إلى أيام.](https://arabroot.io/articles/%D8%AA%D8%B5%D9%85%D9%8A%D9%85-%D8%A7%D9%84%D8%A7%D8%AC%D9%87%D8%B2%D8%A9-%D9%82%D9%84%D9%8A%D9%84%D8%A9-%D8%A7%D9%84%D8%A7%D8%B3%D8%AA%D9%87%D9%84%D8%A7%D9%83-low-power-%D8%B9%D9%85%D8%B1-%D8%A7%D9%84%D8%A8%D8%B7%D8%A7%D8%B1%D9%8A%D8%A9/)[![](https://arabroot.io/content/images/2026/11/ota-updates-cover-cover-1.webp)دليلتحديث الأجهزة عن بعد OTA دون أن تتعطلنرسل سبعة تحديثات إلى برنامج ESP32 حقيقي في محاكي QEMU، فنرى التوقيع ورفض الرجوع إلى نسخة أقدم والرجوع التلقائي يعمل، ونرى الخطأ الذي لا ينقذك منه إلا السلك.](https://arabroot.io/articles/%D8%AA%D8%AD%D8%AF%D9%8A%D8%AB-%D8%A7%D9%84%D8%A7%D8%AC%D9%87%D8%B2%D8%A9-%D8%B9%D9%86-%D8%A8%D8%B9%D8%AF-ota-%D8%AF%D9%88%D9%86-%D8%A7%D9%86-%D8%AA%D8%AA%D8%B9%D8%B7%D9%84/)[![](https://arabroot.io/content/images/2026/11/embedded-debugging-cover-cover-1.webp)دليلتصحيح البرامج المدمجة Debugging مع GDB ثم Renodeنزرع في برنامج مسجل حرارة ثلاثة أخطاء حقيقية ونشخصها بـ GDB على QEMU ثم Renode، بنقاط المراقبة وإطار الاستثناء ومسجلات العطل، ثم نكتب اختبارات Renode تمنع عودتها.](https://arabroot.io/articles/%D8%AA%D8%B5%D8%AD%D9%8A%D8%AD-%D8%A7%D9%84%D8%A8%D8%B1%D8%A7%D9%85%D8%AC-%D8%A7%D9%84%D9%85%D8%AF%D9%85%D8%AC%D8%A9-debugging-%D9%85%D8%B9-gdb-%D8%AB%D9%85-renode/)[![](https://arabroot.io/content/images/2026/11/sensors-motors-interfacing-cover-cover-2.webp)دليلربط الحساسات والمحركات بالمتحكم Interfacingما يحدث بين رجل المتحكم والحساس أو المحرك: دقة المحول والضجيج وفرق 5 و3.3 فولت، وBME280 ومعادلته، وحدود التيار، وServo وDRV8833 وA4988 مقاسة على الأرجل في مختبر حقيقي.](https://arabroot.io/articles/%D8%B1%D8%A8%D8%B7-%D8%A7%D9%84%D8%AD%D8%B3%D8%A7%D8%B3%D8%A7%D8%AA-%D9%88%D8%A7%D9%84%D9%85%D8%AD%D8%B1%D9%83%D8%A7%D8%AA-%D8%A8%D8%A7%D9%84%D9%85%D8%AA%D8%AD%D9%83%D9%85-%D9%85%D9%86-adc-%D8%A7%D9%84%D9%89-a4988/)[![](https://arabroot.io/content/images/2026/11/wireless-iot-protocols-cover-cover-2.webp)دليلبروتوكولات الاتصال اللاسلكي: BLE وZigbee وThread وLoRaWANكيف تختار راديو جهاز إنترنت الأشياء وبروتوكول التطبيق فوقه، مع قراءة واحدة أرسلناها عبر MQTT وCoAP وLwM2M والتقطنا كل بايت منها، ثم إطار LoRaWAN حقيقي وزمن بثه من SF7 إلى SF12.](https://arabroot.io/articles/%D8%A8%D8%B1%D9%88%D8%AA%D9%88%D9%83%D9%88%D9%84%D8%A7%D8%AA-%D8%A7%D9%84%D8%A7%D8%AA%D8%B5%D8%A7%D9%84-%D8%A7%D9%84%D9%84%D8%A7%D8%B3%D9%84%D9%83%D9%8A-%D9%84%D8%A7%D9%86%D8%AA%D8%B1%D9%86%D8%AA-%D8%A7%D9%84%D8%A7%D8%B4%D9%8A%D8%A7%D8%A1-ble-%D8%AB%D9%85-zigbee-%D9%85%D8%B9-lorawan/)[![](https://arabroot.io/content/images/2026/11/ml-basics-cover-cover.webp)دليلالتعلم الآلي Machine Learning للمبتدئينكيف تتعلم الآلة القواعد من الأمثلة، وكيف تعرف أن النموذج تعلم فعلاً ولم يحفظ الإجابات، ومتى تختار كل خوارزمية.](https://arabroot.io/articles/%D8%A7%D9%84%D8%AA%D8%B9%D9%84%D9%85-%D8%A7%D9%84%D8%A7%D9%84%D9%8A-machine-learning-%D9%84%D9%84%D9%85%D8%A8%D8%AA%D8%AF%D8%A6%D9%8A%D9%86/)[![](https://arabroot.io/content/images/2026/11/gpu-npu-cover-cover.webp)دليلGPU وNPU وTPU: لماذا لا يكفي CPU للذكاء الاصطناعي؟نضرب نفس المصفوفات على المعالج وعلى المعالج الرسومي المدمج ونقيس الحساب وسرعة الذاكرة، لنفهم ما الذي يجعل GPU وNPU وTPU أسرع ومتى لا تفيد.](https://arabroot.io/articles/gpu-%D9%88-npu-%D9%88-tpu-%D9%84%D9%85%D8%A7%D8%B0%D8%A7-%D9%84%D8%A7-%D9%8A%D9%83%D9%81%D9%8A-cpu-%D9%84%D9%84%D8%B0%D9%83%D8%A7%D8%A1-%D8%A7%D9%84%D8%A7%D8%B5%D8%B7%D9%86%D8%A7%D8%B9%D9%8A/)

## سجل التحديثات Changelog

- نوفمبر 2026: كتابة المقال، وتشغيل المختبر على بيانات CWRU بـ TensorFlow 2.21.0 وLiteRT 2.3.0 وTFLite Micro (حزمة Python بتاريخ 19 نوفمبر 2026، والمصدر على commit 38a8f0f)، ثم بناء TFLM لمعالج Cortex-M4 بـ arm-none-eabi-gcc 14.2.1 مع CMSIS-NN وبدونها، وتشغيله على STM32F407 في Renode 1.17.0، على Docker Engine 29.8.0.