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

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

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

ما ستتعلمه

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

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

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

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

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

أساسيات توافق Vertex AI

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

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

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

   يجب أن تتبع حمولات الطلبات لنقطة النهاية /predict هذا الهيكل JSON:

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

هيكل مجلد المشروع

سيحدث الجزء الأكبر من البناء داخل حاوية Docker، وستقوم Ultralytics أيضًا بتحميل نموذج YOLO11 مُدرَّب مسبقًا، بحيث يمكنك الحفاظ على بنية المجلد المحلي بسيطة:

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

إنشاء 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.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.
• pillow سيتم استخدامها لمعالجة الصور، ولكنك لست مقيدًا بصور PIL فقط — تدعم Ultralytics العديد من التنسيقات الأخرى.

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

الآن بعد أن قمت بإعداد هيكل المشروع والتبعيات، يمكنك تنفيذ منطق الاستدلال الأساسي لـ YOLO11. قم بإنشاء src/app.py ملف سيتعامل مع تحميل النموذج ومعالجة الصور والتنبؤ، باستخدام Ultralytics Python API.

# src/app.py

from ultralytics import YOLO

# Model initialization and readiness state
model_yolo = None
_model_ready = False


def _initialize_model():
    """Initialize the YOLO model."""
    global model_yolo, _model_ready

    try:
        # Use pre-trained YOLO11n model from Ultralytics base image
        model_yolo = YOLO("yolo11n.pt")
        _model_ready = True

    except Exception as e:
        print(f"Error initializing YOLO model: {e}")
        _model_ready = False
        model_yolo = None


# Initialize model on module import
_initialize_model()


def is_model_ready() -> bool:
    """Check if the model is ready for inference."""
    return _model_ready and model_yolo is not None

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

بعد ذلك، قم بإنشاء وظيفتين utility لمعالجة الصور المدخلة والمخرجة باستخدام pillow. يدعم YOLO11 صور 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 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}

اختياريًا، يمكنك إضافة وظيفة لتعليق الصورة بالمربعات المحيطة والتسميات باستخدام طريقة الرسم المضمنة في 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]
    # Use Ultralytics built-in plot method with PIL output
    return result.plot(pil=True)

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

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

أولاً، أضف عمليات الاستيراد وقم بتكوين التسجيل لـ Vertex AI. نظرًا لأن Vertex AI يعامل stderr كمخرج خطأ، فمن المنطقي توجيه السجلات إلى stdout.

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

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

# 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

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

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


class PredictionResponse(BaseModel):
    predictions: list

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

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

لديك الآن كل شيء لتنفيذ نقطة نهاية التنبؤ التي ستتعامل مع طلبات الاستدلال. سيقبل ملف صورة، ويقوم بتشغيل الاستدلال، وإرجاع النتائج. لاحظ أنه يجب ترميز الصورة بـ 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 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)}")

أخيرًا، أضف نقطة دخول التطبيق لتشغيل خادم 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 كامل يمكنه خدمة طلبات استدلال YOLO11. يمكنك اختباره محليًا عن طريق تثبيت التبعيات وتشغيل الخادم، على سبيل المثال، باستخدام 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 إلى سحب وتحميل نموذج YOLO11.

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

توفر Ultralytics العديد من صور Docker التي يمكنك استخدامها كأساس لصورة التطبيق الخاص بك. سيقوم Docker بتثبيت Ultralytics وبرامج تشغيل GPU الضرورية.

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

• Dockerfile: صورة مُحسَّنة لـ CUDA لتدريب واستدلال YOLO11 أحادي/متعدد GPU.
• Dockerfile-cpu: صورة مخصصة لوحدة المعالجة المركزية CPU فقط لاستدلال YOLO11.

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

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

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

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

بناء واختبار صورة Docker

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

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

استبدل IMAGE_NAME و IMAGE_VERSION بالقيم التي تريدها، على سبيل المثال، yolo11-fastapi:0.1. لاحظ أنه يجب عليك إنشاء الصورة الخاصة بـ linux/amd64 البنية إذا كنت تنشر على Vertex AI. يجب تعيين --platform المعلمة بشكل صريح إذا كنت تقوم بإنشاء الصورة على Apple Silicon Mac أو أي بنية أخرى غير 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. انقر فوق استيراد.

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

5. حدد استيراد حاوية نموذج موجودة.

   

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

7. مرر لأسفل إلى قسم متغيرات البيئة وأدخل نقاط نهاية التوقع والصحة والمنفذ الذي حددته في تطبيق FastAPI الخاص بك.

   

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

5. إنشاء نقطة نهاية Vertex AI ونشر النموذج الخاص بك

لنشر نموذج، تحتاج إلى إنشاء نقطة نهاية (Endpoint) في Vertex AI.

1. في قائمة التنقل في Vertex AI، انتقل إلى نقاط النهاية (Endpoints). حدد المنطقة التي استخدمتها عند استيراد النموذج الخاص بك. انقر فوق إنشاء (Create).

1. أدخل اسم نقطة النهاية (Endpoint).
2. بالنسبة للوصول (Access)، توصي Vertex AI باستخدام نقاط نهاية Vertex AI الخاصة. بالإضافة إلى المزايا الأمنية، تحصل على حد أقصى لحجم الحمولة (payload) أعلى إذا قمت بتحديد نقطة نهاية خاصة، ومع ذلك ستحتاج إلى تكوين شبكة VPC وقواعد جدار الحماية للسماح بالوصول إلى نقطة النهاية. راجع وثائق Vertex AI للحصول على مزيد من الإرشادات حول نقاط النهاية الخاصة.
3. انقر فوق متابعة (Continue).
4. في مربع حوار إعدادات النموذج (Model settings)، حدد النموذج الذي استوردته سابقًا. يمكنك الآن تكوين نوع الجهاز والذاكرة وإعدادات وحدة معالجة الرسومات (GPU) للنموذج الخاص بك. خصص ذاكرة كبيرة إذا كنت تتوقع أحمال استدلال عالية لضمان عدم وجود اختناقات في الإدخال/الإخراج (I/O) لأداء YOLO11 المناسب.

5. في نوع المسرّع (Accelerator type)، حدد نوع وحدة معالجة الرسومات (GPU) التي تريد استخدامها للاستدلال. إذا لم تكن متأكدًا من وحدة معالجة الرسومات (GPU) التي يجب تحديدها، فيمكنك البدء بـ NVIDIA T4، المدعومة من CUDA.

   حصص المنطقة ونوع الجهاز

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

6. بمجرد تحديد نوع الجهاز، يمكنك النقر فوق متابعة (Continue). في هذه المرحلة، يمكنك اختيار تمكين مراقبة النموذج في Vertex AI - وهي خدمة إضافية ستتتبع أداء النموذج الخاص بك وتقدم رؤى حول سلوكه. هذا اختياري ويتكبد تكاليف إضافية، لذا حدد وفقًا لاحتياجاتك. انقر فوق إنشاء (Create).

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

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

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

لاختبار الاستدلال عن بعد، يمكنك استخدام أمر cURL المتوفر أو إنشاء مكتبة عميل python أخرى سترسل طلبات إلى النموذج المنشور. تذكر أنك تحتاج إلى ترميز صورتك إلى base64 قبل إرسالها إلى /predict نقطة النهاية (endpoint).

تهانينا! لقد نجحت في نشر نموذج YOLO11 مُدرَّب مسبقًا باستخدام Ultralytics على Google Cloud Vertex AI.

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

هل يمكنني استخدام نماذج Ultralytics YOLO على Vertex AI بدون Docker؟

نعم، ولكنك ستحتاج أولاً إلى تصدير النموذج إلى تنسيق متوافق مع Vertex AI، مثل TensorFlow أو Scikit-learn أو XGBoost. توفر Google Cloud دليلًا حول تشغيل .pt النماذج على Vertex مع نظرة عامة كاملة على عملية التحويل: تشغيل نماذج PyTorch على Vertex AI.

يرجى ملاحظة أن الإعداد الناتج سيعتمد فقط على طبقة خدمة Vertex AI القياسية ولن يدعم ميزات إطار عمل Ultralytics المتقدم. نظرًا لأن Vertex AI يدعم تمامًا النماذج المحتواة في حاويات وقادر على توسيع نطاقها تلقائيًا وفقًا لتكوين النشر الخاص بك، فإنه يسمح لك بالاستفادة من الإمكانات الكاملة لنماذج Ultralytics YOLO دون الحاجة إلى تحويلها إلى تنسيق مختلف.

لماذا يعتبر FastAPI خيارًا جيدًا لخدمة استدلال YOLO11؟

يوفر FastAPI إنتاجية عالية لأحمال عمل الاستدلال. يتيح دعم Async معالجة طلبات متزامنة متعددة دون حظر مؤشر الترابط الرئيسي، وهو أمر مهم عند خدمة نماذج رؤية الكمبيوتر.

يقلل التحقق التلقائي من الطلبات/الاستجابات باستخدام FastAPI من أخطاء وقت التشغيل في خدمات الاستدلال في الإنتاج. هذا ذو قيمة خاصة بالنسبة لواجهات برمجة تطبيقات (APIs) الكشف عن الكائنات حيث يكون اتساق تنسيق الإدخال أمرًا بالغ الأهمية.

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

يدعم FastAPI أيضًا SSE (أحداث يتم إرسالها من الخادم)، وهو أمر مفيد لسيناريوهات الاستدلال المتدفقة.

لماذا يتعين علي تحديد منطقة عدة مرات؟

هذه في الواقع ميزة تنوع في Google Cloud Platform، حيث تحتاج إلى تحديد منطقة لكل خدمة تستخدمها. بالنسبة لمهمة نشر نموذج مُحَوَّى على Vertex AI، فإن أهم اختيار للمنطقة هو الخاص بـ Model Registry. سيحدد ذلك مدى توفر أنواع الآلات والحصص لنشر النموذج الخاص بك.

بالإضافة إلى ذلك، إذا كنت ستقوم بتوسيع الإعداد وتخزين بيانات التنبؤ أو النتائج في Cloud Storage أو BigQuery، فستحتاج إلى استخدام نفس المنطقة الخاصة بـ Model Registry، لتقليل زمن الوصول وضمان إنتاجية عالية للوصول إلى البيانات.

📅 تم إنشاؤه منذ شهر واحد ✏️ تم التحديث منذ شهر واحد

تعليقات