Bereitstellung eines vortrainierten YOLO-Modells mit Ultralytics auf Vertex AI für die Inferenz

Dieser Leitfaden zeigt Ihnen, wie Sie ein vortrainiertes YOLO11-Modell mit Ultralytics containerisieren, einen FastAPI-Inferenzserver dafür erstellen und das Modell mit dem Inferenzserver auf Google Cloud Vertex AI bereitstellen. Die Beispielimplementierung behandelt den Anwendungsfall der Objekterkennung für YOLO11, aber die gleichen Prinzipien gelten auch für die Verwendung von anderen YOLO-Modi.

Bevor wir beginnen, müssen Sie ein Google Cloud Platform (GCP)-Projekt erstellen. Sie erhalten 300 US-Dollar an GCP-Guthaben, die Sie als neuer Benutzer kostenlos nutzen können. Dieser Betrag reicht aus, um ein laufendes Setup zu testen, das Sie später für jeden anderen YOLO11-Anwendungsfall erweitern können, einschließlich Training oder Batch- und Streaming-Inferenz.

Was Sie lernen werden

1. Erstellen Sie ein Inferenz-Backend für das Ultralytics YOLO11-Modell mit FastAPI.
2. Erstellen Sie ein GCP Artifact Registry-Repository, um Ihr Docker-Image zu speichern.
3. Erstellen Sie das Docker-Image mit dem Modell und übertragen Sie es an die Artifact Registry.
4. Importieren Sie Ihr Modell in Vertex AI.
5. Erstellen Sie einen Vertex AI-Endpunkt und stellen Sie das Modell bereit.

Voraussetzungen

1. Installieren Sie Docker auf Ihrem Rechner.
2. Installieren Sie das Google Cloud SDK und authentifizieren Sie sich für die Verwendung der gcloud CLI.
3. Es wird dringend empfohlen, dass Sie den Docker-Schnellstartleitfaden für Ultralytics durcharbeiten, da Sie eines der offiziellen Ultralytics Docker-Images erweitern müssen, während Sie dieser Anleitung folgen.

1. Erstellen Sie ein Inferenz-Backend mit FastAPI

Zuerst müssen Sie eine FastAPI-Anwendung erstellen, die die YOLO11-Modellinferenzanfragen bedient. Diese Anwendung übernimmt das Laden des Modells, die Bildvorverarbeitung und die Inferenz(Vorhersage)-Logik.

Grundlagen der Vertex AI-Konformität

Vertex AI erwartet, dass Ihr Container zwei spezifische Endpunkte implementiert:

1. Gesundheit Endpunkt (/health): Muss den HTTP-Status zurückgeben 200 OK wenn der Dienst bereit ist.

2. Vorhersagen Endpunkt (/predict): Akzeptiert strukturierte Vorhersageanfragen mit base64-kodiert Bilder und optionale Parameter. Grenzwerte für die Payload-Größe gelten je nach Endpunkttyp.

   Request-Payloads für die /predict Endpunkt sollte dieser JSON-Struktur folgen:

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

Projektordnerstruktur

Der Großteil unseres Builds wird innerhalb des Docker-Containers stattfinden, und Ultralytics wird auch ein vortrainiertes YOLO11-Modell laden, sodass Sie die lokale Ordnerstruktur einfach halten können:

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

Erstellen Sie pyproject.toml mit Abhängigkeiten

Um Ihr Projekt bequem zu verwalten, erstellen Sie ein pyproject.toml Datei mit den folgenden Abhängigkeiten:

[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 wird verwendet, um den FastAPI-Server auszuführen.
• pillow wird für die Bildverarbeitung verwendet, aber Sie sind nicht nur auf PIL-Bilder beschränkt — Ultralytics unterstützt viele andere Formate.

Erstellen Sie eine Inferenzlogik mit Ultralytics YOLO11

Nachdem Sie die Projektstruktur und die Abhängigkeiten eingerichtet haben, können Sie die grundlegende YOLO11-Inferenzlogik implementieren. Erstellen Sie eine src/app.py Datei, die das Laden von Modellen, die Bildverarbeitung und die Vorhersage mithilfe der Ultralytics Python API übernimmt.

# 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

Dadurch wird das Modell einmal beim Start des Containers geladen, und das Modell wird für alle Anfragen gemeinsam genutzt. Wenn Ihr Modell eine hohe Inferenzlast bewältigen muss, wird empfohlen, bei einem späteren Import eines Modells in Vertex AI einen Maschinentyp mit mehr Speicher auszuwählen.

Erstellen Sie als Nächstes zwei Hilfsfunktionen für die Eingabe- und Ausgabebildverarbeitung mit pillow. YOLO11 unterstützt PIL-Bilder nativ.

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

Implementieren Sie abschließend die run_inference Funktion, die die Objekterkennung übernimmt. In diesem Beispiel extrahieren wir Begrenzungsrahmen, Klassennamen und Konfidenzwerte aus den Modellvorhersagen. Die Funktion gibt ein Dictionary mit Erkennungen und Rohdaten zur weiteren Verarbeitung oder Annotation zurück.

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}

Optional kannst du eine Funktion hinzufügen, um das Bild mit Begrenzungsrahmen und Beschriftungen unter Verwendung der integrierten Ultralytics-Plotting-Methode zu versehen. Dies ist nützlich, wenn du annotierte Bilder in der Vorhersageantwort zurückgeben möchtest.

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)

Erstellen Sie einen HTTP-Inferenzserver mit FastAPI

Nachdem Sie die grundlegende YOLO11-Inferenzlogik haben, können Sie eine FastAPI-Anwendung erstellen, um sie bereitzustellen. Diese umfasst die von Vertex AI benötigten Health-Check- und Prediction-Endpunkte.

Fügen Sie zuerst die Importe hinzu und konfigurieren Sie die Protokollierung für Vertex AI. Da Vertex AI stderr als Fehlerausgabe behandelt, ist es sinnvoll, die Protokolle nach stdout umzuleiten.

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

Für eine vollständige Vertex AI-Konformität definieren Sie die erforderlichen Endpunkte in Umgebungsvariablen und legen Sie die Größenbeschränkung für Anfragen fest. Es wird empfohlen, private Vertex AI-Endpunkte für Produktionsbereitstellungen zu verwenden. Auf diese Weise haben Sie ein höheres Limit für die Anfrage-Payload (10 MB anstelle von 1,5 MB für öffentliche Endpunkte), zusammen mit robuster Sicherheit und Zugriffskontrolle.

# 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

Fügen Sie zwei Pydantic-Modelle hinzu, um Ihre Anfragen und Antworten zu validieren:

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


class PredictionResponse(BaseModel):
    predictions: list

Fügen Sie den Health-Check-Endpunkt hinzu, um die Bereitschaft Ihres Modells zu überprüfen. Dies ist wichtig für Vertex AI., da der Orchestrator ohne eine dedizierte Zustandsprüfung zufällige Sockets anpingt und nicht feststellen kann, ob das Modell für die Inferenz bereit ist. Ihre Prüfung muss Folgendes zurückgeben: 200 OK für den Erfolg und 503 Service Unavailable bei Fehlern:

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

Sie haben jetzt alles, um den Vorhersage-Endpunkt zu implementieren, der die Inferenzanfragen verarbeitet. Er akzeptiert eine Bilddatei, führt die Inferenz aus und gibt die Ergebnisse zurück. Beachten Sie, dass das Bild Base64-kodiert sein muss, was die Größe der Nutzlast zusätzlich um bis zu 33 % erhöht.

@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)}")

Fügen Sie abschließend den Anwendungseinstiegspunkt hinzu, um den FastAPI-Server auszuführen.

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)

Sie haben jetzt eine vollständige FastAPI-Anwendung, die YOLO11-Inferenzanfragen bedienen kann. Sie können sie lokal testen, indem Sie die Abhängigkeiten installieren und den Server ausführen, zum Beispiel mit uv.

# Install dependencies
uv pip install -e .

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

Um den Server zu testen, können Sie sowohl die /health und /predict Endpunkte mit cURL. Legen Sie ein Testbild in den tests Ordner. Führen Sie dann in Ihrem Terminal die folgenden Befehle aus:

# 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

Sie sollten eine JSON-Antwort mit den erkannten Objekten erhalten. Bei Ihrer ersten Anfrage ist mit einer kurzen Verzögerung zu rechnen, da Ultralytics das YOLO11-Modell abrufen und laden muss.

2. Erweitern Sie das Ultralytics Docker-Image mit Ihrer Anwendung

Ultralytics stellt verschiedene Docker-Images bereit, die Sie als Basis für Ihr Anwendungs-Image verwenden können. Docker installiert Ultralytics und die notwendigen GPU-Treiber.

Um die vollen Fähigkeiten der Ultralytics YOLO-Modelle zu nutzen, sollten Sie das CUDA-optimierte Image für die GPU-Inferenz auswählen. Wenn die CPU-Inferenz jedoch für Ihre Aufgabe ausreicht, können Sie Rechenressourcen sparen, indem Sie auch das reine CPU-Image auswählen:

• Dockerfile: CUDA-optimiertes Image für YOLO11 Single/Multi-GPU Training und Inferenz.
• Dockerfile-cpu: CPU-only Image für YOLO11 Inferenz.

Erstellen Sie ein Docker-Image für Ihre Anwendung

Erstellen Sie eine Dockerfile im Stammverzeichnis Ihres Projekts mit folgendem Inhalt:

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

In dem Beispiel das offizielle Ultralytics Docker-Image ultralytics:latest wird als Basis verwendet. Es enthält bereits das YOLO11-Modell und alle notwendigen Abhängigkeiten. Der Einstiegspunkt des Servers ist derselbe, den wir zum lokalen Testen der FastAPI-Anwendung verwendet haben.

Erstellen und testen Sie das Docker-Image

Jetzt können Sie das Docker-Image mit dem folgenden Befehl erstellen:

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

Ersetzen Sie IMAGE_NAME und IMAGE_VERSION mit Ihren gewünschten Werten, zum Beispiel yolo11-fastapi:0.1. Beachten Sie, dass Sie das Image für die linux/amd64 Architektur, wenn Sie auf Vertex AI bereitstellen. Die --platform Parameter muss explizit gesetzt werden, wenn Sie das Image auf einem Apple Silicon Mac oder einer anderen Nicht-x86-Architektur erstellen.

Sobald der Image-Build abgeschlossen ist, können Sie das Docker-Image lokal testen:

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

Ihr Docker-Container führt jetzt einen FastAPI-Server auf Port aus 8080, bereit, Inferenzanfragen entgegenzunehmen. Sie können sowohl die /health und das /predict Endpunkt mit den gleichen cURL-Befehlen wie zuvor:

# 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. Laden Sie das Docker-Image in die GCP Artifact Registry hoch

Um Ihr containerisiertes Modell in Vertex AI zu importieren, müssen Sie das Docker-Image in Google Cloud Artifact Registry hochladen. Wenn Sie noch kein Artifact Registry-Repository haben, müssen Sie zuerst eines erstellen.

Erstellen Sie ein Repository in Google Cloud Artifact Registry

Öffnen Sie die Artifact Registry-Seite in der Google Cloud Console. Wenn Sie die Artifact Registry zum ersten Mal verwenden, werden Sie möglicherweise aufgefordert, zuerst die Artifact Registry API zu aktivieren.

1. Wählen Sie Repository erstellen.
2. Geben Sie den Namen Ihres Repository ein. Wählen Sie die gewünschte Region aus und verwenden Sie die Standardeinstellungen für andere Optionen, es sei denn, Sie müssen diese speziell ändern.

1. Sobald das Repository erstellt wurde, speichern Sie Ihre PROJECT_ID, den Standort (Region) und den Repository-Namen in Ihrem Secret-Vault oder .env Datei. Sie benötigen sie später, um Ihr Docker-Image zu taggen und in die Artifact Registry zu pushen.

Authentifizieren Sie Docker bei Artifact Registry

Authentifizieren Sie Ihren Docker-Client bei dem Artifact Registry-Repository, das Sie gerade erstellt haben. Führen Sie den folgenden Befehl in Ihrem Terminal aus:

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

Taggen und pushen Sie Ihr Image zur Artifact Registry

Taggen und pushen Sie das Docker-Image zur Google Artifact Registry.

Taggen Sie Ihr Image mit der Repository-URL der Artifact Registry. Ersetzen Sie die Platzhalter durch die zuvor gespeicherten Werte.

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

Übertragen Sie das getaggte Image in das Artifact Registry Repository.

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

Warten Sie, bis der Vorgang abgeschlossen ist. Sie sollten nun das Bild in Ihrem Artifact Registry-Repository sehen.

Spezifischere Anweisungen zur Arbeit mit Bildern in Artifact Registry finden Sie in der Artifact Registry-Dokumentation: Bilder übertragen und abrufen.

4. Importieren Sie Ihr Modell in Vertex AI

Mit dem Docker-Image, das Sie gerade hochgeladen haben, können Sie das Modell nun in Vertex AI importieren.

1. Gehen Sie im Google Cloud-Navigationsmenü zu Vertex AI > Modell-Registry. Alternativ können Sie in der Suchleiste oben in der Google Cloud Console nach "Vertex AI" suchen.

   

2. Klicken Sie auf Importieren.

3. Wählen Sie Als neues Modell importieren.
4. Wählen Sie die Region aus. Sie können dieselbe Region wie Ihr Artifact Registry-Repository wählen, aber Ihre Auswahl sollte sich nach der Verfügbarkeit von Maschinentypen und Quoten in Ihrer Region richten.

5. Wählen Sie Vorhandenen Modellcontainer importieren.

   

6. Durchsuchen Sie im Feld Container-Image das zuvor erstellte Artifact Registry-Repository und wählen Sie das gerade hochgeladene Image aus.

7. Scrollen Sie nach unten zum Abschnitt Umgebungsvariablen und geben Sie die Predict- und Health-Endpunkte sowie den Port ein, den Sie in Ihrer FastAPI-Anwendung definiert haben.

   

8. Klicken Sie auf Importieren. Vertex AI benötigt einige Minuten, um das Modell zu registrieren und für die Bereitstellung vorzubereiten. Sie erhalten eine E-Mail-Benachrichtigung, sobald der Import abgeschlossen ist.

5. Erstellen Sie einen Vertex AI-Endpunkt und stellen Sie Ihr Modell bereit

Um ein Modell bereitzustellen, müssen Sie einen Endpunkt in Vertex AI erstellen.

1. Gehen Sie im Vertex AI-Navigationsmenü zu Endpunkte. Wählen Sie die Region aus, die Sie beim Importieren Ihres Modells verwendet haben. Klicken Sie auf Erstellen.

1. Geben Sie den Endpunktnamen ein.
2. Für den Zugriff empfiehlt Vertex AI die Verwendung privater Vertex AI-Endpunkte. Abgesehen von den Sicherheitsvorteilen erhalten Sie ein höheres Payload-Limit, wenn Sie einen privaten Endpunkt auswählen. Sie müssen jedoch Ihr VPC-Netzwerk und Ihre Firewall-Regeln konfigurieren, um den Zugriff auf den Endpunkt zu ermöglichen. Weitere Anweisungen zu privaten Endpunkten finden Sie in der Vertex AI-Dokumentation.
3. Klicken Sie auf Weiter.
4. Wählen Sie im Dialogfeld „Modelleinstellungen“ das zuvor importierte Modell aus. Nun können Sie den Maschinentyp, den Speicher und die GPU-Einstellungen für Ihr Modell konfigurieren. Planen Sie ausreichend Speicher ein, wenn Sie hohe Inferenzlasten erwarten, um sicherzustellen, dass es keine I/O-Engpässe für die korrekte YOLO11-Leistung gibt.

5. Wählen Sie unter Beschleunigertyp den GPU-Typ aus, den Sie für die Inferenz verwenden möchten. Wenn Sie sich nicht sicher sind, welche GPU Sie auswählen sollen, können Sie mit NVIDIA T4 beginnen, das CUDA-fähig ist.

   Kontingente für Regionen und Maschinentypen

   Beachten Sie, dass bestimmte Regionen sehr begrenzte Rechenkontingente haben, sodass Sie möglicherweise bestimmte Maschinentypen oder GPUs in Ihrer Region nicht auswählen können. Wenn dies kritisch ist, ändern Sie die Region Ihrer Bereitstellung in eine mit einem größeren Kontingent. Weitere Informationen finden Sie in der offiziellen Vertex AI-Dokumentation: Vertex AI-Kontingente und -Limits.

6. Sobald der Maschinentyp ausgewählt ist, können Sie auf „Weiter“ klicken. An diesem Punkt können Sie die Modellüberwachung in Vertex AI aktivieren – ein zusätzlicher Dienst, der die Leistung Ihres Modells verfolgt und Einblicke in sein Verhalten gibt. Dies ist optional und verursacht zusätzliche Kosten. Wählen Sie also entsprechend Ihren Bedürfnissen aus. Klicken Sie auf „Erstellen“.

Vertex AI benötigt einige Minuten (in einigen Regionen bis zu 30 Minuten), um das Modell bereitzustellen. Sie erhalten eine E-Mail-Benachrichtigung, sobald die Bereitstellung abgeschlossen ist.

6. Testen Sie Ihr bereitgestelltes Modell

Sobald die Bereitstellung abgeschlossen ist, stellt Ihnen Vertex AI eine Beispiel-API-Schnittstelle zum Testen Ihres Modells zur Verfügung.

Um Remote Inference zu testen, können Sie den bereitgestellten cURL-Befehl verwenden oder eine andere Python-Clientbibliothek erstellen, die Anfragen an das bereitgestellte Modell sendet. Denken Sie daran, dass Sie Ihr Bild in Base64 codieren müssen, bevor Sie es an den Server senden. /predict Endpunkt.

Herzlichen Glückwunsch! Sie haben erfolgreich ein vortrainiertes YOLO11-Modell mit Ultralytics auf Google Cloud Vertex AI bereitgestellt.

FAQ

Kann ich Ultralytics YOLO Modelle auf Vertex AI ohne Docker verwenden?

Ja, Sie müssen das Modell jedoch zuerst in ein mit Vertex AI kompatibles Format exportieren, z. B. TensorFlow, Scikit-learn oder XGBoost. Google Cloud bietet eine Anleitung zum Ausführen von .pt Modelle auf Vertex mit einem vollständigen Überblick über den Konvertierungsprozess: PyTorch-Modelle auf Vertex AI ausführen.

Bitte beachten Sie, dass das resultierende Setup ausschließlich auf der Vertex AI Standard Serving Schicht basiert und die erweiterten Ultralytics Framework-Funktionen nicht unterstützt. Da Vertex AI containerisierte Modelle vollständig unterstützt und diese entsprechend Ihrer Deployment-Konfiguration automatisch skalieren kann, können Sie die vollen Möglichkeiten von Ultralytics YOLO-Modellen nutzen, ohne diese in ein anderes Format konvertieren zu müssen.

Warum ist FastAPI eine gute Wahl für die Bereitstellung von YOLO11-Inferenz?

FastAPI bietet einen hohen Durchsatz für Inferenz-Workloads. Die Async-Unterstützung ermöglicht die Bearbeitung mehrerer gleichzeitiger Anfragen, ohne den Hauptthread zu blockieren, was wichtig ist, wenn Computer-Vision-Modelle bereitgestellt werden.

Die automatische Anfrage- / Antwortvalidierung mit FastAPI reduziert Laufzeitfehler in Produktions-Inferenzdiensten. Dies ist besonders wertvoll für Objekterkennungs-APIs, bei denen die Konsistenz des Eingabeformats entscheidend ist.

FastAPI verursacht nur einen minimalen Rechenaufwand für Ihre Inferenzpipeline, wodurch mehr Ressourcen für die Modellausführung und Bildverarbeitungsaufgaben zur Verfügung stehen.

FastAPI unterstützt auch SSE (Server-Sent Events), was für Streaming-Inferenzszenarien nützlich ist.

Warum muss ich so oft eine Region auswählen?

Dies ist eigentlich eine Vielseitigkeitsfunktion der Google Cloud Platform, bei der Sie für jeden Dienst, den Sie nutzen, eine Region auswählen müssen. Für die Aufgabe, ein containerisiertes Modell auf Vertex AI bereitzustellen, ist die Auswahl der Region für die Model Registry am wichtigsten. Sie bestimmt die Verfügbarkeit von Maschinentypen und Kontingenten für Ihre Modellbereitstellung.

Wenn Sie das Setup erweitern und Vorhersagedaten oder -ergebnisse in Cloud Storage oder BigQuery speichern, müssen Sie dieselbe Region wie für Model Registry verwenden, um die Latenz zu minimieren und einen hohen Durchsatz für den Datenzugriff zu gewährleisten.

📅 Erstellt vor 1 Monat ✏️ Aktualisiert vor 1 Monat

Kommentare