コンテンツにスキップ

Ultralyticsを使用して、事前学習済みのYOLOモデルをVertex AIにデプロイして推論を行います。

このガイドでは、Ultralytics を使用して事前トレーニング済みの YOLO11 モデルをコンテナ化し、そのための FastAPI 推論サーバーを構築し、Google Cloud Vertex AI 上の推論サーバーでモデルをデプロイする方法を紹介します。この実装例では YOLO11 の物体検出の使用例を取り上げますが、同じ原則は他の YOLO モードを使用する場合にも適用されます。

始める前に、Google Cloud Platform (GCP) プロジェクトを作成する必要があります。新規ユーザーは GCP クレジットを 300 ドル分無料で利用でき、この金額で、トレーニング、バッチ推論、ストリーミング推論など、他の YOLO11 のユースケースに拡張できる実行設定をテストするのに十分です。

学習内容

  1. FastAPI を使用して、Ultralytics YOLO11 モデルの推論バックエンドを作成します。
  2. Docker イメージを保存するために、GCP Artifact Registry リポジトリを作成します。
  3. モデルを含む Docker イメージを構築し、Artifact Registry にプッシュします。
  4. Vertex AI にモデルをインポートします。
  5. Vertex AI エンドポイントを作成し、モデルをデプロイします。

コンテナ化されたモデルをデプロイする理由

  • Ultralytics による完全なモデル制御: 前処理、後処理、および応答フォーマットを完全に制御して、カスタム推論ロジックを使用できます。
  • Vertex AI が残りを処理: 自動的にスケールしますが、コンピューティングリソース、メモリ、および GPU 構成を柔軟に構成できます。
  • ネイティブ GCP 統合とセキュリティ: Cloud Storage、BigQuery、Cloud Functions、VPC コントロール、IAM ポリシー、および監査ログとのシームレスなセットアップ。

前提条件

  1. お使いのマシンにDockerをインストールします。
  2. Google Cloud SDKをインストールし、gcloud CLI を使用するための認証を行います。
  3. このガイドに従う際に、公式の Ultralytics Docker イメージのいずれかを拡張する必要があるため、Ultralytics の Docker クイックスタートガイドに目を通すことを強くお勧めします。

1. FastAPIで推論バックエンドを作成する

まず、YOLO11 モデルの推論リクエストを処理する FastAPI アプリケーションを作成する必要があります。このアプリケーションは、モデルのロード、画像の前処理、および推論(予測)ロジックを処理します。

Vertex AIコンプライアンスの基礎

Vertex AI は、コンテナが 2 つの特定のエンドポイントを実装することを期待しています。

  1. ヘルス エンドポイント (/health): HTTP ステータスを返す必要があります 200 OK サービスが利用可能になったら。
  2. 予測 エンドポイント (/predict)構造化された予測リクエストを以下で受け付けます。 base64エンコードされた 画像とオプションのパラメータ。 ペイロードサイズの制限 は、エンドポイントの種類によって適用されます。

    以下のエンドポイントに対するリクエストペイロードは /predict この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

重要なライセンスに関する注意

Ultralytics YOLO11モデルおよびフレームワークはAGPL-3.0の下でライセンスされており、重要なコンプライアンス要件があります。必ずUltralyticsのドキュメントでライセンス条項の遵守方法をご確認ください。

依存関係を持つ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"

Ultralytics YOLO11で推論ロジックを作成する

プロジェクト構造と依存関係が設定されたので、コアとなるYOLO11推論ロジックを実装できます。Ultralytics Python APIを使用して、モデルのロード、画像処理、および予測を処理する src/app.py ファイルを作成します。

# 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にモデルをインポートする際に、より多くのメモリを搭載したマシンタイプを選択することをお勧めします。

次に、入出力画像処理のために2つのユーティリティ関数を 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)

FastAPIでHTTP推論サーバーを作成する

コアとなる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エンドポイントを使用することを推奨します。これにより、堅牢なセキュリティとアクセス制御とともに、リクエストペイロードの制限が向上します(パブリックエンドポイントの場合は1.5MBに対し、10MB)。

# 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

リクエストとレスポンスを検証するために、2つのPydanticモデルを追加します。

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


class PredictionResponse(BaseModel):
    predictions: list

モデルの準備状態を確認するためのヘルスチェックエンドポイントを追加します。 これはVertex AIにとって重要です。専用のヘルスチェックがない場合、オーケストレーターがランダムなソケットにpingを送信し、モデルが推論の準備ができているかどうかを判断できないためです。チェックは成功時に 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)

これで、YOLO11推論リクエストを処理できる完全なFastAPIアプリケーションが完成しました。依存関係をインストールし、例えばuvを使用してサーバーを実行することで、ローカルでテストできます。

# Install dependencies
uv pip install -e .

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

サーバーをテストするには、cURLを使用して /health および /predict エンドポイントの両方にクエリを実行できます。テスト画像を 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. Ultralytics Dockerイメージをアプリケーションで拡張する

Ultralyticsは、アプリケーションイメージのベースとして使用できるいくつかのDockerイメージを提供しています。Dockerは、Ultralyticsと必要なGPUドライバーをインストールします。

Ultralytics YOLOモデルの全機能を活用するには、GPU推論用にCUDA最適化されたイメージを選択する必要があります。ただし、CPU推論で十分な場合は、CPU専用イメージを選択してコンピューティングリソースを節約することもできます。

  • Dockerfile:YOLO11のシングル/マルチGPUトレーニングおよび推論用にCUDA最適化されたイメージ。
  • Dockerfile-cpu:YOLO11推論用のCPU専用イメージ。

アプリケーションの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"]

この例では、公式のUltralytics Dockerイメージ ultralytics:latest がベースとして使用されています。これには、YOLO11モデルと必要なすべての依存関係がすでに含まれています。サーバーのエントリポイントは、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 の両方のエンドポイントを、以前と同じcURLコマンドでテストできます。 /predict

# 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にリポジトリを作成する

Google Cloud ConsoleでArtifact Registryページを開きます。Artifact Registryを初めて使用する場合は、最初にArtifact Registry APIを有効にするように求められることがあります。

リポジトリ名、リージョン選択、および形式オプションを示すGoogle Cloud Artifact Registryのリポジトリ作成インターフェース

  1. [リポジトリを作成]を選択します。
  2. リポジトリの名前を入力します。必要なリージョンを選択し、特に変更する必要がない限り、他のオプションにはデフォルト設定を使用します。

リージョンの選択は、マシンと非エンタープライズユーザーに対する特定のコンピューティング制限の可用性に影響を与える可能性があります。詳細については、Vertex AIの公式ドキュメントVertex AIのクォータと制限を参照してください。

  1. リポジトリが作成されたら、PROJECT_ID、場所(リージョン)、およびリポジトリ名をシークレットVaultまたは .env ファイルに保存します。これらは、Dockerイメージにタグを付けてArtifact Registryにプッシュするために後で必要になります。

DockerをArtifact Registryに認証する

作成したArtifact Registryリポジトリに対してDockerクライアントを認証します。ターミナルで次のコマンドを実行します。

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

イメージにタグを付けてArtifact Registryにプッシュする

Dockerイメージにタグを付けてGoogle Artifact Registryにプッシュします。

イメージには一意のタグを使用してください

イメージを更新するたびに、一意のタグを使用することをお勧めします。Vertex AIを含むほとんどのGCPサービスは、自動バージョニングとスケーリングのためにイメージタグに依存しているため、セマンティックバージョニングまたは日付ベースのタグを使用することをお勧めします。

Artifact RegistryリポジトリURLでイメージにタグを付けます。プレースホルダーを、以前に保存した値に置き換えます。

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] > [モデルレジストリ]に移動します。または、Google Cloud Consoleの上部にある検索バーで「Vertex AI」を検索します。

    新しいモデルをインポートするために強調表示された [インポート] ボタンがある Vertex AI Model Registry インターフェース

  2. [インポート] をクリックします。

  3. [新しいモデルとしてインポート] を選択します。
  4. リージョンを選択します。Artifact Registry リポジトリと同じリージョンを選択できますが、選択はお使いのリージョンでのマシンタイプとクォータの可用性によって決まるはずです。
  5. [既存のモデルコンテナをインポート] を選択します。

    コンテナイメージの選択とモデル構成オプションを示す Vertex AI モデルのインポートダイアログ

  6. [コンテナイメージ] フィールドで、以前に作成した Artifact Registry リポジトリを参照し、プッシュしたばかりのイメージを選択します。

  7. 下にスクロールして [環境変数] セクションに移動し、FastAPI アプリケーションで定義した predict エンドポイント、health エンドポイント、およびポートを入力します。

    FastAPI エンドポイントの予測ルート、ヘルスルート、およびポート設定を示す Vertex AI 環境変数構成

  8. [インポート] をクリックします。Vertex AI は、モデルを登録し、デプロイの準備をするのに数分かかります。インポートが完了すると、メール通知が届きます。

5. Vertex AI エンドポイントを作成し、モデルをデプロイします

Vertex AI のエンドポイントとモデル

Vertex AI の用語では、エンドポイントは、推論リクエストを送信する HTTP エンドポイントを表すため、デプロイされたモデルを指します。一方、モデルは、Model Registry に保存されているトレーニング済みの ML アーティファクトです。

モデルをデプロイするには、Vertex AI でエンドポイントを作成する必要があります。

  1. Vertex AI のナビゲーションメニューで、[エンドポイント] に移動します。モデルのインポート時に使用したリージョンを選択します。[作成] をクリックします。

エンドポイント名入力フィールドとアクセス構成オプションを示す Vertex AI エンドポイント作成インターフェース

  1. エンドポイント名を入力します。
  2. アクセスの場合、Vertex AI はプライベート Vertex AI エンドポイントを使用することを推奨しています。セキュリティ上の利点とは別に、プライベートエンドポイントを選択すると、より高いペイロード制限が得られます。ただし、エンドポイントへのアクセスを許可するように VPC ネットワークとファイアウォールルールを構成する必要があります。プライベートエンドポイントの詳細については、Vertex AI のドキュメントを参照してください。
  3. [続行] をクリックします。
  4. [モデル設定] ダイアログで、以前にインポートしたモデルを選択します。これで、モデルのマシンタイプ、メモリ、および GPU 設定を構成できます。適切な YOLO11 のパフォーマンスのために I/O ボトルネックが発生しないように、高い推論負荷が予想される場合は、十分なメモリを確保してください。
  5. [アクセラレータタイプ] で、推論に使用する GPU タイプを選択します。どの GPU を選択すればよいかわからない場合は、CUDA をサポートしている NVIDIA T4 から始めることができます。

    リージョンとマシンタイプのクォータ

    特定のリージョンではコンピューティングクォータが非常に限られているため、特定のリージョンでは特定のマシンタイプまたは GPU を選択できない場合があることに注意してください。これが重要な場合は、デプロイのリージョンをより大きなクォータを持つリージョンに変更してください。詳細については、Vertex AI の公式ドキュメント「Vertex AI のクォータと制限」を参照してください。

  6. マシンタイプを選択したら、[続行] をクリックします。この時点で、Vertex AI でモデルモニタリングを有効にすることを選択できます。これは、モデルのパフォーマンスを追跡し、その動作に関する洞察を提供する追加のサービスです。これはオプションであり、追加費用が発生するため、ニーズに応じて選択してください。[作成] をクリックします。

Vertex AI は、モデルをデプロイするのに数分 (一部のリージョンでは最大 30 分) かかります。デプロイが完了すると、メール通知が届きます。

6. デプロイしたモデルをテストします

デプロイが完了すると、Vertex AI はモデルをテストするためのサンプル API インターフェースを提供します。

リモート推論をテストするには、提供されているcURLコマンドを使用するか、デプロイされたモデルにリクエストを送信する別のpythonクライアントライブラリを作成します。エンドポイントに送信する前に、画像をbase64にエンコードする必要があることに注意してください。 /predict エンドポイント。

デプロイされたYOLO11モデルに予測リクエストを行うためのサンプルcURLコマンドを表示するVertex AIエンドポイントテストインターフェース

最初のリクエストでは短い遅延が発生することが予想されます

ローカルテストと同様に、Ultralyticsが実行中のコンテナにYOLO11モデルをpullしてロードする必要があるため、最初のリクエストでは短い遅延が発生することが予想されます。

おめでとうございます! Ultralyticsを使用して、Google Cloud Vertex AIに事前トレーニング済みのYOLO11モデルを正常にデプロイできました。

よくある質問

Docker なしで Ultralytics YOLO モデルを Vertex AI で使用できますか?

はい。ただし、最初にTensorFlow、Scikit-learn、XGBoostなど、Vertex AIと互換性のある形式でモデルをエクスポートする必要があります。 Google Cloudは、実行に関するガイドを提供しています .pt 変換プロセスの完全な概要を含むVertex上のモデル: Vertex AIでPyTorchモデルを実行する.

結果として得られるセットアップは、Vertex AI標準サービングレイヤーのみに依存し、高度なUltralyticsフレームワーク機能をサポートしないことに注意してください。 Vertex AIはコンテナ化されたモデルを完全にサポートし、デプロイ構成に応じて自動的にスケーリングできるため、Ultralytics YOLOモデルを別の形式に変換しなくても、そのすべての機能を活用できます。

FastAPI が YOLO11 推論の提供に適しているのはなぜですか?

FastAPIは、推論ワークロードに対して高いスループットを提供します。 Asyncサポートにより、メインスレッドをブロックせずに複数の同時リクエストを処理できます。これは、コンピュータビジョンモデルを提供する場合に重要です。

FastAPIによる自動リクエスト/レスポンス検証により、本番環境の推論サービスでのランタイムエラーが削減されます。 これは、入力形式の一貫性が重要なオブジェクト検出APIで特に役立ちます。

FastAPIは、推論パイプラインへの計算オーバーヘッドを最小限に抑え、モデルの実行および画像処理タスクに使用できるリソースを増やします。

FastAPIはSSE(Server-Sent Events)もサポートしており、ストリーミング推論シナリオに役立ちます。

なぜリージョンを何度も選択する必要があるのですか?

これは実際にはGoogle Cloud Platformの多様性機能であり、使用するすべてのサービスに対してリージョンを選択する必要があります。 Vertex AIにコンテナ化されたモデルをデプロイするタスクの場合、最も重要なリージョン選択はモデルレジストリのリージョン選択です。 これにより、モデルデプロイメントのマシンタイプとクォータの可用性が決まります。

さらに、セットアップを拡張し、予測データまたは結果をCloud StorageまたはBigQueryに保存する場合は、レイテンシーを最小限に抑え、データアクセスの高スループットを確保するために、モデルレジストリと同じリージョンを使用する必要があります。



📅 作成日 1か月前 ✏️ 更新日 1か月前

コメント