History

leestott c796f3dda8 🌐 Update translations via Co-op Translator		2 weeks ago
..
solution	🌐 Update translations via Co-op Translator	2 weeks ago
README.md	🌐 Update translations via Co-op Translator	3 weeks ago
assignment.md	🌐 Update translations via Co-op Translator	3 weeks ago
notebook.ipynb	🌐 Update translations via Co-op Translator	2 weeks ago

README.md

Zgradite spletno aplikacijo za uporabo modela strojnega učenja

V tej lekciji boste trenirali model strojnega učenja na podatkovnem naboru, ki je resnično izjemen: opazovanja NLP-jev v zadnjem stoletju, pridobljenih iz baze podatkov NUFORC.

Naučili se boste:

Kako 'shraniti' treniran model
Kako uporabiti ta model v aplikaciji Flask

Še naprej bomo uporabljali beležke za čiščenje podatkov in treniranje modela, vendar lahko proces nadgradite tako, da raziščete uporabo modela 'v divjini', če lahko tako rečemo: v spletni aplikaciji.

Za to morate zgraditi spletno aplikacijo z uporabo Flask.

Predlekcijski kviz

Gradnja aplikacije

Obstaja več načinov za gradnjo spletnih aplikacij, ki uporabljajo modele strojnega učenja. Vaša spletna arhitektura lahko vpliva na način, kako je model treniran. Predstavljajte si, da delate v podjetju, kjer je skupina za podatkovno znanost trenirala model, ki ga želite uporabiti v aplikaciji.

Premisleki

Obstaja veliko vprašanj, ki jih morate zastaviti:

Ali gre za spletno ali mobilno aplikacijo? Če gradite mobilno aplikacijo ali morate model uporabiti v kontekstu IoT, lahko uporabite TensorFlow Lite in model uporabite v aplikaciji za Android ali iOS.
Kje bo model shranjen? V oblaku ali lokalno?
Podpora brez povezave. Ali mora aplikacija delovati brez povezave?
Katera tehnologija je bila uporabljena za treniranje modela? Izbrana tehnologija lahko vpliva na orodja, ki jih morate uporabiti.
- Uporaba TensorFlow. Če trenirate model z uporabo TensorFlow, na primer, ta ekosistem omogoča pretvorbo modela TensorFlow za uporabo v spletni aplikaciji z uporabo TensorFlow.js.
- Uporaba PyTorch. Če gradite model z uporabo knjižnice, kot je PyTorch, imate možnost, da ga izvozite v format ONNX (Open Neural Network Exchange) za uporabo v JavaScript spletnih aplikacijah, ki lahko uporabljajo Onnx Runtime. To možnost bomo raziskali v prihodnji lekciji za model, treniran s Scikit-learn.
- Uporaba Lobe.ai ali Azure Custom Vision. Če uporabljate sistem ML SaaS (Software as a Service), kot sta Lobe.ai ali Azure Custom Vision za treniranje modela, ta vrsta programske opreme omogoča načine za izvoz modela za številne platforme, vključno z gradnjo prilagojenega API-ja, ki ga vaša spletna aplikacija lahko poizveduje v oblaku.

Imate tudi možnost zgraditi celotno spletno aplikacijo Flask, ki bi lahko trenirala model kar v spletnem brskalniku. To je mogoče storiti tudi z uporabo TensorFlow.js v kontekstu JavaScript.

Za naše namene, ker smo delali z beležkami, ki temeljijo na Pythonu, raziščimo korake, ki jih morate narediti, da izvozite treniran model iz takšne beležke v format, ki ga lahko bere spletna aplikacija, zgrajena v Pythonu.

Orodje

Za to nalogo potrebujete dve orodji: Flask in Pickle, oba delujeta na Pythonu.

✅ Kaj je Flask? Flask, opisan kot 'mikro-okvir' s strani njegovih ustvarjalcev, ponuja osnovne funkcije spletnih okvirov z uporabo Pythona in predloge za gradnjo spletnih strani. Oglejte si ta modul za učenje, da vadite gradnjo s Flask.

✅ Kaj je Pickle? Pickle 🥒 je Python modul, ki serializira in de-serializira strukturo Python objektov. Ko 'shranite' model, serializirate ali sploščite njegovo strukturo za uporabo na spletu. Bodite previdni: pickle ni sam po sebi varen, zato bodite previdni, če vas pozove k 'odshranjevanju' datoteke. Shranjena datoteka ima pripono .pkl.

Naloga - očistite svoje podatke

V tej lekciji boste uporabili podatke iz 80.000 opazovanj NLP-jev, zbranih s strani NUFORC (Nacionalni center za poročanje o NLP-jih). Ti podatki vsebujejo zanimive opise opazovanj NLP-jev, na primer:

Dolgi opis primera. "Moški se pojavi iz svetlobnega žarka, ki sveti na travnato polje ponoči, in teče proti parkirišču Texas Instruments."
Kratki opis primera. "luči so nas lovile."

Preglednica ufos.csv vključuje stolpce o mestu, državi in državi, kjer se je opazovanje zgodilo, obliki objekta (shape) ter njegovi zemljepisni širini in zemljepisni dolžini.

V prazni beležki, ki je vključena v to lekcijo:

uvozite pandas, matplotlib in numpy, kot ste to storili v prejšnjih lekcijah, ter uvozite preglednico NLP-jev. Lahko si ogledate vzorčni podatkovni nabor:
```
import pandas as pd
import numpy as np

ufos = pd.read_csv('./data/ufos.csv')
ufos.head()
```

Pretvorite podatke NLP-jev v majhen podatkovni okvir z novimi naslovi. Preverite unikatne vrednosti v polju Country.

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

ufos.Country.unique()

Zdaj lahko zmanjšate količino podatkov, s katerimi se morate ukvarjati, tako da odstranite vse vrednosti null in uvozite samo opazovanja med 1-60 sekundami:
```
ufos.dropna(inplace=True)

ufos = ufos[(ufos['Seconds'] >= 1) & (ufos['Seconds'] <= 60)]

ufos.info()
```

Uvozite knjižnico Scikit-learn LabelEncoder, da pretvorite besedilne vrednosti za države v številke:

✅ LabelEncoder kodira podatke po abecedi

from sklearn.preprocessing import LabelEncoder

ufos['Country'] = LabelEncoder().fit_transform(ufos['Country'])

ufos.head()

Vaši podatki bi morali izgledati takole:

	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

Naloga - zgradite svoj model

Zdaj se lahko pripravite na treniranje modela tako, da podatke razdelite v skupino za treniranje in testiranje.

Izberite tri značilnosti, na katerih želite trenirati, kot vaš X vektor, medtem ko bo y vektor Country. Želite vnesti Seconds, Latitude in Longitude ter dobiti ID države kot rezultat.

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)

Trenirajte svoj model z uporabo logistične regresije:

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))

Natančnost ni slaba (približno 95%), kar ni presenetljivo, saj se Country in Latitude/Longitude korelirata.

Model, ki ste ga ustvarili, ni zelo revolucionaren, saj bi morali biti sposobni sklepati Country iz njegovih Latitude in Longitude, vendar je to dobra vaja za treniranje iz surovih podatkov, ki ste jih očistili, izvozili in nato uporabili ta model v spletni aplikaciji.

Naloga - 'shranite' svoj model

Zdaj je čas, da shranite svoj model! To lahko storite v nekaj vrsticah kode. Ko je shranjen, naložite shranjeni model in ga preizkusite na vzorčnem podatkovnem nizu, ki vsebuje vrednosti za sekunde, zemljepisno širino in dolžino.

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]]))

Model vrne '3', kar je koda države za Združeno kraljestvo. Neverjetno! 👽

Naloga - zgradite aplikacijo Flask

Zdaj lahko zgradite aplikacijo Flask, ki bo klicala vaš model in vračala podobne rezultate, vendar na bolj vizualno privlačen način.

Začnite z ustvarjanjem mape web-app poleg datoteke notebook.ipynb, kjer se nahaja vaša datoteka ufo-model.pkl.
V tej mapi ustvarite še tri mape: static, z mapo css znotraj nje, in templates. Zdaj bi morali imeti naslednje datoteke in direktorije:
```
web-app/
  static/
    css/
  templates/
notebook.ipynb
ufo-model.pkl
```
✅ Oglejte si mapo z rešitvami za pogled na končano aplikacijo
Prva datoteka, ki jo ustvarite v mapi web-app, je datoteka requirements.txt. Kot package.json v aplikaciji JavaScript, ta datoteka navaja odvisnosti, ki jih aplikacija potrebuje. V requirements.txt dodajte vrstice:
```
scikit-learn
pandas
numpy
flask
```
Zdaj zaženite to datoteko tako, da se premaknete v web-app:
```
cd web-app
```
V terminalu vnesite pip install, da namestite knjižnice, navedene v requirements.txt:
```
pip install -r requirements.txt
```
Zdaj ste pripravljeni ustvariti še tri datoteke za dokončanje aplikacije:
1. Ustvarite app.py v korenu.
2. Ustvarite index.html v mapi templates.
3. Ustvarite styles.css v mapi static/css.

Izdelajte datoteko styles.css z nekaj slogi:

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;
}

Nato izdelajte datoteko 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>

Oglejte si predloge v tej datoteki. Opazite sintakso 'mustache' okoli spremenljivk, ki jih bo zagotovila aplikacija, kot je besedilo napovedi: {{}}. Obstaja tudi obrazec, ki pošlje napoved na pot /predict.

Končno ste pripravljeni zgraditi Python datoteko, ki upravlja porabo modela in prikaz napovedi:

V app.py dodajte:

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)

💡 Nasvet: ko dodate debug=True med zagonom spletne aplikacije z uporabo Flask, bodo vse spremembe, ki jih naredite v svoji aplikaciji, takoj vidne brez potrebe po ponovnem zagonu strežnika. Pazite! Ne omogočite tega načina v produkcijski aplikaciji.

Če zaženete python app.py ali python3 app.py - vaš spletni strežnik se zažene lokalno in lahko izpolnite kratek obrazec, da dobite odgovor na svoje pereče vprašanje o tem, kje so bili NLP-ji opaženi!

Preden to storite, si oglejte dele app.py:

Najprej se naložijo odvisnosti in aplikacija se zažene.
Nato se model uvozi.
Nato se na domači poti prikaže index.html.

Na poti /predict se zgodi več stvari, ko je obrazec poslan:

Spremenljivke obrazca se zberejo in pretvorijo v numpy array. Nato se pošljejo modelu in vrne se napoved.
Države, ki jih želimo prikazati, se ponovno prikažejo kot berljivo besedilo iz njihove predvidene kode države, in ta vrednost se pošlje nazaj v index.html, da se prikaže v predlogi.

Uporaba modela na ta način, z Flask in shranjenim modelom, je razmeroma preprosta. Najtežje je razumeti, kakšne oblike morajo biti podatki, ki jih je treba poslati modelu, da dobite napoved. To je odvisno od tega, kako je bil model treniran. Ta model zahteva tri podatkovne točke za vnos, da vrne napoved.

V profesionalnem okolju lahko vidite, kako pomembna je dobra komunikacija med ljudmi, ki trenirajo model, in tistimi, ki ga uporabljajo v spletni ali mobilni aplikaciji. V našem primeru ste to le vi!

🚀 Izziv

Namesto da delate v beležki in uvozite model v aplikacijo Flask, bi lahko model trenirali kar znotraj aplikacije Flask! Poskusite pretvoriti svojo Python kodo v beležki, morda po tem, ko so vaši podatki očiščeni, da trenirate model znotraj aplikacije na poti, imenovani train. Kakšne so prednosti in slabosti tega pristopa?

Po-lekcijski kviz

Pregled in samostojno učenje

Obstaja veliko načinov za gradnjo spletne aplikacije, ki uporablja modele strojnega učenja. Naredite seznam načinov, kako bi lahko uporabili JavaScript ali Python za gradnjo spletne aplikacije, ki izkorišča strojno učenje. Razmislite o arhitekturi: naj model ostane v aplikaciji ali naj živi v oblaku? Če slednje, kako bi dostopali do njega? Narišite arhitekturni model za rešitev spletne aplikacije z uporabo strojnega učenja.

Naloga

Preizkusite drugačen model

Omejitev odgovornosti:
Ta dokument je bil preveden z uporabo storitve za strojno prevajanje Co-op Translator. Čeprav si prizadevamo za natančnost, vas prosimo, da upoštevate, da lahko avtomatizirani prevodi vsebujejo napake ali netočnosti. Izvirni dokument v njegovem izvirnem jeziku je treba obravnavati kot avtoritativni vir. Za ključne informacije priporočamo strokovno človeško prevajanje. Ne prevzemamo odgovornosti za morebitna nesporazumevanja ali napačne razlage, ki izhajajo iz uporabe tega prevoda.