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

Bu kılavuz, Ultralytics ile önceden eğitilmiş bir YOLO26 modelini nasıl paketleyeceğini, bunun için bir FastAPI çıkarım sunucusu oluşturacağını ve modeli bu çıkarım sunucusuyla birlikte Google Cloud Vertex AI üzerinde nasıl dağıtacağını gösterecektir. Örnek uygulama, YOLO26 için nesne algılama kullanım senaryosunu kapsayacaktır, ancak aynı ilkeler diğer YOLO modlarını kullanırken de geçerli olacaktır.

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

Neler öğreneceksin

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

Ön koşullar

1. Makinenize Docker kur.
2. Google Cloud SDK kur ve gcloud CLI kullanımı için kimlik doğrulaması yap.
3. Ultralytics için Docker Hızlı Başlangıç Kılavuzu üzerinden geçmen şiddetle tavsiye edilir, çünkü bu kılavuzu takip ederken resmi Ultralytics Docker imajlarından birini genişletmen gerekecektir.

FastAPI ile bir çıkarım arka ucu oluştur

Öncelikle, YOLO26 modeli çıkarım isteklerine hizmet verecek bir FastAPI uygulaması oluşturman gerekir. Bu uygulama; model yükleme, görüntü ön işleme ve çıkarım (tahmin) mantığını yürütecektir.

Vertex AI Uyumluluk Temelleri

Vertex AI, konteynerinin iki özel uç noktayı uygulamasını bekler:

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

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

   /predict uç noktasına yönelik istek yükleri şu JSON yapısını izlemelidir:

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

Proje klasör yapısı

Oluşturma işlemimizin büyük bir kısmı Docker konteyneri içinde gerçekleşecek ve Ultralytics de önceden eğitilmiş bir YOLO26 modelini yükleyeceğinden, yerel klasör yapısını basit tutabilirsin:

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

Bağımlılıklarla birlikte pyproject.toml oluştur

Projenizi rahatça yönetmek için aşağıdaki bağımlılıkları içeren bir pyproject.toml dosyası oluştur:

[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 sadece PIL görüntüleriyle sınırlı değilsin; Ultralytics birçok başka formatı destekler.

Ultralytics YOLO26 ile çıkarım mantığı oluştur

Artık proje yapısına ve bağımlılıklara sahip olduğuna göre, temel YOLO26 çıkarım mantığını uygulayabilirsin. Ultralytics Python API kullanarak model yükleme, görüntü işleme ve tahmini yönetecek bir src/app.py dosyası oluştur.

# 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

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

Ardından, pillow ile giriş ve çıkış görüntüsü işleme için iki yardımcı işlev oluştur. YOLO26, 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 run_inference işlevini uygula. Bu örnekte, model tahminlerinden sınırlayıcı kutuları (bounding boxes), sınıf adlarını ve güven puanlarını çıkaracağız. İşlev, daha fazla işleme veya ek açıklama için algılamaları ve ham sonuçları içeren 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 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}

İsteğe bağlı olarak, Ultralytics yerleşik çizim yöntemini kullanarak görüntüyü sınırlayıcı kutular ve etiketlerle açıklama eklemek için bir işlev ekleyebilirsin. Bu, tahmin yanıtında açıklamalı görüntüler döndürmek istersen 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ştur

Artık temel YOLO26 çıkarım mantığına sahip olduğuna göre, ona hizmet verecek bir FastAPI uygulaması oluşturabilirsin. Bu, Vertex AI tarafından gerekli olan sağlık kontrolü ve tahmin uç noktalarını içerecektir.

İlk olarak, içe aktarmaları ekle ve Vertex AI için günlük kaydını yapılandır. Vertex AI, stderr'yi hata çıktısı olarak gördüğü için 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")

Tam bir Vertex AI uyumluluğu için gerekli uç noktaları ortam değişkenlerinde tanımla ve istekler için boyut sınırını ayarla. Üretim dağıtımları için özel Vertex AI uç noktalarını kullanman önerilir. Bu sayede, güçlü 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 olursun.

# 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

İsteklerini ve yanıtlarını doğrulamak için iki Pydantic modeli ekle:

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

class PredictionResponse(BaseModel):
    predictions: list

Model hazır bulunuşluğunu doğrulamak için sağlık kontrolü uç noktasını ekle. Bu, Vertex AI için önemlidir, çünkü özel bir sağlık kontrolü olmadan orkestratörü rastgele soketlere ping atacak ve modelin çıkarım için hazır olup olmadığını belirleyemeyecektir. Kontrolün 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 yönetecek tahmin uç noktasını uygulamak için her şeye sahipsin. Bir görüntü dosyası kabul edecek, çıkarımı çalıştıracak ve sonuçları döndürecektir. Görüntünün base64 kodlu olması gerektiğini unutma; bu, yükün boyutunu %33'e kadar artırır.

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

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

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 YOLO26 çıkarım isteklerine hizmet verebilecek tam bir FastAPI uygulamasına sahipsin. Bağımlılıkları yükleyip sunucuyu çalıştırarak (örneğin uv ile) bunu yerel olarak test edebilirsin.

# Install dependencies
uv pip install -e .

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

Sunucuyu test etmek için cURL kullanarak hem /health hem de /predict uç noktalarını sorgulayabilirsin. tests klasörüne bir test görüntüsü koy. Ardından Terminalinde şu komutları çalıştır:

# 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 nesneleri içeren bir JSON yanıtı almalısın. İlk isteğinde, Ultralytics'in YOLO26 modelini çekmesi ve yüklemesi gerektiğinden kısa bir gecikme bekle.

Ultralytics Docker imajını uygulamanla genişlet

Ultralytics, uygulama imajın için temel olarak kullanabileceğin birkaç Docker imajı sağlar. Docker, Ultralytics'i ve gerekli GPU sürücülerini yükleyecektir.

Ultralytics YOLO modellerinin tüm yeteneklerini kullanmak için GPU çıkarımı için CUDA ile optimize edilmiş imajı seçmelisin. Ancak, CPU çıkarımı görevin için yeterliyse, sadece CPU imajını seçerek de bilgi işlem kaynaklarından tasarruf edebilirsin:

• Dockerfile: YOLO26 tek/çoklu GPU eğitimi ve çıkarımı için CUDA ile optimize edilmiş imaj.
• Dockerfile-cpu: YOLO26 çıkarımı için sadece CPU içeren imaj.

Uygulaman için bir Docker imajı oluştur

Projenin kök dizininde aşağıdaki içeriğe sahip bir Dockerfile oluştur:

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

Örnekte, temel olarak resmi Ultralytics Docker imajı ultralytics:latest kullanılmıştır. Bu imaj zaten YOLO26 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ştur ve test et

Artık aşağıdaki komutla Docker imajını oluşturabilirsin:

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

IMAGE_NAME ve IMAGE_VERSION değerlerini istediğin değerlerle (örneğin yolo26-fastapi:0.1) değiştir. Vertex AI üzerinde dağıtım yapıyorsan imajı linux/amd64 mimarisi için oluşturman gerektiğini unutma. Apple Silicon Mac veya x86 olmayan başka bir mimaride imaj oluşturuyorsan --platform parametresinin açıkça ayarlanması gerekir.

İmaj oluşturma işlemi tamamlandıktan sonra Docker imajını yerel olarak test edebilirsin:

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

Your Docker container is now running a FastAPI server on port 8080, ready to accept inference requests. You can test both the /health and the /predict endpoint with the same cURL commands as before:

# 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

Docker imajını GCP Artifact Registry'ye yükle

Konteynerleştirilmiş modelini Vertex AI'a içe aktarmak için Docker imajını Google Cloud Artifact Registry'ye yüklemen gerekir. Henüz bir Artifact Registry depon yoksa, önce bir tane oluşturman gerekecektir.

Google Cloud Artifact Registry'de bir depo oluştur

Google Cloud Console'da Artifact Registry sayfasına git. Artifact Registry'yi ilk kez kullanıyorsan, önce Artifact Registry API'sini etkinleştirmen istenebilir.

1. Depo Oluştur'u seç.
2. Deponun adını gir. İstediğin bölgeyi seç ve özel olarak değiştirmen gerekmediği sürece diğer seçenekler için varsayılan ayarları kullan.

1. Depo oluşturulduktan sonra; PROJECT_ID, Konum (Bölge) ve Depo Adını sır saklama alanına veya .env dosyana kaydet. Docker imajını etiketlemek ve Artifact Registry'ye göndermek için bunlara daha sonra ihtiyacın olacak.

Docker için Artifact Registry kimlik doğrulaması yap

Docker istemcinin az önce oluşturduğun Artifact Registry deposuna kimlik doğrulamasını yap. Terminalinde şu komutu çalıştır:

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

İmajını etiketle ve Artifact Registry'ye gönder

Docker imajını Google Artifact Registry'ye etiketle ve gönder.

İmajını Artifact Registry depo URL'si ile etiketle. Yer tutucuları daha önce kaydettiğin değerlerle değiştir.

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 deposuna gönder.

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

İşlemin tamamlanmasını bekle. Artık imajı Artifact Registry deponda görmelisin.

Artifact Registry'deki imajlarla çalışma hakkında daha özel talimatlar için Artifact Registry belgelerine bak: İmajları gönder ve çek.

Modelini Vertex AI'a içe aktar

Az önce gönderdiğin Docker imajını kullanarak artık modeli Vertex AI'a içe aktarabilirsin.

1. Google Cloud gezinme menüsünde, Vertex AI > Model Registry'ye git. Alternatif olarak, Google Cloud Console'un üst kısmındaki arama çubuğunda "Vertex AI" araması yap.

Bir Vertex AI Uç Noktası oluştur ve modelini dağıt

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

1. Vertex AI gezinme menünde Uç Noktalar'a git. Modelini içe aktarırken kullandığın bölgeyi seç. Oluştur'a tıkla.

1. Makine türü seçildikten sonra Devam et'e tıklayabilirsin. Bu noktada, Vertex AI'da model izlemeyi etkinleştirmeyi seçebilirsin; bu, modelinin performansını takip edecek ve davranışına dair içgörüler sağlayacak ekstra bir hizmettir. Bu isteğe bağlıdır ve ek maliyet gerektirir, bu yüzden ihtiyaçlarına göre seçim yap. Oluştur'a tıkla.

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

Dağıtılan modelini test et

Dağıtım tamamlandığında Vertex AI, modelini test etmen için sana ö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şturabilirsin. Görüntünü /predict uç noktasına göndermeden önce base64'e kodlaman gerektiğini unutma.

Önceden eğitilmiş bir YOLO26 modelini Ultralytics ile Google Cloud Vertex AI üzerinde başarıyla dağıttın.

SSS

Ultralytics YOLO modellerini Docker olmadan Vertex AI üzerinde kullanabilir miyim?

Evet; ancak, önce modeli TensorFlow, Scikit-learn veya XGBoost gibi Vertex AI ile uyumlu bir formata dışa aktarman gerekecektir. Google Cloud, dönüştürme sürecine dair eksiksiz bir genel bakış ile .pt modellerini Vertex üzerinde çalıştırma konusunda bir kılavuz sunar: Vertex AI üzerinde PyTorch modellerini çalıştır.

Ortaya çıkan kurulumun yalnızca Vertex AI standart sunum katmanına dayanacağını ve gelişmiş Ultralytics çerçevesi özelliklerini desteklemeyeceğini lütfen unutma. Vertex AI, konteynerleştirilmiş modelleri tamamen desteklediğinden ve bunları dağıtım yapılandırmana göre otomatik olarak ölçeklendirebildiğinden, modelleri farklı bir formata dönüştürmene gerek kalmadan Ultralytics YOLO modellerinin tüm yeteneklerinden yararlanmanı sağlar.

YOLO26 çıkarımı sunmak için FastAPI neden iyi bir seçimdir?

FastAPI, çıkarım iş yükleri için yüksek verim sağlar. Async desteği, bilgisayarlı görü modelleri sunulurken önemli olan, ana iş parçacığını engellemeden birden fazla eşzamanlı isteği işlemeye olanak tanır.

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

FastAPI, çıkarım işlem hattına minimum hesaplama yükü ekler ve model yürütme ile görüntü işleme görevleri için daha fazla kaynak bırakır.

FastAPI ayrıca, akışlı çıkarım senaryoları için yararlı olan SSE (Server-Sent Events) desteği de sunar.

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

Bu aslında, kullandığın her hizmet için bir bölge seçmen gereken Google Cloud Platform'un bir esneklik özelliğidir. Vertex AI üzerinde kapsayıcılı bir model dağıtma görevi için en önemli bölge seçimini Model Registry için yaparsın. Bu, model dağıtımın için makine türlerinin ve kotalarının kullanılabilirliğini belirleyecektir.

Ayrıca, kurulumu genişleteceksen ve tahmin verilerini veya sonuçlarını Cloud Storage veya BigQuery'de depolayacaksan, gecikmeyi en aza indirmek ve veri erişimi için yüksek verim sağlamak adına Model Registry ile aynı bölgeyi kullanman gerekir.