اے آئی سسٹمز کیسے بنائیں جو جانتے ہوں کہ جب وہ نہیں جانتے ہیں: ایک عملی رہنما

بڑے لینگویج ماڈلز (LLMs) نے ہمارے اندرونی کاروباری ایپلی کیشنز بنانے کے طریقے کو بنیادی طور پر تبدیل کر دیا ہے۔ یہ ڈویلپرز کو ذہین سافٹ ویئر بنانے کی اجازت دیتا ہے جو پیچیدہ انٹرپرائز ڈیٹا کو مربوط کر سکتا ہے، اندرونی سوالات کا جواب دے سکتا ہے، اور دہرائے جانے والے ورک فلو کو خودکار کر سکتا ہے۔

تاہم، LLM ایپلیکیشن کو مقامی پروٹو ٹائپ سے پروڈکشن انٹرپرائز سسٹم میں منتقل کرنے سے قابل اعتمادی کے اہم مسائل سامنے آ سکتے ہیں، بشمول: حد سے زیادہ اعتماد.

معیاری زبان کے ماڈلز کو اعدادوشمار کے لحاظ سے سب سے زیادہ امکان اگلا ٹوکن بنانے کے لیے بہتر بنایا گیا ہے، بجائے اس کے کہ ان کی اپنی بنیادی یقین کا اندازہ لگایا جائے۔ جب مبہم اشارے، نامکمل تلاش کے سیاق و سباق، یا ڈومین سے باہر کناروں کے معاملات کا سامنا کرنا پڑتا ہے، تو بے دفاع ماڈل صارف کو غیر یقینی صورتحال کا کوئی اشارہ دیے بغیر اعتماد کے ساتھ قابل فہم آواز والے جھوٹ، فریب خوردہ حقائق پیش کرتا ہے۔

مشن کے لیے اہم انٹرپرائز ماحول میں، AI ایپلیکیشنز کا آنکھیں بند کرکے اندازہ لگانا سنگین کاروباری خطرات کا باعث بنتا ہے۔ اس گائیڈ میں، آپ سیکھیں گے کہ پروڈکشن گریڈ غیر یقینی صورتحال کا فریم ورک کیسے بنایا جائے۔ ہم آپ کو علم کے خلاء کا پتہ لگانے، ممکنہ اعتماد کی پیمائش کرنے، اور انسانی آپریٹرز کو کم یقینی کی درخواستوں کو خوبصورتی سے روٹ کرنے یا محفوظ فال بیک جوابات فراہم کرنے کے لیے ڈیزائن کیے گئے فن تعمیر کے ذریعے چلائیں گے۔

جس کا ہم احاطہ کریں گے۔

شرائط اور ترجیحات

اس عملی گائیڈ کی پیروی کرنے اور نفاذ کوڈ کو مقامی طور پر چلانے کے لیے، آپ کو درج ذیل بنیادی ضروریات کو پورا کرنا ہوگا:

• صاف، ساختہ ازگر کوڈ لکھنے کی صلاحیت

• سرچ اگمینٹڈ جنریشن (RAG) کے تصورات اور ویکٹر ایمبیڈنگز کی بنیادی تفہیم۔

• آپ کے کمپیوٹر پر Python 3.9 یا اس سے زیادہ انسٹال ہے۔

• ایک مربوط ترقیاتی ماحول جیسے بصری اسٹوڈیو کوڈ۔

پیکیج انسٹال کریں

ایک ٹرمینل کھولیں اور مطلوبہ بیرونی انحصار کو انسٹال کرنے کے لیے درج ذیل کمانڈز چلائیں۔

pip install openai sentence-transformers numpy python-dotenv

مقامی ڈائریکٹری ڈھانچہ

عمل آوری کی تولیدی صلاحیت کو برقرار رکھنے کے لیے، اپنے کام کی جگہ کو منظم اور صاف رکھیں۔

uncertainty-engine/

│

├── .env

├── README.md

└── app.py

ماحولیات کی ترتیب

رسائی کی اسناد اور حد کی ترتیب کو ذخیرہ کرنے کے لیے، اپنے پروجیکٹ کی روٹ ڈائرکٹری میں ایک .env فائل بنائیں۔

کوڈ کا ٹکڑا

OPENAI_API_KEY=your_actual_api_key_here
ENVIRONMENT=development
CONFIDENCE_THRESHOLD=0.75

چیلنج: حد سے زیادہ اعتماد کی کمزوریوں کو دور کرنا

ایک معیاری LLM میں "مجھے نہیں معلوم” کا اعلان کرنے کا کوئی اندرونی طریقہ کار نہیں ہے۔ جب کسی RAG ایپلیکیشن کو کسی گمشدہ دستاویز کا سامنا ہوتا ہے یا کوئی حد سے باہر کوئی سوال موصول ہوتا ہے، تو بنیادی ماڈل گمشدہ ڈیٹا کو ٹیکسٹ مکمل کرنے والی پہیلی کے طور پر پیش کرتا ہے جسے ہر قیمت پر حل کرنا ضروری ہے۔

شکل 1: ایک معیاری LLM پائپ لائن کی کمزوری کا فن تعمیر جس میں مبہم/ حد سے باہر کی درخواستیں، بے ہودہ فوری عمل درآمد، اور پراعتماد وہم دکھایا گیا ہے۔

سسٹم پرامپٹس پر بھروسہ کریں جیسے: "جواب صرف اس صورت میں دیں جب آپ کو 100% یقین ہو” ٹوکن کی ترتیب کی پیشن گوئی کرتے وقت یہ مؤثر نہیں ہوتا ہے کیونکہ ماڈل آسانی سے سسٹم پرامپٹ رکاوٹوں کو نظرانداز کر دیتا ہے۔ انٹرپرائز سسٹمز کو ڈیٹرمنسٹک کوڈ باؤنڈریز کی ضرورت ہوتی ہے جو LLM کے خام آؤٹ پٹ سے آزاد سیمنٹک مطابقت، دستاویز کی دوری، اور ٹوکن امکان کا جائزہ لیتے ہیں۔

غیر یقینی صورتحال کا اندازہ لگانے کے لیے انٹرپرائز ریکوئسٹ لائف سائیکل کو سمجھنا

غیر تصحیح شدہ آؤٹ پٹ کو روکنے کے لیے، ہم درخواستوں کو مسدود کرنے کے لیے ڈیٹرمنسٹک ریکوئسٹ لائف سائیکل کا استعمال کرتے ہیں۔ حتمی آؤٹ پٹ آخری صارف کو بھیجے جانے سے پہلے ہر ٹرانزیکشن تصدیق کی تین پرتوں سے گزرتی ہے۔

تصویر 2: فال بیک ایسکلیشن کے ساتھ انٹرپرائز ایل ایل ایم آرکیٹیکچر کو محفوظ کریں، جس میں صارف کی درخواستوں کو ان پٹ باؤنڈری کی توثیق، تلاش کے معیار کی تشخیص، اور آؤٹ پٹ کی غیر یقینی صورتحال کی جانچ پڑتال دکھا رہا ہو

LLM سے حفاظتی فیصلوں کو الگ کر کے، کوڈ فیصلہ کی حد کے طور پر کام کرتا ہے اور زبان کا ماڈل سختی سے تجزیہ کرنے والے انجن کے طور پر کام کرتا ہے۔

مرحلہ 1: پرت 1 کو لاگو کریں – ان پٹ کے ارادے اور حدود کا پتہ لگائیں۔

دفاع کی پہلی پرت اس بات کا تعین کرتی ہے کہ آیا سرچ پائپ لائن یا ماڈل API کو کال کرنے سے پہلے آنے والا سوال سسٹم کے درست ڈومین پیرامیٹرز کے اندر آتا ہے۔

import numpy as np
from sentence_transformers import SentenceTransformer

class BoundaryDetector:
    def __init__(self, target_domains: list, similarity_threshold: float = 0.45):
        self.encoder = SentenceTransformer("all-MiniLM-L6-v2")
        self.domain_embeddings = self.encoder.encode(target_domains)
        self.threshold = similarity_threshold

    def verify_domain_relevance(self, query: str) -> dict:
        query_vector = self.encoder.encode([query])
        
        # Calculate cosine similarity against domain boundaries
        similarities = np.dot(self.domain_embeddings, query_vector.T) / (
            np.linalg.norm(self.domain_embeddings, axis=1, keepdims=True) * np.linalg.norm(query_vector)
        )
        max_similarity = float(np.max(similarities))
        
        if max_similarity < self.threshold:
            return {
                "is_valid": False,
                "score": round(max_similarity, 4),
                "reason": "Query falls outside operational domain boundaries."
            }
            
        return {
            "is_valid": True,
            "score": round(max_similarity, 4),
            "reason": "Query verified within target operational scope."
        }

if __name__ == "__main__":
    approved_topics = [
        "company VPN configuration",
        "employee payroll schedules",
        "internal IT software deployment"
    ]
    detector = BoundaryDetector(target_domains=approved_topics)
    out_of_scope_query = "What is the optimal baking temperature for sourdough bread?"
    result = detector.verify_domain_relevance(out_of_scope_query)
    print(f"Domain Validation Result: {result}")

یہ ماڈیول منظور شدہ آپریشنل موضوعات کو سیمنٹک ویکٹر ایمبیڈنگز میں تبدیل کرتا ہے۔ جب کوئی صارف استفسار جمع کرتا ہے، تو اسکرپٹ ان پٹ کو سرایت کرنے والے ویکٹر میں تبدیل کرتا ہے اور کوزائن کی مماثلت کو متعین ڈومین کی حدود میں شمار کرتا ہے۔ اگر الائنمنٹ سکور حد سے نیچے ہے، تو درخواست کو فوری طور پر روک دیا جاتا ہے، API کمپیوٹ کے اخراجات کو بچاتے ہوئے اور ڈومین سے باہر کے تخمینے کو روکتے ہیں۔

مرحلہ 2: پرت 2 کو لاگو کریں - سیمنٹک فاصلہ اور تلاش کوالٹی اسکورنگ

آر اے جی پلیٹ فارمز معمول کے مطابق فریب کا باعث بنتے ہیں کیونکہ ویکٹر سرچ انجن متعلقہ سیاق و سباق کے غائب ہونے پر کم اسکور کرنے والے دستاویزی میچ واپس کرتے ہیں۔ تلاش کے معیار کا تعین کرنے کے لیے، ہم استفسار اور بازیافت شدہ سیاق و سباق کے ٹکڑوں کے درمیان معنوی فاصلے کی پیمائش کرتے ہیں۔

class RetrievalQualityScorer:
    def __init__(self, minimum_relevance: float = 0.60):
        self.encoder = SentenceTransformer("all-MiniLM-L6-v2")
        self.min_relevance = minimum_relevance

    def evaluate_retrieved_context(self, user_query: str, retrieved_chunks: list) -> tuple:
        if not retrieved_chunks:
            return False, 0.0

        query_vec = self.encoder.encode(user_query)
        chunk_vecs = self.encoder.encode(retrieved_chunks)

        # Compute cosine similarity across retrieved chunks
        scores = np.dot(chunk_vecs, query_vec) / (
            np.linalg.norm(chunk_vecs, axis=1) * np.linalg.norm(query_vec)
        )
        top_score = float(np.max(scores))

        is_sufficient = top_score >= self.min_relevance
        return is_sufficient, round(top_score, 4)

if __name__ == "__main__":
    scorer = RetrievalQualityScorer()
    sample_query = "How do I configure mutual TLS for gRPC services?"
    sample_context = [
        "Standard deployment uses isolated network clusters with automated releases."
    ]
    has_context, score = scorer.evaluate_retrieved_context(sample_query, sample_context)
    print(f"Context Sufficient: {has_context} | Top Match Score: {score}")

اس مرحلے میں، انفرادی مماثلت کے اسکورز کو صارف کے سوالات کے ساتھ ساتھ بازیافت شدہ دستاویز کے ٹکڑوں کو ویکٹر ایمبیڈنگ میں تبدیل کرکے شمار کیا جاتا ہے۔ اگر سب سے زیادہ اسکور کرنے والا حصہ کم از کم مطابقت کی حد سے تجاوز نہیں کرتا ہے، تو ماڈیول سیاق و سباق کو ناکافی کے طور پر جھنڈا لگاتا ہے، جس سے سسٹم کو ماڈل کو غیر متعلقہ متن بھیجنے سے روکتا ہے۔

مرحلہ 3: پرت 3 کا نفاذ - امکانی لاگٹ تجزیہ اور آؤٹ پٹ تصدیق

حتمی پرت ماڈل API سے واپس آنے والے ٹوکن جنریشن امکان (لاگ امکان) کی جانچ کرتی ہے۔ اگر LLM کو جواب کا یقین نہیں ہے، تو ٹوکن ڈسٹری بیوشن اینٹروپی بڑھ جاتی ہے، جو براہ راست API پے لوڈ میں غیر یقینی صورتحال کو ظاہر کرتی ہے۔

import math

class OutputLogprobValidator:
    def __init__(self, logprob_threshold: float = -0.35):
        self.threshold = logprob_threshold

    def evaluate_token_certainty(self, token_logprobs: list) -> dict:
        if not token_logprobs:
            return {"is_confident": False, "avg_logprob": -1.0, "perplexity": 999.0}

        avg_logprob = sum(token_logprobs) / len(token_logprobs)
        perplexity = math.exp(-avg_logprob)
        is_confident = avg_logprob >= self.threshold

        return {
            "is_confident": is_confident,
            "avg_logprob": round(avg_logprob, 4),
            "perplexity": round(perplexity, 4)
        }

if __name__ == "__main__":
    validator = OutputLogprobValidator()
    # Simulated logprob arrays from an API output
    unconfident_logprobs = [-0.12, -0.85, -1.20, -0.45, -0.95]
    result = validator.evaluate_token_certainty(unconfident_logprobs)
    print(f"Generation Certainty Assessment: {result}")

یہ کلاس اوسط لاگ پروب میٹرک کی گنتی کرنے کے لیے، ٹیکسٹ کنفیوژن کے ساتھ، پیدا کردہ ٹوکنز کے خام لاگ امکانات پر کارروائی کرتی ہے۔ اس قدر کا ایک کیلیبریٹڈ تھریشولڈ سے موازنہ کرکے، ایپلیکیشن معروضی طور پر اس بات کا تعین کرتی ہے کہ آیا ماڈل ٹیکسٹ جنریشن کے دوران غیر یقینی تھا۔

توثیق کی تہوں کو ایک ہی پائپ لائن میں ضم کریں۔

اب ہم ان تین الگ تھلگ توثیق ماڈیولز کو ایک سنگل آرکیسٹریشن انجن میں یکجا کرتے ہیں جو انٹرپرائز کی درخواست پائپ لائن کے آخر سے آخر تک انتظام کرتا ہے۔

class EnterpriseUncertaintyEngine:
    def __init__(self, approved_domains: list):
        self.boundary_layer = BoundaryDetector(target_domains=approved_domains)
        self.retrieval_layer = RetrievalQualityScorer()
        self.output_layer = OutputLogprobValidator()

    def process_request(self, user_query: str, retrieved_docs: list) -> str:
        print(f"n--- Processing Query: '{user_query}' ---")

        # Check 1: Input Boundary Evaluation
        boundary_result = self.boundary_layer.verify_domain_relevance(user_query)
        if not boundary_result["is_valid"]:
            return f"Request Rejected: {boundary_result['reason']}"
        print("[Pass] Input verified within operational domain.")

        # Check 2: Retrieval Context Quality
        valid_context, ret_score = self.retrieval_layer.evaluate_retrieved_context(user_query, retrieved_docs)
        if not valid_context:
            return f"Escalated: Insufficient ground-truth data retrieved (Score: {ret_score}). Routing to support team."
        print(f"[Pass] Context quality validated (Score: {ret_score}).")

        # Step 3: Simulated LLM Generation & Logprob Verification
        # In production, replace dummy logprobs with actual API responses
        simulated_logprobs = [-0.08, -0.05, -0.12, -0.04]
        certainty = self.output_layer.evaluate_token_certainty(simulated_logprobs)

        if not certainty["is_confident"]:
            return "Fallback Active: Generated output exhibited low token certainty."
        print(f"[Pass] Output probability verified (Avg Logprob: {certainty['avg_logprob']}).")

        return "Response Generated: Navigate to portal.company.internal to reset your VPN credentials."

if __name__ == "__main__":
    domains = ["VPN credentials", "software provisioning", "network settings"]
    engine = EnterpriseUncertaintyEngine(approved_domains=domains)

    # Test Case: Query with valid retrieved context
    context_data = ["To update VPN credentials, access portal.company.internal."]
    final_output = engine.process_request("How do I update my VPN password?", context_data)
    print(f"System Output: {final_output}")

یہ آرکیسٹریشن کلاس ان پٹ کی توثیق، تلاش کے اسکورنگ، اور لاگ پروب کو ایک واحد عمل کاری کے کام کے فلو میں یکجا کرتی ہے۔ یہ ترتیب وار ہر ایک تصدیقی چوکی کے ذریعے درخواستوں کو روٹ کرتا ہے، ڈومین سے باہر کے سوالات کو مسدود کرتا ہے، غیر بازیافت شدہ سیاق و سباق کو انسانی مدد تک بڑھاتا ہے، اور کم امکان والی نسلوں کو فلٹر کرتا ہے۔

غیر یقینی صورتحال سینسنگ سسٹم کو نافذ کرنے کے ذریعے آپریشنل بصیرت

ایک LLM فن تعمیر کو ڈیزائن کرنا جو غیر یقینی صورتحال کو تسلیم کرتا ہے کئی عملی تعیناتی اسباق فراہم کرتا ہے:

• اعتماد کی جانچ کو سسٹم کے اشارے سے الگ کرتا ہے۔ ماڈل سے مت پوچھو۔ "کیا آپ کو اس جواب پر یقین ہے؟" فوری سیاق و سباق کے اندر۔ ماڈلز اکثر غلط بیانیوں میں خود سے زیادہ اعتماد پیدا کرتے ہیں۔ اس کے بجائے، حسابی میٹرکس جیسے لاگ پروبس اور ویکٹر کے فاصلے استعمال کریں۔

• ایک واضح اضافہ ورک فلو قائم کریں۔ "میں نہیں جانتا" کو جان بوجھ کر آپریشنل نتیجہ سمجھیں، کوڈ کی غلطی نہیں۔ کم اعتماد والے سوالات کو براہ راست داخلی ٹکٹنگ قطاروں یا ہیومن-ان-دی-لوپ (HITL) جائزہ چینلز پر بھیجیں۔

• نالج گیپس کے لیے سرچ میٹرکس کی نگرانی کریں۔ تلاش کے اسکورنگ میں ناکام ہونے والی درخواستوں کو ٹریک کریں اور جمع کریں۔ کم مطابقت والے اشارے کمپنی کے دستاویزات کو نمایاں کرتے ہیں جو غائب، پرانے، یا خراب انداز میں ترتیب دی گئی ہیں۔

• ہم مماثلت کی حد کو مسلسل ایڈجسٹ کرتے ہیں۔ شامل فاصلے کے میٹرکس دستاویز کی لمبائی اور الفاظ کے انتخاب کے لیے حساس ہیں۔ زیادہ سے زیادہ درستگی کے لیے مطابقت کی حدود کو ایڈجسٹ کرنے کے لیے نمونہ سسٹم لاگز کا وقتاً فوقتاً جائزہ لیا جاتا ہے۔

نتیجہ

پروڈکشن گریڈ AI ایپلی کیشنز کی تعمیر کے لیے سادہ پرامپٹ انجینئرنگ سے سیکیورٹی فرسٹ انجینئرنگ مائنڈ سیٹ میں تبدیلی کی ضرورت ہوتی ہے۔ بڑے پیمانے پر زبان کے ماڈل طاقتور قدرتی زبان کی صلاحیتیں فراہم کرتے ہیں، لیکن وہ فطری طور پر غیر منقولہ ٹولز ہیں جو سچائی یا یقین کی پیمائش نہیں کرسکتے ہیں۔

غیر متوقع زبان کے ماڈلز کو قابل اعتماد انٹرپرائز پلیٹ فارمز میں تبدیل کریں ایسے ماڈلز کو ڈیٹرمنسٹک کوڈ باؤنڈریز کے ساتھ لپیٹ کر جو ان پٹ کے ارادے، دستاویز کی مطابقت اور جنریشن کے امکانات کا جائزہ لیتے ہیں۔ دوسرے لفظوں میں، یہ ایک ایسا پلیٹ فارم ہے جو مفید جوابات فراہم کرتا ہے جب آپ پراعتماد ہوتے ہیں اور یہ جانتے ہیں کہ "مجھے نہیں معلوم" کب کہنا ہے۔

پڑھنے کے لیے آپ کا شکریہ۔

ہم امید کرتے ہیں کہ یہ گائیڈ انٹرپرائز ماحول میں غیر یقینی صورتحال سے آگاہ AI ایپلیکیشنز کی تعمیر کے لیے ایک واضح فریم ورک فراہم کرتا ہے۔

اگر آپ AI انجینئرنگ، ایجنٹ آرکیٹیکچر، LLM آپریشنز، یا AI گورننس پر بات کرنا چاہتے ہیں، تو براہ کرم مجھ سے بلا جھجھک رابطہ کریں۔