# نشر السحابة باستخدام الحاويات - حلول على مستوى الإنتاج

يغطي هذا الدليل الشامل ثلاثة نهج رئيسية لنشر نموذج Phi-4-mini-instruct من Microsoft في بيئات الحاويات: vLLM، Ollama، ومحرك SLM مع ONNX Runtime. يمثل هذا النموذج الذي يحتوي على 3.8 مليار معلمة خيارًا مثاليًا لمهام التفكير مع الحفاظ على الكفاءة للنشر على الأجهزة الطرفية.

## جدول المحتويات

1. [مقدمة إلى نشر Phi-4-mini باستخدام الحاويات](../../../Module03)
2. [أهداف التعلم](../../../Module03)
3. [فهم تصنيف Phi-4-mini](../../../Module03)
4. [نشر حاوية vLLM](../../../Module03)
5. [نشر حاوية Ollama](../../../Module03)
6. [محرك SLM مع ONNX Runtime](../../../Module03)
7. [إطار المقارنة](../../../Module03)
8. [أفضل الممارسات](../../../Module03)

## مقدمة إلى نشر Phi-4-mini باستخدام الحاويات

تمثل نماذج اللغة الصغيرة (SLMs) تقدمًا مهمًا في EdgeAI، حيث تتيح قدرات معالجة اللغة الطبيعية المتقدمة على الأجهزة ذات الموارد المحدودة. يركز هذا الدليل على استراتيجيات النشر باستخدام الحاويات لنموذج Phi-4-mini-instruct من Microsoft، وهو نموذج حديث للتفكير يتميز بالتوازن بين القدرة والكفاءة.

### النموذج المميز: Phi-4-mini-instruct

**Phi-4-mini-instruct (3.8 مليار معلمة)**: أحدث نموذج خفيف الوزن من Microsoft تم ضبطه على التعليمات، مصمم للبيئات ذات القيود على الذاكرة والحوسبة، مع قدرات استثنائية في:
- **التفكير الرياضي والعمليات الحسابية المعقدة**
- **توليد الأكواد، تصحيح الأخطاء، والتحليل**
- **حل المشكلات المنطقية والتفكير خطوة بخطوة**
- **التطبيقات التعليمية التي تتطلب تفسيرات مفصلة**
- **استدعاء الوظائف ودمج الأدوات**

كجزء من فئة "SLMs الصغيرة" (1.5 مليار - 13.9 مليار معلمة)، يحقق Phi-4-mini توازنًا مثاليًا بين قدرة التفكير وكفاءة الموارد.

### فوائد نشر Phi-4-mini باستخدام الحاويات

- **الكفاءة التشغيلية**: استنتاج سريع لمهام التفكير مع متطلبات حوسبة منخفضة
- **مرونة النشر**: قدرات الذكاء الاصطناعي على الأجهزة مع تعزيز الخصوصية من خلال المعالجة المحلية
- **فعالية التكلفة**: تقليل التكاليف التشغيلية مقارنة بالنماذج الأكبر مع الحفاظ على الجودة
- **العزل**: فصل نظيف بين مثيلات النموذج وبيئات التنفيذ الآمنة
- **القابلية للتوسع**: التوسع الأفقي بسهولة لزيادة إنتاجية التفكير

## أهداف التعلم

بنهاية هذا الدليل، ستكون قادرًا على:

- نشر وتحسين Phi-4-mini-instruct في بيئات الحاويات المختلفة
- تنفيذ استراتيجيات التكميم والضغط المتقدمة لسيناريوهات النشر المختلفة
- إعداد تنسيق الحاويات الجاهز للإنتاج لمهام التفكير
- تقييم واختيار أطر النشر المناسبة بناءً على متطلبات الحالة الخاصة
- تطبيق أفضل الممارسات للأمان، المراقبة، والتوسع في نشر SLM باستخدام الحاويات

## فهم تصنيف Phi-4-mini

### مواصفات النموذج

**التفاصيل التقنية:**
- **المعلمات**: 3.8 مليار (فئة SLM الصغيرة)
- **الهيكل**: Transformer مشفر فقط مع انتباه استعلامات مجمعة
- **طول السياق**: 128 ألف رمز (32 ألف موصى به للأداء الأمثل)
- **المفردات**: 200 ألف رمز مع دعم متعدد اللغات
- **بيانات التدريب**: 5 تريليون رمز من محتوى غني بالتفكير عالي الجودة

### متطلبات الموارد

| نوع النشر | الحد الأدنى للذاكرة | الذاكرة الموصى بها | VRAM (GPU) | التخزين | الاستخدامات النموذجية |
|-----------|---------------------|--------------------|------------|---------|-----------------------|
| **التطوير** | 6GB | 8GB | - | 8GB | الاختبار المحلي، النماذج الأولية |
| **الإنتاج باستخدام CPU** | 8GB | 12GB | - | 10GB | الخوادم الطرفية، النشر بتكلفة منخفضة |
| **الإنتاج باستخدام GPU** | 6GB | 8GB | 4-6GB | 8GB | خدمات التفكير عالية الإنتاجية |
| **النشر الطرفي** | 4GB | 6GB | - | 6GB | النشر المكمم، بوابات إنترنت الأشياء |

### قدرات Phi-4-mini

- **التفوق الرياضي**: حل متقدم للمشكلات الحسابية، الجبرية، والتفاضلية
- **ذكاء الأكواد**: توليد الأكواد بلغات متعددة مثل Python وJavaScript مع تصحيح الأخطاء
- **التفكير المنطقي**: تحليل المشكلات خطوة بخطوة وبناء الحلول
- **الدعم التعليمي**: تفسيرات مفصلة مناسبة للتعلم والتعليم
- **استدعاء الوظائف**: دعم أصلي لدمج الأدوات والتفاعل مع واجهات البرمجة

## نشر حاوية vLLM

يوفر vLLM دعمًا ممتازًا لنموذج Phi-4-mini-instruct مع أداء استنتاج محسن وواجهات برمجة تطبيقات متوافقة مع OpenAI، مما يجعله مثاليًا لخدمات التفكير الإنتاجية.

### أمثلة البدء السريع

#### نشر أساسي باستخدام CPU (للتطوير)
```bash
# CPU-optimized deployment for development and testing
docker run --name phi4-mini-dev \
  -e HUGGING_FACE_HUB_TOKEN=${HF_TOKEN} \
  -p 8000:8000 \
  --memory="8g" --cpus="4" \
  vllm/vllm-openai:latest \
  --model microsoft/Phi-4-mini-instruct \
  --max-model-len 4096 \
  --max-num-seqs 4 \
  --trust-remote-code
```

#### نشر إنتاجي مع تسريع GPU
```bash
# GPU deployment for high-performance reasoning
docker run --runtime nvidia --gpus all \
  --name phi4-mini-prod \
  -e HUGGING_FACE_HUB_TOKEN=${HF_TOKEN} \
  -p 8000:8000 \
  vllm/vllm-openai:latest \
  --model microsoft/Phi-4-mini-instruct \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.8 \
  --enable-auto-tool-choice \
  --trust-remote-code
```

### إعداد الإنتاج

```yaml
version: '3.8'
services:
  phi4-mini-reasoning:
    image: vllm/vllm-openai:latest
    container_name: phi4-mini-production
    ports:
      - "8000:8000"
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
      - ./logs:/app/logs
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}
      - CUDA_VISIBLE_DEVICES=0
    command: >
      --model microsoft/Phi-4-mini-instruct
      --host 0.0.0.0
      --port 8000
      --max-model-len 4096
      --max-num-seqs 8
      --gpu-memory-utilization 0.8
      --trust-remote-code
      --enable-auto-tool-choice
      --quantization awq
    deploy:
      resources:
        limits:
          memory: 12G
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
```

### اختبار قدرات التفكير لنموذج Phi-4-mini

```bash
# Test mathematical reasoning
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "microsoft/Phi-4-mini-instruct",
    "messages": [
      {"role": "system", "content": "You are a mathematical reasoning assistant. Show your work step by step."},
      {"role": "user", "content": "A train travels 240 km in 3 hours. If it increases its speed by 20 km/h, how long would the same journey take?"}
    ],
    "max_tokens": 200,
    "temperature": 0.3
  }'

# Test code generation
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "microsoft/Phi-4-mini-instruct",
    "messages": [
      {"role": "user", "content": "Write a Python function to calculate the Fibonacci sequence using dynamic programming. Include comments explaining the approach."}
    ],
    "max_tokens": 300,
    "temperature": 0.5
  }'

# Test function calling capability
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "microsoft/Phi-4-mini-instruct",
    "messages": [
      {"role": "user", "content": "Calculate the area of a circle with radius 5 units"}
    ],
    "tools": [
      {
        "type": "function",
        "function": {
          "name": "calculate_circle_area",
          "description": "Calculate the area of a circle given its radius",
          "parameters": {
            "type": "object",
            "properties": {
              "radius": {"type": "number", "description": "The radius of the circle"}
            },
            "required": ["radius"]
          }
        }
      }
    ],
    "tool_choice": "auto"
  }'
```

## نشر حاوية Ollama

يوفر Ollama دعمًا ممتازًا لنموذج Phi-4-mini-instruct مع نشر وإدارة مبسطة، مما يجعله مثاليًا للتطوير والنشر الإنتاجي المتوازن.

### الإعداد السريع

```bash
# Deploy Ollama container with GPU support
docker run -d \
  --name ollama-phi4 \
  --gpus all \
  -v ollama-data:/root/.ollama \
  -p 11434:11434 \
  --restart unless-stopped \
  ollama/ollama:latest

# Pull Phi-4-mini-instruct model
docker exec ollama-phi4 ollama pull phi4-mini

# Test mathematical reasoning
docker exec ollama-phi4 ollama run phi4-mini \
  "Solve this step by step: If compound interest on $5000 at 6% annually for 3 years, what is the final amount?"

# Test code generation
docker exec ollama-phi4 ollama run phi4-mini \
  "Write a Python function to implement binary search with detailed comments"
```

### إعداد الإنتاج

```yaml
version: '3.8'
services:
  ollama-phi4:
    image: ollama/ollama:latest
    container_name: ollama-phi4-production
    ports:
      - "11434:11434"
    volumes:
      - ollama-data:/root/.ollama
      - ./modelfiles:/modelfiles
    environment:
      - OLLAMA_HOST=0.0.0.0
      - OLLAMA_NUM_PARALLEL=4
      - OLLAMA_MAX_LOADED_MODELS=1
      - OLLAMA_FLASH_ATTENTION=1
    deploy:
      resources:
        limits:
          memory: 12G
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:11434/api/tags"]
      interval: 30s
      timeout: 10s
      retries: 3

  # Web UI for interactive reasoning tasks
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: phi4-webui
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama-phi4:11434
      - DEFAULT_MODELS=phi4-mini
    depends_on:
      - ollama-phi4
    volumes:
      - open-webui-data:/app/backend/data

volumes:
  ollama-data:
  open-webui-data:
```

### تحسين النموذج والمتغيرات

```bash
# Create reasoning-optimized variant
cat > /tmp/phi4-reasoning << EOF
FROM phi4-mini
PARAMETER temperature 0.3
PARAMETER top_p 0.8
SYSTEM """You are an expert reasoning assistant specialized in mathematics, logic, and code analysis. 
Always think step by step and show your work clearly. 
For mathematical problems, break down each calculation.
For coding problems, explain your approach and include comments."""
EOF

docker exec ollama-phi4 ollama create phi4-mini-reasoning -f /tmp/phi4-reasoning

# Create code-focused variant
cat > /tmp/phi4-coder << EOF
FROM phi4-mini
PARAMETER temperature 0.5
PARAMETER top_p 0.9
SYSTEM """You are a coding assistant specialized in writing clean, efficient, and well-documented code.
Always include detailed comments explaining your approach.
Follow best practices for the target programming language.
Provide examples and test cases when helpful."""
EOF

docker exec ollama-phi4 ollama create phi4-mini-coder -f /tmp/phi4-coder
```

### أمثلة استخدام API

```bash
# Mathematical reasoning via API
curl http://localhost:11434/api/generate -d '{
  "model": "phi4-mini-reasoning",
  "prompt": "A rectangle has length 15cm and width 8cm. If we increase both dimensions by 20%, what is the percentage increase in area?",
  "stream": false,
  "options": {
    "temperature": 0.3,
    "top_p": 0.8,
    "num_ctx": 4096
  }
}'

# Code generation via API
curl http://localhost:11434/api/generate -d '{
  "model": "phi4-mini-coder",
  "prompt": "Create a Python class for a binary tree with methods for insertion, deletion, and in-order traversal. Include comprehensive docstrings.",
  "stream": false,
  "options": {
    "temperature": 0.5,
    "top_p": 0.9,
    "num_ctx": 4096
  }
}'
```

## محرك SLM مع ONNX Runtime

يوفر ONNX Runtime أداءً مثاليًا للنشر الطرفي لنموذج Phi-4-mini-instruct مع تحسينات متقدمة وتوافق عبر الأنظمة الأساسية.

### الإعداد الأساسي

```dockerfile
# Dockerfile for ONNX-optimized Phi-4-mini
FROM python:3.11-slim

RUN pip install --no-cache-dir \
    onnxruntime-gpu \
    optimum[onnxruntime] \
    transformers \
    fastapi \
    uvicorn

COPY app/ /app/
WORKDIR /app
EXPOSE 8080
CMD ["python", "server.py"]
```

### تنفيذ خادم مبسط

```python
# app/server.py - Optimized for Phi-4-mini reasoning tasks
import os
import time
import onnxruntime as ort
from transformers import AutoTokenizer
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI(title="Phi-4-mini ONNX Engine")

class ReasoningRequest(BaseModel):
    prompt: str
    task_type: str = "reasoning"  # reasoning, coding, math
    max_length: int = 200
    temperature: float = 0.3

class Phi4MiniEngine:
    def __init__(self):
        self.model = None
        self.tokenizer = None
        self.load_model()
    
    def load_model(self):
        model_path = "/app/models/phi4-mini-instruct.onnx"
        if os.path.exists(model_path):
            # Optimized providers for reasoning tasks
            providers = [
                ('CUDAExecutionProvider', {
                    'arena_extend_strategy': 'kSameAsRequested',
                    'cudnn_conv_algo_search': 'HEURISTIC',
                }),
                ('CPUExecutionProvider', {
                    'intra_op_num_threads': 4,
                    'inter_op_num_threads': 2,
                })
            ]
            
            self.model = ort.InferenceSession(model_path, providers=providers)
            self.tokenizer = AutoTokenizer.from_pretrained("microsoft/Phi-4-mini-instruct")
            print("✓ Phi-4-mini model loaded successfully")
        else:
            print("✗ Model file not found. Please convert the model first.")
    
    def generate_reasoning(self, request: ReasoningRequest):
        if not self.model:
            raise ValueError("Model not loaded")
        
        # Task-specific prompting for better reasoning
        task_prompts = {
            "reasoning": "Think step by step and show your reasoning clearly:",
            "math": "Solve this mathematical problem step by step:",
            "coding": "Write clean, well-commented code for this task:"
        }
        
        system_prompt = task_prompts.get(request.task_type, "")
        full_prompt = f"{system_prompt}\n{request.prompt}"
        
        # Tokenize and run inference
        inputs = self.tokenizer.encode(full_prompt, return_tensors="np", max_length=2048, truncation=True)
        
        start_time = time.time()
        outputs = self.model.run(None, {"input_ids": inputs})
        inference_time = time.time() - start_time
        
        # Decode response
        generated_text = self.tokenizer.decode(outputs[0][0], skip_special_tokens=True)
        
        return {
            "generated_text": generated_text,
            "task_type": request.task_type,
            "inference_time": inference_time,
            "model": "phi4-mini-instruct-onnx"
        }

# Initialize engine
engine = Phi4MiniEngine()

@app.post("/reasoning")
async def generate_reasoning(request: ReasoningRequest):
    try:
        return engine.generate_reasoning(request)
    except Exception as e:
        return {"error": str(e)}

@app.get("/health")
async def health():
    return {
        "status": "healthy" if engine.model else "model_not_loaded",
        "model": "phi4-mini-instruct",
        "capabilities": ["reasoning", "math", "coding"]
    }

@app.get("/")
async def root():
    return {
        "name": "Phi-4-mini ONNX Engine",
        "model": "microsoft/Phi-4-mini-instruct",
        "endpoints": ["/reasoning", "/health"],
        "capabilities": ["mathematical reasoning", "code generation", "logical problem solving"]
    }
```

### نص تحويل النموذج

```python
# convert_phi4_mini.py - Convert Phi-4-mini to optimized ONNX
import os
from pathlib import Path
from optimum.onnxruntime import ORTModelForCausalLM, ORTOptimizer, ORTQuantizer
from optimum.onnxruntime.configuration import AutoQuantizationConfig, AutoOptimizationConfig
from transformers import AutoTokenizer

def convert_phi4_mini():
    print("Converting Phi-4-mini-instruct to optimized ONNX...")
    
    model_name = "microsoft/Phi-4-mini-instruct"
    output_dir = Path("./models/phi4-mini-onnx")
    output_dir.mkdir(parents=True, exist_ok=True)
    
    # Step 1: Convert to ONNX
    print("Step 1: Converting to ONNX format...")
    model = ORTModelForCausalLM.from_pretrained(
        model_name,
        export=True,
        provider="CPUExecutionProvider",
        use_cache=True
    )
    
    # Step 2: Apply optimizations for reasoning tasks
    print("Step 2: Applying reasoning-specific optimizations...")
    optimization_config = AutoOptimizationConfig.with_optimization_level(
        optimization_level="O3",
        optimize_for_gpu=True,
        fp16=True
    )
    
    optimizer = ORTOptimizer.from_pretrained(model)
    optimizer.optimize(save_dir=output_dir, optimization_config=optimization_config)
    
    # Step 3: Apply quantization for edge deployment
    print("Step 3: Applying quantization...")
    quantization_config = AutoQuantizationConfig.avx512_vnni(
        is_static=False,
        per_channel=True
    )
    
    quantizer = ORTQuantizer.from_pretrained(output_dir)
    quantizer.quantize(
        save_dir=output_dir / "quantized",
        quantization_config=quantization_config
    )
    
    # Step 4: Save tokenizer
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    tokenizer.save_pretrained(output_dir)
    
    # Step 5: Create final optimized model
    final_model_path = Path("./models/phi4-mini-instruct.onnx")
    quantized_files = list((output_dir / "quantized").glob("*.onnx"))
    if quantized_files:
        import shutil
        shutil.copy2(quantized_files[0], final_model_path)
        print(f"✓ Phi-4-mini converted and optimized: {final_model_path}")
    
    return final_model_path

if __name__ == "__main__":
    convert_phi4_mini()
```

### إعداد الإنتاج

```yaml
version: '3.8'
services:
  # Model conversion service (run once)
  phi4-converter:
    build: .
    container_name: phi4-converter
    volumes:
      - ./models:/app/models
      - ~/.cache/huggingface:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}
    command: python convert_phi4_mini.py
    profiles: ["convert"]

  # Main reasoning engine
  phi4-onnx:
    build: .
    container_name: phi4-onnx-engine
    ports:
      - "8080:8080"
    volumes:
      - ./models:/app/models:ro
    environment:
      - LOG_LEVEL=INFO
    deploy:
      resources:
        limits:
          memory: 8G
          cpus: '4'
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3
```

### اختبار نشر ONNX

```bash
# Test mathematical reasoning
curl -X POST http://localhost:8080/reasoning \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "If a car travels at 60 mph for 2.5 hours, then at 80 mph for 1.5 hours, what is the total distance traveled?",
    "task_type": "math",
    "max_length": 150,
    "temperature": 0.3
  }'

# Test code generation
curl -X POST http://localhost:8080/reasoning \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Create a Python function to find the greatest common divisor of two numbers using the Euclidean algorithm",
    "task_type": "coding",
    "max_length": 250,
    "temperature": 0.5
  }'

# Test logical reasoning
curl -X POST http://localhost:8080/reasoning \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "All cats are mammals. Some mammals are carnivores. Can we conclude that some cats are carnivores?",
    "task_type": "reasoning",
    "max_length": 200,
    "temperature": 0.3
  }'
```

## إطار المقارنة

### مقارنة الأطر لنموذج Phi-4-mini

| الميزة | vLLM | Ollama | ONNX Runtime |
|--------|------|--------|--------------|
| **تعقيد الإعداد** | متوسط | سهل | معقد |
| **الأداء (GPU)** | ممتاز (~25 رمز/ثانية) | جيد جدًا (~20 رمز/ثانية) | جيد (~15 رمز/ثانية) |
| **الأداء (CPU)** | جيد (~8 رمز/ثانية) | جيد جدًا (~12 رمز/ثانية) | ممتاز (~15 رمز/ثانية) |
| **استخدام الذاكرة** | 8-12GB | 6-10GB | 4-8GB |
| **توافق API** | متوافق مع OpenAI | REST مخصص | FastAPI مخصص |
| **استدعاء الوظائف** | ✅ أصلي | ✅ مدعوم | ⚠️ تنفيذ مخصص |
| **دعم التكميم** | AWQ، GPTQ | Q4_0، Q5_1، Q8_0 | تكميم ONNX |
| **جاهزية الإنتاج** | ✅ ممتاز | ✅ جيد جدًا | ✅ جيد |
| **النشر الطرفي** | جيد | ممتاز | رائع |

## موارد إضافية

### الوثائق الرسمية
- **بطاقة نموذج Microsoft Phi-4**: مواصفات مفصلة وإرشادات الاستخدام
- **وثائق vLLM**: خيارات الإعداد والتحسين المتقدمة
- **مكتبة نماذج Ollama**: نماذج المجتمع وأمثلة التخصيص
- **أدلة ONNX Runtime**: استراتيجيات تحسين الأداء والنشر

### أدوات التطوير
- **Hugging Face Transformers**: للتفاعل مع النموذج والتخصيص
- **مواصفات API لـ OpenAI**: لاختبار توافق vLLM
- **أفضل ممارسات Docker**: أمان الحاويات وإرشادات التحسين
- **نشر Kubernetes**: أنماط التنسيق للتوسع الإنتاجي

### موارد التعلم
- **قياس أداء SLM**: منهجيات التحليل المقارن
- **نشر Edge AI**: أفضل الممارسات للبيئات ذات الموارد المحدودة
- **تحسين مهام التفكير**: استراتيجيات التوجيه للمشكلات الرياضية والمنطقية
- **أمان الحاويات**: ممارسات تعزيز الأمان لنشر نماذج الذكاء الاصطناعي

## نتائج التعلم

بعد إكمال هذا الدليل، ستكون قادرًا على:

1. نشر نموذج Phi-4-mini-instruct في بيئات الحاويات باستخدام أطر متعددة
2. إعداد وتحسين نشر SLM لبيئات الأجهزة المختلفة
3. تنفيذ أفضل ممارسات الأمان لنشر الذكاء الاصطناعي باستخدام الحاويات
4. مقارنة واختيار أطر النشر المناسبة بناءً على متطلبات الحالة الخاصة
5. تطبيق استراتيجيات المراقبة والتوسع لخدمات SLM على مستوى الإنتاج

## ما التالي

- العودة إلى [الوحدة 1](../Module01/README.md)
- العودة إلى [الوحدة 2](../Module02/README.md)

---

**إخلاء المسؤولية**:  
تم ترجمة هذا المستند باستخدام خدمة الترجمة بالذكاء الاصطناعي [Co-op Translator](https://github.com/Azure/co-op-translator). بينما نسعى لتحقيق الدقة، يرجى العلم أن الترجمات الآلية قد تحتوي على أخطاء أو معلومات غير دقيقة. يجب اعتبار المستند الأصلي بلغته الأصلية المصدر الموثوق. للحصول على معلومات حاسمة، يُوصى بالاستعانة بترجمة بشرية احترافية. نحن غير مسؤولين عن أي سوء فهم أو تفسيرات خاطئة تنشأ عن استخدام هذه الترجمة.