Çıkarım için Ultralytics ile önceden eğitilmiş bir YOLO modelini Vertex AI'da dağıtın

Bu kılavuz, Ultralytics ile önceden eğitilmiş bir YOLO11 modelini nasıl konteynerleştireceğinizi, bunun için bir FastAPI çıkarım sunucusu oluşturacağınızı ve modeli çıkarım sunucusuyla Google Cloud Vertex AI'da nasıl dağıtacağınızı gösterecektir. Örnek uygulama, YOLO11 için nesne algılama kullanım durumunu kapsayacaktır, ancak aynı ilkeler diğer YOLO modlarını kullanmak için de geçerli olacaktır.

Başlamadan önce, bir Google Cloud Platform (GCP) projesi oluşturmanız gerekecektir. Yeni bir kullanıcı olarak ücretsiz olarak kullanabileceğiniz 300 ABD Doları değerinde GCP kredisi alırsınız ve bu miktar, daha sonra eğitim veya toplu ve akış çıkarımı dahil olmak üzere diğer YOLO11 kullanım durumları için genişletebileceğiniz çalışan bir kurulumu test etmek için yeterlidir.

Neler öğreneceksiniz

1. FastAPI kullanarak Ultralytics YOLO11 modeli için bir çıkarım arka ucu oluşturun.
2. Docker imajınızı depolamak için bir GCP Artifact Registry deposu oluşturun.
3. Modeli içeren Docker imajını oluşturun ve Artifact Registry'ye gönderin.
4. Modelinizi Vertex AI'da içe aktarın.
5. Bir Vertex AI uç noktası oluşturun ve modeli dağıtın.

Ön koşullar

1. Makinenize Docker kurun.
2. Google Cloud SDK'yı kurun ve gcloud CLI'yı kullanmak için kimlik doğrulayın.
3. Bu kılavuzu izlerken resmi Ultralytics Docker görüntülerinden birini genişletmeniz gerekeceğinden, Ultralytics için Docker Hızlı Başlangıç Kılavuzu'nu incelemeniz şiddetle tavsiye edilir.

1. FastAPI ile bir çıkarım arka ucu oluşturun

İlk olarak, YOLO11 model çıkarım isteklerine hizmet edecek bir FastAPI uygulaması oluşturmanız gerekir. Bu uygulama, model yükleme, görüntü önişleme ve çıkarım (tahmin) mantığını ele alacaktır.

Vertex AI Uyumluluk Temelleri

Vertex AI, konteynerinizin iki belirli uç noktayı uygulamasını bekler:

1. Sağlık uç noktası (/health): Hizmet hazır olduğunda HTTP durumunu döndürmelidir 200 OK .

2. Tahmin et uç noktası (/predict): ile yapılandırılmış tahmin isteklerini kabul eder base64 kodlu görüntüler ve isteğe bağlı parametreler. Yük boyutu sınırları uç nokta türüne bağlı olarak uygulanır.

   için istek yükleri /predict uç noktası şu JSON yapısını izlemelidir:

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

Proje klasörü yapısı

Yapımızın büyük bir kısmı Docker konteynerinin içinde gerçekleşecek ve Ultralytics ayrıca önceden eğitilmiş bir YOLO11 modeli yükleyecektir, bu nedenle yerel klasör yapısını basit tutabilirsiniz:

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

Bağımlılıklarla pyproject.toml oluşturun

Projenizi rahatça yönetmek için bir pyproject.toml aşağıdaki bağımlılıklarla birlikte dosyası oluşturun:

[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 sunucusunu çalıştırmak için kullanılacaktır.
• pillow görüntü işleme için kullanılacaktır, ancak yalnızca PIL görüntüleriyle sınırlı değilsiniz — Ultralytics destekler diğer birçok formatı.

Ultralytics YOLO11 ile çıkarım mantığı oluşturun

Artık proje yapısını ve bağımlılıkları ayarladığınıza göre, temel YOLO11 çıkarım mantığını uygulayabilirsiniz. Ultralytics Python API'sini kullanarak model yükleme, görüntü işleme ve tahmini gerçekleştirecek bir src/app.py dosyası oluşturun.

# 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

Bu, konteyner başladığında modeli bir kez yükleyecektir ve model tüm istekler arasında paylaşılacaktır. Modeliniz yoğun çıkarım yükünü kaldıracaksa, daha sonra Vertex AI'da bir model içe aktarırken daha fazla belleğe sahip bir makine türü seçmeniz önerilir.

Ardından, ile giriş ve çıkış görüntü işleme için iki yardımcı işlev oluşturun. pillowYOLO11, PIL görüntülerini yerel olarak destekler.

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

Son olarak, nesne algılamayı yönetecek olan run_inference işlevini uygulayın. Bu örnekte, model tahminlerinden sınırlayıcı kutuları, sınıf adlarını ve güvenilirlik skorlarını çıkaracağız. İşlev, daha fazla işleme veya açıklama için algılamalar ve ham sonuçlarla birlikte bir sözlük döndürecektir.

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}

İsteğe bağlı olarak, Ultralytics yerleşik çizim yöntemini kullanarak görüntüye sınırlayıcı kutular ve etiketler eklemek için bir işlev ekleyebilirsiniz. Bu, tahmin yanıtında açıklamalı görüntüler döndürmek isterseniz yararlı olacaktır.

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 ile HTTP çıkarım sunucusu oluşturun

Artık temel YOLO11 çıkarım mantığına sahip olduğunuza göre, bunu sunmak için bir FastAPI uygulaması oluşturabilirsiniz. Bu, Vertex AI tarafından gerekli olan sağlık kontrolü ve tahmin uç noktalarını içerecektir.

İlk olarak, Vertex AI için içe aktarmaları ekleyin ve günlüğü yapılandırın. Vertex AI, stderr'yi hata çıktısı olarak ele aldığından, günlükleri stdout'a yönlendirmek mantıklıdır.

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

Eksiksiz bir Vertex AI uyumluluğu için, gerekli uç noktaları ortam değişkenlerinde tanımlayın ve istekler için boyut sınırını ayarlayın. Üretim dağıtımları için özel Vertex AI uç noktaları kullanılması önerilir. Bu şekilde, sağlam güvenlik ve erişim kontrolü ile birlikte daha yüksek bir istek yükü sınırına (genel uç noktalar için 1,5 MB yerine 10 MB) sahip olursunuz.

# 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

İsteklerinizi ve yanıtlarınızı doğrulamak için iki Pydantic modeli ekleyin:

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


class PredictionResponse(BaseModel):
    predictions: list

Modelinizin hazır olup olmadığını doğrulamak için sağlık kontrolü uç noktasını ekleyin. Bu, Vertex AI için önemlidir, çünkü özel bir sağlık kontrolü olmadan düzenleyicisi rastgele soketlere ping atacak ve modelin çıkarım için hazır olup olmadığını belirleyemeyecektir. Kontrolünüz başarı için 200 OK ve başarısızlık için 503 Service Unavailable döndürmelidir:

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

Artık çıkarım isteklerini işleyecek olan tahmin uç noktasını uygulamak için her şeye sahipsiniz. Bir görüntü dosyası kabul edecek, çıkarımı çalıştıracak ve sonuçları döndürecektir. Görüntünün base64 ile kodlanması gerektiğini ve bunun da yük boyutunu %33'e kadar artırdığını unutmayın.

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

Son olarak, FastAPI sunucusunu çalıştırmak için uygulama giriş noktasını ekleyin.

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)

Artık YOLO11 çıkarım isteklerine hizmet edebilecek eksiksiz bir FastAPI uygulamanız var. Bağımlılıkları yükleyip sunucuyu çalıştırarak yerel olarak test edebilirsiniz, örneğin uv ile.

# Install dependencies
uv pip install -e .

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

Sunucuyu test etmek için her ikisini de sorgulayabilirsiniz /health ve /predict cURL kullanarak uç noktaları. Test görüntüsünü tests klasörüne koyun. Ardından, Terminalinizde aşağıdaki komutları çalıştırın:

# 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

Algılanan nesnelerle ilgili bir JSON yanıtı almanız gerekir. İlk isteğinizde, Ultralytics'in YOLO11 modelini çekmesi ve yüklemesi gerektiğinden kısa bir gecikme bekleyin.

2. Ultralytics Docker imajını uygulamanızla genişletin

Ultralytics, uygulama görüntünüz için temel olarak kullanabileceğiniz çeşitli Docker görüntüleri sağlar. Docker, Ultralytics'i ve gerekli GPU sürücülerini yükleyecektir.

Ultralytics YOLO modellerinin tüm özelliklerini kullanmak için, GPU çıkarımı için CUDA optimizasyonlu görüntüyü seçmelisiniz. Ancak, göreviniz için CPU çıkarımı yeterliyse, yalnızca CPU'lu görüntüyü seçerek de bilgi işlem kaynaklarından tasarruf edebilirsiniz:

• Dockerfile: YOLO11 tek/çoklu GPU eğitimi ve çıkarımı için CUDA optimizasyonlu görüntü.
• Dockerfile-cpu: YOLO11 çıkarımı için yalnızca CPU'lu görüntü.

Uygulamanız için bir Docker imajı oluşturun

Bir tane oluşturun Dockerfile projenizin kökünde aşağıdaki içerikle:

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

Örnekte, resmi Ultralytics Docker görüntüsü ultralytics:latest bir temel olarak kullanılır. Zaten YOLO11 modelini ve gerekli tüm bağımlılıkları içerir. Sunucunun giriş noktası, FastAPI uygulamasını yerel olarak test etmek için kullandığımızla aynıdır.

Docker imajını oluşturun ve test edin

Şimdi Docker görüntüsünü aşağıdaki komutla oluşturabilirsiniz:

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

Değiştir IMAGE_NAME ve IMAGE_VERSION istediğiniz değerlerle, örneğin, yolo11-fastapi:0.1. Vertex AI'da dağıtım yapıyorsanız, görüntüyü linux/amd64 mimarisi için oluşturmanız gerektiğini unutmayın. --platform Görüntüyü bir Apple Silicon Mac'te veya başka bir x86 dışı mimaride oluşturuyorsanız, parametrenin açıkça ayarlanması gerekir.

Görüntü oluşturma tamamlandıktan sonra, Docker görüntüsünü yerel olarak test edebilirsiniz:

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

Docker konteyneriniz artık bağlantı noktasında bir FastAPI sunucusu çalıştırıyor 8080, çıkarım isteklerini kabul etmeye hazır. Her ikisini de test edebilirsiniz /health ve /predict öncekiyle aynı cURL komutlarıyla uç nokta:

# 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 imajını GCP Artifact Registry'ye yükleyin

Konteynerize edilmiş modelinizi Vertex AI'a aktarmak için, Docker görüntüsünü Google Cloud Artifact Registry'ye yüklemeniz gerekir. Henüz bir Artifact Registry deponuz yoksa, önce bir tane oluşturmanız gerekir.

Google Cloud Artifact Registry'de bir depo oluşturun

Google Cloud Console'da Artifact Registry sayfasını açın. Artifact Registry'yi ilk kez kullanıyorsanız, önce Artifact Registry API'sini etkinleştirmeniz istenebilir.

1. Havuz Oluştur'u seçin.
2. Havuzunuzun adını girin. Diğer seçenekler için, özellikle değiştirmeniz gerekmiyorsa, istediğiniz bölgeyi seçin ve varsayılan ayarları kullanın.

1. Havuz oluşturulduktan sonra, PROJECT_ID'nizi, Konumunuzu (Bölge) ve Havuz Adınızı gizli kasa veya .env dosyanıza kaydedin. Docker imajınızı Artifact Registry'ye etiketlemek ve göndermek için bunlara daha sonra ihtiyacınız olacaktır.

Docker'ı Artifact Registry'ye doğrulayın

Docker istemcinizin kimliğini, az önce oluşturduğunuz Artifact Registry havuzunda doğrulayın. Terminalinizde aşağıdaki komutu çalıştırın:

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

İmajınızı etiketleyin ve Artifact Registry'ye gönderin

Docker imajını Google Artifact Registry'ye etiketleyin ve gönderin.

İmajınızı Artifact Registry havuz URL'si ile etiketleyin. Yer tutucuları daha önce kaydettiğiniz değerlerle değiştirin.

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

Etiketlenmiş imajı Artifact Registry havuzuna gönderin.

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

İşlemin tamamlanmasını bekleyin. Artık imajı Artifact Registry havuzunuzda görmelisiniz.

Artifact Registry'de imajlarla nasıl çalışılacağına dair daha ayrıntılı talimatlar için Artifact Registry belgelerine bakın: İmajları gönderme ve çekme.

4. Modelinizi Vertex AI'da içe aktarın

Az önce gönderdiğiniz Docker imajını kullanarak, modeli şimdi Vertex AI'da içe aktarabilirsiniz.

1. Google Cloud gezinme menüsünde, Vertex AI > Model Kayıt Defteri'ne gidin. Alternatif olarak, Google Cloud Console'un üst kısmındaki arama çubuğunda "Vertex AI" araması yapın.

   

2. İçe Aktar'ı tıklayın.

3. Yeni bir model olarak İçe Aktar'ı seçin.
4. Bölgeyi seçin. Artifact Registry havuzunuzla aynı bölgeyi seçebilirsiniz, ancak seçiminiz bölgenizdeki makine türlerinin ve kotaların kullanılabilirliğine göre belirlenmelidir.

5. Mevcut bir model konteynerini İçe Aktar'ı seçin.

   

6. Konteyner imajı alanında, daha önce oluşturduğunuz Artifact Registry havuzuna göz atın ve az önce gönderdiğiniz imajı seçin.

7. Ortam değişkenleri bölümüne gidin ve FastAPI uygulamanızda tanımladığınız tahmin ve sağlık uç noktalarını ve portu girin.

   

8. İçe Aktar'a tıklayın. Vertex AI, modeli kaydetmek ve dağıtıma hazırlamak için birkaç dakika sürecektir. İçe aktarma işlemi tamamlandığında bir e-posta bildirimi alacaksınız.

5. Bir Vertex AI Uç Noktası oluşturun ve modelinizi dağıtın

Bir modeli dağıtmak için Vertex AI'da bir Uç Nokta oluşturmanız gerekir.

1. Vertex AI gezinme menünüzde, Uç Noktalar'a gidin. Modelinizi içe aktarırken kullandığınız bölgeyi seçin. Oluştur'a tıklayın.

1. Uç Nokta adını girin.
2. Erişim için Vertex AI, özel Vertex AI uç noktalarının kullanılmasını önerir. Güvenlik avantajlarının yanı sıra, özel bir uç nokta seçerseniz daha yüksek bir yük limiti elde edersiniz, ancak uç noktaya erişime izin vermek için VPC ağınızı ve güvenlik duvarı kurallarınızı yapılandırmanız gerekir. Özel uç noktalar hakkında daha fazla talimat için Vertex AI belgelerine bakın.
3. Devam'a tıklayın.
4. Model ayarları iletişim kutusunda, daha önce içe aktardığınız modeli seçin. Şimdi modeliniz için makine türünü, belleği ve GPU ayarlarını yapılandırabilirsiniz. Uygun YOLO11 performansı için herhangi bir G/Ç darboğazı olmadığından emin olmak için yüksek çıkarım yükleri bekliyorsanız yeterli bellek ayırın.

5. Hızlandırıcı türünde, çıkarım için kullanmak istediğiniz GPU türünü seçin. Hangi GPU'yu seçeceğinizden emin değilseniz, CUDA destekli NVIDIA T4 ile başlayabilirsiniz.

   Bölge ve makine türü kotaları

   Bazı bölgelerin çok sınırlı işlem kotalarına sahip olduğunu unutmayın, bu nedenle bölgenizde belirli makine türlerini veya GPU'ları seçemeyebilirsiniz. Bu kritikse, dağıtımınızın bölgesini daha büyük bir kotaya sahip bir bölgeyle değiştirin. Vertex AI resmi belgelerinde daha fazla bilgi bulun: Vertex AI kotaları ve sınırları.

6. Makine türü seçildikten sonra, Devam'a tıklayabilirsiniz. Bu noktada, Vertex AI'da model izlemeyi etkinleştirmeyi seçebilirsiniz; bu, modelinizin performansını izleyecek ve davranışı hakkında içgörüler sağlayacak ek bir hizmettir. Bu isteğe bağlıdır ve ek maliyetlere neden olur, bu nedenle ihtiyaçlarınıza göre seçin. Oluştur'a tıklayın.

Vertex AI, modeli dağıtmak için birkaç dakika (bazı bölgelerde 30 dakikaya kadar) sürecektir. Dağıtım tamamlandığında bir e-posta bildirimi alacaksınız.

6. Dağıtılan modelinizi test edin

Dağıtım tamamlandıktan sonra, Vertex AI size modelinizi test etmek için örnek bir API arayüzü sağlayacaktır.

Uzak çıkarımı test etmek için, sağlanan cURL komutunu kullanabilir veya dağıtılan modele istek gönderecek başka bir python istemci kitaplığı oluşturabilirsiniz. Görüntünüzü göndermeden önce base64'e kodlamanız gerektiğini unutmayın. /predict uç nokta.

Tebrikler! Google Cloud Vertex AI üzerinde Ultralytics ile önceden eğitilmiş bir YOLO11 modelini başarıyla dağıttınız.

SSS

Ultralytics YOLO modellerini Docker olmadan Vertex AI'da kullanabilir miyim?

Evet, ancak öncelikle modeli TensorFlow, Scikit-learn veya XGBoost gibi Vertex AI ile uyumlu bir formata aktarmanız gerekecektir. Google Cloud, çalıştırma konusunda bir kılavuz sunmaktadır. .pt dönüşüm sürecine genel bir bakış ile Vertex üzerindeki modeller: Vertex AI üzerinde PyTorch modellerini çalıştırma.

Lütfen unutmayın ki sonuçtaki kurulum yalnızca Vertex AI standart sunum katmanına dayanacak ve gelişmiş Ultralytics çerçeve özelliklerini desteklemeyecektir. Vertex AI, konteynerize edilmiş modelleri tam olarak desteklediği ve dağıtım yapılandırmanıza göre bunları otomatik olarak ölçeklendirebildiği için, Ultralytics YOLO modellerinin tüm yeteneklerinden, farklı bir formata dönüştürmenize gerek kalmadan yararlanmanızı sağlar.

YOLO11 çıkarımına hizmet etmek için FastAPI neden iyi bir seçimdir?

FastAPI, çıkarım iş yükleri için yüksek verim sağlar. Eşzamansız destek, ana iş parçacığını engellemeden birden çok eşzamanlı isteği işlemeye olanak tanır; bu, bilgisayar görüşü modelleri sunarken önemlidir.

FastAPI ile otomatik istek/yanıt doğrulaması, üretim çıkarım hizmetlerinde çalışma zamanı hatalarını azaltır. Bu, özellikle giriş formatı tutarlılığının kritik olduğu nesne algılama API'leri için değerlidir.

FastAPI, çıkarım hattınıza minimum düzeyde işlem yükü ekler ve model yürütme ve görüntü işleme görevleri için daha fazla kaynak kalmasını sağlar.

FastAPI ayrıca, akışlı çıkarım senaryoları için yararlı olan SSE'yi (Sunucu Tarafından Gönderilen Olaylar) destekler.

Neden bu kadar çok kez bir bölge seçmem gerekiyor?

Bu aslında, kullandığınız her hizmet için bir bölge seçmeniz gereken Google Cloud Platform'un bir çok yönlülük özelliğidir. Vertex AI'da konteynerize edilmiş bir model dağıtma görevi için, en önemli bölge seçimi Model Kayıt Defteri içindir. Bu, model dağıtımınız için makine türlerinin ve kotaların kullanılabilirliğini belirleyecektir.

Ek olarak, kurulumu genişletecek ve tahmin verilerini veya sonuçlarını Cloud Storage veya BigQuery'de saklayacaksanız, gecikmeyi en aza indirmek ve veri erişimi için yüksek verim sağlamak için Model Kayıt Defteri ile aynı bölgeyi kullanmanız gerekecektir.

📅 1 ay önce oluşturuldu ✏️ 1 ay önce güncellendi

Yorumlar