Concepto clave

FastAPI es un framework web moderno para construir APIs en Python, especialmente útil para desplegar modelos de Machine Learning en producción. A diferencia de frameworks tradicionales como Flask, FastAPI está diseñado específicamente para APIs RESTful con validación automática de datos usando Pydantic y generación automática de documentación con OpenAPI. Esto es crucial en ML porque los modelos requieren entradas estructuradas y predecibles para funcionar correctamente.

Imagina que tu modelo de ML es como un chef en un restaurante: necesita ingredientes específicos (datos de entrada) en un formato exacto para preparar el plato (predicción). FastAPI actúa como el maître que verifica que cada pedido del cliente (solicitud API) tenga los ingredientes correctos antes de enviarlo a la cocina. Si el cliente pide algo mal formado, el maître lo rechaza inmediatamente, evitando que el chef se confunda y produzca resultados erróneos.

Cómo funciona en la práctica

Para desplegar un modelo ML con FastAPI, sigues un flujo estructurado: primero defines un esquema Pydantic para validar los datos de entrada, luego cargas tu modelo entrenado (por ejemplo, con scikit-learn o TensorFlow), y finalmente creas un endpoint que recibe datos, los valida, pasa el modelo y devuelve la predicción. Este proceso asegura que tu API sea robusta y escalable.

Paso a paso: 1) Instala FastAPI y Uvicorn. 2) Crea un archivo main.py con una aplicación FastAPI. 3) Define una clase Pydantic para los datos de entrada (por ejemplo, características de un cliente para un modelo de churn). 4) Carga el modelo ML desde un archivo (como .pkl o .h5). 5) Implementa un endpoint POST que use el esquema y el modelo. 6) Ejecuta con Uvicorn para probar localmente.

Codigo en accion

Aquí un ejemplo funcional de un endpoint básico para un modelo de clasificación:

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

# Cargar modelo entrenado
model = joblib.load("modelo_churn.pkl")

app = FastAPI(title="API de ML para Churn")

# Esquema Pydantic para validación
class ClienteInput(BaseModel):
    edad: int
    salario: float
    antiguedad: int
    productos: int

@app.post("/predict")
async def predict_churn(cliente: ClienteInput):
    # Convertir entrada a array para el modelo
    features = np.array([[cliente.edad, cliente.salario, cliente.antiguedad, cliente.productos]])
    prediction = model.predict(features)
    probabilidad = model.predict_proba(features)[0][1]
    return {"churn": bool(prediction[0]), "probabilidad": float(probabilidad)}

# Para ejecutar: uvicorn main:app --reload

Antes: En Flask, tendrías que validar manualmente los datos, lo que aumenta el riesgo de errores. Después: Con FastAPI, Pydantic maneja la validación automáticamente, y la documentación en /docs se genera sin código extra.

Errores comunes

No validar rangos de datos: Pydantic valida tipos, pero no rangos. Por ejemplo, un modelo puede esperar edades entre 18-100; añade validación personalizada en el esquema.
Cargar el modelo en cada solicitud: Esto ralentiza la API. Carga el modelo una vez al inicio, como en el ejemplo anterior.
Ignorar el manejo de errores: Si el modelo falla, la API debe devolver un error claro. Usa excepciones HTTP como HTTPException de FastAPI.
No versionar la API: Al actualizar el modelo, los clientes pueden romperse. Incluye versión en la ruta, por ejemplo, /v1/predict.
Olvidar la serialización: Los objetos NumPy o custom no son JSON-serializables; convierte a tipos nativos de Python antes de retornar.

Checklist de dominio

¿Puedes definir un esquema Pydantic con validación básica y personalizada?
¿Sabes cargar un modelo ML desde un archivo y reutilizarlo en múltiples solicitudes?
¿Implementas endpoints con métodos HTTP correctos (POST para predicciones)?
¿Manejas errores comunes como entradas inválidas o fallos del modelo?
¿Generas documentación automática y la pruebas en /docs?
¿Conviertes salidas del modelo a formatos JSON-amigables?
¿Planificas la escalabilidad, por ejemplo, con carga diferida del modelo?

Implementa un endpoint FastAPI para un modelo de regresión

En este ejercicio, crearás una API para un modelo de ML que predice precios de casas basado en características como metros cuadrados y número de habitaciones. Sigue estos pasos:

Prepara el entorno: Instala FastAPI, Uvicorn, scikit-learn y pydantic usando pip.
Descarga o genera un modelo simple de regresión lineal (puedes usar sklearn.linear_model.LinearRegression y guardarlo con joblib).
Crea un archivo app.py y define un esquema Pydantic llamado CasaInput con campos: metros_cuadrados (float), habitaciones (int), ano_construccion (int). Añade validación para que metros_cuadrados sea mayor a 0.
Carga el modelo en la aplicación FastAPI y crea un endpoint POST en /predict-precio que reciba datos JSON, los valide, haga la predicción y devuelva el precio estimado como un número float.
Ejecuta la API con uvicorn app:app --reload y prueba con una herramienta como curl o la interfaz en /docs.

Pistas

Usa @app.post("/predict-precio") para definir el endpoint.
Recuerda convertir la entrada a un array 2D para scikit-learn, por ejemplo, np.array([[metros, habitaciones, ano]]).
Si el modelo no está entrenado, crea uno de ejemplo con datos ficticios para probar la API.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Quiz: Fundamentos de FastAPI y ML

Quiz Interactivo