Modelo de aprendizaje automático de Delply con Heroku y FastAPI

Este artículo fue publicado como parte del Blogatón de ciencia de datos

Introducción

Te guiaré a través del proceso de Implementar un modelo de aprendizaje automático como API usando FastAPI y Heroku. Cosas cubiertas en este artículo:

1. Una introducción rápida al conjunto de datos y al modelo
2. Conceptos básicos de FastAPI
3. Cómo estructurar el código para usar el modelo ML
4. ¿Cómo probar y recuperar esta API?
5. Implementación en Heroku
6. Bono: Generación de documentos

El conjunto de datos y el modelo

El enunciado del problema que he elegido para esta serie de artículos es Clasificación de género musical. El conjunto de datos ha sido compilado por un grupo de investigación llamado The Echo Nest. Contiene varios detalles técnicos sobre la música. Éstos incluyen Acústica, bailabilidad, energía, instrumentalidad, vivacidad, habla, tempo y valencia. La variable objetivo de estos datos es si la canción pertenece al género Rock o Hip-Hop. A continuación, se muestran algunos detalles sobre el conjunto de datos:

La identificación de la pista no sirvió para nuestro análisis y, por lo tanto, se eliminó. Genre_top es nuestra variable de destino y contiene «Rock» o «Hip-Hop». Entrené un clasificador de árbol de decisión para este conjunto de datos y obtuve una buena puntuación de precisión. (No probé otros modelos de conjuntos como Random Forest, pero puedes probarlo).

Una vez que haya terminado de ajustar el modelo y probarlo con datos aleatorios, es hora de seleccionar el modelo. El decapado es el proceso de convertir un objeto de Python en un flujo de bytes. Guarda el modelo como un archivo para que se pueda acceder / cargar más adelante. Aquí está el código para el mismo si no está familiarizado:

pkl_filename="model.pkl"
with open(pkl_filename, 'wb') as f:
    pickle.dump(model, f)

Introducción a FastAPI

Es un marco web que acelera el desarrollo backend de un sitio web utilizando Python. Este marco es nuevo, adaptable y fácil de aprender. Permite a los usuarios configurar rápidamente la API, genera documentos automáticos para todos los puntos finales, ofrece autenticación, validación de datos, permite código asincrónico y mucho más. Está desarrollado sobre Starlette, que es un marco / kit de herramientas ASGI liviano y proporciona código listo para producción.

Por otro lado, Flask es más antiguo que FastAPI pero todavía se usa para muchos proyectos. Su enfoque minimalista es prometedor y la creación de API con flask tampoco es tan difícil. Ambos marcos tienen sus pros y sus contras.

Consulte este artículo para obtener una comparación detallada FastAPI: ¿El reemplazo adecuado para matraces?

Para implementar nuestro modelo de aprendizaje automático, usaremos el enfoque FastAPI. Antes de sumergirme en el código para crear la API del modelo, comprendamos algunos conceptos básicos de FastAPI que ayudarán a comprender mejor la base de código.

Conceptos básicos de FastAPI

La estructura del código FastAPI es muy similar a la estructura de la aplicación Flask. Necesita crear puntos finales donde nuestro servicio al cliente pueda realizar solicitudes y obtener los datos requeridos. Vea la implementación del código básico a continuación:

import uvicorn

from fastapi import FastAPI

app = FastAPI()

@app.get('/')

def index():

    return {'message': "This is the home page of this API. Go to /apiv1/ or /apiv2/?name="}

@app.get('/apiv1/{name}')

def api1(name: str):

    return {'message': f'Hello! @{name}'}

@app.get('/apiv2/')

def api2(name: str):

    return {'message': f'Hello! @{name}'}

if __name__ == '__main__':

    uvicorn.run(app, host="127.0.0.1", port=4000, debug=True)

1. Las dos primeras líneas importan FastAPI y uvicorn. El Uvicorn se usa para implementar el servidor y manejar todas las llamadas en Python.
2. A continuación, se crea una instancia de la aplicación FastAPI.
3. Para agregar rutas / puntos finales a esta instancia de aplicación, se crea una función y se agrega un decorador de rutas. Este decorador registra la función para la ruta definida de modo que cuando se solicita esa ruta en particular, se llama a la función y su resultado se devuelve al cliente. Generalmente, devolvemos un objeto JSON para que pueda analizarse en cualquier idioma.
4. La mejor parte de FastAPI es que puede definir estas rutas directamente para los métodos HTTP. En el matraz, debe agregarlos manualmente a una lista de métodos (actualizado en el matraz 2.0).
5. Para obtener las entradas del cliente, puede utilizar parámetros de ruta, parámetros de consulta o cuerpos de solicitud. La ruta “/ apiv1 / {nombre}” implementa un enfoque basado en rutas donde los parámetros se pasan como rutas. La ruta «/ apiv2 /» implementa un enfoque basado en consultas donde los parámetros se pasan agregando el «?» al final de la URL y usando «&» para agregar múltiples parámetros.

Vea estas rutas en acción:

Solicitar enfoque corporal

Con este enfoque, se pueden pasar los datos del cliente a nuestra API. En FastAPI, para simplificar las cosas, usamos modelos Pydantic para definir la estructura de datos para los datos de recepción. Pydantic realiza toda la verificación de tipo de los parámetros y devuelve errores explicables si se recibe el tipo de parámetro incorrecto. Agreguemos una clase de datos a nuestro código existente y creemos una ruta para el cuerpo de la solicitud:

.

.

# After other imports
from pydantic import BaseModel
class Details(BaseModel):
    f_name: str
    l_name: str
    phone_number: int
app = FastAPI()

.
.
.

# After old routes
@app.post('/apiv3/')
def api3(data: Details):
    return {'message': data}

La función de ruta declara un parámetro «datos» del tipo «Detalles» definido anteriormente. Este modelo de «Detalles» se hereda del modelo base de Pydantic y ofrece validación de datos. Para probar esta ruta, estoy usando la extensión de código VS del cliente Thunder para hacer una solicitud de publicación a nuestra ruta API «/ apiv3 /»:

Envolviendo el modelo

Ahora que hemos eliminado los conceptos de FastAPI, es hora de integrar el modelo en la estructura de código FastAPI para realizar solicitudes de predicción. Crearemos una ruta «/ predicción» que tomará los datos enviados por el cuerpo de la solicitud del cliente y nuestra API devolverá la respuesta como un objeto JSON que contiene el resultado. Veamos primero el código y luego explicaré la mecánica:

import uvicorn

import pickle

from fastapi import FastAPI

from pydantic import BaseModel

class Music(BaseModel):

    acousticness: float

    danceability: float

    energy: float

    instrumentalness: float

    liveness: float

    speechiness: float

    tempo: float

    valence: float

app = FastAPI()




with open("./FastAPI Files/model.pkl", "rb") as f:

    model = pickle.load(f)

@app.get('/')

def index():

    return {'message': 'This is the homepage of the API '}

@app.post('/prediction')

def get_music_category(data: Music):

    received = data.dict()

    acousticness = received['acousticness']

    danceability = received['danceability']

    energy = received['energy']

    instrumentalness = received['instrumentalness']

    liveness = received['liveness']

    speechiness = received['speechiness']

    tempo = received['tempo']

    valence = received['valence']

    pred_name = model.predict([[acousticness, danceability, energy,

                                instrumentalness, liveness, speechiness, tempo, valence]]).tolist()[0]

    return {'prediction': pred_name}

if __name__ == '__main__':

    uvicorn.run(app, host="127.0.0.1", port=4000, debug=True)

1. Hemos creado una clase Music Model que define todos los parámetros de nuestro modelo ML. Todos los valores son de tipo flotante.
2. A continuación, cargamos el modelo despegándolo y guardando el modelo como «modelo». Este objeto modelo se utilizará para obtener las predicciones.
3. La función de ruta «/ predicción» declara un parámetro llamado «datos» del tipo de modelo «Música». Se puede acceder a este parámetro como un diccionario. El objeto de diccionario nos permitirá acceder a los valores de los parámetros como pares clave-valor.
4. Ahora, estamos guardando todos los valores de los parámetros enviados por el cliente. Estos valores ahora se alimentan a la función de predicción del modelo y tenemos nuestra predicción para los datos proporcionados.

Todos los códigos discutidos en este artículo están disponibles en mi repositorio de GitHub.

Prueba de la API del modelo

Ahora es el momento de probar la API. Puede probar la API a través de dos métodos:

Cliente Thunder / Cartero

Estamos usando el cliente thunder para enviar una solicitud de publicación a la ruta «/ prediction» con un cuerpo de solicitud. El cuerpo de la solicitud contiene los pares clave-valor de los parámetros y deberíamos esperar una respuesta JSON con el género musical clasificado.

Hacer una solicitud usando el módulo de solicitud

Si no desea utilizar las extensiones de VSCode o cualquier software de prueba de API, simplemente puede crear un programa Python separado para llamar a esta API. El módulo de solicitudes de Python permite llamar a las API.

import requests
import json

url = "<local-host-url>/prediction"

payload = json.dumps({
  "acousticness": 0.344719513,
  "danceability": 0.758067547,
  "energy": 0.323318405,
  "instrumentalness": 0.0166768347,
  "liveness": 0.0856723112,
  "speechiness": 0.0306624283,
  "tempo": 101.993,
  "valence": 0.443876228
})

headers = {
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

Reemplace «local-host-url» con su URL que obtiene después de ejecutar el archivo API del modelo FastAPI. La salida para esto es:

¡Viva! Ha creado correctamente una API para su modelo de aprendizaje automático mediante FastAPI.

Implementación en Heroku

Nuestra API está lista para ser utilizada por cualquier tipo de programa que realice una llamada a nuestra API. Pero no puede ejecutar este programa todo el día en su sistema local, eso es prácticamente imposible. Por lo tanto, debe implementar su servicio en una plataforma en la nube que pueda ejecutar su código y devolver las devoluciones.

Heroku es una de esas plataformas que ofrece alojamiento gratuito. Para implementar nuestra API en Heroku, necesitamos crear estos archivos:

1. Requirements.txt: Este archivo debe enumerar todos los módulos externos que usó en su aplicación. Para nuestro caso, fue FastAPI, scikit-learn, uvicorn y algunos otros módulos auxiliares.
2. runtime.txt: Este archivo especifica la versión de Python que Heroku instalará en su extremo.
3. Procfile: Este archivo es el archivo de interfaz entre nuestro código Python y la plataforma Heroku. Nota: la mayoría de ustedes no crea este archivo correctamente. No es un archivo de texto. Este archivo no tiene extensión. Para crear dichos archivos, puede usar GitHub add files o código Vs o cmd en Windows o terminal en Linux. Este archivo contendría el siguiente comando para FastAPI:

web: gunicorn -w 4 -k uvicorn.workers.UvicornWorker :app

Aquí, reemplace file_name con el nombre del archivo Python donde creó el código FastAPI. Después de este:

1. Coloque todos estos archivos (modelo, archivo Python, requirements.txt, Procfile) en un repositorio de GitHub
2. Inicie sesión en Heroku y cree una nueva aplicación. Conecta tu repositorio de GitHub
3. Haga clic en Implementar rama y su API estará en funcionamiento para que cualquiera la use con el enlace.

Bono: Generación de documentos

FastAPI tiene una característica especial. Genera automáticamente documentos para los puntos finales de API creados. Para acceder a estos documentos, simplemente visite el punto final «/ docs» y obtendrá una interfaz gráfica de usuario atractiva creada con Swagger y OpenAI. Ahora que hemos implementado el servicio, la captura de pantalla a continuación es de la aplicación Heroku Implementada. (Enlace: https://kivymlapp.herokuapp.com/)

Conclusión

En este artículo detallado, le presenté FastAPI, sus conceptos básicos, cómo crear el archivo API para el modelo de aprendizaje automático, cómo probar esta API y cómo implementar esta API en la plataforma Heroku. También vimos cómo acceder al punto final de documentos que FastAPI genera automáticamente.

En el próximo artículo, mostraré cómo usar la API creada en este artículo para crear una aplicación de predicción de música de Android usando Python y también convertiremos ese archivo de Python a APK.

Nota: puede utilizar este enlace, Enlace maestro a todos mis artículos en Internet, que se actualiza cada vez que publico un artículo nuevo para encontrar ese artículo.

Si usted tiene cualquier duda, consulta u oportunidad potencial, entonces puedes comunicarte conmigo a través de

1. Linkedin – en / kaustubh-gupta /

2. Twitter – @ Kaustubh1828

3. GitHub – kaustubhgupta

Relacionado