Implemente un modelo YOLO pre-entrenado con Ultralytics en Vertex AI para la inferencia

Esta guía te mostrará cómo contenerizar un modelo YOLO11 pre-entrenado con Ultralytics, construir un servidor de inferencia FastAPI para él e implementar el modelo con el servidor de inferencia en Google Cloud Vertex AI. La implementación de ejemplo cubrirá el caso de uso de detección de objetos para YOLO11, pero los mismos principios se aplicarán al uso de otros modos YOLO.

Antes de comenzar, deberás crear un proyecto de Google Cloud Platform (GCP). Obtienes $300 en créditos de GCP para usar de forma gratuita como nuevo usuario, y esta cantidad es suficiente para probar una configuración en ejecución que luego puedes extender para cualquier otro caso de uso de YOLO11, incluyendo el entrenamiento, o la inferencia por lotes y en streaming.

Qué aprenderá

1. Crear un backend de inferencia para el modelo Ultralytics YOLO11 usando FastAPI.
2. Crear un repositorio de GCP Artifact Registry para almacenar tu imagen Docker.
3. Construir y subir la imagen Docker con el modelo a Artifact Registry.
4. Importar tu modelo en Vertex AI.
5. Cree un punto de conexión Vertex AI e implemente el modelo.

Prerrequisitos

1. Instale Docker en su máquina.
2. Instale el Google Cloud SDK y autentíquese para usar la CLI de gcloud.
3. Se recomienda encarecidamente que consulte la Guía de inicio rápido de Docker para Ultralytics, ya que deberá ampliar una de las imágenes oficiales de Docker de Ultralytics mientras sigue esta guía.

1. Crear un backend de inferencia con FastAPI

Primero, debe crear una aplicación FastAPI que sirva las solicitudes de inferencia del modelo YOLO11. Esta aplicación gestionará la carga del modelo, el preprocesamiento de imágenes y la lógica de inferencia (predicción).

Fundamentos de cumplimiento de Vertex AI

Vertex AI espera que su contenedor implemente dos puntos de conexión específicos:

1. Salud punto de conexión (/health): Debe devolver el estado HTTP 200 OK cuando el servicio esté listo.

2. Predecir punto de conexión (/predict): Acepta solicitudes de predicción estructuradas con codificación base64 de imágenes y parámetros opcionales. Límites de tamaño de la carga útil se aplican según el tipo de punto de conexión.

   Las cargas útiles de la solicitud para el /predict punto de conexión deben seguir esta estructura JSON:

   {
       "instances": [{ "image": "base64_encoded_image" }],
       "parameters": { "confidence": 0.5 }
   }
   

Estructura de carpetas del proyecto

La mayor parte de nuestra compilación se realizará dentro del contenedor Docker, y Ultralytics también cargará un modelo YOLO11 pre-entrenado, por lo que puede mantener la estructura de carpetas local simple:

YOUR_PROJECT/
├── src/
│   ├── __init__.py
│   ├── app.py              # Core YOLO11 inference logic
│   └── main.py             # FastAPI inference server
├── tests/
├── .env                    # Environment variables for local development
├── Dockerfile              # Container configuration
├── LICENSE                 # AGPL-3.0 License
└── pyproject.toml          # Python dependencies and project config

Crear pyproject.toml con dependencias

Para gestionar cómodamente su proyecto, cree un pyproject.toml archivo con las siguientes dependencias:

[project]
name = "YOUR_PROJECT_NAME"
version = "0.0.1"
description = "YOUR_PROJECT_DESCRIPTION"
requires-python = ">=3.10,<3.13"
dependencies = [
   "ultralytics>=8.3.0",
   "fastapi[all]>=0.89.1",
   "uvicorn[standard]>=0.20.0",
   "pillow>=9.0.0",
]

[build-system]
requires = ["setuptools>=61.0"]
build-backend = "setuptools.build_meta"

• uvicorn se utilizará para ejecutar el servidor FastAPI.
• pillow se utilizará para el procesamiento de imágenes, pero no está limitado solo a imágenes PIL; Ultralytics admite muchos otros formatos..

Crear lógica de inferencia con Ultralytics YOLO11

Ahora que tiene la estructura del proyecto y las dependencias configuradas, puede implementar la lógica central de inferencia de YOLO11. Cree un src/app.py archivo que gestione la carga del modelo, el procesamiento de imágenes y la predicción, utilizando la API de python de Ultralytics.

# src/app.py

from ultralytics import YOLO

# Model initialization and readiness state
model_yolo = None
_model_ready = False


def _initialize_model():
    """Initialize the YOLO model."""
    global model_yolo, _model_ready

    try:
        # Use pre-trained YOLO11n model from Ultralytics base image
        model_yolo = YOLO("yolo11n.pt")
        _model_ready = True

    except Exception as e:
        print(f"Error initializing YOLO model: {e}")
        _model_ready = False
        model_yolo = None


# Initialize model on module import
_initialize_model()


def is_model_ready() -> bool:
    """Check if the model is ready for inference."""
    return _model_ready and model_yolo is not None

Esto cargará el modelo una vez cuando se inicie el contenedor, y el modelo se compartirá entre todas las solicitudes. Si su modelo va a manejar una carga de inferencia pesada, se recomienda seleccionar un tipo de máquina con más memoria al importar un modelo en Vertex AI en un paso posterior.

A continuación, cree dos funciones de utilidad para el procesamiento de imágenes de entrada y salida con pillow. YOLO11 admite imágenes PIL de forma nativa.

def get_image_from_bytes(binary_image: bytes) -> Image.Image:
    """Convert image from bytes to PIL RGB format."""
    input_image = Image.open(io.BytesIO(binary_image)).convert("RGB")
    return input_image

def get_bytes_from_image(image: Image.Image) -> bytes:
    """Convert PIL image to bytes."""
    return_image = io.BytesIO()
    image.save(return_image, format="JPEG", quality=85)
    return_image.seek(0)
    return return_image.getvalue()

Finalmente, implemente la función run_inference que gestionará la detección de objetos. En este ejemplo, extraeremos los cuadros delimitadores, los nombres de las clases y las puntuaciones de confianza de las predicciones del modelo. La función devolverá un diccionario con las detecciones y los resultados sin procesar para su posterior procesamiento o anotación.

def run_inference(input_image: Image.Image, confidence_threshold: float = 0.5) -> Dict[str, Any]:
    """Run inference on an image using YOLO11n model."""
    global model_yolo

    # Check if model is ready
    if not is_model_ready():
        print("Model not ready for inference")
        return {"detections": [], "results": None}

    try:
        # Make predictions and get raw results
        results = model_yolo.predict(
            imgsz=640, source=input_image, conf=confidence_threshold, save=False, augment=False, verbose=False
        )

        # Extract detections (bounding boxes, class names, and confidences)
        detections = []
        if results and len(results) > 0:
            result = results[0]
            if result.boxes is not None and len(result.boxes.xyxy) > 0:
                boxes = result.boxes

                # Convert tensors to numpy for processing
                xyxy = boxes.xyxy.cpu().numpy()
                conf = boxes.conf.cpu().numpy()
                cls = boxes.cls.cpu().numpy().astype(int)

                # Create detection dictionaries
                for i in range(len(xyxy)):
                    detection = {
                        "xmin": float(xyxy[i][0]),
                        "ymin": float(xyxy[i][1]),
                        "xmax": float(xyxy[i][2]),
                        "ymax": float(xyxy[i][3]),
                        "confidence": float(conf[i]),
                        "class": int(cls[i]),
                        "name": model_yolo.names.get(int(cls[i]), f"class_{int(cls[i])}"),
                    }
                    detections.append(detection)

        return {
            "detections": detections,
            "results": results,  # Keep raw results for annotation
        }
    except Exception as e:
        # If there's an error, return empty structure
        print(f"Error in YOLO detection: {e}")
        return {"detections": [], "results": None}

Opcionalmente, puede agregar una función para anotar la imagen con cuadros delimitadores y etiquetas utilizando el método de trazado incorporado de Ultralytics. Esto será útil si desea devolver imágenes anotadas en la respuesta de predicción.

def get_annotated_image(results: list) -> Image.Image:
    """Get annotated image using Ultralytics built-in plot method."""
    if not results or len(results) == 0:
        raise ValueError("No results provided for annotation")

    result = results[0]
    # Use Ultralytics built-in plot method with PIL output
    return result.plot(pil=True)

Crear servidor de inferencia HTTP con FastAPI

Ahora que tiene la lógica central de inferencia de YOLO11, puede crear una aplicación FastAPI para servirla. Esto incluirá los puntos finales de verificación de estado y predicción requeridos por Vertex AI.

Primero, agregue las importaciones y configure el registro para Vertex AI. Debido a que Vertex AI trata stderr como salida de error, tiene sentido canalizar los registros a stdout.

import sys

from loguru import logger

# Configure logger
logger.remove()
logger.add(
    sys.stdout,
    colorize=True,
    format="<green>{time:HH:mm:ss}</green> | <level>{message}</level>",
    level=10,
)
logger.add("log.log", rotation="1 MB", level="DEBUG", compression="zip")

Para una conformidad completa con Vertex AI, defina los puntos finales requeridos en las variables de entorno y establezca el límite de tamaño para las solicitudes. Se recomienda utilizar puntos finales privados de Vertex AI para implementaciones de producción. De esta manera, tendrá un límite de carga útil de solicitud más alto (10 MB en lugar de 1,5 MB para los puntos finales públicos), junto con una seguridad robusta y control de acceso.

# Vertex AI environment variables
AIP_HTTP_PORT = int(os.getenv("AIP_HTTP_PORT", "8080"))
AIP_HEALTH_ROUTE = os.getenv("AIP_HEALTH_ROUTE", "/health")
AIP_PREDICT_ROUTE = os.getenv("AIP_PREDICT_ROUTE", "/predict")

# Request size limit (10 MB for private endpoints, 1.5 MB for public)
MAX_REQUEST_SIZE = 10 * 1024 * 1024  # 10 MB in bytes

Agregue dos modelos Pydantic para validar sus solicitudes y respuestas:

# Pydantic models for request/response
class PredictionRequest(BaseModel):
    instances: list
    parameters: Optional[Dict[str, Any]] = None


class PredictionResponse(BaseModel):
    predictions: list

Agregue el punto final de verificación de estado para verificar la preparación de su modelo. Esto es importante para Vertex AI, ya que sin una verificación de estado dedicada, su orquestador hará ping a sockets aleatorios y no podrá determinar si el modelo está listo para la inferencia. Su verificación debe devolver 200 OK para éxito y 503 Service Unavailable para fallo:

# Health check endpoint
@app.get(AIP_HEALTH_ROUTE, status_code=status.HTTP_200_OK)
def health_check():
    """Health check endpoint for Vertex AI."""
    if not is_model_ready():
        raise HTTPException(status_code=503, detail="Model not ready")
    return {"status": "healthy"}

Ahora tiene todo para implementar el punto final de predicción que gestionará las solicitudes de inferencia. Aceptará un archivo de imagen, ejecutará la inferencia y devolverá los resultados. Tenga en cuenta que la imagen debe estar codificada en base64, lo que aumenta adicionalmente el tamaño de la carga útil hasta en un 33%.

@app.post(AIP_PREDICT_ROUTE, response_model=PredictionResponse)
async def predict(request: PredictionRequest):
    """Prediction endpoint for Vertex AI."""
    try:
        predictions = []

        for instance in request.instances:
            if isinstance(instance, dict):
                if "image" in instance:
                    image_data = base64.b64decode(instance["image"])
                    input_image = get_image_from_bytes(image_data)
                else:
                    raise HTTPException(status_code=400, detail="Instance must contain 'image' field")
            else:
                raise HTTPException(status_code=400, detail="Invalid instance format")

            # Extract YOLO11 parameters if provided
            parameters = request.parameters or {}
            confidence_threshold = parameters.get("confidence", 0.5)
            return_annotated_image = parameters.get("return_annotated_image", False)

            # Run inference with YOLO11n model
            result = run_inference(input_image, confidence_threshold=confidence_threshold)
            detections_list = result["detections"]

            # Format predictions for Vertex AI
            detections = []
            for detection in detections_list:
                formatted_detection = {
                    "class": detection["name"],
                    "confidence": detection["confidence"],
                    "bbox": {
                        "xmin": detection["xmin"],
                        "ymin": detection["ymin"],
                        "xmax": detection["xmax"],
                        "ymax": detection["ymax"],
                    },
                }
                detections.append(formatted_detection)

            # Build prediction response
            prediction = {"detections": detections, "detection_count": len(detections)}

            # Add annotated image if requested and detections exist
            if (
                return_annotated_image
                and result["results"]
                and result["results"][0].boxes is not None
                and len(result["results"][0].boxes) > 0
            ):
                import base64

                annotated_image = get_annotated_image(result["results"])
                img_bytes = get_bytes_from_image(annotated_image)
                prediction["annotated_image"] = base64.b64encode(img_bytes).decode("utf-8")

            predictions.append(prediction)

        logger.info(
            f"Processed {len(request.instances)} instances, found {sum(len(p['detections']) for p in predictions)} total detections"
        )

        return PredictionResponse(predictions=predictions)

    except HTTPException:
        # Re-raise HTTPException as-is (don't catch and convert to 500)
        raise
    except Exception as e:
        logger.error(f"Prediction error: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")

Finalmente, agregue el punto de entrada de la aplicación para ejecutar el servidor FastAPI.

if __name__ == "__main__":
    import uvicorn

    logger.info(f"Starting server on port {AIP_HTTP_PORT}")
    logger.info(f"Health check route: {AIP_HEALTH_ROUTE}")
    logger.info(f"Predict route: {AIP_PREDICT_ROUTE}")
    uvicorn.run(app, host="0.0.0.0", port=AIP_HTTP_PORT)

Ahora tiene una aplicación FastAPI completa que puede servir solicitudes de inferencia de YOLO11. Puede probarla localmente instalando las dependencias y ejecutando el servidor, por ejemplo, con uv.

# Install dependencies
uv pip install -e .

# Run the FastAPI server directly
uv run src/main.py

Para probar el servidor, puede consultar ambos /health y /predict endpoints usando cURL. Coloca una imagen de prueba en la tests carpeta. Luego, en tu Terminal, ejecuta los siguientes comandos:

# Test health endpoint
curl http://localhost:8080/health

# Test predict endpoint with base64 encoded image
curl -X POST -H "Content-Type: application/json" -d "{\"instances\": [{\"image\": \"$(base64 -i tests/test_image.jpg)\"}]}" http://localhost:8080/predict

Deberías recibir una respuesta JSON con los objetos detectados. En tu primera solicitud, espera un breve retraso, ya que Ultralytics necesita extraer y cargar el modelo YOLO11.

2. Extender la imagen Docker de Ultralytics con tu aplicación

Ultralytics proporciona varias imágenes de Docker que puedes usar como base para la imagen de tu aplicación. Docker instalará Ultralytics y los controladores de GPU necesarios.

Para utilizar todas las capacidades de los modelos YOLO de Ultralytics, debes seleccionar la imagen optimizada para CUDA para la inferencia en GPU. Sin embargo, si la inferencia en CPU es suficiente para tu tarea, puedes ahorrar recursos informáticos seleccionando también la imagen solo para CPU:

• Dockerfile: Imagen optimizada para CUDA para el entrenamiento y la inferencia YOLO11 con una o varias GPU.
• Dockerfile-cpu: Imagen solo para CPU para la inferencia YOLO11.

Crear una imagen Docker para tu aplicación

Crea un Dockerfile en la raíz de tu proyecto con el siguiente contenido:

# Extends official Ultralytics Docker image for YOLO11
FROM ultralytics/ultralytics:latest

ENV PYTHONUNBUFFERED=1 \
    PYTHONDONTWRITEBYTECODE=1

# Install FastAPI and dependencies
RUN uv pip install fastapi[all] uvicorn[standard] loguru

WORKDIR /app
COPY src/ ./src/
COPY pyproject.toml ./

# Install the application package
RUN uv pip install -e .

RUN mkdir -p /app/logs
ENV PYTHONPATH=/app/src

# Port for Vertex AI
EXPOSE 8080

# Start the inference server
ENTRYPOINT ["python", "src/main.py"]

En el ejemplo, la imagen oficial de Docker de Ultralytics ultralytics:latest se utiliza como base. Ya contiene el modelo YOLO11 y todas las dependencias necesarias. El punto de entrada del servidor es el mismo que usamos para probar la aplicación FastAPI localmente.

Construir y probar la imagen Docker

Ahora puedes construir la imagen de Docker con el siguiente comando:

docker build --platform linux/amd64 -t IMAGE_NAME:IMAGE_VERSION .

Reemplaza IMAGE_NAME y IMAGE_VERSION con los valores que desees, por ejemplo, yolo11-fastapi:0.1. Ten en cuenta que debes construir la imagen para la linux/amd64 arquitectura si vas a realizar la implementación en Vertex AI. El --platform parámetro debe establecerse explícitamente si estás construyendo la imagen en un Apple Silicon Mac o cualquier otra arquitectura que no sea x86.

Una vez que se complete la construcción de la imagen, puedes probar la imagen de Docker localmente:

docker run --platform linux/amd64 -p 8080:8080 IMAGE_NAME:IMAGE_VERSION

Tu contenedor Docker ahora está ejecutando un servidor FastAPI en el puerto 8080, listo para aceptar solicitudes de inferencia. Puedes probar tanto el /health como el /predict endpoint con los mismos comandos cURL que antes:

# Test health endpoint
curl http://localhost:8080/health

# Test predict endpoint with base64 encoded image
curl -X POST -H "Content-Type: application/json" -d "{\"instances\": [{\"image\": \"$(base64 -i tests/test_image.jpg)\"}]}" http://localhost:8080/predict

3. Subir la imagen Docker a GCP Artifact Registry

Para importar tu modelo en contenedor en Vertex AI, debes subir la imagen de Docker a Google Cloud Artifact Registry. Si aún no tienes un repositorio de Artifact Registry, deberás crear uno primero.

Crear un repositorio en Google Cloud Artifact Registry

Abre la página de Artifact Registry en Google Cloud Console. Si estás utilizando Artifact Registry por primera vez, es posible que se te pida que habilites primero la API de Artifact Registry.

1. Selecciona Crear repositorio.
2. Introduce el nombre de tu repositorio. Selecciona la región deseada y utiliza la configuración predeterminada para otras opciones, a menos que necesites cambiarlas específicamente.

1. Una vez que se crea el repositorio, guarde su PROJECT_ID, ubicación (región) y nombre del repositorio en su almacén de secretos o .env archivo. Los necesitará más adelante para etiquetar y enviar su imagen de Docker al Artifact Registry.

Autenticar Docker en Artifact Registry

Autentique su cliente Docker en el repositorio de Artifact Registry que acaba de crear. Ejecute el siguiente comando en su terminal:

gcloud auth configure-docker YOUR_REGION-docker.pkg.dev

Etiquetar y subir tu imagen a Artifact Registry

Etiquete y envíe la imagen de Docker a Google Artifact Registry.

Etiquete su imagen con la URL del repositorio de Artifact Registry. Reemplace los marcadores de posición con los valores que guardó anteriormente.

docker tag IMAGE_NAME:IMAGE_VERSION YOUR_REGION-docker.pkg.dev/YOUR_PROJECT_ID/YOUR_REPOSITORY_NAME/IMAGE_NAME:IMAGE_VERSION

Envíe la imagen etiquetada al repositorio de Artifact Registry.

docker push YOUR_REGION-docker.pkg.dev/YOUR_PROJECT_ID/YOUR_REPOSITORY_NAME/IMAGE_NAME:IMAGE_VERSION

Espere a que se complete el proceso. Ahora debería ver la imagen en su repositorio de Artifact Registry.

Para obtener instrucciones más específicas sobre cómo trabajar con imágenes en Artifact Registry, consulte la documentación de Artifact Registry: Enviar y extraer imágenes.

4. Importar tu modelo en Vertex AI

Usando la imagen de Docker que acaba de enviar, ahora puede importar el modelo en Vertex AI.

1. En el menú de navegación de Google Cloud, vaya a Vertex AI > Model Registry. Alternativamente, busque "Vertex AI" en la barra de búsqueda en la parte superior de Google Cloud Console.

   

2. Haga clic en Importar.

3. Seleccione Importar como un nuevo modelo.
4. Seleccione la región. Puede elegir la misma región que su repositorio de Artifact Registry, pero su selección debe estar dictada por la disponibilidad de tipos de máquina y cuotas en su región.

5. Seleccione Importar un contenedor de modelo existente.

   

6. En el campo Imagen del contenedor, busque el repositorio de Artifact Registry que creó anteriormente y seleccione la imagen que acaba de enviar.

7. Desplácese hacia abajo hasta la sección Variables de entorno e ingrese los endpoints de predict y health, y el puerto que definió en su aplicación FastAPI.

   

8. Haga clic en Importar. Vertex AI tardará varios minutos en registrar el modelo y prepararlo para la implementación. Recibirá una notificación por correo electrónico una vez que se complete la importación.

5. Crear un Endpoint de Vertex AI e implementar tu modelo

Para implementar un modelo, necesita crear un Endpoint en Vertex AI.

1. En el menú de navegación de Vertex AI, vaya a Endpoints. Seleccione la región que utilizó al importar su modelo. Haga clic en Crear.

1. Ingrese el nombre del Endpoint.
2. Para el acceso, Vertex AI recomienda utilizar endpoints privados de Vertex AI. Además de los beneficios de seguridad, obtiene un límite de carga útil más alto si selecciona un endpoint privado, sin embargo, deberá configurar su red VPC y las reglas de firewall para permitir el acceso al endpoint. Consulte la documentación de Vertex AI para obtener más instrucciones sobre endpoints privados.
3. Haga clic en Continuar.
4. En el diálogo de configuración del modelo, seleccione el modelo que importó anteriormente. Ahora puede configurar el tipo de máquina, la memoria y la configuración de la GPU para su modelo. Asigne suficiente memoria si espera altas cargas de inferencia para asegurarse de que no haya cuellos de botella de E/S para el rendimiento adecuado de YOLO11.

5. En Tipo de acelerador, seleccione el tipo de GPU que desea utilizar para la inferencia. Si no está seguro de qué GPU seleccionar, puede comenzar con NVIDIA T4, que es compatible con CUDA.

   Cuotas de región y tipo de máquina

   Recuerde que ciertas regiones tienen cuotas de cómputo muy limitadas, por lo que es posible que no pueda seleccionar ciertos tipos de máquinas o GPU en su región. Si esto es crítico, cambie la región de su implementación a una con una cuota mayor. Encuentre más información en la documentación oficial de Vertex AI: Cuotas y límites de Vertex AI.

6. Una vez que se selecciona el tipo de máquina, puede hacer clic en Continuar. En este punto, puede optar por habilitar la supervisión del modelo en Vertex AI, un servicio adicional que rastreará el rendimiento de su modelo y proporcionará información sobre su comportamiento. Esto es opcional e incurre en costos adicionales, así que seleccione según sus necesidades. Haga clic en Crear.

Vertex AI tardará varios minutos (hasta 30 minutos en algunas regiones) en implementar el modelo. Recibirá una notificación por correo electrónico una vez que se complete la implementación.

6. Probar tu modelo implementado

Una vez que se complete la implementación, Vertex AI le proporcionará una interfaz API de muestra para probar su modelo.

Para probar la inferencia remota, puede utilizar el comando cURL proporcionado o crear otra biblioteca de cliente de python que envíe solicitudes al modelo implementado. Recuerde que debe codificar su imagen a base64 antes de enviarla al /predict endpoint.

¡Felicitaciones! Ha implementado con éxito un modelo YOLO11 pre-entrenado con Ultralytics en Google Cloud Vertex AI.

Preguntas frecuentes

¿Puedo usar modelos Ultralytics YOLO en Vertex AI sin Docker?

Sí, sin embargo, primero deberá exportar el modelo a un formato compatible con Vertex AI, como TensorFlow, Scikit-learn o XGBoost. Google Cloud proporciona una guía para ejecutar .pt modelos en Vertex con una descripción completa del proceso de conversión: Ejecutar modelos PyTorch en Vertex AI.

Tenga en cuenta que la configuración resultante se basará únicamente en la capa de servicio estándar de Vertex AI y no admitirá las funciones avanzadas del framework de Ultralytics. Dado que Vertex AI es totalmente compatible con los modelos en contenedores y puede escalarlos automáticamente según la configuración de su implementación, le permite aprovechar todas las capacidades de los modelos YOLO de Ultralytics sin necesidad de convertirlos a un formato diferente.

¿Por qué FastAPI es una buena opción para servir inferencia de YOLO11?

FastAPI proporciona un alto rendimiento para las cargas de trabajo de inferencia. La compatibilidad asíncrona permite manejar múltiples solicitudes concurrentes sin bloquear el hilo principal, lo cual es importante al servir modelos de visión artificial.

La validación automática de solicitudes/respuestas con FastAPI reduce los errores de tiempo de ejecución en los servicios de inferencia en producción. Esto es particularmente valioso para las API de detección de objetos donde la consistencia del formato de entrada es crítica.

FastAPI añade una sobrecarga computacional mínima a tu pipeline de inferencia, dejando más recursos disponibles para la ejecución del modelo y las tareas de procesamiento de imágenes.

FastAPI también es compatible con SSE (Eventos Enviados por el Servidor), lo cual es útil para escenarios de inferencia de streaming.

¿Por qué tengo que seleccionar una región tantas veces?

En realidad, esta es una característica de versatilidad de Google Cloud Platform, donde necesitas seleccionar una región para cada servicio que utilices. Para la tarea de implementar un modelo contenedorizado en Vertex AI, la selección de región más importante es la del Registro de Modelos. Esta determinará la disponibilidad de tipos de máquinas y cuotas para la implementación de tu modelo.

Además, si vas a ampliar la configuración y almacenar datos de predicción o resultados en Cloud Storage o BigQuery, tendrás que utilizar la misma región que para el Registro de Modelos, para minimizar la latencia y garantizar un alto rendimiento para el acceso a los datos.

📅 Creado hace 1 mes ✏️ Actualizado hace 1 mes

Comentarios