المراقبة والتنبيه لأنظمة ML

تتطلب أنظمة ML الإنتاجية مراقبة متخصصة تتجاوز مقاييس التطبيق التقليدية. يشمل ذلك أداء النموذج واكتشاف انحراف البيانات واستخدام GPU وتتبع زمن الاستدلال.

مكدس مراقبة ML

┌─────────────────────────────────────────────────────────────────────┐
│                    بنية مراقبة ML                                    │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │                   التنبيه والإشعارات                         │    │
│  │  [Alertmanager] → [PagerDuty] [Slack] [البريد]              │    │
│  └─────────────────────────────────────────────────────────────┘    │
│                              ↑                                       │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │                   التصور (Grafana)                          │    │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐    │    │
│  │  │ لوحة GPU │  │  زمن    │  │  دقة    │  │  تحليل  │    │    │
│  │  │          │  │ الاستدلال│  │ النموذج │  │ التكلفة │    │    │
│  │  └──────────┘  └──────────┘  └──────────┘  └──────────┘    │    │
│  └─────────────────────────────────────────────────────────────┘    │
│                              ↑                                       │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │                   تخزين المقاييس                             │    │
│  │  [Prometheus] [Thanos/Cortex للمدى الطويل]                  │    │
│  └─────────────────────────────────────────────────────────────┘    │
│                              ↑                                       │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │                   المُصدّرون والجامعون                       │    │
│  │  [DCGM] [kube-state] [node-exporter] [مقاييس ML مخصصة]     │    │
│  └─────────────────────────────────────────────────────────────┘    │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

مراقبة GPU مع DCGM

# DaemonSet مُصدّر DCGM
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: dcgm-exporter
  namespace: monitoring
spec:
  selector:
    matchLabels:
      app: dcgm-exporter
  template:
    metadata:
      labels:
        app: dcgm-exporter
    spec:
      nodeSelector:
        nvidia.com/gpu.present: "true"
      containers:
      - name: dcgm-exporter
        image: nvcr.io/nvidia/k8s/dcgm-exporter:3.3.0-3.2.0-ubuntu22.04
        ports:
        - containerPort: 9400
          name: metrics
        env:
        - name: DCGM_EXPORTER_LISTEN
          value: ":9400"
        - name: DCGM_EXPORTER_KUBERNETES
          value: "true"
        securityContext:
          privileged: true
        volumeMounts:
        - name: pod-gpu-resources
          mountPath: /var/lib/kubelet/pod-resources
      volumes:
      - name: pod-gpu-resources
        hostPath:
          path: /var/lib/kubelet/pod-resources
---
apiVersion: v1
kind: Service
metadata:
  name: dcgm-exporter
  labels:
    app: dcgm-exporter
spec:
  selector:
    app: dcgm-exporter
  ports:
  - port: 9400
    targetPort: 9400

قواعد تنبيه خاصة بـ ML

apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: ml-production-alerts
  namespace: monitoring
spec:
  groups:
  - name: inference-sla
    rules:
    - alert: InferenceLatencyHigh
      expr: |
        histogram_quantile(0.99,
          sum(rate(inference_latency_seconds_bucket[5m])) by (le, model)
        ) > 2
      for: 5m
      labels:
        severity: warning
        team: ml-platform
      annotations:
        summary: "زمن استدلال P99 يتجاوز 2s لـ {{ $labels.model }}"
        runbook_url: "https://runbooks.example.com/inference-latency"

    - alert: InferenceErrorRateHigh
      expr: |
        sum(rate(inference_requests_total{status="error"}[5m])) by (model) /
        sum(rate(inference_requests_total[5m])) by (model) > 0.01
      for: 5m
      labels:
        severity: critical
        team: ml-platform
      annotations:
        summary: "معدل الأخطاء > 1% للنموذج {{ $labels.model }}"

  - name: gpu-health
    rules:
    - alert: GPUMemoryExhausted
      expr: DCGM_FI_DEV_FB_USED / DCGM_FI_DEV_FB_FREE > 0.95
      for: 5m
      labels:
        severity: critical
      annotations:
        summary: "استخدام ذاكرة GPU {{ $labels.gpu }} > 95%"

    - alert: GPUTemperatureHigh
      expr: DCGM_FI_DEV_GPU_TEMP > 85
      for: 10m
      labels:
        severity: warning
      annotations:
        summary: "درجة حرارة GPU {{ $labels.gpu }} {{ $value }}°C"

    - alert: GPUXIDErrors
      expr: increase(DCGM_FI_DEV_XID_ERRORS[1h]) > 0
      for: 1m
      labels:
        severity: critical
      annotations:
        summary: "تم اكتشاف خطأ GPU XID على {{ $labels.gpu }}"

  - name: model-quality
    rules:
    - alert: ModelAccuracyDrift
      expr: |
        (model_accuracy - model_accuracy offset 1d) / model_accuracy offset 1d < -0.05
      for: 1h
      labels:
        severity: warning
        team: ml-engineering
      annotations:
        summary: "انخفضت دقة النموذج >5% مقارنة بالأمس"

    - alert: PredictionDistributionShift
      expr: |
        abs(
          avg_over_time(prediction_mean[1h]) -
          avg_over_time(prediction_mean[1h] offset 7d)
        ) / stddev_over_time(prediction_mean[7d]) > 3
      for: 30m
      labels:
        severity: warning
      annotations:
        summary: "تحول توزيع التنبؤات بشكل ملحوظ"

مُصدّر مقاييس ML مخصص

# مُصدّر مقاييس Python لخدمات ML
from prometheus_client import start_http_server, Gauge, Histogram, Counter, Summary
import time

# تعريف مقاييس خاصة بـ ML
MODEL_ACCURACY = Gauge(
    'model_accuracy',
    'دقة النموذج الحالية على مجموعة التحقق',
    ['model_name', 'model_version']
)

PREDICTION_LATENCY = Histogram(
    'prediction_latency_seconds',
    'الوقت المستغرق في معالجة التنبؤ',
    ['model_name', 'batch_size'],
    buckets=[.001, .005, .01, .025, .05, .1, .25, .5, 1, 2.5, 5, 10]
)

FEATURE_DRIFT = Gauge(
    'feature_drift_score',
    'درجة انحراف الميزات (PSI/KL divergence)',
    ['model_name', 'feature_name']
)

PREDICTION_DISTRIBUTION = Summary(
    'prediction_values',
    'توزيع قيم التنبؤ',
    ['model_name', 'class_label']
)

CACHE_HIT_RATIO = Gauge(
    'model_cache_hit_ratio',
    'نسبة التنبؤات المقدمة من الذاكرة المؤقتة',
    ['model_name']
)

# تصدير المقاييس على المنفذ 8000
if __name__ == '__main__':
    start_http_server(8000)
    while True:
        # تحديث المقاييس من نظام ML الخاص بك
        MODEL_ACCURACY.labels(model_name='fraud_detector', model_version='v2').set(0.956)
        time.sleep(30)

تكوين Alertmanager

apiVersion: v1
kind: Secret
metadata:
  name: alertmanager-config
  namespace: monitoring
stringData:
  alertmanager.yaml: |
    global:
      resolve_timeout: 5m
      slack_api_url: 'https://hooks.slack.com/services/xxx'

    route:
      group_by: ['alertname', 'severity', 'model']
      group_wait: 30s
      group_interval: 5m
      repeat_interval: 4h
      receiver: 'default'
      routes:
      - match:
          severity: critical
        receiver: 'pagerduty-ml'
        continue: true
      - match:
          team: ml-platform
        receiver: 'slack-ml-platform'
      - match:
          team: ml-engineering
        receiver: 'slack-ml-engineering'

    receivers:
    - name: 'default'
      slack_configs:
      - channel: '#ml-alerts'
        send_resolved: true

    - name: 'pagerduty-ml'
      pagerduty_configs:
      - service_key: '<pagerduty-key>'
        severity: '{{ .CommonLabels.severity }}'
        description: '{{ .CommonAnnotations.summary }}'

    - name: 'slack-ml-platform'
      slack_configs:
      - channel: '#ml-platform-alerts'
        title: '{{ .CommonLabels.alertname }}'
        text: '{{ range .Alerts }}{{ .Annotations.summary }}{{ end }}'

    - name: 'slack-ml-engineering'
      slack_configs:
      - channel: '#ml-engineering-alerts'

الدرس التالي: تحسين التكلفة لأعباء عمل GPU. :::