Stelle ein vortrainiertes YOLO-Modell mit Ultralytics auf Vertex AI für die Inferenz bereit

Dieser Leitfaden zeigt dir, wie du ein vortrainiertes YOLO26-Modell mit Ultralytics in einen Container packst, einen FastAPI-Inferenzserver dafür erstellst und das Modell zusammen mit dem Inferenzserver auf Google Cloud Vertex AI bereitstellst. Das Implementierungsbeispiel behandelt den Anwendungsfall der Objekterkennung für YOLO26, aber die gleichen Prinzipien gelten auch für die Verwendung anderer YOLO-Modi.

Bevor wir anfangen, musst du ein Google Cloud Platform (GCP) Projekt erstellen. Als neuer Nutzer erhältst du ein Guthaben von 300 $ für die kostenlose Nutzung von GCP. Dieser Betrag reicht aus, um ein laufendes Setup zu testen, das du später für jeden anderen YOLO26-Anwendungsfall erweitern kannst, einschließlich Training oder Batch- und Streaming-Inferenz.

Was du lernen wirst

1. Erstelle ein Inferenz-Backend für ein Ultralytics YOLO26-Modell mit FastAPI.
2. Erstelle ein GCP Artifact Registry-Repository zum Speichern deines Docker-Images.
3. Baue das Docker-Image mit dem Modell und übertrage es in die Artifact Registry.
4. Importiere dein Modell in Vertex AI.
5. Erstelle einen Vertex AI-Endpunkt und stelle das Modell bereit.

Voraussetzungen

1. Installiere Docker auf deinem Rechner.
2. Installiere das Google Cloud SDK und authentifiziere dich für die Verwendung der gcloud CLI.
3. Es wird dringend empfohlen, den Docker Quickstart Guide for Ultralytics durchzugehen, da du eines der offiziellen Ultralytics Docker-Images erweitern musst, während du diesem Leitfaden folgst.

Erstelle ein Inferenz-Backend mit FastAPI

Zuerst musst du eine FastAPI-Anwendung erstellen, die die YOLO26-Modell-Inferenzanfragen bedient. Diese Anwendung verwaltet das Laden des Modells, die Bildvorverarbeitung und die Inferenzlogik (Vorhersage).

Grundlagen der Vertex AI-Compliance

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

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

2. Predict-Endpunkt (/predict): Akzeptiert strukturierte Vorhersageanfragen mit base64-codierten Bildern und optionalen Parametern. Es gelten Payload-Größenbeschränkungen, abhängig vom Endpunkttyp.

   Anfrage-Payloads für den /predict-Endpunkt sollten dieser JSON-Struktur folgen:

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

Projekt-Ordnerstruktur

Der Großteil unseres Builds findet innerhalb des Docker-Containers statt, und Ultralytics lädt ebenfalls ein vortrainiertes YOLO26-Modell, sodass du die lokale Ordnerstruktur einfach halten kannst:

YOUR_PROJECT/
├── src/
│   ├── __init__.py
│   ├── app.py              # Core YOLO26 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

Erstelle pyproject.toml mit Abhängigkeiten

Um dein Projekt komfortabel zu verwalten, erstelle eine 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 du bist nicht nur auf PIL-Bilder beschränkt – Ultralytics unterstützt viele andere Formate.

Erstelle Inferenzlogik mit Ultralytics YOLO26

Jetzt, da du die Projektstruktur und Abhängigkeiten eingerichtet hast, kannst du die grundlegende YOLO26-Inferenzlogik implementieren. Erstelle eine src/app.py-Datei, die das Laden des Modells, die Bildverarbeitung und die Vorhersage unter Verwendung 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 pretrained YOLO26n model from Ultralytics base image
        model_yolo = YOLO("yolo26n.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

Dies lädt das Modell einmal beim Start des Containers, und das Modell wird für alle Anfragen geteilt. Wenn dein Modell eine hohe Inferenzlast bewältigen muss, wird empfohlen, beim späteren Importieren des Modells in Vertex AI einen Maschinentyp mit mehr Arbeitsspeicher zu wählen.

Erstelle als Nächstes zwei Hilfsfunktionen für die Eingabe- und Ausgabebildverarbeitung mit pillow. YOLO26 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()

Implementiere schließlich die Funktion run_inference, die die Objekterkennung handhabt. In diesem Beispiel extrahieren wir Bounding Boxes, Klassennamen und Konfidenzwerte aus den Modellvorhersagen. Die Funktion gibt ein Dictionary mit Erkennungen und Rohdaten für die weitere 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 YOLO26n 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 Bounding Boxes und Labels mithilfe der integrierten Plot-Methode von Ultralytics zu annotieren. 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)

Erstelle einen HTTP-Inferenzserver mit FastAPI

Da du nun die grundlegende YOLO26-Inferenzlogik hast, kannst du eine FastAPI-Anwendung erstellen, um diese zu bedienen. Dies beinhaltet die Health-Checks und die Vorhersage-Endpunkte, die von Vertex AI benötigt werden.

Füge zuerst die Importe hinzu und konfiguriere das Logging für Vertex AI. Da Vertex AI stderr als Fehlerausgabe behandelt, ist es sinnvoll, die Logs an stdout weiterzuleiten.

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-Compliance definiere die erforderlichen Endpunkte in Umgebungsvariablen und lege das Größenlimit für Anfragen fest. Es wird empfohlen, private Vertex AI-Endpunkte für Produktionsbereitstellungen zu verwenden. Auf diese Weise hast du ein höheres Payload-Limit für Anfragen (10 MB statt 1,5 MB bei öffentlichen Endpunkten) sowie robuste 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üge zwei Pydantic-Modelle zur Validierung deiner Anfragen und Antworten hinzu:

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

class PredictionResponse(BaseModel):
    predictions: list

Füge den Health-Check-Endpunkt hinzu, um die Bereitschaft deines Modells zu überprüfen. Dies ist wichtig für Vertex AI, da der Orchestrator ohne einen dedizierten Health-Check zufällige Sockets anpingt und nicht feststellen kann, ob das Modell bereit für die Inferenz ist. Dein Check muss 200 OK bei Erfolg und 503 Service Unavailable bei Fehlern zurückgeben:

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

Du hast nun alles beisammen, um den Vorhersage-Endpunkt zu implementieren, der die Inferenzanfragen verarbeitet. Er akzeptiert eine Bilddatei, führt die Inferenz durch und gibt die Ergebnisse zurück. Beachte, dass das Bild base64-codiert sein muss, was die Größe der Payload 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 YOLO26 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 YOLO26n 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: {e}")
        raise HTTPException(status_code=500, detail=f"Prediction failed: {e}")

Füge schließlich den Einstiegspunkt der Anwendung hinzu, um den FastAPI-Server zu starten.

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)

Du hast jetzt eine vollständige FastAPI-Anwendung, die YOLO26-Inferenzanfragen bedienen kann. Du kannst sie lokal testen, indem du die Abhängigkeiten installierst und den Server ausführst, 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, kannst du sowohl den /health- als auch den /predict-Endpunkt mit cURL abfragen. Lege ein Testbild in den tests-Ordner. Führe dann in deinem 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

Du solltest eine JSON-Antwort mit den erkannten Objekten erhalten. Erwarte bei der ersten Anfrage eine kurze Verzögerung, da Ultralytics das YOLO26-Modell abrufen und laden muss.

Erweitere das Ultralytics Docker-Image mit deiner Anwendung

Ultralytics stellt mehrere Docker-Images bereit, die du als Basis für dein Anwendungs-Image verwenden kannst. Docker installiert Ultralytics und die notwendigen GPU-Treiber.

Um die volle Leistungsfähigkeit der Ultralytics YOLO-Modelle zu nutzen, solltest du das CUDA-optimierte Image für GPU-Inferenz wählen. Wenn CPU-Inferenz für deine Aufgabe ausreicht, kannst du jedoch Rechenressourcen sparen, indem du das reine CPU-Image wählst:

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

Erstelle ein Docker-Image für deine Anwendung

Erstelle ein Dockerfile im Stammverzeichnis deines Projekts mit dem folgenden Inhalt:

# Extends official Ultralytics Docker image for YOLO26
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"]

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

Baue das Docker-Image und teste es

Jetzt kannst du das Docker-Image mit dem folgenden Befehl bauen:

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

Ersetze IMAGE_NAME und IMAGE_VERSION durch deine gewünschten Werte, zum Beispiel yolo26-fastapi:0.1. Beachte, dass du das Image für die Architektur linux/amd64 bauen musst, wenn du es auf Vertex AI bereitstellst. Der --platform-Parameter muss explizit gesetzt werden, wenn du das Image auf einem Apple Silicon Mac oder einer anderen Nicht-x86-Architektur baust.

Sobald der Build-Vorgang des Images abgeschlossen ist, kannst du das Docker-Image lokal testen:

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

Dein Docker-Container führt nun einen FastAPI-Server auf Port 8080 aus und ist bereit, Inferenzanfragen anzunehmen. Du kannst sowohl den /health- als auch den /predict-Endpunkt mit denselben cURL-Befehlen wie zuvor testen:

# 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

Lade das Docker-Image in die GCP Artifact Registry hoch

Um dein containerisiertes Modell in Vertex AI zu importieren, musst du das Docker-Image in die Google Cloud Artifact Registry hochladen. Wenn du noch kein Artifact Registry-Repository hast, musst du zuerst eines erstellen.

Erstelle ein Repository in der Google Cloud Artifact Registry

Öffne die Seite der Artifact Registry in der Google Cloud Console. Wenn du die Artifact Registry zum ersten Mal verwendest, wirst du möglicherweise aufgefordert, zuerst die Artifact Registry API zu aktivieren.

1. Wähle "Repository erstellen".
2. Gib den Namen deines Repositorys ein. Wähle die gewünschte Region und verwende für andere Optionen die Standardeinstellungen, sofern du sie nicht speziell ändern musst.

1. Sobald das Repository erstellt ist, speichere deine PROJECT_ID, den Standort (Region) und den Repository-Namen in deinem Geheimnis-Tresor oder in einer .env-Datei. Du wirst sie später benötigen, um dein Docker-Image zu taggen und in die Artifact Registry zu pushen.

Authentifiziere Docker für die Artifact Registry

Authentifiziere deinen Docker-Client für das soeben erstellte Artifact Registry-Repository. Führe den folgenden Befehl in deinem Terminal aus:

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

Tagge dein Image und pushe es in die Artifact Registry

Tagge und pushe das Docker-Image in die Google Artifact Registry.

Tagge dein Image mit der URL des Artifact Registry-Repositorys. Ersetze 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

Pushe 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

Warte, bis der Vorgang abgeschlossen ist. Du solltest das Image nun in deinem Artifact Registry-Repository sehen.

Weitere spezifische Anweisungen zum Arbeiten mit Images in der Artifact Registry findest du in der Dokumentation der Artifact Registry: Push and pull images.

Importiere dein Modell in Vertex AI

Mit dem soeben gepushten Docker-Image kannst du das Modell nun in Vertex AI importieren.

1. Gehe im Google Cloud-Navigationsmenü zu "Vertex AI > Modell-Registry". Alternativ kannst du in der Suchleiste oben in der Google Cloud Console nach "Vertex AI" suchen.

Erstelle einen Vertex AI-Endpunkt und stelle dein Modell bereit

Um ein Modell bereitzustellen, musst du einen Endpunkt in Vertex AI erstellen.

1. Gehe in deinem Vertex AI-Navigationsmenü zu "Endpunkte". Wähle die Region aus, die du beim Importieren deines Modells verwendet hast. Klicke auf "Erstellen".

1. Sobald der Maschinentyp ausgewählt ist, kannst du auf "Weiter" klicken. An diesem Punkt kannst du optional die Modellüberwachung in Vertex AI aktivieren – ein zusätzlicher Dienst, der die Leistung deines Modells verfolgt und Einblicke in sein Verhalten gibt. Dies ist optional und verursacht zusätzliche Kosten, wähle also nach Bedarf. Klicke auf "Erstellen".

Vertex AI benötigt mehrere Minuten (in einigen Regionen bis zu 30 Minuten), um das Modell bereitzustellen. Du erhältst eine E-Mail-Benachrichtigung, sobald die Bereitstellung abgeschlossen ist.

Teste dein bereitgestelltes Modell

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

Um die Remote-Inferenz zu testen, kannst du den bereitgestellten cURL-Befehl verwenden oder eine weitere Python-Client-Bibliothek erstellen, die Anfragen an das bereitgestellte Modell sendet. Denke daran, dass du dein Bild base64-codieren musst, bevor du es an den /predict-Endpunkt sendest.

Du hast erfolgreich ein vortrainiertes YOLO26-Modell mit Ultralytics auf Google Cloud Vertex AI bereitgestellt.

FAQ

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

Ja; allerdings musst du das Modell zuerst in ein mit Vertex AI kompatibles Format exportieren, wie TensorFlow, Scikit-learn oder XGBoost. Google Cloud bietet eine Anleitung zum Ausführen von .pt-Modellen auf Vertex mit einem vollständigen Überblick über den Konvertierungsprozess: Run PyTorch models on Vertex AI.

Bitte beachte, dass das resultierende Setup nur auf der Standard-Servicing-Ebene von Vertex AI basiert und die fortgeschrittenen Funktionen des Ultralytics-Frameworks nicht unterstützt. Da Vertex AI containerisierte Modelle vollständig unterstützt und diese automatisch entsprechend deiner Bereitstellungskonfiguration skalieren kann, ermöglicht es dir, die volle Leistungsfähigkeit der Ultralytics YOLO-Modelle zu nutzen, ohne sie in ein anderes Format konvertieren zu müssen.

Warum ist FastAPI eine gute Wahl für das Serving von YOLO26-Inferenz?

FastAPI bietet einen hohen Durchsatz für Inferenz-Workloads. Die Unterstützung für Async ermöglicht es, mehrere gleichzeitige Anfragen zu verarbeiten, ohne den Haupt-Thread zu blockieren, was beim Serving von Computer-Vision-Modellen wichtig ist.

Die automatische Validierung von Requests/Responses mit FastAPI reduziert Laufzeitfehler in Inferenzdiensten der Produktion. Dies ist besonders wertvoll für Objekt-Detektions-APIs, bei denen die Konsistenz des Eingabeformats entscheidend ist.

FastAPI fügt deinem Inferenz-Pipeline nur minimalen Rechenaufwand hinzu, wodurch mehr Ressourcen für die Modellausführung und Bildverarbeitungsaufgaben verfügbar bleiben.

FastAPI unterstützt zudem SSE (Server-Sent Events), was für Inferenz-Szenarien mit Streaming nützlich ist.

Warum muss ich so oft eine Region auswählen?

Dies ist tatsächlich ein Vielseitigkeitsmerkmal der Google Cloud Platform, bei dem du für jeden genutzten Dienst eine Region auswählen musst. Für die Aufgabe, ein containerisiertes Modell auf Vertex AI bereitzustellen, ist die wichtigste Regionsauswahl die für die Model Registry. Sie bestimmt die Verfügbarkeit von Maschinentypen und Quotas für dein Deployment.

Wenn du das Setup zudem erweiterst und Vorhersagedaten oder Ergebnisse in Cloud Storage oder BigQuery speicherst, musst du zudem dieselbe Region wie für die Model Registry verwenden, um die Latenz zu minimieren und einen hohen Durchsatz für den Datenzugriff sicherzustellen.