16 KiB

Raw Permalink Blame History

Vytvorte webovú aplikáciu na použitie ML modelu

V tejto lekcii budete trénovať ML model na dátovej sade, ktorá je doslova mimo tohto sveta: pozorovania UFO za posledné storočie, získané z databázy NUFORC.

Naučíte sa:

Ako 'pickle' trénovaný model
Ako použiť tento model v aplikácii Flask

Pokračujeme v používaní notebookov na čistenie dát a trénovanie modelu, ale môžete tento proces posunúť o krok ďalej tým, že preskúmate použitie modelu „v divočine“, takpovediac: v webovej aplikácii.

Na to budete potrebovať vytvoriť webovú aplikáciu pomocou Flask.

Kvíz pred prednáškou

Vytvorenie aplikácie

Existuje niekoľko spôsobov, ako vytvoriť webové aplikácie na využitie modelov strojového učenia. Vaša webová architektúra môže ovplyvniť spôsob, akým je váš model trénovaný. Predstavte si, že pracujete v spoločnosti, kde skupina pre dátovú vedu vytvorila model, ktorý chcete použiť vo svojej aplikácii.

Úvahy

Existuje mnoho otázok, ktoré si musíte položiť:

Je to webová aplikácia alebo mobilná aplikácia? Ak vytvárate mobilnú aplikáciu alebo potrebujete použiť model v kontexte IoT, môžete použiť TensorFlow Lite a použiť model v aplikácii pre Android alebo iOS.
Kde bude model umiestnený? V cloude alebo lokálne?
Podpora offline režimu. Musí aplikácia fungovať offline?
Aká technológia bola použitá na trénovanie modelu? Zvolená technológia môže ovplyvniť nástroje, ktoré musíte použiť.
- Použitie TensorFlow. Ak trénujete model pomocou TensorFlow, napríklad tento ekosystém poskytuje možnosť konvertovať model TensorFlow na použitie vo webovej aplikácii pomocou TensorFlow.js.
- Použitie PyTorch. Ak vytvárate model pomocou knižnice ako PyTorch, máte možnosť exportovať ho vo formáte ONNX (Open Neural Network Exchange) na použitie vo webových aplikáciách JavaScript, ktoré môžu používať Onnx Runtime. Táto možnosť bude preskúmaná v budúcej lekcii pre model trénovaný pomocou Scikit-learn.
- Použitie Lobe.ai alebo Azure Custom Vision. Ak používate ML SaaS (Software as a Service) systém, ako je Lobe.ai alebo Azure Custom Vision na trénovanie modelu, tento typ softvéru poskytuje spôsoby exportu modelu pre mnoho platforiem, vrátane vytvorenia vlastného API, ktoré je možné dotazovať v cloude vašou online aplikáciou.

Máte tiež možnosť vytvoriť celú webovú aplikáciu Flask, ktorá by dokázala trénovať model priamo v webovom prehliadači. To je možné urobiť aj pomocou TensorFlow.js v kontexte JavaScriptu.

Pre naše účely, keďže sme pracovali s notebookmi založenými na Pythone, preskúmajme kroky, ktoré musíte podniknúť na export trénovaného modelu z takého notebooku do formátu čitateľného webovou aplikáciou vytvorenou v Pythone.

Nástroje

Na túto úlohu budete potrebovať dva nástroje: Flask a Pickle, oba bežiace na Pythone.

✅ Čo je Flask? Definovaný ako 'mikro-rámec' jeho tvorcami, Flask poskytuje základné funkcie webových rámcov pomocou Pythonu a šablónového enginu na vytváranie webových stránok. Pozrite si tento modul Learn, aby ste si vyskúšali prácu s Flask.

✅ Čo je Pickle? Pickle 🥒 je modul Pythonu, ktorý serializuje a de-serializuje štruktúru objektov Pythonu. Keď 'pickle' model, serializujete alebo sploštíte jeho štruktúru na použitie na webe. Buďte opatrní: pickle nie je inherentne bezpečný, takže buďte opatrní, ak ste vyzvaní k 'un-pickle' súboru. Súbor pickle má príponu .pkl.

Cvičenie - vyčistite svoje dáta

V tejto lekcii použijete dáta z 80 000 pozorovaní UFO, zhromaždené NUFORC (Národné centrum pre hlásenie UFO). Tieto dáta obsahujú zaujímavé popisy pozorovaní UFO, napríklad:

Dlhý príklad popisu. "Muž sa objaví z lúča svetla, ktorý svieti na trávnaté pole v noci, a beží smerom k parkovisku Texas Instruments".
Krátky príklad popisu. "svetlá nás prenasledovali".

Tabuľka ufos.csv obsahuje stĺpce o meste, štáte a krajine, kde sa pozorovanie uskutočnilo, tvare objektu a jeho zemepisnej šírke a zemepisnej dĺžke.

V prázdnom notebooku zahrnutom v tejto lekcii:

importujte pandas, matplotlib a numpy, ako ste to urobili v predchádzajúcich lekciách, a importujte tabuľku ufos. Môžete si pozrieť vzorovú dátovú sadu:
```
import pandas as pd
import numpy as np

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

Konvertujte dáta ufos na malý dataframe s novými názvami. Skontrolujte unikátne hodnoty v poli Country.

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

ufos.Country.unique()

Teraz môžete zredukovať množstvo dát, s ktorými musíme pracovať, odstránením akýchkoľvek nulových hodnôt a importovaním iba pozorovaní medzi 1-60 sekúnd:
```
ufos.dropna(inplace=True)

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

ufos.info()
```

Importujte knižnicu Scikit-learn LabelEncoder na konverziu textových hodnôt krajín na čísla:

✅ LabelEncoder kóduje dáta abecedne

from sklearn.preprocessing import LabelEncoder

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

ufos.head()

Vaše dáta by mali vyzerať takto:

	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

Cvičenie - vytvorte svoj model

Teraz sa môžete pripraviť na trénovanie modelu rozdelením dát na tréningovú a testovaciu skupinu.

Vyberte tri vlastnosti, na ktorých chcete trénovať ako svoj X vektor, a y vektor bude Country. Chcete byť schopní zadať Seconds, Latitude a Longitude a získať id krajiny na návrat.

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)

Trénujte svoj model pomocou logistickej regresie:

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

Presnosť nie je zlá (okolo 95%), čo nie je prekvapujúce, keďže Country a Latitude/Longitude korelujú.

Model, ktorý ste vytvorili, nie je veľmi revolučný, keďže by ste mali byť schopní odvodiť Country z jeho Latitude a Longitude, ale je to dobré cvičenie na pokus o trénovanie z čistých dát, ktoré ste vyčistili, exportovali a potom použili tento model vo webovej aplikácii.

Cvičenie - 'pickle' váš model

Teraz je čas pickle váš model! Môžete to urobiť v niekoľkých riadkoch kódu. Keď je pickled, načítajte váš pickled model a otestujte ho na vzorovom dátovom poli obsahujúcom hodnoty pre sekundy, zemepisnú šírku a zemepisnú dĺžku.

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 vráti '3', čo je kód krajiny pre Spojené kráľovstvo. Divné! 👽

Cvičenie - vytvorte Flask aplikáciu

Teraz môžete vytvoriť Flask aplikáciu na volanie vášho modelu a návrat podobných výsledkov, ale v vizuálne príjemnejšej podobe.

Začnite vytvorením priečinka web-app vedľa súboru notebook.ipynb, kde sa nachádza váš súbor ufo-model.pkl.
V tomto priečinku vytvorte ďalšie tri priečinky: static, s priečinkom css vo vnútri, a templates. Teraz by ste mali mať nasledujúce súbory a adresáre:
```
web-app/
  static/
    css/
  templates/
notebook.ipynb
ufo-model.pkl
```
✅ Pozrite si riešenie priečinka pre pohľad na hotovú aplikáciu
Prvý súbor, ktorý vytvoríte v priečinku web-app, je súbor requirements.txt. Podobne ako package.json v aplikácii JavaScript, tento súbor uvádza závislosti požadované aplikáciou. Do requirements.txt pridajte riadky:
```
scikit-learn
pandas
numpy
flask
```
Teraz spustite tento súbor navigáciou do web-app:
```
cd web-app
```
Vo vašom termináli zadajte pip install, aby ste nainštalovali knižnice uvedené v requirements.txt:
```
pip install -r requirements.txt
```
Teraz ste pripravení vytvoriť ďalšie tri súbory na dokončenie aplikácie:
1. Vytvorte app.py v koreňovom adresári.
2. Vytvorte index.html v adresári templates.
3. Vytvorte styles.css v adresári static/css.

Vytvorte súbor styles.css s niekoľkými štýlmi:

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

Ďalej vytvorte súbor 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>

Pozrite sa na šablónovanie v tomto súbore. Všimnite si syntax 'mustache' okolo premenných, ktoré budú poskytnuté aplikáciou, ako je text predikcie: {{}}. Je tu tiež formulár, ktorý posiela predikciu na trasu /predict.

Nakoniec ste pripravení vytvoriť pythonový súbor, ktorý riadi spotrebu modelu a zobrazenie predikcií:

Do app.py pridajte:

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)

💡 Tip: keď pridáte debug=True pri spustení webovej aplikácie pomocou Flask, všetky zmeny, ktoré urobíte vo svojej aplikácii, sa okamžite prejavia bez potreby reštartovania servera. Pozor! Nepovoľujte tento režim v produkčnej aplikácii.

Ak spustíte python app.py alebo python3 app.py - váš webový server sa spustí lokálne a môžete vyplniť krátky formulár, aby ste získali odpoveď na svoju naliehavú otázku o tom, kde boli UFO pozorované!

Predtým, než to urobíte, pozrite sa na časti app.py:

Najprv sa načítajú závislosti a aplikácia sa spustí.
Potom sa importuje model.
Potom sa na domovskej trase vykreslí index.html.

Na trase /predict sa pri odoslaní formulára deje niekoľko vecí:

Premenné formulára sa zhromaždia a konvertujú na numpy pole. Potom sa odošlú modelu a vráti sa predikcia.
Krajiny, ktoré chceme zobraziť, sa znovu vykreslia ako čitateľný text z ich predikovaného kódu krajiny a táto hodnota sa odošle späť do index.html, aby sa vykreslila v šablóne.

Použitie modelu týmto spôsobom, s Flask a pickled modelom, je relatívne jednoduché. Najťažšie je pochopiť, aký tvar dát musí byť odoslaný modelu, aby sa získala predikcia. To všetko závisí od toho, ako bol model trénovaný. Tento má tri dátové body, ktoré je potrebné zadať, aby sa získala predikcia.

V profesionálnom prostredí vidíte, aká dôležitá je dobrá komunikácia medzi ľuďmi, ktorí trénujú model, a tými, ktorí ho používajú vo webovej alebo mobilnej aplikácii. V našom prípade je to len jedna osoba, vy!

🚀 Výzva

Namiesto práce v notebooku a importovania modelu do Flask aplikácie, môžete model trénovať priamo vo Flask aplikácii! Skúste konvertovať svoj Python kód v notebooku, možno po vyčistení dát, na trénovanie modelu priamo v aplikácii na trase nazvanej train. Aké sú výhody a nevýhody sledovania tejto metódy?

Kvíz po prednáške

Prehľad a samoštúdium

Existuje mnoho spôsobov, ako vytvoriť webovú aplikáciu na využitie ML modelov. Urobte si zoznam spôsobov, ako by ste mohli použiť JavaScript alebo Python na vytvorenie webovej aplikácie na využitie strojového učenia. Zvážte architektúru: mal by model zostať v aplikácii alebo byť umiestnený v cloude? Ak je to druhé, ako by ste k nemu pristupovali? Nakreslite architektonický model pre aplikované ML webové riešenie.

Zadanie

Vyskúšajte iný model

Upozornenie:
Tento dokument bol preložený pomocou služby AI prekladu Co-op Translator. Aj keď sa snažíme o presnosť, prosím, berte na vedomie, že automatizované preklady môžu obsahovať chyby alebo nepresnosti. Pôvodný dokument v jeho rodnom jazyku by mal byť považovaný za autoritatívny zdroj. Pre kritické informácie sa odporúča profesionálny ľudský preklad. Nie sme zodpovední za žiadne nedorozumenia alebo nesprávne interpretácie vyplývajúce z použitia tohto prekladu.

16 KiB Raw Permalink Blame History