[PYTHON] Apprentissage automatique facile avec scikit-learn et flask ✕ Application Web
Apprentissage automatique et applications Web simples
J'ai créé une application de démonstration simple qui affiche le résultat à l'écran avec le modèle de jugement créé par l'apprentissage automatique pour l'entrée du site Web. Entrez la taille de l'éclat d'iris et des pétales (vertical, horizontal) pour déterminer et afficher la variété.
Le code est ici. https://github.com/shibuiwilliam/mlweb
Vue d'ensemble
C'est comme ça.
Il est composé d'un back-end qui détermine qu'il s'agit d'un front-end pour l'entrée de débris et de pétales et renvoie le résultat. C'est super simple. Le langage est Python 3.6, utilisant flask et wtform pour le Web et scicit-learn pour l'apprentissage automatique.
Comment utiliser
L'environnement de développement est CentOS 7.3 et Python 3.6. La bibliothèque comprend flask, wtform, scicit-learn et Jupyter Notebook. Cette zone est principalement introduite dans Anaconda3, mais flask et wtform sont pip installés. Veuillez cloner le code.
git clone https://github.com/shibuiwilliam/mlweb.git
Le site Web sera publié sur le port 5000. Il est nécessaire de configurer pour que le système d'exploitation et le réseau puissent accéder à 5000. (OS est selinux et firewalld)
Voici comment gérer le site Web.
nohup python web.py &
Le journal d'exécution est craché sur nohup.out. Si vous souhaitez afficher le journal de manière séquentielle, procédez comme suit:
tail -f nohup.out
Apprentissage automatique
Le modèle de jugement d'iris utilise la forêt aléatoire de scicit-learn et GridSearchCV.
Obtenez l'ensemble de données iris fourni par scikit-learn et créez les paramètres du modèle avec GridSearchCV avec les hyperparamètres de la forêt aléatoire.
# iris_train.ipynb
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.externals import joblib
import numpy as np
# use Iris dataset
data = load_iris()
x = data.data
y = data.target
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=54321)
# run gridsearchcv on random forest classifier
forest = RandomForestClassifier()
param_grid = {
'n_estimators' : [5, 10, 20, 30, 50, 100, 300],
'random_state' : [0],
'n_jobs' : [1],
'min_samples_split' : [3, 5, 10, 15, 20, 25, 30, 40, 50, 100],
'max_depth' : [3, 5, 10, 15, 20, 25, 30, 40, 50, 100]
}
forestGrid = GridSearchCV(forest, param_grid)
fgFit = forestGrid.fit(x_train, y_train)
Un modèle est créé en ajustant les paramètres de modèle créés dans une forêt aléatoire. Enregistrez le modèle sous forme de cornichon. Lorsqu'il est utilisé sur un site Web, appelez le modèle enregistré.
# set the best params to fit random forest classifier
forest.set_params(**fgFit.best_params_)
forest.fit(x, y)
# save the model as pickle
joblib.dump(forest, './rfcParam.pkl', compress=True)
# load the model
forest = joblib.load('./rfcParam.pkl')
# predict
t = np.array([5.1, 3.5, 1.4, 0.2])
t = t.reshape(1,-1)
print(forest.predict(t))
Site Internet
Le Web est fait avec flask et wtform. Tout d'abord, définissez les fonctions utilisées sur le Web (web.py).
# web.py
import numpy as np
#Enregistrez l'entrée en tant que journal dans csv.
def insert_csv(data):
import csv
import uuid
tuid = str(uuid.uuid1())
with open("./logs/"+tuid+".csv", "a") as f:
writer = csv.writer(f, lineterminator='\n')
writer.writerow(["sepalLength","sepalWidth","petalLength","petalWidth"])
writer.writerow(data)
return tuid
# scikit-Le jugement est fait à l'aide du modèle créé par learn.
def predictIris(params):
from sklearn.externals import joblib
# load the model
forest = joblib.load('./rfcParam.pkl')
# predict
params = params.reshape(1,-1)
pred = forest.predict(params)
return pred
#Le jugement est 0,1,Puisqu'il est sorti en 2, il est converti en nom de variété d'iris.
def getIrisName(irisId):
if irisId == 0: return "Iris Setosa"
elif irisId == 1: return "Iris Versicolour"
elif irisId == 2: return "Iris Virginica"
else: return "Error"
Vous trouverez ci-dessous le code Python utilisant Web HTML et flask.
Le premier est le formulaire d'entrée (templates / irisPred.html).
<!doctype html>
<html>
<body>
<h2 style = "text-align: center;">Enter Iris Params</h2>
{% for message in form.SepalLength.errors %}
<div>{{ message }}</div>
{% endfor %}
{% for message in form.SepalWidth.errors %}
<div>{{ message }}</div>
{% endfor %}
{% for message in form.PetalLength.errors %}
<div>{{ message }}</div>
{% endfor %}
{% for message in form.PetalWidth.errors %}
<div>{{ message }}</div>
{% endfor %}
<form action = "" method = post>
<fieldset>
<legend>Enter parameters here.</legend>
<div style = font-size:20px; font-weight:bold; margin-left:150px;>
{{ form.SepalLength.label }}<br>
{{ form.SepalLength }}
<br>
{{ form.SepalWidth.label }}<br>
{{ form.SepalWidth }}
<br>
{{ form.PetalLength.label }}<br>
{{ form.PetalLength }}
<br>
{{ form.PetalWidth.label }}<br>
{{ form.PetalWidth }}
<br>
{{ form.submit }}
</div>
</fieldset>
</form>
</body>
</html>
C'est l'écran (templates / success.html) qui affiche les résultats du jugement.
<!doctype html>
<title>Hello from Iris</title>
{% if irisName %}
<h1>It is {{ irisName }}</h1>
{% else %}
<h1>Hello from Iris</h1>
{% endif %}
Définition de formulaire Python (web.py).
# web.py
from flask import Flask, render_template, request, flash
from wtforms import Form, FloatField, SubmitField, validators, ValidationError
# App config.
DEBUG = True
app = Flask(__name__)
app.config.from_object(__name__)
app.config['SECRET_KEY'] = 'fda0e618-685c-11e7-bb40-fa163eb65161'
class IrisForm(Form):
SepalLength = FloatField("Sepal Length in cm",
[validators.InputRequired("all parameters are required!"),
validators.NumberRange(min=0, max=10)])
SepalWidth = FloatField("Sepal Width in cm",
[validators.InputRequired("all parameters are required!"),
validators.NumberRange(min=0, max=10)])
PetalLength = FloatField("Petal Length in cm",
[validators.InputRequired("all parameters are required!"),
validators.NumberRange(min=0, max=10)])
PetalWidth = FloatField("Petal Width in cm",
[validators.InputRequired("all parameters are required!"),
validators.NumberRange(min=0, max=10)])
submit = SubmitField("Try")
@app.route('/irisPred', methods = ['GET', 'POST'])
def irisPred():
form = IrisForm(request.form)
if request.method == 'POST':
if form.validate() == False:
flash("You need all parameters")
return render_template('irisPred.html', form = form)
else:
SepalLength = float(request.form["SepalLength"])
SepalWidth = float(request.form["SepalWidth"])
PetalLength = float(request.form["PetalLength"])
PetalWidth = float(request.form["PetalWidth"])
params = np.array([SepalLength, SepalWidth, PetalLength, PetalWidth])
print(params)
insert_csv(params)
pred = predictIris(params)
irisName = getIrisName(pred)
return render_template('success.html', irisName=irisName)
elif request.method == 'GET':
return render_template('irisPred.html', form = form)
if __name__ == "__main__":
app.debug = True
app.run(host='0.0.0.0')
Image d'exécution
Entrez un nombre approprié (entre 0 et 10) dans le formulaire de saisie à l'écran et essayez.
Le nom de la variété d'iris déterminée s'affiche à l'écran.
Recherchez les erreurs de saisie.
