ML-For-Beginners/translations/km/3-Web-App/1-Web-App

បង្កើតកម្មវិធីវេបសាយដើម្បីប្រើម៉ូដែល ML

នៅក្នុងមេរៀននេះ អ្នកនឹងបណ្តុះបណ្តាលម៉ូដែល MLលើទិន្នន័យមួយដែលមកពីពិភពលោកខាងក្រៅ៖ ការមើលឃើញ UFO លើរយៈពេលមួយសតវត្សที่ผ่านมา ដែលបានយកពីមូលដ្ឋានទិន្នន័យ NUFORC។

អ្នកនឹងរៀន៖

• របៀប 'pickle' ម៉ូដែលបានបណ្តុះបណ្តាល
• របៀបប្រើម៉ូដែលនោះក្នុងកម្មវិធី Flask

យើងនឹងបន្ដប្រើកំណត់ត្រាដើម្បីសម្អាតទិន្នន័យ និងបណ្តុះបណ្តាលម៉ូដែលរបស់យើង ប៉ុន្តែអ្នកអាចយកដំណើរការនេះទៅជំហានបន្ថែម ដោយស្វែងយល់ពីរបៀបប្រើម៉ូដែល 'នៅតាមធម្មជាតិ' និយាយម្នាដូចជា នៅក្នុងកម្មវិធីវេបសាយ។

ដើម្បីធ្វើនេះ អ្នកត្រូវបង្កើតកម្មវិធីវេបសាយដោយប្រើ Flask។

សំណួរមុនមេរៀន

ការបង្កើតកម្មវិធី

មានវិធីជាច្រើនក្នុងការបង្កើតកម្មវិធីវេបសាយសម្រាប់ប្រើម៉ូដែលម៉ាស៊ីនរៀន។ វិធានាស្ថាបត្យកម្មវេបសាយរបស់អ្នកអាចមានឥទ្ធិពលលើរបៀបដែលម៉ូដែលរបស់អ្នកត្រូវបានបណ្តុះបណ្តាល។ សូមនិយាយថាអ្នកកំពុងធ្វើការនៅក្នុងអាជីវកម្មមួយ ដែលក្រុមវិទ្យាសាស្រ្តទិន្នន័យបានបណ្តុះបណ្តាលម៉ូដែលដែលពួកគេចង់ឱ្យអ្នកប្រើនៅក្នុងកម្មវិធីមួយ។

ពិចារណា

មានសំណួរច្រើនដែលអ្នកត្រូវសួរ៖

• វាជាកម្មវិធីវេបសាយឬកម្មវិធីចល័ត? ប្រសិនបើអ្នកកំពុងបង្កើតកម្មវិធីចល័ត ឬត្រូវប្រើម៉ូដែលក្នុងបរិបទ IoT អ្នកអាចប្រើ TensorFlow Lite ហើយប្រើម៉ូដែលក្នុងកម្មវិធី Android ឬ iOS ។
• ម៉ូដែលនឹងផ្ទុកនៅកន្លែងណា? នៅក្នុងពពកឬក្នុងមូលដ្ឋានក្នុងតំបន់ ?
• គាំទ្របច្ចេកវិទ្យាឯកតា។ តើកម្មវិធីត្រូវដំណើរការបន្តរពេលអត់ចូលបណ្ដាញរឺទេ?
• បច្ចេកវិទ្យាអ្វីដែលបានប្រើបណ្តុះបណ្តាលម៉ូដែល? បច្ចេកវិទ្យាត្រូវបានជ្រើសអាចមានឥទ្ធិពលលើឧបករណ៍ដែលអ្នកត្រូវប្រើ។
  • ប្រើ TensorFlow។ ប្រសិនបើអ្នកកំពុងបណ្តុះបណ្តាលម៉ូដែលដោយប្រើ TensorFlow ជាឧទាហរណ៍ អេកូសុីស្តែមនោះផ្តល់ជូនសមត្ថភាពបម្លែងម៉ូដែល TensorFlow សម្រាប់ប្រើនៅក្នុងកម្មវិធីវេបដោយប្រើ TensorFlow.js។
  • ប្រើ PyTorch។ ប្រសិនបើអ្នកកំពុងបង្កើតម៉ូដែលដោយប្រើបណ្ណាល័យដូចជា PyTorch, អ្នកអាចនាំចេញវាទៅទ្រង់ទ្រាយ ONNX (Open Neural Network Exchange) សម្រាប់ប្រើនៅក្នុងកម្មវិធីវេប JavaScript ដែលអាចប្រើ Onnx Runtimeបាន។ ជម្រើសនេះនឹងត្រូវស្វែងរកនៅមេរៀនខាងមុខសម្រាប់ម៉ូដែលបណ្តុះបណ្តាលដោយ Scikit-learn។
  • ប្រើ Lobe.ai ឬ Azure Custom Vision។ ប្រសិនបើអ្នកកំពុងប្រើប្រព័ន្ធ ML SaaS (Software as a Service) ដូចជា Lobe.ai ឬ Azure Custom Vision ដើម្បីបណ្តុះបណ្តាលម៉ូដែល ប្រព័ន្ធនេះផ្តល់វិធីសាស្រ្តនាំចេញម៉ូដែលសម្រាប់វេទិកាច្រើន រួមមានការបង្កើត API ផ្ទាល់ខ្លួនសម្រាប់ស្វែងរកក្នុងពពកដោយកម្មវិធីអនឡាញរបស់អ្នក។

អ្នកក៏មានឱកាសបង្កើតកម្មវិធីវេប Flask ពេញលេញមួយដែលអាចបណ្តុះបណ្តាលម៉ូដែលដោយផ្ទាល់ក្នុងកម្មវិធីរុករកវេបផងដែរ។ នេះក៏អាចធ្វើបានដោយប្រើ TensorFlow.js នៅក្នុងបរិបទ JavaScript។

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

ឧបករណ៍

សម្រាប់ភារកិច្ចនេះ អ្នកត្រូវការឧបករណ៍ពីរគឺ Flask និង Pickle ដែលទាំងពីររត់លើ Python។

✅ Flask គឺជាអ្វី? និយាយថា 'micro-framework' ដោយអ្នកបង្កើតវា, Flask ផ្តល់លក្ខណៈមូលដ្ឋាននៃ framework សម្រាប់វេបដោយប្រើ Python និងម៉ាស៊ីនផ្សំទំព័រដើម្បីបង្កើតទំព័រវេប។ សូមមើល មូឌុលរៀននេះ ដើម្បីហ្វឹកហាត់ការបង្កើតជាមួយ Flask។

✅ Pickle គឺជាអ្វី? Pickle 🥒 គឺជាម៉ូឌុល Python មួយសម្រាប់សេរៀលកម្ម និងបង្វិលសេរៀលកម្មរចនាសម្ព័ន្ធ objects Python។ ពេលដែលអ្នក 'pickle' ម៉ូដែល អ្នកកំពុងសេរៀលកម្ម ឬប្លាតម៉ូដែលនេះសម្រាប់ប្រើនៅលើវេប។ សូមប្រយ័ត្ន៖ pickle មិនមានសុវត្ថិភាពផ្ទាល់ខ្លួនទេ ដូច្នេះសូមប្រយ័ត្ន ពេលដែលត្រូវ unzip ឬ 'un-pickle' ឯកសារ។ ឯកសារ pickle មានគោលបំណង .pkl។

លំហាត់ - សម្អាតទិន្នន័យរបស់អ្នក

នៅក្នុងមេរៀននេះ អ្នកនឹងប្រើទិន្នន័យពីការមើលឃើញ UFO ជាង 80,000 ដង ដែលបានប្រមូលឡើងដោយ NUFORC (មជ្ឈមណ្ឌលរាយការណ៍ UFO ជាតិ)។ ទិន្នន័យនេះមានការពិពណ៌នាផ្សេងៗអំពីការមើល UFO ដូចជា៖

• ការពិពណ៌នាឧទាហរណ៍វែង។ "បុរសម្នាក់ឡើងពីកាំរស្មីភ្លឺមួយដែលភ្លឺលើដីឡង់ម៉ាស ស្រែព្រៃនៅយប់ ហើយគាត់រត់ទៅកាន់សួនចត់យានយន្ត Texas Instruments"។
• ការពិពណ៌នាឧទាហរណ៍ខ្លី។ "ពន្លឺបានវិលតាមយើង"។

តារាង ufos.csv មានជួរឈរអំពី city, state និង country ដែលបានឃើញ, រូបរាងនៃវត្ថុ shape និង latitude និង longitude របស់វា។

នៅកំណត់ត្រាតែមួយ notebook ដែលរួមបញ្ចូលក្នុងមេរៀននេះ៖

1. នាំចូល pandas, matplotlib, និង numpy ដូចជា​បានធ្វើនៅមេរៀនកន្លងមក ហើយនាំចូលតារាង ufos។ អ្នកអាចមើលគំរូទិន្នន័យមួយ៖

   import pandas as pd
   import numpy as np
   
   ufos = pd.read_csv('./data/ufos.csv')
   ufos.head()
   

2. បម្លែងទិន្នន័យ ufos ទៅកាន់ dataframe តូចមួយដោយមានចំណងជើងថ្មី។ ពិនិត្យតម្លៃដាច់ខាតនៅក្នុងវាល Country ។

   ufos = pd.DataFrame({'Seconds': ufos['duration (seconds)'], 'Country': ufos['country'],'Latitude': ufos['latitude'],'Longitude': ufos['longitude']})
   
   ufos.Country.unique()
   

3. ឥឡូវនេះ អ្នកអាចកាត់បន្ថយទិន្នន័យដែលត្រូវដោះស្រាយ ដោយបោះបង់តម្លៃ null និងនាំចូលតែចំនួនវេលាដែលមានរវាង 1-60 វិនាទីតែប៉ុណ្ណោះ៖

   ufos.dropna(inplace=True)
   
   ufos = ufos[(ufos['Seconds'] >= 1) & (ufos['Seconds'] <= 60)]
   
   ufos.info()
   

4. នាំចូលបណ្ណាល័យ LabelEncoder របស់ Scikit-learn ដើម្បីបម្លែងតម្លៃអក្សររបស់ប្រទេសទៅជាលេខ៖

   ✅ LabelEncoder គឺ encode ទិន្នន័យតាមលំដាប់អក្ខរាវិរុទ្ធ។

   from sklearn.preprocessing import LabelEncoder
   
   ufos['Country'] = LabelEncoder().fit_transform(ufos['Country'])
   
   ufos.head()
   

   ទិន្នន័យរបស់អ្នកគួរតែបង្ហាញដូចខាងក្រោម៖

   	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 ហើយទទួលបានលេខសម្គាល់ប្រទេសវិញ។

   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)
   

2. បណ្តុះបណ្តាលម៉ូដែលរបស់អ្នកដោយប្រើ logistic regression៖

   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។

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 របស់អ្នករក្សាទុក។

2. នៅក្នុងថតនោះបង្កើតថតបីទៀត៖ static ដែលមានថត css ខាងក្នុង និង templates។ ឥឡូវនេះ អ្នកគួរតែមានឯកសារ និងថតដូចខាងក្រោម៖

   web-app/
     static/
       css/
     templates/
   notebook.ipynb
   ufo-model.pkl
   

   ✅ សូមយោងទៅថតដំណោះស្រាយសម្រាប់មើលកម្មវិធីដែលបានបញ្ចប់រួច

3. ឯកសារដ៏ដំបូងក្នុងថត web-app ដែលត្រូវបង្កើតគឺ requirements.txt។ ដូចជា package.json ក្នុងកម្មវិធី JavaScript, ឯកសារនេះរាយបញ្ជីការពឹងផ្អែកដែលកម្មវិធីត្រូវការជា dependency។ ក្នុង requirements.txt បញ្ចូលបន្ទាត់៖

   scikit-learn
   pandas
   numpy
   flask
   

4. ឥឡូវនេះ បើកបញ្ជីរដ្ឋនៃផ្លូវ web-app ហើយរត់ឯកសារនេះ៖

   cd web-app
   

5. នៅក្នុង terminal របស់អ្នកវាយ pip install ដើម្បីដំឡើងបណ្ណាល័យដែលមាននៅក្នុងឯកសារ requirements.txt៖

   pip install -r requirements.txt
   

6. ឥឡូវនេះ អ្នកត្រៀមបង្កើតឯកសារបីបន្ថែម ដើម្បីបញ្ចប់កម្មវិធី៖

   1. បង្កើត app.py នៅឫសថត។
   2. បង្កើត index.html នៅក្នុងថត templates។
   3. បង្កើត styles.css នៅក្នុងថត static/css។

7. កសាងឯកសារ styles.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;
   }
   

8. បន្ទាប់មក សរសេរ​ឯកសារ index.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 ដែលដឹកនាំការប្រើម៉ូដែល និងបង្ហាញលទ្ធផលព្យាករណ៍៖

9. នៅក្នុង app.py បន្ថែម៖

   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 ពេលរត់កម្មវិធីវេបដោយប្រើ Flask, ការផ្លាស់ប្តូរណាមួយប្រតិបត្ដិបន្ទាន់នឹងត្រូវបង្ហាញភ្លាមៗ ដោយមិនចាំបាច់ចាប់ផ្ដើមម៉ាស៊ីនមួយទៀត។ តែបញ្ហាជាលក្ខណៈ៖ កុំបើកមុខងារនេះនៅក្នុងកម្មវិធីផលិតកម្ម។

បើអ្នករត់ python app.py ឬ python3 app.py ម៉ាស៊ីនបម្រើវេបរបស់អ្នកនឹងចាប់ផ្ដើមក្នុងបរិបទក្នុងស្រុក ហើយអ្នកអាចបំពេញសំណុំបែបបទខ្លីមួយ ដើម្បីទទួលបានចម្លើយចំពោះសំណួររបស់អ្នកអំពីទីតាំងដែលបានមើលឃើញ UFO!

មុនធ្វើហ្នឹង សូមមើលផ្នែកនៃ app.py៖

1. ជាដំបូង dependencies ត្រូវបានទាញយក ហើយកម្មវិធីចាប់ផ្ដើម។
2. បន្ទាប់ម៉ូដែលត្រូវបាននាំចូល។
3. បន្ទាប់មក index.html ត្រូវបានបង្ហាញនៅផ្លូវមុខ។

នៅផ្លូវ /predict, មានរឿងជាច្រើនកើតឡើងនៅពេលសំណុំបែបបទត្រូវបានបញ្ចូន៖

1. អថេរនៃសំណុំបែបបទ ត្រូវបានប្រមួល និងបម្លែងទៅជា numpy array។ បន្ទាប់មកវាត្រូវបានផ្ញើទៅម៉ូដែល ហើយលទ្ធផលព្យាករណ៍ត្រូវបានទទួល។
2. ប្រទេសដែលយើងចង់បង្ហាញ ត្រូវបានបម្លែងឡើងវិញជាអត្ថបទដែលអាចអានបាន ពីកូដប្រទេសដែលបានព្យាករណ៍ ហើយតម្លៃនោះត្រូវបានផ្ញើត្រឡប់ទៅ index.html សម្រាប់បង្ហាញក្នុងគំរូ។

ការប្រើម៉ូដែលបែបនេះ ដោយប្រើ Flask និងម៉ូដែលដែលបាន pickle គឺសាមញ្ញ។ រឿងលំបាកបំផុតគឺយល់ថាទិន្នន័យមាននៅក្នុងរបៀបណា ដែលត្រូវផ្ញើទៅម៉ូដែលដើម្បីទទួលបានព្យាករណ៍។ រឿងនេះទាំងអស់ תלויនឹងរបៀបដែលម៉ូដែលត្រូវបានបណ្តុះបណ្តាល។ ម៉ូដែលនេះមានចំណុចទិន្នន័យបី ដែលត្រូវបញ្ចូលដើម្បីទទួលបានព្យាករណ៍។

នៅក្នុងបរិបទមុខរបរ អ្នកអាចមើលឃើញថាការទំនាក់ទំនងល្អគឺទាមទារជាចាំបាច់រវាងមនុស្សដែលបណ្តុះបណ្តាលម៉ូដែល និងអ្នកប្រើវាសម្រាប់កម្មវិធីវេប ឬចល័ត។ ក្នុងករណីយើង គឺមនុស្សម្នាក់គត់ គឺអ្នក!

---

🚀 ការប្រកួតប្រជែង

ជំនួសការងារនៅក្នុងកំណត់ត្រា និងនាំចូលម៉ូដែលទៅកម្មវិធី Flask អ្នកអាចបណ្តុះបណ្តាលម៉ូដែលនៅក្នុងកម្មវិធី Flask យ៉ាងត្រង់! ព្យាយាមបម្លែងកូដ Python របស់អ្នកក្នុងកំណត់ត្រា ប្រហែលបន្ទាប់ពីទិន្នន័យរបស់អ្នកបានសម្អាត ហើយបណ្តុះម៉ូដែលពីក្នុងកម្មវិធីលើផ្លូវដែលហៅថា train ។ មានគុណសម្បត្តិ និងគុណវិបត្តិអ្វីខ្លះក្នុងការធ្វើវិធាននេះ?

សំណួរបន្ទាប់មកមេរៀន

ការត្រួតពិនិត្យ និងសិក្សាដោយខ្លួនឯង

មានវិធីជាច្រើនក្នុងការបង្កើតកម្មវិធីវេបសម្រាប់ប្រើម៉ូដែល ML។ សូមរាយបញ្ជីវិធីដែលអ្នកអាចប្រើ JavaScript ឬ Python ដើម្បីបង្កើតកម្មវិធីវេបសម្រាប់យកអត្ថប្រយោជន៍ពីម៉ាស៊ីនរៀន។ ពិចារណាស្ថាបត្យកម្ម៖ តើម៉ូដែលគួរចាំនៅក្នុងកម្មវិធី ឬនៅក្នុងពពក? ប្រសិនបើគឺនៅក្នុងពពក អ្នកត្រូវចូលដំណើរការយ៉ាងដូចម្តេច? គូររូបមន្តស្ថាបត្យកម្មសម្រាប់ដំណោះស្រាយ ML វេបសម្រាប់អនុវត្តន៍។

មេរៀនបន្ថែម

សាកល្បងម៉ូដែលផ្សេង

---

ការបដិសេធ៖
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាកម្មបកប្រែ AI Co-op Translator ។ ទោះយើងខ្ញុំខិតខំផ្តល់ភាពត្រឹមត្រូវក៏ដោយ សូមយកចិត្តទុកដាក់ថា ការបកប្រែដោយស្វ័យប្រវត្តិអាចមានកំហុសឬភាពខុសត្រូវ។ ឯកសារដើមនៅក្នុងភាសាជាតិ ជាការត្រូវបានគេពិចារណាថាជាផ្លាកលក្ខណៈសម្បត្តិ។ សម្រាប់ព័ត៌មានសំខាន់ៗ គួរប្រើការបកប្រែមនុស្សជំនាញវិជ្ជាជីវៈ។ យើងខ្ញុំមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកប្រែខុសៗផ្សេងៗដែលកើតឡើងពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។