ទិដ្ឋភាពមួយនៃសេណារីយ៉ូគឺការបង្កើតគំរូរៀនម៉ាស៊ីន។ វាត្រូវតែអាចប្រើប្រាស់បាននៅក្នុងពិភពពិត ហើយមានសម្រាប់អ្នកប្រើប្រាស់ និងអ្នកអភិវឌ្ឍន៍។
មធ្យោបាយដ៏សាមញ្ញ និងពេញនិយមបំផុតក្នុងការដាក់ឱ្យប្រើប្រាស់ម៉ូដែលរៀនម៉ាស៊ីនគឺដើម្បីភ្ជាប់ពួកវានៅក្នុង REST API ។
ជាមួយនឹងបណ្ណាល័យដ៏ពេញនិយមមួយដែលមានឈ្មោះថា FastAPI នោះហើយជាអ្វីដែលយើងនឹងសម្រេចបាននៅថ្ងៃនេះ។
ប៉ុន្តែតើអ្វីទៅជា អាយភីអេស?
ក្របខ័ណ្ឌបណ្ដាញ FastAPI Python ត្រូវបានបង្កើតឡើងតាំងពីមូលដ្ឋានឡើង ដើម្បីទាញយកអត្ថប្រយោជន៍ពីសមត្ថភាព Python សហសម័យ។
សម្រាប់ការទំនាក់ទំនងអសមកាល និងស្របគ្នាជាមួយអតិថិជន វាប្រកាន់ខ្ជាប់នូវស្តង់ដារ ASGI ខណៈពេលដែលវាក៏អាចប្រើ WSGI ផងដែរ។
ចំណុចបញ្ចប់ និងផ្លូវទាំងពីរអាចប្រើមុខងារ async ។ លើសពីនេះ FastAPI បើកដំណើរការបង្កើតកម្មវិធីគេហទំព័រប្រកបដោយផលិតភាពនៅក្នុងកូដ Python សហសម័យដែលមានការណែនាំ ប្រភេទស្អាត។
ករណីប្រើប្រាស់សំខាន់របស់ FastAPI គឺដូចដែលឈ្មោះបានបង្ហាញ ការបង្កើតចំណុចបញ្ចប់ API ។
ការប្រើប្រាស់ស្តង់ដារ OpenAPI ដែលរួមបញ្ចូល Swagger UI អន្តរកម្ម ឬការផ្តល់ទិន្នន័យវចនានុក្រម Python ជា JSON គឺជាវិធីសាមញ្ញទាំងពីរដើម្បីសម្រេចបាន។ ទោះយ៉ាងណាក៏ដោយ FastAPI មិនត្រឹមតែសម្រាប់ APIs ប៉ុណ្ណោះទេ។
វាអាចត្រូវបានប្រើដើម្បីផ្តល់ជូននូវគេហទំព័រស្តង់ដារដោយប្រើម៉ាស៊ីនគំរូ Jinja2 និងដើម្បីបម្រើកម្មវិធីដែលប្រើប្រាស់ WebSockets បន្ថែមពីលើអ្វីៗជាច្រើនទៀតដែលក្របខ័ណ្ឌគេហទំព័រអាចធ្វើបាន។
នៅក្នុងអត្ថបទនេះ យើងនឹងបង្កើតគំរូម៉ាស៊ីនរៀនត្រង់មួយ ហើយបន្ទាប់មកប្រើ FastAPI ដើម្បីដាក់ឱ្យប្រើប្រាស់វា។ តោះចាប់ផ្ដើម។
ការដំឡើង FastAPI និងការបង្កើត API ដំបូង
ការដំឡើងបណ្ណាល័យ និងម៉ាស៊ីនមេ ASGI គឺចាំបាច់ជាមុនសិន។ ទាំង Uvuicorn ឬ Hypercorn នឹងដំណើរការ។ វាដំណើរការដោយបញ្ចូលពាក្យបញ្ជាខាងក្រោមទៅក្នុងស្ថានីយ៖
ឥឡូវនេះ API ត្រូវបានបង្កើតឡើង អ្នកអាចប្រើកម្មវិធីនិពន្ធកូដដែលអ្នកពេញចិត្ត ហើយរកមើលតាមរយៈវា។ បង្កើតស្គ្រីប Python ហៅថា ml_model.py ដើម្បីចាប់ផ្តើម។ អ្នកត្រូវបានស្វាគមន៍ក្នុងការដាក់ឈ្មោះផ្សេងរបស់អ្នក ប៉ុន្តែសម្រាប់ជាប្រយោជន៍នៃការបង្ហោះនេះ ខ្ញុំនឹងយោងឯកសារនេះថា ml_model.py ។
ដើម្បីបង្កើត API ត្រង់ជាមួយចំណុចបញ្ចប់ពីរ អ្នកត្រូវតែបំពេញកិច្ចការខាងក្រោម៖
- នាំចូលបណ្ណាល័យ FastAPI និង Uvicorn ។
- ដំឡើងឧទាហរណ៍ថ្នាក់ FastAPI ។
- ប្រកាសផ្លូវទីមួយ ដែលនៅលើទំព័រលិបិក្រម បង្កើតវត្ថុ JSON ត្រង់។
- ប្រកាសផ្លូវទីពីរ ដែលផ្តល់នូវវត្ថុ JSON ត្រង់ជាមួយសារតាមបំណង។ ប៉ារ៉ាម៉ែត្រឈ្មោះត្រូវបានយកដោយផ្ទាល់ពី URL (ឧទាហរណ៍ https://127.0.0.1:8000/Jay) ។
- ប្រើប្រាស់ Uvicorn ដើម្បីដំណើរការ API ។
ការអនុវត្តដំណាក់កាលទាំងប្រាំនេះត្រូវបានបង្ហាញនៅក្នុងប៊ីតនៃកូដខាងក្រោម។ បង្កើត API សាមញ្ញ
រួចរាល់ហើយ! តោះចាប់ផ្តើម API របស់យើងភ្លាមៗ។ បើកបង្អួចស្ថានីយនៅជាប់នឹងឯកសារ ml model.py ដើម្បីសម្រេចកិច្ចការនេះ។ បន្ទាប់មកបញ្ចូលដូចខាងក្រោម៖
គ្រាប់ចុចបញ្ចូល។ មុននឹងបន្ត សូមលុបការអះអាងនេះ។ កម្មវិធីដំបូងប្រើឈ្មោះឯកសារ Python តែម្នាក់ឯងដោយគ្មានផ្នែកបន្ថែម។ កម្មវិធីទីពីរត្រូវតែមានឈ្មោះដូចគ្នានឹង FastAPI របស់អ្នក។
ដោយប្រើ -reload អ្នកប្រាប់ API ថាអ្នកចង់ឱ្យវាផ្ទុកឡើងវិញដោយស្វ័យប្រវត្តិនៅពេលអ្នករក្សាទុកឯកសារជាជាងចាប់ផ្តើមពីដំបូង។
ឥឡូវនេះបើកដំណើរការកម្មវិធីរុករកហើយចូលទៅកាន់ https://127.0.0.1:8000; លទ្ធផលគួរតែលេចឡើងដូចខាងក្រោមៈ
ឥឡូវនេះអ្នកយល់ពីរបៀបបង្កើត API សាមញ្ញដោយប្រើ FastAPI ។
ការកសាង និងបណ្តុះបណ្តាលគំរូម៉ាស៊ីនរៀន
ដោយមិនប្រមូល ឬវិភាគទិន្នន័យណាមួយទេ យើងនឹងបណ្តុះបណ្តាលគំរូសាមញ្ញមួយ។ ទាំងនេះមិនទាក់ទងនឹងការដាក់ពង្រាយម៉ូដែល ហើយមិនសំខាន់ចំពោះប្រធានបទនៅក្នុងដៃនោះទេ។
គំរូដែលផ្អែកលើសំណុំទិន្នន័យ Iris អាចត្រូវបានដំឡើងដោយប្រើដូចគ្នា។ បណ្តាញសរសៃប្រសាទ វិធីសាស្រ្តដំឡើង។
ហើយយើងនឹងធ្វើដូចនេះ៖ ទាញយក សំណុំទិន្នន័យ Iris និងបណ្តុះបណ្តាលគំរូ។ នោះនឹងមិនសាមញ្ញទេ។ ដើម្បីចាប់ផ្តើម សូមបង្កើតឯកសារមួយដែលមានឈ្មោះថា jaysmlmodel.py។
នៅក្នុងវាអ្នកនឹងធ្វើដូចខាងក្រោម:
- ការនាំចូល — អ្នកនឹងត្រូវការខ្លាឃ្មុំផេនដា scikit-RandomForecastClassifier រៀន BaseModel របស់ pydantic (អ្នកនឹងរកឃើញមូលហេតុនៅក្នុងជំហានបន្ទាប់) និង joblib សម្រាប់រក្សាទុក និងផ្ទុកគំរូ។
- ប្រកាសថ្នាក់ IrisSpecies ដែលទទួលមរតកពីគំរូមូលដ្ឋាន។ ថ្នាក់នេះមានតែវាលដែលត្រូវការដើម្បីព្យាករណ៍ប្រភេទផ្កាតែមួយប៉ុណ្ណោះ (បន្ថែមលើវានៅផ្នែកបន្ទាប់)
- បង្កើតថ្នាក់។ IrisModel គឺជាឧបករណ៍បណ្តុះបណ្តាល និងទស្សន៍ទាយគំរូ។
- ប្រកាសវិធីសាស្រ្តមួយដែលមានឈ្មោះថា _train model នៅក្នុង IrisModel ។ វាត្រូវបានប្រើដើម្បីបណ្តុះបណ្តាលម៉ូដែលដោយប្រើបច្ចេកទេស Random Forests។ គំរូដែលត្រូវបានបណ្តុះបណ្តាលត្រូវបានប្រគល់មកវិញដោយនីតិវិធី។
- ប្រកាសមុខងារប្រភេទដែលបានព្យាករណ៍នៅខាងក្នុង IrisModel ។ វាត្រូវបានគេប្រើដើម្បីព្យាករដោយផ្អែកលើកត្តាបញ្ចូលចំនួន 4 (ការវាស់វែងផ្កា)។ ទាំងការព្យាករណ៍ (ប្រភេទផ្កា) និងប្រូបាប៊ីលីតេនៃការទស្សន៍ទាយត្រូវបានត្រលប់មកវិញដោយក្បួនដោះស្រាយ។
- ផ្លាស់ប្តូរ constructor នៅក្នុង IrisModel ដើម្បីឱ្យវាផ្ទុកសំណុំទិន្នន័យ Iris និងបង្ហាត់គំរូប្រសិនបើវាបាត់ពីថត។ នេះដោះស្រាយបញ្ហានៃការបណ្តុះបណ្តាលម្តងហើយម្តងទៀតនូវម៉ូដែលថ្មីៗ។ បណ្ណាល័យ joblib ត្រូវបានប្រើប្រាស់សម្រាប់ការផ្ទុក និងរក្សាទុកគំរូ។
នេះជាកូដទាំងមូល៖
ខ្ញុំសង្ឃឹមថាបញ្ជីខាងលើ និងមតិយោបល់បានធ្វើឱ្យវាងាយស្រួលក្នុងការយល់ បើទោះបីជានេះជាចំនួនដ៏ច្រើននៃកូដដើម្បីបង្កើតក៏ដោយ។ ឥឡូវនេះ គំរូនេះត្រូវបានបង្កើតឡើង សូមផ្សព្វផ្សាយសមត្ថភាពទស្សន៍ទាយរបស់វានៅលើ ក REST API.
កំពុងបង្កើត REST API ពេញលេញ
ត្រឡប់ទៅឯកសារ ml_model.py ហើយលុបទិន្នន័យទាំងអស់។ បន្ទះ boilerplate នឹងមានលក្ខណៈដូចគ្នាទៅនឹងអ្វីដែលអ្នកមានពីមុន ប៉ុន្តែយើងគួរតែចាប់ផ្តើមឡើងវិញជាមួយនឹងឯកសារទទេ។
អ្នកនឹងកំណត់តែចំណុចបញ្ចប់មួយប៉ុណ្ណោះនៅពេលនេះ ដែលជាចំណុចដែលប្រើក្នុងការកំណត់ប្រភេទផ្កា។ IrisModel.predict species() ដែលត្រូវបានប្រកាសនៅក្នុងផ្នែកមុនត្រូវបានហៅដោយចំណុចបញ្ចប់នេះដើម្បីអនុវត្តការទស្សន៍ទាយ។
ប្រភេទសំណើគឺជាការផ្លាស់ប្តូរដ៏ធំផ្សេងទៀត។ ដើម្បីបញ្ជូនប៉ារ៉ាម៉ែត្រនៅក្នុង JSON ជាជាង URL វាត្រូវបានណែនាំឱ្យអ្នកប្រើ POST នៅពេលប្រើ ការរៀនម៉ាស៊ីន APIs ។
ប្រយោគខាងលើអាចស្តាប់ទៅដូចជានិយាយលេងសើច ប្រសិនបើអ្នកជា ក អ្នកវិទ្យាសាស្ត្រទិន្នន័យប៉ុន្តែវាមិនអីទេ។ ដើម្បីរចនា និងដាក់ពង្រាយម៉ូដែល មិនចាំបាច់ក្លាយជាអ្នកជំនាញលើសំណើ HTTP និង REST APIs នោះទេ។
ភារកិច្ចសម្រាប់ ml model.py គឺតិចតួច និងត្រង់៖
- អ្នកត្រូវតែនាំចូលឯកសារខាងក្រោមពីឯកសារ jaymlmodel.py ដែលបានបង្កើតពីមុន៖ uvicorn, FastAPI, IrisModel, និង IrisSpecies ។
- បង្កើតឧទាហរណ៍នៃ FastAPI និង IrisModel ។
- ប្រកាសមុខងារនៅ https://127.0.0.1:8000/predict ដើម្បីធ្វើការទស្សន៍ទាយ។
- វិធីសាស្ត្រ IrisModel.predict species() ទទួលវត្ថុនៃប្រភេទ IrisSpecies បំប្លែងវាទៅជាវចនានុក្រម ហើយបន្ទាប់មកបញ្ជូនវាមកវិញ។ ការត្រឡប់មកវិញគឺជាថ្នាក់ដែលរំពឹងទុក និងប្រូបាប៊ីលីតេដែលបានព្យាករណ៍។
- ប្រើ uvicorn ដើម្បីប្រតិបត្តិ API ។
ជាថ្មីម្តងទៀត នេះគឺជាកូដរបស់ឯកសារទាំងមូល រួមជាមួយនឹងមតិយោបល់របស់វា៖
នោះហើយជាអ្វីដែលអ្នកត្រូវធ្វើ។ នៅជំហានបន្ទាប់ ចូរយើងសាកល្បង API ។
ការធ្វើតេស្ត API
បញ្ចូលបន្ទាត់ខាងក្រោមទៅក្នុងស្ថានីយឡើងវិញ ដើម្បីប្រតិបត្តិ API៖ uvicorn ml_model:app –reload
នេះជារបៀបដែលទំព័រឯកសារលេចឡើង៖
នោះហើយជាវាសម្រាប់ថ្ងៃនេះ។ នៅក្នុងផ្នែកបន្ទាប់ពីនេះសូមសន្និដ្ឋាន។
សន្និដ្ឋាន
ថ្ងៃនេះ អ្នកបានដឹងពីអ្វីដែល FastAPI និងរបៀបប្រើវា ដោយប្រើទាំងឧទាហរណ៍ API សាមញ្ញ និងឧទាហរណ៍ការរៀនម៉ាស៊ីនសាមញ្ញ។ អ្នកក៏បានរៀនពីរបៀបបង្កើត និងមើលឯកសារ API ក៏ដូចជារបៀបសាកល្បងវា។
វាច្រើនណាស់សម្រាប់មួយដុំ ដូច្នេះកុំភ្ញាក់ផ្អើលប្រសិនបើវាត្រូវការអានពីរបីដើម្បីយល់ឱ្យបានត្រឹមត្រូវ។
រីករាយក្នុងការសរសេរកូដ។
សូមផ្ដល់យោបល់