Instalación y Primer Endpoint con FastAPI

Concepto clave

FastAPI es un framework web moderno y rápido para construir APIs con Python 3.7+. Lo que lo hace ideal para Machine Learning en producción es su rendimiento comparable a NodeJS y Go, su tipado estático con Pydantic para validación automática, y su generación automática de documentación OpenAPI. Imagina que tu modelo ML es un chef experto: FastAPI es el restaurante que organiza las órdenes (requests), valida los ingredientes (datos de entrada), y sirve los platos (predicciones) de forma eficiente y documentada.

En el contexto de ML, FastAPI te permite exponer modelos como endpoints REST que pueden ser consumidos por aplicaciones web, móviles, o otros servicios. A diferencia de soluciones más simples como Flask, FastAPI incluye validación de datos out-of-the-box, lo que es crucial cuando recibes datos de usuarios o sistemas externos que podrían estar mal formados. Esto reduce errores en producción y mejora la confiabilidad de tu API.

Cómo funciona en la práctica

Para desplegar un modelo ML con FastAPI, sigues un flujo estructurado: primero instalas las dependencias, luego creas una aplicación FastAPI, defines endpoints usando decoradores, y finalmente ejecutas el servidor. Un endpoint típico recibe datos (por ejemplo, características de un cliente para un modelo de riesgo crediticio), los valida, pasa los datos al modelo entrenado, y devuelve la predicción en formato JSON.

Paso a paso: 1) Instalas FastAPI y un servidor ASGI como Uvicorn. 2) Creas un archivo main.py con tu aplicación. 3) Defines un modelo Pydantic para validar la entrada. 4) Cargas tu modelo ML (por ejemplo, con joblib o pickle). 5) Creas un endpoint con @app.post() que use el modelo. 6) Ejecutas el servidor y pruebas con herramientas como curl o Swagger UI.

Codigo en accion

Aquí un ejemplo básico de instalación y primer endpoint. Antes de comenzar, asegúrate de tener Python 3.7+ instalado.

# Instalación de dependencias
pip install fastapi uvicorn scikit-learn joblib

Luego, crea un archivo main.py con el siguiente contenido:

from fastapi import FastAPI
from pydantic import BaseModel
import joblib
import numpy as np

# Cargar un modelo ML preentrenado (ejemplo con un modelo simple)
# En la práctica, reemplaza esto con tu modelo real
try:
    model = joblib.load("modelo_ml.pkl")
except FileNotFoundError:
    # Modelo de ejemplo para demostración
    from sklearn.linear_model import LogisticRegression
    model = LogisticRegression()
    model.fit([[0, 1], [1, 0]], [0, 1])  # Datos dummy

app = FastAPI(title="API de ML en Producción")

# Definir modelo de datos de entrada con Pydantic
class InputData(BaseModel):
    feature1: float
    feature2: float

@app.get("/")
async def root():
    return {"message": "API de ML activa. Usa /predict para predicciones."}

@app.post("/predict")
async def predict(data: InputData):
    """Endpoint para hacer predicciones con el modelo ML."""
    # Convertir entrada a array numpy
    input_array = np.array([[data.feature1, data.feature2]])
    # Hacer predicción
    prediction = model.predict(input_array)
    # Devolver resultado
    return {"prediction": int(prediction[0]), "input_received": data.dict()}

# Para ejecutar: uvicorn main:app --reload

Errores comunes

• No validar datos de entrada: Usar tipos dinámicos sin Pydantic puede llevar a errores silenciosos. Siempre define modelos de datos para validación automática.
• Olvidar cargar el modelo ML correctamente: Asegúrate de que la ruta del archivo .pkl sea correcta y de que las dependencias del modelo (por ejemplo, versiones de scikit-learn) sean compatibles.
• No manejar excepciones en endpoints: Incluye bloques try-except para capturar errores como divisiones por cero o datos inválidos, y devuelve respuestas de error claras.
• Ejecutar en modo de desarrollo en producción: El flag --reload de Uvicorn es para desarrollo; en producción, usa un servidor ASGI como Gunicorn con Uvicorn workers.
• Ignorar la documentación automática: FastAPI genera docs en /docs y /redoc; revísalas para verificar que tus endpoints estén bien definidos.

Checklist de dominio

1. Instalé FastAPI y Uvicorn en un entorno virtual aislado.
2. Creé una aplicación FastAPI con al menos un endpoint GET y un endpoint POST.
3. Definí un modelo Pydantic para validar los datos de entrada en el endpoint POST.
4. Cargué un modelo ML (real o de ejemplo) y lo integré en el endpoint de predicción.
5. Ejecuté el servidor localmente y probé los endpoints con curl o la interfaz Swagger.
6. Validé que la documentación automática en /docs muestre correctamente mis endpoints.
7. Manejé al menos un caso de error (por ejemplo, datos faltantes) en el código.

Crear un endpoint de predicción para un modelo de clasificación de iris

En este ejercicio práctico, crearás un endpoint FastAPI que use el dataset de Iris para hacer predicciones. Sigue estos pasos:

1. Instala las dependencias necesarias: pip install fastapi uvicorn scikit-learn.
2. Crea un archivo llamado iris_api.py y escribe el código para una aplicación FastAPI.
3. Entrena un modelo simple de clasificación (por ejemplo, LogisticRegression) con el dataset de Iris de scikit-learn. Usa from sklearn.datasets import load_iris y from sklearn.linear_model import LogisticRegression.
4. Define un modelo Pydantic llamado IrisInput con cuatro campos float: sepal_length, sepal_width, petal_length, petal_width.
5. Crea un endpoint POST en /predict-iris que reciba datos en formato JSON, los valide con IrisInput, haga una predicción con el modelo entrenado, y devuelva la clase predicha (por ejemplo, 'setosa', 'versicolor', o 'virginica').
6. Ejecuta el servidor con uvicorn iris_api:app --reload y prueba el endpoint usando curl o la interfaz Swagger en http://localhost:8000/docs.
7. Opcional: Agrega un endpoint GET en / que devuelva un mensaje de bienvenida.

Pistas

• Usa load_iris() para cargar los datos y train_test_split para dividirlos si es necesario.
• En el modelo Pydantic, define los campos con tipos float y añade descripciones usando Field de pydantic para mejorar la documentación.
• Para devolver la clase predicha, mapea el número de predicción (0, 1, 2) a los nombres de las clases usando una lista como ['setosa', 'versicolor', 'virginica'].

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.