# ML മോഡൽ ഉപയോഗിച്ച് ഒരു വെബ് ആപ്പ് നിർമ്മിക്കുക
ഈ പാഠത്തിൽ, നിങ്ങൾ ഒരു ഡാറ്റാ സെറ്റിൽ ML മോഡൽ പരിശീലിപ്പിക്കും, അത് ഈ ലോകത്തിന് പുറത്തുള്ളതാണ്: _കഴിഞ്ഞ നൂറ്റാണ്ടിലെ UFO ദൃശ്യങ്ങൾ_, NUFORC-യുടെ ഡാറ്റാബേസിൽ നിന്നുള്ളത്.
നിങ്ങൾ പഠിക്കാനിരിക്കുന്നവ:
- പരിശീലിപ്പിച്ച മോഡൽ 'pickle' ചെയ്യുന്നത് എങ്ങനെ
- ആ മോഡൽ Flask ആപ്പിൽ എങ്ങനെ ഉപയോഗിക്കാം
ഡാറ്റ ശുദ്ധീകരണത്തിനും മോഡൽ പരിശീലനത്തിനും നോട്ട്ബുക്കുകൾ ഉപയോഗിക്കുന്നതിനെ തുടരും, പക്ഷേ നിങ്ങൾക്ക് ഒരു മോഡൽ 'വൈൽഡിൽ' ഉപയോഗിക്കുന്നതിനെക്കുറിച്ച് അന്വേഷിച്ച് ഒരു പടി മുന്നോട്ട് പോകാം: വെബ് ആപ്പിൽ.
ഇത് ചെയ്യാൻ, Flask ഉപയോഗിച്ച് ഒരു വെബ് ആപ്പ് നിർമ്മിക്കേണ്ടതാണ്.
## [പ്രീ-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
## ആപ്പ് നിർമ്മിക്കൽ
മെഷീൻ ലേണിംഗ് മോഡലുകൾ ഉപയോഗിക്കുന്ന വെബ് ആപ്പുകൾ നിർമ്മിക്കാൻ പല വഴികളുണ്ട്. നിങ്ങളുടെ വെബ് ആർക്കിടെക്ചർ മോഡൽ പരിശീലന രീതിയെ ബാധിക്കാം. ഡാറ്റ സയൻസ് ഗ്രൂപ്പ് ഒരു മോഡൽ പരിശീലിപ്പിച്ച് ആ മോഡൽ ആപ്പിൽ ഉപയോഗിക്കാൻ നിങ്ങൾക്ക് നൽകുന്ന ഒരു ബിസിനസ്സിൽ നിങ്ങൾ ജോലി ചെയ്യുന്നു എന്ന് കരുതുക.
### പരിഗണനകൾ
നിങ്ങൾ ചോദിക്കേണ്ട നിരവധി ചോദ്യങ്ങളുണ്ട്:
- **ഇത് വെബ് ആപ്പാണോ മൊബൈൽ ആപ്പാണോ?** നിങ്ങൾ മൊബൈൽ ആപ്പ് നിർമ്മിക്കുന്നുവെങ്കിൽ അല്ലെങ്കിൽ മോഡൽ IoT സാഹചര്യത്തിൽ ഉപയോഗിക്കേണ്ടതുണ്ടെങ്കിൽ, [TensorFlow Lite](https://www.tensorflow.org/lite/) ഉപയോഗിച്ച് ആൻഡ്രോയിഡ് അല്ലെങ്കിൽ iOS ആപ്പിൽ മോഡൽ ഉപയോഗിക്കാം.
- **മോഡൽ എവിടെ നിലനിൽക്കും?** ക്ലൗഡിലോ ലോക്കലിലോ?
- **ഓഫ്ലൈൻ പിന്തുണ.** ആപ്പ് ഓഫ്ലൈനിലും പ്രവർത്തിക്കേണ്ടതുണ്ടോ?
- **മോഡൽ പരിശീലിപ്പിക്കാൻ ഉപയോഗിച്ച സാങ്കേതികവിദ്യ എന്ത്?** തിരഞ്ഞെടുക്കപ്പെട്ട സാങ്കേതികവിദ്യ ഉപയോഗിക്കുന്ന ടൂളുകൾ വ്യത്യസ്തമായിരിക്കും.
- **TensorFlow ഉപയോഗിക്കുന്നത്.** ഉദാഹരണത്തിന് TensorFlow ഉപയോഗിച്ച് മോഡൽ പരിശീലിപ്പിക്കുന്നുവെങ്കിൽ, ആ ഇക്കോസിസ്റ്റം [TensorFlow.js](https://www.tensorflow.org/js/) ഉപയോഗിച്ച് വെബ് ആപ്പിൽ ഉപയോഗിക്കാൻ മോഡൽ മാറ്റാൻ കഴിയും.
- **PyTorch ഉപയോഗിക്കുന്നത്.** [PyTorch](https://pytorch.org/) പോലുള്ള ലൈബ്രറി ഉപയോഗിച്ച് മോഡൽ നിർമ്മിക്കുന്നുവെങ്കിൽ, അത് [ONNX](https://onnx.ai/) (Open Neural Network Exchange) ഫോർമാറ്റിൽ എക്സ്പോർട്ട് ചെയ്ത് ജാവാസ്ക്രിപ്റ്റ് വെബ് ആപ്പുകളിൽ ഉപയോഗിക്കാൻ [Onnx Runtime](https://www.onnxruntime.ai/) ഉപയോഗിക്കാം. ഈ ഓപ്ഷൻ Scikit-learn-ൽ പരിശീലിപ്പിച്ച മോഡലിനായി ഭാവിയിലെ പാഠത്തിൽ പരിശോധിക്കും.
- **Lobe.ai അല്ലെങ്കിൽ Azure Custom Vision ഉപയോഗിക്കുന്നത്.** [Lobe.ai](https://lobe.ai/) അല്ലെങ്കിൽ [Azure Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77952-leestott) പോലുള്ള ML SaaS (Software as a Service) സിസ്റ്റം ഉപയോഗിച്ച് മോഡൽ പരിശീലിപ്പിക്കുന്നുവെങ്കിൽ, ഈ സോഫ്റ്റ്വെയർ പല പ്ലാറ്റ്ഫോമുകൾക്കായി മോഡൽ എക്സ്പോർട്ട് ചെയ്യാനുള്ള മാർഗങ്ങൾ നൽകുന്നു, കൂടാതെ ക്ലൗഡിൽ ഓൺലൈൻ ആപ്ലിക്കേഷനിലൂടെ ചോദിക്കാവുന്ന ഒരു കസ്റ്റം API നിർമ്മിക്കാനും കഴിയും.
നിങ്ങൾക്ക് ഒരു മുഴുവൻ Flask വെബ് ആപ്പ് നിർമ്മിച്ച് ബ്രൗസറിൽ തന്നെ മോഡൽ പരിശീലിപ്പിക്കാൻ അവസരമുണ്ട്. ഇത് TensorFlow.js ഉപയോഗിച്ച് ജാവാസ്ക്രിപ്റ്റ് സാഹചര്യത്തിലും ചെയ്യാം.
നമ്മുടെ ആവശ്യങ്ങൾക്ക്, Python അടിസ്ഥാനമാക്കിയുള്ള നോട്ട്ബുക്കുകൾ ഉപയോഗിച്ചുകൊണ്ടുള്ളതിനാൽ, ഒരു പരിശീലിപ്പിച്ച മോഡൽ Python-ൽ നിർമ്മിച്ച വെബ് ആപ്പിൽ വായിക്കാൻ കഴിയുന്ന ഫോർമാറ്റിലേക്ക് എങ്ങനെ എക്സ്പോർട്ട് ചെയ്യാമെന്ന് പരിശോധിക്കാം.
## ടൂൾ
ഈ ടാസ്കിനായി നിങ്ങൾക്ക് രണ്ട് ടൂളുകൾ വേണം: Flask, Pickle, രണ്ടും Python-ൽ പ്രവർത്തിക്കുന്നു.
✅ [Flask](https://palletsprojects.com/p/flask/) എന്താണ്? അതിന്റെ സ്രഷ്ടാക്കൾ 'മൈക്രോ-ഫ്രെയിംവർക്ക്' എന്ന് നിർവചിച്ചിരിക്കുന്ന Flask, Python ഉപയോഗിച്ച് വെബ് ഫ്രെയിംവർക്ക് അടിസ്ഥാന സവിശേഷതകളും വെബ് പേജുകൾ നിർമ്മിക്കാൻ ടെംപ്ലേറ്റിംഗ് എഞ്ചിൻ നൽകുന്നു. Flask ഉപയോഗിച്ച് നിർമ്മാണം അഭ്യസിക്കാൻ [ഈ Learn മോഡ്യൂൾ](https://docs.microsoft.com/learn/modules/python-flask-build-ai-web-app?WT.mc_id=academic-77952-leestott) കാണുക.
✅ [Pickle](https://docs.python.org/3/library/pickle.html) എന്താണ്? Pickle 🥒 Python ഒബ്ജക്റ്റ് ഘടന സീരിയലൈസ് ചെയ്യാനും ഡീ-സീരിയലൈസ് ചെയ്യാനും ഉപയോഗിക്കുന്ന Python മോഡ്യൂളാണ്. മോഡൽ 'pickle' ചെയ്യുമ്പോൾ, അതിന്റെ ഘടന വെബിൽ ഉപയോഗിക്കാൻ സീരിയലൈസ് അല്ലെങ്കിൽ ഫ്ലാറ്റൻ ചെയ്യുന്നു. ശ്രദ്ധിക്കുക: pickle സ്വാഭാവികമായി സുരക്ഷിതമല്ല, അതിനാൽ ഒരു ഫയൽ 'un-pickle' ചെയ്യാൻ ആവശ്യപ്പെട്ടാൽ ജാഗ്രത പാലിക്കുക. ഒരു pickle ചെയ്ത ഫയലിന് `.pkl` എന്ന സഫിക്സ് ഉണ്ട്.
## അഭ്യാസം - നിങ്ങളുടെ ഡാറ്റ ശുദ്ധീകരിക്കുക
ഈ പാഠത്തിൽ നിങ്ങൾ 80,000 UFO ദൃശ്യങ്ങളുടെ ഡാറ്റ ഉപയോഗിക്കും, [NUFORC](https://nuforc.org) (The National UFO Reporting Center) ശേഖരിച്ചിരിക്കുന്നു. ഈ ഡാറ്റയിൽ UFO ദൃശ്യങ്ങളുടെ ചില രസകരമായ വിവരണങ്ങളുണ്ട്, ഉദാഹരണത്തിന്:
- **വലിയ ഉദാഹരണ വിവരണം.** "ഒരു മനുഷ്യൻ രാത്രി ഒരു പുല്ല് നിറഞ്ഞ മൈതാനത്തിൽ പ്രകാശിക്കുന്ന ഒരു ലൈറ്റ് ബീമിൽ നിന്ന് പുറത്തുവരുന്നു, അവൻ ടെക്സാസ് ഇൻസ്ട്രുമെന്റ്സ് പാർക്കിംഗ് ലോട്ടിലേക്ക് ഓടുന്നു".
- **ചെറിയ ഉദാഹരണ വിവരണം.** "ലൈറ്റുകൾ ഞങ്ങളെ പിന്തുടർന്നു".
[ufos.csv](../../../../3-Web-App/1-Web-App/data/ufos.csv) സ്പ്രെഡ്ഷീറ്റിൽ `city`, `state`, `country` എന്നിവയുടെ കോളങ്ങൾ ഉൾപ്പെടുന്നു, ദൃശ്യമായ വസ്തുവിന്റെ `shape` കൂടാതെ അതിന്റെ `latitude`യും `longitude`യും.
ഈ പാഠത്തിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന ശൂന്യമായ [നോട്ട്ബുക്ക്](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 ഡാറ്റ ഒരു ചെറിയ ഡാറ്റാഫ്രെയിമിലേക്ക് പുതിയ തലക്കെട്ടുകളോടെ മാറ്റുക. `Country` ഫീൽഡിലെ വ്യത്യസ്ത മൂല്യങ്ങൾ പരിശോധിക്കുക.
```python
ufos = pd.DataFrame({'Seconds': ufos['duration (seconds)'], 'Country': ufos['country'],'Latitude': ufos['latitude'],'Longitude': ufos['longitude']})
ufos.Country.unique()
```
1. ഇപ്പോൾ, നാം കൈകാര്യം ചെയ്യേണ്ട ഡാറ്റയുടെ അളവ് കുറയ്ക്കാൻ, ഏതെങ്കിലും നൾ മൂല്യങ്ങൾ ഒഴിവാക്കി 1-60 സെക്കൻഡ് ഇടയിലുള്ള ദൃശ്യങ്ങൾ മാത്രം ഇറക്കുമതി ചെയ്യുക:
```python
ufos.dropna(inplace=True)
ufos = ufos[(ufos['Seconds'] >= 1) & (ufos['Seconds'] <= 60)]
ufos.info()
```
1. രാജ്യങ്ങളുടെ ടെക്സ്റ്റ് മൂല്യങ്ങൾ സംഖ്യയാക്കി മാറ്റാൻ Scikit-learn-ന്റെ `LabelEncoder` ലൈബ്രറി ഇറക്കുമതി ചെയ്യുക:
✅ LabelEncoder ഡാറ്റ അക്ഷരമാലാനുസരിച്ച് എൻകോഡ് ചെയ്യുന്നു
```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. ലോജിസ്റ്റിക് റെഗ്രഷൻ ഉപയോഗിച്ച് മോഡൽ പരിശീലിപ്പിക്കുക:
```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`യും ഉപയോഗിച്ച് ഒരു `Country` നിശ്ചയിക്കാനാകും, പക്ഷേ ഇത് ശുദ്ധീകരിച്ച, എക്സ്പോർട്ട് ചെയ്ത, പിന്നീട് വെബ് ആപ്പിൽ ഉപയോഗിക്കുന്ന മോഡൽ പരിശീലിപ്പിക്കാൻ നല്ല അഭ്യാസമാണ്.
## അഭ്യാസം - മോഡൽ 'pickle' ചെയ്യുക
ഇപ്പോൾ, നിങ്ങളുടെ മോഡൽ _pickle_ ചെയ്യാനുള്ള സമയം! ഇത് കുറച്ച് കോഡ് വരികളിൽ ചെയ്യാം. _pickle_ ചെയ്ത ശേഷം, നിങ്ങളുടെ pickle ചെയ്ത മോഡൽ ലോഡ് ചെയ്ത് സെക്കൻഡ്, 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. _notebook.ipynb_ ഫയലിന് സമീപം **web-app** എന്ന ഫോൾഡർ സൃഷ്ടിക്കുക, അവിടെ നിങ്ങളുടെ _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_ പോലെയാണ് ഇത്, ആപ്പിന് ആവശ്യമായ ഡിപ്പൻഡൻസികൾ പട്ടികപ്പെടുത്തുന്നു. **requirements.txt** ൽ ഈ വരികൾ ചേർക്കുക:
```text
scikit-learn
pandas
numpy
flask
```
1. ഇപ്പോൾ, _web-app_ ലേക്ക് നാവിഗേറ്റ് ചെയ്ത് ഈ ഫയൽ പ്രവർത്തിപ്പിക്കുക:
```bash
cd web-app
```
1. നിങ്ങളുടെ ടെർമിനലിൽ `pip install` ടൈപ്പ് ചെയ്ത് _requirements.txt_ ലിസ്റ്റ് ചെയ്ത ലൈബ്രറികൾ ഇൻസ്റ്റാൾ ചെയ്യുക:
```bash
pip install -r requirements.txt
```
1. ഇപ്പോൾ, ആപ്പ് പൂർത്തിയാക്കാൻ മൂന്ന് ഫയലുകൾ കൂടി സൃഷ്ടിക്കാൻ തയ്യാറാകൂ:
1. റൂട്ടിൽ **app.py** സൃഷ്ടിക്കുക.
2. _templates_ ഡയറക്ടറിയിൽ **index.html** സൃഷ്ടിക്കുക.
3. _static/css_ ഡയറക്ടറിയിൽ **styles.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
🛸 UFO Appearance Prediction! 👽
According to the number of seconds, latitude and longitude, which country is likely to have reported seeing a UFO?
{{ prediction_text }}
```
ഈ ഫയലിലെ ടെംപ്ലേറ്റിംഗ് നോക്കുക. ആപ്പ് നൽകുന്ന വേരിയബിളുകൾ ചുറ്റിപ്പറ്റിയുള്ള 'മസ്റ്റാഷ്' സിന്റാക്സ് `{{}}` ശ്രദ്ധിക്കുക, ഉദാഹരണത്തിന് പ്രവചന ടെക്സ്റ്റ്. `/predict` റൂട്ടിലേക്ക് ഒരു ഫോർം പോസ്റ്റ് ചെയ്യുന്നതും കാണാം.
അവസാനം, മോഡൽ ഉപയോഗിച്ച് പ്രവചനങ്ങൾ പ്രദർശിപ്പിക്കുന്ന പൈത്തൺ ഫയൽ നിർമ്മിക്കാൻ തയ്യാറാകൂ:
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)
```
> 💡 ടിപ്പ്: Flask ഉപയോഗിച്ച് വെബ് ആപ്പ് ഓടിക്കുമ്പോൾ [`debug=True`](https://www.askpython.com/python-modules/flask/flask-debug-mode) ചേർക്കുമ്പോൾ, ആപ്പിൽ ചെയ്ത മാറ്റങ്ങൾ ഉടൻ പ്രതിഫലിക്കും, സെർവർ റീസ്റ്റാർട്ട് ചെയ്യേണ്ടതില്ല. ശ്രദ്ധിക്കുക! പ്രൊഡക്ഷൻ ആപ്പിൽ ഇത് ഉപയോഗിക്കരുത്.
`python app.py` അല്ലെങ്കിൽ `python3 app.py` ഓടിച്ചാൽ നിങ്ങളുടെ വെബ് സെർവർ ലോക്കലായി ആരംഭിക്കും, നിങ്ങൾക്ക് ഒരു ചെറിയ ഫോർം പൂരിപ്പിച്ച് UFO ദൃശ്യങ്ങൾ എവിടെ കണ്ടുവെന്ന് അറിയാം!
അതിനുമുമ്പ്, `app.py` ഭാഗങ്ങൾ നോക്കാം:
1. ആദ്യം, ഡിപ്പൻഡൻസികൾ ലോഡ് ചെയ്ത് ആപ്പ് ആരംഭിക്കുന്നു.
1. തുടർന്ന്, മോഡൽ ഇറക്കുമതി ചെയ്യുന്നു.
1. പിന്നീട്, ഹോം റൂട്ടിൽ index.html റെൻഡർ ചെയ്യുന്നു.
`/predict` റൂട്ടിൽ, ഫോർം പോസ്റ്റ് ചെയ്തപ്പോൾ പല കാര്യങ്ങളും നടക്കുന്നു:
1. ഫോർം വേരിയബിളുകൾ ശേഖരിച്ച് numpy അറേ ആയി മാറ്റുന്നു. മോഡലിലേക്ക് അയച്ച് പ്രവചന ഫലം ലഭിക്കുന്നു.
2. പ്രവചിച്ച രാജ്യ കോഡിൽ നിന്നുള്ള രാജ്യങ്ങൾ വായിക്കാൻ കഴിയുന്ന ടെക്സ്റ്റായി മാറ്റി index.html-ലേക്ക് അയക്കുന്നു, ടെംപ്ലേറ്റിൽ പ്രദർശിപ്പിക്കാൻ.
Flask-ഉം pickle ചെയ്ത മോഡലും ഉപയോഗിച്ച് മോഡൽ ഇങ്ങനെ ഉപയോഗിക്കുന്നത് സാദാരണമാണ്. ഏറ്റവും ബുദ്ധിമുട്ടുള്ളത് മോഡലിന് അയയ്ക്കേണ്ട ഡാറ്റയുടെ രൂപം മനസ്സിലാക്കലാണ്. മോഡൽ എങ്ങനെ പരിശീലിപ്പിച്ചതിനനുസരിച്ച് ഇത് വ്യത്യാസപ്പെടും. ഈ മോഡലിന് പ്രവചനത്തിന് മൂന്ന് ഡാറ്റ പോയിന്റുകൾ നൽകണം.
പ്രൊഫഷണൽ സാഹചര്യത്തിൽ, മോഡൽ പരിശീലിപ്പിക്കുന്നവരും വെബ് അല്ലെങ്കിൽ മൊബൈൽ ആപ്പ് ഉപയോഗിക്കുന്നവരും നല്ല ആശയവിനിമയം വേണം. നമ്മുടെ കേസിൽ, അത് നിങ്ങൾ മാത്രം!
---
## 🚀 ചലഞ്ച്
നോട്ട്ബുക്കിൽ പ്രവർത്തിക്കാതെ, മോഡൽ Flask ആപ്പിൽ തന്നെ പരിശീലിപ്പിക്കാൻ ശ്രമിക്കൂ! നിങ്ങളുടെ Python കോഡ് നോട്ട്ബുക്കിൽ നിന്ന് മാറ്റി, ഡാറ്റ ശുദ്ധീകരിച്ചതിന് ശേഷം, `train` എന്ന റൂട്ടിൽ ആപ്പിനുള്ളിൽ മോഡൽ പരിശീലിപ്പിക്കുക. ഈ രീതിയുടെ ഗുണങ്ങളും ദോഷങ്ങളും എന്തെല്ലാമാണ്?
## [പോസ്റ്റ്-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
## അവലോകനം & സ്വയം പഠനം
ML മോഡലുകൾ ഉപയോഗിക്കുന്ന വെബ് ആപ്പുകൾ നിർമ്മിക്കാൻ പല വഴികളുണ്ട്. ജാവാസ്ക്രിപ്റ്റ് അല്ലെങ്കിൽ Python ഉപയോഗിച്ച് ML ലെവറേജ് ചെയ്യാൻ നിങ്ങൾക്ക് കഴിയുന്ന വഴികളുടെ പട്ടിക തയ്യാറാക്കുക. ആർക്കിടെക്ചർ പരിഗണിക്കുക: മോഡൽ ആപ്പിൽ തന്നെ നിലനിൽക്കണോ, ക്ലൗഡിൽ ആയിരിക്കണോ? പിന്നീട് എങ്ങനെ ആക്സസ് ചെയ്യും? പ്രയോഗിച്ച ML വെബ് പരിഹാരത്തിനുള്ള ഒരു ആർക്കിടെക്ചറൽ മോഡൽ വരച്ചുകാണിക്കുക.
## അസൈൻമെന്റ്
[മറ്റൊരു മോഡൽ പരീക്ഷിക്കുക](assignment.md)
---
**അസൂയാപത്രം**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കപ്പെടണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.