Implante um modelo YOLO pré-treinado com Ultralytics no Vertex AI para inferência

Este guia mostrará como conteinerizar um modelo YOLO11 pré-treinado com Ultralytics, construir um servidor de inferência FastAPI para ele e implementar o modelo com o servidor de inferência no Google Cloud Vertex AI. A implementação de exemplo cobrirá o caso de uso de detecção de objetos para YOLO11, mas os mesmos princípios se aplicarão ao uso de outros modos YOLO.

Antes de começarmos, você precisará criar um projeto no Google Cloud Platform (GCP). Você recebe $300 em créditos do GCP para usar gratuitamente como um novo usuário, e esse valor é suficiente para testar uma configuração em execução que você pode estender posteriormente para qualquer outro caso de uso do YOLO11, incluindo treinamento ou inferência em lote e streaming.

O que você vai aprender

1. Crie um backend de inferência para o modelo Ultralytics YOLO11 usando FastAPI.
2. Crie um repositório GCP Artifact Registry para armazenar sua imagem Docker.
3. Construa e envie a imagem Docker com o modelo para o Artifact Registry.
4. Importe seu modelo no Vertex AI.
5. Crie um endpoint Vertex AI e implemente o modelo.

Pré-requisitos

1. Instale o Docker em sua máquina.
2. Instale o Google Cloud SDK e autentique-se para usar o gcloud CLI.
3. É altamente recomendável que você consulte o Guia de Início Rápido do Docker para Ultralytics, pois você precisará estender uma das imagens Docker oficiais da Ultralytics ao seguir este guia.

1. Criar um backend de inferência com FastAPI

Primeiro, você precisa criar um aplicativo FastAPI que servirá as solicitações de inferência do modelo YOLO11. Este aplicativo irá lidar com o carregamento do modelo, pré-processamento de imagem e lógica de inferência (predição).

Fundamentos de Conformidade do Vertex AI

O Vertex AI espera que o seu contentor implemente dois endpoints específicos:

1. Health endpoint (/health): Deve retornar o status HTTP 200 OK quando o serviço estiver pronto.

2. Prever endpoint (/predict): Aceita pedidos de previsão estruturados com imagens codificadas em base64 e parâmetros opcionais. Limites de tamanho de payload aplicam-se dependendo do tipo de endpoint.

   Os payloads de solicitação para o endpoint /predict devem seguir esta estrutura JSON:

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

Estrutura de pastas do projeto

A maior parte da nossa construção acontecerá dentro do contentor Docker, e a Ultralytics também carregará um modelo YOLO11 pré-treinado, para que possa manter a estrutura de pastas local simples:

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

Criar pyproject.toml com dependências

Para gerir convenientemente o seu projeto, crie um ficheiro pyproject.toml com as seguintes dependências:

[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 será usado para executar o servidor FastAPI.
• pillow será usado para processamento de imagem, mas não está limitado apenas a imagens PIL — a Ultralytics suporta muitos outros formatos.

Criar lógica de inferência com Ultralytics YOLO11

Agora que tem a estrutura do projeto e as dependências configuradas, pode implementar a lógica central de inferência YOLO11. Crie um ficheiro src/app.py que irá lidar com o carregamento do modelo, processamento de imagem e previsão, usando a API Python da 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

Isto irá carregar o modelo uma vez quando o contentor iniciar, e o modelo será partilhado por todos os pedidos. Se o seu modelo estiver a lidar com uma carga de inferência pesada, é recomendado selecionar um tipo de máquina com mais memória ao importar um modelo no Vertex AI num passo posterior.

Em seguida, crie duas funções de utilidade para processamento de imagem de entrada e saída com pillow. O YOLO11 suporta imagens PIL nativamente.

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

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

Finalmente, implemente a run_inference função que irá lidar com a detecção de objetos. Neste exemplo, iremos extrair bounding boxes, nomes de classes e scores de confiança das predições do modelo. A função retornará um dicionário com detecções e resultados brutos para processamento ou anotação adicionais.

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

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

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

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

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

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

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

Opcionalmente, você pode adicionar uma função para anotar a imagem com bounding boxes e rótulos usando o método de plotagem integrado da Ultralytics. Isso será útil se você quiser retornar imagens anotadas na resposta da predição.

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)

Criar servidor de inferência HTTP com FastAPI

Agora que você tem a lógica central de inferência do YOLO11, você pode criar uma aplicação FastAPI para servi-la. Isso incluirá os endpoints de verificação de saúde e predição exigidos pelo Vertex AI.

Primeiro, adicione os imports e configure o logging para o Vertex AI. Como o Vertex AI trata stderr como saída de erro, faz sentido direcionar os logs para stdout.

import sys

from loguru import logger

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

Para uma conformidade completa com o Vertex AI, defina os endpoints necessários em variáveis de ambiente e defina o limite de tamanho para as requisições. Recomenda-se usar endpoints privados do Vertex AI para implementações de produção. Desta forma, você terá um limite de payload de requisição maior (10 MB em vez de 1,5 MB para endpoints públicos), juntamente com segurança robusta e controle de acesso.

# 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

Adicione dois modelos Pydantic para validar suas requisições e respostas:

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


class PredictionResponse(BaseModel):
    predictions: list

Adicione o endpoint de verificação de saúde para verificar a prontidão do seu modelo. Isto é importante para o Vertex AI, pois sem uma verificação de saúde dedicada, seu orquestrador estará pingando sockets aleatórios e não será capaz de determinar se o modelo está pronto para a inferência. Sua verificação deve retornar 200 OK para sucesso e 503 Service Unavailable para falha:

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

Agora você tem tudo para implementar o endpoint de predição que irá lidar com as requisições de inferência. Ele aceitará um arquivo de imagem, executará a inferência e retornará os resultados. Note que a imagem deve ser codificada em base64, o que aumenta adicionalmente o tamanho do payload em até 33%.

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

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

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

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

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

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

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

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

            predictions.append(prediction)

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

        return PredictionResponse(predictions=predictions)

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

Finalmente, adicione o ponto de entrada da aplicação para executar o servidor FastAPI.

if __name__ == "__main__":
    import uvicorn

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

Agora você tem uma aplicação FastAPI completa que pode servir requisições de inferência YOLO11. Você pode testá-la localmente instalando as dependências e executando o servidor, por exemplo, com uv.

# Install dependencies
uv pip install -e .

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

Para testar o servidor, você pode consultar ambos os endpoints /health e /predict usando cURL. Coloque uma imagem de teste na pasta tests . Então, no seu Terminal, execute os seguintes comandos:

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

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

Você deverá receber uma resposta JSON com os objetos detectados. Na sua primeira requisição, espere um pequeno atraso, pois a Ultralytics precisa baixar e carregar o modelo YOLO11.

2. Estender a imagem Docker Ultralytics com sua aplicação

A Ultralytics fornece várias imagens Docker que você pode usar como base para a imagem da sua aplicação. O Docker irá instalar a Ultralytics e os drivers de GPU necessários.

Para usar todas as capacidades dos modelos YOLO da Ultralytics, você deve selecionar a imagem otimizada para CUDA para inferência em GPU. No entanto, se a inferência em CPU for suficiente para sua tarefa, você pode economizar recursos computacionais selecionando também a imagem somente para CPU:

• Dockerfile: Imagem otimizada para CUDA para treinamento e inferência YOLO11 single/multi-GPU.
• Dockerfile-cpu: Imagem somente para CPU para inferência YOLO11.

Criar uma imagem Docker para sua aplicação

Criar um Dockerfile na raiz do seu projeto com o seguinte conteúdo:

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

No exemplo, a imagem Docker oficial da Ultralytics ultralytics:latest é usado como base. Ele já contém o modelo YOLO11 e todas as dependências necessárias. O ponto de entrada do servidor é o mesmo que usamos para testar o aplicativo FastAPI localmente.

Construir e testar a imagem Docker

Agora você pode construir a imagem Docker com o seguinte comando:

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

Substitua IMAGE_NAME e IMAGE_VERSION com os valores desejados, por exemplo, yolo11-fastapi:0.1. Observe que você deve construir a imagem para a linux/amd64 arquitetura se estiver implantando no Vertex AI. O --platform parâmetro precisa ser definido explicitamente se você estiver construindo a imagem em um Apple Silicon Mac ou qualquer outra arquitetura não x86.

Após a conclusão da construção da imagem, você pode testar a imagem Docker localmente:

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

Seu contêiner Docker agora está executando um servidor FastAPI na porta 8080, pronto para aceitar solicitações de inferência. Você pode testar ambos os endpoints /health e /predict com os mesmos comandos cURL de antes:

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

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

3. Envie a imagem Docker para o GCP Artifact Registry

Para importar seu modelo em contêiner no Vertex AI, você precisa enviar a imagem Docker para o Google Cloud Artifact Registry. Se você ainda não tiver um repositório Artifact Registry, precisará criar um primeiro.

Crie um repositório no Google Cloud Artifact Registry

Abra a página do Artifact Registry no Google Cloud Console. Se você estiver usando o Artifact Registry pela primeira vez, poderá ser solicitado que você ative a API do Artifact Registry primeiro.

1. Selecione Criar Repositório.
2. Insira o nome do seu repositório. Selecione a região desejada e use as configurações padrão para outras opções, a menos que precise alterá-las especificamente.

1. Depois que o repositório for criado, salve seu PROJECT_ID, Localização (Região) e Nome do Repositório em seu cofre de segredos ou .env arquivo. Você precisará deles mais tarde para marcar e enviar sua imagem Docker para o Artifact Registry.

Autentique o Docker no Artifact Registry

Autentique seu cliente Docker no repositório Artifact Registry que você acabou de criar. Execute o seguinte comando em seu terminal:

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

Marque e envie sua imagem para o Artifact Registry

Marque e envie a imagem Docker para o Google Artifact Registry.

Marque sua imagem com o URL do repositório Artifact Registry. Substitua os espaços reservados pelos valores que você salvou anteriormente.

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

Envie a imagem marcada para o repositório Artifact Registry.

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

Aguarde a conclusão do processo. A imagem deverá aparecer no seu repositório do Artifact Registry.

Para obter instruções mais específicas sobre como trabalhar com imagens no Artifact Registry, consulte a documentação do Artifact Registry: Enviar e extrair imagens.

4. Importe seu modelo no Vertex AI

Usando a imagem Docker que você acabou de enviar, agora você pode importar o modelo no Vertex AI.

1. No menu de navegação do Google Cloud, vá para Vertex AI > Model Registry. Como alternativa, procure por "Vertex AI" na barra de pesquisa na parte superior do Google Cloud Console.

   

2. Clique em Importar.

3. Selecione Importar como um novo modelo.
4. Selecione a região. Você pode escolher a mesma região do seu repositório do Artifact Registry, mas sua seleção deve ser ditada pela disponibilidade de tipos de máquina e cotas em sua região.

5. Selecione Importar um contêiner de modelo existente.

   

6. No campo Imagem do contêiner, procure o repositório do Artifact Registry que você criou anteriormente e selecione a imagem que você acabou de enviar.

7. Role para baixo até a seção Variáveis de ambiente e insira os endpoints de previsão e health, e a porta que você definiu em seu aplicativo FastAPI.

   

8. Clique em Importar. O Vertex AI levará vários minutos para registrar o modelo e prepará-lo para a implantação. Você receberá uma notificação por e-mail assim que a importação for concluída.

5. Crie um Endpoint Vertex AI e implemente seu modelo

Para implantar um modelo, você precisa criar um Endpoint no Vertex AI.

1. No menu de navegação do Vertex AI, vá para Endpoints. Selecione a região que você usou ao importar seu modelo. Clique em Criar.

1. Insira o nome do Endpoint.
2. Para Acesso, o Vertex AI recomenda o uso de endpoints Vertex AI privados. Além dos benefícios de segurança, você obtém um limite de payload maior se selecionar um endpoint privado, no entanto, você precisará configurar sua rede VPC e regras de firewall para permitir o acesso ao endpoint. Consulte a documentação do Vertex AI para obter mais instruções sobre endpoints privados.
3. Clique em Continuar.
4. Na caixa de diálogo Configurações do modelo, selecione o modelo que você importou anteriormente. Agora você pode configurar o tipo de máquina, a memória e as configurações de GPU para o seu modelo. Reserve bastante memória se você estiver esperando altas cargas de inferência para garantir que não haja gargalos de E/S para o desempenho adequado do YOLO11.

5. Em Tipo de acelerador, selecione o tipo de GPU que você deseja usar para inferência. Se você não tiver certeza de qual GPU selecionar, você pode começar com NVIDIA T4, que é compatível com CUDA.

   Cotas de região e tipo de máquina

   Lembre-se de que certas regiões têm quotas de computação muito limitadas, portanto, você pode não conseguir selecionar certos tipos de máquina ou GPUs em sua região. Se isso for crítico, altere a região da sua implementação para uma com uma quota maior. Encontre mais informações na documentação oficial do Vertex AI: Quotas e limites do Vertex AI.

6. Depois que o tipo de máquina for selecionado, você pode clicar em Continuar. Neste ponto, você pode optar por ativar o monitoramento de modelo no Vertex AI — um serviço extra que rastreará o desempenho do seu modelo e fornecerá insights sobre seu comportamento. Isso é opcional e acarreta custos adicionais, portanto, selecione de acordo com suas necessidades. Clique em Criar.

O Vertex AI levará vários minutos (até 30 minutos em algumas regiões) para implantar o modelo. Você receberá uma notificação por e-mail quando a implantação for concluída.

6. Teste seu modelo implementado

Após a conclusão da implantação, o Vertex AI fornecerá uma interface de API de amostra para testar seu modelo.

Para testar a inferência remota, você pode usar o comando cURL fornecido ou criar outra biblioteca de cliente Python que enviará solicitações ao modelo implantado. Lembre-se de que você precisa codificar sua imagem para base64 antes de enviá-la para o /predict endpoint.

Parabéns! Você implantou com sucesso um modelo YOLO11 pré-treinado com Ultralytics no Google Cloud Vertex AI.

FAQ

Posso usar modelos Ultralytics YOLO no Vertex AI sem Docker?

Sim, no entanto, você precisará primeiro exportar o modelo para um formato compatível com o Vertex AI, como TensorFlow, Scikit-learn ou XGBoost. O Google Cloud fornece um guia sobre a execução de .pt modelos no Vertex com uma visão geral completa do processo de conversão: Executar modelos PyTorch no Vertex AI.

Observe que a configuração resultante dependerá apenas da camada de serviço padrão do Vertex AI e não oferecerá suporte aos recursos avançados da estrutura Ultralytics. Como o Vertex AI oferece suporte total a modelos em contêineres e é capaz de escalá-los automaticamente de acordo com sua configuração de implantação, ele permite que você aproveite todos os recursos dos modelos Ultralytics YOLO sem precisar convertê-los para um formato diferente.

Por que o FastAPI é uma boa escolha para servir a inferência YOLO11?

FastAPI oferece alto rendimento para cargas de trabalho de inferência. O suporte assíncrono permite lidar com várias solicitações simultâneas sem bloquear o thread principal, o que é importante ao servir modelos de visão computacional.

A validação automática de solicitação/resposta com FastAPI reduz os erros de tempo de execução em serviços de inferência de produção. Isso é particularmente valioso para APIs de detecção de objetos, onde a consistência do formato de entrada é crítica.

FastAPI adiciona uma sobrecarga computacional mínima ao seu pipeline de inferência, deixando mais recursos disponíveis para execução do modelo e tarefas de processamento de imagem.

FastAPI também oferece suporte a SSE (Server-Sent Events), que é útil para cenários de inferência de streaming.

Por que tenho que selecionar uma região tantas vezes?

Esta é, na verdade, uma funcionalidade de versatilidade do Google Cloud Platform, onde você precisa selecionar uma região para cada serviço que usa. Para a tarefa de implantação de um modelo em contêiner no Vertex AI, sua seleção de região mais importante é a do Model Registry. Ele determinará a disponibilidade de tipos de máquina e quotas para a implantação do seu modelo.

Além disso, se você for estender a configuração e armazenar dados de previsão ou resultados no Cloud Storage ou BigQuery, precisará usar a mesma região do Model Registry, para minimizar a latência e garantir alto rendimento para acesso aos dados.

📅 Criado há 1 mês ✏️ Atualizado há 1 mês

Comentários