معايير ومقارنة المصنفات

اختيار مصنف السلامة المناسب يتطلب فهم مقايضات الأداء في العالم الحقيقي. يوفر هذا الدرس مقارنات معيارية لتوجيه قرارات الإنتاج.

نظرة عامة على المعايير

المصنف	درجة F1	الدقة	الاستدعاء	التأخير (GPU)	الذاكرة
LlamaGuard 3 1B	0.81	0.79	0.83	50-100 مللي ثانية	2GB
LlamaGuard 3 8B	0.87	0.86	0.88	200-400 مللي ثانية	16GB
ShieldGemma 2B	0.81	0.82	0.80	30-60 مللي ثانية	4GB
ShieldGemma 9B	0.84	0.85	0.83	80-150 مللي ثانية	18GB
ShieldGemma 27B	0.88	0.89	0.87	200-400 مللي ثانية	54GB
toxic-bert	0.85	0.83	0.87	15-30 مللي ثانية	0.4GB
Detoxify (original)	0.89	0.87	0.91	100-200 مللي ثانية	1.3GB

المصدر: المعايير مستمدة من إصدارات النماذج الرسمية وتقييمات المجتمع (2024-2025).

الأداء حسب فئة الضرر

تتفوق المصنفات المختلفة في أنواع ضرر مختلفة:

CATEGORY_PERFORMANCE = {
    "hate_speech": {
        "best": "ShieldGemma 27B",
        "runner_up": "LlamaGuard 3 8B",
        "notes": "ShieldGemma مدرب على بيانات خطاب كراهية أوسع"
    },
    "violence": {
        "best": "LlamaGuard 3 8B",
        "runner_up": "ShieldGemma 27B",
        "notes": "LlamaGuard لديه فئات عنف دقيقة"
    },
    "sexual_content": {
        "best": "LlamaGuard 3 8B",
        "runner_up": "ShieldGemma 9B",
        "notes": "LlamaGuard يميز بين الصريح والموحي"
    },
    "self_harm": {
        "best": "Detoxify",
        "runner_up": "LlamaGuard 3 8B",
        "notes": "Detoxify مدرب على بيانات منع الانتحار"
    },
    "prompt_injection": {
        "best": "مصنف مخصص",
        "runner_up": "LlamaGuard 3 8B",
        "notes": "المصنفات العامة تفوت الهجمات المشفرة"
    }
}

مقايضة التأخير مقابل الدقة

import matplotlib.pyplot as plt

def plot_tradeoff():
    """تصور مقايضة التأخير مقابل الدقة."""
    classifiers = [
        ("toxic-bert", 22, 0.85),
        ("ShieldGemma 2B", 45, 0.81),
        ("LlamaGuard 3 1B", 75, 0.81),
        ("ShieldGemma 9B", 115, 0.84),
        ("Detoxify", 150, 0.89),
        ("LlamaGuard 3 8B", 300, 0.87),
        ("ShieldGemma 27B", 300, 0.88),
    ]

    names, latencies, accuracies = zip(*classifiers)

    plt.figure(figsize=(10, 6))
    plt.scatter(latencies, accuracies, s=100)

    for name, lat, acc in classifiers:
        plt.annotate(name, (lat, acc), textcoords="offset points",
                     xytext=(5, 5), fontsize=9)

    plt.xlabel("التأخير (مللي ثانية)")
    plt.ylabel("درجة F1")
    plt.title("مقايضات مصنفات السلامة")
    plt.grid(True, alpha=0.3)

    # تمييز المنطقة المثلى
    plt.axhline(y=0.85, color='g', linestyle='--', alpha=0.5, label='دقة جيدة')
    plt.axvline(x=100, color='r', linestyle='--', alpha=0.5, label='عتبة السرعة')

    plt.legend()
    return plt

استراتيجية التصنيف المتدرج

بناءً على المعايير، نفذ نهجاً متدرجاً:

from enum import Enum
from dataclasses import dataclass
from typing import Optional
import time

class ClassifierTier(Enum):
    FAST = "fast"        # < 50 مللي ثانية
    BALANCED = "balanced" # 50-200 مللي ثانية
    THOROUGH = "thorough" # > 200 مللي ثانية

@dataclass
class TieredResult:
    decision: str
    confidence: float
    tier_used: ClassifierTier
    latency_ms: float
    escalated: bool = False

class TieredClassifier:
    """نظام تصنيف متدرج للإنتاج."""

    def __init__(self):
        # تحميل كسول لكفاءة الذاكرة
        self._fast = None
        self._balanced = None
        self._thorough = None

    @property
    def fast(self):
        if self._fast is None:
            from transformers import pipeline
            self._fast = pipeline(
                "text-classification",
                model="martin-ha/toxic-comment-model"
            )
        return self._fast

    @property
    def balanced(self):
        if self._balanced is None:
            self._balanced = ShieldGemmaClassifier(model_size="9b")
        return self._balanced

    @property
    def thorough(self):
        if self._thorough is None:
            self._thorough = LlamaGuard3Classifier(model_size="8B")
        return self._thorough

    def classify(
        self,
        content: str,
        confidence_threshold: float = 0.85
    ) -> TieredResult:
        """
        التصنيف مع تصعيد المستوى التلقائي.

        الاستراتيجية:
        1. المستوى السريع أولاً (toxic-bert)
        2. إذا كان غير مؤكد (0.15 < score < 0.85)، تصعيد للمتوازن
        3. إذا ظل غير مؤكد، تصعيد للشامل
        """
        start = time.time()

        # المستوى 1: سريع
        fast_result = self.fast(content)[0]
        fast_score = fast_result["score"]
        fast_label = fast_result["label"]

        # ثقة عالية - إرجاع فوري
        if fast_score > confidence_threshold:
            return TieredResult(
                decision="unsafe" if fast_label == "toxic" else "safe",
                confidence=fast_score,
                tier_used=ClassifierTier.FAST,
                latency_ms=(time.time() - start) * 1000
            )

        # ثقة منخفضة على آمن - أيضاً إرجاع
        if fast_label == "non-toxic" and fast_score > confidence_threshold:
            return TieredResult(
                decision="safe",
                confidence=fast_score,
                tier_used=ClassifierTier.FAST,
                latency_ms=(time.time() - start) * 1000
            )

        # المستوى 2: متوازن (ShieldGemma)
        balanced_result = self.balanced.classify_all(content)
        max_harmful = max(
            r["probability"] for r in balanced_result.values()
        )

        if max_harmful > confidence_threshold or max_harmful < (1 - confidence_threshold):
            return TieredResult(
                decision="unsafe" if max_harmful > 0.5 else "safe",
                confidence=max_harmful if max_harmful > 0.5 else 1 - max_harmful,
                tier_used=ClassifierTier.BALANCED,
                latency_ms=(time.time() - start) * 1000,
                escalated=True
            )

        # المستوى 3: شامل (LlamaGuard 8B)
        decision, categories = self.thorough.classify(content)

        return TieredResult(
            decision=decision,
            confidence=0.9,  # LlamaGuard لا يُرجع ثقة
            tier_used=ClassifierTier.THOROUGH,
            latency_ms=(time.time() - start) * 1000,
            escalated=True
        )

# الاستخدام
classifier = TieredClassifier()
result = classifier.classify("كيف أتعلم برمجة Python؟")
print(f"القرار: {result.decision}، المستوى: {result.tier_used.value}")

اختيار المصنف المناسب

السيناريو	المصنف الموصى به	السبب
API عالي الحجم	toxic-bert + LlamaGuard 1B	السرعة حاسمة، تصعيد غير المؤكد
قائمة الإشراف	LlamaGuard 3 8B	دقة للمراجعة البشرية
دردشة فورية	ShieldGemma 2B	تأخير منخفض، احتمالية جيدة
امتثال المؤسسات	LlamaGuard 3 8B	تسجيل فئات دقيق
الحافة/الجوال	ShieldGemma 2B	أصغر نموذج دقيق
أقصى دقة	ShieldGemma 27B	أفضل درجات معيارية

تحليل التكلفة

CLASSIFIER_COSTS = {
    # بافتراض تكاليف استضافة GPU
    "toxic-bert": {
        "gpu": "T4",
        "hourly_cost": 0.35,
        "throughput_per_hour": 120000,
        "cost_per_1k": 0.003
    },
    "LlamaGuard 3 1B": {
        "gpu": "T4",
        "hourly_cost": 0.35,
        "throughput_per_hour": 36000,
        "cost_per_1k": 0.01
    },
    "LlamaGuard 3 8B": {
        "gpu": "A10G",
        "hourly_cost": 1.00,
        "throughput_per_hour": 9000,
        "cost_per_1k": 0.11
    },
    "ShieldGemma 27B": {
        "gpu": "A100",
        "hourly_cost": 3.00,
        "throughput_per_hour": 9000,
        "cost_per_1k": 0.33
    }
}

def calculate_monthly_cost(
    daily_requests: int,
    classifier: str,
    escalation_rate: float = 0.15
) -> dict:
    """حساب تكاليف التصنيف الشهرية مع النهج المتدرج."""
    costs = CLASSIFIER_COSTS[classifier]
    monthly_requests = daily_requests * 30

    base_cost = (monthly_requests / 1000) * costs["cost_per_1k"]

    # إضافة تكاليف التصعيد إذا كان يستخدم النهج المتدرج
    if escalation_rate > 0:
        escalated = monthly_requests * escalation_rate
        escalation_cost = (escalated / 1000) * CLASSIFIER_COSTS["LlamaGuard 3 8B"]["cost_per_1k"]
        total = base_cost + escalation_cost
    else:
        total = base_cost

    return {
        "base_cost": base_cost,
        "escalation_cost": escalation_cost if escalation_rate > 0 else 0,
        "total_monthly": total
    }

رؤية إنتاجية: النهج المتدرج عادةً يقلل التكاليف بنسبة 60-70% مقارنة بتشغيل المصنف الأكثر دقة على كل طلب، مع الحفاظ على 95%+ من الدقة.

التالي: تخصيص تصنيفات السلامة لحالة استخدامك المحددة. :::