Déployez un modèle YOLO pré-entraîné avec Ultralytics sur Vertex AI pour l'inférence

Ce guide vous montrera comment conteneuriser un modèle YOLO11 pré-entraîné avec Ultralytics, construire un serveur d'inférence FastAPI pour celui-ci, et déployer le modèle avec le serveur d'inférence sur Google Cloud Vertex AI. L'implémentation d'exemple couvrira le cas d'utilisation de la détection d'objets pour YOLO11, mais les mêmes principes s'appliqueront à l'utilisation d'autres modes YOLO.

Avant de commencer, vous devrez créer un projet Google Cloud Platform (GCP). Vous obtenez 300 $ de crédits GCP à utiliser gratuitement en tant que nouvel utilisateur, et ce montant est suffisant pour tester une configuration en cours d'exécution que vous pourrez ensuite étendre à tout autre cas d'utilisation de YOLO11, y compris l'entraînement, ou l'inférence par lots et en continu.

Ce que vous allez apprendre

1. Créer un backend d'inférence pour le modèle Ultralytics YOLO11 en utilisant FastAPI.
2. Créer un dépôt GCP Artifact Registry pour stocker votre image Docker.
3. Construire et envoyer l'image Docker avec le modèle vers Artifact Registry.
4. Importer votre modèle dans Vertex AI.
5. Créez un point de terminaison Vertex AI et déployez le modèle.

Prérequis

1. Installez Docker sur votre machine.
2. Installez le Google Cloud SDK et authentifiez-vous pour utiliser la CLI gcloud.
3. Il est fortement recommandé de consulter le Guide de démarrage rapide Docker pour Ultralytics, car vous devrez étendre l'une des images Docker officielles d'Ultralytics en suivant ce guide.

1. Créer un backend d'inférence avec FastAPI

Tout d'abord, vous devez créer une application FastAPI qui servira les requêtes d'inférence du modèle YOLO11. Cette application gérera le chargement du modèle, le prétraitement des images et la logique d'inférence (prédiction).

Principes fondamentaux de la conformité de Vertex AI

Vertex AI s'attend à ce que votre conteneur implémente deux points de terminaison spécifiques :

1. Santé point de terminaison (/health) : Doit renvoyer le statut HTTP 200 OK lorsque le service est prêt.

2. Prédire point de terminaison (/predict) : Accepte les requêtes de prédiction structurées avec des images codées en base64 et des paramètres optionnels. Limites de taille de la charge utile s'appliquent en fonction du type de point de terminaison.

   Les charges utiles de requête pour le point de terminaison /predict doivent suivre cette structure JSON :

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

Structure du dossier de projet

L'essentiel de notre build se déroulera à l'intérieur du conteneur Docker, et Ultralytics chargera également un modèle YOLO11 pré-entraîné, vous pouvez donc conserver une structure de dossiers locale 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

Créer un fichier pyproject.toml avec les dépendances

Pour gérer facilement votre projet, créez un pyproject.toml fichier avec les dépendances suivantes :

[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 sera utilisé pour exécuter le serveur FastAPI.
• pillow sera utilisé pour le traitement d'images, mais vous n'êtes pas limité aux images PIL uniquement — Ultralytics prend en charge de nombreux autres formats..

Créer une logique d'inférence avec Ultralytics YOLO11

Maintenant que la structure du projet et les dépendances sont configurées, vous pouvez implémenter la logique d'inférence YOLO11 principale. Créez un src/app.py fichier qui gérera le chargement du modèle, le traitement de l'image et la prédiction, en utilisant l'API Python 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

Cela chargera le modèle une fois au démarrage du conteneur, et le modèle sera partagé entre toutes les requêtes. Si votre modèle doit gérer une charge d'inférence importante, il est recommandé de sélectionner un type de machine avec plus de mémoire lors de l'importation d'un modèle dans Vertex AI à une étape ultérieure.

Ensuite, créez deux fonctions utilitaires pour le traitement des images d'entrée et de sortie avec pillow. YOLO11 prend en charge nativement les images PIL.

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()

Enfin, implémentez la run_inference fonction qui gérera la détection d'objets. Dans cet exemple, nous extrairons les boîtes englobantes, les noms de classe et les scores de confiance à partir des prédictions du modèle. La fonction renverra un dictionnaire avec les détections et les résultats bruts pour un traitement ou une annotation ultérieure.

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}

En option, vous pouvez ajouter une fonction pour annoter l'image avec des boîtes englobantes et des étiquettes en utilisant la méthode de tracé intégrée d'Ultralytics. Cela sera utile si vous souhaitez renvoyer des images annotées dans la réponse de prédiction.

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)

Créer un serveur d'inférence HTTP avec FastAPI

Maintenant que vous avez la logique d'inférence YOLO11 principale, vous pouvez créer une application FastAPI pour la servir. Cela inclura les points de terminaison de contrôle de santé et de prédiction requis par Vertex AI.

Tout d'abord, ajoutez les importations et configurez la journalisation pour Vertex AI. Étant donné que Vertex AI traite stderr comme une sortie d'erreur, il est logique de rediriger les journaux vers 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")

Pour une conformité complète avec Vertex AI, définissez les points de terminaison requis dans les variables d'environnement et définissez la limite de taille pour les requêtes. Il est recommandé d'utiliser des points de terminaison Vertex AI privés pour les déploiements en production. De cette façon, vous aurez une limite de charge utile de requête plus élevée (10 Mo au lieu de 1,5 Mo pour les points de terminaison publics), ainsi qu'une sécurité et un contrôle d'accès robustes.

# 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

Ajoutez deux modèles Pydantic pour valider vos requêtes et vos réponses :

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


class PredictionResponse(BaseModel):
    predictions: list

Ajoutez le point de terminaison de contrôle de santé pour vérifier la disponibilité de votre modèle. Ceci est important pour Vertex AI, car sans un contrôle de santé dédié, son orchestrateur effectuera un ping sur des sockets aléatoires et ne pourra pas déterminer si le modèle est prêt pour l'inférence. Votre contrôle doit renvoyer 200 OK en cas de succès et 503 Service Unavailable en cas d'échec :

# 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"}

Vous avez maintenant tout ce qu'il faut pour implémenter le point de terminaison de prédiction qui gérera les requêtes d'inférence. Il acceptera un fichier image, exécutera l'inférence et renverra les résultats. Notez que l'image doit être encodée en base64, ce qui augmente en plus la taille de la charge utile jusqu'à 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)}")

Enfin, ajoutez le point d'entrée de l'application pour exécuter le serveur 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)

Vous disposez maintenant d'une application FastAPI complète qui peut servir les requêtes d'inférence YOLO11. Vous pouvez la tester localement en installant les dépendances et en exécutant le serveur, par exemple, avec uv.

# Install dependencies
uv pip install -e .

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

Pour tester le serveur, vous pouvez interroger les deux /health et /predict endpoints en utilisant cURL. Placez une image de test dans le tests dossier. Ensuite, dans votre Terminal, exécutez les commandes suivantes :

# 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

Vous devriez recevoir une réponse JSON avec les objets détectés. Lors de votre première requête, prévoyez un court délai, car Ultralytics doit extraire et charger le modèle YOLO11.

2. Étendre l'image Docker Ultralytics avec votre application

Ultralytics fournit plusieurs images Docker que vous pouvez utiliser comme base pour l'image de votre application. Docker installera Ultralytics et les pilotes GPU nécessaires.

Pour utiliser toutes les capacités des modèles Ultralytics YOLO, vous devez sélectionner l'image optimisée pour CUDA pour l'inférence GPU. Toutefois, si l'inférence CPU est suffisante pour votre tâche, vous pouvez économiser des ressources de calcul en sélectionnant également l'image CPU uniquement :

• Dockerfile : Image optimisée pour CUDA pour l'entraînement et l'inférence YOLO11 sur un ou plusieurs GPU.
• Dockerfile-cpu : Image CPU uniquement pour l'inférence YOLO11.

Créer une image Docker pour votre application

Créer un fichier Dockerfile à la racine de votre projet avec le contenu suivant :

# 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"]

Dans l'exemple, l'image Docker officielle Ultralytics ultralytics:latest est utilisée comme base. Elle contient déjà le modèle YOLO11 et toutes les dépendances nécessaires. Le point d'entrée du serveur est le même que celui que nous avons utilisé pour tester l'application FastAPI localement.

Construire et tester l'image Docker

Vous pouvez maintenant construire l'image Docker avec la commande suivante :

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

Remplacez IMAGE_NAME et IMAGE_VERSION avec les valeurs souhaitées, par exemple, yolo11-fastapi:0.1. Notez que vous devez construire l'image pour l' linux/amd64 architecture si vous déployez sur Vertex AI. Le --platform paramètre doit être explicitement défini si vous construisez l'image sur un Mac Apple Silicon ou toute autre architecture non-x86.

Une fois la construction de l'image terminée, vous pouvez tester l'image Docker localement :

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

Votre conteneur Docker exécute maintenant un serveur FastAPI sur le port 8080, prêt à accepter les requêtes d'inférence. Vous pouvez tester à la fois le /health et le /predict endpoint avec les mêmes commandes cURL qu'avant :

# 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. Téléverser l'image Docker vers GCP Artifact Registry

Pour importer votre modèle conteneurisé dans Vertex AI, vous devez télécharger l'image Docker dans Google Cloud Artifact Registry. Si vous n'avez pas encore de référentiel Artifact Registry, vous devrez d'abord en créer un.

Créer un dépôt dans Google Cloud Artifact Registry

Ouvrez la page Artifact Registry dans la console Google Cloud. Si vous utilisez Artifact Registry pour la première fois, vous serez peut-être invité à activer l'API Artifact Registry au préalable.

1. Sélectionnez Créer un référentiel.
2. Entrez le nom de votre référentiel. Sélectionnez la région souhaitée et utilisez les paramètres par défaut pour les autres options, sauf si vous devez les modifier spécifiquement.

1. Une fois le référentiel créé, enregistrez votre PROJECT_ID, votre emplacement (région) et le nom du référentiel dans votre coffre de secrets ou .env fichier. Vous en aurez besoin plus tard pour étiqueter et envoyer votre image Docker vers Artifact Registry.

Authentifier Docker auprès d'Artifact Registry

Authentifiez votre client Docker auprès du référentiel Artifact Registry que vous venez de créer. Exécutez la commande suivante dans votre terminal :

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

Identifier et envoyer votre image vers Artifact Registry

Étiquetez et envoyez l'image Docker vers Google Artifact Registry.

Étiquetez votre image avec l'URL du référentiel Artifact Registry. Remplacez les espaces réservés par les valeurs que vous avez enregistrées précédemment.

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

Envoyez l'image étiquetée vers le référentiel Artifact Registry.

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

Attendez que le processus se termine. Vous devriez maintenant voir l'image dans votre référentiel Artifact Registry.

Pour des instructions plus spécifiques sur la façon de travailler avec des images dans Artifact Registry, consultez la documentation d'Artifact Registry : Envoyer et extraire des images.

4. Importer votre modèle dans Vertex AI

En utilisant l'image Docker que vous venez d'envoyer, vous pouvez maintenant importer le modèle dans Vertex AI.

1. Dans le menu de navigation de Google Cloud, accédez à Vertex AI > Model Registry. Vous pouvez également rechercher « Vertex AI » dans la barre de recherche en haut de la console Google Cloud.

   

2. Cliquez sur Importer.

3. Sélectionnez Importer en tant que nouveau modèle.
4. Sélectionnez la région. Vous pouvez choisir la même région que votre référentiel Artifact Registry, mais votre sélection doit être dictée par la disponibilité des types de machines et des quotas dans votre région.

5. Sélectionnez Importer un conteneur de modèle existant.

   

6. Dans le champ Image du conteneur, parcourez le référentiel Artifact Registry que vous avez créé précédemment et sélectionnez l'image que vous venez d'envoyer.

7. Faites défiler jusqu'à la section Variables d'environnement et entrez les points de terminaison predict et health, ainsi que le port que vous avez définis dans votre application FastAPI.

   

8. Cliquez sur Importer. Vertex AI prendra plusieurs minutes pour enregistrer le modèle et le préparer au déploiement. Vous recevrez une notification par e-mail une fois l'importation terminée.

5. Créer un point de terminaison Vertex AI et déployer votre modèle

Pour déployer un modèle, vous devez créer un point de terminaison (Endpoint) dans Vertex AI.

1. Dans le menu de navigation de Vertex AI, accédez à « Endpoints ». Sélectionnez la région que vous avez utilisée lors de l'importation de votre modèle. Cliquez sur « Créer ».

1. Entrez le nom du point de terminaison.
2. Pour l'accès, Vertex AI recommande d'utiliser des points de terminaison Vertex AI privés. Outre les avantages en matière de sécurité, vous bénéficiez d'une limite de payload plus élevée si vous sélectionnez un point de terminaison privé. Toutefois, vous devrez configurer votre réseau VPC et vos règles de pare-feu pour autoriser l'accès au point de terminaison. Consultez la documentation de Vertex AI pour plus d'instructions sur les points de terminaison privés.
3. Cliquez sur « Continuer ».
4. Dans la boîte de dialogue des paramètres du modèle, sélectionnez le modèle que vous avez importé précédemment. Vous pouvez maintenant configurer le type de machine, la mémoire et les paramètres du GPU pour votre modèle. Prévoyez suffisamment de mémoire si vous prévoyez des charges d'inférence élevées afin de garantir l'absence de goulots d'étranglement d'E/S pour les performances appropriées de YOLO11.

5. Dans « Type d'accélérateur », sélectionnez le type de GPU que vous souhaitez utiliser pour l'inférence. Si vous n'êtes pas sûr du GPU à sélectionner, vous pouvez commencer par NVIDIA T4, qui est compatible avec CUDA.

   Quotas de région et de type de machine

   N'oubliez pas que certaines régions ont des quotas de calcul très limités, vous ne pourrez donc peut-être pas sélectionner certains types de machines ou GPU dans votre région. Si cela est essentiel, modifiez la région de votre déploiement pour en choisir une avec un quota plus important. Vous trouverez plus d'informations dans la documentation officielle de Vertex AI : Quotas et limites de Vertex AI.

6. Une fois le type de machine sélectionné, vous pouvez cliquer sur « Continuer ». À ce stade, vous pouvez choisir d'activer la surveillance du modèle dans Vertex AI, un service supplémentaire qui suivra les performances de votre modèle et fournira des informations sur son comportement. Ceci est facultatif et entraîne des coûts supplémentaires, alors sélectionnez en fonction de vos besoins. Cliquez sur « Créer ».

Vertex AI prendra plusieurs minutes (jusqu'à 30 minutes dans certaines régions) pour déployer le modèle. Vous recevrez une notification par e-mail une fois le déploiement terminé.

6. Tester votre modèle déployé

Une fois le déploiement terminé, Vertex AI vous fournira un exemple d'interface API pour tester votre modèle.

Pour tester l'inférence à distance, vous pouvez utiliser la commande cURL fournie ou créer une autre bibliothèque cliente python qui enverra des requêtes au modèle déployé. N'oubliez pas que vous devez encoder votre image en base64 avant de l'envoyer au /predict point de terminaison.

Félicitations ! Vous avez déployé avec succès un modèle YOLO11 pré-entraîné avec Ultralytics sur Google Cloud Vertex AI.

FAQ

Puis-je utiliser des modèles Ultralytics YOLO sur Vertex AI sans Docker ?

Oui, mais vous devrez d'abord exporter le modèle dans un format compatible avec Vertex AI, tel que TensorFlow, Scikit-learn ou XGBoost. Google Cloud fournit un guide sur l'exécution de .pt modèles sur Vertex avec une vue d'ensemble complète du processus de conversion : Exécuter des modèles PyTorch sur Vertex AI.

Veuillez noter que la configuration résultante reposera uniquement sur la couche de service standard de Vertex AI et ne prendra pas en charge les fonctionnalités avancées du framework Ultralytics. Étant donné que Vertex AI prend entièrement en charge les modèles conteneurisés et est capable de les mettre à l'échelle automatiquement en fonction de votre configuration de déploiement, il vous permet de tirer parti de toutes les capacités des modèles YOLO Ultralytics sans avoir à les convertir dans un format différent.

Pourquoi FastAPI est-il un bon choix pour servir l'inférence YOLO11 ?

FastAPI offre un débit élevé pour les charges de travail d'inférence. La prise en charge asynchrone permet de gérer plusieurs requêtes simultanées sans bloquer le thread principal, ce qui est important lors de la diffusion de modèles de vision par ordinateur.

La validation automatique des requêtes/réponses avec FastAPI réduit les erreurs d'exécution dans les services d'inférence de production. Ceci est particulièrement utile pour les API de détection d'objets où la cohérence du format d'entrée est essentielle.

FastAPI ajoute une surcharge de calcul minimale à votre pipeline d'inférence, laissant ainsi plus de ressources disponibles pour l'exécution du modèle et les tâches de traitement d'image.

FastAPI prend également en charge SSE (Server-Sent Events), ce qui est utile pour les scénarios d'inférence en streaming.

Pourquoi dois-je sélectionner une région autant de fois ?

Il s'agit en fait d'une fonctionnalité de polyvalence de Google Cloud Platform, où vous devez sélectionner une région pour chaque service que vous utilisez. Pour la tâche de déploiement d'un modèle conteneurisé sur Vertex AI, votre sélection de région la plus importante est celle du registre de modèles. Elle déterminera la disponibilité des types de machines et des quotas pour le déploiement de votre modèle.

De plus, si vous prévoyez d'étendre la configuration et de stocker les données de prédiction ou les résultats dans Cloud Storage ou BigQuery, vous devrez utiliser la même région que pour le registre de modèles, afin de minimiser la latence et de garantir un débit élevé pour l'accès aux données.

📅 Créé il y a 1 mois ✏️ Mis à jour il y a 1 mois

Commentaires