Add AICL example: 48_nlp_system.aicl

data/aicl/examples/48_nlp_system.aicl

@@ -0,0 +1,426 @@
+# AICL Example: NLP Processing System
+# Comprehensive natural language processing system covering tokenization, named entity recognition,
+# sentiment analysis, translation, summarization, and chatbot integration with multi-language support.
+
+Goal Build a production NLP processing system that provides comprehensive language understanding capabilities including tokenization, NER, sentiment analysis, translation, and summarization with chatbot integration, supporting 50+ languages with sub-200ms inference latency
+
+Constraint All NLP models must support at minimum 50 languages with consistent quality benchmarks
+Constraint PII detected in text must be redacted or flagged before storage or model processing
+Constraint Sentiment analysis must achieve F1 score above 0.85 on standard benchmarks
+Constraint Translation must maintain BLEU score above 0.4 for all supported language pairs
+Constraint Chatbot responses must pass safety guardrail checks before delivery to users
+
+Risk PII leakage through NLP pipeline logging or model memorization
+Recovery Implement PII detection as first pipeline stage; apply differential privacy to model training; sanitize all logs and intermediate representations
+
+Risk Model hallucination in summarization and chatbot responses
+Recovery Implement factual consistency checking against source text; apply constrained decoding; add confidence thresholds below which responses are flagged for review
+
+Risk Language detection failure leading to wrong model routing
+Recovery Use ensemble language detection with confidence calibration; fall back to character n-gram analysis; route ambiguous inputs to multilingual model variant
+
+Risk Adversarial text inputs designed to manipulate sentiment or NER results
+Recovery Implement input sanitization and adversarial example detection; apply model robustness training; log suspicious inputs for security review
+
+Risk Translation quality degradation for low-resource language pairs
+Recovery Prioritize high-quality multilingual models; implement back-translation quality estimation; fall back to pivot-language translation with quality warning
+
+Risk Chatbot generating harmful or biased content
+Recovery Deploy multi-layer safety classifiers; implement content policy filtering; maintain blocklist with regex and semantic matching; enable human-in-the-loop for edge cases
+
+Layer NLPCore
+    SubLayer: Tokenization
+    SubLayer: LanguageDetection
+    SubLayer: TextPreprocessing
+Layer NLU
+    SubLayer: NamedEntityRecognition
+    SubLayer: SentimentAnalysis
+    SubLayer: IntentClassification
+Layer NLG
+    SubLayer: Translation
+    SubLayer: Summarization
+    SubLayer: ResponseGeneration
+Layer Conversation
+    SubLayer: DialogueManager
+    SubLayer: ContextTracker
+    SubLayer: SafetyFilter
+
+Validation Tokenization must handle Unicode, emojis, and mixed-script text without errors
+Validation NER precision must exceed 0.90 on CoNLL benchmark for English
+Validation Sentiment F1 must exceed 0.85 on SST-2 benchmark
+Validation Translation BLEU must exceed 0.4 for all Tier-1 language pairs
+Validation Summarization ROUGE-L must exceed 0.40 on CNN/DailyMail benchmark
+Validation Chatbot safety filter must catch 99.5% of harmful content in red-team testing
+Validation Language detection accuracy must exceed 0.95 for all supported languages
+Validation Pipeline end-to-end latency must remain below 200ms p99
+
+# Level 2 - Entities
+
+Entity TextDocument
+    documentId: string
+    rawText: string
+    language: string
+    detectedLanguage: string
+    languageConfidence: float
+    tokenCount: integer
+    piiLocations: list
+    processedAt: datetime
+    sourceSystem: string
+    metadata: dict
+
+Entity TokenSequence
+    sequenceId: string
+    documentId: string
+    tokens: list
+    tokenOffsets: list
+    tokenTypes: list
+    posTags: list
+    dependencyParse: list
+    language: string
+    tokenizerVersion: string
+
+Entity NERAnnotation
+    annotationId: string
+    documentId: string
+    entities: list
+    entityTypes: list
+    confidenceScores: list
+    entityOffsets: list
+    linkedUris: list
+    modelVersion: string
+    processedAt: datetime
+
+Entity SentimentResult
+    resultId: string
+    documentId: string
+    overallSentiment: string
+    sentimentScore: float
+    confidence: float
+    aspectSentiments: dict
+    emotionVector: dict
+    modelVersion: string
+    processedAt: datetime
+
+Entity TranslationResult
+    translationId: string
+    sourceDocumentId: string
+    sourceLanguage: string
+    targetLanguage: string
+    translatedText: string
+    bleuScore: float
+    qualityEstimation: float
+    backTranslationScore: float
+    modelVersion: string
+    processedAt: datetime
+
+Entity ChatbotSession
+    sessionId: string
+    userId: string
+    conversationHistory: list
+    currentIntent: string
+    intentConfidence: float
+    contextVector: list
+    entityMemory: dict
+    sessionStartTime: datetime
+    lastActivityTime: datetime
+    safetyFlags: list
+
+# Level 3 - Behaviors
+
+Behavior TokenizeText
+    Input:
+        document: TextDocument
+        tokenizerConfig: dict
+    Output:
+        tokenSequence: TokenSequence
+    Action:
+        Detect language if not provided
+        Select appropriate tokenizer for detected language
+        Apply subword tokenization with byte-pair encoding
+        Compute token offsets mapping back to original text
+        Tag part-of-speech for each token
+        Generate dependency parse tree
+        Return token sequence with all annotations
+
+Behavior ExtractEntities
+    Input:
+        tokenSequence: TokenSequence
+        nerConfig: dict
+    Output:
+        nerAnnotation: NERAnnotation
+    Action:
+        Run transformer-based NER model on token sequence
+        Apply BIO tagging scheme for entity boundaries
+        Compute confidence scores for each entity span
+        Link entities to knowledge base URIs where possible
+        Cross-reference with PII detection for sensitive entities
+        Return complete NER annotation set
+
+Behavior AnalyzeSentiment
+    Input:
+        tokenSequence: TokenSequence
+        sentimentConfig: dict
+    Output:
+        sentimentResult: SentimentResult
+    Action:
+        Run sentiment classification model on token sequence
+        Compute overall polarity score and label
+        Extract aspect-level sentiments for key topics
+        Generate emotion vector across standard emotion categories
+        Calibrate confidence score using temperature scaling
+        Return comprehensive sentiment result
+
+Behavior TranslateText
+    Input:
+        document: TextDocument
+        targetLanguage: string
+        translationConfig: dict
+    Output:
+        translationResult: TranslationResult
+    Action:
+        Validate source and target language pair support
+        Run encoder-decoder translation model
+        Estimate translation quality using predictor model
+        Optionally run back-translation for quality verification
+        Select best translation from beam search candidates
+        Return translation with quality metrics
+
+Behavior SummarizeText
+    Input:
+        document: TextDocument
+        summarizationConfig: dict
+    Output:
+        summary: string
+        qualityMetrics: dict
+    Action:
+        Verify document length meets summarization threshold
+        Run abstractive summarization model with length constraints
+        Check factual consistency against source document
+        Compute ROUGE metrics against reference if available
+        Apply post-processing to ensure grammatical coherence
+        Return summary with quality assessment
+
+Behavior ProcessChatMessage
+    Input:
+        session: ChatbotSession
+        userMessage: string
+        chatConfig: dict
+    Output:
+        response: string
+        updatedSession: ChatbotSession
+        safetyReport: dict
+    Action:
+        Tokenize and preprocess user message
+        Classify user intent with confidence scoring
+        Extract relevant entities from message
+        Update conversation context and entity memory
+        Generate candidate responses using language model
+        Apply safety filtering and content policy checks
+        Select safest and most relevant response
+        Update session state and return response
+
+# Level 4 - Conditions
+
+Condition: PIIDetectedInInput
+    When PII entities are found in input text during tokenization
+    Then flag PII locations, apply redaction or pseudonymization based on policy, route sanitized text through remaining pipeline
+
+Condition: LanguageDetectionLowConfidence
+    When language detection confidence falls below 0.7
+    Then route to multilingual model variant; flag for manual review; log ambiguous language detection event
+
+Condition: HarmfulContentDetected
+    When safety classifier flags user input or generated response as harmful
+    Then block response delivery; substitute with safety template response; escalate to human moderator; log safety incident
+
+Condition: TranslationQualityBelowThreshold
+    When estimated translation BLEU score falls below 0.3
+    Then attempt pivot-language translation; append quality disclaimer to output; flag for human post-editing
+
+Condition: SummarizationFactualInconsistency
+    When factual consistency score between summary and source falls below 0.8
+    Then regenerate summary with stronger constraints; fall back to extractive summarization; flag low-consistency output
+
+# Level 5 - Events
+
+Event: DocumentReceived
+    On new text document submitted for processing
+    Action: initiate tokenization pipeline; log document metadata; check cache for previous results
+
+Event: PIIDetected
+    On PII entities identified during NER processing
+    Action: apply redaction policy; notify data governance system; update PII audit log
+
+Event: SafetyViolation
+    On harmful content detected by safety filter
+    Action: block response; alert moderation team; update safety metrics; log full context for review
+
+Event: TranslationComplete
+    On translation result produced with quality metrics
+    Action: cache translation for similar future requests; update quality tracking dashboard; emit metrics
+
+Event: ConversationTurnComplete
+    On chatbot response delivered to user
+    Action: update session state; log interaction for training; trigger satisfaction prediction; check session timeout
+
+# Level 6 - Concurrency
+
+Parallel:
+    Tokenization and language detection simultaneously
+    NER and sentiment analysis on same token sequence concurrently
+    Translation for multiple target languages in parallel
+    Safety filtering alongside response generation
+    Aspect sentiment extraction for different text segments
+    Multi-turn dialogue context retrieval with response generation
+
+# Level 7 - Optimization
+
+Optimize: NLP pipeline throughput and latency
+    Priority: Batch inference for offline processing; dynamic batching for real-time requests; model quantization to INT8 where quality impact below 0.5%
+
+Optimize: Model serving cost efficiency
+    Priority: Share transformer backbone across NER, sentiment, and intent tasks; use knowledge distillation for edge deployment; cache frequent patterns
+
+Optimize: Translation quality for high-traffic language pairs
+    Priority: Allocate larger models for Tier-1 language pairs; pre-compute common phrase translations; use adaptive beam width based on input complexity
+
+# Level 8 - Learning
+
+Learn: Domain-specific NER entity types
+    Goal: Improve entity recognition accuracy for specialized domains
+    Adapt: NER model fine-tuning with domain corpora
+    Based: Human-annotated feedback and active learning samples from domain experts
+
+Learn: Chatbot response quality from user feedback
+    Goal: Maximize user satisfaction and conversation completion rates
+    Adapt: Response ranking model and dialogue policy
+    Based: Explicit user feedback, implicit signals (rephrasing, abandonment), and conversation outcome
+
+Learn: Sentiment model calibration across languages
+    Goal: Achieve consistent sentiment scoring across all supported languages
+    Adapt: Per-language calibration parameters and model weights
+    Based: Cross-lingual sentiment benchmarks and human evaluation studies
+
+Learn: Safety classifier boundaries from red-team results
+    Goal: Maximize harmful content detection while minimizing false positives on benign content
+    Adapt: Safety classifier decision thresholds and policy rules
+    Based: Red-team attack results, user reports, and adversarial example datasets
+
+# Level 9 - Security
+
+Security:
+    Encrypt: All text documents and intermediate representations at rest using AES-256
+    Encrypt: API communication channels with TLS 1.3 and mutual authentication
+    Protect: PII entities with automatic detection and redaction before model processing
+    Protect: Chatbot conversation history with per-user encryption keys
+    Protect: Model weights and configuration with signed artifact verification
+    Encrypt: Translation cache entries with per-tenant encryption
+    Protect: Safety classifier rules and blocklists from unauthorized modification via signed config
+
+# Level 10 - Native
+
+Native: python
+{
+import re
+from typing import Dict, List, Optional, Tuple
+from dataclasses import dataclass, field
+from enum import Enum
+
+class SentimentLabel(Enum):
+    POSITIVE = "positive"
+    NEGATIVE = "negative"
+    NEUTRAL = "neutral"
+    MIXED = "mixed"
+
+class EntityType(Enum):
+    PERSON = "PERSON"
+    ORGANIZATION = "ORG"
+    LOCATION = "LOC"
+    DATE = "DATE"
+    EMAIL = "EMAIL"
+    PHONE = "PHONE"
+    CREDIT_CARD = "CREDIT_CARD"
+    SSN = "SSN"
+
+@dataclass
+class PIIDetector:
+    patterns: Dict[str, str] = field(default_factory=lambda: {
+        "EMAIL": r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b",
+        "PHONE": r"\b\d{3}[-.]?\d{3}[-.]?\d{4}\b",
+        "SSN": r"\b\d{3}-\d{2}-\d{4}\b",
+        "CREDIT_CARD": r"\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b",
+    })
+
+    def detect(self, text: str) -> List[Dict]:
+        findings = []
+        for entity_type, pattern in self.patterns.items():
+            for match in re.finditer(pattern, text):
+                findings.append({
+                    "entity_type": entity_type,
+                    "text": match.group(),
+                    "start": match.start(),
+                    "end": match.end(),
+                    "confidence": 0.95
+                })
+        return findings
+
+    def redact(self, text: str, findings: List[Dict]) -> str:
+        redacted = text
+        for finding in sorted(findings, key=lambda x: x["start"], reverse=True):
+            label = finding["entity_type"]
+            redacted = (
+                redacted[:finding["start"]] +
+                f"[REDACTED_{label}]" +
+                redacted[finding["end"]:]
+            )
+        return redacted
+
+@dataclass
+class SafetyFilter:
+    harm_threshold: float = 0.7
+    hate_threshold: float = 0.7
+    sexual_threshold: float = 0.7
+    violence_threshold: float = 0.7
+
+    def check_response(self, response: str, scores: Dict[str, float]) -> Dict:
+        violations = []
+        for category, threshold in [
+            ("harm", self.harm_threshold),
+            ("hate", self.hate_threshold),
+            ("sexual", self.sexual_threshold),
+            ("violence", self.violence_threshold),
+        ]:
+            score = scores.get(category, 0.0)
+            if score > threshold:
+                violations.append({
+                    "category": category,
+                    "score": score,
+                    "threshold": threshold
+                })
+
+        is_safe = len(violations) == 0
+        return {
+            "is_safe": is_safe,
+            "violations": violations,
+            "fallback_response": "I cannot provide that information. Could you rephrase your question?" if not is_safe else None
+        }
+
+@dataclass
+class DialogueManager:
+    max_context_turns: int = 10
+    intent_confidence_threshold: float = 0.6
+
+    def update_context(self, session_context: Dict, user_message: str,
+                       intent: str, entities: List[Dict]) -> Dict:
+        session_context["history"].append({
+            "role": "user",
+            "content": user_message,
+            "intent": intent,
+            "entities": entities
+        })
+        if len(session_context["history"]) > self.max_context_turns * 2:
+            session_context["history"] = session_context["history"][-(self.max_context_turns * 2):]
+        for entity in entities:
+            session_context["entity_memory"][entity["type"]] = entity["value"]
+        return session_context
+}