Silicon Labs នាំយក AI និង Machine Learning សៀវភៅណែនាំអ្នកប្រើប្រាស់

ផ្នែកបន្ថែមការរៀនម៉ាស៊ីន SDK កំណែ 2.1.1 (ត្រូវបានគេស្គាល់ផងដែរថាជា
Silicon Labs AI/ML) គឺជាផ្នែកបន្ថែមទៅកាន់ Simplicity SDK នោះ។
បើកដំណើរការការអភិវឌ្ឍន៍ AI/ML នៅលើឧបករណ៍ស៊េរី 2 និង SiWG917 ដោយប្រើ
Tensorflow Lite សម្រាប់ក្របខ័ណ្ឌ Microcontrollers ។

សេចក្តីណែនាំអំពីការប្រើប្រាស់៖

ការចាប់ផ្តើម៖

ទាញយក និងដំឡើង Simplicity Studio ។
ដំឡើងកម្មវិធី Machine Learning Extension SDK កំណែ 2.1.1 ។
សូមមើលឯកសារអ្នកអភិវឌ្ឍន៍សម្រាប់ការណែនាំអំពីការដំឡើង
គម្រោង និងការប្រើប្រាស់គំរូ AI/ML។

កម្មវិធីចាត់ថ្នាក់រូបភាព៖

SDK រួមបញ្ចូលឧបករណ៍ចាត់ថ្នាក់រូបភាព (Rock-Paper-Scissors)
កម្មវិធីសម្រាប់ឧបករណ៍ xG24 និង xG26 ។ ដើម្បីប្រើរូបភាព
អ្នកចាត់ថ្នាក់៖

អនុវត្តតាមការបង្រៀនដែលមាននៅក្នុងឯកសារ។
ត្រូវប្រាកដថាការកំណត់គម្រោងរបស់អ្នកត្រូវបានកំណត់យ៉ាងត្រឹមត្រូវសម្រាប់
ឧបករណ៍ដែលបានជ្រើសរើស។

ការផ្លាស់ប្តូរ API៖

SDK ណែនាំ APIs ថ្មីសម្រាប់ការហៅគំរូ និងការប្រតិបត្តិ
សម្រាប់គ្រួសារបន្ទះឈីប SiWG917 ។ ដើម្បីប្រើប្រាស់ APIs ទាំងនេះ៖

ធ្វើបច្ចុប្បន្នភាពលេខកូដរបស់អ្នកដើម្បីបញ្ចូលការហៅ API ថ្មី។
សូមមើលឯកសារ API សម្រាប់ព័ត៌មានលម្អិតនៅលើ
ការប្រើប្រាស់ APIs ទាំងនេះ។

សំណួរគេសួរញឹកញាប់៖

សំណួរ៖ តើឧបករណ៍អ្វីខ្លះដែលត្រូវបានគាំទ្រដោយផ្នែកបន្ថែមការរៀនម៉ាស៊ីន
SDK កំណែ 2.1.1?

A: SDK គាំទ្រឧបករណ៍ស៊េរី 2 និង SiWG917 សម្រាប់ AI/ML
ការអភិវឌ្ឍន៍។

សំណួរ៖ តើអ្វីជាលក្ខណៈសំខាន់ៗដែលបានបន្ថែមនៅក្នុងកំណែ 2.1.1 នៃ
ផ្នែកបន្ថែម SDK?

ចម្លើយ៖ មុខងារសំខាន់ដែលបានបន្ថែមគឺកម្មវិធីចាត់ថ្នាក់រូបភាពថ្មី។
កម្មវិធី (Rock-Paper-Scissors) និងការបង្រៀនសម្រាប់ xG24 និង xG26
ឧបករណ៍។

“`

View Fullscreen

ការរៀនម៉ាស៊ីន
ការរៀនម៉ាស៊ីន
ការបង្កើតជាមួយនឹងការចាប់ផ្តើមកំណត់ចំណាំការចេញផ្សាយ Machine Learning
ការចាប់ផ្តើមជាមួយនឹង Machine Learning Tensorflow Lite Micro ពី Scratch Voice Control Light ពី Scratch Voice Control Light Demo Fundamentals Machine Learning Fundamentals MVP Accelerator Developers Guide Machine Learning Developers Guide Add Machine Learning to a New or Existing project update or Replace a .tflite File បង្កើតគំរូ AI/ML Extension Setup Flatbuffer Converter Tool I2S for SiWx917 Machine Learning API Reference Microphone I2S Driver for Machine Learning Model Specific Functions Model Specific Audio Variables and Constants Audio Feature Generator Image Feature Generator TensorFlow Lite Micro Debug TensorFlow Lite References Micro Initition Machine Learning APIampកម្មវិធី
ជាងview ចំណាត់ថ្នាក់រូបភាព ឧបករណ៍ភាគីទីបី និងដំណោះស្រាយ

៥/៥

ការអភិវឌ្ឍន៍ជាមួយ Machine Learning
ការអភិវឌ្ឍន៍ជាមួយ Machine Learning
ការអភិវឌ្ឍន៍ជាមួយ Silicon Labs Machine Learning (AI/ML)
ការរៀនម៉ាស៊ីនគឺជាសំណុំរងនៃបញ្ញាសិប្បនិមិត្ត (AI) ដែលអាចឱ្យប្រព័ន្ធរៀនពីទិន្នន័យ និងកែលម្អដំណើរការរបស់ពួកគេដោយមិនចាំបាច់មានកម្មវិធីច្បាស់លាស់។ វាពាក់ព័ន្ធនឹងក្បួនដោះស្រាយដែលកំណត់អត្តសញ្ញាណគំរូ និងធ្វើការសម្រេចចិត្តដោយផ្អែកលើទិន្នន័យបញ្ចូល។ ការរៀនជ្រៅជ្រះ ដែលជាសាខាឯកទេសនៃការរៀនម៉ាស៊ីនប្រើបណ្តាញសរសៃប្រសាទដែលមានស្រទាប់ជាច្រើនដើម្បីធ្វើគំរូគំរូស្មុគស្មាញ និងសម្រេចបាននូវភាពត្រឹមត្រូវខ្ពស់ក្នុងកិច្ចការដូចជាការសម្គាល់រូបភាព និងការនិយាយជាដើម។ ជាមួយគ្នានេះ បច្ចេកវិទ្យាទាំងនេះផ្តល់ថាមពលដល់កម្មវិធីទំនើបៗជាច្រើន ចាប់ពីប្រព័ន្ធណែនាំ រហូតដល់រថយន្តស្វយ័ត។ ជាផ្នែកមួយនៃវិស័យ AI កាន់តែទូលំទូលាយ ការរៀនម៉ាស៊ីន និងការរៀនស៊ីជម្រៅ គឺជាគន្លឹះក្នុងការបង្កើតប្រព័ន្ធដែលអាចសម្របខ្លួន ហេតុផល និងធ្វើសកម្មភាពប្រកបដោយភាពឆ្លាតវៃ។

៥/៥

ការអភិវឌ្ឍន៍ជាមួយ Machine Learning

បច្ចុប្បន្ន Silicon Labs គាំទ្រ TensorFlow Lite សម្រាប់ Microcontrollers (TFLM) និងកម្មវិធីដែលពាក់ព័ន្ធជាផ្នែកបន្ថែមទៅ SiSDK ។

៥/៥

ការអភិវឌ្ឍន៍ជាមួយ Machine Learning
ខ្លឹមសារនៅលើទំព័រទាំងនេះគឺមានបំណងសម្រាប់អ្នកដែលចង់ពិសោធន៍ ឬកំពុងបង្កើតកម្មវិធី Machine Learning រួចហើយដោយប្រើបច្ចេកវិទ្យា Silicon Labs។ សម្រាប់ព័ត៌មានផលិតផល Silicon Labs Machine Learning៖ សូមមើលទំព័រផលិតផលនៅលើ silabs.com ។ សម្រាប់ផ្ទៃខាងក្រោយលើការរៀនម៉ាស៊ីន៖ ផ្នែកមូលដ្ឋានគ្រឹះគឺជាកន្លែងដ៏ល្អដើម្បីចាប់ផ្តើម។ ដើម្បីចាប់ផ្តើមជាមួយការអភិវឌ្ឍន៍៖ សូមមើលផ្នែកចាប់ផ្តើម ដើម្បីចាប់ផ្តើមធ្វើការជាមួយអតីតampកម្មវិធីឡេ។ ប្រសិនបើអ្នកកំពុងស្ថិតក្នុងការអភិវឌ្ឍន៍រួចហើយ៖ សូមមើលការណែនាំរបស់អ្នកអភិវឌ្ឍន៍។ ប្រសិនបើអ្នកកំពុងប្រើ Machine Learning SDK កំណែ 1.3.x ឬមុននេះ៖ សូមមើលការណែនាំអំពីការដំឡើងផ្នែកបន្ថែម AI/ML ដើម្បីផ្លាស់ប្តូរពី v1.x ទៅ v2.x នៃ AI/ML SDK ។ កំណែមុននេះត្រូវបានគាំទ្រជាផ្នែកទន់នៃ SiSDK ជង់ត្រូវបានផ្លាស់ប្តូរទៅជាផ្នែកបន្ថែមឥឡូវនេះ។ សម្រាប់ Silicon Labs AI/ML Extension Source Code៖ សូមមើលតំណភ្ជាប់ AI/ML Extension ទៅ GitHub ។

៥/៥

ការរៀនម៉ាស៊ីន

ការរៀនម៉ាស៊ីន (Silicon Labs AI/ML) ផ្នែកបន្ថែម SDK កំណែ 2.1.1 (ថ្ងៃទី 23 ខែកក្កដា ឆ្នាំ 2025) – កំណត់ចំណាំចេញផ្សាយ
ភាពសាមញ្ញ SDK កំណែ 2025.6.1 ផ្នែកបន្ថែមការរៀនម៉ាស៊ីនត្រូវបានគេស្គាល់ផងដែរថាជា "Silicon Labs AI/ML" ហើយត្រូវបានផ្តល់ជាផ្នែកបន្ថែមដល់ Simplicity SDK ។ វាអនុញ្ញាតឱ្យមានការអភិវឌ្ឍន៍ AI/ML នៅលើឧបករណ៍ស៊េរី 2 និង SiWG917 ដោយប្រើក្របខ័ណ្ឌ Tensorflow Lite for Microcontrollers (TFLM) ។ ចុចទីនេះសម្រាប់ការចេញផ្សាយមុននេះ។
សេចក្តីសង្ខេបនៃការចេញផ្សាយ
លក្ខណៈសំខាន់ៗ | ការផ្លាស់ប្តូរ API | កែកំហុស | ការបើកដំណើរការបន្ទះឈីប
លក្ខណៈសំខាន់ៗ
បានបន្ថែមក្នុង 2.1.1 បានបន្ថែមកម្មវិធីចំណាត់ថ្នាក់រូបភាពថ្មី (Rock-Paper-Scissors) និងការបង្រៀនសម្រាប់ឧបករណ៍ xG24 និង xG26។ ជួសជុលកំហុសនៅពេលបង្កើតគម្រោងដោយប្រើមុខងារ "ចម្លងមាតិកា" នៅក្នុង Simplicity Studio។
បានបន្ថែមនៅក្នុង 2.1.0 កូដប្រភពបានផ្លាស់ទីទៅផ្នែកបន្ថែម។ ផ្នែកបន្ថែម AI/ML ឥឡូវនេះមានជាទូទៅ (GA) វាត្រូវបានចេញផ្សាយជាទម្រង់អាល់ហ្វាមុននេះ។ បានបន្ថែមការគាំទ្រសម្រាប់គ្រួសារបន្ទះឈីប SiWG917 តាមរយៈការបង្កើនប្រសិទ្ធភាពកម្មវិធី។ ឯកសារអ្នកអភិវឌ្ឍន៍ Machine Learning (AI/ML) ត្រូវបានរៀបចំឡើងវិញ។
ការផ្លាស់ប្តូរ API
បានផ្លាស់ប្តូរនៅក្នុង 2.1.1 គ្មាន។
បានផ្លាស់ប្តូរនៅក្នុង 2.1.0 APIs ថ្មីសម្រាប់ការហៅគំរូ និងការប្រតិបត្តិសម្រាប់គ្រួសារបន្ទះឈីប SiWG917។ អថេរថ្មីសម្រាប់អន្តរកម្មជាមួយគំរូ ML ។
កែកំហុស
បានជួសជុលនៅក្នុង 2.1.1 កំហុសដែលបានជួសជុលនៅពេលបង្កើតគម្រោងដោយប្រើមុខងារ "ចម្លងមាតិកា" នៅក្នុង Simplicity Studio ។
ជួសជុលក្នុង 2.1.0 ជួសជុលការលេចធ្លាយអង្គចងចាំរបស់មីក្រូហ្វូន នៅពេលដែលម៉ូដែលមិនផ្ទុកត្រឹមត្រូវ។
ការបើកដំណើរការបន្ទះឈីប
បានបន្ថែមក្នុង 2.1.1 គ្មាន។

៥/៥

ការរៀនម៉ាស៊ីន
បានបន្ថែមក្នុង 2.1.0 EFR32xG2x SiWG917
លក្ខណៈសំខាន់ៗ
លក្ខណៈពិសេសថ្មី | ការលើកកំពស់ | លក្ខណៈពិសេសដែលបានដកចេញ | លក្ខណៈពិសេសដែលបានបដិសេធ
ចំណាំ៖ មើល Feature Matrix សម្រាប់បញ្ជី APIs ដែលអាចអនុវត្តបាន ឧamples, software variants, modes, hardware, and host interfaces អាចអនុវត្តបានសម្រាប់លក្ខណៈពិសេសនីមួយៗ។
លក្ខណៈពិសេសថ្មី។
បានបន្ថែមនៅក្នុងកម្មវិធី 2.1.1 Image Classifier (Rock-Paper-Scissors) កម្មវិធី និងការបង្រៀនសម្រាប់ឧបករណ៍ xG24 និង xG26 សូមមើលចំណាត់ថ្នាក់រូបភាព
បានបន្ថែមនៅក្នុង 2.1.0 កូដប្រភពបានផ្លាស់ប្តូរទៅផ្នែកបន្ថែម AI/ML ។ កម្មវិធីអូឌីយ៉ូត្រូវបានបើកសម្រាប់គ្រួសារបន្ទះឈីប SiWG917 សូមមើល Audio Classifier និង Voice Control Light exampកម្មវិធីសម្រាប់ SiWG917 ។ APIs ថ្មីត្រូវបានបន្ថែមសម្រាប់ការហៅគំរូ និងការប្រតិបត្តិសម្រាប់គ្រួសារបន្ទះឈីប SiWG917 សូមមើលការផ្លាស់ប្តូរ API សម្រាប់ព័ត៌មានលម្អិត។ ឯកសារអ្នកអភិវឌ្ឍន៍ Machine Learning (AI/ML) ត្រូវបានរៀបចំឡើងវិញហើយ revamped ទាំងស្រុងដើម្បីធ្វើឱ្យវាចុះសម្រុងគ្នាជាមួយនឹងការអនុវត្តល្អបំផុតនៃឯកសារ ពិនិត្យមើលផ្លូវថ្មីនៅក្នុងឯកសារ។
ការលើកកម្ពស់
បានបន្ថែមនៅក្នុង 2.1.1 ជួសជុលកំហុសនៅពេលបង្កើតគម្រោងដោយប្រើមុខងារ "ចម្លងមាតិកា" នៅក្នុង Simplicity Studio ។
បានបន្ថែមនៅក្នុង 2.1.0 មានតែមុខងារថ្មីៗប៉ុណ្ណោះដែលត្រូវបានបន្ថែមនៅក្នុងការចេញផ្សាយនេះ។ គ្មានការកែលម្អត្រូវបានធ្វើឡើងចំពោះមុខងារដែលមានស្រាប់នោះទេ។
លក្ខណៈពិសេសដែលបានលុប
គ្មាន។
លក្ខណៈពិសេសដែលត្រូវបានបដិសេធ
គ្មាន។
ការផ្លាស់ប្តូរ API
APIs ថ្មី | APIs ដែលបានកែប្រែ | APIs ដែលត្រូវបានដកចេញ | APIs ដែលបានបដិសេធ
APIs ថ្មី
បានបន្ថែមក្នុង 2.1.1 គ្មាន។
បានបន្ថែមនៅក្នុង 2.1.0

៥/៥

ការរៀនម៉ាស៊ីន
ហត្ថលេខា API ថ្មី sl_status_t sl_ml_ _model_init() sl_status_t sl_ml_ _model_run() ឋិតិវន្ត TfliteMicroModel _គំរូឋិតិវន្ត sl_status_t _model_status uint8_t* _model_flatbuffer const int _model_flatbuffer_length
APIs ដែលបានកែប្រែ
គ្មាន។
APIs ដែលត្រូវបានដកចេញ
គ្មាន។
APIs ដែលបានបដិសេធ
គ្មាន។
កែកំហុស
ជួសជុលក្នុង 2.1.1

ការពិពណ៌នាបញ្ហា

1479968

ជួសជុលកំហុសនៅពេលបង្កើតគម្រោងដោយប្រើមុខងារ "ចម្លងមាតិកា" នៅក្នុង Simplicity Studio។

Deprecated API ជំនួសដោយនេះ (ប្រសិនបើមាន) គ្មាន គ្មាន គ្មាន គ្មាន គ្មាន គ្មាន គ្មាន គ្មាន

GitHub / Salesforce យោង (ប្រសិនបើមាន) គ្មានទេ។

វ៉ារ្យ៉ង់កម្មវិធីដែលរងផលប៉ះពាល់, ផ្នែករឹង, របៀប, ចំណុចប្រទាក់ម៉ាស៊ីន
ស្តង់ដារ EFR32xG2x, SiWG917 SoC

ជួសជុលក្នុង 2.1.0

ការពិពណ៌នាបញ្ហា

1452807

ការលេចធ្លាយអង្គចងចាំនៅក្នុង sl_ml_audio_feature_generation_init() ដោយសារតែបាត់ការសម្អាតធនធាន។

GitHub / Salesforce យោង (ប្រសិនបើមាន) គ្មានទេ។

វ៉ារ្យ៉ង់កម្មវិធីដែលរងផលប៉ះពាល់, ផ្នែករឹង, របៀប, ចំណុចប្រទាក់ម៉ាស៊ីន
ស្តង់ដារ EFR32xG2x SoC

ការបើកដំណើរការបន្ទះឈីប

បានបន្ថែមក្នុង 2.1.1 គ្មាន។
បានបន្ថែមនៅក្នុង 2.1.0

ឈីបគ្រួសារ

OPNs / Boards / OPN រួមបញ្ចូលគ្នា
OPN៖ EFR32xG2x, SiWG917x Boards: BRD2601b, BRD2608a, BRD2605a, BRD2705a ម៉ាស៊ីនខាងក្រៅ៖ N/A

វ៉ារ្យ៉ង់កម្មវិធីដែលគាំទ្រ (ប្រសិនបើមាន) ស្តង់ដារ

របៀបដែលគាំទ្រ

ចំណុចប្រទាក់ម៉ាស៊ីនដែលគាំទ្រ

SoC

៥/៥

ការរៀនម៉ាស៊ីន

កម្មវិធី Exampការផ្លាស់ប្តូរ
អតីតថ្មីamples | កែប្រែ Examples | បានដក Examples | បដិសេធ Examples
អតីតថ្មីamples
បានបន្ថែមនៅក្នុង 2.1.1

Exampការពិពណ៌នាឈ្មោះ

ឧបករណ៍ចាត់ថ្នាក់រូបភាព (RockPaperScissors)
សូមមើល readme.md

កម្មវិធីនេះប្រើ TensorFlow Lite សម្រាប់ Microcontrollers ដើម្បីដំណើរការគំរូនៃការរៀនម៉ាស៊ីនចំណាត់ថ្នាក់រូបភាព ដើម្បីចាត់ថ្នាក់កាយវិការដៃពីទិន្នន័យរូបភាពដែលចាប់យកពីកាមេរ៉ាខាងក្រៅ។ ការរកឃើញត្រូវបានមើលឃើញដោយប្រើ LED នៅលើក្តារ ហើយលទ្ធផលចំណាត់ថ្នាក់ត្រូវបានសរសេរទៅកាន់ច្រកសៀរៀល VCOM ។

វ៉ារ្យ៉ង់កម្មវិធីដែលគាំទ្រ (ប្រសិនបើមាន) ស្តង់ដារ

របៀបដែលគាំទ្រ
SoC

ការរួមបញ្ចូល OPNs / Boards / OPN ដែលគាំទ្រ
OPN៖ EFR32xG2x Boards៖ BRD2601b, BRD2608a ម៉ាស៊ីនខាងក្រៅ៖ N/A

ចំណុចប្រទាក់ម៉ាស៊ីនដែលគាំទ្រ

បានបន្ថែមនៅក្នុង 2.1.0

Exampឈ្មោះឡេ

ការពិពណ៌នា

ឧបករណ៍ចាត់ថ្នាក់សំឡេងសម្រាប់ SiWG917
សូមមើល readme.md
ពន្លឺបញ្ជាសំឡេងសម្រាប់ SiWG917

កម្មវិធីនេះប្រើ TensorFlow Lite សម្រាប់ Microcontrollers ដើម្បីដំណើរការគំរូនៃការរៀនម៉ាស៊ីនចំណាត់ថ្នាក់សំឡេង ដើម្បីចាត់ថ្នាក់ពាក្យពីទិន្នន័យសំឡេងដែលបានកត់ត្រាពីមីក្រូហ្វូន។ ការរកឃើញត្រូវបានមើលឃើញដោយប្រើ LED នៅលើក្តារ ហើយលទ្ធផលចំណាត់ថ្នាក់ត្រូវបានសរសេរទៅកាន់ VCOM serialport។ កម្មវិធីនេះប្រើ TensorFlow Lite សម្រាប់ Microcontrollers ដើម្បីស្វែងរកពាក្យ "បើក" និង "បិទ" ពីទិន្នន័យអូឌីយ៉ូដែលបានកត់ត្រានៅលើមីក្រូហ្វូន។ ពាក្យគន្លឹះដែលបានរកឃើញត្រូវបានប្រើដើម្បីគ្រប់គ្រង LED នៅលើក្តារ។

សូមមើល readme.md

វ៉ារ្យ៉ង់កម្មវិធីដែលគាំទ្រ (ប្រសិនបើមាន) ស្តង់ដារ
ស្តង់ដារ

របៀបដែលគាំទ្រ
SoC
SoC

ការរួមបញ្ចូល OPNs / Boards / OPN ដែលគាំទ្រ
OPN៖ SiWG917x Boards៖ BRD2605a ម៉ាស៊ីនខាងក្រៅ៖ N/A
OPN៖ SiWG917x Boards៖ BRD2605a ម៉ាស៊ីនខាងក្រៅ៖ N/A

ចំណុចប្រទាក់ម៉ាស៊ីនដែលគាំទ្រ

កែប្រែ Examples
គ្មាន។
បានដក Examples
គ្មាន។
បដិសេធ Examples
គ្មាន។

បញ្ហា និងដែនកំណត់ដែលគេស្គាល់

៥/៥

ការរៀនម៉ាស៊ីន

លេខសម្គាល់ 1463269

បញ្ហា ឬការកំណត់ការពិពណ៌នាកម្មវិធី Blink មានឥរិយាបទខុសគ្នានៅពេលដំណើរការលើស៊េរី 2 បើប្រៀបធៀបទៅនឹង SiWG917 ។ LED មានពន្លឺកម្រិតមូលដ្ឋាននៅលើ SiWG917 ខណៈពេលកំពុងភ្លឹបភ្លែតៗ ប៉ុន្តែវាបិទទាំងស្រុងនៅលើស៊េរី 2។ នេះគឺដោយសារតែការអនុវត្តកម្មវិធីបញ្ជា LED ផ្សេងគ្នានៅលើគ្រួសារបន្ទះឈីបទាំងពីរ។

GitHub / Salesforce យោង (ប្រសិនបើមាន) គ្មានទេ។

1463268 សមាសធាតុបង្កើតមុខងារអូឌីយ៉ូបង្ហាញ កំហុសកំណត់រចនាសម្ព័ន្ធ គ្មានសម្រាប់ SiWG917។

1464105

ការហៅ API សម្រាប់ការហៅទូរសព្ទគំរូ និងការប្រតិបត្តិគឺខុសគ្នានៅលើស៊េរី 2 និង SiWG917 គ្រួសារបន្ទះឈីប។

គ្មាន

ដំណោះស្រាយ (ប្រសិនបើមាន)

វ៉ារ្យ៉ង់កម្មវិធីដែលរងផលប៉ះពាល់, ផ្នែករឹង, របៀប, ចំណុចប្រទាក់ម៉ាស៊ីន

ដំណោះស្រាយមិនទាន់ត្រូវបានអនុវត្តនៅឡើយទេ។ បញ្ហានេះកំពុងស្ថិតនៅក្រោមការស៊ើបអង្កេតដើម្បីផ្លាស់ប្តូរពីកម្មវិធី PWM ទៅការអនុវត្តផ្នែករឹង PWM សម្រាប់កម្មវិធីបញ្ជា LED នៅលើ SiWG917 ។
បញ្ហានេះជាបញ្ហាកែសម្ផស្ស ហើយការជួសជុលកំពុងស្ថិតក្រោមការស៊ើបអង្កេតសម្រាប់ការចេញផ្សាយនាពេលអនាគត។ បញ្ហានេះមិនប៉ះពាល់ដល់គម្រោងស៊េរី 2 ទេ។
ស៊េរី 2 ប្រើ
sl_ml_model_init()
, និង
sl_tflite_micro_ge t_interpreter()->ខ្ញុំហៅ()
សម្រាប់ការហៅគំរូ និងការប្រតិបត្តិរៀងៗខ្លួន ចំណែក SiWG917 ប្រើ
sl_ml_ _គំរូ_init()
,
sl_ml_ _model_run()
.

SiWG917M111MGTBA BRD2605a SoC
SiWG917M111MGTBA BRD2605a SoC
SiWG917M111MGTBA BRD2605a SoC

ផលប៉ះពាល់នៃការផ្លាស់ប្តូរការចេញផ្សាយ
សេចក្តីថ្លែងការណ៍ផលប៉ះពាល់ | មគ្គុទ្ទេសក៍ការធ្វើចំណាកស្រុក
សេចក្តីថ្លែងការណ៍អំពីផលប៉ះពាល់
បានបន្ថែមក្នុង 2.1.1 គ្មាន។

បានបន្ថែមនៅក្នុង 2.1.0

ផ្លាស់ប្តូរ
កូដប្រភពបានផ្លាស់ទីទៅផ្នែកបន្ថែម AI/ML

ផលប៉ះពាល់
សមាសភាគបានផ្លាស់ប្តូរពី "ការរៀនម៉ាស៊ីន" ទៅ "ស៊ីលីកុន មន្ទីរពិសោធន៍ AI/ML v2.1.0 > ការរៀនម៉ាស៊ីន"

វ៉ារ្យ៉ង់កម្មវិធីដែលរងផលប៉ះពាល់ ប្រសិនបើស្តង់ដារអាចអនុវត្តបាន។

របៀបដែលរងផលប៉ះពាល់
SoC

ការរួមបញ្ចូល OPNs / Boards / OPN ដែលរងផលប៉ះពាល់
OPN៖ EFR32xG2x, SiWG917x Boards: BRD2601b, BRD2608a, BRD2605a, BRD2705a ម៉ាស៊ីនខាងក្រៅ៖ N/A

ចំណុចប្រទាក់ម៉ាស៊ីនដែលរងផលប៉ះពាល់

មគ្គុទ្ទេសក៍ការធ្វើចំណាកស្រុក

៥/៥

ការរៀនម៉ាស៊ីន

ផ្ទេរទៅផ្នែកបន្ថែម AI/ML

ការប្រើប្រាស់ការចេញផ្សាយនេះ។
តើមានអ្វីនៅក្នុងការចេញផ្សាយ? | កម្មវិធីដែលត្រូវគ្នា | ការដំឡើង និងប្រើប្រាស់ | ជំនួយ និងមតិកែលម្អ
តើមានអ្វីនៅក្នុងការចេញផ្សាយ?
បានបន្ថែមនៅក្នុង 2.1.1 ការចេញផ្សាយបំណះនេះរួមបញ្ចូលកម្មវិធីចំណាត់ថ្នាក់រូបភាពថ្មី (Rock-Paper-Scissors) និងការបង្រៀនសម្រាប់ឧបករណ៍ xG24 និង xG26 ហើយជួសជុលកំហុសនៅពេលបង្កើតគម្រោងដោយប្រើមុខងារ "ចម្លងមាតិកា" នៅក្នុង Simplicity Studio ។

បានបន្ថែមនៅក្នុង 2.1.0
នេះគឺជាកំណែដំបូងដែលកម្មវិធី AI/ML ត្រូវបានផ្តល់ជាផ្នែកបន្ថែមទៅកាន់ Simplicity SDK ។ វាគាំទ្រស៊េរី 2 និង SiWG917 នៃឧបករណ៍ Silicon Labs គ្រួសារដោយប្រើ Tensorflow Lite for Microcontrollers (TFLM) framework ។ ការបន្លិចនៃការចេញផ្សាយនេះគឺការកែលម្អដំណើរការទៅ SDK ដែលនាំមកនូវការគាំទ្រសម្រាប់គ្រួសារបន្ទះឈីប SiWG917 ដែលមានស្ថាបត្យកម្ម SoC ខុសគ្នាខ្លាំងបើប្រៀបធៀបទៅនឹងឧបករណ៍ស៊េរី 2 ។ SiWG917 គឺជាបន្ទះឈីប Wi-Fi ថាមពលទាប ដំណើរការខ្ពស់ ដែលល្អសម្រាប់កម្មវិធី AI/ML។ ដូច្នេះហើយ កម្មវិធី AI/ML របស់អ្នកឥឡូវនេះអាចប្រើប្រាស់ការតភ្ជាប់ Wi-Fi សម្រាប់កម្មវិធី និងសេវាកម្ម AI/ML ដែលមានមូលដ្ឋានលើពពក។
កម្មវិធីដែលត្រូវគ្នា។
បានបន្ថែមនៅក្នុង 2.1.1

កញ្ចប់អភិវឌ្ឍន៍កម្មវិធីសូហ្វវែរ (SDK)

កំណែដែលត្រូវគ្នា ឬវ៉ារ្យ៉ង់
ភាពសាមញ្ញ SDK៖ 2025.6.1 WiSeConnect SDK: 3.5.1

បានបន្ថែមនៅក្នុង 2.1.0
កញ្ចប់អភិវឌ្ឍន៍កម្មវិធីសូហ្វវែរ (SDK)

កំណែដែលត្រូវគ្នា ឬវ៉ារ្យ៉ង់
ភាពសាមញ្ញ SDK៖ 2025.6.1 WiSeConnect SDK: 3.5.1

ការដំឡើងនិងការប្រើប្រាស់
បានបន្ថែមនៅក្នុង 2.1.1
ដើម្បីដំឡើងកំណែកម្មវិធីដែលមានស្រាប់របស់អ្នកជាមួយនឹងការចេញផ្សាយនេះ ធ្វើបច្ចុប្បន្នភាព Simplicity Studio ទៅចុងក្រោយបំផុត SiSDK ទៅ v2025.6.1, WiSeConnect SDK ទៅ v3.5.1 និងផ្នែកបន្ថែម AI/ML ទៅ v2.1.1 ពីកម្មវិធីគ្រប់គ្រងការដំឡើងស្ទូឌីយោ ឬទាញយក SDKs ពីតំណរៀងៗខ្លួនដែលបានរាយក្នុងផ្នែកកម្មវិធីដែលត្រូវគ្នាខាងលើ។ ដើម្បីធ្វើបច្ចុប្បន្នភាពផ្នែកបន្ថែម AI/ML សូមមើលការណែនាំអំពីការដំឡើងផ្នែកបន្ថែម AI/ML។

បានបន្ថែមនៅក្នុង 2.1.0
ដើម្បីដំឡើងកំណែកម្មវិធីដែលមានស្រាប់របស់អ្នកជាមួយនឹងការចេញផ្សាយនេះ ធ្វើបច្ចុប្បន្នភាព Simplicity Studio ទៅចុងក្រោយបំផុត SiSDK ទៅ v2025.6.0, WiSeConnect SDK ទៅ v3.5.0 និងផ្នែកបន្ថែម AI/ML ទៅ v2.1.0 ពីកម្មវិធីគ្រប់គ្រងការដំឡើងស្ទូឌីយោ ឬទាញយក SDKs ពីតំណរៀងៗខ្លួនដែលបានរាយក្នុងផ្នែកកម្មវិធីដែលត្រូវគ្នាខាងលើ។ ដើម្បីធ្វើបច្ចុប្បន្នភាពផ្នែកបន្ថែម AI/ML សូមមើលការណែនាំអំពីការដំឡើងផ្នែកបន្ថែម AI/ML។
ដើម្បីដំណើរការការបង្ហាញដំបូងរបស់អ្នក សូមមើលការចាប់ផ្តើមរបស់យើង។
ដើម្បីចាប់ផ្តើមការអភិវឌ្ឍន៍របស់អ្នក សូមមើលការណែនាំរបស់អ្នកអភិវឌ្ឍន៍របស់យើង។
សម្រាប់ព័ត៌មានអំពីការរួមបញ្ចូលតុដេកសុវត្ថិភាព សូមមើល Secure Vault ។
ដើម្បីឡើងវិញview ការជូនដំណឹងអំពីសុវត្ថិភាព និងកម្មវិធីប្រឹក្សា និងគ្រប់គ្រងចំណូលចិត្តការជូនដំណឹងរបស់អ្នក៖
1. ចូលទៅកាន់ https://community.silabs.com/ ។ ២.

៥/៥

ការរៀនម៉ាស៊ីន
ចូលដោយប្រើព័ត៌មានសម្ងាត់គណនីរបស់អ្នក។ 3. ចុចគាំទ្ររបស់អ្នក។file រូបតំណាងនៅជ្រុងខាងស្តាំខាងលើនៃទំព័រ។ 4. ជ្រើសរើសការជូនដំណឹងពីម៉ឺនុយទម្លាក់ចុះ។ 5. នៅក្នុងផ្នែកការជូនដំណឹង សូមចូលទៅកាន់ផ្ទាំងការជូនដំណឹងអំពីផលិតផលរបស់ខ្ញុំដើម្បីបន្តview ការជូនដំណឹងអំពីសុវត្ថិភាព និងប្រឹក្សាផ្នែកទន់ជាប្រវត្តិសាស្ត្រ 6. ដើម្បីគ្រប់គ្រងចំណូលចិត្តរបស់អ្នក សូមប្រើផ្ទាំងគ្រប់គ្រងការជូនដំណឹង ដើម្បីប្ដូរតាមបំណងនូវបច្ចុប្បន្នភាពផលិតផល និងការណែនាំដែលអ្នកទទួលបាន។
ដើម្បីស្វែងយល់បន្ថែមអំពីកម្មវិធីនៅក្នុងការចេញផ្សាយនេះ សូមចូលទៅកាន់ឯកសារអនឡាញរបស់យើង។
ជំនួយ និងមតិកែលម្អ
ទាក់ទងផ្នែកគាំទ្រ Silicon Labs ។ ដើម្បីប្រើឧបករណ៍ Ask AI របស់យើងដើម្បីទទួលបានចម្លើយ សូមមើលវាលស្វែងរកនៅផ្នែកខាងលើនៃទំព័រនេះ។

ចំណាំ៖ សួរ AI គឺជាការពិសោធន៍។

ទទួលបានជំនួយពីសហគមន៍អ្នកអភិវឌ្ឍន៍របស់យើង។

ម៉ាទ្រីសលក្ខណៈពិសេស
លក្ខណៈពិសេសដែលបានគាំទ្រ | មុខងារដែលមិនគាំទ្រ
លក្ខណៈពិសេសដែលបានគាំទ្រ
បានបន្ថែមក្នុង 2.1.1 គ្មាន។

បានបន្ថែមនៅក្នុង 2.1.0

ឈ្មោះលក្ខណៈពិសេស ម៉ូដែល APIs ជាក់លាក់

ការពិពណ៌នាអំពីគំរូ APIs ជាក់លាក់សម្រាប់ការហៅ និងប្រតិបត្តិម៉ូដែល AI/ML នៅលើឧបករណ៍។

គុណភាព

ឈ្មោះ API ដែលពាក់ព័ន្ធ

ពិសោធន៍

មគ្គុទ្ទេសក៍យោង AI/ML API
sl_ml_ _model_i nit()
sl_ml_ _model_r un()

វ៉ារ្យ៉ង់កម្មវិធីដែលគាំទ្រ ផ្នែករឹង របៀប ចំណុចប្រទាក់ម៉ាស៊ីន
ស្តង់ដារ SiWG917 SoC

ពាក់ព័ន្ធ Exampឈ្មោះឡេ
ឧបករណ៍ចាត់ថ្នាក់សំឡេងសម្រាប់ SiWG917 Voice Control Light សម្រាប់ SiWG917

អូឌីយ៉ូ

បានបើកកម្មវិធីអូឌីយ៉ូ

កម្មវិធី SiWG917 តាមរយៈកម្មវិធី

ការបង្កើនប្រសិទ្ធភាព

ពិសោធន៍

ស្តង់ដារ SiWG917 SoC

ឧបករណ៍ចាត់ថ្នាក់សំឡេងសម្រាប់ SiWG917 Voice Control Light សម្រាប់ SiWG917

មុខងារដែលមិនគាំទ្រ
បានបន្ថែមក្នុង 2.1.1 គ្មាន។
បានបន្ថែមនៅក្នុង 2.1.0

៥/៥

ការរៀនម៉ាស៊ីន
SiWG917 មិនប្រើសមាសធាតុ TensorFlow ដែលភ្ជាប់មកជាមួយដោយផ្ទាល់ទេ។ ជំនួសមកវិញ ការគាំទ្រត្រូវបានផ្តល់តាមរយៈការបង្កើតកូដដោយស្វ័យប្រវត្តិដែលគ្រប់គ្រងដោយអ្នកកំណត់រចនាសម្ព័ន្ធ។ ឧបករណ៍ស៊េរី 2 មិនគាំទ្រការបង្កើនប្រសិទ្ធភាពកម្មវិធីថ្មីទេ ប៉ុន្តែដោយសារតែស្ថាបត្យកម្មរបស់ពួកគេ ពួកគេនៅតែមានប្រសិទ្ធភាពដូច SiWG917 ប្រសិនបើមិនមានច្រើនជាងនេះ។
គោលការណ៍ចេញផ្សាយ និងថែទាំ SDK
សូមមើលគោលការណ៍ចេញផ្សាយ និងថែទាំ SDK របស់យើង។

៥/៥

ការចាប់ផ្តើម

ការចាប់ផ្តើមជាមួយនឹងការរៀនម៉ាស៊ីន

សេចក្តីផ្តើម
Silicon Labs TensorFlow Lite សម្រាប់ការរួមបញ្ចូល Microcontrollers
Silicon Labs ផ្តល់នូវការគាំទ្រដ៏រឹងមាំសម្រាប់ TensorFlow Lite សម្រាប់ Microcontrollers (TFLM) ជាផ្នែកបន្ថែមមួយទៅកាន់ Simplicity Studio SDK (SiSDK) ដោយផ្តល់ជូនអ្នកអភិវឌ្ឍន៍នូវជម្រើសដែលអាចបត់បែនបានសម្រាប់ដាក់ពង្រាយម៉ូដែលរៀនម៉ាស៊ីននៅលើ EFx32 និង Si91x microcontrollers ដោយប្រើ Project Configurator for Simplicity Studio។ ការណែនាំនេះគ្របដណ្តប់ពីរបៀបដែល TensorFlow Lite សម្រាប់ Microcontrollers ត្រូវបានរួមបញ្ចូលជាមួយ SiSDK ដោយប្រើផ្នែកបន្ថែម AIML សម្រាប់ការប្រើប្រាស់ឧបករណ៍ EFx32 និង Si91x របស់ Silicon Labs ។
TensorFlow Lite សម្រាប់ Microcontrollers
TensorFlow គឺជាក្របខ័ណ្ឌសិក្សាជ្រៅជ្រះដែលត្រូវបានប្រើប្រាស់យ៉ាងទូលំទូលាយ ជាមួយនឹងសមត្ថភាពសម្រាប់ការអភិវឌ្ឍ និងប្រតិបត្តិបណ្តាញសរសៃប្រសាទនៅទូទាំងវេទិកាផ្សេងៗ។ TensorFlow Lite ផ្តល់នូវសំណុំឧបករណ៍ដែលបានធ្វើឱ្យប្រសើរឡើងជាពិសេសសម្រាប់ការសិក្សាដោយម៉ាស៊ីនសម្រាប់ឧបករណ៍ចល័ត និងឧបករណ៍បង្កប់។
TensorFlow Lite សម្រាប់ Microcontrollers (TFLM) ជាពិសេសផ្តល់នូវបណ្ណាល័យ C ++ សម្រាប់ដំណើរការម៉ូដែលរៀនម៉ាស៊ីននៅក្នុងបរិស្ថានដែលបានបង្កប់ជាមួយនឹងឧបសគ្គនៃការចងចាំដ៏តឹងរ៉ឹង។ Silicon Labs ផ្តល់ឧបករណ៍ និងការគាំទ្រសម្រាប់ការផ្ទុក និងដំណើរការគំរូដែលបានបណ្តុះបណ្តាលជាមុន ដែលអាចប្រើបានជាមួយបណ្ណាល័យនេះ។
ផ្នែកបន្ថែម AIML
ការដំឡើងផ្នែកបន្ថែម AI/ML សម្រាប់ Silicon Labs Simplicity Studio
សម្រាប់ការណែនាំលម្អិតអំពីការដំឡើងផ្នែកបន្ថែម AI/ML សូមមើលការណែនាំអំពីការដំឡើងផ្នែកបន្ថែម AI/ML ។ ផ្នែកបន្ថែមនេះផ្តល់អំណាចដល់អ្នកអភិវឌ្ឍន៍ក្នុងការរួមបញ្ចូលសមត្ថភាពរៀនម៉ាស៊ីនទៅក្នុងគម្រោងដែលផ្អែកលើ Silicon Labs របស់ពួកគេ។
ការបណ្តុះបណ្តាលនិងបរិមាណគំរូ
ដើម្បីអនុវត្តការសន្និដ្ឋានបណ្តាញសរសៃប្រសាទនៅលើឧបករណ៍ Silicon Labs ដំបូងគេត្រូវការគំរូដែលបានបណ្តុះបណ្តាលក្នុងទម្រង់ TFLite Flatbuffer ។ មានវិធីសាស្រ្តពីរដែលត្រូវពិចារណាសម្រាប់អ្នកអភិវឌ្ឍន៍ដែលមានបទពិសោធន៍ជាមួយ TensorFlow៖
បន្ទាប់ពីការបង្រៀនដែលបានបោះពុម្ពផ្សាយសម្រាប់ការបណ្តុះបណ្តាលបណ្តាញសរសៃប្រសាទដោយប្រើ TensorFlow ដូចដែលបានរៀបរាប់នៅក្នុង ការអភិវឌ្ឍន៍គំរូមួយ។ ការប្រើប្រាស់ដៃគូ Silicon Labs AI/ML ។ សូមមើលផ្នែក AI/ML Partners នៅលើ Silicon Labs Machine Learning នៅក្នុងទំព័រ IoT សម្រាប់ព័ត៌មានបន្ថែម។ ការប្រើប្រាស់ឧបករណ៍សិក្សាម៉ាស៊ីន Silicon Labs ដែលជាកញ្ចប់ឯកសារយោង Python ដែលរួមបញ្ចូលគ្នា និងសម្រួលដល់ជំហានបណ្តុះបណ្តាល TensorFlow ចាំបាច់ទាំងអស់។
បង្កើតកម្មវិធី Inference ដោយប្រើប្រាស់ Simplicity Studio, SiSDK និង AIML extension
បន្ទាប់ពីអ្នកមានគំរូ TFLite ដែលបានបណ្តុះបណ្តាល និងកំណត់បរិមាណ ជំហានបន្ទាប់គឺត្រូវរៀបចំបណ្ណាល័យ TFLM ដើម្បីដំណើរការការសន្និដ្ឋានលើឧបករណ៍ Silicon Labs ។
ការដំឡើងកម្មវិធីកំណត់រចនាសម្ព័ន្ធគម្រោង
កម្មវិធីកំណត់រចនាសម្ព័ន្ធគម្រោងរួមមានបណ្ណាល័យ TFLM ជាសមាសធាតុកម្មវិធី។ សមាសធាតុកម្មវិធីទាំងនេះអាចត្រូវបានបន្ថែមទៅគម្រោងដែលមានស្រាប់ណាមួយ។ ពួកវាត្រូវបានពិពណ៌នានៅក្នុង SDK Component Overview. សមាសធាតុស្នូលដែលត្រូវការសម្រាប់គម្រោងរៀនម៉ាស៊ីនណាមួយមានដូចខាងក្រោម៖
1. TensorFlow Lite Micro ។ នេះគឺជាសមាសភាគកម្មវិធីស្នូលដែលទាញភាពអាស្រ័យ TFLM ទាំងអស់។ 2. ការអនុវត្តខឺណែល TFLM ដែលគាំទ្រ។ ខឺណែលគឺជាការអនុវត្តផ្នែករឹង/វេទិកាជាក់លាក់នៃប្រតិបត្តិការកម្រិតទាបដែលប្រើដោយ
TensorFlow ។ ការជ្រើសរើសខឺណែលអាចផ្លាស់ប្តូរយ៉ាងខ្លាំងនូវដំណើរការ និងពេលវេលាគណនានៃបណ្តាញសរសៃប្រសាទ។ តាមលំនាំដើមគឺល្អបំផុត

៥/៥

ការចាប់ផ្តើម
ការអនុវត្តខឺណែលសម្រាប់ឧបករណ៍ដែលបានផ្តល់ឱ្យត្រូវបានជ្រើសរើសដោយស្វ័យប្រវត្តិ។ 3. កម្មវិធីកែកំហុស TFLM ដែលគាំទ្រ។ Project Configurator កំណត់លំនាំដើមចំពោះការប្រើប្រាស់ I/O Stream នៃអ្នកកាប់ឈើ។ ដើម្បីបិទ
ចូលទាំងស្រុង បន្ថែមផ្នែក Debug Loggging Disabled ។
បន្ថែមពីលើសមាសធាតុ TFLM ដែលត្រូវការ សមាសធាតុសូហ្វវែរសម្រាប់ការទទួលបាន និងដំណើរការទិន្នន័យឧបករណ៍ចាប់សញ្ញាជាមុនអាចត្រូវបានបន្ថែមទៅក្នុងគម្រោង។ ក្នុងនាមជាអតីតample សម្រាប់កម្មវិធីអូឌីយ៉ូ Silicon Labs ផ្តល់នូវសមាសធាតុបង្កើតមុខងារអូឌីយ៉ូ ដែលរួមបញ្ចូលមុខងារ DSP ដ៏មានអានុភាព ដើម្បីត្រង និងទាញយកលក្ខណៈពិសេសពីទិន្នន័យអូឌីយ៉ូឆៅ ដើម្បីប្រើជាផ្នែកខាងមុខសម្រាប់កម្មវិធីដែលមានមូលដ្ឋានលើមីក្រូហ្វូន។ Silicon Labs បានបង្កើតកម្មវិធីបញ្ជាសម្រាប់មីក្រូហ្វូន ឧបករណ៍វាស់ល្បឿន និងឧបករណ៍ចាប់សញ្ញាផ្សេងទៀតផ្តល់នូវចំណុចប្រទាក់សាមញ្ញសម្រាប់ការទទួលបានទិន្នន័យឧបករណ៍ចាប់សញ្ញាដើម្បីបញ្ជូនទៅកាន់បណ្តាញមួយ។

៥/៥

Tensorflow Lite Micro ពី Scratch
Tensorflow Lite Micro ពី Scratch
ការរៀនម៉ាស៊ីននៅលើឧបករណ៍ Silicon Labs ពី Scratch
មគ្គុទ្ទេសក៍នេះសន្មត់ថាស្គាល់ខ្លឹមសារនៃការណែនាំចាប់ផ្តើម។ វាផ្តល់នូវព័ត៌មានលម្អិតនៃការធ្វើការជាមួយ TensorFlow API ដែលជាជម្រើសមួយសម្រាប់ការចាប់ផ្តើមដោយស្វ័យប្រវត្តិដែលផ្តល់ដោយ Silicon Labs ដូចដែលបានពិពណ៌នានៅក្នុងការណែនាំស្តីពីការបន្ថែមការរៀនម៉ាស៊ីនទៅគម្រោងថ្មី។
ការរួមបញ្ចូលគំរូ
ជាមួយនឹងសមាសភាគ TensorFlow Lite Micro បានបន្ថែមនៅក្នុង Project Configurator ជំហានបន្ទាប់គឺត្រូវផ្ទុកគំរូ file ចូលទៅក្នុងគម្រោង។ ដើម្បីធ្វើដូចនេះចម្លងគំរូ .tflite file ចូលទៅក្នុងថត config/tflite នៃគម្រោង។ កម្មវិធីកំណត់រចនាសម្ព័ន្ធគម្រោងផ្តល់ឧបករណ៍ដែលនឹងបំប្លែង .tflite ដោយស្វ័យប្រវត្តិ files ចូលទៅក្នុងប្រភព sl_tflite_micro_model និងបឋមកថា fileស. ឯកសារពេញលេញសម្រាប់ឧបករណ៍នេះមាននៅ Flatbuffer Converter Tool។ ដើម្បីធ្វើជំហាននេះដោយដៃ អារេ C អាចត្រូវបានបង្កើតពី .tflite ដោយប្រើឧបករណ៍ដូចជា xxd ។
TFLM ការចាប់ផ្តើម និងការសន្និដ្ឋាន
ដើម្បីជម្រុញ និងប្រើប្រាស់ TensorFlow APIs សូមអនុវត្តតាមជំហានខាងក្រោម ដើម្បីបន្ថែមមុខងារ TFLM ទៅក្នុងស្រទាប់កម្មវិធីនៃគម្រោង។ មគ្គុទ្ទេសក៍នេះធ្វើតាមការណែនាំអំពីការចាប់ផ្តើមរបស់ TFLM ហើយត្រូវបានកែសម្រួលសម្រាប់ប្រើប្រាស់ជាមួយគម្រោងរបស់ Silicon Labs។ កំណត់ចំណាំពិសេសចាំបាច់ត្រូវយកទាក់ទងនឹងប្រតិបត្តិការដែលប្រើដោយ TensorFlow ។ ប្រតិបត្តិការគឺជាប្រភេទជាក់លាក់នៃការគណនាដែលប្រតិបត្តិដោយស្រទាប់មួយនៅក្នុងបណ្តាញសរសៃប្រសាទ។ ប្រតិបត្តិការទាំងអស់អាចត្រូវបានរួមបញ្ចូលនៅក្នុងគម្រោងមួយក្នុងពេលតែមួយ ប៉ុន្តែការធ្វើនេះអាចបង្កើនទំហំគោលពីរយ៉ាងខ្លាំង (> 100kB) ។ ជម្រើសដែលមានប្រសិទ្ធភាពជាងគឺរួមបញ្ចូលតែប្រតិបត្តិការចាំបាច់ដើម្បីដំណើរការគំរូជាក់លាក់មួយ។ ជម្រើសទាំងពីរត្រូវបានពិពណ៌នានៅក្នុងជំហានខាងក្រោម។
0. បិទការចាប់ផ្តើមដោយស្វ័យប្រវត្តិដែលផ្តល់ដោយសមាសភាគ TensorFlow Lite Micro
ដើម្បីដំឡើង TensorFlow ដោយដៃ ដំបូងត្រូវបិទការចាប់ផ្ដើមដោយស្វ័យប្រវត្តិនៃគំរូ ដោយបិទការចាប់ផ្ដើមគំរូដោយស្វ័យប្រវត្តិនៅក្នុងបឋមកថាកំណត់រចនាសម្ព័ន្ធសម្រាប់សមាសភាគ TensorFlow Lite Micro ( sl_tflite_micro_config.h ) ។

1. រួមបញ្ចូលបឋមកថាបណ្ណាល័យ
ប្រសិនបើប្រើសំណុំប្រតិបត្តិការផ្ទាល់ខ្លួន មានកំណត់ (បានណែនាំ)៖
រក្សាសិទ្ធិ © 2025 Silicon Laboratories ។ រក្សារសិទ្ធគ្រប់យ៉ាង។

៥/៥

Tensorflow Lite Micro ពី Scratch
#include “tensorflow/lite/micro/micro_mutable_op_resolver.h” #include “tensorflow/lite/micro/tflite_bridge/micro_error_reporter.h” #include “tensorflow/lite/micro/micro_interpreter.h” #include “/genesorflow” “tensorflow/lite/version.h”
ប្រសិនបើប្រើប្រតិបត្តិការទាំងអស់៖
#include “tensorflow/lite/micro/all_ops_resolver.h” #include “tensorflow/lite/micro/micro_error_reporter.h” #include “tensorflow/lite/micro/micro_interpreter.h” #include “tensorflow/lite/schema/schema” #include “tensorflow/lite/version.h”
2. រួមបញ្ចូលបឋមកថាគំរូ
ដោយសារតែ autogen/ folder តែងតែត្រូវបានរួមបញ្ចូលនៅក្នុងគម្រោងរួមមានផ្លូវ ម៉ូដែលដែលបាននាំចូលអាចនឹងត្រូវបានរួមបញ្ចូលជាទូទៅនៅក្នុងប្រភពគម្រោងណាមួយ។ file ជាមួយ៖
# រួមបញ្ចូល “sl_tflite_micro_model.h”
ប្រសិនបើមិនប្រើឧបករណ៍បំប្លែង Flatbuffer រួមបញ្ចូល file មាននិយមន័យគំរូរបស់អ្នកជំនួសវិញ។
3. កំណត់សង្វៀននៃការចងចាំ
TensorFlow ទាមទារសង្វៀនអង្គចងចាំសម្រាប់ការផ្ទុកពេលដំណើរការនៃការបញ្ចូល ទិន្នផល និងអារេកម្រិតមធ្យម។ សង្វៀននេះគួរត្រូវបានបែងចែកជាឋិតិវន្ត ហើយទំហំនៃសង្វៀនអាស្រ័យលើគំរូដែលបានប្រើ។ វាត្រូវបានផ្ដល់អនុសាសន៍ឱ្យចាប់ផ្តើមជាមួយនឹងទំហំសង្វៀនធំមួយកំឡុងពេលបង្កើតគំរូ។
constexpr int tensor_arena_size = 10 * 1024; uint8_t tensor_arena [tensor_arena_size];
ចំណាំ៖ បន្ទាប់ពីការធ្វើគំរូរួចហើយ វាត្រូវបានណែនាំឱ្យលៃតម្រូវទំហំមេម៉ូរីដោយដៃទៅនឹងម៉ូដែលដែលបានប្រើ។ បន្ទាប់ពីគំរូត្រូវបានបញ្ចប់ សូមចាប់ផ្តើមជាមួយនឹងទំហំសង្វៀនធំ ហើយបន្ថយវាបន្តិចម្តងៗ រហូតដល់ការបែងចែកអ្នកបកប្រែ (ពិពណ៌នាខាងក្រោម) បរាជ័យ។
4. រៀបចំការកត់ត្រា
នេះគួរតែត្រូវបានអនុវត្តទោះបីជាសមាសធាតុ Debug Logging Disabled ត្រូវបានប្រើក៏ដោយ។ វាត្រូវបានណែនាំឱ្យធ្វើភ្លាមៗនូវស្ថានភាពនេះ ហើយហៅមុខងារ logger init កំឡុងពេលលំដាប់ app_init() នៅក្នុង app.cpp ។
static tflite::MicroErrorReporter micro_error_reporter; tflite::ErrorReporter* error_reporter = &micro_error_reporter;
5. ផ្ទុកគំរូ
បន្តក្នុងអំឡុងពេលនៃលំដាប់ app_init() ជំហានបន្ទាប់គឺត្រូវផ្ទុកគំរូទៅក្នុង tflite៖

៥/៥

Tensorflow Lite Micro ពី Scratch
const tflite::Model* model = ::tflite::GetModel(sl_tflite_model_array); ប្រសិនបើ (model->version() != TFLITE_SCHEMA_VERSION) {
TF_LITE_REPORT_ERROR(error_reporter, “ម៉ូដែលដែលបានផ្តល់គឺកំណែគ្រោងការណ៍ %d មិនស្មើ” “ទៅកំណែដែលបានគាំទ្រ %dn”, model->version(), TFLITE_SCHEMA_VERSION);
}
6. បន្ទាន់អ្នកដោះស្រាយប្រតិបត្តិការ
ប្រសិនបើប្រើប្រតិបត្តិការទាំងអស់ នេះគឺពិតជាត្រង់ណាស់។ កំឡុងពេល app_init() ធ្វើឱ្យអ្នកដោះស្រាយភ្លាមៗតាមរយៈ៖
static tflite::AllOpsResolver ដោះស្រាយ;
ចំណាំ៖ ការផ្ទុកប្រតិបត្តិការទាំងអស់នឹងនាំឱ្យមានការកើនឡើងដ៏ធំដល់ទំហំគោលពីរ។ វាត្រូវបានណែនាំឱ្យប្រើសំណុំប្រតិបត្តិការផ្ទាល់ខ្លួន។
ប្រសិនបើប្រើសំណុំប្រតិបត្តិការផ្ទាល់ខ្លួន អ្នកដោះស្រាយ ops ដែលអាចផ្លាស់ប្តូរបានត្រូវតែកំណត់រចនាសម្ព័ន្ធ និងចាប់ផ្តើម។ វានឹងប្រែប្រួលអាស្រ័យលើគំរូ និងកម្មវិធី។ ដើម្បីកំណត់ប្រតិបត្តិការដែលបានប្រើនៅក្នុង .tflite ដែលបានផ្តល់ឱ្យ fileឧបករណ៍ភាគីទីបីដូចជា netron អាចត្រូវបានប្រើប្រាស់ដើម្បីមើលឃើញបណ្តាញ និងពិនិត្យមើលប្រតិបត្តិការណាមួយដែលកំពុងប្រើប្រាស់។

៥/៥

Tensorflow Lite Micro ពី Scratch
អតីតample ខាងក្រោមផ្ទុកប្រតិបត្តិករអប្បបរមាដែលត្រូវការសម្រាប់ TensorFlow hello_world exampម៉ូដែល។ ដូចដែលបានបង្ហាញនៅក្នុងការមើលឃើញរបស់ Netron វាទាមទារតែស្រទាប់ដែលភ្ជាប់យ៉ាងពេញលេញប៉ុណ្ណោះ៖
#កំណត់ NUM_OPS 1
tflite ឋិតិវន្ត ::MicroMutableOpResolver micro_op_resolver; ប្រសិនបើ (micro_op_resolver.AddFullyConnected() != kTfLiteOk) {
ត្រឡប់មកវិញ; }
ប្រសិនបើប្រើឧបករណ៍បំលែង Flatbuffer វាបង្កើតម៉ាក្រូ C preprocessor ដែលដំឡើង tflite ល្អបំផុតដោយស្វ័យប្រវត្តិ::MicroMutableOpResolver សម្រាប់ flatbuffer:
# រួមបញ្ចូល “sl_tflite_micro_opcode_resolver.h”
SL_TFLITE_MICRO_OPCODE_RESOLVER(micro_op_resolver, error_reporter);
7. ចាប់ផ្តើមអ្នកបកប្រែ
ជំហានចុងក្រោយក្នុងកំឡុងពេល app_init() គឺធ្វើឱ្យអ្នកបកប្រែភ្លាមៗ និងបែងចែកសតិបណ្ដោះអាសន្ននៅក្នុង memory arena សម្រាប់អ្នកបកប្រែប្រើ៖
// ការប្រកាសឋិតិវន្ត tflite::MicroInterpreter* interpreter = nullptr;
// ការចាប់ផ្តើមនៅក្នុង app_init tflite:: អ្នកបកប្រែ MicroInterpreter (គំរូ, micro_op_resolver, tensor_arena,
tensor_arena_size, error_reporter); អ្នកបកប្រែ = &interpreter_struct; TfLiteStatus allocate_status = interpreter.AllocateTensors(); ប្រសិនបើ (allocate_status != kTfLiteOk) {
TF_LITE_REPORT_ERROR(error_reporter, “AllocateTensors() បរាជ័យ”); ត្រឡប់មកវិញ; }
ការបែងចែកនឹងបរាជ័យ ប្រសិនបើសង្វៀនតូចពេក សមនឹងប្រតិបត្តិការ និងសតិបណ្ដោះអាសន្នទាំងអស់ដែលតម្រូវដោយគំរូ។ លៃតម្រូវ tensor_arena_size ស្របតាម ដើម្បីដោះស្រាយបញ្ហា។
8. ដំណើរការគំរូ
សម្រាប់ឥរិយាបទលំនាំដើមនៅក្នុងកម្មវិធីដែកទទេ វាត្រូវបានផ្ដល់អនុសាសន៍ឱ្យដំណើរការគំរូកំឡុងពេល app_process_action() នៅក្នុង app.cpp ដើម្បីឱ្យការសន្និដ្ឋានតាមកាលកំណត់កើតឡើងក្នុងអំឡុងពេលរង្វិលជុំព្រឹត្តិការណ៍ស្តង់ដារ។ ការរត់ម៉ូដែលពាក់ព័ន្ធនឹងបី stages:
1. ទិន្នន័យឧបករណ៍ចាប់សញ្ញាត្រូវបានដំណើរការជាមុន (បើចាំបាច់) ហើយបន្ទាប់មកត្រូវបានផ្តល់ជាការបញ្ចូលទៅអ្នកបកប្រែ។
TfLiteTensor* បញ្ចូល = interpreter.input(0); // រក្សាទុក 0.0 ទៅ tensor បញ្ចូលនៃ model input->data.f[0] = 0.;
វាមានសារៈសំខាន់ណាស់ក្នុងការផ្គូផ្គងរូបរាងនៃទិន្នន័យឧបករណ៍ចាប់សញ្ញាចូលទៅនឹងរូបរាងដែលរំពឹងទុកដោយគំរូ។ នេះអាចត្រូវបានសួរជាជម្រើសដោយពិនិត្យមើលលក្ខណៈសម្បត្តិដែលបានកំណត់នៅក្នុងរចនាសម្ព័ន្ធបញ្ចូល។ អតីតampពីនេះសម្រាប់ hello_world example ត្រូវបានបង្ហាញខាងក្រោម៖
TfLiteTensor* បញ្ចូល = អ្នកបកប្រែ->បញ្ចូល(0); ប្រសិនបើ ((input->dims->size != 1) || (input->type != kTfLiteFloat32)) {
TF_LITE_REPORT_ERROR(error_reporter, "ប៉ារ៉ាម៉ែត្រ tensor បញ្ចូលមិនល្អនៅក្នុងគំរូ");
ត្រឡប់មកវិញ; }
2. បន្ទាប់មកអ្នកបកប្រែត្រូវបានហៅឱ្យដំណើរការស្រទាប់ទាំងអស់នៃគំរូ។

៥/៥

Tensorflow Lite Micro ពី Scratch
TfLiteStatus invoke_status = អ្នកបកប្រែ->Invoke(); ប្រសិនបើ (invoke_status != kTfLiteOk) {
TF_LITE_REPORT_ERROR(error_reporter, “Invoke failed on x_val: %fn”, static_cast (x_val));
ត្រឡប់មកវិញ; }
3. ការព្យាករណ៍លទ្ធផលត្រូវបានអានពីអ្នកបកប្រែ។
TfLiteTensor* លទ្ធផល = អ្នកបកប្រែ-> លទ្ធផល(0); // ទទួលបានតម្លៃលទ្ធផលពីតម្លៃ tensor float = output->data.f[0];
នៅចំណុចនេះ ឥរិយាបថអាស្រ័យលើកម្មវិធីដោយផ្អែកលើការព្យាករណ៍លទ្ធផលគួរតែត្រូវបានអនុវត្ត។ កម្មវិធីនឹងដំណើរការការសន្និដ្ឋានលើការធ្វើឡើងវិញនីមួយៗនៃ app_process_action() ។
សម្រង់កូដពេញលេញ
បន្ទាប់ពីធ្វើតាមជំហានខាងលើ ហើយជ្រើសរើសប្រើកម្មវិធីដោះស្រាយ ops ដែលអាចផ្លាស់ប្តូរបាន លទ្ធផល app.cpp ឥឡូវនេះនឹងបង្ហាញដូចខាងក្រោម៖

៥/៥

Tensorflow Lite Micro ពី Scratch
#include “tensorflow/lite/micro/micro_mutable_op_resolver.h” #include “tensorflow/lite/micro/micro_error_reporter.h” #include “tensorflow/lite/micro/micro_interpreter.h” #include “tensorflow/lite/schema/” “tensorflow/lite/version.h”
# រួមបញ្ចូល “sl_tflite_micro_model.h”
#កំណត់ NUM_OPS 1
constexpr int tensor_arena_size = 10 * 1024; uint8_t tensor_arena [tensor_arena_size];
tflite::MicroInterpreter* អ្នកបកប្រែ = nullptr;
/*************************************************************************************//** * ចាប់ផ្តើមកម្មវិធី។ ***********************************************************************************/
void app_init(void) {
static tflite::MicroErrorReporter micro_error_reporter; tflite::ErrorReporter* error_reporter = µ_error_reporter;
const tflite::Model* model = ::tflite::GetModel(g_model); ប្រសិនបើ (model->version() != TFLITE_SCHEMA_VERSION) {
TF_LITE_REPORT_ERROR(error_reporter, “ម៉ូដែលដែលបានផ្តល់គឺកំណែគ្រោងការណ៍ %d មិនស្មើ” “ទៅកំណែដែលបានគាំទ្រ %dn”, model->version(), TFLITE_SCHEMA_VERSION);
}
tflite ឋិតិវន្ត ::MicroMutableOpResolver micro_op_resolver; ប្រសិនបើ (micro_op_resolver.AddFullyConnected() != kTfLiteOk) {
ត្រឡប់មកវិញ; }
static tflite::MicroInterpreter interpreter_struct(គំរូ, micro_op_resolver, tensor_arena, tensor_arena_size, error_reporter);
អ្នកបកប្រែ = &interpreter_struct; TfLiteStatus allocate_status = interpreter.AllocateTensors(); ប្រសិនបើ (allocate_status != kTfLiteOk) {
TF_LITE_REPORT_ERROR(error_reporter, “AllocateTensors() បរាជ័យ”); ត្រឡប់មកវិញ; } }
/*************************************************************************************//** * មុខងារធីកកម្មវិធី។ ***********************************************************************************/
void app_process_action(void) {
// រក្សាទុក 0.0 ទៅ tensor បញ្ចូលនៃគំរូ TfLiteTensor* input = interpreter->input(0); input->data.f[0] = 0.;
TfLiteStatus invoke_status = អ្នកបកប្រែ->Invoke(); ប្រសិនបើ (invoke_status != kTfLiteOk) {
TF_LITE_REPORT_ERROR(error_reporter, “Invoke failed on x_val: %fn”, static_cast (x_val));
ត្រឡប់មកវិញ; }
TfLiteTensor* លទ្ធផល = អ្នកបកប្រែ-> លទ្ធផល(0); តម្លៃអណ្តែត = output->data.f[0]; }
រក្សាសិទ្ធិ © 2025 Silicon Laboratories ។ រក្សារសិទ្ធគ្រប់យ៉ាង។

៥/៥

Tensorflow Lite Micro ពី Scratch
Examples
ដូចដែលបានពិពណ៌នានៅក្នុង Sampការដាក់ពាក្យសុំលើសview, ឧamples ត្រូវបានបង្កើតឡើងដោយក្រុម TensorFlow ដែលបង្ហាញពី hello_world exampឡេបានពិពណ៌នានៅក្នុងការណែនាំនេះ ក៏ដូចជាការទទួលស្គាល់ការនិយាយសាមញ្ញ ឧample micro_speech ត្រូវបានរួមបញ្ចូលនៅក្នុង Simplicity SDK។ ចំណាំថា micro_speech example បង្ហាញការប្រើប្រាស់ MicroMutableOpResolver ដើម្បីផ្ទុកតែប្រតិបត្តិការដែលត្រូវការប៉ុណ្ណោះ។

៥/៥

សំឡេងបញ្ជាពន្លឺពីកោស
សំឡេងបញ្ជាពន្លឺពីកោស
ជំហានពីចុងដល់ចប់ដើម្បីបង្កើតកម្មវិធី ML ដែលគ្រប់គ្រងដោយសំឡេងពីកោស
ការណែនាំនេះរៀបរាប់លម្អិតអំពីដំណើរការនៃការបង្កើតកម្មវិធីពន្លឺដែលគ្រប់គ្រងដោយសំឡេងដោយប្រើ TensorFlow Lite Micro (TFLM) នៅលើ EFR32xG24 Development Kit។ អតីតample ប្រើ keyword_spotting_on_off_v3.tflite model (បានណែនាំ) សម្រាប់ "on" និង "off" keyword detection។ សម្រាប់ព័ត៌មានបន្ថែមស្តីពីការបង្កើតគំរូ សូមមើលការបង្រៀន MLTK ។
ផ្នែករឹង៖ EFR32xG24 Dev Kit Board (BRD2601B Rev A01) កម្មវិធី៖ Simplicity Studio (SiSDK 2024.12 ឬខ្ពស់ជាងនេះ)
1. ដំឡើងផ្នែកបន្ថែម AI/ML
1. ចុចដំឡើងនៅលើរបារខាងលើ។
2. ចុចគ្រប់គ្រងកញ្ចប់ដែលបានដំឡើង។
3. នៅក្រោម SDKs សូមដំឡើងកំណែចុងក្រោយបំផុតនៃផ្នែកបន្ថែម AI/ML (មានចាប់ពី SiSDK 2024.12 តទៅ)។

2. ចាប់ផ្តើមគម្រោងសាមញ្ញថ្មី។
1. ពី File មឺនុយ ជ្រើសរើស New > Silicon Labs Project Wizard។
រក្សាសិទ្ធិ © 2025 Silicon Laboratories ។ រក្សារសិទ្ធគ្រប់យ៉ាង។

៥/៥

សំឡេងបញ្ជាពន្លឺពីកោស
2. ជ្រើសរើសបន្ទះគោលដៅ (EFR32xG24 Development Kit), SDK (Simplicity SDK v2024.12.0 ឬក្រោយ) និង IDE/Toolchain (ឧ. GNU ARM v12.2.1)។ ចុចបន្ទាប់។

3. ជ្រើសរើសគម្រោង C++ ទទេ។ ចុចបន្ទាប់។ 4. ដាក់ឈ្មោះគម្រោងរបស់អ្នក ហើយចុច Finish ។
រក្សាសិទ្ធិ © 2025 Silicon Laboratories ។ រក្សារសិទ្ធគ្រប់យ៉ាង។

៥/៥

សំឡេងបញ្ជាពន្លឺពីកោស

3. បន្ថែមសមាសធាតុកម្មវិធីរៀនម៉ាស៊ីន
1. បើកគម្រោងរបស់អ្នក។ file (មួយដែលមានផ្នែកបន្ថែម .slcp) ។
2. នៅក្រោមសមាសភាគកម្មវិធី សូមស្វែងរក " aiml" ។ 3. បើកដំណើរការផ្នែកបន្ថែម AI/ML ដោយចុច Enable Extension។ 4. ពង្រីក AI/ML >> Machine Learning >> TensorFlow ។ ជ្រើសរើស TensorFlow Lite Micro ហើយចុចដំឡើង។ 5. អ្នកនឹងត្រូវបានជម្រុញឱ្យជ្រើសរើសសមាសធាតុបន្ថែម៖
រក្សាសិទ្ធិ © 2025 Silicon Laboratories ។ រក្សារសិទ្ធគ្រប់យ៉ាង។

៥/៥

សំឡេងបញ្ជាពន្លឺពីកោស
Debug Loggging៖ ជ្រើសរើស Debug Loggging ដោយប្រើ IO Stream (ប្រសិនបើចាំបាច់) ឬ Debug Logging Disabled។ ចុចដំឡើង។ ខឺណែល៖ ជ្រើសរើសខឺណែលបង្កើនល្បឿន MVPv1 ។ ចុចដំឡើង។

4. កំណត់រចនាសម្ព័ន្ធ TFLM Component
1. ចុច Configure ក្នុង TensorFlow Lite Micro Software Component។
2. កំណត់ទំហំសង្វៀន។ សម្រាប់អតីតនេះ។ampបញ្ចូល "-1" ។ វាប្រាប់ប្រព័ន្ធឱ្យកំណត់ថាមវន្តទំហំសង្វៀនល្អបំផុតនៅពេលដំណើរការ។

5. រួមបញ្ចូល និងបំប្លែងគំរូ
1. បង្កើតថតឯកសារ tflite នៅក្នុងថតកំណត់រចនាសម្ព័ន្ធរបស់គម្រោងរបស់អ្នក (ជាជម្រើស ប៉ុន្តែត្រូវបានណែនាំ)។ 2. អូស និងទម្លាក់ keyword_spotting_on_off_v2.tflite file ចូលទៅក្នុងថត config/tflite (ឬដោយផ្ទាល់ទៅក្នុង config ប្រសិនបើអ្នក
រំលងការបង្កើតថតរង)។ 3. ក្របខ័ណ្ឌនឹងបំប្លែង .tflite ដោយស្វ័យប្រវត្តិ file ទៅក្នុងអារេ C ( sl_tflite_micro_model.c ក្នុង autogen directory)។
អ្នកបកប្រែ TFLM ក៏ត្រូវបានចាប់ផ្តើមដោយស្វ័យប្រវត្តិផងដែរ។

៥/៥

សំឡេងបញ្ជាពន្លឺពីកោស
6. ប្រូfile ម៉ូដែល (ស្រេចចិត្ត)
ការបង្កើតទម្រង់គំរូអាចមានប្រយោជន៍សម្រាប់ការបង្កើនប្រសិទ្ធភាព។ សម្រាប់អ្នកប្រើប្រាស់កម្រិតខ្ពស់ដែលចង់វិភាគការអនុវត្តគំរូ MLTK Model Profiler ឧបករណ៍ប្រើប្រាស់អាចប្រើបាន។ នេះមិនត្រូវបានទាមទារយ៉ាងតឹងរឹងសម្រាប់អតីតមូលដ្ឋាននេះទេ។ampលេ
7. ដំណើរការគំរូ
1. រួមបញ្ចូល TensorFlow Init API៖ បន្ថែមកូដចាំបាច់ដើម្បីចាប់ផ្តើមកម្មវិធីបកប្រែ TFLM ។ 2. ផ្តល់ទិន្នន័យបញ្ចូល៖
ទទួលបានទ្រនិចទៅឧបករណ៍បញ្ចូលបញ្ចូល៖ TfLiteTensor* input = sl_tflite_micro_get_input_tensor(); . ផ្ទុកទិន្នន័យបញ្ចូលរបស់អ្នក (មីក្រូហ្វូនអូឌីយ៉ូ quantized ទៅ int8) ទៅក្នុង input tensor: input->data.int8f[0] = ; (សូមមើលអតីតampលេខកូដសម្រាប់ការបង្កើតមុខងារអូឌីយ៉ូ) ។ 3. ដំណើរការ Inference៖ ហៅអ្នកបកប្រែ៖ TfLiteStatus invoke_status = sl_tflite_micro_get_interpreter()->Invoke(); ពិនិត្យរកកំហុស៖ ប្រសិនបើ (invoke_status != kTfLiteOk) {
TF_LITE_REPORT_ERROR(sl_tflite_micro_get_error_reporter(), "ប៉ារ៉ាម៉ែត្រ tensor បញ្ចូលមិនល្អនៅក្នុងគំរូ"); }
4. អានលទ្ធផល៖ ទទួលបានទ្រនិចមួយទៅកាន់ទិន្នផល tensor៖ TfLiteTensor* output = sl_tflite_micro_get_output_tensor(); ចូលប្រើទិន្នន័យលទ្ធផល៖ តម្លៃ int8_t = output->data.int8_tf[0];
8. អនុវត្តក្រោយដំណើរការ
1. បង្កើតក្បួនដោះស្រាយ៖ បង្កើតក្បួនដោះស្រាយដើម្បីបកស្រាយលទ្ធផលរបស់ម៉ូដែល (ឧទាហរណ៍ តម្លៃ int8_t) និងកំណត់ថាតើ "បើក" ឬ "បិទ" ត្រូវបាននិយាយ។
2. ព្រឹត្តិការណ៍កេះ៖ ផ្អែកលើលទ្ធផលក្រោយដំណើរការ សកម្មភាពកេះដូចជាការគ្រប់គ្រង LED ជាដើម។ យោងទៅ voice_control_light.cc , recognition_commands.cc , និងទទួលស្គាល់_commands.h files ក្នុង aiml-extension examples សម្រាប់ការណែនាំអំពីការអនុវត្តតក្កវិជ្ជានេះ រួមទាំងការគ្រប់គ្រង LED និងការទទួលស្គាល់ពាក្យបញ្ជា។ អ្នកនឹងត្រូវបន្ថែមសមាសធាតុសម្រាប់មីក្រូហ្វូន ដំណើរការសំឡេង និងការគ្រប់គ្រង LED ទៅក្នុងគម្រោងរបស់អ្នក។

៥/៥

ការបង្ហាញពន្លឺគ្រប់គ្រងសំឡេង
ការបង្ហាញពន្លឺគ្រប់គ្រងសំឡេង
ការសាកល្បងពន្លឺបញ្ជាសំឡេង - ការណែនាំអំពីការចាប់ផ្តើមរហ័ស
មគ្គុទ្ទេសក៍នេះផ្តល់ការណែនាំសម្រាប់បង្ហាញយ៉ាងរហ័សនូវកម្មវិធី Voice-Control Light ដោយប្រើប្រព័ន្ធគោលពីរដែលបានបង្កើតជាមុន។ ការបង្ហាញនេះអនុញ្ញាតឱ្យអ្នកគ្រប់គ្រង LED នៅលើ EFR32xG24 Dev Kit (BRD2601B Rev A01) ដោយនិយាយ "បើក" ឬ "បិទ" ទៅក្នុងមីក្រូហ្វូន។
ផ្នែករឹង៖ EFR32xG24 Dev Kit Board (BRD2601B Rev A01) កម្មវិធី៖ Simplicity Studio (SiSDK 2024.12 ឬខ្ពស់ជាងនេះ)
ជំហាន
1. បើក Simplicity Studio៖ បើកដំណើរការ Simplicity Studio (ដោយប្រើប៊ូតុងរ៉ុក្កែតនៅជ្រុងខាងលើខាងស្តាំ)។ 2. ភ្ជាប់ឧបករណ៍របស់អ្នក៖ ភ្ជាប់ EFR32xG24 Dev Kit របស់អ្នកទៅកុំព្យូទ័ររបស់អ្នក។ រង់ចាំ 5-10 វិនាទីដើម្បីឱ្យឧបករណ៍ត្រូវបានទទួលស្គាល់ដោយ
ស្ទូឌីយោសាមញ្ញ។ ការដោះស្រាយបញ្ហា៖ ប្រសិនបើឧបករណ៍របស់អ្នកមិនត្រូវបានគេទទួលស្គាល់ទេ ចុចប៊ូតុង "ធ្វើឱ្យស្រស់" នៅក្នុងបង្អួចរងរបស់អាដាប់ទ័របំបាត់កំហុស (ជាធម្មតាមានទីតាំងនៅខាងក្រោមខាងឆ្វេង)។
3. ជ្រើសរើសឧបករណ៍របស់អ្នក៖ ជ្រើសរើសឧបករណ៍ដែលបានភ្ជាប់របស់អ្នកពី Connected Devices dropdown ហើយចុច Start។ 4. រុករកទៅការបង្ហាញ៖ ចូលទៅកាន់ Exampគម្រោង និងការបង្ហាញ។ នៅក្នុងម៉ឺនុយបរិបទខាងឆ្វេង សូមរំកិលចុះក្រោមទៅ សមត្ថភាព ហើយជ្រើសរើស
ការរៀនម៉ាស៊ីន។ 5. ដំណើរការ Demo: ស្វែងរក Voice Control Light demo ហើយចុច Run។ វានឹងបញ្ចេញប្រព័ន្ធគោលពីរដែលបានបង្កើតមុនមកលើក្ដាររបស់អ្នក។

៥/៥

មូលដ្ឋានគ្រឹះ
មូលដ្ឋានគ្រឹះ
មូលដ្ឋានគ្រឹះនៃការរៀនម៉ាស៊ីន
TensorFlow Lite សម្រាប់ Microcontrollers គឺជាក្របខ័ណ្ឌដែលផ្តល់នូវសំណុំឧបករណ៍សម្រាប់ដំណើរការការសន្និដ្ឋានបណ្តាញសរសៃប្រសាទលើ microcontrollers ។ វាមានជម្រើសដ៏ធំទូលាយនៃប្រតិបត្តិករខឺណែលជាមួយនឹងការគាំទ្រដ៏ល្អសម្រាប់បណ្តាញចំនួនគត់ 8 ប៊ីត។ ក្របខ័ណ្ឌត្រូវបានកំណត់ចំពោះការសន្និដ្ឋានគំរូ និងមិនគាំទ្រការបណ្តុះបណ្តាល។ សម្រាប់ព័ត៌មានអំពីរបៀបបណ្តុះបណ្តាលបណ្តាញសរសៃប្រសាទ សូមមើលឧបករណ៍សិក្សាម៉ាស៊ីន Silicon Labs (MLTK)។
Silicon Labs ផ្តល់នូវការរួមបញ្ចូល TensorFlow Lite សម្រាប់ Microcontrollers ជាមួយនឹង Simplicity SDK ។ សូមមើលការណែនាំអំពីការចាប់ផ្តើមសម្រាប់ការណែនាំជាជំហាន ៗ អំពីរបៀបប្រើប្រាស់ Machine Learning នៅក្នុងគម្រោងរបស់អ្នក។
សមាសភាគ SDK លើសview
សមាសធាតុកម្មវិធីដែលត្រូវការដើម្បីប្រើ TensorFlow Lite សម្រាប់ Microcontrollers អាចរកបាននៅក្រោម Machine Learning > TensorFlow នៅក្នុង UI browser សមាសភាគកម្មវិធីនៅក្នុងកម្មវិធីកំណត់រចនាសម្ព័ន្ធគម្រោង Simplicity Studio ។
TensorFlow Lite Micro
សមាសភាគនេះមាន TensorFlow Lite ពេញលេញសម្រាប់ក្របខ័ណ្ឌ Microcontrollers ហើយទាញដោយស្វ័យប្រវត្តិនូវការអនុវត្តដ៏ល្អប្រសើរបំផុតនៃខឺណែលសម្រាប់ឧបករណ៍ដែលបានជ្រើសរើសសម្រាប់គម្រោងតាមលំនាំដើម។ ដើម្បីប្រើ TensorFlow Lite Micro សមាសភាគនេះគឺតែមួយគត់ដែលត្រូវដំឡើងយ៉ាងជាក់លាក់។ ទោះយ៉ាងណាក៏ដោយ វាអាចទៅរួចក្នុងការដំឡើងការអនុវត្តខឺណែលផ្សេងៗដោយដៃ ប្រសិនបើចង់បាន ឧទាហរណ៍ ដើម្បីប្រៀបធៀបការអនុវត្តការសន្និដ្ឋាន ឬទំហំកូដ និងដើម្បីដំឡើងការអនុវត្តការកត់ត្រាបំបាត់កំហុសផ្សេងៗដោយដៃ។ តាមលំនាំដើម សមាសធាតុ TensorFlow Lite Micro ប្រើឧបករណ៍បំប្លែង Flatbuffer ដើម្បីបំប្លែង .tflite file ចូលទៅក្នុងអារេ C និងដើម្បីចាប់ផ្តើមគំរូបណ្តាញសរសៃប្រសាទនេះដោយស្វ័យប្រវត្តិ។ សូមមើលផ្នែកស្តីពីការចាប់ផ្តើមដោយស្វ័យប្រវត្តិសម្រាប់ព័ត៌មានលម្អិតបន្ថែម។
ការអនុវត្តខឺណែល
ខឺណែលយោង
សមាសភាគនេះផ្តល់នូវការអនុវត្តកម្មវិធីដែលមិនដំណើរការល្អនៃខឺណែលទាំងអស់។ នេះគឺជាការអនុវត្តលំនាំដើមដែលត្រូវបានរចនាឡើងដើម្បីងាយស្រួលអាន និងអាចដំណើរការលើវេទិកាណាមួយ។ ជាលទ្ធផល ខឺណែលទាំងនេះអាចដំណើរការយឺតជាងការអនុវត្តដ៏ល្អប្រសើរ។
ខឺណែលដែលបានកែលម្អ CMSIS-NN
ខឺណែលខ្លះមានការអនុវត្តដែលត្រូវបានធ្វើឱ្យប្រសើរឡើងសម្រាប់ស្ថាបត្យកម្មស៊ីភីយូជាក់លាក់ដោយប្រើបណ្ណាល័យ CMSIS-NN ។ ការប្រើប្រាស់ខឺណែលទាំងនេះនៅពេលដែលមានអាចធ្វើអោយប្រសើរឡើងនូវការអនុវត្តការសន្និដ្ឋានយ៉ាងសំខាន់។ តាមរយៈការបើកដំណើរការសមាសភាគនេះ ការអនុវត្តខឺណែលដែលបានធ្វើឱ្យប្រសើរឡើងដែលមានត្រូវបានបន្ថែមទៅគម្រោង ដោយជំនួសការអនុវត្តខឺណែលយោងដែលត្រូវគ្នា។ ខឺណែល។
ខឺណែលបង្កើនល្បឿន MVP
ខឺណែលមួយចំនួនមានការអនុវត្តដែលត្រូវបានធ្វើឱ្យប្រសើរឡើងសម្រាប់ឧបករណ៍បង្កើនល្បឿន MVP ដែលមាននៅលើផ្នែក Silicon Labs ដែលបានជ្រើសរើស។ ការប្រើប្រាស់ខឺណែលទាំងនេះនឹងធ្វើអោយប្រសើរឡើងនូវការអនុវត្តការសន្និដ្ឋាន។ តាមរយៈការបើកដំណើរការសមាសភាគនេះ ការអនុវត្តខឺណែលដែលបានពន្លឿនដែលមានត្រូវបានបន្ថែមទៅគម្រោង ដោយជំនួសការអនុវត្តខឺណែលដែលសមស្រប ឬយោង។ ខឺណែលដែលនៅសេសសល់ត្រលប់មកវិញដើម្បីប្រើការអនុវត្តន៍ដែលបានធ្វើឱ្យប្រសើរឡើង ឬយោងដោយអាស្រ័យលើសមាសធាតុដែលត្រូវគ្នា។ សូមមើលព័ត៌មានលម្អិតបន្ថែមអំពីឧបករណ៍បង្កើនល្បឿន ដើម្បីស្វែងយល់ពីអ្វីដែលខឺណែលត្រូវបានគាំទ្រ និងអ្វីដែលត្រូវអនុវត្ត។
ការលុបកំហុសដោយប្រើ I/O Stream / Disabled
ការកត់ត្រាបំបាត់កំហុសត្រូវបានប្រើនៅក្នុង TensorFlow ដើម្បីបង្ហាញព័ត៌មានបំបាត់កំហុស និងកំហុស។ លើសពីនេះទៀតវាអាចត្រូវបានប្រើដើម្បីបង្ហាញលទ្ធផលសន្និដ្ឋាន។ ការកត់ត្រាបំបាត់កំហុសត្រូវបានបើកតាមលំនាំដើម ជាមួយនឹងការអនុវត្តដែលប្រើ I/O Stream ដើម្បីបោះពុម្ពលើ UART ទៅ COM និម្មិត

៥/៥

មូលដ្ឋានគ្រឹះ
ច្រកនៅលើឧបករណ៍អភិវឌ្ឍន៍ (VCOM) ។ ការកត់ត្រាអាចត្រូវបានបិទដោយធានាថាសមាសធាតុ "ការបិទការកត់ត្រាកំហុស" ត្រូវបានរួមបញ្ចូលនៅក្នុងគម្រោង។
TensorFlow ភាពអាស្រ័យភាគីទីបី
កំណែជាក់លាក់នៃបណ្ណាល័យ CMSIS-NN ត្រូវបានប្រើដូចនឹង TensorFlow Lite សម្រាប់ Microcontrollers ដើម្បីបង្កើនប្រសិទ្ធភាពខឺណែលជាក់លាក់។ បណ្ណាល័យនេះត្រូវបានរួមបញ្ចូលនៅក្នុងគម្រោងរួមគ្នាជាមួយ TensorFlow Lite សម្រាប់ Microcontrollers ។ TensorFlow ពឹងផ្អែកលើកំណែគែមហូរឈាមនៃ CMSIS-NN ខណៈពេលដែលផ្នែកផ្សេងទៀតនៃ Simplicity SDK ប្រើការចេញផ្សាយ CMSIS ដែលមានស្ថេរភាព។ វាត្រូវបានផ្តល់អនុសាសន៍យ៉ាងខ្លាំងឱ្យជៀសវាងការប្រើមុខងារពីកំណែ Simplicity SDK នៃ CMSIS-DSP និង CMSIS-NN នៅកន្លែងផ្សេងទៀតក្នុងគម្រោង ហើយជំនួសមកវិញឱ្យប្រើកំណែដែលបានភ្ជាប់មកជាមួយ TensorFlow Lite សម្រាប់ Microcontrollers ដើម្បីជៀសវាងការប៉ះទង្គិចគ្នារវាងកំណែទាំងពីរ។
ឧបករណ៍បង្កើតមុខងារអូឌីយ៉ូ
ម៉ាស៊ីនបង្កើតមុខងារអូឌីយ៉ូអាចត្រូវបានប្រើដើម្បីទាញយកលក្ខណៈពិសេសប្រេកង់ពេលវេលាពីសញ្ញាអូឌីយ៉ូសម្រាប់ប្រើជាមួយកម្មវិធីចំណាត់ថ្នាក់អូឌីយ៉ូ (ML) ម៉ាស៊ីនរៀន។ អារេលក្ខណៈដែលបានបង្កើតគឺជាវិសាលគមមាត្រដ្ឋានមេល ដែលតំណាងឱ្យព័ត៌មានប្រេកង់នៃសញ្ញាដែលបានផ្ដល់ឱ្យampប្រវែងនៃអូឌីយ៉ូ។
នៅពេលប្រើរួមគ្នាជាមួយឧបករណ៍បំប្លែង Flatbuffer ឧបករណ៍បង្កើតមុខងារអូឌីយ៉ូតាមលំនាំដើមប្រើប្រាស់ការកំណត់រចនាសម្ព័ន្ធរបស់វាពីប៉ារ៉ាម៉ែត្រគំរូនៃ .tflite flatbuffer ។ ទិន្នន័យមេតាបែបនេះអាចត្រូវបានបន្ថែមទៅ flatbuffer ដោយប្រើឧបករណ៍សិក្សាម៉ាស៊ីន Silicon Labs ។ នេះធានាថាការកំណត់ដែលបានប្រើក្នុងអំឡុងពេលការសន្និដ្ឋាននៅលើឧបករណ៍បង្កប់ត្រូវគ្នានឹងការកំណត់ដែលបានប្រើអំឡុងពេលហ្វឹកហាត់។ ប្រសិនបើម៉ូដែលដែលគ្មានទិន្នន័យមេតាបែបនេះត្រូវបានប្រើប្រាស់ ជម្រើសកំណត់រចនាសម្ព័ន្ធ "បើកដំណើរការការកំណត់ផ្នែកខាងមុខដោយដៃ" អាចត្រូវបានបើក ហើយតម្លៃកំណត់រចនាសម្ព័ន្ធដែលបានកំណត់នៅក្នុងបឋមកថាការកំណត់រចនាសម្ព័ន្ធ sl_ml_audio_feature_generation_config.h ។
ការចាប់ផ្តើមដោយស្វ័យប្រវត្តិនៃគំរូលំនាំដើម
នៅពេលដែលសមាសភាគ TensorFlow Lite Micro ត្រូវបានបន្ថែមទៅគម្រោង វានឹងដោយការព្យាយាមលំនាំដើមដើម្បីចាប់ផ្តើមគំរូលំនាំដើមដោយស្វ័យប្រវត្តិដោយប្រើ TFLite Micro Init API ។ វាដំណើរការការចាប់ផ្តើមនៃ TensorFlow Lite Micro ដោយបង្កើតឧបករណ៍ដោះស្រាយ opcode និងអ្នកបកប្រែសម្រាប់ flatbuffer ដែលបានផ្តល់ឱ្យ។ លើសពីនេះ វាបង្កើតនូវ tensor arena buffer។
គំរូដែលប្រើដោយលេខកូដចាប់ផ្តើមដោយស្វ័យប្រវត្តិបានមកពី Flatbuffer Converter Tool។ ប្រសិនបើ flatbuffer ត្រូវបានផលិតដោយប្រើ MLTK វាអាចមានទិន្នន័យមេតាអំពីទំហំ tensor ចាំបាច់។ ប្រសិនបើព័ត៌មានបែបនេះមានវត្តមាន វានឹងត្រូវបានចាប់ផ្តើមដោយស្វ័យប្រវត្តិទៅទំហំត្រឹមត្រូវ។ ប្រសិនបើ flatbuffer មិនមែន MLTK ត្រូវបានប្រើប្រាស់ ទំហំ tensor arena ត្រូវតែកំណត់រចនាសម្ព័ន្ធដោយដៃដោយប្រើការកំណត់ file សម្រាប់សមាសភាគ TensorFlow Lite Micro ។
ប្រសិនបើការចាប់ផ្តើមដោយស្វ័យប្រវត្តិនៅពេលចាប់ផ្តើមមិនត្រូវបានចង់បានទេ វាអាចត្រូវបានបិទដោយប្រើជម្រើសកំណត់រចនាសម្ព័ន្ធស្វ័យប្រវត្តិគំរូ ( SL_TFLITE_MICRO_INTERPRETER_INIT_ENABLE ) ។
កំណែ
ផ្នែកបន្ថែមរបស់ Silicon Labs AI/ML រួមបញ្ចូល TensorFlow Lite សម្រាប់ Microcontrollers កំណែ #02414075e7f718a2d0412775fcadbf28fb4cc5aa នៅក្នុង third_party/tflite-micro/ ។ ស្នូល TensorFlow Lite សម្រាប់ Microcontrollers ផ្តល់ជូនគឺមិនត្រូវបានជួសជុលទេ មាតិកាបន្ថែមទាំងអស់សម្រាប់ឧបករណ៍ Silicon Labs ត្រូវបានចែកចាយនៅក្នុងថត root របស់ផ្នែកបន្ថែម។
ឧបករណ៍ភាគីទីបី និងដៃគូ
ឧបករណ៍
Netron គឺជាឧបករណ៍មើលឃើញសម្រាប់បណ្តាញសរសៃប្រសាទ ដែលអាចប្រើបានជាមួយគំរូ .tflite fileស. នេះមានប្រយោជន៍សម្រាប់ viewដោយប្រតិបត្តិការដែលប្រើក្នុងគំរូ ទំហំនៃ tensors និង kernels ។ល។
ដៃគូ AI/ML
ដៃគូរបស់ Silicon Labs AI/ML ផ្តល់នូវជំនាញ និងវេទិកាសម្រាប់ការប្រមូលទិន្នន័យ ការអភិវឌ្ឍន៍គំរូ និងការបណ្តុះបណ្តាល។ សូមមើលទំព័រដៃគូបច្ចេកវិទ្យា ដើម្បីស្វែងយល់បន្ថែម។

៥/៥

ឧបករណ៍បង្កើនល្បឿន MVP
ឧបករណ៍បង្កើនល្បឿន MVP
ឧបករណ៍បង្កើនល្បឿន MVP
ឧបករណ៍បង្កើនល្បឿន MVP គឺជាសហដំណើរការដែលត្រូវបានរចនាឡើងដើម្បីអនុវត្តប្រតិបត្តិការម៉ាទ្រីស និងវ៉ិចទ័រ។ ការប្រើប្រាស់ការពន្លឿនការអនុវត្តន៍ខឺណែលផ្នែករឹងនឹងកាត់បន្ថយពេលវេលានៃការសន្និដ្ឋានបណ្តាញសរសៃប្រសាទ ក៏ដូចជាបិទដំណើរការប្រព័ន្ធដំណើរការមេ ដើម្បីអនុញ្ញាតឱ្យវាបំពេញកិច្ចការផ្សេងទៀត ឬចូលគេង។ Silicon Labs បានអនុវត្តប្រតិបត្តិករបណ្តាញសរសៃប្រសាទទូទៅជាកម្មវិធីដែលត្រូវប្រតិបត្តិនៅលើ MVP និងរួមបញ្ចូលជាមួយ TensorFlow Lite សម្រាប់ Microcontrollers ។ MVP មានឧបករណ៍បញ្ជាអារេចំនួន 5 ដែលឧបករណ៍នីមួយៗអាចគាំទ្រការធ្វើឡើងវិញក្នុងវិមាត្រឯករាជ្យចំនួន 3 ។ វិមាត្រនីមួយៗត្រូវបានកំណត់ត្រឹម 1024 ធាតុ ជាមួយនឹងការបោះជំហានរវាងធាតុនីមួយៗនៃ 2047 ។ កត្តាកំណត់សម្រាប់ប្រតិបត្តិការបណ្តាញសរសៃប្រសាទភាគច្រើនគឺជាផលិតផលនៃវិមាត្រទទឹង និងជម្រៅ ចាប់តាំងពីវាក្លាយជាជំហាននៅក្នុងវិមាត្រកម្ពស់។ រាល់ប្រតិបត្តិការដែលបង្កើនល្បឿន MVP យកចំនួនគត់ 8 ប៊ីតដែលបានចុះហត្ថលេខាជាការបញ្ចូល និងលទ្ធផល។ ប្រសិនបើវិមាត្រខាងក្នុងនៃ tensor មានទំហំស្មើគ្នា នោះធាតុនីមួយៗអាចមានតម្លៃ int8 ពីរដែលត្រូវបានបកស្រាយថាជាតម្លៃ int8 ស្មុគស្មាញតែមួយដោយ accelerator ។ បន្ទាប់មកឧបករណ៍បង្កើនល្បឿនអាចគាំទ្រតម្លៃ 2048 int8 យ៉ាងមានប្រសិទ្ធភាព។ ប្រសិនបើវិមាត្រខាងក្នុងគឺសេស ឧបករណ៍បង្កើនល្បឿនត្រូវតែអនុវត្តការគណនាមួយក្នុងពេលតែមួយ ដែលកាត់បន្ថយការអនុវត្ត និងកំណត់ទំហំវិមាត្រដល់តម្លៃ 1024 int8។ ប្រតិបត្តិករដែលបានរាយខាងក្រោមនឹងត្រូវបានបង្កើនល្បឿនដោយប្រើ MVP ប្រសិនបើទំហំ tensor អនុញ្ញាត។ ប្រសិនបើ tensor ជាក់លាក់មិនអាចពន្លឿនបានទេ ការអនុវត្តនឹងត្រលប់មកវិញដោយស្វ័យប្រវត្តិនូវការប្រើប្រាស់ optimized (CMSIS-NN) ឬការអនុវត្តន៍ខឺណែលយោងនៅពេលដំណើរការ។ ដើម្បីបង្កើនលទ្ធភាពដែលប្រតិបត្តិករត្រូវបានគាំទ្រដោយឧបករណ៍បង្កើនល្បឿន សូមប្រើចំនួនប៉ុស្តិ៍ដែលមានតម្លៃស្មើគ្នានៅពេលរចនាគំរូ។ នៅខាងក្នុងឧបករណ៍បង្កើនល្បឿន MVP ប្រើគណិតវិទ្យាចំណុចអណ្តែត 16 ប៊ីត សូម្បីតែនៅពេលយកចំនួនគត់ 8 ប៊ីតជាការបញ្ចូលក៏ដោយ។ នេះមានន័យថាមានការថយចុះបន្តិចនៃភាពត្រឹមត្រូវនៃការគណនា ដែលវាអាចគួរឱ្យកត់សម្គាល់ជាពិសេសនៅពេលអនុវត្តប្រតិបត្តិការដែលប្រមូលផ្តុំធាតុជាច្រើន។ សម្រាប់ព័ត៌មានបន្ថែមអំពីឧបករណ៍បង្កើនល្បឿនផ្នែករឹង MVP សូមមើលសៀវភៅណែនាំសម្រាប់ EFR32xG24 ។
ប្រតិបត្តិករ TensorFlow បង្កើនល្បឿន
បន្ថែម
ឈ្មោះប្រតិបត្តិករ TensorFlow៖ ADD ទំហំ tensor ណាមួយត្រូវបានគាំទ្រ។
ភ្ជាប់យ៉ាងពេញលេញ (ក្រាស់)
ឈ្មោះប្រតិបត្តិករ TensorFlow៖ FULLY_CONNECTED , FULLY_CONNECTED_INT8 គាំទ្រ tensors ដែលវិមាត្រទាំងអស់ស្ថិតនៅក្នុងដែនកំណត់នៃធាតុ 1024 ។ គាំទ្រផងដែរនូវ tensors ធំជាងដែលទំហំនៃវិមាត្រចុងក្រោយគឺអាចបំបែកទៅជាកត្តាពីរដែលមានទាំងនៅក្នុងដែនកំណត់ធាតុ 1024 ។
AveragePool2D
ឈ្មោះប្រតិបត្តិករ TensorFlow៖ AVERAGE_POOL_2D គាំទ្រ tensors ដែលទទឹង * ឆានែលស្ថិតនៅក្នុងដែនកំណត់នៃធាតុ 2047 ហើយវិមាត្រទាំងអស់ស្ថិតនៅក្នុងដែនកំណត់ធាតុ 1024 ។
MaxPool2D
ឈ្មោះប្រតិបត្តិករ TensorFlow៖ MAX_POOL_2D

៥/៥

ឧបករណ៍បង្កើនល្បឿន MVP
គាំទ្រ tensors ដែលទទឹង * ឆានែលស្ថិតនៅក្នុងដែនកំណត់ជំហាននៃធាតុ 2047 ហើយវិមាត្រទាំងអស់ស្ថិតនៅក្នុងដែនកំណត់ធាតុ 1024 ។
Conv2D
ឈ្មោះប្រតិបត្តិករ TensorFlow៖ CONV_2D
គាំទ្រ tensors ដែលទទឹង * ឆានែលស្ថិតនៅក្នុងដែនកំណត់ជំហាននៃធាតុ 2047 ហើយវិមាត្រទាំងអស់ស្ថិតនៅក្នុងដែនកំណត់ធាតុ 1024 ។
DepthwiseConv2D
ឈ្មោះប្រតិបត្តិករ TensorFlow៖ DEPTHWISE_CONV_2D
គាំទ្រ tensors ដែលទទឹង * ឆានែលស្ថិតនៅក្នុងដែនកំណត់ជំហាននៃធាតុ 2047 ហើយវិមាត្រទាំងអស់ស្ថិតនៅក្នុងដែនកំណត់ធាតុ 1024 ។ ការពង្រីកមិនត្រូវបានគាំទ្រទេ។
TransposeConv2D
ឈ្មោះប្រតិបត្តិករ TensorFlow៖ TRANSPOSE_CONV_2D
គាំទ្រ tensors ដែលទទឹង * ឆានែលស្ថិតនៅក្នុងដែនកំណត់ជំហាននៃធាតុ 2047 ហើយវិមាត្រទាំងអស់ស្ថិតនៅក្នុងដែនកំណត់ធាតុ 1024 ។ ការពង្រីកមិនត្រូវបានគាំទ្រទេ។
ផ្អាកការប្រតិបត្តិខណៈពេលរង់ចាំឧបករណ៍ពន្លឿន
API កម្មវិធីសម្រាប់ឧបករណ៍បង្កើនល្បឿន MVP កំពុងរារាំង មានន័យថាការហៅទៅកាន់កម្មវិធីបញ្ជា MVP នឹងរង់ចាំការបញ្ចប់ មុនពេលត្រឡប់ពីការហៅមុខងារ។ ដើម្បីសន្សំសំចៃថាមពល អ្នកបើកបរអាចផ្អាកដំណើរការប្រព័ន្ធដំណើរការមេជាជម្រើស ខណៈពេលរង់ចាំឧបករណ៍បង្កើនល្បឿនដើម្បីបញ្ចប់ប្រតិបត្តិការ។ តាមលំនាំដើម ខួរក្បាលចម្បងរវល់ - រង់ចាំសម្រាប់ឧបករណ៍បង្កើនល្បឿន។
គេងមិនលក់ (0)
នៅពេលដែលជម្រើស "No sleep" ត្រូវបានប្រើ ស្នូល MCU នឹងរវល់ - រង់ចាំ MVP បញ្ចប់។ នេះគឺជាជម្រើសដែលផ្តល់នូវពេលវេលាប្រតិបត្តិ MVP លឿនបំផុត។ ជម្រើស "គ្មានការគេង" អាចត្រូវបានប្រើនៅក្នុងកម្មវិធីដែកទទេ ឬកម្មវិធីដោយប្រើប្រព័ន្ធប្រតិបត្តិការពេលវេលាពិត (RTOS) ។
បញ្ចូល EM1 (1)
នៅពេលដែលជម្រើស "Enter EM1" ត្រូវបានប្រើ MCU នឹងត្រូវបានដាក់ចូលទៅក្នុងរបៀបថាមពល 1 នៅពេលណាដែលអ្នកបើកបររង់ចាំកម្មវិធី MVP ដើម្បីបញ្ចប់។ ជម្រើស “Enter EM1” មិនមានសុវត្ថិភាពក្នុងការប្រើប្រាស់នៅក្នុងកម្មវិធីដោយប្រើ RTOS ទេព្រោះវានឹងការពារការកំណត់ពេល RTOS ត្រឹមត្រូវ។
ផ្តល់ទិន្នផលខ្សែស្រឡាយ RTOS (2)
នៅពេលដែលជម្រើស "Yield RTOS thread" ត្រូវបានប្រើ កិច្ចការដែលរង់ចាំកម្មវិធី MVP បញ្ចប់នឹងផ្តល់លទ្ធផល ដែលអនុញ្ញាតឱ្យកិច្ចការផ្សេងទៀតនៅក្នុងប្រព័ន្ធដំណើរការ ឬអាចឱ្យអ្នកកំណត់ពេលដាក់ប្រព័ន្ធចូលទៅក្នុងរបៀបគេង។ "Yield RTOS thread" តម្រូវឱ្យកម្មវិធីកំពុងប្រើ RTOS ។ របៀបថាមពលរបស់កម្មវិធីបញ្ជា MVP អាចត្រូវបានកំណត់រចនាសម្ព័ន្ធដោយកំណត់ជម្រើសកំណត់រចនាសម្ព័ន្ធ SL_MVP_POWER_MODE នៅក្នុងបឋមកថាការកំណត់រចនាសម្ព័ន្ធ sl_mvp_config.h ។

៥/៥

មគ្គុទ្ទេសក៍អ្នកអភិវឌ្ឍន៍
មគ្គុទ្ទេសក៍អ្នកអភិវឌ្ឍន៍
មគ្គុទ្ទេសក៍អ្នកអភិវឌ្ឍន៍ការរៀនម៉ាស៊ីន
ខ្លឹមសារមគ្គុទ្ទេសក៍របស់អ្នកអភិវឌ្ឍន៍ត្រូវបានរៀបចំដូចខាងក្រោម៖ បន្ថែមការរៀនម៉ាស៊ីនទៅកាន់គម្រោងថ្មី ឬដែលមានស្រាប់៖ ពិពណ៌នាអំពីដំណើរការនៃការបន្ថែមគំរូរៀនម៉ាស៊ីនទៅគម្រោងថ្មី ឬគម្រោងដែលមានស្រាប់។ ធ្វើបច្ចុប្បន្នភាព ឬជំនួស .tflite File៖ ពិពណ៌នាអំពីជំហានដើម្បីធ្វើបច្ចុប្បន្នភាព និងជំនួសគំរូសិក្សាម៉ាស៊ីននៅក្នុងគម្រោងរបស់អ្នក។ ការអភិវឌ្ឍន៍គំរូ៖ ពន្យល់ពីដំណើរការបង្កើតគំរូរៀនម៉ាស៊ីន។ ការដំឡើងផ្នែកបន្ថែម AI/ML៖ ការពន្យល់ស៊ីជម្រៅនៃការបន្ថែមផ្នែកបន្ថែម AI/ML ទៅក្នុងការដំឡើង។ ឧបករណ៍បំលែង Flatbuffer៖ បង្ហាញពីរបៀបដែល flatbuffer ត្រូវបានបំប្លែងទៅជាបៃសម្រាប់បញ្ចូលទៅក្នុងបឋមកថា file. ការកំណត់រចនាសម្ព័ន្ធ I2S សម្រាប់ SiWx917៖ ផ្តល់ព័ត៌មានលម្អិតអំពីការកំណត់រចនាសម្ព័ន្ធ I2S សម្រាប់កម្មវិធីអូឌីយ៉ូ AI/ML នៅលើ SiWx917។

៥/៥

បន្ថែមការរៀនម៉ាស៊ីនទៅគម្រោងថ្មី ឬដែលមានស្រាប់
បន្ថែមការរៀនម៉ាស៊ីនទៅគម្រោងថ្មី ឬដែលមានស្រាប់
បន្ថែមការរៀនម៉ាស៊ីនទៅគម្រោងថ្មី ឬដែលមានស្រាប់
មគ្គុទ្ទេសក៍នេះផ្តល់នូវព័ត៌មានលម្អិតនៃការបន្ថែម Machine Learning ទៅក្នុងគម្រោងថ្មី ឬដែលមានស្រាប់ ដោយប្រើប្រាស់ wrapper APIs សម្រាប់ TensorFlow Lite សម្រាប់ Microcontrollers ដែលផ្តល់ដោយ Silicon Labs សម្រាប់ការចាប់ផ្តើមដោយស្វ័យប្រវត្តិនៃក្របខ័ណ្ឌ TFLM ។ មគ្គុទ្ទេសក៍សន្មតថាគម្រោងមានរួចហើយនៅក្នុងកន្លែងធ្វើការ Simplicity Studio ហើយអ្នកបានដំឡើងផ្នែកបន្ថែម AI/ML ។ ប្រសិនបើអ្នកចាប់ផ្តើមពីដំបូង អ្នកអាចចាប់ផ្តើមជាមួយ s ណាមួយ។ampកម្មវិធី le ឬកម្មវិធី C++ ទទេ។ សូមមើលការដំឡើងផ្នែកបន្ថែម AI/ML សម្រាប់ការណែនាំក្នុងការដំឡើងផ្នែកបន្ថែម AI/ML។ TFLM មាន C++ API ដូច្នេះកូដកម្មវិធីដែលភ្ជាប់ជាមួយវាក៏នឹងត្រូវសរសេរជា C++ ផងដែរ។ ប្រសិនបើអ្នកចាប់ផ្តើមជាមួយកម្មវិធីដែលភាគច្រើនជាកូដ C សូមមើលផ្នែកស្តីពីការភ្ជាប់ជាមួយកូដ C សម្រាប់ការណែនាំអំពីរបៀបរៀបចំគម្រោងរបស់អ្នកដោយបន្ថែម C++ ដាច់ដោយឡែក។ file សម្រាប់ចំណុចប្រទាក់ TFLM ។
ដំឡើង TensorFlow Lite Micro Component
1. បើកគម្រោងរបស់អ្នក។ file (មួយដែលមានផ្នែកបន្ថែម .slcp) ។
2. នៅក្រោមសមាសភាគកម្មវិធី សូមស្វែងរក " aiml" ។
3. បើកដំណើរការផ្នែកបន្ថែម AI/ML ដោយចុច Enable Extension។
4. ពង្រីក៖ AI/ML > Machine Learning > TensorFlow។ ជ្រើសរើស TensorFlow Lite Micro ហើយចុចដំឡើង។ ចំណាំ៖ រំលងជំហាននេះសម្រាប់កម្មវិធី SiWx917។

៥/៥

បន្ថែមការរៀនម៉ាស៊ីនទៅគម្រោងថ្មី ឬដែលមានស្រាប់ 5. អ្នកនឹងត្រូវបានជម្រុញឱ្យជ្រើសរើសសមាសធាតុបន្ថែម៖ ចំណាំ៖ រំលងជំហាននេះសម្រាប់កម្មវិធី SiWx917 ។
Debug Loggging៖ ជ្រើសរើស Debug Loggging ដោយប្រើ IO Stream (ប្រសិនបើចាំបាច់) ឬ Debug Logging Disabled។ ចុចដំឡើង។ ចំណាំ៖ ប្រសិនបើគម្រោងរបស់អ្នកមិនទាន់មានការអនុវត្ត I/O Stream ទេ អ្នកអាចទទួលបានការព្រមានអំពីសុពលភាពភាពអាស្រ័យ។ នេះមិនមែនជាបញ្ហាទេ ប៉ុន្តែគ្រាន់តែមានន័យថា ការជ្រើសរើសផ្នែកខាងក្រោយ I/O Stream ត្រូវតែធ្វើឡើង ផ្នែកខាងក្រោយរបស់ USART ឬ EUSART គឺជារឿងធម្មតាបំផុត ព្រោះឧបករណ៍ទាំងនេះអាចទាក់ទងជាមួយកុំព្យូទ័រដែលបានភ្ជាប់តាមរយៈឧបករណ៍អភិវឌ្ឍន៍និម្មិតច្រក COM (VCOM) ។

IO Stream៖ អ្នកប្រហែលជាត្រូវដំឡើងសមាសភាគ EUSART ឬ USART ប្រសិនបើអ្នកមិនឃើញលទ្ធផលនៅលើកុងសូលសៀរៀលរបស់អ្នក។

ទទួលយកការផ្ដល់យោបល់លំនាំដើមនៃ "vcom" ជាឈ្មោះឧទាហរណ៍ ដែលនឹងកំណត់រចនាសម្ព័ន្ធ pinout ដោយស្វ័យប្រវត្តិដើម្បីភ្ជាប់ទៅបន្ទាត់ VCOM របស់ក្រុមប្រឹក្សាភិបាលអភិវឌ្ឍន៍។ ប្រសិនបើអ្នកកំពុងប្រើ hardware ផ្ទាល់ខ្លួនរបស់អ្នក អ្នកអាចកំណត់ឈ្មោះ instance ណាមួយ ហើយកំណត់រចនាសម្ព័ន្ធ pinout ដោយដៃ។

៥/៥

បន្ថែមការរៀនម៉ាស៊ីនទៅគម្រោងថ្មី ឬដែលមានស្រាប់
សមាសភាគកម្មវិធីបន្ថែម និងការកំណត់បង្កើត C++
ចំណាំ៖ រំលងទៅផ្នែកការដាក់បញ្ចូលគំរូសម្រាប់ឧបករណ៍ស៊េរី 2 ។ ផ្នែកនេះអាចអនុវត្តបានសម្រាប់ឧបករណ៍ SiWx917 ប៉ុណ្ណោះ។ 1. សូមប្រាកដថាសមាសធាតុខាងក្រោមត្រូវបានដំឡើងនៅក្នុងគម្រោងរបស់អ្នក។
WiseConnect SDK > ឧបករណ៍ > Si91X > MCU > សេវាកម្ម > កម្មវិធីគ្រប់គ្រងថាមពល > កម្មវិធីកំណត់ពេលគេងសម្រាប់ Si91x Platform > Peripheral > Common headers

2. ធ្វើបច្ចុប្បន្នភាពការកំណត់ C++ build របស់អ្នកដូចខាងក្រោម៖ នៅក្នុង C preprocessor កំណត់ បន្ថែម៖ SUPPORT_CPLUSPLUS ។ នៅក្នុង GNU ARM C++ Compiler > ការកំណត់ផ្សេងៗ បន្ថែម៖ -mfp16-format=ieee ។
រក្សាសិទ្ធិ © 2025 Silicon Laboratories ។ រក្សារសិទ្ធគ្រប់យ៉ាង។

៥/៥

បន្ថែមការរៀនម៉ាស៊ីនទៅគម្រោងថ្មី ឬដែលមានស្រាប់

៥/៥

បន្ថែមការរៀនម៉ាស៊ីនទៅគម្រោងថ្មី ឬដែលមានស្រាប់

វិធីសាស្ត្រជំនួស៖ អ្នកក៏អាចបន្ថែមការកំណត់ទាំងនេះដោយផ្ទាល់ទៅ .slcp នៃគម្រោងរបស់អ្នក។ file:
បើក .slcp file នៅក្នុងកម្មវិធីនិពន្ធអត្ថបទ។ បន្ថែម SUPPORT_CPLUSPLUS ទៅផ្នែកកំណត់សម្រាប់ C preprocessor កំណត់។ សម្រាប់អតីតampលេ៖
កំណត់៖ – ឈ្មោះ៖ តម្លៃ SUPPORT_CPLUSPLUS៖ ១
បន្ថែម -mfp16-format=ieee ទៅផ្នែក toolchain_settings សម្រាប់ទង់អ្នកចងក្រង C++ សម្រាប់ឧ.ampលេ៖
toolchain_settings៖ – ជម្រើស៖ gcc_compiler_option តម្លៃ៖ -mfp16-format=ieee
រក្សាទុក file និងបង្កើតគម្រោងរបស់អ្នកឡើងវិញ ដើម្បីអនុវត្តការផ្លាស់ប្តូរ។
ការរួមបញ្ចូលគំរូ
ជាមួយនឹងសមាសភាគ TensorFlow Lite Micro បានបន្ថែមនៅក្នុង Project Configurator ជំហានបន្ទាប់គឺត្រូវផ្ទុកគំរូ file ចូលទៅក្នុងគម្រោង។ ដើម្បីធ្វើដូចនេះបង្កើតថតឯកសារ tflite នៅខាងក្នុងថតកំណត់រចនាសម្ព័ន្ធនៃគម្រោង ហើយចម្លងគំរូ .tflite file ចូលទៅក្នុងវា។ កម្មវិធីកំណត់រចនាសម្ព័ន្ធគម្រោងផ្តល់ឧបករណ៍ដែលនឹងបំប្លែង .tflite ដោយស្វ័យប្រវត្តិ files ចូលទៅក្នុងប្រភព sl_tflite_micro_model និងបឋមកថា fileស. ឯកសារពេញលេញសម្រាប់ឧបករណ៍នេះមាននៅ Flatbuffer Converter Tool។
សម្រាប់ឧបករណ៍ SiWx917 បន្ទាប់ពីចម្លងគំរូ .tflite file ចូលទៅក្នុងគម្រោង, បឋមកថាមួយ។ file ដាក់ឈ្មោះ sl_ml_model_ .h ត្រូវបានបង្កើត។ បឋមកថានេះផ្តល់នូវការចូលទៅកាន់អារេ C ដែលទទួលបានពី .tflite ដែលបានបំប្លែង fileក៏ដូចជា APIs ដើម្បីចាប់ផ្តើម និងដំណើរការគំរូ។
ការចាប់ផ្តើមដោយស្វ័យប្រវត្តិ

៥/៥

បន្ថែមការរៀនម៉ាស៊ីនទៅគម្រោងថ្មី ឬដែលមានស្រាប់
ក្របខ័ណ្ឌ TensorFlow ត្រូវបានចាប់ផ្តើមដោយស្វ័យប្រវត្តិដោយប្រើគ្រោងការណ៍ចាប់ផ្តើមប្រព័ន្ធដែលបានពិពណ៌នានៅក្នុងគំរូកម្មវិធី SDK ។ នេះរួមបញ្ចូលទាំងការបែងចែក tensor Arena, instantiating អ្នកបកប្រែ និងការផ្ទុកគំរូ។
ការកំណត់រចនាសម្ព័ន្ធ
ចំណាំ៖ ការកំណត់រចនាសម្ព័ន្ធទាំងអស់សម្រាប់ SiWx917 ត្រូវបានយកចិត្តទុកដាក់ដោយស្វ័យប្រវត្តិ។
ប្រសិនបើគំរូនេះត្រូវបានផលិតដោយប្រើឧបករណ៍សិក្សាម៉ាស៊ីន Silicon Labs (MLTK) វាមានទិន្នន័យមេតាដែលបង្ហាញពីទំហំដែលត្រូវការនៃ Tensor Arena ដែលជាទំហំអង្គចងចាំដែលប្រើប្រាស់ដោយ TensorFlow សម្រាប់ដំណើរការផ្ទុករយៈពេលដំណើរការនៃធាតុបញ្ចូល ទិន្នផល និងអារេកម្រិតមធ្យម។ ទំហំដែលត្រូវការនៃសង្វៀនគឺអាស្រ័យលើគំរូដែលបានប្រើ។ ប្រសិនបើមិនប្រើ MLTK ទេ ទំហំសង្វៀនត្រូវកំណត់រចនាសម្ព័ន្ធ។ នេះអាចត្រូវបានធ្វើតាមពីរវិធី៖
[ស្វ័យប្រវត្តិ] កំណត់ទំហំសង្វៀនទៅ -1 ហើយវានឹងព្យាយាមធ្វើការសន្និដ្ឋានដោយស្វ័យប្រវត្តិនៅពេលចាប់ផ្តើម។ [សៀវភៅណែនាំ] ចាប់ផ្តើមជាមួយនឹងចំនួនច្រើនកំឡុងពេលអភិវឌ្ឍន៍ ហើយកាត់បន្ថយការបែងចែករហូតដល់ការចាប់ផ្តើមបរាជ័យជាផ្នែកនៃការបង្កើនប្រសិទ្ធភាពទំហំ។

ដំណើរការគំរូសម្រាប់ឧបករណ៍ស៊េរី 2
រួមបញ្ចូល Silicon Labs TensorFlow Init API
# រួមបញ្ចូល “sl_tflite_micro_init.h”
សម្រាប់ឥរិយាបទលំនាំដើមនៅក្នុងកម្មវិធីដែកទទេ វាត្រូវបានផ្ដល់អនុសាសន៍ឱ្យដំណើរការគំរូកំឡុងពេល app_process_action() នៅក្នុង app.cpp ដើម្បីធានាថាការសន្និដ្ឋានតាមកាលកំណត់កើតឡើងក្នុងអំឡុងពេលរង្វិលជុំព្រឹត្តិការណ៍ស្តង់ដារ។ ការរត់ម៉ូដែលពាក់ព័ន្ធនឹងបី stages: ផ្តល់ការបញ្ចូលទៅក្នុងទិន្នន័យឧបករណ៍ចាប់សញ្ញាអ្នកបកប្រែត្រូវបានដំណើរការជាមុន (បើចាំបាច់) ហើយបន្ទាប់មកត្រូវបានផ្តល់ជាការបញ្ចូលទៅអ្នកបកប្រែ។
TfLiteTensor* បញ្ចូល = sl_tflite_micro_get_input_tensor(); // រក្សាទុក 0.0 ទៅ tensor បញ្ចូលនៃ model input->data.f[0] = 0.;

៥/៥

បន្ថែមការរៀនម៉ាស៊ីនទៅគម្រោងថ្មី ឬដែលមានស្រាប់
ដំណើរការការសន្និដ្ឋាន
បន្ទាប់មកអ្នកបកប្រែត្រូវបានហៅឱ្យដំណើរការស្រទាប់ទាំងអស់នៃគំរូ។
TfLiteStatus invoke_status = sl_tflite_micro_get_interpreter()->Invoke(); ប្រសិនបើ (invoke_status != kTfLiteOk) { TF_LITE_REPORT_ERROR(sl_tflite_micro_get_error_reporter(),
"ប៉ារ៉ាម៉ែត្រ tensor បញ្ចូលមិនល្អនៅក្នុងគំរូ"); ត្រឡប់មកវិញ; }
អានលទ្ធផលសម្រាប់ឧបករណ៍ស៊េរី 2
ការព្យាករណ៍លទ្ធផលត្រូវបានអានពីអ្នកបកប្រែ។
TfLiteTensor* លទ្ធផល = sl_tflite_micro_get_output_tensor(); // ទទួលបានតម្លៃលទ្ធផលពីតម្លៃ tensor float = output->data.f[0];
នៅចំណុចនេះ ឥរិយាបថអាស្រ័យលើកម្មវិធីដោយផ្អែកលើការព្យាករណ៍លទ្ធផលគួរតែត្រូវបានអនុវត្ត។ កម្មវិធីនឹងដំណើរការការសន្និដ្ឋានលើការធ្វើឡើងវិញនីមួយៗនៃ app_process_action() ។
សម្រង់កូដពេញលេញ (ស៊េរីទី 2)
បន្ទាប់ពីធ្វើតាមជំហានខាងលើ លទ្ធផល app.cpp ឥឡូវនេះលេចឡើងដូចខាងក្រោម៖
# រួមបញ្ចូល “sl_tflite_micro_init.h”
/*************************************************************************************//** * ចាប់ផ្តើមកម្មវិធី។ ***********************************************************************************/
void app_init(void) {
// វាកើតឡើងដោយស្វ័យប្រវត្តិ }
/*************************************************************************************//** * មុខងារធីកកម្មវិធី។ ***********************************************************************************/
void app_process_action(void) {
TfLiteTensor* បញ្ចូល = sl_tflite_micro_get_input_tensor(); // រក្សាទុក 0.0 ទៅ tensor បញ្ចូលនៃ model input->data.f[0] = 0.;
TfLiteStatus invoke_status = sl_tflite_micro_get_interpreter()->Invoke(); ប្រសិនបើ (invoke_status != kTfLiteOk) { TF_LITE_REPORT_ERROR(sl_tflite_micro_get_error_reporter(),
"ប៉ារ៉ាម៉ែត្រ tensor បញ្ចូលមិនល្អនៅក្នុងគំរូ"); ត្រឡប់មកវិញ; }
TfLiteTensor* លទ្ធផល = sl_tflite_micro_get_output_tensor(); // ទទួលបានតម្លៃលទ្ធផលពីតម្លៃ tensor float = output->data.f[0]; }
ដំណើរការគំរូសម្រាប់ឧបករណ៍ SiWx917

៥/៥

បន្ថែមការរៀនម៉ាស៊ីនទៅគម្រោងថ្មី ឬដែលមានស្រាប់
សម្រាប់ឧបករណ៍ SiWx917 APIs ខុសពីស៊េរី 2។ ប្រើគំរូ C++ APIs ដែលបានបង្កើត ដើម្បីចាប់ផ្តើម និងដំណើរការគំរូរបស់អ្នក។ ខាងក្រោមនេះគឺជាការណែនាំទូទៅសម្រាប់ការប្រើប្រាស់ APIs ទាំងនេះ៖
1. រួមបញ្ចូលបឋមកថាដែលត្រូវការ
// ផ្តល់មុខងារ _init() និង _run() សម្រាប់ម៉ូដែលនេះ #include “sl_ml_model_ .h” // …បឋមកថាផ្សេងទៀតតាមតម្រូវការ…
៤.៦. ការចាប់ផ្តើមប្រព័ន្ធ
sl_system_init();
3. ការចាប់ផ្តើមគំរូ
// ផ្ទុក និងចាប់ផ្តើមម៉ូដែលដោយឈ្មោះ // ចាប់ផ្តើមប៉ារ៉ាម៉ែត្ររបស់វា // ចាប់ផ្តើមអ្នកបកប្រែរបស់វា // ចាប់ផ្តើមអ្នករាយការណ៍កំហុសរបស់វា // បែងចែកអង្គចងចាំសម្រាប់ tensors របស់ម៉ូដែល
ស្ថានភាព sl_status_t = slx_ml_ _គំរូ_init(); ប្រសិនបើ (ស្ថានភាព != SL_STATUS_OK) {
printf(“បរាជ័យក្នុងការចាប់ផ្តើមគំរូ”); // ដោះស្រាយកំហុស }
4. ចូលប្រើ និងរៀបចំ Input Tensors
សម្រាប់ (មិនបានចុះហត្ថលេខា int i = 0; i < _model.n_inputs(); ++i) { auto& input_tensor = * _model.input(i); // បំពេញ input_tensor.data ជាមួយនឹងទិន្នន័យបញ្ចូលរបស់អ្នក។
}
5. ដំណើរការការសន្និដ្ឋាន
/// ប្រតិបត្តិគំរូដោយឈ្មោះ ដោយការហៅអ្នកបកប្រែរបស់ខ្លួនសម្រាប់ TFLite Micro និងត្រឡប់ស្ថានភាពប្រតិបត្តិ។ /// ទិន្នផលត្រូវបានរក្សាទុកក្នុង output tensor នៃ model ខ្លួនវាផ្ទាល់។ ស្ថានភាព = slx_ml_model_ _រត់(); ប្រសិនបើ (ស្ថានភាព != SL_STATUS_OK) {
printf(“កំហុសខណៈពេលកំពុងដំណើរការការសន្និដ្ឋាន”); // ដោះស្រាយកំហុស }
6. Access Output Tensors
សម្រាប់ (មិនបានចុះហត្ថលេខា int i = 0; i < _model.n_outputs(); ++i) { auto&output_tensor = * _model.output(i); // អានលទ្ធផលពី output_tensor.data
}
សម្រង់កូដពេញលេញ (SiWx917)
ខាងក្រោមនេះគឺជាព័ត៌មានសង្ខេបនៃកូដទូទៅសម្រាប់ដំណើរការម៉ូដែលនៅលើឧបករណ៍ SiWx917។ ជំនួស ជាមួយនឹងឈ្មោះម៉ូដែលពិតប្រាកដរបស់អ្នក។
app.h

៥/៥

បន្ថែមការរៀនម៉ាស៊ីនទៅគម្រោងថ្មី ឬដែលមានស្រាប់
#ifndef APP_H #define APP_H
#ifdef __cplusplus extern “C” { #endif
void app_init(void); មោឃៈ app_process_action (ទុកជាមោឃៈ);
#ifdef __cplusplus } #endif
#endif // APP_H
app.cc
#include “app.h” #include “model_runner.h”
sl_status_t _model_status = SL_STATUS_OK;
// តក្កវិជ្ជាចាប់ផ្តើមជាមោឃៈ app_init (ចាត់ទុកជាមោឃៈ) {
_model_status = model_runner_init(); ប្រសិនបើ ( _model_status != SL_STATUS_OK) {
// បោះពុម្ពសារកំហុសមានប្រយោជន៍ ឬដោះស្រាយការត្រឡប់កំហុស; } }
void app_process_action(ចាត់ទុកជាមោឃៈ) { ប្រសិនបើ ( _model_status != SL_STATUS_OK) { // បោះពុម្ពសារកំហុស ឬបង្ហាញកំហុសត្រឡប់មកវិញ; } model_runner_loop();
}
model_runner.cc

៥/៥

បន្ថែមការរៀនម៉ាស៊ីនទៅគម្រោងថ្មី ឬដែលមានស្រាប់
# រួមបញ្ចូល “sl_ml_model_ .h”
sl_status_t model_runner_init (ចាត់ទុកជាមោឃៈ) { // តក្កវិជ្ជានៃគ្រឿងកុំព្យូទ័រ និងការចាប់ផ្តើមផ្សេងទៀត
_model_status = slx_ml_ _គំរូ_init();
ប្រសិនបើ ( _model_status != SL_STATUS_OK) { // peripheral deinit ឬ cleanup logic return SL_STATUS_FAIL;
} ត្រឡប់មកវិញ ស្ថានភាព _model_; }
sl_status_t model_runner_loop (ចាត់ទុកជាមោឃៈ) { // ការចាប់យកទិន្នន័យ និងតក្កវិជ្ជាដំណើរការមុន
_model_status = slx_ml_ _model_run();
ប្រសិនបើ ( _model_status != SL_STATUS_OK) { // peripheral deinit ឬ cleanup logic return SL_STATUS_FAIL;
}
// តក្កវិជ្ជាក្រោយដំណើរការ
ត្រឡប់មកវិញ ស្ថានភាព _model_; }
ឧបសម្ព័ន្ធ៖ ចំណុចប្រទាក់ជាមួយលេខកូដ C
ប្រសិនបើគម្រោងរបស់អ្នកត្រូវបានសរសេរជា C ជាជាង C ++ សូមដាក់កូដអន្តរកម្មជាមួយ TFLM ដាច់ដោយឡែក file ដែលនាំចេញ C API តាមរយៈបឋមកថាចំណុចប្រទាក់។ សម្រាប់អតីតនេះ។ampលេ, អេ fileឈ្មោះ app_ml.cpp ត្រូវបានសន្មត់ថាអនុវត្តមុខងារ ml_process_action() ជាមួយនឹងមាតិកាដូចគ្នានឹងអតីតample ខាងលើ។
app_ml.h
#ifdef __cplusplus extern “C” { #endif
មោឃៈ ml_process_action (មោឃៈ);
#ifdef __cplusplus } #endif
app_ml.cpp
#include “app_ml.h” #include “sl_tflite_micro_init.h”
ខាងក្រៅ “C” ចាត់ទុកជាមោឃៈ ml_process_action (ទុកជាមោឃៈ) {
// … }
app.c

៥/៥

បន្ថែមការរៀនម៉ាស៊ីនទៅគម្រោងថ្មី ឬដែលមានស្រាប់
#include “app_ml.h” // … void app_process_action(void) {
ml_process_action(); }
ឧបសម្ព័ន្ធ៖ ស៊េរីទី 2 ទៅ SiWx917 (និងផ្ទុយមកវិញ) ការបំប្លែងកម្មវិធី
ប្រសិនបើអ្នកត្រូវការច្រកកម្មវិធីពីស៊េរី 2 ទៅ SiWx917 ដំបូងអ្នកត្រូវដកសមាសភាគ TensorFlow Lite Micro ចេញពីគម្រោងរបស់អ្នក។ បន្ទាប់មក សូមអនុវត្តតាមជំហានទាំងនេះសម្រាប់ការបន្ថែមសមាសធាតុកម្មវិធីដែលត្រូវការ និងការកំណត់បង្កើត C++ ។ សម្រាប់ឧបករណ៍ SiWx917 APIs និងដំណើរការការងារខុសគ្នាពីស៊េរី 2។ ប្រើគំរូ C++ APIs ដែលបានបង្កើតដូចដែលបានពិពណ៌នានៅក្នុងផ្នែក Run the Model for SiWx917 Devices ខាងលើ។ សូមមើលផ្នែកខ្លីៗនៃកូដដែលបានផ្តល់ និងការណែនាំជាជំហានៗនៅលើទំព័រនេះ សម្រាប់ព័ត៌មានលម្អិតស្តីពីការចាប់ផ្តើម ការដំណើរការការសន្និដ្ឋាន និងការចូលប្រើធាតុបញ្ចូល/ទិន្នផល tensors ។ សម្រាប់ ex ពេញលេញampសូមមើលផ្នែក Full Code Snippet (SiWx917) ។ បន្ទាប់ពីធ្វើបច្ចុប្បន្នភាពគម្រោងរបស់អ្នក សូមបង្កើតវាឡើងវិញ ដើម្បីធានាថាភាពអាស្រ័យទាំងអស់ត្រូវបានកំណត់រចនាសម្ព័ន្ធយ៉ាងត្រឹមត្រូវ។

៥/៥

ធ្វើបច្ចុប្បន្នភាព ឬជំនួស .tflite File
ធ្វើបច្ចុប្បន្នភាព ឬជំនួស .tflite File
ការធ្វើបច្ចុប្បន្នភាព ឬជំនួស .tflite File នៅក្នុងគម្រោងមួយ។
មគ្គុទ្ទេសក៍នេះពិពណ៌នាអំពីរបៀបផ្លាស់ប្តូរគំរូនៅក្នុងគម្រោងដែលមានស្រាប់។ វាសន្មត់ថាគម្រោងនេះប្រើឧបករណ៍បំលែង Flatbuffer ។
ជំនួសម៉ូដែល
ដើម្បីជំនួសគំរូនៅក្នុងគម្រោងដែលមានស្រាប់ អូសហើយទម្លាក់គំរូថ្មី។ file ចូលទៅក្នុង config/tflite/ directory នៃគម្រោង។ ប្រសិនបើម៉ូដែលថ្មីមានដូចគ្នា។ file ដាក់ឈ្មោះជាគំរូមុន ទទួលយកប្រអប់បញ្ចូលដើម្បីសរសេរជាន់លើ file. ប្រសិនបើម៉ូដែលថ្មីមានឈ្មោះផ្សេង សូមលុប ឬប្តូរឈ្មោះ .tflite ចាស់ file ដូច្នេះវាលែងមានផ្នែកបន្ថែម .tflite ទៀតហើយ។ ឧបករណ៍បំប្លែង Flatbuffer នឹងដំណើរការដោយស្វ័យប្រវត្តិ នៅពេលអ្នកមើលថតសម្គាល់ថា .tflite ខុសគ្នា file គឺមានវត្តមាន។
ចំណាំ៖ ប្រសិនបើអ្នកមាន .tflite ច្រើន។ files នៅក្នុង config/tflite/ directory ឧបករណ៍បំលែងនឹងជ្រើសរើសដំបូង file តាមលំដាប់អក្ខរក្រម។ អាស្រ័យហេតុនេះ សូមផ្តល់អនុសាសន៍ឱ្យប្តូរឈ្មោះ ឬលុបម៉ូដែលចាស់ណាមួយ ដើម្បីធានាថាឧបករណ៍ប្រើប្រាស់ត្រឹមត្រូវ។ file.
ពិនិត្យមើលគំរូ
អ្នកអាចចាត់វិធានការដើម្បីធានាថាការបង្កើតឡើងវិញដោយស្វ័យប្រវត្តិនៃអារេ C និងបឋមកថាពី .tflite file ប្រតិបត្តិតាមការរំពឹងទុក។ រាល់ជំហានខាងក្រោមអាចត្រូវបានអនុវត្ត ប្រសិនបើអ្នកមិនប្រាកដក្នុងចិត្តថាតើគំរូអ្វីជាផ្នែកនៃកម្មវិធីគោលពីររបស់អ្នក។
ពិនិត្យទំហំម៉ូដែល
ដែលបានបង្កើត file autogen/sl_tflite_micro_model.c កំណត់អថេរទំហំ sl_tflite_model_len ។ លេខនេះអាចប្រៀបធៀបជាមួយ file ទំហំ .tflite file ជាបៃ, ឧទាហរណ៍ample ដោយចុចខាងស្តាំលើ .tflite file ហើយមើលតម្លៃនៃ Properties > Resource > Size។
ពិនិត្យមើលប្រតិបត្តិករដែលប្រើដោយម៉ូដែល
ដែលបានបង្កើត file autogen/sl_tflite_micro_opcode_resolver.h មានការហៅច្រើនដងទៅកាន់ tflite::MicroMutableOpResolver::AddXXX ដែល XXX គឺជាឈ្មោះប្រតិបត្តិករដែលប្រើដោយគំរូ។ នេះអាចប្រៀបធៀបទៅនឹងប្រតិបត្តិករដែលអ្នកដឹងថាគំរូគួរប្រើ។
ពិនិត្យប៉ារ៉ាម៉ែត្រគំរូ
ប្រសិនបើ .tflite file ត្រូវបានបង្កើតដោយប្រើឧបករណ៍សិក្សាម៉ាស៊ីន Silicon Labs វាមានទិន្នន័យមេតាដែលត្រូវបានបង្កើតទៅជា autogen/sl_tflite_micro_model_parameters.h ។ ប៉ារ៉ាម៉ែត្រទាំងនេះអាចប្រៀបធៀបទៅនឹងប៉ារ៉ាម៉ែត្រដែលរំពឹងទុក។
ជំនាន់កម្លាំងរបស់ គ files
ប្រសិនបើមានអ្វីកើតឡើងដែលធ្វើឱ្យ .c និង .h ដែលត្រូវបានបង្កើតចេញពីការធ្វើសមកាលកម្មជាមួយ .tflite fileគម្រោងអាចត្រូវបានបង្កើតឡើងវិញដោយបង្ខំដោយចុចប៊ូតុងបង្កើតកម្លាំងនៅលើផ្ទាំងព័ត៌មានលំអិតគម្រោងនៃអ្នកកំណត់រចនាសម្ព័ន្ធគម្រោង។

៥/៥

ការអភិវឌ្ឍន៍គំរូ
ការអភិវឌ្ឍន៍គំរូ
ការបង្កើតគំរូរៀនម៉ាស៊ីន
ការបង្កើតគំរូដោយដៃដោយប្រើ TensorFlow និង Keras

នៅពេលបង្កើត និងបណ្តុះបណ្តាលបណ្តាញប្រសាទសម្រាប់ប្រើប្រាស់ក្នុងប្រព័ន្ធបង្កប់ វាជាការសំខាន់ក្នុងការកត់សម្គាល់ពីដែនកំណត់លើ TFLM ដែលអនុវត្តចំពោះស្ថាបត្យកម្មគំរូ និងការបណ្តុះបណ្តាល។ វេទិកាដែលបានបង្កប់ក៏មានឧបសគ្គក្នុងការអនុវត្តសំខាន់ៗផងដែរ ដែលត្រូវតែពិចារណានៅពេលរចនា និងវាយតម្លៃគំរូ។ តំណភ្ជាប់ឯកសារ TLFM ដែលបានបង្កប់ពិពណ៌នាអំពីដែនកំណត់ និងការពិចារណាលម្អិតទាំងនេះ។
លើសពីនេះ សមាសធាតុកម្មវិធី TensorFlow នៅក្នុង Simplicity Studio ត្រូវការតំណាង *.tflite បរិមាណនៃគំរូដែលបានបណ្តុះបណ្តាល។ ជាលទ្ធផល TensorFlow និង Keras គឺជាវេទិកាដែលបានណែនាំសម្រាប់ការអភិវឌ្ឍន៍គំរូ និងការបណ្តុះបណ្តាល ដោយសារតែវេទិកាទាំងពីរត្រូវបានគាំទ្រដោយកម្មវិធីបម្លែង TensorFlow Lite ដែលបង្កើតតំណាងគំរូ .tflite ។
ទាំង TensorFlow និង Keras ផ្តល់មគ្គុទ្ទេសក៍ស្តីពីការអភិវឌ្ឍន៍គំរូ និងការបណ្តុះបណ្តាល៖
រង្វិលជុំបណ្តុះបណ្តាលមូលដ្ឋាន TensorFlow

៥/៥

ការអភិវឌ្ឍន៍គំរូ
ការបណ្តុះបណ្តាល និងការវាយតម្លៃ Keras បន្ទាប់ពីគំរូមួយត្រូវបានបង្កើត និងបណ្តុះបណ្តាលនៅក្នុង TensorFlow ឬ Keras វាចាំបាច់ត្រូវបំប្លែង និងដាក់សៀរៀលទៅជា *.tflite file. កំឡុងពេលបំប្លែងគំរូ វាជារឿងសំខាន់ក្នុងការបង្កើនប្រសិទ្ធភាពការប្រើប្រាស់អង្គចងចាំរបស់ម៉ូដែលដោយកំណត់បរិមាណរបស់វា។ វាត្រូវបានផ្ដល់អនុសាសន៍យ៉ាងខ្លាំងឱ្យប្រើបរិមាណចំនួនគត់នៅលើឧបករណ៍ Silicon Labs ។
TensorFlow Lite Converter Quantization លើសview អតីតពេញលេញample បង្ហាញពីការបណ្តុះបណ្តាល ការបម្លែង និងបរិមាណនៃបណ្តាញប្រសាទដែលឆបគ្នា TFLM សាមញ្ញអាចរកបានពី TensorFlow: TensorFlow Hello World Training Example បានបណ្តុះបណ្តាល Hello World Model (ទាញយក .zip a file មានគំរូ)
បង្កើតគំរូដោយប្រើ Silicon Labs AI/ML Partners
សូមមើលផ្នែក AI/ML Partners នៅលើទំព័រ Silicon Labs Machine Learning in IoT សម្រាប់ព័ត៌មានបន្ថែមអំពីដៃគូ Silicon Labs AI/ML ។ ដៃគូទាំងនេះអាចជួយអ្នកបង្កើតគំរូដែលអាចប្រើបានជាមួយឧបករណ៍ Silicon Labs ។
ការបង្កើតគំរូដោយប្រើ MLTK
ចំណាំ៖ MLTK គឺជាការពិសោធន៍ ហើយការគាំទ្រជាផ្លូវការគឺមិនមានទេ។ វាត្រូវបានគេរំពឹងថា MLTK ត្រូវបានប្រើប្រាស់ដោយអ្នកជំនាញ ML ដែលមានចំណេះដឹងជ្រៅជ្រះអំពី TensorFlow និង Python ឬដោយអ្នកអភិវឌ្ឍន៍ដែលមានបំណងចង់រៀន។
Silicon Labs Machine Learning Toolkit (MLTK) គឺជាកញ្ចប់ Python ដែលអនុវត្តស្រទាប់ខាងលើ TensorFlow ដើម្បីជួយអ្នកបង្កើត TensorFlow បង្កើតគំរូដែលអាចដាក់ឱ្យប្រើប្រាស់ដោយជោគជ័យលើបន្ទះឈីប Silicon Labs ។ ស្គ្រីបទាំងនេះគឺជាការអនុវត្តឯកសារយោងសម្រាប់ករណីប្រើប្រាស់អូឌីយ៉ូ ដែលរួមបញ្ចូលការប្រើប្រាស់ឧបករណ៍បង្កើតមុខងារអូឌីយ៉ូទាំងផ្នែកបណ្តុះបណ្តាល និងការសន្និដ្ឋាន។ នេះគឺជាកំណែដែលបានកែប្រែនៃ TensorFlow "microfrontend" ផ្នែកខាងមុខអូឌីយ៉ូ។ MLTK ត្រូវបានផ្តល់ជូនជាកញ្ចប់ឯកសារយោង Python ដែលបានបោះពុម្ពផ្សាយតាម GitHub ដោយខ្លួនឯង យើងកំពុងចែកចាយវាជាកញ្ចប់សាកល្បង ដែលមានន័យថាវាមាន

៥/៥

ការដំឡើងផ្នែកបន្ថែម AI/ML
ការដំឡើងផ្នែកបន្ថែម AI/ML
ការដំឡើងផ្នែកបន្ថែម AI/ML សម្រាប់ Silicon Labs Simplicity Studio
ការណែនាំនេះរៀបរាប់លម្អិតអំពីដំណើរការដំឡើងសម្រាប់ផ្នែកបន្ថែម AI/ML នៅក្នុង Silicon Labs Simplicity Studio។ ផ្នែកបន្ថែមនេះផ្តល់អំណាចដល់អ្នកអភិវឌ្ឍន៍ក្នុងការរួមបញ្ចូលសមត្ថភាពរៀនម៉ាស៊ីនទៅក្នុងគម្រោងដែលផ្អែកលើ Silicon Labs របស់ពួកគេ។
តម្រូវការជាមុន
មុននឹងបន្តការដំឡើង សូមប្រាកដថាអ្នកមានដូចខាងក្រោម៖
Silicon Labs Simplicity Studio៖ កំណែចុងក្រោយបំផុតរបស់ Simplicity Studio គឺចាំបាច់ណាស់។ ទាញយកវាពី Silicon Labs ផ្លូវការ webគេហទំព័រ។ ផ្នែករឹងដែលគាំទ្រ៖ ផ្ទៀងផ្ទាត់ថាផ្នែករឹង Silicon Labs គោលដៅរបស់អ្នកគឺត្រូវគ្នាជាមួយផ្នែកបន្ថែម AI/ML ។ សូមពិគ្រោះជាមួយកំណត់ចំណាំឬឯកសារចេញផ្សាយរបស់ផ្នែកបន្ថែមសម្រាប់បញ្ជីឧបករណ៍ដែលគាំទ្រ។ បរិស្ថាន Python (មានសក្តានុពល): មុខងារ AI/ML មួយចំនួនអាចពឹងផ្អែកលើបរិស្ថាន Python ។ វាត្រូវបានណែនាំឱ្យដំឡើង Python 3.7 ឬខ្ពស់ជាងនេះ។ បរិស្ថាននិម្មិតត្រូវបានណែនាំយ៉ាងខ្លាំងដើម្បីគ្រប់គ្រងភាពអាស្រ័យប្រកបដោយប្រសិទ្ធភាព។ Git (សក្តានុពល): Git អាចត្រូវបានទាមទារសម្រាប់វិធីសាស្រ្តដំឡើងជាក់លាក់ ឬសម្រាប់ការចូលប្រើធនធានជាក់លាក់។ ត្រូវប្រាកដថា Git ត្រូវបានដំឡើងនៅលើប្រព័ន្ធរបស់អ្នក។
វិធីសាស្រ្តដំឡើង
ផ្នែកបន្ថែម AI/ML អាចត្រូវបានដំឡើងតាមវិធីដូចខាងក្រោមៈ
1. កម្មវិធីគ្រប់គ្រងការដំឡើងស្ទូឌីយោសាមញ្ញ (បានណែនាំ)
នេះគឺជាវិធីសាស្ត្រត្រង់បំផុត និងបានណែនាំ។
1. បើក Simplicity Studio។ 2. រុករកទៅជំនួយ > អាប់ដេតកម្មវិធី…. 3. ចុច Installation Manager > SDKs…. 4. ជ្រើសរើសផ្នែកបន្ថែម Silicon Labs AI/ML ពីបញ្ជីនៃផ្នែកបន្ថែមដែលមាននៅក្រោម Simplicity SDK។ 5. ធ្វើតាមការណែនាំនៅលើអេក្រង់ ដើម្បីបញ្ចប់ការដំឡើង។
2. ការដំឡើងដោយដៃ (ប្រសិនបើមាន)
ប្រសិនបើវិធីសាស្រ្តដំឡើងដោយដៃត្រូវបានផ្តល់ជូនរួមជាមួយវិធីសាស្ត្រកម្មវិធីគ្រប់គ្រងផ្នែកបន្ថែម សូមធ្វើតាមការណែនាំខាងក្រោម។ ចំណាំថានេះជារឿងធម្មតាតិចជាង។
1. ទាញយកកំណែកញ្ចប់បន្ថែម AI/ML ដែលចង់បានពី https://github.com/SiliconLabsSoftware/aiml-extension/releases។ តំណភ្ជាប់ទៅកាន់កំណែចេញផ្សាយដែលត្រូវគ្នាត្រូវបានផ្តល់ជូននៅក្នុងកំណត់ចំណាំការចេញផ្សាយរបស់កម្មវិធីបន្ថែមផងដែរ។
2. ស្រង់កញ្ចប់ដែលបានទាញយកទៅថត “simplicity_sdkextension” ។ 3. ពិគ្រោះជាមួយឯកសាររបស់ផ្នែកបន្ថែមសម្រាប់ជំហានដំឡើងដោយដៃជាក់លាក់។ ជំហានទាំងនេះអាចពាក់ព័ន្ធនឹងការចម្លង files ទៅជាក់លាក់
ទីតាំងនៅក្នុងថតដំឡើង Simplicity Studio ឬដំណើរការស្គ្រីបដំឡើង។
ជំហានក្រោយការដំឡើង
បន្ទាប់ពីការដំឡើងជោគជ័យ៖
1. ចាប់ផ្ដើម Simplicity Studio ឡើងវិញ៖ ចាប់ផ្ដើម Simplicity Studio ឡើងវិញ ដើម្បីធានាថាការផ្លាស់ប្តូរមានប្រសិទ្ធភាព។ 2. ផ្ទៀងផ្ទាត់ការដំឡើង៖ ពិនិត្យមើលចំណូលចិត្ត Simplicity Studio ឬបញ្ជីកម្មវិធីដែលបានដំឡើង ដើម្បីបញ្ជាក់ថាផ្នែកបន្ថែម AI/ML ត្រូវបានរាយបញ្ជី និង
បានដំឡើង។ 3. រុករកឯកសារ និង Examples: ផ្នែកបន្ថែម AI/ML គួរតែរួមបញ្ចូលឯកសារ និងឧampគម្រោង។ ធនធានទាំងនេះ
មានសារៈសំខាន់សម្រាប់ការចាប់ផ្តើម និងស្វែងយល់ពីរបៀបប្រើប្រាស់មុខងារ និង APIs របស់កម្មវិធីបន្ថែម។

៥/៥

ការដំឡើងផ្នែកបន្ថែម AI/ML
ការដោះស្រាយបញ្ហា
ប្រសិនបើអ្នកជួបប្រទះបញ្ហាណាមួយកំឡុងពេលដំឡើង៖ 1. ពិនិត្យមើលកំណត់ហេតុស្ទូឌីយោសាមញ្ញ៖ ពិនិត្យមើលកំណត់ហេតុស្ទូឌីយោសាមញ្ញសម្រាប់សារកំហុសណាមួយ។ កំណត់ហេតុទាំងនេះអាចផ្តល់នូវតម្រុយដ៏មានតម្លៃសម្រាប់
ការដោះស្រាយបញ្ហា។ 2. ឡើងវិញview ឯកសារ៖ យោងទៅលើឯកសាររបស់ផ្នែកបន្ថែម AI/ML និងកំណត់ចំណាំចេញផ្សាយសម្រាប់គន្លឹះដោះស្រាយបញ្ហា និងបញ្ហាដែលគេស្គាល់។ 3. វេទិកាសហគមន៍ Silicon Labs៖ វេទិកាសហគមន៍ Silicon Labs គឺជាធនធានដ៏ល្អសម្រាប់ការស្វែងរកដំណោះស្រាយចំពោះបញ្ហាទូទៅ។
បញ្ហា ឬសុំជំនួយពីអ្នកប្រើប្រាស់ផ្សេងទៀត និងអ្នកជំនាញ Silicon Labs។
ការធ្វើបច្ចុប្បន្នភាពផ្នែកបន្ថែម
ដើម្បីធ្វើបច្ចុប្បន្នភាពផ្នែកបន្ថែម AI/ML សូមអនុវត្តតាមជំហានដំឡើងដូចគ្នាដូចដែលបានពិពណ៌នាខាងលើ។ ជាធម្មតា Simplicity Studio នឹងរកឃើញកំណែថ្មីជាងនេះ ហើយណែនាំអ្នកតាមរយៈដំណើរការអាប់ដេត។
ការលុបការដំឡើង
ដើម្បីលុបកម្មវិធីបន្ថែម AI/ML សូមប្រើកម្មវិធីគ្រប់គ្រងផ្នែកបន្ថែមស្ទូឌីយោ Simplicity ឬពិគ្រោះជាមួយឯកសាររបស់កម្មវិធីបន្ថែមសម្រាប់ការណែនាំអំពីការលុបជាក់លាក់។
ចំណាំសំខាន់៖ មគ្គុទ្ទេសក៍នេះផ្តល់នូវការទូទៅview នៃដំណើរការដំឡើងផ្នែកបន្ថែម AI/ML ជាមួយនឹងព័ត៌មានចុងក្រោយបំផុត។ តែងតែយោងទៅការចេញផ្សាយកំណត់ចំណាំសម្រាប់កំណែការណែនាំផ្ទាល់ខ្លួនជាក់លាក់ដែលអាចត្រូវបានទាមទារ។ ការណែនាំបន្ថែមណាមួយ និងពាក់ព័ន្ធ URLs រួមជាមួយនឹងការណែនាំដោយដៃនឹងត្រូវបានផ្តល់ជូនជាមួយនឹងកំណត់ចំណាំចេញផ្សាយ។

៥/៥

ឧបករណ៍បំលែង Flatbuffer
ឧបករណ៍បំលែង Flatbuffer
ឧបករណ៍បំលែង Flatbuffer
ឧបករណ៍បំលែង Flatbuffer ជួយបំប្លែង .tflite file ចូលទៅក្នុងអារេ C ដែលអាចត្រូវបានចងក្រងជាប្រព័ន្ធគោលពីរសម្រាប់ប្រព័ន្ធបង្កប់។ អារេនេះអាចត្រូវបានប្រើជាមួយ TensorFlow Lite សម្រាប់ Microcontrollers API ដែលយកទ្រនិចទទេទៅសតិបណ្ដោះអាសន្នដែលមានគំរូជាអាគុយម៉ង់ចំពោះមុខងារ tflite របស់វា::GetModel() init ។ បន្ថែមពីលើការបំប្លែង flatbuffer ទៅជាអារេ C ឧបករណ៍នេះគាំទ្រការបញ្ចេញប៉ារ៉ាម៉ែត្រគំរូដែលបានបង្កប់ជាទិន្នន័យមេតានៅក្នុង .tflite file ជាម៉ាក្រូ C preprocessor ។
បញ្ចូល
ឧបករណ៍យកថតដែលមាន .tflite មួយ ឬច្រើន។ files ជាការបញ្ចូល។ ប្រសិនបើថតមានច្រើន។ files, មានតែដំបូងប៉ុណ្ណោះ។ file តាមលំដាប់អក្ខរក្រមត្រូវបានបំប្លែង។
គន្លឹះ៖ ប្រសិនបើអ្នកមានច្រើន។ files នៅក្នុងថតឯកសារ ប៉ុន្តែអ្នកចង់បំប្លែងមិនមែនជាទីមួយទេ។ file តាមលំដាប់អក្ខរក្រម អ្នកអាចប្តូរឈ្មោះផ្សេងទៀត។ files ដើម្បីបន្ថែមផ្នែកបន្ថែម .bak ឬប្តូរឈ្មោះគោលដៅ file តាម។
ទិន្នផល
ឧបករណ៍សរសេរលទ្ធផលរបស់វាទៅជាពហុ files នៅក្នុងថតលទ្ធផលតែមួយ។
អារេគំរូ
ឧបករណ៍តែងតែបញ្ចេញជាគូ files sl_tflite_micro_model.c / .h ដែលប្រកាសអថេរដូចខាងក្រោម។ const uint8_t sl_tflite_model_array[] ដែលមានមាតិកាពេញលេញនៃ .tflite file const uint32_t sl_tflite_model_len ដែលមានប្រវែងនៃអារេគំរូ
ឧបករណ៍ដោះស្រាយ Opcode
បឋមកថា file sl_tflite_micro_opcode_resolver.h ក៏ត្រូវបានបញ្ចេញផងដែរ។ នេះ។ file ប្រកាសម៉ាក្រូ C preprocessor SL_TFLITE_MICRO_OPCODE_RESOLVER(opcode_resolver, error_reporter) ដែលធ្វើអោយ tflite ភ្លាមៗ៖:MicroMutableOpResolver object ហើយចុះឈ្មោះដោយស្វ័យប្រវត្តិនូវសំណុំនៃ operators ដែលត្រូវការដើម្បីញែកគំរូ។ ម៉ាក្រូនេះអាចត្រូវបានប្រើជាផ្នែកនៃលំដាប់ចាប់ផ្តើម ដើម្បីចាប់ផ្តើមដោយស្វ័យប្រវត្តិនូវឧបករណ៍ដោះស្រាយ opcode ដ៏ល្អប្រសើរ។
ប៉ារ៉ាម៉ែត្រគំរូ
ប្រសិនបើ .tflite file មានប៉ារ៉ាម៉ែត្រគំរូនៅក្នុងផ្នែកទិន្នន័យមេតារបស់វា ដែលជាបឋមកថាទីបី file sl_tflite_micro_model_parameters.h ត្រូវបានបញ្ចេញ។ សម្រាប់រាល់ប៉ារ៉ាម៉ែត្រគំរូគូតម្លៃសោ ម៉ាក្រូ C preprocessor SL_TFLITE_MODEL_ ត្រូវបានបង្កើតឡើងដោយតម្លៃដែលពាក់ព័ន្ធ។ សូមមើលឯកសារ MLTK ដើម្បីស្វែងយល់បន្ថែមអំពីការបង្កប់ប៉ារ៉ាម៉ែត្រគំរូនៅក្នុង .tflite file.
ការរួមបញ្ចូលការកំណត់រចនាសម្ព័ន្ធគម្រោង SLC

៥/៥

ឧបករណ៍បំលែង Flatbuffer
ឧបករណ៍បំលែង Flatbuffer រួមបញ្ចូលជាមួយឧបករណ៍កំណត់រចនាសម្ព័ន្ធគម្រោង SLC នៅក្នុង Simplicity Studio និងនៅលើបន្ទាត់ពាក្យបញ្ជាដោយប្រើ SLC-CLI ។ នៅពេលប្រើឧបករណ៍ទាំងនេះ កម្មវិធីបម្លែង Flatbuffer ត្រូវបានដំណើរការដោយស្វ័យប្រវត្តិជាមួយនឹង config/tflite/ directory of the project as input និង autogen/ directory ជាលទ្ធផល។ នៅក្នុងពាក្យផ្សេងទៀតណាមួយ។ file ជាមួយនឹងផ្នែកបន្ថែម .tflite ក្នុង config/tflite/ directory ក្នុងគម្រោងនឹងត្រូវបានបំប្លែងដោយស្វ័យប្រវត្តិនៅពេលដែលគម្រោងត្រូវបានបង្កើត។ ប្រសិនបើប្រើ Simplicity Studio កម្មវិធីមើលថតធានាថាគម្រោងត្រូវបានបង្កើតដោយស្វ័យប្រវត្តិប្រសិនបើ .tflite file ត្រូវបានបន្ថែមឬដកចេញ។ នេះមានន័យថាវាគ្រប់គ្រាន់ក្នុងការអូសនិងទម្លាក់ .tflite file ចូលទៅក្នុងគម្រោង ហើយវាត្រូវបានបំប្លែងទៅជាកូដ C ដោយស្វ័យប្រវត្តិ។
ការប្រើប្រាស់ដោយដៃ
ប្រសិនបើការបំប្លែងគឺចង់បាននៅខាងក្រៅវដ្តនៃការបង្កើតគម្រោង SLC ពេញលេញនោះ កម្មវិធីបំប្លែង flatbuffer អាចត្រូវបានហៅដោយដៃ។ នេះជាទូទៅមិនចាំបាច់ទេ ប៉ុន្តែជាជម្រើសសម្រាប់អ្នកប្រើប្រាស់កម្រិតខ្ពស់។ នេះអាចត្រូវបានធ្វើដោយប្រើ SLC-CLI តែប៉ុណ្ណោះ អ្នកប្រើប្រាស់នៃ Simplicity Studio ត្រូវបានណែនាំអោយបង្កើតគម្រោងពេញលេញឡើងវិញ។
ក្នុងនាមជាអ្នកបង្កើតគម្រោង SLC
SLC-CLI គាំទ្រការដំណើរការឧបករណ៍បង្កើតគម្រោងតែមួយដោយឆ្លងកាត់ -tools ទៅ slc បង្កើតពាក្យបញ្ជា។ ជំហានកម្មវិធីបម្លែង Flatbuffer នៃដំណើរការបង្កើតគម្រោងអាចដំណើរការតែម្នាក់ឯងដោយដំណើរការពាក្យបញ្ជាខាងក្រោម៖
slc បង្កើត -p - ឧបករណ៍ tflite
ជាពាក្យបញ្ជា SLC-CLI ឯករាជ្យ
ឧបករណ៍បំប្លែង flatbuffer ក៏មានជាពាក្យបញ្ជាដាច់ដោយឡែកនៅក្នុង SLC-CLI សម្រាប់ប្រើប្រាស់នៅខាងក្រៅបរិបទនៃគម្រោង។ ប្រតិបត្តិពាក្យបញ្ជាខាងក្រោមដោយប្រើផ្លូវដាច់ខាតសម្រាប់ទាំងថតបញ្ចូល និងទិន្នផល។
slc tflite បង្កើត -contentFolder [/path/to/config/tflite] -generationOutput [/path/to/autogen]

៥/៥

ការកំណត់រចនាសម្ព័ន្ធ I2S សម្រាប់ SiWx917
ការកំណត់រចនាសម្ព័ន្ធ I2S សម្រាប់ SiWx917
ការកំណត់ I2S Pin សម្រាប់កម្មវិធីអូឌីយ៉ូ ML នៅលើវេទិកា SiWx917
ការកំណត់រចនាសម្ព័ន្ធលំនាំដើមនៃម្ជុល I2S នៅលើ SiWx917 មិនផ្តល់នូវលទ្ធផលរំពឹងទុកសម្រាប់លទ្ធផលចំណាត់ថ្នាក់នៅលើផ្នែករឹងសម្រាប់កម្មវិធីអូឌីយ៉ូ AI/ML ទាំងអស់។ អ្នកត្រូវតែកំណត់រចនាសម្ព័ន្ធម្ជុល I2S ដោយដៃដោយប្រើ .slcp ដូចដែលបានពិពណ៌នាខាងក្រោម។ ដើម្បីកំណត់រចនាសម្ព័ន្ធម្ជុល I2S សម្រាប់ក្តាររបស់អ្នក សូមអនុវត្តតាមជំហានទាំងនេះដោយប្រើ Simplicity Studio៖
1. បើក I2S Peripheral តាមរយៈផ្នែកទន់
ម្តង .pintool file ត្រូវបានបង្កើតនៅក្នុងថតគម្រោងរបស់អ្នក បើក .slcp file នៅក្នុង Simplicity Studio។ បន្ទាប់ពីនោះ សូមចូលទៅកាន់ផ្ទាំង Software Components ។ ស្វែងរក ហើយបើកឧបករណ៍ I2S (ឧ. I2S0 )។ ចូលទៅកាន់ WiSeConnect 3 SDK v3.5.0 > ឧបករណ៍ > Si91x > MCU > Peripheral > I2S > i2s0 > Configure។
2. កំណត់រចនាសម្ព័ន្ធ I2S Pins
នៅក្នុងការកំណត់រចនាសម្ព័ន្ធផ្នែកទន់ សូមចុចប៊ូតុង កំណត់រចនាសម្ព័ន្ធ នៅជាប់នឹងគ្រឿងកុំព្យូទ័រ I2S ដែលបានបើក។
កំណត់សញ្ញា I2S ដែលត្រូវការ ( DIN0 , SCLK , និង WSCLK ) ទៅកាន់ម្ជុល GPIO ដែលសមស្របដូចបង្ហាញក្នុងរូបភាពខាងក្រោម។ ឧបករណ៍កំណត់រចនាសម្ព័ន្ធបង្ហាញម្ជុលដែលមាន។ ត្រូវប្រាកដថាអ្នកជ្រើសរើសតែអ្វីដែលបានបង្ហាញនៅក្នុងរូបភាព។

៥/៥

ការកំណត់រចនាសម្ព័ន្ធ I2S សម្រាប់ SiWx917
3. រក្សាទុក និងបង្កើតកូដ
ឧបករណ៍នេះបង្កើតកូដកំណត់រចនាសម្ព័ន្ធម្ជុលដោយស្វ័យប្រវត្តិសម្រាប់គម្រោងរបស់អ្នក។
4. កសាងគម្រោងឡើងវិញ
បង្កើតគម្រោងរបស់អ្នកដើម្បីធានាថាការកំណត់រចនាសម្ព័ន្ធម្ជុលថ្មីត្រូវបានរួមបញ្ចូល។ សម្រាប់ព័ត៌មានលម្អិត សូមមើលឯកសារសមាសភាគកម្មវិធី Simplicity Studio ។

៥/៥

ឯកសារយោង API ការរៀនម៉ាស៊ីន
ឯកសារយោង API ការរៀនម៉ាស៊ីន
ឯកសារយោង API ការរៀនម៉ាស៊ីន

បញ្ជីនៃម៉ូឌុល TensorFlow Lite Micro Init TensorFlow Lite Micro Debug ម៉ាស៊ីនបង្កើតមុខងារអូឌីយ៉ូ
មុខងារជាក់លាក់នៃគំរូ
គំរូអថេរជាក់លាក់ និងថេរ

ការពិពណ៌នា
ចាប់ផ្តើម Tensorflow Lite Micro Runtime ។ ឧបករណ៍ប្រើប្រាស់ SL បន្ថែមសម្រាប់ការចូល TensorFlow Lite Micro ។
ទាញយកលក្ខណៈពិសេស mel-filterbank ចេញពីសញ្ញាសំឡេង ដើម្បីប្រើជាមួយកម្មវិធីចំណាត់ថ្នាក់សំឡេងនៃការរៀនម៉ាស៊ីន។ មុខងារដែលបានបង្កើតដោយប្រើឈ្មោះនៃគំរូ .tflite file. (បច្ចុប្បន្នអាចប្រើបានតែជាមួយវេទិកា SiWx917) គំរូអថេរ និងថេរជាក់លាក់ដែលបានបង្កើតដោយប្រើឈ្មោះគំរូ .tflite file. (បច្ចុប្បន្ន អាចប្រើបានតែជាមួយវេទិកា SiWx917)

៥/៥

កម្មវិធីបញ្ជាមីក្រូហ្វូន I2S សម្រាប់រៀនម៉ាស៊ីន

កម្មវិធីបញ្ជាមីក្រូហ្វូន API សម្រាប់ចំណុចប្រទាក់ I2S នៅលើ SI91x ។
Typedefs

typedef void(*

sl_mic_buffer_ready_callback_t)(const void *buffer, uint32_t n_frames)
មុខងារ Callback បង្ហាញថា sample buffer រួចរាល់ហើយ។

មុខងារ

sl_status_t sl_status_t sl_status_t sl_status_t

sl_ml_mic_init(uint32_t sample_rate, ឆានែល uint8_t)
ចាប់ផ្តើមមីក្រូហ្វូន។
sl_ml_mic_deinit (ចាត់ទុកជាមោឃៈ)
លុបមីក្រូហ្វូនចាប់ផ្តើម។
sl_ml_mic_start_streaming(ចាត់ទុកជាមោឃៈ *សតិបណ្ដោះអាសន្ន, uint32_t n_frames, sl_mic_buffer_ready_callback_t ការហៅត្រឡប់មកវិញ)
អាន សamples ពីមីក្រូហ្វូនចូលទៅក្នុង asample buffer បន្ត។
sl_ml_mic_stop(ទុកជាមោឃៈ)
បញ្ឈប់មីក្រូហ្វូន។

ឯកសារ Typedef
sl_mic_buffer_ready_callback_t

typedef void(* sl_mic_buffer_ready_callback_t) (const void *buffer, uint32_t n_frames) )(const void *buffer, uint32_t n_frames)

មុខងារ Callback បង្ហាញថា sample buffer រួចរាល់ហើយ។ ប៉ារ៉ាម៉ែត្រ

ប្រភេទ

ទិសដៅ [ក្នុង] [ក្នុង]

ឈ្មោះអាគុយម៉ង់ n_frames

ការពិពណ៌នា ចង្អុលទៅ sample buffer ចំនួននៃស៊ុមអូឌីយ៉ូនៅក្នុង sample buffer

ត្រឡប់គ្មាន។

ឯកសារមុខងារ
sl_ml_mic_init

sl_status_t sl_ml_mic_init (uint32_t sample_rate, ឆានែល uint8_t)

ចាប់ផ្តើមមីក្រូហ្វូន។

៥/៥

កម្មវិធីបញ្ជាមីក្រូហ្វូន I2S សម្រាប់រៀនម៉ាស៊ីន

ប៉ារ៉ាម៉ែត្រ
វាយ uint32_t uint8_t

ទិសដៅ [ក្នុង] [ក្នុង]

ឈ្មោះអាគុយម៉ង់ sample_rate ឆានែល

ត្រឡប់ ត្រឡប់ SL_STATUS_OK លើជោគជ័យ មិនមែនសូន្យទេ។

ការពិពណ៌នា sample អត្រាគិតជា Hz ចំនួនឆានែលអូឌីយ៉ូ (1 ឬ 2)

sl_ml_mic_deinit

sl_status_t sl_ml_mic_deinit (ទុកជាមោឃៈ)

លុបមីក្រូហ្វូនចាប់ផ្តើម។ ប៉ារ៉ាម៉ែត្រ

វាយបញ្ចូលភាពទទេ

ទិសដៅ N/A

ឈ្មោះអាគុយម៉ង់

ការពិពណ៌នា

sl_ml_mic_start_streaming

sl_status_t sl_ml_mic_start_streaming (ចាត់ទុកជាមោឃៈ * សតិបណ្ដោះអាសន្ន, uint32_t n_frames, sl_mic_buffer_ready_callback_t callback)

អាន សamples ពីមីក្រូហ្វូនចូលទៅក្នុង asample buffer បន្ត។ ប៉ារ៉ាម៉ែត្រ

ប្រភេទ

ទិសដៅ

ឈ្មោះអាគុយម៉ង់

ការពិពណ៌នា

ទុកជាមោឃៈ

[ក្នុង]

buffer ទ្រនិចទៅ sample buffer ដើម្បីរក្សាទុកទិន្នន័យ។ ទិន្នន័យឆានែល 16 ប៊ីតគឺ

រក្សាទុកជាប់គ្នាដោយចាប់ផ្តើមជាមួយ ch0 ។ បណ្តុំនេះនឹងធំល្មម

ដើម្បីកាន់ n_frames ពីរដងដោយសារតែប្រតិបត្តិការ ping-pong ។

uint32_t

[ក្នុង]

n_frames ចំនួននៃស៊ុមអូឌីយ៉ូដែលត្រូវទទួល មុនពេលការហៅត្រឡប់មកវិញត្រូវបានហៅ។

តម្លៃអតិបរមាកំណត់ដោយ DMADRV_MAX_XFER_COUNT ។

sl_mic_buffer_ready_callback_t [ក្នុង]

callback Callback ត្រូវបានហៅនៅពេលដែល n_frames នៅក្នុង sample buffer រួចរាល់ហើយ។

មុខងារនេះចាប់ផ្តើមមីក្រូហ្វូន sampling ហើយឈប់តែពេលហៅ sl_ml_mic_stop ឬ sl_ml_mic_deinit ប៉ុណ្ណោះ។ សតិបណ្ដោះអាសន្នត្រូវបានប្រើក្នុងលក្ខណៈ "ភីងប៉ុង" ដែលមានន័យថាមួយពាក់កណ្តាលនៃសតិបណ្ដោះអាសន្នត្រូវបានប្រើសម្រាប់ sampling ខណៈពេលដែលពាក់កណ្តាលផ្សេងទៀតកំពុងដំណើរការ។

sl_ml_mic_stop

sl_status_t sl_ml_mic_stop (ទុកជាមោឃៈ)

បញ្ឈប់មីក្រូហ្វូន។ ប៉ារ៉ាម៉ែត្រ

វាយបញ្ចូលភាពទទេ

ទិសដៅ N/A

ឈ្មោះអាគុយម៉ង់

ការពិពណ៌នា

៥/៥

កម្មវិធីបញ្ជាមីក្រូហ្វូន I2S សម្រាប់រៀនម៉ាស៊ីន

៥/៥

មុខងារជាក់លាក់នៃគំរូ
មុខងារជាក់លាក់នៃគំរូ
មុខងារជាក់លាក់នៃគំរូ
មុខងារដែលបានបង្កើតដោយប្រើឈ្មោះនៃគំរូ .tflite file. APIs ទាំងនេះបច្ចុប្បន្នអាចប្រើបានតែជាមួយវេទិកា SiWx917 ប៉ុណ្ណោះ។
sl_ml_ _init
sl_status_t sl_ml_ _model_init(ទុកជាមោឃៈ)
បង្កើតអ្នករាយការណ៍កំហុស និងអ្នកដោះស្រាយ opcode ហើយចាប់ផ្តើមអថេរសម្រាប់គំរូដែលបានផ្តល់ឱ្យ។ គឺបានមកពី file ឈ្មោះ .tflite របស់អ្នក។ file. ត្រឡប់មកវិញ
ស្ថានភាពនៃការចាប់ផ្តើមគំរូ។ SL_STATUS_OK ប្រសិនបើជោគជ័យ បើមិនដូច្នេះទេ SL_STATUS_FAIL ។
sl_ml_ _រត់
sl_status_t sl_ml_ _model_run(ទុកជាមោឃៈ)
អនុវត្តគំរូម្តងសម្រាប់ការសន្និដ្ឋាន។ លទ្ធផលត្រូវបានអាប់ដេតខាងក្នុងនៅក្នុងគំរូ។ ត្រឡប់មកវិញ
ស្ថានភាពនៃការអនុវត្តគំរូ និងការសន្និដ្ឋាន។ SL_STATUS_OK ប្រសិនបើជោគជ័យ បើមិនដូច្នេះទេ SL_STATUS_FAIL ។

៥/៥

គំរូអថេរជាក់លាក់ និងថេរ
គំរូអថេរជាក់លាក់ និងថេរ
គំរូអថេរជាក់លាក់ និងថេរ
គំរូអថេរ និងថេរជាក់លាក់ដែលបានបង្កើតដោយប្រើឈ្មោះនៃគំរូ .tflite file. APIs ទាំងនេះបច្ចុប្បន្នអាចប្រើបានតែជាមួយវេទិកា SiWx917 ប៉ុណ្ណោះ។
_គំរូ
TfliteMicroModel ឋិតិវន្ត _គំរូ
វត្ថុគំរូជាមួយនឹងវិធីសាស្រ្តជាច្រើនដើម្បីធ្វើអន្តរកម្មជាមួយគំរូ។
ស្ថានភាព _គំរូ
ឋិតិវន្ត sl_status_t ស្ថានភាព _គំរូ
តាមដានស្ថានភាពរបស់ _គំរូនៅពេលចាប់ផ្តើម និងប្រតិបត្តិ។
_model_flatbuffer
uint8_t* _model_flatbuffer
ចង្អុលទៅ flatbuffer ឆៅនៃគំរូដែលយោងដោយ _គំរូ
_model_flatbuffer_length
const int _model_flatbuffer_length
ប្រវែងនៃ flatbuffer ឆៅ សំដៅលើ _model_flatbuffer

៥/៥

ឧបករណ៍បង្កើតមុខងារអូឌីយ៉ូ

ម៉ាស៊ីនបង្កើតមុខងារអូឌីយ៉ូទាញយកលក្ខណៈពិសេស mel-filterbank ពីសញ្ញាអូឌីយ៉ូ ដើម្បីប្រើជាមួយកម្មវិធីចំណាត់ថ្នាក់សំឡេងនៃការរៀនម៉ាស៊ីនដោយប្រើមីក្រូហ្វូនជាប្រភពសំឡេង។
ជំនាន់លក្ខណៈពិសេស
មាត្រដ្ឋាន Mel ចម្លងឥរិយាបថនៃត្រចៀករបស់មនុស្សដែលមានគុណភាពបង្ហាញខ្ពស់សម្រាប់ប្រេកង់ទាប និងមិនសូវរើសអើងចំពោះប្រេកង់ខ្ពស់។ ដើម្បីបង្កើត mel filterbank តម្រងមួយចំនួនត្រូវបានអនុវត្តចំពោះសញ្ញាដែល passband នៃតម្រងឆានែលទាបគឺតូចចង្អៀត និងកើនឡើងឆ្ពោះទៅរកប្រេកង់ខ្ពស់។
សញ្ញាអូឌីយ៉ូត្រូវបានបំបែកទៅជាផ្នែកត្រួតគ្នាខ្លីៗដោយប្រើមុខងារបង្អួច (ញញួរ)។ Fast Fourier Transform (FFT) ត្រូវបានអនុវត្តចំពោះផ្នែកនីមួយៗ ដើម្បីទាញយកវិសាលគមប្រេកង់ និងបន្ទាប់មកវិសាលគមថាមពលនៃផ្នែក។ ធនាគារតម្រងត្រូវបានបង្កើតឡើងដោយការអនុវត្តស៊េរីនៃតម្រងដែលធ្វើមាត្រដ្ឋាន mel ទៅទិន្នផល។ ទីបំផុតកំណត់ហេតុត្រូវបានអនុវត្តទៅទិន្នផលដើម្បីបង្កើនភាពប្រែប្រួលរវាងឆានែលទាប។

សញ្ញាសំឡេង

បង្អួច

FFT

តម្រង Mel

កំណត់ហេតុ

Mel Filterbank ដែលបានធ្វើមាត្រដ្ឋានកំណត់ហេតុ

៥/៥

ឧបករណ៍បង្កើតមុខងារអូឌីយ៉ូ
ចំណាំថាប្រសិនបើសតិបណ្ដោះអាសន្នអូឌីយ៉ូមិនធំគ្រប់គ្រាន់ដើម្បីផ្ទុកអូឌីយ៉ូទាំងអស់។amples តម្រូវឱ្យបង្កើតលក្ខណៈពិសេសរវាងការហៅទៅកាន់ sl_ml_audio_feature_generation_update_features() ទិន្នន័យអូឌីយ៉ូនឹងត្រូវបានសរសេរជាន់ពីលើ។ ម៉ាស៊ីនភ្លើងនឹងមិនត្រឡប់កំហុសទេ។ ដូច្នេះ សតិបណ្ដោះអាសន្នអូឌីយ៉ូត្រូវតែកំណត់រចនាសម្ព័ន្ធឱ្យធំល្មមដើម្បីរក្សាទុកសំឡេងថ្មីទាំងអស់។ampដឹកនាំទិន្នន័យរវាងការធ្វើបច្ចុប្បន្នភាពលក្ខណៈពិសេស។
ដើម្បីទាញយកលក្ខណៈពិសេសដែលបានបង្កើត ទាំង sl_ml_audio_feature_generation_get_features_raw(), sl_ml_audio_feature_generation_get_features_quantized() ឬ sl_ml_audio_feature_generation_fill_tensor() ត្រូវតែហៅ។
Example
នៅពេលប្រើជាមួយ TensorFlow Lite Micro ឧបករណ៍បង្កើតមុខងារអូឌីយ៉ូអាចត្រូវបានប្រើដើម្បីបំពេញ tensor ដោយផ្ទាល់ដោយប្រើ sl_ml_audio_feature_generation_fill_tensor() ។ ទោះជាយ៉ាងណាក៏ដោយ គំរូត្រូវតែត្រូវបានបណ្តុះបណ្តាលដោយប្រើការកំណត់រចនាសម្ព័ន្ធម៉ាស៊ីនភ្លើងលក្ខណៈដូចគ្នា ដូចដែលបានប្រើសម្រាប់ការសន្និដ្ឋាន ដែលកំណត់រចនាសម្ព័ន្ធនៅក្នុង sl_ml_audio_feature_generation_config.h ។
#include “sl_tflite_micro_init.h” #include “sl_ml_audio_feature_generation.h”
void main(void) {
sl_ml_audio_feature_generation_init();
while(1){ sl_ml_audio_feature_generation_update_features();
ប្រសិនបើ (do_inference){ sl_ml_audio_feature_generation_fill_tensor(sl_tflite_micro_get_input_tensor()); sl_tflite_micro_get_interpreter()->Invoke();
}
…
} }
ចំណាំថាការធ្វើបច្ចុប្បន្នភាពលក្ខណៈពិសេស និងការទាញយកពួកវាអាចត្រូវបានអនុវត្តដោយឯករាជ្យ។ ការអាប់ដេតលក្ខណៈពិសេសគួរតែត្រូវបានធ្វើជាញឹកញាប់គ្រប់គ្រាន់ដើម្បីជៀសវាងការសរសេរជាន់លើសតិបណ្ដោះអាសន្នអូឌីយ៉ូ ខណៈពេលដែលការទាញយកពួកវាគ្រាន់តែត្រូវធ្វើមុនការសន្និដ្ឋានប៉ុណ្ណោះ។
ម៉ាស៊ីនបង្កើតមុខងារអូឌីយ៉ូទាញយកលក្ខណៈពិសេស mel-filterbank ពីសញ្ញាអូឌីយ៉ូ ដើម្បីប្រើជាមួយកម្មវិធីចំណាត់ថ្នាក់សំឡេងនៃការរៀនម៉ាស៊ីនដោយប្រើមីក្រូហ្វូនជាប្រភពសំឡេង។
ជំនាន់លក្ខណៈពិសេស
មាត្រដ្ឋាន Mel ចម្លងឥរិយាបថនៃត្រចៀករបស់មនុស្សដែលមានគុណភាពបង្ហាញខ្ពស់សម្រាប់ប្រេកង់ទាប និងមិនសូវរើសអើងចំពោះប្រេកង់ខ្ពស់។ ដើម្បីបង្កើត mel filterbank តម្រងមួយចំនួនត្រូវបានអនុវត្តចំពោះសញ្ញាដែល passband នៃតម្រងឆានែលទាបគឺតូចចង្អៀត និងកើនឡើងឆ្ពោះទៅរកប្រេកង់ខ្ពស់។
សញ្ញាអូឌីយ៉ូត្រូវបានបំបែកទៅជាផ្នែកត្រួតគ្នាខ្លីៗដោយប្រើមុខងារបង្អួច (ញញួរ)។ Fast Fourier Transform (FFT) ត្រូវបានអនុវត្តចំពោះផ្នែកនីមួយៗ ដើម្បីទាញយកវិសាលគមប្រេកង់ និងបន្ទាប់មកវិសាលគមថាមពលនៃផ្នែក។ ធនាគារតម្រងត្រូវបានបង្កើតឡើងដោយការអនុវត្តស៊េរីនៃតម្រងដែលធ្វើមាត្រដ្ឋាន mel ទៅទិន្នផល។ ទីបំផុតកំណត់ហេតុត្រូវបានអនុវត្តទៅទិន្នផលដើម្បីបង្កើនភាពប្រែប្រួលរវាងឆានែលទាប។

៥/៥

ឧបករណ៍បង្កើតមុខងារអូឌីយ៉ូ

សញ្ញាសំឡេង

បង្អួច

FFT

តម្រង Mel

កំណត់ហេតុ

Mel Filterbank ដែលបានធ្វើមាត្រដ្ឋានកំណត់ហេតុ

អារេលក្ខណៈពិសេសត្រូវបានបង្កើតដោយការជង់ filterbanks នៃផ្នែកបន្តបន្ទាប់គ្នាដើម្បីបង្កើតជា spectrogram ។ អារេត្រូវបានតម្រៀបដូចដែលធាតុទីមួយគឺជាឆានែលទីមួយនៃធនាគារតម្រងចាស់បំផុត។
ការប្រើប្រាស់
sl_ml_audio_feature_generation_init() ចាប់ផ្តើមផ្នែកខាងមុខសម្រាប់ការបង្កើតលក្ខណៈពិសេសដោយផ្អែកលើការកំណត់នៅក្នុង sl_ml_audio_feature_generation_config_si91x.h ។ វាក៏ចាប់ផ្តើម និងចាប់ផ្តើមមីក្រូហ្វូននៅក្នុងរបៀបស្ទ្រីម ដែលដាក់អូឌីយ៉ូamples ចូលទៅក្នុង ring-buffer ។
ប្រសិនបើប្រើរួមគ្នាជាមួយឧបករណ៍បំប្លែង Flatbuffer និងម៉ូដែល TensorFlow Lite ដែលត្រូវគ្នានោះ ការកំណត់រចនាសម្ព័ន្ធត្រូវបានទាញចេញពីគំរូ TensorFlow Lite តាមលំនាំដើម។ កំណត់ជម្រើសនៃការកំណត់រចនាសម្ព័ន្ធ SL_ML_AUDIO_FEATURE_GENERATION_MANUAL_CONFIG_ENABLE ដើម្បីបដិសេធឥរិយាបថនេះ ហើយប្រើជម្រើសដែលបានកំណត់រចនាសម្ព័ន្ធដោយដៃពីបឋមកថានៃការកំណត់រចនាសម្ព័ន្ធ។
លក្ខណៈពិសេសត្រូវបានបង្កើតនៅពេលដែល sl_ml_audio_feature_generation_update_features() ត្រូវបានហៅ។ បន្ទាប់មកម៉ាស៊ីនបង្កើតមុខងារធ្វើបច្ចុប្បន្នភាពមុខងារសម្រាប់ផ្នែកថ្មីជាច្រើនតាមដែលអាចធ្វើបាន ដោយចាប់ផ្តើមពីពេលចុងក្រោយដែលមុខងារត្រូវបានហៅរហូតដល់ពេលបច្ចុប្បន្ន។ មុខងារថ្មីត្រូវបានបន្ថែមទៅសតិបណ្ដោះអាសន្នមុខងារ ដោយជំនួសមុខងារចាស់បំផុត ដែលអារេមុខងារតែងតែមានលក្ខណៈពិសេសថ្មីៗបំផុត។
ចំណាំថាប្រសិនបើសតិបណ្ដោះអាសន្នអូឌីយ៉ូមិនធំគ្រប់គ្រាន់ដើម្បីផ្ទុកអូឌីយ៉ូទាំងអស់។amples តម្រូវឱ្យបង្កើតលក្ខណៈពិសេសរវាងការហៅទៅកាន់ sl_ml_audio_feature_generation_update_features() ទិន្នន័យអូឌីយ៉ូនឹងត្រូវបានសរសេរជាន់ពីលើ។ ម៉ាស៊ីនភ្លើងនឹងមិនត្រឡប់កំហុសទេ។ ដូច្នេះ សតិបណ្ដោះអាសន្នអូឌីយ៉ូត្រូវតែកំណត់រចនាសម្ព័ន្ធឱ្យធំល្មមដើម្បីរក្សាទុកសំឡេងថ្មីទាំងអស់។ampដឹកនាំទិន្នន័យរវាងការធ្វើបច្ចុប្បន្នភាពលក្ខណៈពិសេស។
ដើម្បីទាញយកលក្ខណៈពិសេសដែលបានបង្កើត ទាំង sl_ml_audio_feature_generation_get_features_raw(), sl_ml_audio_feature_generation_get_features_quantized() ឬ sl_ml_audio_feature_generation_fill_tensor() ត្រូវតែហៅ។
Example
នៅពេលប្រើជាមួយ TensorFlow Lite Micro ឧបករណ៍បង្កើតមុខងារអូឌីយ៉ូអាចត្រូវបានប្រើដើម្បីបំពេញ tensor ដោយផ្ទាល់ដោយប្រើ sl_ml_audio_feature_generation_fill_tensor() ។ ទោះជាយ៉ាងណាក៏ដោយ គំរូត្រូវតែត្រូវបានបណ្តុះបណ្តាលដោយប្រើការកំណត់រចនាសម្ព័ន្ធម៉ាស៊ីនភ្លើងលក្ខណៈដូចគ្នា ដូចដែលបានប្រើសម្រាប់ការសន្និដ្ឋាន ដែលបានកំណត់រចនាសម្ព័ន្ធនៅក្នុង sl_ml_audio_feature_generation_config_si91x.h ។

៥/៥

ឧបករណ៍បង្កើតមុខងារអូឌីយ៉ូ

#include “sl_tflite_micro_init.h” #include “sl_ml_audio_feature_generation_si91x.h”
void main(void) {
sl_ml_audio_feature_generation_init();
while(1){ sl_ml_audio_feature_generation_update_features();
ប្រសិនបើ (do_inference){ sl_ml_audio_feature_generation_fill_tensor(sl_tflite_micro_get_input_tensor()); sl_tflite_micro_get_interpreter()->Invoke();
}
…
} }
ចំណាំថាការធ្វើបច្ចុប្បន្នភាពលក្ខណៈពិសេស និងការទាញយកពួកវាអាចត្រូវបានអនុវត្តដោយឯករាជ្យ។ ការអាប់ដេតលក្ខណៈពិសេសគួរតែត្រូវបានធ្វើជាញឹកញាប់គ្រប់គ្រាន់ដើម្បីជៀសវាងការសរសេរជាន់លើសតិបណ្ដោះអាសន្នអូឌីយ៉ូ ខណៈពេលដែលការទាញយកពួកវាគ្រាន់តែត្រូវធ្វើមុនការសន្និដ្ឋានប៉ុណ្ណោះ។
Typedefs

typedef void(*

sl_ml_audio_feature_generation_mic_callback_t)(ចាត់ទុកជាមោឃៈ *arg, const int16_t *ទិន្នន័យ, uint32_t n_frames)
ប្រភេទមុខងារហៅទូរសព្ទទៅមីក្រូហ្វូនសម្រាប់ការបង្កើតមុខងារសំឡេង។

អថេរ

int16_t *

sl_ml_audio_feature_generation_audio_buffer
សតិបណ្ដោះអាសន្នអូឌីយ៉ូខាងក្រៅសម្រាប់ការបង្កើតមុខងារអូឌីយ៉ូ។

មុខងារ

sl_status_t sl_status_t sl_status_t sl_status_t sl_status_t
int
ទុកជាមោឃៈ

sl_ml_audio_feature_generation_init()
ដំឡើងមីក្រូហ្វូនជាប្រភពសំឡេងសម្រាប់ការបង្កើតមុខងារ និងចាប់ផ្តើមផ្នែកខាងមុខសម្រាប់ការបង្កើតមុខងារ។
sl_ml_audio_feature_generation_frontend_init()
ចាប់ផ្តើម microfrontend យោងតាមការកំណត់នៅក្នុង sl_ml_audio_feature_generation_config.h ។
sl_ml_audio_feature_generation_update_features()
ធ្វើបច្ចុប្បន្នភាពមុខងារបណ្ដោះអាសន្នជាមួយនឹងបំណែកមុខងារដែលបាត់ចាប់តាំងពីការហៅចុងក្រោយទៅកាន់មុខងារនេះ។
sl_ml_audio_feature_generation_get_features_raw(uint16_t *buffer, size_t num_elements)
ទាញយកលក្ខណៈពិសេសដូចប្រភេទ uint16 ហើយចម្លងពួកវាទៅសតិបណ្ដោះអាសន្នដែលបានផ្តល់។
sl_ml_audio_feature_generation_fill_tensor(TfLiteTensor *input_tensor)
បំពេញ TensorFlow tensor ជាមួយនឹងទិន្នន័យលក្ខណៈនៃប្រភេទ int8 ។
sl_ml_audio_feature_generation_get_new_feature_slice_count()
ត្រឡប់ចំនួននៃផ្នែកមុខងារថ្មី ឬមិនបានទាញយកដែលត្រូវបានធ្វើបច្ចុប្បន្នភាពចាប់តាំងពីការហៅចុងក្រោយទៅកាន់ sl_ml_audio_feature_generation_get_features_raw ឬ sl_ml_audio_feature_generation_fill_tensor ។
sl_ml_audio_feature_generation_get_feature_buffer_size()
ត្រឡប់ទំហំផ្ទុកមុខងារ។
sl_ml_audio_feature_generation_reset()
កំណត់ស្ថានភាពរបស់ឧបករណ៍បង្កើតមុខងារអូឌីយ៉ូឡើងវិញ។

៥/៥

ឧបករណ៍បង្កើតមុខងារអូឌីយ៉ូ

sl_status_t

sl_ml_audio_feature_generation_init_with_buffer(int16_t *buffer, int n_frames)
ចាប់ផ្តើមការបង្កើតមុខងារអូឌីយ៉ូជាមួយនឹងសតិបណ្ដោះអាសន្នដែលផ្តល់ដោយអ្នកប្រើប្រាស់។

sl_status_t

sl_ml_audio_feature_generation_get_features_raw_float32(float *buffer, size_t num_elements)
ទាញយកលក្ខណៈពិសេសដូចជាប្រភេទ float32 ហើយចម្លងពួកវាទៅសតិបណ្ដោះអាសន្នដែលបានផ្តល់។

sl_status_t

sl_ml_audio_feature_generation_get_features_scaled(float *buffer, size_t num_elements, float scaler)
ទាញយកលក្ខណៈពិសេស ធ្វើមាត្រដ្ឋានពួកវាដោយមាត្រដ្ឋានដែលបានផ្តល់ឱ្យ ហើយបំពេញបណ្តែតបណ្តែត។

sl_status_t

sl_ml_audio_feature_generation_get_features_mean_std_normalized(float *buffer, size_t num_elements)
ទាញយកលក្ខណៈពិសេស ធ្វើឱ្យពួកវាមានលក្ខណៈធម្មតាដោយផ្តោតលើគម្លាតមធ្យម និងស្តង់ដាររបស់ពួកគេ ហើយបំពេញសតិបណ្ដោះអាសន្នអណ្តែត។

sl_status_t

sl_ml_audio_feature_generation_activity_detected()
ត្រឡប់ប្រសិនបើប្លុកការរកឃើញសកម្មភាពបានរកឃើញសកម្មភាពនៅក្នុងស្ទ្រីមអូឌីយ៉ូ។

sl_status_t

sl_ml_audio_feature_generation_set_mic_callback(sl_ml_audio_feature_generation_mic_callback_t callback, void *arg)
កំណត់ការហៅទូរសព្ទទៅមីក្រូហ្វូនសម្រាប់ការបង្កើតមុខងារអូឌីយ៉ូ។

ឯកសារ Typedef
sl_ml_audio_feature_generation_mic_callback_t

typedef void(* sl_ml_audio_feature_generation_mic_callback_t) (void *arg, const int16_t *data, uint32_t n_frames))(void *arg, const int16_t *data, uint32_t n_frames)

ប្រភេទមុខងារហៅទូរសព្ទទៅមីក្រូហ្វូនសម្រាប់ការបង្កើតមុខងារសំឡេង។ ប៉ារ៉ាម៉ែត្រ

ប្រភេទ

ទិសដៅ N/AN/AN/A

ឈ្មោះអាគុយម៉ង់ arg ទិន្នន័យ n_frames

ការពិពណ៌នា អាគុយម៉ង់កំណត់ដោយអ្នកប្រើប្រាស់បានបញ្ជូនទៅការហៅត្រឡប់មកវិញ។ ចង្អុលទៅសតិបណ្ដោះអាសន្នទិន្នន័យអូឌីយ៉ូ។ ចំនួនស៊ុមអូឌីយ៉ូនៅក្នុងសតិបណ្ដោះអាសន្ន។

ឯកសារអថេរ
sl_ml_audio_feature_generation_audio_buffer
int16_t* sl_ml_audio_feature_generation_audio_buffer សតិបណ្ដោះអាសន្នអូឌីយ៉ូខាងក្រៅសម្រាប់ការបង្កើតមុខងារអូឌីយ៉ូ។
ឯកសារមុខងារ
sl_ml_audio_feature_generation_init
sl_status_t sl_ml_audio_feature_generation_init () ដំឡើងមីក្រូហ្វូនជាប្រភពសំឡេងសម្រាប់ការបង្កើតមុខងារ និងចាប់ផ្តើមផ្នែកខាងមុខសម្រាប់ការបង្កើតមុខងារ។ ត្រឡប់មកវិញ
រក្សាសិទ្ធិ © 2025 Silicon Laboratories ។ រក្សារសិទ្ធគ្រប់យ៉ាង។

៥/៥

កម្មវិធីបង្កើតមុខងារអូឌីយ៉ូ SL_STATUS_OK សម្រាប់ភាពជោគជ័យ SL_STATUS_FAIL

sl_ml_audio_feature_generation_frontend_init
sl_status_t sl_ml_audio_feature_generation_frontend_init ()
ចាប់ផ្តើម microfrontend យោងតាមការកំណត់នៅក្នុង sl_ml_audio_feature_generation_config.h ។ ចាប់ផ្តើម microfrontend យោងតាមការកំណត់នៅក្នុង sl_ml_audio_feature_generation_config_si91x.h. ត្រឡប់មកវិញ
SL_STATUS_OK សម្រាប់ភាពជោគជ័យ SL_STATUS_FAIL

sl_ml_audio_feature_generation_update_features
sl_status_t sl_ml_audio_feature_generation_update_feature ()
ធ្វើបច្ចុប្បន្នភាពមុខងារបណ្ដោះអាសន្នជាមួយនឹងបំណែកមុខងារដែលបាត់ចាប់តាំងពីការហៅចុងក្រោយទៅកាន់មុខងារនេះ។ ដើម្បីទាញយកលក្ខណៈពិសេស សូមទូរស័ព្ទទៅ sl_ml_audio_feature_generation_get_features_raw ឬ sl_ml_audio_feature_generation_fill_tensor ។ ចំណាំ
មុខងារនេះត្រូវការហៅជាញឹកញាប់គ្រប់គ្រាន់ ដើម្បីធានាថា សតិបណ្ដោះអាសន្នសំឡេងមិនត្រូវបានសរសេរជាន់លើទេ។ ត្រឡប់មកវិញ
SL_STATUS_OK សម្រាប់ភាពជោគជ័យ SL_STATUS_EMPTY គ្មានផ្នែកថ្មីត្រូវបានគណនាទេ។

sl_ml_audio_feature_generation_get_features_raw

sl_status_t sl_ml_audio_feature_generation_get_features_raw (uint16_t * buffer, size_t num_elements)

ទាញយកលក្ខណៈពិសេសដូចប្រភេទ uint16 ហើយចម្លងពួកវាទៅសតិបណ្ដោះអាសន្នដែលបានផ្តល់។ ប៉ារ៉ាម៉ែត្រ

ប្រភេទ

ទិសដៅ

ឈ្មោះអាគុយម៉ង់

ការពិពណ៌នា

uint16_t [ចេញ] * ទំហំ_t [ក្នុង]

សតិបណ្ដោះអាសន្ន

ចង្អុលទៅសតិបណ្ដោះអាសន្ន ដើម្បីរក្សាទុកទិន្នន័យមុខងារ

num_elements ចំនួននៃធាតុដែលត្រូវគ្នានឹងទំហំនៃសតិបណ្ដោះអាសន្ន; ប្រសិនបើវាមិនធំគ្រប់គ្រាន់ដើម្បីរក្សាទុកមុខងារទាំងមូល នោះមុខងារនឹងត្រលប់មកវិញដោយមានកំហុស។

ចំណាំ មុខងារនេះសរសេរជាន់លើសតិបណ្ដោះអាសន្នទាំងមូល។
ត្រឡប់ SL_STATUS_OK សម្រាប់ភាពជោគជ័យ SL_STATUS_INVALID_PARAMETER num_elements តូចពេក

sl_ml_audio_feature_generation_fill_tensor

៥/៥

ឧបករណ៍បង្កើតមុខងារអូឌីយ៉ូ

sl_status_t sl_ml_audio_feature_generation_fill_tensor (TfLiteTensor * input_tensor)

បំពេញ TensorFlow tensor ជាមួយនឹងទិន្នន័យលក្ខណៈនៃប្រភេទ int8 ។ ប៉ារ៉ាម៉ែត្រ

វាយ TfLiteTensor *

ទិសដៅ [ក្នុង]

ឈ្មោះអាគុយម៉ង់ input_tensor

ការពិពណ៌នា បញ្ចូល tensor ដើម្បីបំពេញមុខងារ។

តម្លៃ int8 ត្រូវបានមកដោយការធ្វើបរិមាណទិន្នផល microfrontend ដែលរំពឹងថានឹងស្ថិតនៅក្នុងចន្លោះ 0 ទៅ 670 ដើម្បីចុះហត្ថលេខាលើលេខចំនួនគត់ក្នុងចន្លោះ -128 ទៅ 127 ។
ចំណាំ
មុខងារនេះសរសេរជាន់លើឧបករណ៍បញ្ចូលទាំងមូល។ គាំទ្រ tensors ប្រភេទ kTfLiteInt8 ។
ត្រឡប់មកវិញ
SL_STATUS_OK សម្រាប់ភាពជោគជ័យ SL_STATUS_INVALID_PARAMETER ប្រភេទ ឬទំហំ Tensor មិនត្រូវគ្នានឹងការកំណត់រចនាសម្ព័ន្ធទេ

sl_ml_audio_feature_generation_get_new_feature_slice_count
int sl_ml_audio_feature_generation_get_new_feature_slice_count ()
ត្រឡប់ចំនួននៃផ្នែកមុខងារថ្មី ឬមិនបានទាញយកដែលត្រូវបានធ្វើបច្ចុប្បន្នភាពចាប់តាំងពីការហៅចុងក្រោយទៅកាន់ sl_ml_audio_feature_generation_get_features_raw ឬ sl_ml_audio_feature_generation_fill_tensor ។ ត្រឡប់មកវិញ
ចំនួនបំណែកនៃមុខងារដែលមិនបានទាញយក

sl_ml_audio_feature_generation_get_feature_buffer_size
int sl_ml_audio_feature_generation_get_feature_buffer_size ()
ត្រឡប់ទំហំផ្ទុកមុខងារ។ ត្រឡប់មកវិញ
ទំហំនៃបណ្តុំមុខងារ

sl_ml_audio_feature_generation_reset
ចាត់ទុកជាមោឃៈ sl_ml_audio_feature_generation_reset () កំណត់ស្ថានភាពនៃម៉ាស៊ីនបង្កើតមុខងារអូឌីយ៉ូឡើងវិញ។

sl_ml_audio_feature_generation_init_with_buffer
sl_status_t sl_ml_audio_feature_generation_init_with_buffer (int16_t * buffer, int n_frames)

៥/៥

ឧបករណ៍បង្កើតមុខងារអូឌីយ៉ូ

ចាប់ផ្តើមការបង្កើតមុខងារអូឌីយ៉ូជាមួយនឹងសតិបណ្ដោះអាសន្នដែលផ្តល់ដោយអ្នកប្រើប្រាស់។ ប៉ារ៉ាម៉ែត្រ

វាយ int16_t * int

ទិសដៅ [ក្នុង] [ក្នុង]

ឈ្មោះអាគុយម៉ង់ n_frames

ការពិពណ៌នា ចង្អុលទៅសតិបណ្ដោះអាសន្នអូឌីយ៉ូ ដើម្បីប្រើសម្រាប់ការបង្កើតមុខងារ។ ចំនួនស៊ុមអូឌីយ៉ូនៅក្នុងសតិបណ្ដោះអាសន្ន។

ត្រឡប់ SL_STATUS_OK នៅពេលជោគជ័យ SL_STATUS_FAIL បើមិនដូច្នេះទេ។

sl_ml_audio_feature_generation_get_features_raw_float32

sl_status_t sl_ml_audio_feature_generation_get_features_raw_float32 (float * buffer, size_t num_elements)

ទាញយកលក្ខណៈពិសេសដូចជាប្រភេទ float32 ហើយចម្លងពួកវាទៅសតិបណ្ដោះអាសន្នដែលបានផ្តល់។ ប៉ារ៉ាម៉ែត្រ

ប្រភេទ

ទិសដៅ

ឈ្មោះអាគុយម៉ង់

ការពិពណ៌នា

អណ្តែត * [ចេញ]

សតិបណ្ដោះអាសន្ន

ចង្អុលទៅសតិបណ្ដោះអាសន្ន ដើម្បីរក្សាទុកទិន្នន័យមុខងារ

ទំហំ_t [ក្នុង]

sl_ml_audio_feature_generation_get_features_scaled

sl_status_t sl_ml_audio_feature_generation_get_features_scaled (float * buffer, size_t num_elements, float scaler)

ទាញយកលក្ខណៈពិសេស ធ្វើមាត្រដ្ឋានពួកវាដោយមាត្រដ្ឋានដែលបានផ្តល់ឱ្យ ហើយបំពេញបណ្តែតបណ្តែត។ ប៉ារ៉ាម៉ែត្រ

ប្រភេទ

ទិសដៅ

ឈ្មោះអាគុយម៉ង់

ការពិពណ៌នា

អណ្តែត * [ចេញ]

សតិបណ្ដោះអាសន្ន

ចង្អុលទៅសតិបណ្ដោះអាសន្ន ដើម្បីរក្សាទុកទិន្នន័យមុខងារដែលបានធ្វើមាត្រដ្ឋាន

ទំហំ_t [ក្នុង]

អណ្តែត [ក្នុង]

មាត្រដ្ឋាន

កត្តាធ្វើមាត្រដ្ឋានដើម្បីអនុវត្តចំពោះតម្លៃលក្ខណៈពិសេសនីមួយៗ។

buffer = (float)uint16_features_data * កំណត់ចំណាំ scaler
មុខងារនេះសរសេរជាន់លើសតិបណ្ដោះអាសន្នទាំងមូល។

៥/៥

ឧបករណ៍បង្កើតមុខងារអូឌីយ៉ូ
ត្រឡប់ SL_STATUS_OK សម្រាប់ភាពជោគជ័យ SL_STATUS_INVALID_PARAMETER num_elements តូចពេក

sl_ml_audio_feature_generation_get_features_mean_std_ធម្មតា

sl_status_t sl_ml_audio_feature_generation_get_features_mean_std_normalized (float * buffer, size_t num_elements)

ទាញយកលក្ខណៈពិសេស ធ្វើឱ្យពួកវាមានលក្ខណៈធម្មតាដោយផ្តោតលើគម្លាតមធ្យម និងស្តង់ដាររបស់ពួកគេ ហើយបំពេញសតិបណ្ដោះអាសន្នអណ្តែត។ ប៉ារ៉ាម៉ែត្រ

ប្រភេទ

ទិសដៅ

ឈ្មោះអាគុយម៉ង់

ការពិពណ៌នា

អណ្តែត * [ចេញ]

សតិបណ្ដោះអាសន្ន

ចង្អុលទៅសតិបណ្ដោះអាសន្ន ដើម្បីរក្សាទុកទិន្នន័យមុខងារធម្មតា។

ទំហំ_t [ក្នុង]

buffer = ((float)uint16_features_data – mean(uint16_features_data)) / std(uint16_features_data) ចំណាំ
មុខងារនេះសរសេរជាន់លើសតិបណ្ដោះអាសន្នទាំងមូល។ ត្រឡប់មកវិញ
SL_STATUS_OK សម្រាប់ភាពជោគជ័យ SL_STATUS_INVALID_PARAMETER num_elements តូចពេក

sl_ml_audio_feature_generation_activity_បានរកឃើញ
sl_status_t sl_ml_audio_feature_generation_activity_detected ()
ត្រឡប់ប្រសិនបើប្លុកការរកឃើញសកម្មភាពបានរកឃើញសកម្មភាពនៅក្នុងស្ទ្រីមអូឌីយ៉ូ។ sl_ml_audio_feature_generation_update_features() ត្រូវតែត្រូវបានហៅជាទៀងទាត់ ដើម្បីស្វែងរកសកម្មភាព។ ចំណាំ
SL_ML_FRONTEND_ACTIVITY_DETECTION_ENABLE ត្រូវតែជា 1 ដើម្បីប្រើ API នេះ។ ស្ថានភាពខាងក្នុងត្រូវបានកំណត់ឡើងវិញបន្ទាប់ពីហៅ API នេះ។ ឧទាហរណ៍ ប្រសិនបើ API នេះត្រឡប់ SL_STATUS_OK នោះការហៅ API នេះម្តងទៀតនឹងត្រឡប់ SL_STATUS_IN_PROGRESS រហូតដល់សកម្មភាពថ្មីត្រូវបានរកឃើញ។ ត្រឡប់ SL_STATUS_OK គឺសកម្មភាពត្រូវបានរកឃើញ SL_STATUS_IN_PROGRESS មិនបានរកឃើញសកម្មភាព SL_STATUS_NOT_AVAILABLE ប្រសិនបើប្លុករកឃើញសកម្មភាពមិនត្រូវបានបើក

sl_ml_audio_feature_generation_set_mic_callback
sl_status_t sl_ml_audio_feature_generation_set_mic_callback (sl_ml_audio_feature_generation_mic_callback_t callback, void * arg) កំណត់ការហៅត្រលប់មកវិញរបស់មីក្រូហ្វូនសម្រាប់ការបង្កើតមុខងារអូឌីយ៉ូ។ ប៉ារ៉ាម៉ែត្រ
រក្សាសិទ្ធិ © 2025 Silicon Laboratories ។ រក្សារសិទ្ធគ្រប់យ៉ាង។

៥/៥

ឧបករណ៍បង្កើតមុខងារអូឌីយ៉ូ

វាយ sl_ml_audio_feature_generation_mic_callback_t ទុកជាមោឃៈ

ទិសដៅ N/AN/A

ឈ្មោះអាគុយម៉ង់ callback arg

ការពិពណ៌នាមុខងារចង្អុលទៅមីក្រូហ្វូនហៅត្រឡប់មកវិញ។ អាគុយម៉ង់ដែលកំណត់ដោយអ្នកប្រើប្រាស់ដើម្បីបញ្ជូនទៅកាន់ការហៅត្រឡប់មកវិញ។

បង្ហាញលេខកូដស្ថានភាព sl_status_t ដែលបង្ហាញពីជោគជ័យ ឬបរាជ័យ។

៥/៥

កម្មវិធីបង្កើតមុខងាររូបភាព

កម្មវិធីបង្កើតមុខងាររូបភាពដំណើរការបញ្ចូលរូបភាពដែលបានថតចេញពីកាមេរ៉ា និងការស្រង់ចេញនូវមុខងារដែលត្រូវការដើម្បីប្រើជាមួយកម្មវិធីចំណាត់ថ្នាក់រូបភាពរៀនដោយម៉ាស៊ីនដោយប្រើកាមេរ៉ាជាប្រភពរូបភាព។
ជំនាន់លក្ខណៈពិសេស
រូបភាពដែលបានថតទុកមុនបានដំណើរការដោយប្រើការច្រឹប និងការធ្វើឱ្យមានលក្ខណៈធម្មតាកម្រិតមធ្យមដោយផ្អែកលើការកំណត់រចនាសម្ព័ន្ធគំរូដែលបានប្រើពីកម្មវិធី។

រូបភាព

ដំណាំ

ពិនិត្យមធ្យម

ការធ្វើឱ្យមានលក្ខណៈធម្មតា។

គំរូ

ការប្រើប្រាស់
sl_ml_image_feature_generation_init() ចាប់ផ្តើមការបង្កើតលក្ខណៈពិសេសដោយផ្អែកលើការកំណត់នៅក្នុង sl_ml_image_feature_generation_config.h ។ វាក៏ចាប់ផ្តើម និងចាប់ផ្តើមកាមេរ៉ានៅក្នុងរបៀបស្ទ្រីម ដែលដាក់រូបភាព samples ចូលទៅក្នុង ping-pong-buffer ។
រូបភាពត្រូវបានដំណើរការជាមុន និងបានបំពេញក្នុងការបញ្ចូល tensor ពេល sl_ml_image_feature_generation_fill_tensor() ត្រូវបានហៅ។
ដើម្បីទាញយកលក្ខណៈពិសេសដែលបានបង្កើត sl_ml_image_feature_generation_fill_tensor() ត្រូវតែហៅ។
Example
នៅពេលប្រើជាមួយ TensorFlow Lite Micro ឧបករណ៍បង្កើតមុខងាររូបភាពអាចត្រូវបានប្រើដើម្បីបំពេញ tensor ដោយផ្ទាល់ដោយប្រើ sl_ml_image_feature_generation_fill_tensor() ។ ទោះជាយ៉ាងណាក៏ដោយ គំរូត្រូវតែត្រូវបានបណ្តុះបណ្តាលដោយប្រើការកំណត់រចនាសម្ព័ន្ធម៉ាស៊ីនភ្លើងលក្ខណៈដូចគ្នា ដូចដែលបានប្រើសម្រាប់ការសន្និដ្ឋាន ដែលបានកំណត់រចនាសម្ព័ន្ធនៅក្នុង sl_ml_image_feature_generation_config.h ។

៥/៥

កម្មវិធីបង្កើតមុខងាររូបភាព

#include “sl_tflite_micro_init.h” #include “sl_ml_image_feature_generation.h”
void main(void) {
sl_ml_image_feature_generation_init();
while(1){ * if(do_inference){ sl_ml_image_feature_generation_fill_tensor(sl_tflite_micro_get_input_tensor()); sl_tflite_micro_get_interpreter()->Invoke(); }
…
} }

មុខងារ

sl_status_t sl_status_t sl_status_t
មោឃៈ sl_status_t sl_status_t sl_status_t sl_status_t ទុកជាមោឃៈ

sl_ml_image_feature_generation_init()
ដំឡើងកាមេរ៉ាជាប្រភពរូបភាពសម្រាប់ការបង្កើតមុខងារ។
sl_ml_image_feature_generation_fill_tensor(TfLiteTensor *input_tensor)
បំពេញ TensorFlow tensor ជាមួយនឹងទិន្នន័យលក្ខណៈពិសេស។ ប្រភេទទិន្នន័យនៃរូបភាពបញ្ចូលសម្រាប់ម៉ូដែលនឹងត្រូវបានជ្រើសរើសដោយផ្អែកលើការកំណត់រចនាសម្ព័ន្ធគំរូ។
sl_ml_initialize_arducam_camera()
ដំឡើង aurducam ជាប្រភពរូបភាពសម្រាប់ការបង្កើតមុខងារ និងចាប់ផ្តើមកាមេរ៉ាជាមួយនឹងការកំណត់រចនាសម្ព័ន្ធ។
sl_ml_dump_image(const uint8_t *image_data, uint32_t image_length)
ដំឡើងស្ទ្រីម JLink ជាថ្នាំងលទ្ធផល។ ទិន្នន័យរូបភាពបានផ្សាយតាម JLink ទៅចំណុចប្រទាក់ python ។
sl_ml_retrieve_next_camera_image(uint8_t **image_data, uint32_t *image_size)
ទាញយករូបភាពពី ping-pog buffer ដែលថតចេញពី aurducam ។ រក្សាទុកទិន្នន័យរូបភាពទៅកាន់ទ្រនិចទិសដៅ។
sl_ml_image_crop_lut_init()
Initializes រកមើលតារាងសម្រាប់ការច្រឹបរូបភាព។
sl_ml_image_feature_generation_get_image_scaled(uint8_t *image_data, float *buffer, size_t num_elements, float scaler)
ទាញយកលក្ខណៈពិសេស ធ្វើមាត្រដ្ឋានពួកវាដោយមាត្រដ្ឋានដែលបានផ្តល់ឱ្យ ហើយបំពេញបណ្តែតបណ្តែត។
sl_ml_get_image_mean(uint8_t *in_cam_image, float *mean, float *mean2, size_t num_elements)
គណនាមធ្យម និងមធ្យមការ៉េនៃរូបភាពបញ្ចូល។
sl_ml_image_feature_generation_get_image_mean_std_normalized(uint8_t *image_data, float *buffer, float mean, float mean2, size_t num_elements)
ទាញយកលក្ខណៈពិសេស ធ្វើឱ្យពួកវាមានលក្ខណៈធម្មតាដោយផ្តោតលើគម្លាតមធ្យម និងស្តង់ដាររបស់ពួកគេ ហើយបំពេញសតិបណ្ដោះអាសន្នអណ្តែត។
sl_ml_image_feature_generation_get_image_raw_float32(uint8_t *image_data, float *buffer, size_t num_elements)
ទាញយកលក្ខណៈពិសេសដូចជាប្រភេទ float32 ហើយចម្លងពួកវាទៅសតិបណ្ដោះអាសន្នដែលបានផ្តល់។
sl_ml_image_feature_generation_reset()
កំណត់ស្ថានភាពនៃកម្មវិធីបង្កើតមុខងាររូបភាពឡើងវិញ។

ឯកសារមុខងារ
sl_ml_image_feature_generation_init

៥/៥

កម្មវិធីបង្កើតមុខងាររូបភាព

sl_status_t sl_ml_image_feature_generation_init ()
ដំឡើងកាមេរ៉ាជាប្រភពរូបភាពសម្រាប់ការបង្កើតមុខងារ។ ត្រឡប់មកវិញ
SL_STATUS_OK សម្រាប់ភាពជោគជ័យ SL_STATUS_FAIL

sl_ml_image_feature_generation_fill_tensor

sl_status_t sl_ml_image_feature_generation_fill_tensor (TfLiteTensor * input_tensor)

បំពេញ TensorFlow tensor ជាមួយនឹងទិន្នន័យលក្ខណៈពិសេស។ ប្រភេទទិន្នន័យនៃរូបភាពបញ្ចូលសម្រាប់ម៉ូដែលនឹងត្រូវបានជ្រើសរើសដោយផ្អែកលើការកំណត់រចនាសម្ព័ន្ធគំរូ។ ប៉ារ៉ាម៉ែត្រ

វាយ TfLiteTensor *

ទិសដៅ [ក្នុង]

ឈ្មោះអាគុយម៉ង់ input_tensor

ការពិពណ៌នា បញ្ចូល tensor ដើម្បីបំពេញមុខងារ។

ចំណាំ មុខងារនេះសរសេរជាន់លើតង់សឺរបញ្ចូលទាំងមូល។
ត្រឡប់ SL_STATUS_OK សម្រាប់ភាពជោគជ័យ SL_STATUS_INVALID_PARAMETER ប្រភេទ ឬទំហំ Tensor មិនត្រូវគ្នានឹងការកំណត់រចនាសម្ព័ន្ធទេ

sl_ml_initialize_arducam_camera
sl_status_t sl_ml_initialize_arducam_camera ()
ដំឡើង aurducam ជាប្រភពរូបភាពសម្រាប់ការបង្កើតមុខងារ និងចាប់ផ្តើមកាមេរ៉ាជាមួយនឹងការកំណត់រចនាសម្ព័ន្ធ។ ត្រឡប់មកវិញ
SL_STATUS_OK សម្រាប់ភាពជោគជ័យ SL_STATUS_FAIL

sl_ml_dump_រូបភាព

ទុកជាមោឃៈ sl_ml_dump_image (const uint8_t * image_data, ប្រវែងរូបភាព uint32_t)

ដំឡើងស្ទ្រីម JLink ជាថ្នាំងលទ្ធផល។ ទិន្នន័យរូបភាពបានផ្សាយតាម JLink ទៅចំណុចប្រទាក់ python ។ ប៉ារ៉ាម៉ែត្រ

វាយ const uint8_t * uint32_t

ទិសដៅ N/AN/A

ឈ្មោះអាគុយម៉ង់ image_data image_length

ត្រឡប់មកវិញ

SL_STATUS_OK សម្រាប់ភាពជោគជ័យ SL_STATUS_FAIL

ការពិពណ៌នា

៥/៥

កម្មវិធីបង្កើតមុខងាររូបភាព

sl_ml_retrieve_next_camera_image

ទុកចោល sl_ml_retrieve_next_camera_image (uint8_t ** image_data, uint32_t * image_size)

ទាញយករូបភាពពី ping-pog buffer ដែលថតចេញពី aurducam ។ រក្សាទុកទិន្នន័យរូបភាពទៅកាន់ទ្រនិចទិសដៅ។ ប៉ារ៉ាម៉ែត្រ

វាយ uint8_t ** uint32_t *

ទិសដៅ N/AN/A

ឈ្មោះអាគុយម៉ង់ image_data image_size

ការពិពណ៌នា

sl_ml_image_crop_lut_init
void sl_ml_image_crop_lut_init () ចាប់ផ្តើម រកមើលតារាងសម្រាប់ច្រឹបរូបភាព។

sl_ml_image_feature_generation_get_image_scaled

sl_status_t sl_ml_image_feature_generation_get_image_scaled (uint8_t * image_data, float * buffer, size_t num_elements, float scaler)

ប្រភេទ

ទិសដៅ

ឈ្មោះអាគុយម៉ង់

ការពិពណ៌នា

uint8_t [ចេញ] * អណ្តែត * [ក្នុង]

រូបភាព_ទិន្នន័យបណ្តោះអាសន្ន

ចង្អុលទៅសតិបណ្ដោះអាសន្ន ដើម្បីរក្សាទុកទិន្នន័យមុខងារដែលបានធ្វើមាត្រដ្ឋាន
ចំនួននៃធាតុដែលត្រូវគ្នាទៅនឹងទំហំនៃសតិបណ្ដោះអាសន្ន; ប្រសិនបើវាមិនធំគ្រប់គ្រាន់ដើម្បីរក្សាទុកមុខងារទាំងមូល នោះមុខងារនឹងត្រលប់មកវិញដោយមានកំហុស។

ទំហំ_t [ក្នុង]

num_elements កត្តាធ្វើមាត្រដ្ឋានដែលត្រូវអនុវត្តចំពោះតម្លៃលក្ខណៈពិសេសនីមួយៗ។

អណ្តែត N/A

មាត្រដ្ឋាន

buffer = (float)image_data * scaler

ចំណាំ

មុខងារនេះសរសេរជាន់លើសតិបណ្ដោះអាសន្នទាំងមូល។

ត្រឡប់មកវិញ

SL_STATUS_OK សម្រាប់ភាពជោគជ័យ SL_STATUS_INVALID_PARAMETER num_elements តូចពេក

sl_ml_get_image_mean
sl_status_t sl_ml_get_image_mean (uint8_t * in_cam_image, float * mean, float * mean2, size_t num_elements)
គណនាមធ្យម និងមធ្យមការ៉េនៃរូបភាពបញ្ចូល។ ប៉ារ៉ាម៉ែត្រ
រក្សាសិទ្ធិ © 2025 Silicon Laboratories ។ រក្សារសិទ្ធគ្រប់យ៉ាង។

៥/៥

កម្មវិធីបង្កើតមុខងាររូបភាព

ប្រភេទ

ទិសដៅ

ឈ្មោះអាគុយម៉ង់

ការពិពណ៌នា

ប្រភេទ

ទិសដៅ

ឈ្មោះអាគុយម៉ង់

ការពិពណ៌នា

uint8_t [ចេញ] * អណ្តែត * [ចេញ]

in_cam_image ចង្អុលទៅមធ្យម ដើម្បីរក្សាទុកតម្លៃមធ្យមនៃរូបភាព។

មធ្យម

ចង្អុលទៅ mean2 ដើម្បីរក្សាទុកតម្លៃមធ្យមការ៉េនៃរូបភាព។

អណ្តែត * [ក្នុង]

មានន័យថា ២

ចំនួននៃធាតុដែលត្រូវគ្នាទៅនឹងទំហំនៃសតិបណ្ដោះអាសន្ន; ប្រសិនបើវាមិនធំគ្រប់គ្រាន់ដើម្បីរក្សាទុកមុខងារទាំងមូល នោះមុខងារនឹងត្រលប់មកវិញដោយមានកំហុស។

size_t N/A

num_ធាតុ

មធ្យម = ((អណ្តែត)រូបភាព_ទិន្នន័យ / (ទទឹង*ប្រវែង)

ត្រឡប់មកវិញ

SL_STATUS_OK សម្រាប់ភាពជោគជ័យ SL_STATUS_INVALID_PARAMETER num_elements តូចពេក

sl_ml_image_feature_generation_get_image_mean_std_ធម្មតា។

sl_status_t sl_ml_image_feature_generation_get_image_mean_std_normalized (uint8_t * image_data, float * buffer, float mean, float mean2, size_t num_elements)

ប្រភេទ

ទិសដៅ

ឈ្មោះអាគុយម៉ង់

ការពិពណ៌នា

uint8_t [ចេញ] * អណ្តែត * [ក្នុង]

រូបភាព_ទិន្នន័យបណ្តោះអាសន្ន

ចង្អុលទៅសតិបណ្ដោះអាសន្ន ដើម្បីរក្សាទុកលក្ខណៈធម្មតានៃទិន្នន័យអណ្តែតមធ្យម តម្លៃមធ្យមនៃរូបភាព។

អណ្តែត [ក្នុង]

មធ្យម

float mean2, មធ្យមតម្លៃការ៉េនៃរូបភាព។

អណ្តែត [ក្នុង]

មានន័យថា ២

size_t N/A

num_ធាតុ

buffer = ((float)image_data – mean(image_data)) / std(image_data)

ចំណាំ

មុខងារនេះសរសេរជាន់លើសតិបណ្ដោះអាសន្នទាំងមូល។

ត្រឡប់មកវិញ

SL_STATUS_OK សម្រាប់ភាពជោគជ័យ SL_STATUS_INVALID_PARAMETER num_elements តូចពេក

sl_ml_image_feature_generation_get_image_raw_float32
sl_status_t sl_ml_image_feature_generation_get_image_raw_float32 (uint8_t * image_data, float * buffer, size_t num_elements) ទាញយកលក្ខណៈពិសេសដូចជាប្រភេទ float32 ហើយចម្លងពួកវាទៅសតិបណ្ដោះអាសន្នដែលបានផ្តល់។ ប៉ារ៉ាម៉ែត្រ

៥/៥

កម្មវិធីបង្កើតមុខងាររូបភាព

ប្រភេទ

ទិសដៅ

ឈ្មោះអាគុយម៉ង់

ការពិពណ៌នា

uint8_t [ចេញ] * អណ្តែត * [ក្នុង]

រូបភាព_ទិន្នន័យបណ្តោះអាសន្ន

ចង្អុលទៅសតិបណ្ដោះអាសន្ន ដើម្បីរក្សាទុកទិន្នន័យមុខងារ
ចំនួននៃធាតុដែលត្រូវគ្នាទៅនឹងទំហំនៃសតិបណ្ដោះអាសន្ន; ប្រសិនបើវាមិនធំគ្រប់គ្រាន់ដើម្បីរក្សាទុកមុខងារទាំងមូល នោះមុខងារនឹងត្រលប់មកវិញដោយមានកំហុស។

size_t N/A

num_ធាតុ

ចំណាំ

មុខងារនេះសរសេរជាន់លើសតិបណ្ដោះអាសន្នទាំងមូល។

ត្រឡប់មកវិញ

SL_STATUS_OK សម្រាប់ភាពជោគជ័យ SL_STATUS_INVALID_PARAMETER num_elements តូចពេក

sl_ml_image_feature_generation_reset
ចាត់ទុកជាមោឃៈ sl_ml_image_feature_generation_reset () កំណត់ស្ថានភាពនៃម៉ាស៊ីនបង្កើតមុខងាររូបភាពឡើងវិញ។

៥/៥

TensorFlow Lite Micro Debug

ឧបករណ៍ប្រើប្រាស់ SL បន្ថែមសម្រាប់ការចូល TensorFlow Lite Micro ។
មុខងារ

bool ទទេ

sl_tflite_micro_enable_debug_log(បើកដំណើរការ)
បើក ឬបិទការកត់ត្រាបំបាត់កំហុស។
sl_tflite_micro_is_debug_log_enabled(ទុកជាមោឃៈ)
ពិនិត្យមើលថាតើការកត់ត្រាបំបាត់កំហុសត្រូវបានបើកឬអត់។

ឯកសារមុខងារ
sl_tflite_micro_enable_debug_log

ទុកជាមោឃៈ sl_tflite_micro_enable_debug_log (បើកដំណើរការ)

បើក ឬបិទការកត់ត្រាបំបាត់កំហុស។ ប៉ារ៉ាម៉ែត្រ

វាយប៊ូល។

ទិសដៅ [ក្នុង]

ឈ្មោះអាគុយម៉ង់បើក

ការពិពណ៌នាថាតើការកត់ត្រាបំបាត់កំហុសគួរតែត្រូវបានបើក ឬបិទ។

sl_tflite_micro_is_debug_log_បានបើកដំណើរការ

bool sl_tflite_micro_is_debug_log_បានបើកដំណើរការ (ទុកជាមោឃៈ)

ពិនិត្យមើលថាតើការកត់ត្រាបំបាត់កំហុសត្រូវបានបើកឬអត់។ ប៉ារ៉ាម៉ែត្រ

វាយបញ្ចូលភាពទទេ

ទិសដៅ N/A

ត្រឡប់មកវិញ

ថាតើការកត់ត្រាបំបាត់កំហុសត្រូវបានបើកឬអត់។

ឈ្មោះអាគុយម៉ង់

ការពិពណ៌នា

៥/៥

TensorFlow Lite Micro Init

មុខងារ TensorFlow Lite Micro Init ត្រូវបានបង្កើតដោយស្វ័យប្រវត្តិពី flatbuffer file បានផ្តល់នៅក្នុងការកំណត់រចនាសម្ព័ន្ធ ដែលរួមបញ្ចូល opsResolver ដែលបង្កើតដោយយោងទៅតាមប្រតិបត្តិករដែលបានរួមបញ្ចូលនៅក្នុង flatbuffer ។ មុខងារជំនួយក្នុងការចូលប្រើ tensors បញ្ចូល និងទិន្នផលក៏ត្រូវបានផ្តល់ជូនផងដែរ។
មុខងារ

sl_status_t
uint8_t * tflite::ErrorR
អ្នករាយការណ៍ * tflite:: MicroI
អ្នកបកប្រែ * TfLiteTensor * TfLiteTensor * tflite::MicroO
pResolver & ចាត់ទុកជាមោឃៈ

sl_tflite_micro_estimate_arena_size(const tflite::Model *model, const tflite::MicroOpResolver &opcode_resolver, size_t *estimated_size)
ប៉ាន់ស្មានទំហំសង្វៀនសម្រាប់គំរូដែលបានផ្តល់ឱ្យ។
sl_tflite_micro_allocate_tensor_arena(size_t arena_size, uint8_t **tensor_arena)
បែងចែកសតិបណ្ដោះអាសន្នថាមវន្តដែលអាចប្រើបានសម្រាប់សង្វៀន tensor ។
sl_tflite_micro_get_error_reporter()
ទទួលបានទ្រនិចទៅអ្នករាយការណ៍កំហុស TensorFlow Lite Micro ដែលបង្កើតឡើងដោយមុខងារ init ។
sl_tflite_micro_get_interpreter()
ទទួលបានទ្រនិចទៅអ្នកបកប្រែ TensorFlow Lite Micro ដែលបង្កើតឡើងដោយមុខងារ init ។
sl_tflite_micro_get_input_tensor()
ទទួលបានទ្រនិចទៅឧបករណ៍បញ្ចូល tensor ដែលកំណត់ដោយអនុគមន៍ init ។
sl_tflite_micro_get_output_tensor()
ទទួលបានទ្រនិចមួយទៅកាន់ output tensor ដែលកំណត់ដោយអនុគមន៍ init ។
sl_tflite_micro_opcode_resolver()
ទទួលបានទ្រនិចទៅឧបករណ៍ដោះស្រាយ opcode សម្រាប់ flatbuffer ដែលផ្តល់ដោយការកំណត់រចនាសម្ព័ន្ធ។
sl_tflite_micro_init (ចាត់ទុកជាមោឃៈ)
បង្កើតអ្នករាយការណ៍កំហុស និងអ្នកដោះស្រាយ opcode ហើយចាប់ផ្តើមអថេរសម្រាប់ flatbuffer ដែលបានផ្តល់ឱ្យដោយការកំណត់រចនាសម្ព័ន្ធ។

ឯកសារមុខងារ
sl_tflite_micro_estimate_arena_size

sl_status_t sl_tflite_micro_estimate_arena_size (const tflite::Model * model, const tflite::MicroOpResolver & opcode_resolver, size_t *ប៉ាន់ស្មាន_ទំហំ)

ប៉ាន់ស្មានទំហំសង្វៀនសម្រាប់គំរូដែលបានផ្តល់ឱ្យ។ ប៉ារ៉ាម៉ែត្រ

វាយ const tflite::Model * const tflite::MicroOpResolver & size_t *

ទិសដៅ [ចូល] [ចូល] [ចេញ]

អាគុយម៉ង់ ឈ្មោះគំរូ opcode_resolver ប៉ាន់ស្មាន_ទំហំ

ត្រឡប់ SL_STATUS_OK ប្រសិនបើការប៉ាន់ស្មានបានជោគជ័យ។

ការពិពណ៌នាចង្អុលទៅម៉ូដែលដើម្បីប៉ាន់ប្រមាណទំហំសង្វៀនសម្រាប់។ ឧបករណ៍ដោះស្រាយ opcode សម្រាប់ប្រើសម្រាប់ម៉ូដែល។ ទំហំប៉ាន់ស្មាននៃសង្វៀនដែលជាលទ្ធផល។

៥/៥

TensorFlow Lite Micro Init

sl_tflite_micro_allocate_tensor_arena

uint8_t * sl_tflite_micro_allocate_tensor_arena (ទំហំ_t arena_size, uint8_t ** tensor_arena)

បែងចែកសតិបណ្ដោះអាសន្នថាមវន្តដែលអាចប្រើបានសម្រាប់សង្វៀន tensor ។ ប៉ារ៉ាម៉ែត្រ

វាយ size_t uint8_t **

ទិសដៅ [ចូល] [ចេញ]

ឈ្មោះអាគុយម៉ង់ arena_size tensor_arena

ការពិពណ៌នាទំហំនៃសង្វៀនដែលត្រូវបែងចែក។ ចង្អុលទៅសតិបណ្ដោះអាសន្ន tensor ដែលត្រូវបានបម្រុងទុក។

ត្រឡប់មកវិញ
ទ្រនិចទៅសតិបណ្ដោះអាសន្នមូលដ្ឋានដែលបានបែងចែក។ ត្រឡប់ nullptr ប្រសិនបើការបែងចែកបរាជ័យ។ សតិបណ្ដោះអាសន្នមូលដ្ឋានត្រូវបានប្រើសម្រាប់ការដោះលែងអង្គចងចាំដែលបានបម្រុងទុក។

sl_tflite_micro_get_error_reporter
tflite::ErrorReporter * sl_tflite_micro_get_error_reporter ()
ទទួលបានទ្រនិចទៅអ្នករាយការណ៍កំហុស TensorFlow Lite Micro ដែលបង្កើតឡើងដោយមុខងារ init ។ ត្រឡប់មកវិញ
ចង្អុលទៅអ្នករាយការណ៍កំហុស។

sl_tflite_micro_get_interpreter
tflite::MicroInterpreter * sl_tflite_micro_get_interpreter ()
ទទួលបានទ្រនិចទៅអ្នកបកប្រែ TensorFlow Lite Micro ដែលបង្កើតឡើងដោយមុខងារ init ។ ត្រឡប់មកវិញ
ចង្អុលទៅអ្នកបកប្រែ។

sl_tflite_micro_get_input_tensor
TfLiteTensor * sl_tflite_micro_get_input_tensor ()
ទទួលបានទ្រនិចទៅឧបករណ៍បញ្ចូល tensor ដែលកំណត់ដោយអនុគមន៍ init ។ ត្រឡប់មកវិញ
ទ្រនិចទៅទ្រនិចបញ្ចូល។

sl_tflite_micro_get_output_tensor
TfLiteTensor * sl_tflite_micro_get_output_tensor ()

៥/៥

TensorFlow Lite Micro Init
ទទួលបានទ្រនិចមួយទៅកាន់ output tensor ដែលកំណត់ដោយអនុគមន៍ init ។ ត្រឡប់មកវិញ
ទ្រនិចទៅទ្រនិចទិន្នផល។

sl_tflite_micro_opcode_resolver
tflite::MicroOpResolver & sl_tflite_micro_opcode_resolver ()
ទទួលបានទ្រនិចទៅឧបករណ៍ដោះស្រាយ opcode សម្រាប់ flatbuffer ដែលផ្តល់ដោយការកំណត់រចនាសម្ព័ន្ធ។ ត្រឡប់មកវិញ
អាសយដ្ឋានទៅកាន់អ្នកដោះស្រាយ opcode ។

sl_tflite_micro_init

ទុកជាមោឃៈ sl_tflite_micro_init (ទុកជាមោឃៈ)

បង្កើតអ្នករាយការណ៍កំហុស និងអ្នកដោះស្រាយ opcode ហើយចាប់ផ្តើមអថេរសម្រាប់ flatbuffer ដែលបានផ្តល់ឱ្យដោយការកំណត់រចនាសម្ព័ន្ធ។ ប៉ារ៉ាម៉ែត្រ

វាយបញ្ចូលភាពទទេ

ទិសដៅ N/A

ឈ្មោះអាគុយម៉ង់

ការពិពណ៌នា

៥/៥

Sampកម្មវិធី
Sampកម្មវិធី
Sample កម្មវិធី លើសview
កម្មវិធីខាងក្រោមបង្ហាញពីការប្រើប្រាស់ TensorFlow Lite សម្រាប់ក្របខ័ណ្ឌ Microcontrollers ជាមួយ Simplicity SDK ។
ពន្លឺបញ្ជាសំឡេង
កម្មវិធីនេះបង្ហាញពីបណ្តាញសរសៃប្រសាទជាមួយ TensorFlow Lite សម្រាប់ Microcontrollers ដើម្បីស្វែងរកពាក្យ "បើក" និង "បិទ" ពីទិន្នន័យអូឌីយ៉ូដែលបានកត់ត្រានៅលើមីក្រូហ្វូននៅក្នុងភារកិច្ចខឺណែល Micrium OS ។ ពាក្យគន្លឹះដែលបានរកឃើញត្រូវបានប្រើដើម្បីគ្រប់គ្រង LED នៅលើក្តារ។ ទិន្នន័យអូឌីយ៉ូគឺ sampដឹកនាំបន្ត និងដំណើរការជាមុនដោយប្រើសមាសភាគម៉ាស៊ីនបង្កើតមុខងារអូឌីយ៉ូ។ ការសន្និដ្ឋានត្រូវបានដំណើរការរៀងរាល់ 200 ms នៅលើទិន្នន័យអូឌីយ៉ូ ~ 1 វិនាទីកន្លងមក។ នេះ សampកម្មវិធី le ប្រើ Flatbuffer Converter Tool ដើម្បីបន្ថែម .tflite file ទៅកម្មវិធីគោលពីរ។
Z3 ប្តូរជាមួយសំឡេង
កម្មវិធីនេះរួមបញ្ចូលគ្នានូវការរកឃើញសំឡេងជាមួយ Zigbee 3.0 ដើម្បីបង្កើតថ្នាំងប្តូរដែលគ្រប់គ្រងដោយសំឡេងដែលអាចត្រូវបានប្រើដើម្បីបិទ/បើកថ្នាំងពន្លឺ។ កម្មវិធីនេះប្រើគំរូដូចគ្នាទៅនឹង Voice Control Light ដើម្បីស្វែងរកពាក្យគន្លឹះដែលបាននិយាយ “បើក” និង “បិទ”។ នៅពេលរកឃើញ កុងតាក់បញ្ជូនពាក្យបញ្ជា បើក/បិទ លើបណ្តាញ Zigbee ។ នេះ សampកម្មវិធី le ប្រើ Flatbuffer Converter Tool ដើម្បីបន្ថែម .tflite file ទៅកម្មវិធីគោលពីរ។
TensorFlow Lite Micro - សួស្តីពិភពលោក
កម្មវិធីនេះបង្ហាញពីគំរូដែលត្រូវបានបណ្តុះបណ្តាលដើម្បីចម្លងមុខងារស៊ីនុស និងប្រើលទ្ធផលសន្និដ្ឋានដើម្បីបន្ថយ LED ។ កម្មវិធីនេះត្រូវបានសរសេរដំបូងដោយ TensorFlow ប៉ុន្តែត្រូវបានបញ្ជូនទៅកាន់ Simplicity SDK ។ ម៉ូដែលនេះគឺប្រហែល 2.5 KB ។ កម្មវិធីទាំងមូលចំណាយពេលប្រហែល 157 KB flash និង 15 KB RAM ។ កម្មវិធីនេះប្រើអង្គចងចាំពន្លឺច្រើនព្រោះវាមិនបញ្ជាក់ដោយដៃនូវប្រតិបត្តិការណាមួយដែលត្រូវបានប្រើនៅក្នុងគំរូ ហើយជាលទ្ធផល ចងក្រងការអនុវត្តខឺណែលទាំងអស់។ កម្មវិធីនេះបង្ហាញពីកម្មវិធីការសន្និដ្ឋានតិចតួចបំផុត និងបម្រើជាចំណុចចាប់ផ្តើមដ៏ល្អសម្រាប់ការយល់ដឹងអំពីលំហូរការបកស្រាយគំរូ TensorFlow Lite សម្រាប់ Microcontrollers ។ នេះ សample កម្មវិធីប្រើគំរូថេរដែលមាននៅក្នុង hello_world_model_data.cc ។
TensorFlow Lite Micro - ការនិយាយខ្នាតតូច
កម្មវិធីនេះបង្ហាញគំរូ 20 KB ដែលត្រូវបានបណ្តុះបណ្តាលដើម្បីស្វែងរកពាក្យសាមញ្ញពីទិន្នន័យការនិយាយដែលបានកត់ត្រាពីមីក្រូហ្វូន។ កម្មវិធីនេះត្រូវបានសរសេរដំបូងដោយ TensorFlow ប៉ុន្តែត្រូវបានបញ្ជូនទៅកាន់ Simplicity SDK ។ កម្មវិធីនេះប្រើប្រហែល 100 KB flash និង 37 KB នៃ RAM ។ ប្រហែល 10 KB នៃការប្រើប្រាស់ RAM គឺទាក់ទងទៅនឹង FFT frontend និងដើម្បីរក្សាទុកទិន្នន័យអូឌីយ៉ូ។ ជាមួយនឹងល្បឿននាឡិកា 38.4 MHz និងប្រើប្រាស់ការអនុវត្តន៍ខឺណែលដែលបានធ្វើឱ្យប្រសើរ ពេលវេលាសន្និដ្ឋានលើទិន្នន័យអូឌីយ៉ូ ~1 s គឺប្រហែល 111 ms ។ កម្មវិធីនេះបង្ហាញពីដំណើរការនៃការបង្កើតលក្ខណៈពិសេសពីទិន្នន័យអូឌីយ៉ូ និងធ្វើការរកឃើញក្នុងពេលវេលាជាក់ស្តែង។ វាក៏បង្ហាញពីរបៀបដើម្បីបញ្ជាក់ដោយដៃនូវប្រតិបត្តិការណាមួយដែលត្រូវបានប្រើនៅក្នុងបណ្តាញ ដែលជួយសន្សំសំចៃពន្លឺយ៉ាងច្រើន។ នេះ សampកម្មវិធី le ប្រើគំរូថេរដែលមាននៅក្នុង micro_speech_model_data.cc ។
TensorFlow Lite Micro - Magic Wand

៥/៥

Sampកម្មវិធី
កម្មវិធីនេះបង្ហាញគំរូទំហំ 10 KB ដែលត្រូវបានបណ្តុះបណ្តាលដើម្បីសម្គាល់កាយវិការដៃផ្សេងៗដោយប្រើឧបករណ៍វាស់ល្បឿនដើម្បីចាប់ចលនា។ កាយវិការដែលបានរកឃើញត្រូវបានបោះពុម្ពទៅច្រកសៀរៀល។ កម្មវិធីនេះត្រូវបានសរសេរដំបូងដោយ TensorFlow ប៉ុន្តែត្រូវបានបញ្ជូនទៅកាន់ Simplicity SDK ។
កម្មវិធីនេះប្រើប្រហែល 104 KB flash និង 25 KB នៃ RAM ។ កម្មវិធីនេះបង្ហាញពីរបៀបប្រើទិន្នន័យ accelerometer ជាការបញ្ចូលការសន្និដ្ឋាន ហើយក៏បង្ហាញពីរបៀបដើម្បីបញ្ជាក់ដោយខ្លួនឯងនូវប្រតិបត្តិការណាមួយដែលត្រូវបានប្រើនៅក្នុងបណ្តាញ ដែលរក្សាទុកចំនួន flash យ៉ាងច្រើន។
នេះ សampកម្មវិធី le ប្រើ Flatbuffer Converter Tool ដើម្បីបន្ថែម .tflite file ទៅកម្មវិធីគោលពីរ។
TensorFlow Model Profiler
កម្មវិធីនេះត្រូវបានរចនាឡើងដើម្បីគាំទ្រfile គំរូ TensorFlow Lite Micro នៅលើផ្នែករឹងរបស់ Silicon Labs ។ គំរូដែលប្រើដោយកម្មវិធីត្រូវបានផ្តល់ដោយ TensorFlow Lite flatbuffer file ហៅថា model.tflite នៅក្នុងថតរង config/tflite ។ គាំទ្រfiler នឹងវាស់ចំនួនវដ្តនាឡិកា CPU និងពេលវេលាដែលកន្លងផុតទៅក្នុងស្រទាប់នីមួយៗនៃគំរូ នៅពេលអនុវត្តការសន្និដ្ឋានមួយ។ វាក៏នឹងបង្កើតសេចក្តីសង្ខេបផងដែរ នៅពេលដែលការសន្និដ្ឋានត្រូវបានធ្វើរួច។ ស្រទាប់បញ្ចូលនៃគំរូត្រូវបានបំពេញដោយសូន្យទាំងអស់ មុនពេលអនុវត្តការសន្និដ្ឋានតែមួយ។ លទ្ធផលនៃទម្រង់ត្រូវបានបញ្ជូនតាម VCOM ។
ដើម្បីដំណើរការកម្មវិធីជាមួយនឹងគំរូ .tflite ផ្សេង អ្នកអាចជំនួសវាបាន file ហៅថា model.tflite ជាមួយនឹង TensorFlow Lite Micro flatbuffer ថ្មី។ file. ថ្មីនេះ។ file ត្រូវតែត្រូវបានគេហៅថា "model.tflite" ហើយត្រូវបានដាក់នៅខាងក្នុងថតរង config/tflite ដែលត្រូវជ្រើសរើសដោយ sampកម្មវិធី le ។ បន្ទាប់ពីគំរូត្រូវបានជំនួស បង្កើតគម្រោងឡើងវិញ។
ដើម្បីផ្ទុក និងអនុវត្តការសន្និដ្ឋានលើគំរូ TensorFlow Lite Micro សូមបែងចែកបៃមួយចំនួនទៅ "tensor arena" ដើម្បីរក្សាស្ថានភាពដែលត្រូវការដោយ TensorFlow Lite Micro ។ ទំហំនៃសង្វៀន tensor នេះអាស្រ័យលើទំហំនៃគំរូ និងចំនួនប្រតិបត្តិករ។ TensorFlow Model Profileកម្មវិធី r អាចត្រូវបានប្រើដើម្បីវាស់បរិមាណ RAM ដែលត្រូវការដោយ tensor Arena ដើម្បីផ្ទុកគំរូ TensorFlow Lite Micro ជាក់លាក់។ នេះត្រូវបានវាស់ដោយការបែងចែក RAM យ៉ាងសកម្មសម្រាប់ tensor Arena និងរាយការណ៍ពីចំនួនបៃដែលត្រូវការនៅលើ VCOM ។ ចំនួនបៃដែលត្រូវការសម្រាប់ tensor arena ក្រោយមកអាចប្រើដើម្បីបែងចែកអង្គចងចាំជាស្ថាពរ នៅពេលដែលគំរូត្រូវបានប្រើនៅក្នុងកម្មវិធីផ្សេង។
នេះ សampកម្មវិធី le ប្រើ Flatbuffer Converter Tool ដើម្បីបន្ថែម .tflite file ទៅកម្មវិធីគោលពីរ។
រ៉ុក-ក្រដាស-កន្ត្រៃ (ចំណាត់ថ្នាក់រូបភាព)
ការចាត់ថ្នាក់រូបភាពគឺជាកម្មវិធីដ៏សំខាន់បំផុតមួយនៃការរៀនស៊ីជម្រៅ និងបញ្ញាសិប្បនិម្មិត។ ការចាត់ថ្នាក់រូបភាពសំដៅលើការផ្តល់ស្លាកទៅរូបភាពដោយផ្អែកលើលក្ខណៈជាក់លាក់ ឬលក្ខណៈពិសេសដែលមាននៅក្នុងពួកវា។ ក្បួនដោះស្រាយកំណត់លក្ខណៈពិសេសទាំងនេះ ហើយប្រើពួកវាដើម្បីបែងចែករវាងរូបភាពផ្សេងៗគ្នា និងកំណត់ស្លាកឱ្យពួកគេ។
កម្មវិធីនេះប្រើ TensorFlow Lite សម្រាប់ Microcontrollers ដើម្បីដំណើរការគំរូនៃការរៀនម៉ាស៊ីនចំណាត់ថ្នាក់រូបភាពដើម្បីចាត់ថ្នាក់កាយវិការដៃពីទិន្នន័យរូបភាពដែលបានចាប់យកពីកាមេរ៉ា ArduCAM ។ ការរកឃើញត្រូវបានមើលឃើញដោយប្រើ LED នៅលើក្តារ ហើយលទ្ធផលចំណាត់ថ្នាក់ត្រូវបានសរសេរទៅកាន់ច្រកសៀរៀល VCOM ។
សម្រាប់ព័ត៌មានបន្ថែម សូមមើលឯកសារអ្នកចាត់ថ្នាក់រូបភាព។

៥/៥

អ្នកចាត់ថ្នាក់រូបភាព
អ្នកចាត់ថ្នាក់រូបភាព
អ្នកចាត់ថ្នាក់រូបភាព
ការចាត់ថ្នាក់រូបភាពគឺជាកម្មវិធីដ៏សំខាន់បំផុតមួយនៃការរៀនស៊ីជម្រៅ និងបញ្ញាសិប្បនិម្មិត។ ការចាត់ថ្នាក់រូបភាពសំដៅលើការផ្តល់ស្លាកទៅរូបភាពដោយផ្អែកលើលក្ខណៈជាក់លាក់ ឬលក្ខណៈពិសេសដែលមាននៅក្នុងពួកវា។ ក្បួនដោះស្រាយកំណត់លក្ខណៈពិសេសទាំងនេះ ហើយប្រើពួកវាដើម្បីបែងចែករវាងរូបភាពផ្សេងៗគ្នា និងកំណត់ស្លាកឱ្យពួកគេ។ កម្មវិធីនេះប្រើ TensorFlow Lite សម្រាប់ Microcontrollers ដើម្បីដំណើរការគំរូនៃការរៀនម៉ាស៊ីនចំណាត់ថ្នាក់រូបភាពដើម្បីចាត់ថ្នាក់កាយវិការដៃពីទិន្នន័យរូបភាពដែលបានចាប់យកពីកាមេរ៉ា ArduCAM ។ ការរកឃើញត្រូវបានមើលឃើញដោយប្រើ LED នៅលើក្តារ ហើយលទ្ធផលចំណាត់ថ្នាក់ត្រូវបានសរសេរទៅកាន់ច្រកសៀរៀល VCOM ។ នេះ សampកម្មវិធី le ប្រើ Flatbuffer Converter Tool ដើម្បីបន្ថែម .tflite file ទៅកម្មវិធីគោលពីរ។
ស្លាកថ្នាក់
ថ្ម៖ រូបភាពនៃដៃមនុស្សធ្វើ ក

ផ្នែករឹង និងការដំឡើងដែលត្រូវការ
បន្ទះស៊េរី Silicon Labs EFR BRD2601B ឬ BRD2608A ។ ឧបករណ៍ភ្ជាប់ Berg Strip ជាមួយខ្សែ Jumper (រាប់ចំនួន 8 យ៉ាងតិច) ណាមួយនៃបន្សំខាងក្រោម។
ឆ្នូត Male-Berg ជាមួយខ្សែលោតពីស្រីទៅស្រី។ បន្ទះស្រី-Berg ជាមួយខ្សែលោតពីបុរសទៅស្ត្រី។ ម៉ូឌុលកាមេរ៉ា ArduCAM ។
កំណត់រចនាសម្ព័ន្ធម្ជុល
តារាងខាងក្រោមបង្ហាញការភ្ជាប់ម្ជុលរវាង ArduCAM និងឧបករណ៍អភិវឌ្ឍន៍។
រក្សាសិទ្ធិ © 2025 Silicon Laboratories ។ រក្សារសិទ្ធគ្រប់យ៉ាង។

៥/៥

អ្នកចាត់ថ្នាក់រូបភាព

ArduCAM Pin GND VCC CS MOSI MISO SCK SDA SCL

Board Expansion Header Pin 1 18 10 4 6 8 16 ១៥

កម្មវិធីដែលត្រូវការ
ស្ទូឌីយោសាមញ្ញ v5 ជាមួយ simplicity_sdk aiml-extension
ទម្លាក់រូបភាពទៅកុំព្យូទ័រ
កម្មវិធីនេះប្រើ JLink ដើម្បីស្ទ្រីមទិន្នន័យរូបភាពទៅស្គ្រីប Python ដែលមានទីតាំងនៅ aiml-extension/tools/image-visualization។ ដើម្បីចាប់ផ្តើម សូមមើលការណែនាំដែលមាននៅក្នុង readme.md file. នៅពេលដែលកម្មវិធីគោលពីរត្រូវបានបញ្ចេញទៅលើក្រុមប្រឹក្សាអភិវឌ្ឍន៍ អ្នកអាចបើកដំណើរការឧបករណ៍មើលឃើញ view ស្ទ្រីមរូបភាពចូល និងរក្សាទុកវាជាជម្រើសទៅក្នុងកុំព្យូទ័រមូលដ្ឋានរបស់អ្នក។
កំណត់ចំណាំកម្មវិធី
ការបញ្ចូលកាមេរ៉ា៖ កម្មវិធីនេះប្រើប្រាស់រូបភាពដែលបានថតដោយប្រើកាមេរ៉ា ArduCAM ។ លក្ខខណ្ឌពន្លឺ៖ គំរូត្រូវបានបណ្តុះបណ្តាលលើរូបភាពដែលមានពន្លឺល្អ។ ដើម្បីសម្រេចបានលទ្ធផលល្អបំផុត ធ្វើការពិសោធន៍ក្នុងពន្លឺល្អ។ កែតម្រូវប៉ារ៉ាម៉ែត្រ SL_ML_IMAGE_MEAN_THRESHOLD ក្នុងការកំណត់រចនាសម្ព័ន្ធ .slcp file ដើម្បីកំណត់អាំងតង់ស៊ីតេមធ្យមអប្បបរមាដែលត្រូវការសម្រាប់ដំណើរការរូបភាព។ ចម្ងាយដែលបានណែនាំ៖ រក្សាចម្ងាយប្រហែល 0.5 ម៉ែត្ររវាងកាមេរ៉ា និងដៃរបស់វត្ថុអំឡុងពេលពិសោធន៍។ ការរៀបចំផ្ទៃខាងក្រោយ៖ ប្រើផ្ទៃខាងក្រោយធម្មតា (និយមពណ៌ស ឬខ្មៅ) ដើម្បីកែលម្អភាពត្រឹមត្រូវនៃការរកឃើញ និងភាពជាប់លាប់។
បណ្តាញសរសៃប្រសាទ Convolutional
ប្រភេទនៃគំរូរៀនម៉ាស៊ីនដែលប្រើក្នុងកម្មវិធីនេះគឺ Convolutional Neural Network (CNN)។
Convolutional Neural Network (ConvNet/CNN) គឺជាក្បួនដោះស្រាយ Deep Learning ដែលអាចចាប់យករូបភាពបញ្ចូល ផ្តល់សារៈសំខាន់ (ទម្ងន់ដែលអាចរៀនបាន និងភាពលំអៀង) ចំពោះទិដ្ឋភាព/វត្ថុផ្សេងៗក្នុងរូបភាព និងអាចបែងចែកមួយពីផ្សេងទៀត។
CNN ធម្មតាអាចត្រូវបានគេមើលឃើញដូចខាងក្រោម:

៥/៥

ឧបករណ៍ចាត់ថ្នាក់រូបភាព A ធម្មតា CNN មានស្រទាប់ជាច្រើន។ ស្រទាប់ដែលបានផ្តល់ឱ្យគឺជាប្រតិបត្តិការគណិតវិទ្យាជាមូលដ្ឋានដែលដំណើរការលើអារេពហុវិមាត្រ (ហៅថា tensors)។ ស្រទាប់នៃ CNN អាចបែងចែកជាពីរដំណាក់កាលស្នូល៖ ការរៀនមុខងារ៖ វាប្រើស្រទាប់ Convolutional ដើម្បីស្រង់ចេញ
បំពង់សិក្សាជ្រៅ
បំពង់សម្រាប់សិក្សាជ្រៅ ជាធម្មតាមានបឋមសិក្សាចំនួនបីtages: ការប្រមូលសំណុំទិន្នន័យ ការបណ្តុះបណ្តាលគំរូ និងការសន្និដ្ឋានដូចខាងក្រោម។
មួយចំនួន sampទិន្នន័យដែលបានប្រើសម្រាប់ការបណ្តុះបណ្តាលគំរូនៅក្នុងកម្មវិធីនេះត្រូវបានបង្ហាញនៅក្នុងរូបភាពខាងក្រោម។

ដំណើរការទិន្នន័យជាមុន
ដំណើរការមុន stage ពាក់ព័ន្ធនឹងការកំណត់ធម្មតានៃទិន្នន័យជាក់លាក់ ដែលគ្រប់គ្រងដោយសមាសធាតុ ml_image_feature_generation ។ សamplewise_center = ពិត samplewise_std_normalization = ពិត

៥/៥

អ្នកចាត់ថ្នាក់រូបភាព
norm_img = (img – mean(img)) / std(img) ការកំណត់ទាំងនេះធ្វើឱ្យរូបភាពបញ្ចូលនីមួយៗមានលក្ខណៈធម្មតាដោយប្រើរូបមន្ត។ នេះជួយឱ្យប្រាកដថាម៉ូដែលមិនអាស្រ័យលើការប្រែប្រួលកាមេរ៉ា និងពន្លឺ។
ព័ត៌មានលំអិតម៉ូដែល
ការសង្ខេបគំរូបង្ហាញព័ត៌មានលម្អិតអំពីស្រទាប់នីមួយៗ រួមជាមួយនឹងចំនួនប៉ារ៉ាម៉ែត្រដែលពាក់ព័ន្ធ។ ការវិភាគនេះរៀបរាប់អំពីស្ថាបត្យកម្មដែលប្រើដើម្បីអនុវត្តកិច្ចការចាត់ថ្នាក់រូបភាព។

ការវាយតម្លៃគំរូ
វិធីសាស្រ្តជាមូលដ្ឋានក្នុងការវាយតម្លៃគំរូពាក់ព័ន្ធនឹងការធ្វើតេស្តការផ្តល់អាហារamples-ថ្មី ទិន្នន័យដែលមើលមិនឃើញ មិនត្រូវបានប្រើប្រាស់កំឡុងពេលហ្វឹកហាត់ ចូលទៅក្នុងគំរូ និងប្រៀបធៀបការព្យាករណ៍របស់វាជាមួយនឹងតម្លៃដែលរំពឹងទុកពិតប្រាកដ។ ប្រសិនបើរាល់ការទស្សន៍ទាយត្រឹមត្រូវ គំរូសម្រេចបាននូវភាពត្រឹមត្រូវ 100% ។ ការទស្សន៍ទាយមិនត្រឹមត្រូវនីមួយៗកាត់បន្ថយភាពត្រឹមត្រូវសរុប។
រូបខាងក្រោមបង្ហាញពីសូចនាករការអនុវត្តសំខាន់ៗ (KPIs) ដែលសម្រេចបានដោយប្រើសំណុំទិន្នន័យ Rock-Paper-Scissors រួមទាំង៖
ភាពត្រឹមត្រូវ៖ សមាមាត្រនៃការទស្សន៍ទាយត្រឹមត្រូវលើការព្យាករណ៍សរុប ROC Curve៖ តំណាងក្រាហ្វិកនៃអត្រាវិជ្ជមានពិតធៀបនឹងអត្រាវិជ្ជមានមិនពិត ការរំលឹកឡើងវិញ៖ រង្វាស់នៃសមត្ថភាពរបស់គំរូដើម្បីកំណត់អត្តសញ្ញាណករណីពាក់ព័ន្ធទាំងអស់ ភាពជាក់លាក់៖ សមាមាត្រនៃវិជ្ជមានពិតក្នុងចំណោមការព្យាករណ៍វិជ្ជមានទាំងអស់

៥/៥

អ្នកចាត់ថ្នាក់រូបភាព

ភាពត្រឹមត្រូវសរុប៖ ៩៥.០៣៧% ភាពត្រឹមត្រូវនៃថ្នាក់៖
ក្រដាស = 98.394% កន្ត្រៃ = 97.500% ថ្ម = 92.476% មិនស្គាល់ = 92.083% មធ្យម ROC AUC: 98.664% ថ្នាក់ ROC AUC: ក្រដាស = 99.461% មិនស្គាល់ = 99.042% កន្ត្រៃ = 98.554.% ថ្ម = 97.600% ថ្ម

៥/៥

ប្រធានបទបន្ថែម
ប្រធានបទបន្ថែម
ឧបករណ៍ភាគីទីបី និងដំណោះស្រាយដៃគូ
ឧបករណ៍
TensorFlow
SiSDK គាំទ្រ TensorFlow Lite សម្រាប់ Microcontrollers (TFLM) ដើម។ អ្នកអភិវឌ្ឍន៍អាចបង្កើតគំរូ .tflite ដែលមានបរិមាណ file ដោយប្រើបរិយាកាស TensorFlow ដោយផ្ទាល់ ហើយបញ្ចូលវាទៅក្នុង GDSK ។ ការចាប់ផ្តើម
ការបង្កើតគំរូដោយប្រើ TensorFlow និង Keras
Silicon Labs Machine Learning Toolkit (MLTK) (បដិសេធ)
ប្រអប់ឧបករណ៍រៀនម៉ាស៊ីន (MLTK) ត្រូវបានបង្កើតឡើងសម្រាប់ហេតុផលទាំងនេះដើម្បីជួយអ្នកអភិវឌ្ឍន៍ Tensorflow ។ វាគឺជាសំណុំនៃស្គ្រីប python ដែលត្រូវបានរចនាឡើងដើម្បីអនុវត្តតាមដំណើរការការងាររៀនម៉ាស៊ីនធម្មតាសម្រាប់ឧបករណ៍បង្កប់ Silicon Labs ។
ចំណាំ៖ កញ្ចប់នេះត្រូវបានបង្កើតឡើងជាប្រភពបើកចំហ បម្រើដោយខ្លួនឯង គាំទ្រសហគមន៍ កញ្ចប់ឯកសារយោងជាមួយនឹងសំណុំឯកសារអនឡាញដ៏ទូលំទូលាយ។ មិនមានសេវាកម្មគាំទ្រ Silicon Labs សម្រាប់កម្មវិធីនេះទេនៅពេលនេះ។ ស្គ្រីបទាំងនេះគឺជាការអនុវត្តឯកសារយោងសម្រាប់ករណីប្រើប្រាស់ដែលគ្របដណ្តប់ដោយការបង្រៀនដែលបានចងក្រងជាឯកសារ។ ការគាំទ្រសម្រាប់ករណីប្រើប្រាស់ផ្សេងទៀតគឺជាការទទួលខុសត្រូវរបស់អ្នកអភិវឌ្ឍន៍។
ការចាប់ផ្តើមបង្កើតគំរូស្វែងរកពាក្យគន្លឹះសម្រាប់ SiSDK exampលេ (GitHub.io) - ការបង្រៀន MLTK
ការរួមបញ្ចូលគំរូ
គំរូដែលបានបណ្តុះបណ្តាល មិនថាប្រើ TensorFlow ដោយផ្ទាល់ ឬ MLTK ត្រូវបានតំណាងនៅក្នុង .tflite file. ដើម្បីបន្ថែម .tflite file ទៅកាន់កម្មវិធីបង្កប់របស់អ្នក សូមមើលការបង្កើតកម្មវិធីសន្និដ្ឋាន។ មាន SiSDK examples ដែលរួមបញ្ចូលការរៀនម៉ាស៊ីន និងបង្ហាញពីរបៀបដំណើរការការសន្និដ្ឋានដោយប្រើគំរូដែលបានបណ្តុះបណ្តាលជាមុន។ ម៉ូដែលដែលបានបណ្តុះបណ្តាលមុនអាចត្រូវបានជំនួសដោយគំរូមួយ។

ឯកសារ/ធនធាន

Silicon Labs នាំមកនូវ AI និង Machine Learning [pdf] សៀវភៅណែនាំអ្នកប្រើប្រាស់
នាំមកនូវ AI និង Machine Learning នាំមកនូវ AI និង Machine Learning ការរៀនម៉ាស៊ីន ការរៀន

ឯកសារយោង

សៀវភៅណែនាំអ្នកប្រើប្រាស់

នាំមកនូវ AI និង Machine Learning

លក្ខណៈ​ពិសេស៖

ព័ត៌មានផលិតផល៖

សេចក្តីណែនាំអំពីការប្រើប្រាស់៖

ការចាប់ផ្តើម៖

កម្មវិធីចាត់ថ្នាក់រូបភាព៖

ការផ្លាស់ប្តូរ API៖

សំណួរគេសួរញឹកញាប់៖

សំណួរ៖ តើឧបករណ៍អ្វីខ្លះដែលត្រូវបានគាំទ្រដោយផ្នែកបន្ថែមការរៀនម៉ាស៊ីន SDK កំណែ 2.1.1?

សំណួរ៖ តើអ្វីជាលក្ខណៈសំខាន់ៗដែលបានបន្ថែមនៅក្នុងកំណែ 2.1.1 នៃ ផ្នែកបន្ថែម SDK?

ឯកសារ/ធនធាន

ឯកសារយោង

ទុកមតិយោបល់

បោះបង់ការឆ្លើយតប

លក្ខណៈពិសេស៖

សំណួរ៖ តើឧបករណ៍អ្វីខ្លះដែលត្រូវបានគាំទ្រដោយផ្នែកបន្ថែមការរៀនម៉ាស៊ីន
SDK កំណែ 2.1.1?

សំណួរ៖ តើអ្វីជាលក្ខណៈសំខាន់ៗដែលបានបន្ថែមនៅក្នុងកំណែ 2.1.1 នៃ
ផ្នែកបន្ថែម SDK?