1596686520
How to Deploy PyTorch Model with Flask and Heroku
Create and Deploy your first Deep Learning app! In this PyTorch tutorial we learn how to deploy our PyTorch model with Flask and Heroku.
We create a simple Flask app with a REST API that returns the result as json data, and then we deploy it to Heroku. As an example PytTorch app we do digit classification, and at the end I show you how I draw my own digits and then predict it with our live running app.
Code:
https://github.com/python-engineer/pytorch-examples
Links:
Flask installation:
https://flask.palletsprojects.com/en/1.1.x/installation/#installation
PyTorch code:
https://github.com/python-engineer/pytorchTutorial
PyTorch:
https://pytorch.org/
Heroku:
https://www.heroku.com/
#python #pytorch #heroku #flask #deep-learning
What is GEEK
Buddha Community
1596686520
How to Deploy PyTorch Model with Flask and Heroku
Create and Deploy your first Deep Learning app! In this PyTorch tutorial we learn how to deploy our PyTorch model with Flask and Heroku.
We create a simple Flask app with a REST API that returns the result as json data, and then we deploy it to Heroku. As an example PytTorch app we do digit classification, and at the end I show you how I draw my own digits and then predict it with our live running app.
Code:
https://github.com/python-engineer/pytorch-examples
Links:
Flask installation:
https://flask.palletsprojects.com/en/1.1.x/installation/#installation
PyTorch code:
https://github.com/python-engineer/pytorchTutorial
PyTorch:
https://pytorch.org/
Heroku:
https://www.heroku.com/
#python #pytorch #heroku #flask #deep-learning
1595294400
Deploying Machine learning models using Flask on your website
Understanding of Machine Learning using Python (sklearn)
Basics of Flask
Basics of HTML,CSS
#machine-learning #deployment #ml-model-deployment #flask #deploying
1617331277
Workshop Alert! Deep Learning Model Deployment & Management
The Association of Data Scientists (AdaSci), the premier global professional body of data science and ML practitioners, has announced a hands-on workshop on deep learning model deployment on February 6, Saturday.
Over the last few years, the applications of deep learning models have increased exponentially, with use cases ranging from automated driving, fraud detection, healthcare, voice assistants, machine translation and text generation.
Typically, when data scientists start machine learning model development, they mostly focus on the algorithms to use, feature engineering process, and hyperparameters to make the model more accurate. However, model deployment is the most critical step in the machine learning pipeline. As a matter of fact, models can only be beneficial to a business if deployed and managed correctly. Model deployment or management is probably the most under discussed topic.
In this workshop, the attendees get to learn about ML lifecycle, from gathering data to the deployment of models. Researchers and data scientists can build a pipeline to log and deploy machine learning models. Alongside, they will be able to learn about the challenges associated with machine learning models in production and handling different toolkits to track and monitor these models once deployed.
#hands on deep learning #machine learning model deployment #machine learning models #model deployment #model deployment workshop
1622782728
Model Deployment using Flask
Making consumable models
INTRODUCTION
No matter how awesome model you have built, it would not give any value sitting in a jupyter notebook.
Often we focus a lot in the EDA, Model Development part, however there is one more major aspect that we tend to miss out i.e creating an end to end application or deploying the model, after all that hard work and efforts that you had put in developing your model it is equally important that you give it in a usable form that can be consumed by the end user directly. Moreover building an application around the code you have developed helps you make you make your work more presentable and helps you showcase your work better.
#machine-learning #flask #ml-model-deployment #heroku #data-science
1641005280
Presentamos el Modelo PyTorch usando Flask y Heroku
Cree e implemente su primera aplicación de aprendizaje profundo. En este tutorial de PyTorch, aprenderá a implementar un modelo de PyTorch usando Flask y Heroku. Cree una aplicación Flask simple utilizando la API REST que devuelve el resultado como datos json e impleméntelo en Heroku. Como ejemplo de la aplicación PytTorch, puede clasificar números, dibujar sus propios números al final y hacer predicciones en la aplicación de ejecución en vivo.
Configuración
Cree un proyecto en un entorno virtual (los comandos pueden variar ligeramente en Windows).
$ mkdir pytorch-deploy
$ cd pytorch-deploy
$ python3 -m venv venv
Activarlo
$ . venv/bin/activate
O para Windows
venv\Scripts\activate
Instalar Flask y PyTorch
$ pip install Flask
$ pip install torch torchvision
Crea una aplicación
Cree una nueva aplicación de directorio e inserte lo siguiente dentro de este archivo main.py :
from flask import Flask, jsonify
app = Flask(__name__)
@app.route('/predict', methods=['POST'])
def predict():
if request.method == 'POST':
return jsonify({'test': 'test_result'})
Solo se requiere un punto final @app.route('/predict'). Aquí tomamos una imagen, la predecimos con un modelo de PyTorch y devolvemos el resultado como datos json. Por ahora, los jsonifymétodos de Flask solo devuelven datos json ficticios.
Ejecuta y prueba la aplicación
Correr
$ export FLASK_APP=app/main.py
$ export FLASK_ENV=development
$ flask run
Cree una carpeta de prueba test e insértela dentro del archivo test.py.
import requests
resp = requests.post("http://localhost:5000/predict")
print(resp.text)
Ejecute el archivo test.py en la segunda terminal (es posible que deba instalar la solicitud :)pip install requests . Si todo funciona correctamente, esto generará datos json ficticios {'test': 'test_result'}.
Entrena y guarda tu modelo.
Aquí se obtiene el código de mi PyTorch supuesto que . Esta es una red neuronal de retroalimentación simple entrenada en el conjunto de datos MNIST y utilizada para clasificar números. El único cambio que hacemos es agregar otra transformación de conjunto de datos. Esto se debe a que queremos mostrar que la aplicación necesita la misma conversión. Por lo tanto, primero use esta transformación para aplicarla a su conjunto de datos.
transform = transforms.Compose([transforms.ToTensor(),
transforms.Normalize((0.1307,),(0.3081,))])
# MNIST dataset
train_dataset = torchvision.datasets.MNIST(root='./data',
train=True,
transform=transform,
download=True)
test_dataset = torchvision.datasets.MNIST(root='./data',
train=False,
transform=transform)
Esto es solo una normalización con la media global y la desviación estándar del conjunto de datos MNIST.
Inserte esta línea al final del archivo para guardar el modelo después del entrenamiento.
torch.save(model.state_dict(), "mnist_ffn.pth")
Luego ejecute este archivo. Esto entrena el modelo, lo imprime con alta precisión y guarda el modelo en el archivo especificado. Obtén este archivo y cópialo en tu carpeta de aplicaciones .
Crear una función de utilidad PyTorch
Cree un nuevo archivo torch_utils.py en la carpeta de la aplicación . Aquí hacemos tres cosas:
- Cargar el modelo
- Preprocese la imagen y conviértala en un tensor de antorcha
- Haz una predicción
Cargar el modelo
Consulte también este curso de PyTorch para guardar y cargar . Cree el mismo modelo que el archivo original, cargue el diccionario de estado y configúrelo en modo. Aquí solo se utiliza la versión de la CPU. De lo contrario, el paquete es demasiado grande para Heroku. Por lo tanto, si se entrenó en la GPU, asegúrese de que se cargue correctamente. También puede encontrar este código en el tutorial de guardar / cargar. Puede eliminar todas las llamadas de su código. No te preocupes. La CPU funciona lo suficientemente rápido como para inferir el modelo en esta aplicación.eval.to(device)
import io
import torch
import torch.nn as nn
import torchvision.transforms as transforms
from PIL import Image
class NeuralNet(nn.Module):
def __init__(self, input_size, hidden_size, num_classes):
super(NeuralNet, self).__init__()
self.input_size = input_size
self.l1 = nn.Linear(input_size, hidden_size)
self.relu = nn.ReLU()
self.l2 = nn.Linear(hidden_size, num_classes)
def forward(self, x):
out = self.l1(x)
out = self.relu(out)
out = self.l2(out)
# no activation and no softmax at the end
return out
input_size = 784 # 28x28
hidden_size = 500
num_classes = 10
model = NeuralNet(input_size, hidden_size, num_classes)
PATH = "mnist_ffn.pth"
model.load_state_dict(torch.load(PATH))
model.eval()
Cargar y convertir imágenes
Aquí nos aseguramos de que el tensor tenga las mismas propiedades que el conjunto de datos MNIST. Por lo tanto, aplique las mismas conversiones que el archivo original. Además, cambie el tamaño de la imagen a (28,28) y conviértala en una imagen en escala de grises. Agregue esta función al archivo torch_utils.py .
def transform_image(image_bytes):
transform = transforms.Compose([transforms.Grayscale(num_output_channels=1),
transforms.Resize((28,28)),
transforms.ToTensor(),
transforms.Normalize((0.1307,),(0.3081,))])
image = Image.open(io.BytesIO(image_bytes))
return transform(image).unsqueeze(0)
predecir
Ahora use el mismo código que el archivo original para predecir la imagen y devolver la predicción con la nueva función auxiliar.
def get_prediction(image_tensor):
images = image_tensor.reshape(-1, 28*28)
outputs = model(images)
# max returns (value ,index)
_, predicted = torch.max(outputs.data, 1)
return predicted
Poner todo junto
En el archivo main.py , predictcómo importar estas funciones auxiliares y ejecutarlas todas juntas . Además, también incluye algunas comprobaciones de errores, permitiendo solo ciertos archivos.
from flask import Flask, request, jsonify
from torch_utils import transform_image, get_prediction
app = Flask(__name__)
ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg'}
def allowed_file(filename):
# xxx.png
return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
@app.route('/predict', methods=['POST'])
def predict():
if request.method == 'POST':
file = request.files.get('file')
if file is None or file.filename == "":
return jsonify({'error': 'no file'})
if not allowed_file(file.filename):
return jsonify({'error': 'format not supported'})
try:
img_bytes = file.read()
tensor = transform_image(img_bytes)
prediction = get_prediction(tensor)
data = {'prediction': prediction.item(), 'class_name': str(prediction.item())}
return jsonify(data)
except:
return jsonify({'error': 'error during prediction'})
Tenga en cuenta que en este conjunto de datos prediction, class_namees el mismo que. Normalmente, debe hacer el mapeo del índice al nombre real de la clase aquí.
Prueba el modelo
Luego, tome algunas imágenes de muestra o use un programa de pintura simple para dibujar su propia imagen. En mi caso, en el Mac se usó pincel para crear una nueva imagen de tamaño 100x100, rellenar el fondo con negro, se dibujó números en blanco. Guarde como png o jpg y copie el archivo a la carpeta de prueba . Luego, incluye esta imagen en tu solicitud de publicación. Por ejemplo, Eight.Png la imagen que utilice usted.
import requests
resp = requests.post("http://localhost:5000/predict", files={'file': open('eight.png', 'rb')})
print(resp.text)
Esto debe imprimirse {'prediction': 8, 'class_name': 8}. enhorabuena! Ahora tiene una aplicación web PyTorch en ejecución. Como paso final, implemente en Heroku
Implementar en Heroku
La producción en el medio ambiente , el servidor Web apropiado es tan necesario, Gunicorn instalar que .
$ pip install gunicorn
Todos los siguientes archivos deben agregarse al directorio base. Primero, cree un archivo wsgi.py e inserte esta línea
from app.main import app
Procfile cree un, esto e inserte el.
web: gunicorn wsgi:app
Cambie el nombre de la ruta para basarla en el paquete de su aplicación .
# in the main.py file:
from app.torch_utils import get_prediction, transform_image
# in the torch_utils.py file
PATH = "app/mnist_ffn.pth"
Cree runtime.txt e inserte la versión de Python que está utilizando .
python-3.8.3
Asegúrese de estar nuevamente en la carpeta raíz del paquete. Luego, todos los paquetes con los siguientes requisitos.txt y agregarlo al archivo pip freeze.
$ pip freeze > requirements.txt
Solo está disponible la versión de CPU, así que modifique el archivo de esta manera para usar la versión de PyTorch solo para CPU. Puede obtener la versión del comando solo para CPU en esta guía de instalación de PyTorch . Seleccione Linux, pip y no CUDA. Puede agregar el comando de descarga como la primera línea en el archivo requirements.txt .
-f https://download.pytorch.org/whl/torch_stable.html
torch==1.6.0+cpu
torchvision==0.7.0+cpu
El .gitignore te agrega . Esta versión de Python es, GitHub se puede obtener de usted . Además, agregue una carpeta de prueba para que la primera línea del archivo contenga la siguiente línea:
test/
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
...
Crea una aplicación Heroku. Para hacer esto, necesita instalar Heroku CLI. Aquí usted puede conseguir que . Inicie sesión y cree una nueva aplicación con el nombre que desee.
$ heroku login -i
$ heroku create your-app-name
Pruebe su aplicación localmente.
$ heroku local
Luego agregue un repositorio de git, confirme todos los archivos y envíelos a Heroku.
git init
heroku git:remote -a your-app-name
git add .
git commit -m "initial commit"
git push heroku master
Esto implementará su aplicación en Heroku y le mostrará un enlace a la aplicación que se ejecuta en vivo. Luego use esta URL en su archivo test.py de la siguiente manera:
import requests
resp = requests.post("https://your-app-name.herokuapp.com/predict",
files={"file": open('eight.png','rb')})
print(resp.text)
enhorabuena! Ahora tiene una aplicación de ejecución en vivo con un modelo de PyTorch que puede realizar la clasificación de números. Tenga en cuenta que si solo usa el nivel gratuito, Heroku deberá activar su aplicación primero, por lo que puede tomar unos segundos enviar su primera solicitud.
¿Has disfrutado de este tutorial?
Enlace: https://www.python-engineer.com/posts/pytorch-model-deployment-with-flask/