Triển khai mô hình YOLO được huấn luyện trước với Ultralytics trên Vertex AI để suy luận

Hướng dẫn này sẽ chỉ cho bạn cách đóng gói một mô hình YOLO11 đã được huấn luyện trước bằng Ultralytics, xây dựng một máy chủ suy luận FastAPI cho nó và triển khai mô hình với máy chủ suy luận trên Google Cloud Vertex AI. Ví dụ triển khai sẽ bao gồm trường hợp sử dụng phát hiện đối tượng cho YOLO11, nhưng các nguyên tắc tương tự sẽ được áp dụng cho việc sử dụng các chế độ YOLO khác.

Trước khi bắt đầu, bạn sẽ cần tạo một dự án Google Cloud Platform (GCP). Bạn nhận được 300 đô la tín dụng GCP để sử dụng miễn phí với tư cách là người dùng mới và số tiền này đủ để kiểm tra thiết lập đang chạy mà sau này bạn có thể mở rộng cho bất kỳ trường hợp sử dụng YOLO11 nào khác, bao gồm huấn luyện hoặc suy luận hàng loạt và phát trực tuyến.

Bạn sẽ học được gì

1. Tạo một backend suy luận cho mô hình Ultralytics YOLO11 bằng FastAPI.
2. Tạo kho lưu trữ GCP Artifact Registry để lưu trữ ảnh Docker của bạn.
3. Xây dựng và đẩy Docker image chứa mô hình lên Artifact Registry.
4. Nhập mô hình của bạn vào Vertex AI.
5. Tạo một điểm cuối Vertex AI và triển khai mô hình.

Điều Kiện Tiên Quyết

1. Cài đặt Docker trên máy của bạn.
2. Cài đặt Google Cloud SDK và xác thực để sử dụng gcloud CLI.
3. Bạn nên xem qua Hướng dẫn Bắt đầu Nhanh Docker cho Ultralytics, vì bạn sẽ cần mở rộng một trong các ảnh Docker Ultralytics chính thức trong khi làm theo hướng dẫn này.

1. Tạo một backend suy luận bằng FastAPI

Đầu tiên, bạn cần tạo một ứng dụng FastAPI để phục vụ các yêu cầu suy luận mô hình YOLO11. Ứng dụng này sẽ xử lý việc tải mô hình, tiền xử lý hình ảnh và logic suy luận (dự đoán).

Các Nguyên tắc Cơ bản về Tuân thủ Vertex AI

Vertex AI yêu cầu container của bạn triển khai hai điểm cuối cụ thể:

1. Sức khỏe điểm cuối (/health): Phải trả về trạng thái HTTP 200 OK khi dịch vụ đã sẵn sàng.

2. Dự đoán điểm cuối (/predict): Chấp nhận các yêu cầu dự đoán có cấu trúc với được mã hóa base64 hình ảnh và các tham số tùy chọn. Giới hạn kích thước Payload áp dụng tùy thuộc vào loại điểm cuối.

   Yêu cầu tải trọng cho /predict điểm cuối nên tuân theo cấu trúc JSON này:

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

Cấu trúc thư mục dự án

Phần lớn quá trình xây dựng của chúng ta sẽ diễn ra bên trong Docker container và Ultralytics cũng sẽ tải một mô hình YOLO11 đã được huấn luyện trước, vì vậy bạn có thể giữ cho cấu trúc thư mục cục bộ đơn giản:

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

Tạo pyproject.toml với các dependency

Để quản lý dự án của bạn một cách thuận tiện, hãy tạo một pyproject.toml tập tin với các dependency (phụ thuộc) sau:

[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 sẽ được sử dụng để chạy máy chủ FastAPI.
• pillow sẽ được sử dụng để xử lý hình ảnh, nhưng bạn không bị giới hạn chỉ với hình ảnh PIL — Ultralytics hỗ trợ nhiều định dạng khác.

Tạo logic suy luận với Ultralytics YOLO11

Bây giờ bạn đã thiết lập cấu trúc dự án và các phần phụ thuộc, bạn có thể triển khai logic suy luận YOLO11 cốt lõi. Tạo một src/app.py tập tin sẽ xử lý việc tải mô hình, xử lý ảnh và dự đoán, bằng cách sử dụng 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

Thao tác này sẽ tải mô hình một lần khi container khởi động và mô hình sẽ được chia sẻ trên tất cả các yêu cầu. Nếu mô hình của bạn sẽ xử lý tải suy luận lớn, bạn nên chọn loại máy có nhiều bộ nhớ hơn khi nhập mô hình vào Vertex AI ở bước sau.

Tiếp theo, tạo hai hàm tiện ích để xử lý hình ảnh đầu vào và đầu ra với pillow. YOLO11 hỗ trợ ảnh PIL một cách tự nhiên.

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()

Cuối cùng, triển khai run_inference function sẽ xử lý việc phát hiện đối tượng. Trong ví dụ này, chúng ta sẽ trích xuất các hộp giới hạn, tên lớp và điểm tin cậy từ các dự đoán của mô hình. Function sẽ trả về một từ điển chứa các phát hiện và kết quả thô để xử lý hoặc chú thích thêm.

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}

Tùy chọn, bạn có thể thêm một hàm để chú thích hình ảnh bằng các hộp giới hạn và nhãn sử dụng phương pháp vẽ tích hợp sẵn của Ultralytics. Điều này sẽ hữu ích nếu bạn muốn trả về hình ảnh đã được chú thích trong phản hồi dự đoán.

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)

Tạo máy chủ suy luận HTTP bằng FastAPI

Bây giờ bạn đã có logic suy luận YOLO11 cốt lõi, bạn có thể tạo một ứng dụng FastAPI để phục vụ nó. Ứng dụng này sẽ bao gồm kiểm tra sức khỏe và các điểm cuối dự đoán theo yêu cầu của Vertex AI.

Đầu tiên, thêm các lệnh nhập và định cấu hình ghi nhật ký cho Vertex AI. Vì Vertex AI coi stderr là đầu ra lỗi, nên việc chuyển các nhật ký đến stdout là hợp lý.

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")

Để hoàn toàn tuân thủ Vertex AI, hãy xác định các điểm cuối cần thiết trong các biến môi trường và đặt giới hạn kích thước cho các yêu cầu. Bạn nên sử dụng các điểm cuối Vertex AI riêng tư cho các triển khai sản xuất. Bằng cách này, bạn sẽ có giới hạn tải trọng yêu cầu cao hơn (10 MB thay vì 1,5 MB cho các điểm cuối công khai), cùng với bảo mật mạnh mẽ và kiểm soát truy cập.

# 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

Thêm hai mô hình Pydantic để xác thực các yêu cầu và phản hồi của bạn:

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


class PredictionResponse(BaseModel):
    predictions: list

Thêm điểm cuối kiểm tra sức khỏe để xác minh khả năng sẵn sàng của mô hình. Điều này rất quan trọng đối với Vertex AI, vì nếu không có kiểm tra sức khỏe chuyên dụng, trình điều phối của nó sẽ ping các socket ngẫu nhiên và sẽ không thể xác định xem mô hình đã sẵn sàng cho suy luận hay chưa. Kiểm tra của bạn phải trả về 200 OK cho sự thành công và 503 Service Unavailable khi thất bại:

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

Bây giờ bạn đã có mọi thứ để triển khai điểm cuối dự đoán để xử lý các yêu cầu suy luận. Nó sẽ chấp nhận một tệp hình ảnh, chạy suy luận và trả về kết quả. Lưu ý rằng hình ảnh phải được mã hóa base64, điều này làm tăng thêm kích thước của payload lên đến 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)}")

Cuối cùng, thêm điểm truy cập ứng dụng để chạy máy chủ 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)

Bây giờ bạn đã có một ứng dụng FastAPI hoàn chỉnh có thể phục vụ các yêu cầu suy luận YOLO11. Bạn có thể kiểm tra nó cục bộ bằng cách cài đặt các dependency và chạy máy chủ, ví dụ: với uv.

# Install dependencies
uv pip install -e .

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

Để kiểm tra máy chủ, bạn có thể truy vấn cả /health và /predict các điểm cuối bằng cURL. Đặt một ảnh thử nghiệm vào tests . Sau đó, trong Terminal, hãy chạy các lệnh sau:

# 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

Bạn sẽ nhận được phản hồi JSON với các đối tượng được phát hiện. Trong yêu cầu đầu tiên của bạn, hãy dự kiến một độ trễ ngắn, vì Ultralytics cần kéo và tải mô hình YOLO11.

2. Mở rộng Docker image Ultralytics bằng ứng dụng của bạn

Ultralytics cung cấp một số Docker image mà bạn có thể sử dụng làm cơ sở cho application image của mình. Docker sẽ cài đặt Ultralytics và các driver GPU cần thiết.

Để sử dụng đầy đủ các khả năng của mô hình Ultralytics YOLO, bạn nên chọn ảnh được tối ưu hóa CUDA để suy luận GPU. Tuy nhiên, nếu suy luận CPU là đủ cho tác vụ của bạn, bạn có thể tiết kiệm tài nguyên tính toán bằng cách chọn ảnh chỉ dành cho CPU:

• Dockerfile: Ảnh được tối ưu hóa CUDA cho huấn luyện và suy luận YOLO11 đơn/đa GPU.
• Dockerfile-cpu: Ảnh chỉ CPU cho suy luận YOLO11.

Tạo một ảnh Docker cho ứng dụng của bạn

Tạo một Dockerfile trong thư mục gốc của dự án của bạn với nội dung sau:

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

Trong ví dụ, ảnh Ultralytics Docker chính thức ultralytics:latest được sử dụng làm cơ sở. Nó đã chứa mô hình YOLO11 và tất cả các phụ thuộc cần thiết. Entrypoint của máy chủ giống như chúng ta đã sử dụng để kiểm tra ứng dụng FastAPI cục bộ.

Xây dựng và kiểm tra Docker image

Bây giờ bạn có thể xây dựng Docker image bằng lệnh sau:

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

Thay thế IMAGE_NAME và IMAGE_VERSION với các giá trị bạn muốn, ví dụ: yolo11-fastapi:0.1. Lưu ý rằng bạn phải xây dựng image cho linux/amd64 kiến trúc nếu bạn đang triển khai trên Vertex AI. Các --platform tham số cần được đặt rõ ràng nếu bạn đang xây dựng hình ảnh trên Apple Silicon Mac hoặc bất kỳ kiến trúc không phải x86 nào khác.

Sau khi quá trình xây dựng hình ảnh hoàn tất, bạn có thể kiểm tra hình ảnh Docker cục bộ:

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

Docker container của bạn hiện đang chạy máy chủ FastAPI trên cổng 8080, sẵn sàng chấp nhận các yêu cầu suy luận. Bạn có thể kiểm tra cả hai /health và /predict điểm cuối với các lệnh cURL tương tự như trước:

# 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. Tải Docker image lên GCP Artifact Registry

Để nhập mô hình được chứa trong container của bạn vào Vertex AI, bạn cần tải ảnh Docker lên Google Cloud Artifact Registry. Nếu bạn chưa có kho lưu trữ Artifact Registry, bạn sẽ cần tạo một kho trước.

Tạo một kho lưu trữ trong Google Cloud Artifact Registry

Mở trang Artifact Registry trong Google Cloud Console. Nếu bạn sử dụng Artifact Registry lần đầu tiên, bạn có thể được nhắc bật Artifact Registry API trước.

1. Chọn Tạo kho lưu trữ.
2. Nhập tên kho lưu trữ của bạn. Chọn khu vực mong muốn và sử dụng cài đặt mặc định cho các tùy chọn khác, trừ khi bạn cần thay đổi chúng một cách cụ thể.

1. Sau khi kho lưu trữ được tạo, hãy lưu PROJECT_ID, Vị trí (Khu vực) và Tên kho lưu trữ vào kho bí mật của bạn hoặc .env tập tin. Bạn sẽ cần chúng sau này để gắn thẻ và đẩy ảnh Docker của bạn lên Artifact Registry.

Xác thực Docker với Artifact Registry

Xác thực Docker client của bạn với kho lưu trữ Artifact Registry mà bạn vừa tạo. Chạy lệnh sau trong terminal của bạn:

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

Gắn thẻ và đẩy hình ảnh của bạn lên Artifact Registry

Gắn thẻ và đẩy Docker image lên Google Artifact Registry.

Gắn thẻ image của bạn với URL kho lưu trữ Artifact Registry. Thay thế các phần giữ chỗ bằng các giá trị bạn đã lưu trước đó.

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

Đẩy ảnh đã gắn thẻ lên kho lưu trữ Artifact Registry.

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

Đợi quá trình hoàn tất. Bây giờ bạn sẽ thấy hình ảnh trong kho lưu trữ Artifact Registry của mình.

Để biết hướng dẫn cụ thể hơn về cách làm việc với hình ảnh trong Artifact Registry, hãy xem tài liệu Artifact Registry: Đẩy và kéo hình ảnh.

4. Nhập mô hình của bạn vào Vertex AI

Sử dụng ảnh Docker bạn vừa đẩy, giờ đây bạn có thể nhập mô hình vào Vertex AI.

1. Trong menu điều hướng của Google Cloud, hãy chuyển đến Vertex AI > Model Registry. Ngoài ra, hãy tìm kiếm "Vertex AI" trong thanh tìm kiếm ở đầu Google Cloud Console.

   

2. Nhấp vào Nhập.

3. Chọn Nhập làm mô hình mới.
4. Chọn khu vực. Bạn có thể chọn cùng khu vực với kho lưu trữ Artifact Registry của mình, nhưng lựa chọn của bạn phải được quyết định bởi tính khả dụng của các loại máy và hạn ngạch trong khu vực của bạn.

5. Chọn Nhập một vùng chứa mô hình hiện có.

   

6. Trong trường Container image, hãy duyệt kho lưu trữ Artifact Registry mà bạn đã tạo trước đó và chọn ảnh bạn vừa đẩy.

7. Cuộn xuống phần Biến môi trường và nhập các điểm cuối dự đoán và kiểm tra sức khỏe, cùng với cổng mà bạn đã xác định trong ứng dụng FastAPI của mình.

   

8. Nhấp vào Nhập. Vertex AI sẽ mất vài phút để đăng ký mô hình và chuẩn bị cho việc triển khai. Bạn sẽ nhận được thông báo qua email sau khi quá trình nhập hoàn tất.

5. Tạo một Endpoint Vertex AI và triển khai mô hình của bạn

Để triển khai một mô hình, bạn cần tạo một Endpoint trong Vertex AI.

1. Trong menu điều hướng Vertex AI của bạn, hãy chuyển đến Điểm cuối. Chọn khu vực bạn đã sử dụng khi nhập mô hình của mình. Nhấp vào Tạo.

1. Nhập tên Endpoint.
2. Để truy cập, Vertex AI khuyên bạn nên sử dụng các điểm cuối Vertex AI riêng tư. Ngoài các lợi ích về bảo mật, bạn sẽ nhận được giới hạn tải trọng cao hơn nếu bạn chọn một điểm cuối riêng tư, tuy nhiên bạn sẽ cần định cấu hình mạng VPC và các quy tắc tường lửa để cho phép truy cập vào điểm cuối. Tham khảo tài liệu Vertex AI để biết thêm hướng dẫn về các điểm cuối riêng tư.
3. Nhấp vào Tiếp tục.
4. Trên hộp thoại Model settings (Cài đặt mô hình), hãy chọn mô hình bạn đã nhập trước đó. Bây giờ bạn có thể định cấu hình loại máy, bộ nhớ và cài đặt GPU cho mô hình của mình. Hãy cấp đủ bộ nhớ nếu bạn dự kiến tải suy luận cao để đảm bảo không có tắc nghẽn I/O cho hiệu suất YOLO11 thích hợp.

5. Trong loại Trình tăng tốc, hãy chọn loại GPU bạn muốn sử dụng để suy luận. Nếu bạn không chắc nên chọn GPU nào, bạn có thể bắt đầu với NVIDIA T4, được hỗ trợ CUDA.

   Hạn ngạch khu vực và loại máy

   Hãy nhớ rằng một số khu vực nhất định có hạn ngạch tính toán rất hạn chế, vì vậy bạn có thể không chọn được một số loại máy hoặc GPU nhất định trong khu vực của mình. Nếu điều này là quan trọng, hãy thay đổi khu vực triển khai của bạn thành một khu vực có hạn ngạch lớn hơn. Tìm thêm thông tin trong tài liệu chính thức của Vertex AI: Hạn ngạch và giới hạn của Vertex AI.

6. Sau khi chọn loại máy, bạn có thể nhấp vào Tiếp tục. Tại bước này, bạn có thể chọn bật tính năng giám sát mô hình trong Vertex AI—một dịch vụ bổ sung sẽ theo dõi hiệu suất mô hình của bạn và cung cấp thông tin chi tiết về hành vi của nó. Tùy chọn này là không bắt buộc và phát sinh thêm chi phí, vì vậy hãy lựa chọn theo nhu cầu của bạn. Nhấp vào Tạo.

Vertex AI sẽ mất vài phút (tối đa 30 phút ở một số khu vực) để triển khai mô hình. Bạn sẽ nhận được thông báo qua email sau khi quá trình triển khai hoàn tất.

6. Kiểm tra mô hình đã triển khai của bạn

Sau khi quá trình triển khai hoàn tất, Vertex AI sẽ cung cấp cho bạn một giao diện API mẫu để kiểm tra mô hình của bạn.

Để kiểm tra suy luận từ xa, bạn có thể sử dụng lệnh cURL được cung cấp hoặc tạo một thư viện ứng dụng python khác để gửi yêu cầu đến mô hình đã triển khai. Hãy nhớ rằng bạn cần mã hóa hình ảnh của mình sang base64 trước khi gửi đến /predict điểm cuối.

Chúc mừng bạn! Bạn đã triển khai thành công mô hình YOLO11 đã được huấn luyện trước với Ultralytics trên Google Cloud Vertex AI.

Câu hỏi thường gặp

Tôi có thể sử dụng các mô hình Ultralytics YOLO trên Vertex AI mà không cần Docker không?

Có, tuy nhiên trước tiên bạn cần xuất mô hình sang định dạng tương thích với Vertex AI, chẳng hạn như TensorFlow, Scikit-learn hoặc XGBoost. Google Cloud cung cấp hướng dẫn về cách chạy .pt các mô hình trên Vertex với tổng quan đầy đủ về quy trình chuyển đổi: Chạy các mô hình PyTorch trên Vertex AI.

Xin lưu ý rằng thiết lập kết quả sẽ chỉ dựa trên lớp phục vụ tiêu chuẩn của Vertex AI và sẽ không hỗ trợ các tính năng nâng cao của khung Ultralytics. Vì Vertex AI hỗ trợ đầy đủ các mô hình được đóng gói trong container và có thể tự động mở rộng chúng theo cấu hình triển khai của bạn, nên nó cho phép bạn tận dụng toàn bộ khả năng của các mô hình Ultralytics YOLO mà không cần chuyển đổi chúng sang một định dạng khác.

Tại sao FastAPI là một lựa chọn tốt để phục vụ suy luận YOLO11?

FastAPI cung cấp thông lượng cao cho khối lượng công việc suy luận. Hỗ trợ Async cho phép xử lý nhiều yêu cầu đồng thời mà không chặn luồng chính, điều này rất quan trọng khi phục vụ các mô hình thị giác máy tính.

Xác thực yêu cầu/phản hồi tự động với FastAPI giúp giảm lỗi thời gian chạy trong các dịch vụ suy luận sản xuất. Điều này đặc biệt có giá trị đối với các API phát hiện đối tượng, nơi tính nhất quán của định dạng đầu vào là rất quan trọng.

FastAPI bổ sung chi phí tính toán tối thiểu cho quy trình suy luận của bạn, giúp giải phóng thêm tài nguyên cho các tác vụ xử lý ảnh và thực thi mô hình.

FastAPI cũng hỗ trợ SSE (Server-Sent Events), rất hữu ích cho các tình huống suy luận trực tuyến.

Tại sao tôi phải chọn một khu vực nhiều lần như vậy?

Đây thực sự là một tính năng linh hoạt của Google Cloud Platform, nơi bạn cần chọn một khu vực cho mọi dịch vụ bạn sử dụng. Đối với nhiệm vụ triển khai một mô hình được đóng gói trên Vertex AI, lựa chọn khu vực quan trọng nhất của bạn là khu vực cho Model Registry. Nó sẽ xác định tính khả dụng của các loại máy và hạn ngạch cho việc triển khai mô hình của bạn.

Ngoài ra, nếu bạn sẽ mở rộng thiết lập và lưu trữ dữ liệu dự đoán hoặc kết quả trong Cloud Storage hoặc BigQuery, bạn sẽ cần sử dụng cùng khu vực với Model Registry để giảm thiểu độ trễ và đảm bảo thông lượng cao cho việc truy cập dữ liệu.

📅 Đã tạo 1 tháng trước ✏️ Đã cập nhật 1 tháng trước

Bình luận