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
30 KiB
352 lines
30 KiB
# 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
|
|
<!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>
|
|
```
|
|
|
|
ഈ ഫയലിലെ ടെംപ്ലേറ്റിംഗ് നോക്കുക. ആപ്പ് നൽകുന്ന വേരിയബിളുകൾ ചുറ്റിപ്പറ്റിയുള്ള 'മസ്റ്റാഷ്' സിന്റാക്സ് `{{}}` ശ്രദ്ധിക്കുക, ഉദാഹരണത്തിന് പ്രവചന ടെക്സ്റ്റ്. `/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)
|
|
|
|
---
|
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
|
**അസൂയാപത്രം**:
|
|
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കപ്പെടണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |