Distribuisci un modello YOLO pre-addestrato con Ultralytics su Vertex AI per l'inferenza

Questa guida ti mostrerà come containerizzare un modello YOLO11 pre-addestrato con Ultralytics, costruire un server di inferenza FastAPI per esso e distribuire il modello con il server di inferenza su Google Cloud Vertex AI. L'implementazione di esempio coprirà il caso d'uso del rilevamento oggetti per YOLO11, ma gli stessi principi si applicheranno per l'utilizzo di altre modalità YOLO.

Prima di iniziare, dovrai creare un progetto Google Cloud Platform (GCP). Come nuovo utente, ricevi $300 di crediti GCP da utilizzare gratuitamente, e questo importo è sufficiente per testare una configurazione funzionante che puoi successivamente estendere per qualsiasi altro caso d'uso di YOLO11, inclusi l'addestramento o l'inferenza batch e streaming.

Cosa imparerai

1. Crea un backend di inferenza per il modello Ultralytics YOLO11 utilizzando FastAPI.
2. Crea un repository GCP Artifact Registry per archiviare la tua immagine Docker.
3. Costruisci e invia l'immagine Docker con il modello ad Artifact Registry.
4. Importa il tuo modello in Vertex AI.
5. Crea un endpoint Vertex AI e distribuisci il modello.

Prerequisiti

1. Installa Docker sulla tua macchina.
2. Installa Google Cloud SDK e autenticati per utilizzare la CLI gcloud.
3. Si consiglia vivamente di consultare la Guida rapida di Docker per Ultralytics, perché dovrai estendere una delle immagini Docker ufficiali di Ultralytics mentre segui questa guida.

1. Crea un backend di inferenza con FastAPI

Innanzitutto, devi creare un'applicazione FastAPI che servirà le richieste di inferenza del modello YOLO11. Questa applicazione gestirà il caricamento del modello, la pre-elaborazione delle immagini e la logica di inferenza (previsione).

Fondamenti di conformità di Vertex AI

Vertex AI si aspetta che il tuo container implementi due endpoint specifici:

1. Stato endpoint (/health): Deve restituire lo stato HTTP 200 OK quando il servizio è pronto.

2. Predizione endpoint (/predict): Accetta richieste di previsione strutturate con immagini codificate in base64 e parametri opzionali. Limiti di dimensione del payload si applicano a seconda del tipo di endpoint.

   I payload di richiesta per l'endpoint /predict devono seguire questa struttura JSON:

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

Struttura delle cartelle del progetto

La maggior parte della nostra build avverrà all'interno del container Docker e Ultralytics caricherà anche un modello YOLO11 pre-addestrato, quindi puoi mantenere la struttura delle cartelle locali semplice:

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

Crea pyproject.toml con le dipendenze

Per gestire comodamente il tuo progetto, crea un file pyproject.toml con le seguenti dipendenze:

[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 verrà utilizzato per eseguire il server FastAPI.
• pillow verrà utilizzato per l'elaborazione delle immagini, ma non sei limitato solo alle immagini PIL — Ultralytics supporta molti altri formati.

Crea la logica di inferenza con Ultralytics YOLO11

Ora che hai impostato la struttura del progetto e le dipendenze, puoi implementare la logica principale di inferenza YOLO11. Crea un file src/app.py che gestirà il caricamento del modello, l'elaborazione delle immagini e la previsione, utilizzando l'API Python di 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

Questo caricherà il modello una volta all'avvio del container e il modello sarà condiviso tra tutte le richieste. Se il tuo modello gestirà un carico di inferenza elevato, si consiglia di selezionare un tipo di macchina con più memoria quando si importa un modello in Vertex AI in una fase successiva.

Successivamente, crea due funzioni di utilità per l'elaborazione delle immagini di input e output con pillow. YOLO11 supporta nativamente le immagini 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()

Infine, implementa la funzione run_inference che gestirà il rilevamento degli oggetti. In questo esempio, estrarremo i riquadri di delimitazione, i nomi delle classi e i punteggi di confidenza dalle previsioni del modello. La funzione restituirà un dizionario con i rilevamenti e i risultati grezzi per ulteriori elaborazioni o annotazioni.

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}

Opzionalmente, puoi aggiungere una funzione per annotare l'immagine con bounding box ed etichette utilizzando il metodo di plotting integrato di Ultralytics. Questo sarà utile se desideri restituire immagini annotate nella risposta di previsione.

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)

Crea un server di inferenza HTTP con FastAPI

Ora che hai la logica di inferenza principale di YOLO11, puoi creare un'applicazione FastAPI per servirla. Questa includerà gli endpoint di health check e di previsione richiesti da Vertex AI.

Innanzitutto, aggiungi gli import e configura il logging per Vertex AI. Poiché Vertex AI considera stderr come output di errore, è consigliabile indirizzare i log 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")

Per una completa conformità con Vertex AI, definisci gli endpoint richiesti nelle variabili d'ambiente e imposta il limite di dimensione per le richieste. Si consiglia di utilizzare endpoint Vertex AI privati per le implementazioni di produzione. In questo modo, avrai un limite di payload di richiesta più elevato (10 MB invece di 1,5 MB per gli endpoint pubblici), insieme a una solida sicurezza e controllo degli accessi.

# 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

Aggiungi due modelli Pydantic per la convalida delle richieste e delle risposte:

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


class PredictionResponse(BaseModel):
    predictions: list

Aggiungi l'endpoint di health check per verificare la preparazione del tuo modello. Questo è importante per Vertex AI, poiché senza un health check dedicato, il suo orchestratore eseguirà il ping di socket casuali e non sarà in grado di determinare se il modello è pronto per l'inferenza. Il tuo controllo deve restituire 200 OK per il successo e 503 Service Unavailable per il fallimento:

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

Ora hai tutto il necessario per implementare l'endpoint di previsione che gestirà le richieste di inferenza. Accetterà un file immagine, eseguirà l'inferenza e restituirà i risultati. Tieni presente che l'immagine deve essere codificata in base64, il che aumenta ulteriormente le dimensioni del payload fino al 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)}")

Infine, aggiungi il punto di ingresso dell'applicazione per eseguire il server 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)

Ora hai un'applicazione FastAPI completa in grado di servire le richieste di inferenza YOLO11. Puoi testarla localmente installando le dipendenze ed eseguendo il server, ad esempio, con uv.

# Install dependencies
uv pip install -e .

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

Per testare il server, puoi interrogare entrambi gli /health e /predict endpoint utilizzando cURL. Inserisci un'immagine di prova nella cartella tests . Quindi, nel tuo Terminale, esegui i seguenti comandi:

# 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

Dovresti ricevere una risposta JSON con gli oggetti rilevati. Alla tua prima richiesta, prevedi un breve ritardo, poiché Ultralytics deve scaricare e caricare il modello YOLO11.

2. Estendi l'immagine Docker di Ultralytics con la tua applicazione

Ultralytics fornisce diverse immagini Docker che puoi utilizzare come base per l'immagine della tua applicazione. Docker installerà Ultralytics e i driver GPU necessari.

Per utilizzare tutte le funzionalità dei modelli Ultralytics YOLO, è necessario selezionare l'immagine ottimizzata per CUDA per l'inferenza su GPU. Tuttavia, se l'inferenza su CPU è sufficiente per la tua attività, puoi risparmiare risorse di calcolo selezionando anche l'immagine solo CPU:

• Dockerfile: Immagine ottimizzata per CUDA per l'addestramento e l'inferenza YOLO11 su singola/multi-GPU.
• Dockerfile-cpu: Immagine solo CPU per l'inferenza YOLO11.

Crea un'immagine Docker per la tua applicazione

Crea un Dockerfile nella root del tuo progetto con il seguente contenuto:

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

Nell'esempio, l'immagine Docker ufficiale di Ultralytics ultralytics:latest viene utilizzata come base. Contiene già il modello YOLO11 e tutte le dipendenze necessarie. L'entrypoint del server è lo stesso che abbiamo utilizzato per testare l'applicazione FastAPI localmente.

Costruisci e testa l'immagine Docker

Ora puoi costruire l'immagine Docker con il seguente comando:

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

Sostituisci IMAGE_NAME e IMAGE_VERSION con i valori desiderati, ad esempio, yolo11-fastapi:0.1. Si noti che è necessario creare l'immagine per l' linux/amd64 architettura se si esegue il deployment su Vertex AI. Il --platform parametro deve essere impostato esplicitamente se si sta creando l'immagine su un Mac Apple Silicon o su qualsiasi altra architettura non x86.

Una volta completata la creazione dell'immagine, è possibile testare l'immagine Docker localmente:

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

Il container Docker sta ora eseguendo un server FastAPI sulla porta 8080, pronto per accettare richieste di inferenza. È possibile testare sia l' /health che l' /predict endpoint con gli stessi comandi cURL di prima:

# 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. Carica l'immagine Docker su GCP Artifact Registry

Per importare il modello containerizzato in Vertex AI, è necessario caricare l'immagine Docker in Google Cloud Artifact Registry. Se non si dispone ancora di un repository Artifact Registry, sarà necessario crearne uno.

Crea un repository in Google Cloud Artifact Registry

Aprire la pagina di Artifact Registry nella Google Cloud Console. Se si utilizza Artifact Registry per la prima volta, potrebbe essere richiesto di abilitare prima l'API Artifact Registry.

1. Selezionare Crea repository.
2. Inserire il nome del repository. Selezionare la regione desiderata e utilizzare le impostazioni predefinite per le altre opzioni, a meno che non sia necessario modificarle specificamente.

1. Una volta creato il repository, salvare l'ID PROGETTO, la posizione (regione) e il nome del repository nel vault dei segreti o nel file .env . Saranno necessari in seguito per taggare e inviare l'immagine Docker all'Artifact Registry.

Autentica Docker su Artifact Registry

Autenticare il client Docker al repository Artifact Registry appena creato. Eseguire il seguente comando nel terminale:

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

Tagga e invia la tua immagine ad Artifact Registry

Taggare e inviare l'immagine Docker a Google Artifact Registry.

Taggare l'immagine con l'URL del repository Artifact Registry. Sostituire i segnaposto con i valori salvati in precedenza.

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

Inviare l'immagine taggata al repository Artifact Registry.

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

Attendere il completamento del processo. L'immagine dovrebbe ora essere visibile nel repository Artifact Registry.

Per istruzioni più specifiche su come lavorare con le immagini in Artifact Registry, consultare la documentazione di Artifact Registry: Push e pull di immagini.

4. Importa il tuo modello in Vertex AI

Utilizzando l'immagine Docker che hai appena inviato, ora puoi importare il modello in Vertex AI.

1. Nel menu di navigazione di Google Cloud, vai a Vertex AI > Registro modelli. In alternativa, cerca "Vertex AI" nella barra di ricerca nella parte superiore di Google Cloud Console.

   

2. Fai clic su Importa.

3. Seleziona Importa come nuovo modello.
4. Seleziona la regione. Puoi scegliere la stessa regione del tuo repository Artifact Registry, ma la tua selezione dovrebbe essere dettata dalla disponibilità di tipi di macchina e quote nella tua regione.

5. Seleziona Importa un container modello esistente.

   

6. Nel campo Immagine container, cerca il repository Artifact Registry creato in precedenza e seleziona l'immagine appena inviata.

7. Scorri verso il basso fino alla sezione Variabili d'ambiente e inserisci gli endpoint predict e health, e la porta che hai definito nella tua applicazione FastAPI.

   

8. Fai clic su Importa. Vertex AI impiegherà alcuni minuti per registrare il modello e prepararlo per la distribuzione. Riceverai una notifica via email una volta completata l'importazione.

5. Crea un endpoint Vertex AI e distribuisci il tuo modello

Per distribuire un modello, è necessario creare un endpoint in Vertex AI.

1. Nel menu di navigazione di Vertex AI, vai a Endpoint. Seleziona la regione utilizzata durante l'importazione del modello. Fai clic su Crea.

1. Inserisci il nome dell'endpoint.
2. Per l'accesso, Vertex AI consiglia di utilizzare endpoint Vertex AI privati. Oltre ai vantaggi in termini di sicurezza, si ottiene un limite di payload più elevato se si seleziona un endpoint privato, tuttavia sarà necessario configurare la rete VPC e le regole del firewall per consentire l'accesso all'endpoint. Consulta la documentazione di Vertex AI per ulteriori istruzioni sugli endpoint privati.
3. Fai clic su Continua.
4. Nella finestra di dialogo Impostazioni modello, seleziona il modello importato in precedenza. Ora puoi configurare il tipo di macchina, la memoria e le impostazioni della GPU per il tuo modello. Prevedi un'ampia memoria se prevedi carichi di inferenza elevati per garantire che non vi siano colli di bottiglia I/O per le corrette prestazioni di YOLO11.

5. In Tipo di acceleratore, seleziona il tipo di GPU che desideri utilizzare per l'inferenza. Se non sei sicuro di quale GPU selezionare, puoi iniziare con NVIDIA T4, che è supportata da CUDA.

   Quote di regione e tipo di macchina

   Ricorda che alcune regioni hanno quote di calcolo molto limitate, quindi potresti non essere in grado di selezionare determinati tipi di macchina o GPU nella tua regione. Se questo è fondamentale, cambia la regione della tua distribuzione con una con una quota maggiore. Trova maggiori informazioni nella documentazione ufficiale di Vertex AI: Quote e limiti di Vertex AI.

6. Una volta selezionato il tipo di macchina, puoi fare clic su Continua. A questo punto, puoi scegliere di abilitare il monitoraggio del modello in Vertex AI, un servizio extra che terrà traccia delle prestazioni del tuo modello e fornirà informazioni dettagliate sul suo comportamento. Questo è opzionale e comporta costi aggiuntivi, quindi seleziona in base alle tue esigenze. Fai clic su Crea.

Vertex AI impiegherà diversi minuti (fino a 30 minuti in alcune regioni) per distribuire il modello. Riceverai una notifica via email una volta completata la distribuzione.

6. Testa il tuo modello distribuito

Una volta completata la distribuzione, Vertex AI ti fornirà un'interfaccia API di esempio per testare il tuo modello.

Per testare l'inferenza remota, puoi utilizzare il comando cURL fornito o creare un'altra libreria client python che invierà richieste al modello distribuito. Ricorda che devi codificare la tua immagine in base64 prima di inviarla all' /predict endpoint.

Congratulazioni! Hai distribuito con successo un modello YOLO11 pre-addestrato con Ultralytics su Google Cloud Vertex AI.

FAQ

Posso usare i modelli Ultralytics YOLO su Vertex AI senza Docker?

Sì, tuttavia dovrai prima esportare il modello in un formato compatibile con Vertex AI, come TensorFlow, Scikit-learn o XGBoost. Google Cloud fornisce una guida sull'esecuzione di .pt modelli su Vertex con una panoramica completa del processo di conversione: Esegui modelli PyTorch su Vertex AI.

Tieni presente che la configurazione risultante si baserà solo sul livello di serving standard di Vertex AI e non supporterà le funzionalità avanzate del framework Ultralytics. Poiché Vertex AI supporta completamente i modelli containerizzati ed è in grado di scalarli automaticamente in base alla configurazione della tua distribuzione, ti consente di sfruttare tutte le funzionalità dei modelli YOLO di Ultralytics senza la necessità di convertirli in un formato diverso.

Perché FastAPI è una buona scelta per servire l'inferenza di YOLO11?

FastAPI fornisce un'elevata velocità di trasmissione per i carichi di lavoro di inferenza. Il supporto asincrono consente di gestire più richieste simultanee senza bloccare il thread principale, il che è importante quando si servono modelli di computer vision.

La convalida automatica di richieste/risposte con FastAPI riduce gli errori di runtime nei servizi di inferenza di produzione. Questo è particolarmente utile per le API di object detection in cui la coerenza del formato di input è fondamentale.

FastAPI aggiunge un overhead computazionale minimo alla tua pipeline di inferenza, lasciando più risorse disponibili per l'esecuzione del modello e le attività di elaborazione delle immagini.

FastAPI supporta anche SSE (Server-Sent Events), che è utile per scenari di streaming inference.

Perché devo selezionare una regione così tante volte?

Questa è in realtà una caratteristica di versatilità di Google Cloud Platform, in cui è necessario selezionare una regione per ogni servizio che si utilizza. Per l'attività di distribuzione di un modello containerizzato su Vertex AI, la selezione della regione più importante è quella per il Model Registry. Determinerà la disponibilità dei tipi di macchina e delle quote per la distribuzione del modello.

Inoltre, se estenderai la configurazione e memorizzerai i dati di predizione o i risultati in Cloud Storage o BigQuery, dovrai utilizzare la stessa regione del Model Registry, per ridurre al minimo la latenza e garantire un'elevata velocità di trasmissione per l'accesso ai dati.

📅 Creato 1 mese fa ✏️ Aggiornato 1 mese fa

Commenti