Разверните предварительно обученную модель YOLO с Ultralytics на Vertex AI для инференса

В этом руководстве показано, как контейнеризировать предварительно обученную модель YOLO11 с помощью Ultralytics, создать для нее сервер инференса FastAPI и развернуть модель с сервером инференса в Google Cloud Vertex AI. Пример реализации охватывает случай использования обнаружения объектов для YOLO11, но те же принципы будут применяться и для использования других режимов YOLO.

Прежде чем мы начнем, вам нужно будет создать проект Google Cloud Platform (GCP). Вы получаете 300 долларов США в виде кредитов GCP для бесплатного использования в качестве нового пользователя, и этой суммы достаточно, чтобы протестировать работающую установку, которую вы позже сможете расширить для любого другого варианта использования YOLO11, включая обучение или пакетный и потоковый инференс.

Что вы узнаете

1. Создайте бэкенд инференса для модели Ultralytics YOLO11, используя FastAPI.
2. Создайте репозиторий GCP Artifact Registry для хранения вашего Docker-образа.
3. Соберите и отправьте Docker-образ с моделью в Artifact Registry.
4. Импортируйте вашу модель в Vertex AI.
5. Создайте Endpoint Vertex AI и разверните модель.

Предварительные требования

1. Установите Docker на свою машину.
2. Установите Google Cloud SDK и пройдите аутентификацию для использования gcloud CLI.
3. Настоятельно рекомендуется ознакомиться с Руководством по быстрому старту Docker для Ultralytics, поскольку вам потребуется расширить один из официальных Docker-образов Ultralytics, следуя этому руководству.

1. Создайте бэкенд инференса с FastAPI

Сначала вам нужно создать приложение FastAPI, которое будет обслуживать запросы на инференс модели YOLO11. Это приложение будет обрабатывать загрузку модели, предварительную обработку изображений и логику инференса (предсказания).

Основы соответствия требованиям Vertex AI

Vertex AI ожидает, что ваш контейнер будет реализовывать две определенные конечные точки:

1. Health endpoint (/health): Должен возвращать HTTP-статус 200 OK , когда сервис готов.

2. Прогнозирование endpoint (/predict): Принимает структурированные запросы на предсказание с base64-encoded изображениями и опциональными параметрами. Ограничения на размер полезной нагрузки применяются в зависимости от типа конечной точки.

   Полезные нагрузки запросов для /predict endpoint должны соответствовать следующей JSON-структуре:

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

Структура папок проекта

Основная часть нашей сборки будет происходить внутри Docker-контейнера, и Ultralytics также загрузит предварительно обученную модель YOLO11, поэтому вы можете сохранить простую структуру локальной папки:

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

Создайте pyproject.toml с зависимостями

Для удобного управления проектом создайте pyproject.toml файл со следующими зависимостями:

[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 будет использоваться для запуска сервера FastAPI.
• pillow будет использоваться для обработки изображений, но вы не ограничены только изображениями PIL — Ultralytics поддерживает множество других форматов..

Создайте логику инференса с Ultralytics YOLO11

Теперь, когда у вас есть структура проекта и настроены зависимости, вы можете реализовать основную логику инференса YOLO11. Создайте src/app.py файл, который будет обрабатывать загрузку модели, обработку изображений и прогнозирование, используя Ultralytics Python API.

# 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

Это загрузит модель один раз при запуске контейнера, и модель будет использоваться совместно для всех запросов. Если ваша модель будет обрабатывать большую нагрузку инференса, рекомендуется выбрать тип машины с большим объемом памяти при импорте модели в Vertex AI на более позднем этапе.

Далее создайте две вспомогательные функции для обработки входных и выходных изображений с помощью pillow. YOLO11 изначально поддерживает изображения 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()

Наконец, реализуйте run_inference функцию, которая будет обрабатывать обнаружение объектов. В этом примере мы извлечем ограничивающие рамки, названия классов и оценки достоверности из предсказаний модели. Функция вернет словарь с обнаружениями и необработанными результатами для дальнейшей обработки или аннотации.

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}

При необходимости вы можете добавить функцию для аннотирования изображения ограничивающими рамками и метками, используя встроенный метод построения графиков Ultralytics. Это будет полезно, если вы хотите возвращать аннотированные изображения в ответе прогноза.

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)

Создайте HTTP-сервер инференса с FastAPI

Теперь, когда у вас есть основная логика инференса YOLO11, вы можете создать приложение FastAPI для его обслуживания. Это будет включать проверку работоспособности и конечные точки прогнозирования, необходимые Vertex AI.

Сначала добавьте импорты и настройте ведение журнала для Vertex AI. Поскольку Vertex AI рассматривает stderr как вывод ошибок, имеет смысл перенаправлять журналы в 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")

Для полного соответствия Vertex AI определите необходимые конечные точки в переменных среды и установите ограничение размера для запросов. Для производственных развертываний рекомендуется использовать частные конечные точки Vertex AI. Таким образом, вы получите более высокий лимит полезной нагрузки запроса (10 МБ вместо 1,5 МБ для общедоступных конечных точек) вместе с надежной безопасностью и контролем доступа.

# 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

Добавьте две модели Pydantic для проверки ваших запросов и ответов:

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


class PredictionResponse(BaseModel):
    predictions: list

Добавьте конечную точку проверки работоспособности, чтобы проверить готовность вашей модели. Это важно для Vertex AI, поскольку без выделенной проверки работоспособности его оркестратор будет пинговать случайные сокеты и не сможет определить, готова ли модель к инференсу. Ваша проверка должна вернуть 200 OK в случае успеха и 503 Service Unavailable в случае неудачи:

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

Теперь у вас есть все необходимое для реализации конечной точки прогнозирования, которая будет обрабатывать запросы инференса. Он будет принимать файл изображения, запускать инференс и возвращать результаты. Обратите внимание, что изображение должно быть закодировано в base64, что дополнительно увеличивает размер полезной нагрузки до 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)}")

Наконец, добавьте точку входа приложения для запуска сервера 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)

Теперь у вас есть полноценное приложение FastAPI, которое может обслуживать запросы инференса YOLO11. Вы можете протестировать его локально, установив зависимости и запустив сервер, например, с помощью uv.

# Install dependencies
uv pip install -e .

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

Чтобы протестировать сервер, вы можете запросить обе /health и /predict конечные точки, используя cURL. Поместите тестовое изображение в tests папку. Затем в вашем терминале выполните следующие команды:

# 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

Вы должны получить JSON-ответ с обнаруженными объектами. При первом запросе ожидайте небольшую задержку, поскольку Ultralytics необходимо загрузить и запустить модель YOLO11.

2. Расширьте Docker-образ Ultralytics вашим приложением

Ultralytics предоставляет несколько Docker-образов, которые можно использовать в качестве основы для образа вашего приложения. Docker установит Ultralytics и необходимые драйверы GPU.

Чтобы использовать все возможности моделей Ultralytics YOLO, следует выбрать CUDA-оптимизированный образ для инференса на GPU. Однако, если для вашей задачи достаточно инференса на CPU, вы можете сэкономить вычислительные ресурсы, выбрав образ только для CPU:

• Dockerfile: CUDA-оптимизированный образ для обучения и инференса YOLO11 на одном/нескольких GPU.
• Dockerfile-cpu: Образ только для CPU для инференса YOLO11.

Создайте Docker-образ для вашего приложения

Создайте Dockerfile в корневом каталоге вашего проекта со следующим содержимым:

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

В примере официальный Docker-образ Ultralytics ultralytics:latest используется в качестве основы. Он уже содержит модель YOLO11 и все необходимые зависимости. Entrypoint сервера такой же, как и при локальном тестировании приложения FastAPI.

Соберите и протестируйте Docker-образ

Теперь вы можете собрать Docker-образ с помощью следующей команды:

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

Замените IMAGE_NAME и IMAGE_VERSION с желаемыми значениями, например, yolo11-fastapi:0.1. Обратите внимание, что вы должны собрать образ для linux/amd64 архитектуры, если вы развертываете его в Vertex AI. Параметр --platform необходимо установить явно, если вы собираете образ на Apple Silicon Mac или любой другой архитектуре, отличной от x86.

После завершения сборки образа вы можете протестировать Docker-образ локально:

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

Ваш Docker-контейнер теперь запускает FastAPI-сервер на порту 8080, готовый принимать запросы на инференс. Вы можете протестировать оба /health и /predict endpoint с помощью тех же cURL-команд, что и раньше:

# 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. Загрузите Docker-образ в GCP Artifact Registry

Чтобы импортировать контейнеризированную модель в Vertex AI, необходимо загрузить Docker-образ в Google Cloud Artifact Registry. Если у вас еще нет репозитория Artifact Registry, вам потребуется сначала его создать.

Создайте репозиторий в Google Cloud Artifact Registry

Откройте страницу Artifact Registry в Google Cloud Console. Если вы используете Artifact Registry впервые, вам может быть предложено сначала включить Artifact Registry API.

1. Выберите Create Repository (Создать репозиторий).
2. Введите имя вашего репозитория. Выберите желаемый регион и используйте настройки по умолчанию для других параметров, если вам не нужно их специально изменять.

1. После создания репозитория сохраните свой PROJECT_ID, Location (Region) и Repository Name в хранилище секретов или .env файл. Они понадобятся вам позже для добавления тегов и отправки вашего Docker-образа в Artifact Registry.

Аутентифицируйте Docker в Artifact Registry

Аутентифицируйте ваш Docker-клиент в репозитории Artifact Registry, который вы только что создали. Выполните следующую команду в вашем терминале:

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

Пометьте и отправьте ваш образ в Artifact Registry

Добавьте тег и отправьте Docker-образ в Google Artifact Registry.

Пометьте свой образ URL-адресом репозитория Artifact Registry. Замените заполнители значениями, которые вы сохранили ранее.

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

Отправьте помеченный образ в репозиторий Artifact Registry.

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

Дождитесь завершения процесса. Теперь вы должны увидеть изображение в своем репозитории Artifact Registry.

Более подробные инструкции о том, как работать с образами в Artifact Registry, см. в документации Artifact Registry: Отправка и получение образов.

4. Импортируйте вашу модель в Vertex AI

Используя Docker-образ, который вы только что отправили, теперь вы можете импортировать модель в Vertex AI.

1. В меню навигации Google Cloud перейдите в Vertex AI > Model Registry. Или найдите "Vertex AI" в строке поиска в верхней части консоли Google Cloud.

   

2. Нажмите Import.

3. Выберите Import as a new model.
4. Выберите регион. Вы можете выбрать тот же регион, что и ваш репозиторий Artifact Registry, но ваш выбор должен определяться доступностью типов машин и квотами в вашем регионе.

5. Выберите Import an existing model container.

   

6. В поле Container image найдите репозиторий Artifact Registry, который вы создали ранее, и выберите образ, который вы только что отправили.

7. Прокрутите вниз до раздела Environment variables и введите конечные точки predict и health, а также порт, который вы определили в своем приложении FastAPI.

   

8. Нажмите Import. Vertex AI потребуется несколько минут, чтобы зарегистрировать модель и подготовить ее к развертыванию. Вы получите уведомление по электронной почте, когда импорт будет завершен.

5. Создайте Endpoint Vertex AI и разверните вашу модель

Чтобы развернуть модель, вам необходимо создать Endpoint в Vertex AI.

1. В меню навигации Vertex AI перейдите в Endpoints. Выберите регион, который вы использовали при импорте своей модели. Нажмите Create.

1. Введите имя конечной точки (Endpoint name).
2. Для доступа Vertex AI рекомендует использовать частные конечные точки Vertex AI. Помимо преимуществ в плане безопасности, при выборе частной конечной точки вы получаете более высокий лимит полезной нагрузки, однако вам потребуется настроить сеть VPC и правила брандмауэра, чтобы разрешить доступ к конечной точке. Обратитесь к документации Vertex AI для получения дополнительных инструкций по частным конечным точкам.
3. Нажмите Continue.
4. В диалоговом окне Model settings выберите модель, которую вы импортировали ранее. Теперь вы можете настроить тип машины, память и параметры GPU для вашей модели. Предусмотрите достаточный объем памяти, если вы ожидаете высоких нагрузок при выводе, чтобы избежать узких мест ввода-вывода для надлежащей производительности YOLO11.

5. В Accelerator type выберите тип GPU, который вы хотите использовать для инференса. Если вы не уверены, какой GPU выбрать, вы можете начать с NVIDIA T4, который поддерживается CUDA.

   Квоты на регион и тип машины

   Помните, что в некоторых регионах действуют очень ограниченные квоты на вычислительные ресурсы, поэтому вы не сможете выбрать определенные типы машин или GPU в своем регионе. Если это критично, измените регион развертывания на регион с большей квотой. Дополнительную информацию можно найти в официальной документации Vertex AI: Квоты и лимиты Vertex AI.

6. После выбора типа машины вы можете нажать Continue. На этом этапе вы можете включить мониторинг модели в Vertex AI — дополнительную службу, которая будет отслеживать производительность вашей модели и предоставлять информацию о ее поведении. Это необязательно и влечет за собой дополнительные расходы, поэтому выбирайте в соответствии с вашими потребностями. Нажмите Create.

Vertex AI потребуется несколько минут (до 30 минут в некоторых регионах) для развертывания модели. Вы получите уведомление по электронной почте после завершения развертывания.

6. Протестируйте развернутую модель

После завершения развертывания Vertex AI предоставит вам пример интерфейса API для тестирования вашей модели.

Чтобы протестировать удаленный инференс, вы можете использовать предоставленную команду cURL или создать другую клиентскую библиотеку Python, которая будет отправлять запросы к развернутой модели. Помните, что вам нужно закодировать изображение в base64, прежде чем отправлять его в /predict конечную точку.

Поздравляем! Вы успешно развернули предварительно обученную модель YOLO11 с Ultralytics в Google Cloud Vertex AI.

Часто задаваемые вопросы

Могу ли я использовать модели Ultralytics YOLO в Vertex AI без Docker?

Да, однако сначала вам нужно будет экспортировать модель в формат, совместимый с Vertex AI, например TensorFlow, Scikit-learn или XGBoost. Google Cloud предоставляет руководство по запуску .pt моделей на Vertex с полным обзором процесса преобразования: Запуск моделей PyTorch на Vertex AI.

Обратите внимание, что результирующая настройка будет полагаться только на стандартный уровень обслуживания Vertex AI и не будет поддерживать расширенные функции фреймворка Ultralytics. Поскольку Vertex AI полностью поддерживает контейнеризированные модели и может масштабировать их автоматически в соответствии с вашей конфигурацией развертывания, это позволяет вам использовать все возможности моделей Ultralytics YOLO без необходимости преобразования их в другой формат.

Почему FastAPI является хорошим выбором для обслуживания инференса YOLO11?

FastAPI обеспечивает высокую пропускную способность для рабочих нагрузок инференса. Асинхронная поддержка позволяет обрабатывать несколько одновременных запросов, не блокируя основной поток, что важно при обслуживании моделей компьютерного зрения.

Автоматическая проверка запросов/ответов с помощью FastAPI снижает количество ошибок времени выполнения в производственных сервисах инференса. Это особенно ценно для API обнаружения объектов, где критически важна согласованность формата ввода.

FastAPI добавляет минимальные вычислительные издержки в ваш конвейер инференса, оставляя больше ресурсов для выполнения модели и задач обработки изображений.

FastAPI также поддерживает SSE (Server-Sent Events), что полезно для сценариев потоковой передачи инференса.

Почему мне приходится так много раз выбирать регион?

На самом деле, это универсальная функция Google Cloud Platform, где вам необходимо выбирать регион для каждой используемой службы. Для задачи развертывания контейнеризованной модели на Vertex AI наиболее важным является выбор региона для Model Registry. Он определит доступность типов машин и квот для развертывания вашей модели.

Кроме того, если вы планируете расширить настройку и хранить данные прогнозирования или результаты в Cloud Storage или BigQuery, вам потребуется использовать тот же регион, что и для Model Registry, чтобы минимизировать задержку и обеспечить высокую пропускную способность для доступа к данным.

📅 Создано 1 месяц назад ✏️ Обновлено 1 месяц назад

Комментарии