python - tfidftransformer - Aplicación web que utiliza scikit-learn.
sklearn ensemble (4)
Estoy trabajando en una imagen de Docker que envuelve los métodos de predict y predictproba y los expone como una API web: https://github.com/hexacta/docker-sklearn-predict-http-api
Necesitas guardar tu modelo:
from sklearn.externals import joblib
joblib.dump(clf, ''iris-svc.pkl'')
crear un Dockerfile:
FROM hexacta/sklearn-predict-http-api:latest
COPY iris-svc.pkl /usr/src/app/model.pkl
y ejecute el contenedor:
$ docker build -t iris-svc .
$ docker run -d -p 4000:8080 iris-svc
entonces usted puede hacer solicitudes:
$ curl -H "Content-Type: application/json" -X POST -d ''{"sepal length (cm)":4.4}'' http://localhost:4000/predictproba
[{"0":0.8284069169,"1":0.1077571623,"2":0.0638359208}]
$ curl -H "Content-Type: application/json" -X POST -d ''[{"sepal length (cm)":4.4}, {"sepal length (cm)":15}]'' http://localhost:4000/predict
[0, 2]
He entrenado localmente un clasificador de sklearn y tengo que crear una aplicación web simple que demuestre su uso. Soy un noob completo en el desarrollo de aplicaciones web y no quiero perder horas en crear una aplicación web utilizando un marco que no admita los módulos que estoy usando.
- ¿Cuál sugieres que sería un buen enfoque para esta tarea?
- ¿Qué marco de desarrollo de aplicaciones web debo usar (si corresponde)?
- ¿Tengo que sumergirme en cosas como
Heoku,django, etc. o hay soluciones más simples y rápidas para una demostración científica simple?
Mi idea era tomar el clasificador que entrené, decaparlo y quitarlo en el servidor, luego ejecutar la classify desde el servidor, pero no estoy seguro de por dónde empezar.
Puede seguir el tutorial a continuación para implementar su modelo scikit-learn en Azure ML y obtener el servicio web generado automáticamente:
Cree e implemente una aplicación web predictiva utilizando Python y Azure ML
o la combinación de yHat + Heroku también puede hacer el truco
Si bien esto no es un clasificador, he implementado un servicio web de aprendizaje automático simple utilizando el marco de la botella y scikit-learn. Dado un conjunto de datos en formato .csv, devuelve visualizaciones en 2D con respecto al análisis de componentes principales y técnicas de análisis discriminante lineal.
Puede encontrar más información y ejemplos de archivos de datos en: http://mindwriting.org/blog/?p=153
Aquí está la implementación: upload.html:
<form
action="/plot" method="post"
enctype="multipart/form-data"
>
Select a file: <input type="file" name="upload" />
<input type="submit" value="PCA & LDA" />
</form>
pca_lda_viz.py (modificar nombre de host y número de puerto):
import matplotlib
matplotlib.use(''Agg'')
import matplotlib.pyplot as plt
import numpy as np
from cStringIO import StringIO
from bottle import route, run, request, static_file
import csv
from matplotlib.font_manager import FontProperties
import colorsys
from sklearn import datasets
from sklearn.decomposition import PCA
from sklearn.lda import LDA
html = ''''''
<html>
<body>
<img src="data:image/png;base64,{}" />
</body>
</html>
''''''
@route(''/'')
def root():
return static_file(''upload.html'', root=''.'')
@route(''/plot'', method=''POST'')
def plot():
# Get the data
upload = request.files.get(''upload'')
mydata = list(csv.reader(upload.file, delimiter='',''))
x = [row[0:-1] for row in mydata[1:len(mydata)]]
classes = [row[len(row)-1] for row in mydata[1:len(mydata)]]
labels = list(set(classes))
labels.sort()
classIndices = np.array([labels.index(myclass) for myclass in classes])
X = np.array(x).astype(''float'')
y = classIndices
target_names = labels
#Apply dimensionality reduction
pca = PCA(n_components=2)
X_r = pca.fit(X).transform(X)
lda = LDA(n_components=2)
X_r2 = lda.fit(X, y).transform(X)
#Create 2D visualizations
fig = plt.figure()
ax=fig.add_subplot(1, 2, 1)
bx=fig.add_subplot(1, 2, 2)
fontP = FontProperties()
fontP.set_size(''small'')
colors = np.random.rand(len(labels),3)
for c,i, target_name in zip(colors,range(len(labels)), target_names):
ax.scatter(X_r[y == i, 0], X_r[y == i, 1], c=c,
label=target_name,cmap=plt.cm.coolwarm)
ax.legend(loc=''upper center'', bbox_to_anchor=(1.05, -0.05),
fancybox=True,shadow=True, ncol=len(labels),prop=fontP)
ax.set_title(''PCA'')
ax.tick_params(axis=''both'', which=''major'', labelsize=6)
for c,i, target_name in zip(colors,range(len(labels)), target_names):
bx.scatter(X_r2[y == i, 0], X_r2[y == i, 1], c=c,
label=target_name,cmap=plt.cm.coolwarm)
bx.set_title(''LDA'');
bx.tick_params(axis=''both'', which=''major'', labelsize=6)
# Encode image to png in base64
io = StringIO()
fig.savefig(io, format=''png'')
data = io.getvalue().encode(''base64'')
return html.format(data)
run(host=''mindwriting.org'', port=8079, debug=True)
Si esto es solo para una demostración, entrene a su clasificador fuera de línea, escoja el modelo y luego use un marco web de Python simple como un flask o una bottle para desentrañar el modelo en el momento de inicio del servidor y llame a la función de predicción en un controlador de solicitud HTTP.
django es un marco completo de características, por lo tanto, es más largo de aprender que el matraz o la botella, pero tiene una gran documentación y una comunidad más grande.
heroku es un servicio para alojar su aplicación en la nube. Es posible alojar aplicaciones de matraz en heroku , aquí hay una plantilla de proyecto simple + instrucciones para hacerlo.
Para las configuraciones de "producción", le aconsejaría que no use pickle, sino que escriba su propia capa de persistencia para el modelo de aprendizaje automático para tener un control total sobre los parámetros de su tienda y ser más robusto con las actualizaciones de la biblioteca que podrían romper el descifrado de los antiguos modelos