# បង្កើតកម្មវិធីវេបសាយដើម្បីប្រើម៉ូដែល 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 -->