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 డేటాబేస్ నుండి సేకరించబడింది.
|
|
|
|
మీరు నేర్చుకుంటారు:
|
|
|
|
- శిక్షణ పొందిన మోడల్ను 'పికిల్' చేయడం ఎలా
|
|
- ఆ మోడల్ను 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/) ఉపయోగించి వెబ్ యాప్లో ఉపయోగించడానికి TensorFlow మోడల్ను మార్చే సామర్థ్యాన్ని అందిస్తుంది.
|
|
- **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 (సాఫ్ట్వేర్ ఆజ్ ఎ సర్వీస్) వ్యవస్థను ఉపయోగించి మోడల్ను శిక్షణ ఇస్తుంటే, ఈ రకమైన సాఫ్ట్వేర్ అనేక ప్లాట్ఫారమ్లకు మోడల్ను ఎగుమతి చేయడానికి మార్గాలను అందిస్తుంది, మీ ఆన్లైన్ అప్లికేషన్ ద్వారా క్లౌడ్లో ప్రశ్నించదగిన ప్రత్యేక APIని కూడా నిర్మించవచ్చు.
|
|
|
|
మీకు ఒక పూర్తి Flask వెబ్ యాప్ను కూడా నిర్మించే అవకాశం ఉంది, ఇది వెబ్ బ్రౌజర్లోనే మోడల్ను శిక్షణ ఇస్తుంది. ఇది JavaScript సందర్భంలో 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 స్వభావంగా సురక్షితం కాదు, కాబట్టి ఫైల్ను 'అన్-పికిల్' చేయమని అడిగితే జాగ్రత్తగా ఉండండి. పికిల్ చేసిన ఫైల్కు `.pkl` అనే సఫిక్స్ ఉంటుంది.
|
|
|
|
## వ్యాయామం - మీ డేటాను శుభ్రపరచండి
|
|
|
|
ఈ పాఠంలో మీరు [NUFORC](https://nuforc.org) (నేషనల్ UFO రిపోర్టింగ్ సెంటర్) సేకరించిన 80,000 UFO దర్శనాల డేటాను ఉపయోగిస్తారు. ఈ డేటాలో 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. ఇప్పుడు, మనం వ్యవహరించాల్సిన డేటా పరిమాణాన్ని తగ్గించడానికి ఏ null విలువలైనా తొలగించి, 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` ను ఇన్పుట్గా ఇచ్చి దేశ ID ను పొందగలగాలి.
|
|
|
|
```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` ను అంచనా వేయగలరు, కానీ ఇది మీరు శుభ్రపరిచిన, ఎగుమతి చేసిన ముడి డేటా నుండి శిక్షణ ఇస్తూ, ఆ మోడల్ను వెబ్ యాప్లో ఉపయోగించడానికి మంచి వ్యాయామం.
|
|
|
|
## వ్యాయామం - మీ మోడల్ను 'పికిల్' చేయండి
|
|
|
|
ఇప్పుడు, మీ మోడల్ను _పికిల్_ చేయడానికి సమయం వచ్చింది! మీరు కొన్ని కోడ్ లైన్లలో ఇది చేయవచ్చు. ఒకసారి _పికిల్_ చేసిన తర్వాత, మీ పికిల్ చేసిన మోడల్ను లోడ్ చేసి, సెకన్లు, అక్షాంశం మరియు రేఖాంశం విలువలతో కూడిన నమూనా డేటా అర్రేపై పరీక్షించండి,
|
|
|
|
```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'** ను తిరిగి ఇస్తుంది, ఇది UK కోసం దేశ కోడ్. అద్భుతం! 👽
|
|
|
|
## వ్యాయామం - 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**. JavaScript యాప్లో _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>
|
|
```
|
|
|
|
ఈ ఫైల్లో టెంప్లేటింగ్ను గమనించండి. యాప్ అందించే వేరియబుల్స్ చుట్టూ ఉన్న 'మస్టాచ్' సింటాక్స్: `{{}}` ను గమనించండి, ఉదాహరణకు prediction టెక్స్ట్. అలాగే, `/predict` రూట్కు prediction పోస్ట్ చేసే ఫారం కూడా ఉంది.
|
|
|
|
చివరగా, మోడల్ వినియోగం మరియు prediction ప్రదర్శనను నడిపే 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)
|
|
```
|
|
|
|
> 💡 సూచన: 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 అర్రేకు మార్చబడతాయి. అవి మోడల్కు పంపబడతాయి మరియు prediction తిరిగి వస్తుంది.
|
|
2. మేము ప్రదర్శించదలచిన దేశాలు వారి అంచనా దేశ కోడ్ నుండి పఠనీయమైన టెక్స్ట్గా మళ్లీ రేండర్ చేయబడతాయి, ఆ విలువ index.html కు తిరిగి పంపబడుతుంది, టెంప్లేట్లో ప్రదర్శించడానికి.
|
|
|
|
Flask మరియు పికిల్ చేసిన మోడల్తో ఈ విధంగా మోడల్ను ఉపయోగించడం సాపేక్షంగా సులభం. కఠినమైన విషయం ఏమిటంటే, prediction పొందడానికి మోడల్కు పంపాల్సిన డేటా ఆకారాన్ని అర్థం చేసుకోవడం. అది మోడల్ శిక్షణ విధానంపై ఆధారపడి ఉంటుంది. ఈ మోడల్కు prediction కోసం మూడు డేటా పాయింట్లు ఇన్పుట్ కావాలి.
|
|
|
|
ప్రొఫెషనల్ పరిసరంలో, మోడల్ను శిక్షణ ఇస్తున్న వారు మరియు దాన్ని వెబ్ లేదా మొబైల్ యాప్లో వినియోగిస్తున్న వారు మధ్య మంచి కమ్యూనికేషన్ అవసరం అని మీరు చూడవచ్చు. మన సందర్భంలో, అది ఒక్క వ్యక్తి, మీరు!
|
|
|
|
---
|
|
|
|
## 🚀 సవాలు
|
|
|
|
నోట్బుక్లో పని చేయడం మరియు మోడల్ను 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 --> |