在 Vertex AI 上使用 Ultralytics 部署预训练的 YOLO 模型以进行推理

本指南将向您展示如何使用 Ultralytics 对预训练的 YOLO11 模型进行容器化，为其构建 FastAPI 推理服务器，并在 Google Cloud Vertex AI 上部署带有推理服务器的模型。示例实现将涵盖 YOLO11 的对象检测用例，但相同的原则适用于使用其他 YOLO 模式。

在开始之前，您需要创建一个 Google Cloud Platform (GCP) 项目。作为新用户，您将获得 300 美元的 GCP 抵用金以供免费使用，此金额足以测试一个正在运行的设置，您可以稍后将其扩展到任何其他 YOLO11 用例，包括训练或批量和流式推理。

您将学到什么

使用 FastAPI 为 Ultralytics YOLO11 模型创建一个推理后端。
创建一个 GCP Artifact Registry 仓库来存储您的 Docker 镜像。
构建 Docker 镜像并将带有模型的镜像推送到 Artifact Registry。
在 Vertex AI 中导入您的模型。
创建一个 Vertex AI 端点并部署模型。

为什么要部署容器化的模型？

使用 Ultralytics 实现完全模型控制: 您可以使用自定义推理逻辑，完全控制预处理、后处理和响应格式。
Vertex AI 处理其余事务：它可以自动扩展，同时在配置计算资源、内存和 GPU 配置方面提供灵活性。
原生 GCP 集成和安全性：与 Cloud Storage、BigQuery、Cloud Functions、VPC 控制、IAM 策略和审计日志无缝设置。

准备工作

在您的机器上安装Docker。
安装Google Cloud SDK并验证以使用gcloud CLI。
强烈建议您阅读Ultralytics 的 Docker 快速入门指南，因为在遵循本指南的同时，您需要扩展官方 Ultralytics Docker 镜像之一。

1. 使用FastAPI创建一个推理后端

首先，您需要创建一个 FastAPI 应用程序，该应用程序将服务于 YOLO11 模型推理请求。此应用程序将处理模型加载、图像预处理和推理（预测）逻辑。

Vertex AI 合规性基础

Vertex AI 要求您的容器实现两个特定端点：

健康状况 端点 (/health）：必须返回 HTTP 状态 200 OK 当服务准备就绪时。
预测端点 (/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"

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)

使用 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.5 MB，而私有端点为 10 MB），以及强大的安全性和访问控制。

# 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 非常重要，因为如果没有专门的健康检查，其编排器将 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)

现在，您有了一个完整的 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. 使用您的应用程序扩展Ultralytics Docker镜像

Ultralytics 提供了多个 Docker 镜像，您可以将它们用作应用程序镜像的基础。Docker 将安装 Ultralytics 和必要的 GPU 驱动程序。

要使用 Ultralytics YOLO 模型的全部功能，你应该选择 CUDA 优化的图像以进行 GPU 推理。但是，如果 CPU 推理足以满足你的任务，你也可以通过选择仅使用 CPU 的图像来节省计算资源：

Dockerfile：CUDA 优化的镜像，用于 YOLO11 单/多 GPU 训练和推理。
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 和 /predict 端点，使用与之前相同的 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 中创建一个仓库

在 Google Cloud Console 中打开 Artifact Registry 页面。如果您是首次使用 Artifact Registry，系统可能会提示您先启用 Artifact Registry API。

Google Cloud Artifact Registry 创建仓库界面，显示仓库名称、区域选择和格式选项

选择创建存储库。
输入您的仓库名称。选择所需的区域，并对其他选项使用默认设置，除非您需要专门更改它们。

注意

区域选择可能会影响机器的可用性以及非企业用户的某些计算限制。您可以在 Vertex AI 官方文档中找到更多信息：Vertex AI 配额和限制

创建存储库后，将您的 PROJECT_ID、位置（区域）和存储库名称保存到您的密钥库或 .env 文件。稍后您将需要它们来标记您的 Docker 镜像并将其推送到 Artifact Registry。

向 Artifact Registry 验证 Docker

将您的 Docker 客户端验证到您刚刚创建的 Artifact Registry 仓库。在您的终端中运行以下命令：

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

将您的镜像标记并推送到 Artifact Registry

标记 Docker 镜像并将其推送到 Google Artifact Registry。

为您的图像使用唯一的标签

建议每次更新镜像时都使用唯一的标签。大多数 GCP 服务（包括 Vertex AI）都依赖于镜像标签来实现自动版本控制和扩展，因此使用语义版本控制或基于日期的标签是一个好习惯。

使用 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 中导入模型。

在 Google Cloud 导航菜单中，转到 Vertex AI > 模型注册表。或者，在 Google Cloud Console 顶部的搜索栏中搜索“Vertex AI”。
点击导入。
选择作为新模型导入。
选择区域。您可以选择与 Artifact Registry 存储库相同的区域，但您的选择应取决于您所在区域中机器类型和配额的可用性。
选择导入现有模型容器。
在 Container image 字段中，浏览您之前创建的 Artifact Registry 仓库，然后选择您刚刚推送的镜像。
向下滚动到“环境变量”部分，然后输入 predict 和 health 端点，以及您在 FastAPI 应用程序中定义的端口。
点击导入。Vertex AI 将需要几分钟来注册模型并准备部署。导入完成后，您将收到一封电子邮件通知。

5. 创建 Vertex AI 端点并部署您的模型

Vertex AI 中的端点与模型

在 Vertex AI 术语中，端点指的是已部署的模型，因为它们代表您发送推理请求的 HTTP 端点，而模型是存储在模型注册表中的已训练 ML 项目。

要部署模型，您需要在 Vertex AI 中创建一个 Endpoint。

在 Vertex AI 导航菜单中，转到端点。选择导入模型时使用的区域。单击创建。

Vertex AI 创建端点界面，显示端点名称输入字段和访问配置选项

输入端点名称。
对于访问，Vertex AI 建议使用私有 Vertex AI 端点。除了安全优势之外，如果选择私有端点，您还可以获得更高的负载限制，但是您需要配置 VPC 网络和防火墙规则以允许访问该端点。有关私有端点的更多说明，请参阅 Vertex AI 文档。
点击继续。
在“模型设置”对话框中，选择您之前导入的模型。现在，您可以为您的模型配置机器类型、内存和 GPU 设置。如果您期望高推理负载，请预留充足的内存，以确保没有 I/O 瓶颈，从而保证 YOLO11 的正常性能。
在加速器类型中，选择您要用于推理的 GPU 类型。如果您不确定选择哪个 GPU，可以从 NVIDIA T4 开始，它支持 CUDA。

区域和机器类型配额

请记住，某些地区的计算配额非常有限，因此您可能无法在您所在的地区选择某些机器类型或 GPU。如果这一点至关重要，请将您的部署区域更改为配额更大的区域。有关更多信息，请参阅 Vertex AI 官方文档：Vertex AI 配额和限制。
选择机器类型后，您可以单击“继续”。此时，您可以选择在 Vertex AI 中启用模型监控——这是一项额外的服务，可以跟踪您模型的性能并提供对其行为的见解。这是可选的，会产生额外的费用，因此请根据您的需求进行选择。点击“创建”。

Vertex AI 将花费几分钟（在某些区域最多 30 分钟）来部署模型。部署完成后，您将收到一封电子邮件通知。

6. 测试您已部署的模型

部署完成后，Vertex AI 将为您提供一个示例 API 接口来测试您的模型。

要测试远程推理，你可以使用提供的 cURL 命令或创建另一个 python 客户端库，该库将向已部署的模型发送请求。请记住，你需要先将图像编码为 base64，然后再将其发送到 /predict 端点。

Vertex AI 端点测试界面，显示用于向已部署的 YOLO11 模型发出预测请求的示例 cURL 命令

首次请求预计会有短暂延迟

与本地测试类似，首次请求时预计会有短暂延迟，因为 Ultralytics 需要在运行的容器中拉取并加载 YOLO11 模型。

恭喜！您已成功在 Google Cloud Vertex AI 上使用 Ultralytics 部署了预训练的 YOLO11 模型。

常见问题

我可以在没有 Docker 的情况下在 Vertex AI 上使用 Ultralytics YOLO 模型吗？

是的，但是您首先需要将模型导出为与 Vertex AI 兼容的格式，例如 TensorFlow、Scikit-learn 或 XGBoost。 Google Cloud 提供了一个关于运行 .pt 模型在 Vertex 上的部署，其中包含转换过程的完整概述：在 Vertex AI 上运行 PyTorch 模型.

请注意，最终的设置将仅依赖于 Vertex AI 标准服务层，并且不支持高级 Ultralytics 框架功能。由于 Vertex AI 完全支持容器化模型，并且能够根据您的部署配置自动扩展它们，因此您可以充分利用 Ultralytics YOLO 模型的功能，而无需将它们转换为不同的格式。

为什么 FastAPI 是用于提供 YOLO11 推理服务的理想选择？

FastAPI 为推理工作负载提供高吞吐量。异步支持允许处理多个并发请求，而不会阻塞主线程，这在服务计算机视觉模型时非常重要。

使用 FastAPI 进行自动请求/响应验证，可减少生产推理服务中的运行时错误。这对于输入格式一致性至关重要的对象检测 API 尤其有价值。

FastAPI 为您的推理管道增加了最少的计算开销，从而为模型执行和图像处理任务留出更多可用资源。

FastAPI 还支持 SSE（服务器发送事件），这对于流式推理场景非常有用。

为什么我需要多次选择区域？

这实际上是 Google Cloud Platform 的一项多功能特性，您需要为使用的每项服务选择一个区域。对于在 Vertex AI 上部署容器化模型的任务，您最重要的区域选择是模型注册表的区域。它将决定模型部署的机器类型和配额的可用性。

此外，如果您将扩展设置并将预测数据或结果存储在 Cloud Storage 或 BigQuery 中，您将需要使用与 Model Registry 相同的区域，以最大限度地减少延迟并确保数据访问的高吞吐量。

📅 1 个月前创建 ✏️ 1 个月前更新