Triển khai model YOLO tiền huấn luyện với Ultralytics trên Vertex AI để phục vụ suy luận

Hướng dẫn này sẽ chỉ cho bạn cách đóng gói model YOLO26 tiền huấn luyện bằng Ultralytics vào container, xây dựng server suy luận FastAPI cho nó và triển khai model cùng server suy luận lên Google Cloud Vertex AI. Ví dụ triển khai này sẽ bao quát trường hợp sử dụng phát hiện đối tượng cho YOLO26, nhưng các nguyên tắc tương tự cũng áp dụng cho việc sử dụng các mode 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 tín dụng GCP để sử dụng miễn phí với tư cách người dùng mới, và số tiền này đủ để thử nghiệm một 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 YOLO26 nào khác, bao gồm huấn luyện hoặc suy luận hàng loạt và truyền phát.

Những gì bạn sẽ học

1. Tạo backend suy luận cho model Ultralytics YOLO26 sử dụng FastAPI.
2. Tạo một repository GCP Artifact Registry để lưu trữ Docker image của bạn.
3. Build và đẩy Docker image chứa model lên Artifact Registry.
4. Nhập model của bạn vào Vertex AI.
5. Tạo endpoint Vertex AI và triển khai model.

Đ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 đặc biệt 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 Docker image chính thức của Ultralytics trong khi làm theo hướng dẫn này.

1. Tạo backend suy luận với FastAPI

Đầu tiên, bạn cần tạo một ứng dụng FastAPI sẽ phục vụ các yêu cầu suy luận model YOLO26. Ứng dụng này sẽ xử lý việc tải model, 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 phải triển khai hai endpoint cụ thể:

1. Health endpoint (/health): Phải trả về trạng thái HTTP 200 OK khi dịch vụ đã sẵn sàng.

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

   Payload yêu cầu cho endpoint /predict phải 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 build của chúng ta sẽ diễn ra bên trong Docker container, và Ultralytics cũng sẽ tải một model YOLO26 tiền huấn luyện, vì vậy bạn có thể giữ cấu trúc thư mục cục bộ đơn giản:

YOUR_PROJECT/
├── src/
│   ├── __init__.py
│   ├── app.py              # Core YOLO26 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 phụ thuộc

Để quản lý dự án một cách thuận tiện, hãy tạo một tệp pyproject.toml với các 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 server FastAPI.
• pillow sẽ được sử dụng để xử lý hình ảnh, nhưng bạn không chỉ giới hạn ở các hình ảnh PIL — Ultralytics hỗ trợ nhiều định dạng khác.

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

Bây giờ bạn đã thiết lập xong cấu trúc dự án và các phụ thuộc, bạn có thể triển khai logic suy luận YOLO26 cốt lõi. Tạo một tệp src/app.py sẽ xử lý việc tải model, xử lý hình ảnh và dự đoán, sử dụng Python API của 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 pretrained YOLO26n model from Ultralytics base image
        model_yolo = YOLO("yolo26n.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

Điều này sẽ tải model một lần khi container khởi động, và model sẽ được chia sẻ giữa tất cả các yêu cầu. Nếu model của bạn sẽ xử lý tải suy luận nặng, bạn nên chọn loại máy có nhiều bộ nhớ hơn khi nhập model 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. YOLO26 hỗ trợ nguyên bản hình ảnh 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()

Cuối cùng, triển khai hàm run_inference 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 khung bao (bounding boxes), tên lớp và điểm tin cậy từ các dự đoán của model. Hàm sẽ trả về một dictionary chứa các kết quả 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 YOLO26n 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 với các khung bao và nhãn bằng phương thức vẽ tích hợp 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 server suy luận HTTP với FastAPI

Bây giờ bạn đã có logic suy luận YOLO26 cốt lõi, bạn có thể tạo một ứng dụng FastAPI để phục vụ nó. Điều này sẽ bao gồm các endpoint kiểm tra sức khỏe (health check) và dự đoán do Vertex AI yêu cầu.

Đầu tiên, thêm các import và cấu hình ghi nhật ký (logging) cho Vertex AI. Vì Vertex AI coi stderr là đầu ra lỗi, nên việc chuyển hướng nhật ký sang 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")

Để tuân thủ hoàn toàn Vertex AI, hãy xác định các endpoint bắt buộc trong 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 endpoint 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 payload yêu cầu cao hơn (10 MB thay vì 1.5 MB đối với các endpoint công cộng), 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 Pydantic model để 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 endpoint kiểm tra sức khỏe để xác minh độ sẵn sàng của model. Đ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 liệu model đã sẵn sàng để suy luận hay chưa. Kiểm tra của bạn phải trả về 200 OK để thành công và 503 Service Unavailable nếu 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 endpoint dự đoán sẽ 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 YOLO26 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 YOLO26n 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: {e}")
        raise HTTPException(status_code=500, detail=f"Prediction failed: {e}")

Cuối cùng, thêm điểm nhập (entry point) ứng dụng để chạy server 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 YOLO26. Bạn có thể kiểm tra nó cục bộ bằng cách cài đặt các phụ thuộc và chạy server, ví dụ như với uv.

# Install dependencies
uv pip install -e .

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

Để kiểm tra server, bạn có thể truy vấn cả hai endpoint /health và /predict bằng cURL. Đặt một hình ảnh kiểm tra vào thư mục tests. Sau đó, trong Terminal của bạn, 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 một phản hồi JSON với các đối tượng được phát hiện. Ở yêu cầu đầu tiên, hãy dự kiến một khoảng trễ ngắn vì Ultralytics cần kéo và tải model YOLO26.

2. Mở rộng Docker image Ultralytics với ứ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 image ứng dụng 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 các model Ultralytics YOLO, bạn nên chọn image đã 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ũng có thể tiết kiệm tài nguyên tính toán bằng cách chọn image chỉ dành cho CPU:

• Dockerfile: Image đã tối ưu hóa CUDA cho việc huấn luyện và suy luận YOLO26 đơn/đa GPU.
• Dockerfile-cpu: Image chỉ dành cho CPU để suy luận YOLO26.

Tạo một Docker image 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 YOLO26
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ụ, Docker image chính thức của Ultralytics ultralytics:latest được sử dụng làm cơ sở. Nó đã chứa sẵn model YOLO26 và tất cả các phụ thuộc cần thiết. Điểm nhập của server cũng giống như chúng ta đã sử dụng để kiểm tra ứng dụng FastAPI cục bộ.

Build và kiểm tra Docker image

Bây giờ bạn có thể build Docker image với lệnh sau:

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

Thay thế IMAGE_NAME và IMAGE_VERSION bằng các giá trị bạn muốn, ví dụ: yolo26-fastapi:0.1. Lưu ý rằng bạn phải build image cho kiến trúc linux/amd64 nếu bạn đang triển khai trên Vertex AI. Tham số --platform cần được đặt rõ ràng nếu bạn đang build image trên máy 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 build image hoàn tất, bạn có thể kiểm tra Docker image 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 server 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ả endpoint /health và /predict với các lệnh cURL giống 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 model đã được đóng gói của bạn vào Vertex AI, bạn cần tải Docker image lên Google Cloud Artifact Registry. Nếu bạn chưa có repository Artifact Registry, bạn sẽ cần tạo một cái trước.

Tạo một repository trong Google Cloud Artifact Registry

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

1. Chọn Create Repository (Tạo Repository).
2. Nhập tên repository của bạn. Chọn khu vực (region) mong muốn và sử dụng các 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 repository được tạo, hãy lưu PROJECT_ID, Location (Khu vực) và Tên Repository vào vault bí mật hoặc tệp .env của bạn. Bạn sẽ cần chúng sau này để gán thẻ (tag) và đẩy Docker image của mình 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 repository 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 image của bạn lên Artifact Registry

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

Gán thẻ cho image của bạn với URL của repository Artifact Registry. Thay thế các trình giữ chỗ (placeholders) 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 image đã được gán thẻ lên repository Artifact Registry.

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

Chờ quá trình hoàn tất. Bạn bây giờ sẽ thấy image trong repository Artifact Registry của mình.

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

4. Nhập model của bạn vào Vertex AI

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

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

5. Tạo Vertex AI Endpoint và triển khai model của bạn

Để triển khai một model, bạn cần tạo một Endpoint trong Vertex AI.

1. Trong menu điều hướng Vertex AI, đi tới Endpoints. Chọn khu vực bạn đã sử dụng khi nhập model. Nhấp Create (Tạo).

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

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

6. Kiểm tra model đã 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 model 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 client Python khác sẽ gửi yêu cầu đến model đã 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ó đến endpoint /predict.

Bạn đã triển khai thành công một model YOLO26 tiền huấn luyện với Ultralytics trên Google Cloud Vertex AI.

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

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

Có; tuy nhiên, trước tiên bạn sẽ cần xuất model sang một đị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 chạy các model .pt trên Vertex với tổng quan đầy đủ về quá trình chuyển đổi: Chạy các model PyTorch trên Vertex AI.

Xin lưu ý rằng thiết lập thu được sẽ chỉ dựa vào 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 framework Ultralytics nâng cao. Vì Vertex AI hỗ trợ đầy đủ các model dạng container và có thể tự động mở rộng quy mô chúng theo cấu hình triển khai của bạn, nó cho phép bạn tận dụng tối đa khả năng của các model Ultralytics YOLO mà không cần phải chuyển đổi chúng sang định dạng khác.

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

FastAPI cung cấp lưu lượng xử lý cao cho các tác vụ suy luận. Hỗ trợ bất đồng bộ (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 model thị giác máy tính.

Tính năng xác thực request/response tự động của FastAPI giúp giảm thiểu lỗi runtime trong các dịch vụ suy luận production. Đ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à yếu tố then chốt.

FastAPI bổ sung rất ít chi phí tính toán vào pipeline suy luận của bạn, giúp dành nhiều tài nguyên hơn cho việc thực thi model và các tác vụ xử lý hình ảnh.

FastAPI cũng hỗ trợ SSE (Server-Sent Events), vốn hữu ích cho các kịch bản suy luận truyền phát (streaming).

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

Đây thực chất là một tính năng đa năng của Google Cloud Platform, nơi bạn cần chọn khu vực cho mỗi dịch vụ mà bạn sử dụng. Đối với nhiệm vụ triển khai model dạng container trên Vertex AI, lựa chọn khu vực quan trọng nhất của bạn là dành cho Model Registry. Nó sẽ xác định khả năng cung cấp các loại máy ảo và hạn mức (quotas) cho việc triển khai model của bạn.

Ngoài ra, nếu bạn 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 lưu lượng truy cập dữ liệu cao.