نشر نموذج YOLO مدرّب مسبقًا باستخدام Ultralytics على Vertex AI للاستدلال#

سيوضح لك هذا الدليل كيفية تحويل نموذج YOLO26 مدرّب مسبقًا باستخدام Ultralytics إلى حاوية، وإنشاء خادم استدلال FastAPI له، ونشر النموذج مع خادم الاستدلال على Google Cloud Vertex AI. سيغطي التنفيذ المثال حالة استخدام كشف الأجسام في YOLO26، لكن المبادئ نفسها تنطبق على استخدام مهام YOLO الأخرى.

قبل البدء، ستحتاج إلى إنشاء مشروع على منصة Google Cloud (GCP). يحصل المستخدم الجديد على رصيد بقيمة 300 دولار أمريكي لاستخدامه مجانًا، وهو مبلغ يكفي لاختبار إعداد قيد التشغيل يمكنك توسيعه لاحقًا لأي حالة استخدام أخرى في YOLO26، بما في ذلك التدريب أو الاستدلال الدفعي أو المتدفق.

ما ستتعلمه#

1. إنشاء خلفية للاستدلال لنموذج Ultralytics YOLO26 باستخدام FastAPI.
2. إنشاء مستودع في GCP Artifact Registry لتخزين صورة Docker.
3. إنشاء صورة Docker التي تحتوي على النموذج ودفعها إلى Artifact Registry.
4. استيراد النموذج إلى Vertex AI.
5. إنشاء نقطة نهاية في Vertex AI ونشر النموذج.

المتطلبات الأساسية#

1. ثبّت Docker على جهازك.
2. ثبّت Google Cloud SDK وصادِق لاستخدام CLI الخاص بـ gcloud.
3. يوصى بشدة بالاطلاع على دليل البدء السريع لـ Docker من Ultralytics، لأنك ستحتاج إلى توسيع إحدى صور Docker الرسمية من Ultralytics أثناء اتباع هذا الدليل.

1. إنشاء خلفية للاستدلال باستخدام FastAPI#

أولًا، أنشئ تطبيق FastAPI لتقديم طلبات استدلال نموذج YOLO26. سيتولى هذا التطبيق تحميل النموذج والمعالجة المسبقة للصور ومنطق الاستدلال (التنبؤ).

أساسيات الامتثال في Vertex AI#

تتطلب Vertex AI أن تنفذ الحاوية نقطتي نهاية محددتين:

1. نقطة نهاية Health (/health): يجب أن تُعيد حالة HTTP 200 OK عندما تكون الخدمة جاهزة.

2. نقطة نهاية Predict (/predict): تقبل طلبات تنبؤ منظّمة تتضمن صورًا مشفرة بترميز base64 ومعلمات اختيارية. تسري حدود حجم الحمولة وفقًا لنوع نقطة النهاية.

   يجب أن تتبع حمولات الطلبات المرسلة إلى نقطة النهاية /predict بنية JSON التالية:

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

بنية مجلد المشروع#

سيُجرى معظم عمل الإنشاء داخل حاوية Docker، كما سيحمّل Ultralytics نموذج YOLO26 مدرّبًا مسبقًا، لذا يمكنك الإبقاء على بنية المجلد المحلي بسيطة:

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

إنشاء pyproject.toml مع التبعيات#

لتسهيل إدارة مشروعك، أنشئ ملف pyproject.toml بالتبعيات التالية:

[project]
name = "YOUR_PROJECT_NAME"
version = "0.0.1"
description = "YOUR_PROJECT_DESCRIPTION"
requires-python = ">=3.10,<3.13"
dependencies = [
   "ultralytics>=8.4.0",
   "fastapi[all]>=0.89.1",
   "uvicorn[standard]>=0.20.0",
   "pillow>=9.0.0",
   "loguru",
]

[build-system]
requires = ["setuptools>=61.0"]
build-backend = "setuptools.build_meta"

• سيُستخدم uvicorn لتشغيل خادم FastAPI.
• سيُستخدم loguru للتسجيل في خادم FastAPI.
• سيُستخدم pillow لمعالجة الصور، لكنك لست مقيدًا بصور PIL وحدها — إذ يدعم Ultralytics تنسيقات أخرى كثيرة.

إنشاء منطق الاستدلال باستخدام Ultralytics YOLO26#

بعد إعداد بنية المشروع والتبعيات، يمكنك تنفيذ منطق الاستدلال الأساسي لـ YOLO26. أنشئ ملف src/app.py يتولى تحميل النموذج ومعالجة الصور والتنبؤ، باستخدام واجهة Python API الخاصة بـ 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

سيحمّل هذا النموذج مرة واحدة عند بدء تشغيل الحاوية، وسيُتاح النموذج لجميع الطلبات. إذا كان النموذج سيتعامل مع حمل استدلال كثيف، فمن المستحسن اختيار نوع جهاز ذي ذاكرة أكبر عند استيراد النموذج إلى Vertex AI في خطوة لاحقة.

بعد ذلك، أنشئ دالتَي أدوات لمعالجة صور الإدخال والإخراج باستخدام pillow. يدعم YOLO26 صور PIL أصليًا.

def get_image_from_bytes(binary_image: bytes) -> Image.Image:
    """Convert image from bytes to PIL RGB format."""
    input_image = Image.open(io.BytesIO(binary_image)).convert("RGB")
    return input_image

def get_bytes_from_image(image: Image.Image) -> bytes:
    """Convert PIL image to bytes."""
    return_image = io.BytesIO()
    image.save(return_image, format="JPEG", quality=85)
    return_image.seek(0)
    return return_image.getvalue()

أخيرًا، نفّذ الدالة run_inference التي ستتولى كشف الأجسام. سنستخرج في هذا المثال مربعات الإحاطة وأسماء الفئات ودرجات الثقة من تنبؤات النموذج. ستعيد الدالة قاموسًا يتضمن عمليات الكشف والنتائج الخام لمزيد من المعالجة أو التعليق التوضيحي.

def run_inference(input_image: Image.Image, confidence_threshold: float = 0.5) -> Dict[str, Any]:
    """Run inference on an image using YOLO26n model."""
    # Check if model is ready
    if not is_model_ready():
        print("Model not ready for inference")
        return {"detections": [], "results": None}

    try:
        # Make predictions and get raw results
        results = model_yolo.predict(
            imgsz=640, source=input_image, conf=confidence_threshold, save=False, augment=False, verbose=False
        )

        # Extract detections (bounding boxes, class names, and confidences)
        detections = []
        if results and len(results) > 0:
            result = results[0]
            if result.boxes is not None and len(result.boxes.xyxy) > 0:
                boxes = result.boxes

                # Convert tensors to numpy for processing
                xyxy = boxes.xyxy.cpu().numpy()
                conf = boxes.conf.cpu().numpy()
                cls = boxes.cls.cpu().numpy().astype(int)

                # Create detection dictionaries
                for i in range(len(xyxy)):
                    detection = {
                        "xmin": float(xyxy[i][0]),
                        "ymin": float(xyxy[i][1]),
                        "xmax": float(xyxy[i][2]),
                        "ymax": float(xyxy[i][3]),
                        "confidence": float(conf[i]),
                        "class": int(cls[i]),
                        "name": model_yolo.names.get(int(cls[i]), f"class_{int(cls[i])}"),
                    }
                    detections.append(detection)

        return {
            "detections": detections,
            "results": results,  # Keep raw results for annotation
        }
    except Exception as e:
        # If there's an error, return empty structure
        print(f"Error in YOLO detection: {e}")
        return {"detections": [], "results": None}

يمكنك اختياريًا إضافة دالة لوضع مربعات الإحاطة والتسميات التوضيحية على الصورة باستخدام طريقة الرسم المضمنة في Ultralytics. سيكون ذلك مفيدًا إذا أردت إرجاع صور مشروحة في استجابة التنبؤ.

def get_annotated_image(results: list) -> Image.Image:
    """Get annotated image using Ultralytics built-in plot method."""
    if not results or len(results) == 0:
        raise ValueError("No results provided for annotation")

    result = results[0]
    # ⁨استخدم طريقة الرسم المضمنة في Ultralytics مع مخرجات PIL⁩
    return result.plot(pil=True)

إنشاء خادم استدلال HTTP باستخدام FastAPI#

بعد إعداد منطق الاستدلال الأساسي لـ YOLO26، يمكنك إنشاء تطبيق FastAPI لتقديمه. وسيتضمن ذلك نقطتَي نهاية فحص الصحة والتنبؤ المطلوبتين من Vertex AI.

أولًا، أنشئ src/main.py، وأضف عمليات الاستيراد، وأنشئ تطبيق FastAPI، واضبط التسجيل في Vertex AI. بما أن Vertex AI تتعامل مع stderr بوصفه مخرجات أخطاء، فمن المنطقي توجيه السجلات إلى stdout.

# src/main.py

import sys

from fastapi import FastAPI
from loguru import logger

app = FastAPI()

# ⁨إعداد المسجّل⁩
logger.remove()
logger.add(
    sys.stdout,
    colorize=True,
    format="<green>{time:HH:mm:ss}</green> | <level>{message}</level>",
    level=10,
)
logger.add("log.log", rotation="1 MB", level="DEBUG", compression="zip")

لضمان الامتثال الكامل لمتطلبات Vertex AI، عرّف نقاط النهاية المطلوبة في متغيرات البيئة واضبط حدًا لحجم الطلبات. يوصى باستخدام نقاط نهاية Vertex AI الخاصة في عمليات النشر الإنتاجية. بهذه الطريقة، ستحصل على حد أعلى لحمولة الطلب (10 MB بدلًا من 1.5 MB لنقاط النهاية العامة)، إلى جانب أمان قوي وضوابط وصول.

# ⁨متغيرات بيئة Vertex AI⁩
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")

# ⁨حد حجم الطلب (10 MB لنقاط النهاية الخاصة، و1.5 MB للعامة)⁩
MAX_REQUEST_SIZE = 10 * 1024 * 1024  # ⁨10 MB بالبايت⁩

أضف نموذجي Pydantic للتحقق من صحة الطلبات والاستجابات:

# ⁨نماذج Pydantic للطلب/الاستجابة⁩
class PredictionRequest(BaseModel):
    instances: list
    parameters: Optional[Dict[str, Any]] = None

class PredictionResponse(BaseModel):
    predictions: list

أضف نقطة نهاية فحص الصحة للتحقق من جاهزية النموذج. هذا مهم في Vertex AI، إذ إن المنسّق لن يتمكن من تحديد ما إذا كان النموذج جاهزًا للاستدلال من دون فحص صحة مخصص، وسيواصل إرسال طلبات ping إلى مقابس عشوائية. يجب أن يعيد الفحص 200 OK عند النجاح و503 Service Unavailable عند الفشل:

# ⁨نقطة نهاية فحص الصحة⁩
@app.get(AIP_HEALTH_ROUTE, status_code=status.HTTP_200_OK)
def health_check():
    """Health check endpoint for Vertex AI."""
    if not is_model_ready():
        raise HTTPException(status_code=503, detail="Model not ready")
    return {"status": "healthy"}

أصبح لديك الآن كل ما يلزم لتنفيذ نقطة نهاية التنبؤ التي ستتعامل مع طلبات الاستدلال. ستقبل ملف صورة، وتشغّل الاستدلال، ثم تعيد النتائج. لاحظ أن الصورة يجب أن تكون مشفرة بترميز base64، ما يزيد حجم الحمولة بنسبة تصل إلى 33% إضافية.

@app.post(AIP_PREDICT_ROUTE, response_model=PredictionResponse)
async def predict(request: PredictionRequest):
    """Prediction endpoint for Vertex AI."""
    try:
        predictions = []

        for instance in request.instances:
            if isinstance(instance, dict):
                if "image" in instance:
                    image_data = base64.b64decode(instance["image"])
                    input_image = get_image_from_bytes(image_data)
                else:
                    raise HTTPException(status_code=400, detail="Instance must contain 'image' field")
            else:
                raise HTTPException(status_code=400, detail="Invalid instance format")

            # Extract 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
            ):
                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}")

أخيرًا، أضف نقطة دخول التطبيق لتشغيل خادم FastAPI.

if __name__ == "__main__":
    import uvicorn

    logger.info(f"Starting server on port {AIP_HTTP_PORT}")
    logger.info(f"Health check route: {AIP_HEALTH_ROUTE}")
    logger.info(f"Predict route: {AIP_PREDICT_ROUTE}")
    uvicorn.run(app, host="0.0.0.0", port=AIP_HTTP_PORT)

أصبح لديك الآن تطبيق FastAPI كامل قادر على تقديم طلبات استدلال YOLO26. يمكنك اختباره محليًا بتثبيت التبعيات وتشغيل الخادم، مثلًا باستخدام uv.

# Install dependencies
uv pip install -e .

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

لاختبار الخادم، يمكنك الاستعلام عن نقطتَي النهاية /health و/predict باستخدام cURL. ضع صورة اختبار في المجلد tests. ثم نفّذ الأوامر التالية في الطرفية:

# Test health endpoint
curl http://localhost:8080/health

# Test predict endpoint with base64 encoded image
curl -X POST -H "Content-Type: application/json" -d "{\"instances\": [{\"image\": \"$(base64 -i tests/test_image.jpg)\"}]}" http://localhost:8080/predict

من المفترض أن تتلقى استجابة JSON تتضمن الأجسام المكتشفة. توقّع تأخيرًا قصيرًا عند الطلب الأول، إذ يحتاج Ultralytics إلى تنزيل نموذج YOLO26 وتحميله.

2. توسيع صورة Docker من Ultralytics بتطبيقك#

يوفر Ultralytics عدة صور Docker يمكنك استخدامها أساسًا لصورة تطبيقك. وتتضمن هذه الصور Ultralytics ومكتبات CUDA اللازمة، لذا لا تحتاج إلا إلى إضافة تطبيقك فوقها.

للاستفادة من كامل إمكانات نماذج Ultralytics YOLO، ينبغي اختيار الصورة المحسّنة لـ CUDA لاستدلال GPU. أما إذا كان الاستدلال باستخدام CPU كافيًا لمهمتك، فيمكنك أيضًا توفير موارد الحوسبة باختيار الصورة المخصصة لـ CPU فقط:

• Dockerfile: صورة محسّنة لـ CUDA لتدريب YOLO26 واستدلاله باستخدام GPU واحد أو عدة وحدات GPU.
• Dockerfile-cpu: صورة مخصصة لاستدلال YOLO26 باستخدام CPU فقط.

إنشاء صورة Docker لتطبيقك#

أنشئ Dockerfile في جذر مشروعك بالمحتوى التالي:

# Extends official Ultralytics Docker image for YOLO26
FROM ultralytics/ultralytics:latest

ENV PYTHONUNBUFFERED=1

# Install FastAPI and dependencies
RUN uv pip install --system fastapi[all] uvicorn[standard] loguru

WORKDIR /app
COPY src/ ./src/
COPY pyproject.toml ./

# Install the application package
RUN uv pip install --system -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"]

يُستخدم في هذا المثال Docker image الرسمي من Ultralytics، ultralytics:latest، أساسًا للصورة. وهو يتضمن بالفعل نموذج YOLO26 وجميع التبعيات اللازمة. نقطة دخول الخادم هي نفسها التي استخدمناها لاختبار تطبيق FastAPI محليًا.

إنشاء صورة Docker واختبارها#

يمكنك الآن إنشاء صورة Docker باستخدام الأمر التالي:

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

استبدل IMAGE_NAME وIMAGE_VERSION بالقيم التي تريدها، مثل yolo26-fastapi:0.1. لاحظ أنه يجب إنشاء الصورة لمعمارية linux/amd64 عند النشر على Vertex AI. يجب تعيين المعلمة --platform صراحةً إذا كنت تنشئ الصورة على جهاز Mac بمعالج Apple Silicon أو أي معمارية أخرى غير x86.

بعد اكتمال إنشاء الصورة، يمكنك اختبار صورة Docker محليًا:

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

تُشغّل حاوية Docker الآن خادم FastAPI على المنفذ 8080، وهي جاهزة لقبول طلبات الاستدلال. يمكنك اختبار نقطتي النهاية /health و/predict باستخدام أوامر cURL نفسها التي استخدمتها سابقًا:

# Test health endpoint
curl http://localhost:8080/health

# Test predict endpoint with base64 encoded image
curl -X POST -H "Content-Type: application/json" -d "{\"instances\": [{\"image\": \"$(base64 -i tests/test_image.jpg)\"}]}" http://localhost:8080/predict

3. تحميل صورة Docker إلى GCP Artifact Registry#

لاستيراد نموذجك المحوّل إلى حاوية في Vertex AI، عليك تحميل صورة Docker إلى Google Cloud Artifact Registry. إذا لم يكن لديك مستودع في Artifact Registry بعد، فستحتاج أولًا إلى إنشاء واحد.

إنشاء مستودع في Google Cloud Artifact Registry#

افتح صفحة Artifact Registry في Google Cloud Console. إذا كنت تستخدم Artifact Registry للمرة الأولى، فقد يُطلب منك تفعيل Artifact Registry API أولًا.

1. اختر «إنشاء مستودع».
2. أدخل اسم المستودع. اختر المنطقة المطلوبة واستخدم الإعدادات الافتراضية للخيارات الأخرى، ما لم تكن بحاجة إلى تغييرها تحديدًا.

1. بعد إنشاء المستودع، احفظ PROJECT_ID والموقع (المنطقة) واسم المستودع في خزنة الأسرار أو ملف .env. ستحتاج إليها لاحقًا لوضع وسم لصورة Docker ودفعها إلى Artifact Registry.

مصادقة Docker للوصول إلى Artifact Registry#

صادِق عميل Docker للوصول إلى مستودع Artifact Registry الذي أنشأته للتو. نفّذ الأمر التالي في الطرفية:

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

وضع وسم لصورتك ودفعها إلى Artifact Registry#

ضع وسمًا لصورة Docker وادفعها إلى Google Artifact Registry.

ضع وسمًا لصورتك باستخدام عنوان URL لمستودع Artifact Registry. استبدل العناصر النائبة بالقيم التي حفظتها سابقًا.

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

ادفع الصورة ذات الوسم إلى مستودع Artifact Registry.

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

انتظر حتى تكتمل العملية. من المفترض أن تظهر الصورة الآن في مستودع Artifact Registry.

للحصول على إرشادات أكثر تحديدًا حول كيفية التعامل مع الصور في Artifact Registry، راجع وثائق Artifact Registry: دفع الصور وسحبها.

4. استيراد النموذج إلى Vertex AI#

باستخدام صورة Docker التي دفعتها للتو، يمكنك الآن استيراد النموذج إلى Vertex AI.

1. من قائمة التنقل في Google Cloud، انتقل إلى Vertex AI > Model Registry. أو ابحث عن "Vertex AI" في شريط البحث أعلى Google Cloud Console.

   

2. انقر على Import.

3. اختر Import as a new model.

4. اختر المنطقة. يمكنك اختيار المنطقة نفسها التي يوجد فيها مستودع Artifact Registry، لكن ينبغي أن يستند اختيارك إلى مدى توافر أنواع الأجهزة والحصص في منطقتك.

5. اختر Import an existing model container.

   

6. في حقل Container image، استعرض مستودع Artifact Registry الذي أنشأته سابقًا، ثم اختر الصورة التي دفعتها للتو.

7. مرّر إلى أسفل الصفحة حتى قسم Environment variables، وأدخل نقطتي نهاية predict وhealth والمنفذ الذي حددته في تطبيق FastAPI.

   

8. انقر على Import. سيستغرق Vertex AI عدة دقائق لتسجيل النموذج وإعداده للنشر. ستتلقى إشعارًا بالبريد الإلكتروني عند اكتمال الاستيراد.

5. إنشاء نقطة نهاية في Vertex AI ونشر النموذج#

لنشر نموذج، عليك إنشاء نقطة نهاية في Vertex AI.

1. في قائمة التنقل في Vertex AI، انتقل إلى Endpoints. اختر المنطقة التي استخدمتها عند استيراد النموذج. انقر على Create.

   

2. أدخل Endpoint name.

3. بالنسبة إلى Access، يوصي Vertex AI باستخدام نقاط نهاية Vertex AI الخاصة. وإلى جانب مزايا الأمان، ستحصل على حد أعلى لحجم الحمولة عند اختيار نقطة نهاية خاصة، لكن سيتعين عليك ضبط شبكة VPC وقواعد جدار الحماية للسماح بالوصول إلى نقطة النهاية. راجع وثائق Vertex AI للحصول على مزيد من الإرشادات حول نقاط النهاية الخاصة.

4. انقر على Continue.

5. في مربع الحوار Model settings، اختر النموذج الذي استوردته سابقًا. يمكنك الآن ضبط نوع الجهاز والذاكرة وإعدادات GPU للنموذج. خصص ذاكرة كافية إذا كنت تتوقع أحمال استدلال مرتفعة، لضمان عدم حدوث اختناقات في الإدخال والإخراج والحصول على أداء YOLO26 المناسب.

6. في Accelerator type، اختر نوع GPU الذي تريد استخدامه للاستدلال. إذا لم تكن متأكدًا من GPU الذي ينبغي اختياره، يمكنك البدء باستخدام NVIDIA T4، المدعوم من CUDA.

7. بعد تحديد نوع الجهاز، يمكنك النقر على Continue. في هذه المرحلة، يمكنك اختيار تفعيل مراقبة النماذج في Vertex AI، وهي خدمة إضافية تتتبّع أداء النموذج وتوفّر رؤى حول سلوكه. هذا الخيار اختياري وتترتب عليه تكاليف إضافية، لذا اختر ما يناسب احتياجاتك. انقر على Create.

سيستغرق نشر النموذج في Vertex AI عدة دقائق (وقد يصل ذلك إلى 30 دقيقة في بعض المناطق). ستتلقى إشعارًا بالبريد الإلكتروني عند اكتمال النشر.

6. اختبار النموذج المنشور#

بعد اكتمال النشر، ستوفر لك Vertex AI واجهة API نموذجية لاختبار النموذج.

لاختبار الاستدلال عن بُعد، يمكنك استخدام أمر cURL المقدم أو إنشاء مكتبة عميل أخرى بلغة Python ترسل الطلبات إلى النموذج المنشور. تذكّر ضرورة ترميز صورتك بصيغة base64 قبل إرسالها إلى نقطة النهاية /predict.

لقد نشرت بنجاح نموذج YOLO26 مدرّبًا مسبقًا باستخدام Ultralytics على Google Cloud Vertex AI.

الأسئلة الشائعة#