You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
352 lines
29 KiB
352 lines
29 KiB
# បង្កើតកម្មវិធីវេបសាយដើម្បីប្រើម៉ូដែល ML
|
|
|
|
នៅក្នុងមេរៀននេះ អ្នកនឹងបណ្តុះបណ្តាលម៉ូដែល MLលើទិន្នន័យមួយដែលមកពីពិភពលោកខាងក្រៅ៖ _ការមើលឃើញ UFO លើរយៈពេលមួយសតវត្សที่ผ่านมา_ ដែលបានយកពីមូលដ្ឋានទិន្នន័យ NUFORC។
|
|
|
|
អ្នកនឹងរៀន៖
|
|
|
|
- របៀប 'pickle' ម៉ូដែលបានបណ្តុះបណ្តាល
|
|
- របៀបប្រើម៉ូដែលនោះក្នុងកម្មវិធី Flask
|
|
|
|
យើងនឹងបន្ដប្រើកំណត់ត្រាដើម្បីសម្អាតទិន្នន័យ និងបណ្តុះបណ្តាលម៉ូដែលរបស់យើង ប៉ុន្តែអ្នកអាចយកដំណើរការនេះទៅជំហានបន្ថែម ដោយស្វែងយល់ពីរបៀបប្រើម៉ូដែល 'នៅតាមធម្មជាតិ' និយាយម្នាដូចជា នៅក្នុងកម្មវិធីវេបសាយ។
|
|
|
|
ដើម្បីធ្វើនេះ អ្នកត្រូវបង្កើតកម្មវិធីវេបសាយដោយប្រើ Flask។
|
|
|
|
## [សំណួរមុនមេរៀន](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
## ការបង្កើតកម្មវិធី
|
|
|
|
មានវិធីជាច្រើនក្នុងការបង្កើតកម្មវិធីវេបសាយសម្រាប់ប្រើម៉ូដែលម៉ាស៊ីនរៀន។ វិធានាស្ថាបត្យកម្មវេបសាយរបស់អ្នកអាចមានឥទ្ធិពលលើរបៀបដែលម៉ូដែលរបស់អ្នកត្រូវបានបណ្តុះបណ្តាល។ សូមនិយាយថាអ្នកកំពុងធ្វើការនៅក្នុងអាជីវកម្មមួយ ដែលក្រុមវិទ្យាសាស្រ្តទិន្នន័យបានបណ្តុះបណ្តាលម៉ូដែលដែលពួកគេចង់ឱ្យអ្នកប្រើនៅក្នុងកម្មវិធីមួយ។
|
|
|
|
### ពិចារណា
|
|
|
|
មានសំណួរច្រើនដែលអ្នកត្រូវសួរ៖
|
|
|
|
- **វាជាកម្មវិធីវេបសាយឬកម្មវិធីចល័ត?** ប្រសិនបើអ្នកកំពុងបង្កើតកម្មវិធីចល័ត ឬត្រូវប្រើម៉ូដែលក្នុងបរិបទ IoT អ្នកអាចប្រើ [TensorFlow Lite](https://www.tensorflow.org/lite/) ហើយប្រើម៉ូដែលក្នុងកម្មវិធី Android ឬ iOS ។
|
|
- **ម៉ូដែលនឹងផ្ទុកនៅកន្លែងណា?** នៅក្នុងពពកឬក្នុងមូលដ្ឋានក្នុងតំបន់ ?
|
|
- **គាំទ្របច្ចេកវិទ្យាឯកតា។** តើកម្មវិធីត្រូវដំណើរការបន្តរពេលអត់ចូលបណ្ដាញរឺទេ?
|
|
- **បច្ចេកវិទ្យាអ្វីដែលបានប្រើបណ្តុះបណ្តាលម៉ូដែល?** បច្ចេកវិទ្យាត្រូវបានជ្រើសអាចមានឥទ្ធិពលលើឧបករណ៍ដែលអ្នកត្រូវប្រើ។
|
|
- **ប្រើ TensorFlow។** ប្រសិនបើអ្នកកំពុងបណ្តុះបណ្តាលម៉ូដែលដោយប្រើ TensorFlow ជាឧទាហរណ៍ អេកូសុីស្តែមនោះផ្តល់ជូនសមត្ថភាពបម្លែងម៉ូដែល TensorFlow សម្រាប់ប្រើនៅក្នុងកម្មវិធីវេបដោយប្រើ [TensorFlow.js](https://www.tensorflow.org/js/)។
|
|
- **ប្រើ PyTorch។** ប្រសិនបើអ្នកកំពុងបង្កើតម៉ូដែលដោយប្រើបណ្ណាល័យដូចជា [PyTorch](https://pytorch.org/), អ្នកអាចនាំចេញវាទៅទ្រង់ទ្រាយ [ONNX](https://onnx.ai/) (Open Neural Network Exchange) សម្រាប់ប្រើនៅក្នុងកម្មវិធីវេប JavaScript ដែលអាចប្រើ [Onnx Runtime](https://www.onnxruntime.ai/)បាន។ ជម្រើសនេះនឹងត្រូវស្វែងរកនៅមេរៀនខាងមុខសម្រាប់ម៉ូដែលបណ្តុះបណ្តាលដោយ Scikit-learn។
|
|
- **ប្រើ Lobe.ai ឬ Azure Custom Vision។** ប្រសិនបើអ្នកកំពុងប្រើប្រព័ន្ធ ML SaaS (Software as a Service) ដូចជា [Lobe.ai](https://lobe.ai/) ឬ [Azure Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77952-leestott) ដើម្បីបណ្តុះបណ្តាលម៉ូដែល ប្រព័ន្ធនេះផ្តល់វិធីសាស្រ្តនាំចេញម៉ូដែលសម្រាប់វេទិកាច្រើន រួមមានការបង្កើត API ផ្ទាល់ខ្លួនសម្រាប់ស្វែងរកក្នុងពពកដោយកម្មវិធីអនឡាញរបស់អ្នក។
|
|
|
|
អ្នកក៏មានឱកាសបង្កើតកម្មវិធីវេប Flask ពេញលេញមួយដែលអាចបណ្តុះបណ្តាលម៉ូដែលដោយផ្ទាល់ក្នុងកម្មវិធីរុករកវេបផងដែរ។ នេះក៏អាចធ្វើបានដោយប្រើ TensorFlow.js នៅក្នុងបរិបទ JavaScript។
|
|
|
|
សម្រាប់គោលបំណងរបស់យើង ដោយសារយើងបានធ្វើការងារជាមួយកំណត់ត្រាគោលបំណង Python, យើងនឹងស្វែងយល់ពីជំហានដែលត្រូវធ្វើ ដើម្បីនាំចេញម៉ូដែលដែលបានបណ្តុះបណ្តាលពីកំណត់ត្រា ចេញទៅទ្រង់ទ្រាយដែលអាចអានបានដោយកម្មវិធីវេបដែលបានស្តាប់ដោយ Python។
|
|
|
|
## ឧបករណ៍
|
|
|
|
សម្រាប់ភារកិច្ចនេះ អ្នកត្រូវការឧបករណ៍ពីរគឺ Flask និង Pickle ដែលទាំងពីររត់លើ Python។
|
|
|
|
✅ Flask គឺជាអ្វី? និយាយថា 'micro-framework' ដោយអ្នកបង្កើតវា, Flask ផ្តល់លក្ខណៈមូលដ្ឋាននៃ framework សម្រាប់វេបដោយប្រើ Python និងម៉ាស៊ីនផ្សំទំព័រដើម្បីបង្កើតទំព័រវេប។ សូមមើល [មូឌុលរៀននេះ](https://docs.microsoft.com/learn/modules/python-flask-build-ai-web-app?WT.mc_id=academic-77952-leestott) ដើម្បីហ្វឹកហាត់ការបង្កើតជាមួយ Flask។
|
|
|
|
✅ Pickle គឺជាអ្វី? Pickle 🥒 គឺជាម៉ូឌុល Python មួយសម្រាប់សេរៀលកម្ម និងបង្វិលសេរៀលកម្មរចនាសម្ព័ន្ធ objects Python។ ពេលដែលអ្នក 'pickle' ម៉ូដែល អ្នកកំពុងសេរៀលកម្ម ឬប្លាតម៉ូដែលនេះសម្រាប់ប្រើនៅលើវេប។ សូមប្រយ័ត្ន៖ pickle មិនមានសុវត្ថិភាពផ្ទាល់ខ្លួនទេ ដូច្នេះសូមប្រយ័ត្ន ពេលដែលត្រូវ unzip ឬ 'un-pickle' ឯកសារ។ ឯកសារ pickle មានគោលបំណង .pkl។
|
|
|
|
## លំហាត់ - សម្អាតទិន្នន័យរបស់អ្នក
|
|
|
|
នៅក្នុងមេរៀននេះ អ្នកនឹងប្រើទិន្នន័យពីការមើលឃើញ UFO ជាង 80,000 ដង ដែលបានប្រមូលឡើងដោយ [NUFORC](https://nuforc.org) (មជ្ឈមណ្ឌលរាយការណ៍ UFO ជាតិ)។ ទិន្នន័យនេះមានការពិពណ៌នាផ្សេងៗអំពីការមើល UFO ដូចជា៖
|
|
|
|
- **ការពិពណ៌នាឧទាហរណ៍វែង។** "បុរសម្នាក់ឡើងពីកាំរស្មីភ្លឺមួយដែលភ្លឺលើដីឡង់ម៉ាស ស្រែព្រៃនៅយប់ ហើយគាត់រត់ទៅកាន់សួនចត់យានយន្ត Texas Instruments"។
|
|
- **ការពិពណ៌នាឧទាហរណ៍ខ្លី។** "ពន្លឺបានវិលតាមយើង"។
|
|
|
|
តារាង [ufos.csv](../../../../3-Web-App/1-Web-App/data/ufos.csv) មានជួរឈរអំពី `city`, `state` និង `country` ដែលបានឃើញ, រូបរាងនៃវត្ថុ `shape` និង `latitude` និង `longitude` របស់វា។
|
|
|
|
នៅកំណត់ត្រាតែមួយ [notebook](notebook.ipynb) ដែលរួមបញ្ចូលក្នុងមេរៀននេះ៖
|
|
|
|
1. នាំចូល `pandas`, `matplotlib`, និង `numpy` ដូចជាបានធ្វើនៅមេរៀនកន្លងមក ហើយនាំចូលតារាង ufos។ អ្នកអាចមើលគំរូទិន្នន័យមួយ៖
|
|
|
|
```python
|
|
import pandas as pd
|
|
import numpy as np
|
|
|
|
ufos = pd.read_csv('./data/ufos.csv')
|
|
ufos.head()
|
|
```
|
|
|
|
1. បម្លែងទិន្នន័យ ufos ទៅកាន់ dataframe តូចមួយដោយមានចំណងជើងថ្មី។ ពិនិត្យតម្លៃដាច់ខាតនៅក្នុងវាល `Country` ។
|
|
|
|
```python
|
|
ufos = pd.DataFrame({'Seconds': ufos['duration (seconds)'], 'Country': ufos['country'],'Latitude': ufos['latitude'],'Longitude': ufos['longitude']})
|
|
|
|
ufos.Country.unique()
|
|
```
|
|
|
|
1. ឥឡូវនេះ អ្នកអាចកាត់បន្ថយទិន្នន័យដែលត្រូវដោះស្រាយ ដោយបោះបង់តម្លៃ null និងនាំចូលតែចំនួនវេលាដែលមានរវាង 1-60 វិនាទីតែប៉ុណ្ណោះ៖
|
|
|
|
```python
|
|
ufos.dropna(inplace=True)
|
|
|
|
ufos = ufos[(ufos['Seconds'] >= 1) & (ufos['Seconds'] <= 60)]
|
|
|
|
ufos.info()
|
|
```
|
|
|
|
1. នាំចូលបណ្ណាល័យ `LabelEncoder` របស់ Scikit-learn ដើម្បីបម្លែងតម្លៃអក្សររបស់ប្រទេសទៅជាលេខ៖
|
|
|
|
✅ LabelEncoder គឺ encode ទិន្នន័យតាមលំដាប់អក្ខរាវិរុទ្ធ។
|
|
|
|
```python
|
|
from sklearn.preprocessing import LabelEncoder
|
|
|
|
ufos['Country'] = LabelEncoder().fit_transform(ufos['Country'])
|
|
|
|
ufos.head()
|
|
```
|
|
|
|
ទិន្នន័យរបស់អ្នកគួរតែបង្ហាញដូចខាងក្រោម៖
|
|
|
|
```output
|
|
Seconds Country Latitude Longitude
|
|
2 20.0 3 53.200000 -2.916667
|
|
3 20.0 4 28.978333 -96.645833
|
|
14 30.0 4 35.823889 -80.253611
|
|
23 60.0 4 45.582778 -122.352222
|
|
24 3.0 3 51.783333 -0.783333
|
|
```
|
|
|
|
## លំហាត់ - បង្កើតម៉ូដែលរបស់អ្នក
|
|
|
|
ឥឡូវនេះ អ្នកអាចត្រៀមខ្លួនបណ្តុះបណ្តាលម៉ូដែល ដោយបំបែកទិន្នន័យជាក្រុមបណ្តុះបណ្តាល និងក្រុមសាកល្បង។
|
|
|
|
1. ជ្រើសរើសលក្ខណៈបីដែលអ្នកចង់បណ្តុះជាតម្លៃ X ហើយតម្លៃ y ដូចជា `Country`។ អ្នកចង់អាចបញ្ចូល `Seconds`, `Latitude` និង `Longitude` ហើយទទួលបានលេខសម្គាល់ប្រទេសវិញ។
|
|
|
|
```python
|
|
from sklearn.model_selection import train_test_split
|
|
|
|
Selected_features = ['Seconds','Latitude','Longitude']
|
|
|
|
X = ufos[Selected_features]
|
|
y = ufos['Country']
|
|
|
|
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
|
|
```
|
|
|
|
1. បណ្តុះបណ្តាលម៉ូដែលរបស់អ្នកដោយប្រើ logistic regression៖
|
|
|
|
```python
|
|
from sklearn.metrics import accuracy_score, classification_report
|
|
from sklearn.linear_model import LogisticRegression
|
|
model = LogisticRegression()
|
|
model.fit(X_train, y_train)
|
|
predictions = model.predict(X_test)
|
|
|
|
print(classification_report(y_test, predictions))
|
|
print('Predicted labels: ', predictions)
|
|
print('Accuracy: ', accuracy_score(y_test, predictions))
|
|
```
|
|
|
|
ភាពត្រឹមត្រូវមិនអាក្រក់ទេ **(ប្រហែល 95%)** អ្វីដែលគ្មានភាពភ្ញាក់ផ្អើល សម្រាប់ `Country` និង `Latitude/Longitude` មានសមាមាត្រចំរូង។
|
|
|
|
ម៉ូដែលដែលអ្នកបានបង្កើតមិនមែនជាថ្មីគ្រប់ແលកទេ ព្រោះអ្នកអាចអង្កេតឃើញប្រទេសពី `Latitude` និង `Longitude` ប៉ុណ្ណោះ តែវាជាលំហាត់ល្អក្នុងការបណ្តុះបណ្តាលពីទិន្នន័យដើមដែលអ្នកបានសម្អាតនិងនាំចេញ ហើយបន្ទាប់មកប្រើម៉ូដែលនេះជាកម្មវិធីវេបសាយ។
|
|
|
|
## លំហាត់ - 'pickle' ម៉ូដែលរបស់អ្នក
|
|
|
|
ឥឡូវនេះ គឺពេលវេលា _pickle_ ម៉ូដែលរបស់អ្នក! អ្នកអាចធ្វើវា នៅក្នុងបន្ទាត់កូដប៉ុន្មានខ្សែ។ បន្ទាប់ពីវា _pickle_ រួច អ្នកអាចផ្ទុកម៉ូដែល pickle និងសាកល្បងវាជាមួយអារេ ឧទាហរណ៍មានតម្លៃ seconds, latitude និង longitude។
|
|
|
|
```python
|
|
import pickle
|
|
model_filename = 'ufo-model.pkl'
|
|
pickle.dump(model, open(model_filename,'wb'))
|
|
|
|
model = pickle.load(open('ufo-model.pkl','rb'))
|
|
print(model.predict([[50,44,-12]]))
|
|
```
|
|
|
|
ម៉ូដែលត្រឡប់តម្លៃ **'3'** ដែលជាកូដប្រទេសសហរាជអង់គ្លេស។ ពិភពក្រៅ! 👽
|
|
|
|
## លំហាត់ - បង្កើតកម្មវិធី Flask
|
|
|
|
ឥឡូវនេះ អ្នកអាចបង្កើតកម្មវិធី Flask ដើម្បីហៅម៉ូដែលរបស់អ្នក ហើយត្រឡប់នូវលទ្ធផលដូចគ្នា តែមានរូបរាងសម្រស់ជាងមុន។
|
|
|
|
1. ចាប់ផ្តើមដោយបង្កើតថតណាមួយមានឈ្មោះ **web-app** នៅជាប់ឯកសារ _notebook.ipynb_ ដែលឯកសារ _ufo-model.pkl_ របស់អ្នករក្សាទុក។
|
|
|
|
1. នៅក្នុងថតនោះបង្កើតថតបីទៀត៖ **static** ដែលមានថត **css** ខាងក្នុង និង **templates**។ ឥឡូវនេះ អ្នកគួរតែមានឯកសារ និងថតដូចខាងក្រោម៖
|
|
|
|
```output
|
|
web-app/
|
|
static/
|
|
css/
|
|
templates/
|
|
notebook.ipynb
|
|
ufo-model.pkl
|
|
```
|
|
|
|
✅ សូមយោងទៅថតដំណោះស្រាយសម្រាប់មើលកម្មវិធីដែលបានបញ្ចប់រួច
|
|
|
|
1. ឯកសារដ៏ដំបូងក្នុងថត _web-app_ ដែលត្រូវបង្កើតគឺ **requirements.txt**។ ដូចជា _package.json_ ក្នុងកម្មវិធី JavaScript, ឯកសារនេះរាយបញ្ជីការពឹងផ្អែកដែលកម្មវិធីត្រូវការជា dependency។ ក្នុង **requirements.txt** បញ្ចូលបន្ទាត់៖
|
|
|
|
```text
|
|
scikit-learn
|
|
pandas
|
|
numpy
|
|
flask
|
|
```
|
|
|
|
1. ឥឡូវនេះ បើកបញ្ជីរដ្ឋនៃផ្លូវ _web-app_ ហើយរត់ឯកសារនេះ៖
|
|
|
|
```bash
|
|
cd web-app
|
|
```
|
|
|
|
1. នៅក្នុង terminal របស់អ្នកវាយ `pip install` ដើម្បីដំឡើងបណ្ណាល័យដែលមាននៅក្នុងឯកសារ _requirements.txt_៖
|
|
|
|
```bash
|
|
pip install -r requirements.txt
|
|
```
|
|
|
|
1. ឥឡូវនេះ អ្នកត្រៀមបង្កើតឯកសារបីបន្ថែម ដើម្បីបញ្ចប់កម្មវិធី៖
|
|
|
|
1. បង្កើត **app.py** នៅឫសថត។
|
|
2. បង្កើត **index.html** នៅក្នុងថត _templates_។
|
|
3. បង្កើត **styles.css** នៅក្នុងថត _static/css_។
|
|
|
|
1. កសាងឯកសារ _styles.css_ ជាមួយរចនាប័ទ្មមួយចំនួន៖
|
|
|
|
```css
|
|
body {
|
|
width: 100%;
|
|
height: 100%;
|
|
font-family: 'Helvetica';
|
|
background: black;
|
|
color: #fff;
|
|
text-align: center;
|
|
letter-spacing: 1.4px;
|
|
font-size: 30px;
|
|
}
|
|
|
|
input {
|
|
min-width: 150px;
|
|
}
|
|
|
|
.grid {
|
|
width: 300px;
|
|
border: 1px solid #2d2d2d;
|
|
display: grid;
|
|
justify-content: center;
|
|
margin: 20px auto;
|
|
}
|
|
|
|
.box {
|
|
color: #fff;
|
|
background: #2d2d2d;
|
|
padding: 12px;
|
|
display: inline-block;
|
|
}
|
|
```
|
|
|
|
1. បន្ទាប់មក សរសេរឯកសារ _index.html_៖
|
|
|
|
```html
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<meta charset="UTF-8">
|
|
<title>🛸 UFO Appearance Prediction! 👽</title>
|
|
<link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
|
|
</head>
|
|
|
|
<body>
|
|
<div class="grid">
|
|
|
|
<div class="box">
|
|
|
|
<p>According to the number of seconds, latitude and longitude, which country is likely to have reported seeing a UFO?</p>
|
|
|
|
<form action="{{ url_for('predict')}}" method="post">
|
|
<input type="number" name="seconds" placeholder="Seconds" required="required" min="0" max="60" />
|
|
<input type="text" name="latitude" placeholder="Latitude" required="required" />
|
|
<input type="text" name="longitude" placeholder="Longitude" required="required" />
|
|
<button type="submit" class="btn">Predict country where the UFO is seen</button>
|
|
</form>
|
|
|
|
<p>{{ prediction_text }}</p>
|
|
|
|
</div>
|
|
|
|
</div>
|
|
|
|
</body>
|
|
</html>
|
|
```
|
|
|
|
សូមមើលការផ្សំរូបតំបន់ (templating) នៅក្នុងឯកសារនេះ។ សម្គាល់ថាសំណុំបែបបទ 'mustache' ជាគន្ធដៅជុំវិញអថេរ លទ្ធផលនៅពេលកម្មវិធីផ្តល់ឱ្យ ដូចជា អត្ថបទព្យាករណ៍៖ `{{}}`។ មានបែបបទមួយដែលផ្ញើព្យាករណ៍ទៅផ្លូវ `/predict` ទៀតផង។
|
|
|
|
ចុងក្រោយ អ្នកត្រៀមប្រើឯកសារ python ដែលដឹកនាំការប្រើម៉ូដែល និងបង្ហាញលទ្ធផលព្យាករណ៍៖
|
|
|
|
1. នៅក្នុង `app.py` បន្ថែម៖
|
|
|
|
```python
|
|
import numpy as np
|
|
from flask import Flask, request, render_template
|
|
import pickle
|
|
|
|
app = Flask(__name__)
|
|
|
|
model = pickle.load(open("./ufo-model.pkl", "rb"))
|
|
|
|
|
|
@app.route("/")
|
|
def home():
|
|
return render_template("index.html")
|
|
|
|
|
|
@app.route("/predict", methods=["POST"])
|
|
def predict():
|
|
|
|
int_features = [int(x) for x in request.form.values()]
|
|
final_features = [np.array(int_features)]
|
|
prediction = model.predict(final_features)
|
|
|
|
output = prediction[0]
|
|
|
|
countries = ["Australia", "Canada", "Germany", "UK", "US"]
|
|
|
|
return render_template(
|
|
"index.html", prediction_text="Likely country: {}".format(countries[output])
|
|
)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
app.run(debug=True)
|
|
```
|
|
|
|
> 💡 គន្លឹះ៖ ពេលអ្នកបន្ថែម [`debug=True`](https://www.askpython.com/python-modules/flask/flask-debug-mode) ពេលរត់កម្មវិធីវេបដោយប្រើ Flask, ការផ្លាស់ប្តូរណាមួយប្រតិបត្ដិបន្ទាន់នឹងត្រូវបង្ហាញភ្លាមៗ ដោយមិនចាំបាច់ចាប់ផ្ដើមម៉ាស៊ីនមួយទៀត។ តែបញ្ហាជាលក្ខណៈ៖ កុំបើកមុខងារនេះនៅក្នុងកម្មវិធីផលិតកម្ម។
|
|
|
|
បើអ្នករត់ `python app.py` ឬ `python3 app.py` ម៉ាស៊ីនបម្រើវេបរបស់អ្នកនឹងចាប់ផ្ដើមក្នុងបរិបទក្នុងស្រុក ហើយអ្នកអាចបំពេញសំណុំបែបបទខ្លីមួយ ដើម្បីទទួលបានចម្លើយចំពោះសំណួររបស់អ្នកអំពីទីតាំងដែលបានមើលឃើញ UFO!
|
|
|
|
មុនធ្វើហ្នឹង សូមមើលផ្នែកនៃ `app.py`៖
|
|
|
|
1. ជាដំបូង dependencies ត្រូវបានទាញយក ហើយកម្មវិធីចាប់ផ្ដើម។
|
|
1. បន្ទាប់ម៉ូដែលត្រូវបាននាំចូល។
|
|
1. បន្ទាប់មក index.html ត្រូវបានបង្ហាញនៅផ្លូវមុខ។
|
|
|
|
នៅផ្លូវ `/predict`, មានរឿងជាច្រើនកើតឡើងនៅពេលសំណុំបែបបទត្រូវបានបញ្ចូន៖
|
|
|
|
1. អថេរនៃសំណុំបែបបទ ត្រូវបានប្រមួល និងបម្លែងទៅជា numpy array។ បន្ទាប់មកវាត្រូវបានផ្ញើទៅម៉ូដែល ហើយលទ្ធផលព្យាករណ៍ត្រូវបានទទួល។
|
|
2. ប្រទេសដែលយើងចង់បង្ហាញ ត្រូវបានបម្លែងឡើងវិញជាអត្ថបទដែលអាចអានបាន ពីកូដប្រទេសដែលបានព្យាករណ៍ ហើយតម្លៃនោះត្រូវបានផ្ញើត្រឡប់ទៅ index.html សម្រាប់បង្ហាញក្នុងគំរូ។
|
|
|
|
ការប្រើម៉ូដែលបែបនេះ ដោយប្រើ Flask និងម៉ូដែលដែលបាន pickle គឺសាមញ្ញ។ រឿងលំបាកបំផុតគឺយល់ថាទិន្នន័យមាននៅក្នុងរបៀបណា ដែលត្រូវផ្ញើទៅម៉ូដែលដើម្បីទទួលបានព្យាករណ៍។ រឿងនេះទាំងអស់ תלויនឹងរបៀបដែលម៉ូដែលត្រូវបានបណ្តុះបណ្តាល។ ម៉ូដែលនេះមានចំណុចទិន្នន័យបី ដែលត្រូវបញ្ចូលដើម្បីទទួលបានព្យាករណ៍។
|
|
|
|
នៅក្នុងបរិបទមុខរបរ អ្នកអាចមើលឃើញថាការទំនាក់ទំនងល្អគឺទាមទារជាចាំបាច់រវាងមនុស្សដែលបណ្តុះបណ្តាលម៉ូដែល និងអ្នកប្រើវាសម្រាប់កម្មវិធីវេប ឬចល័ត។ ក្នុងករណីយើង គឺមនុស្សម្នាក់គត់ គឺអ្នក!
|
|
|
|
---
|
|
|
|
## 🚀 ការប្រកួតប្រជែង
|
|
|
|
ជំនួសការងារនៅក្នុងកំណត់ត្រា និងនាំចូលម៉ូដែលទៅកម្មវិធី Flask អ្នកអាចបណ្តុះបណ្តាលម៉ូដែលនៅក្នុងកម្មវិធី Flask យ៉ាងត្រង់! ព្យាយាមបម្លែងកូដ Python របស់អ្នកក្នុងកំណត់ត្រា ប្រហែលបន្ទាប់ពីទិន្នន័យរបស់អ្នកបានសម្អាត ហើយបណ្តុះម៉ូដែលពីក្នុងកម្មវិធីលើផ្លូវដែលហៅថា `train` ។ មានគុណសម្បត្តិ និងគុណវិបត្តិអ្វីខ្លះក្នុងការធ្វើវិធាននេះ?
|
|
|
|
## [សំណួរបន្ទាប់មកមេរៀន](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
## ការត្រួតពិនិត្យ និងសិក្សាដោយខ្លួនឯង
|
|
|
|
មានវិធីជាច្រើនក្នុងការបង្កើតកម្មវិធីវេបសម្រាប់ប្រើម៉ូដែល ML។ សូមរាយបញ្ជីវិធីដែលអ្នកអាចប្រើ JavaScript ឬ Python ដើម្បីបង្កើតកម្មវិធីវេបសម្រាប់យកអត្ថប្រយោជន៍ពីម៉ាស៊ីនរៀន។ ពិចារណាស្ថាបត្យកម្ម៖ តើម៉ូដែលគួរចាំនៅក្នុងកម្មវិធី ឬនៅក្នុងពពក? ប្រសិនបើគឺនៅក្នុងពពក អ្នកត្រូវចូលដំណើរការយ៉ាងដូចម្តេច? គូររូបមន្តស្ថាបត្យកម្មសម្រាប់ដំណោះស្រាយ ML វេបសម្រាប់អនុវត្តន៍។
|
|
|
|
## មេរៀនបន្ថែម
|
|
|
|
[សាកល្បងម៉ូដែលផ្សេង](assignment.md)
|
|
|
|
---
|
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
|
**ការបដិសេធ**៖
|
|
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator) ។ ទោះយើងខ្ញុំខិតខំផ្តល់ភាពត្រឹមត្រូវក៏ដោយ សូមយកចិត្តទុកដាក់ថា ការបកប្រែដោយស្វ័យប្រវត្តិអាចមានកំហុសឬភាពខុសត្រូវ។ ឯកសារដើមនៅក្នុងភាសាជាតិ ជាការត្រូវបានគេពិចារណាថាជាផ្លាកលក្ខណៈសម្បត្តិ។ សម្រាប់ព័ត៌មានសំខាន់ៗ គួរប្រើការបកប្រែមនុស្សជំនាញវិជ្ជាជីវៈ។ យើងខ្ញុំមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកប្រែខុសៗផ្សេងៗដែលកើតឡើងពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |