यह मेरे ब्लॉग से शुरू हुआ अनुवाद उपकरणकैश में केवल एक उपयोक्ता के लिए 5 कार्यों को रखा गया।
अधिकांश विकासकर्ताओं को उन पर काम करने के लिए अवरोधों के रूप में देखेंगे स्वयं-cleaning और स्वयं-विशेषकरण. यह उपयोगकर्ताओं की जरूरतों को बनाए रखा और भूल गया कि वे क्या नहीं करते थे था प्रणाली
मैं उस मूलभूत में बाहर निकाला सबसे अधिक स्पष्टसंकेन्द्रित समवर्तन
पैटर्न दिखा रहा है डीआईएसई, एलएलएम को कोड विकसित करता है, लेकिन इकाई परीक्षण और गुणवत्ता जाँचों पर निर्भर करता है क्या बचाता है। बोट खोज, हेरिस्टिक डिटेक्टर्स प्राप्ताङ्क अनुरोध करता है, लेकिन नीति थ्रेसहोल्ड अंतिम निर्णय को लागू करते हैं।
चार प्रणालियां
एक अवरोध अस्पष्टता को एक बाध्य विकल्प में परिवर्तित करता है संसाधन समय चिन्तनात्मक (evidenceM SK1 invariants). Same roleMSC3 enforce selection and prevent unarned certainty .
flowchart LR
subgraph Constraint["The Constraint (Primitive)"]
C1[Constrained Size]
C2[Sliding Expiration]
end
subgraph Emergence["Emergent Behavior"]
E1[Selective Forgetting]
E2[Focus on Relevance]
E3[Self-Optimization]
end
C1 --> E1
C2 --> E1
E1 --> E2
E2 --> E3
style Constraint stroke:#ef4444,stroke-width:2px
style Emergence stroke:#22c55e,stroke-width:2px
यह मुख्य अंतर्दृष्टि है अर्थ-बुद्धि श्रृंखला और डायरेक्टेड सिंथेटिक एवोल्यूशन:
प्रतिबंध don't सीमा बुद्धिमत्ता उपयोगी व्यवहार बनाना उन प्रणालियों में जो अन्यथा drift
दबाव के अधीन LRU कैश. संगणित तथ्यों से प्रतिबंधित LLM. नीति थ्रेसहोल्ड्स द्वारा प्रतिबंधित हेरिस्टिक मॉडलM SK2 प्रत्येक प्रतिबंध प्रणाली को निर्णय लेने के लिए बाध्य करता है।
| प्रणाली | अवरोध (प्रारंभिक |--------|----------------------|-------------------| LRU कैश | आकार सीमा LLM सारांशकर्ता | स्रोत टुकड़े को उद्धरण करना चाहिए | | | क्या |' | असर्थित दावे को भ्रमित नहीं कर सकते | बोट डिटेक्टर छवि कैप्सनर
एक ही पैटर्न
TL;DR: संभावनात्मक मॉडलों को छोड़ें प्रस्तावित करना; निर्णायक प्रणालियों को छोड़ें निर्णय लेनाआप सत्यापित तथ्यों का संगणन कर सकते हैं।
| इरादा वास्तविक गारंटी वाली प्रणालियों में संभाव्यात्मक घटकों का सुरक्षित प्रयोग करें | ||||||||||||||||||||||||
| बल उच्च | ||||||||||||||||||||||||
| समाधान | सबस्ट्रैट | ( | तथ्य | ) | МSK3 | प्रस्तावक | 4 | अनिश्चितता | 5 | 6 | कंट्रानर | 7 | वैधीकरण | 8 | पुनः लेखन | 9 | बजट | 10 | 11 | उत्पादन | 12 | गिरावट | 13 | |
| परिणाम अधिक इंजीनियरिंग अग्रभूमि |
क्या आप प्राप्त कर रहे हैं
यह कितना खर्च करता है
यहाँ प्रतिबंधित का अर्थ है घेरे हुए: कठिन सीमाओं को मशीनरी द्वारा प्रवर्तित किया जाता है बजाय प्रांप्टों के माध्यम से समझौता किए जाते हैं।
बहुत भिन्न डोमेनों में सिस्टम निर्माण करने के बाद (document summarization, image analysisM SK2 bot detectionMSC3 data querying ), यह वास्तुकला उभरती रही है
flowchart TB
subgraph Input
I[Input Data]
end
subgraph Truth["Deterministic Substrate (Truth Layer)"]
T1[Compute Facts]
T2[Extract Evidence]
T3[Calculate Metrics]
end
subgraph Fuzzy["Fuzzy Proposer (Creativity Layer)"]
F1[Generate Proposals]
F2[Score/Rank]
F3[Synthesize Output]
end
subgraph Constrain["Constrainer (Contract Layer)"]
B1{Acceptable?}
B2[Rewrite/Hedge]
B3[Enforce Limits]
end
subgraph Output
O[Constrained Result]
D[Degraded Fallback]
end
I --> T1 --> T2 --> T3
T3 --> F1 --> F2 --> F3
F3 --> B1
B1 -->|"Full"| B3 --> O
B1 -->|"Partial"| B2 --> B3
B1 -->|"None"| D
T3 -.->|"Evidence"| B1
style Truth stroke:#22c55e,stroke-width:3px
style Fuzzy stroke:#f59e0b,stroke-width:3px
style Constrain stroke:#ef4444,stroke-width:3px
मुख्य अंतर्दृष्टि probabilistic अवयवों को प्रस्तावित करना चाहिए, लेकिन कभी भी उन्हें निर्णय नहींइनका उपयोग उस के लिए करें जो वे कर रहे हैं
इस पैटर्न को शक्तिशाली बनाता है इसकी लचीलाता
संरचना एक ही बनी रहती है
प्रतिबंधों के बिना संभाव्यतावादी प्रणालियां ऐसे तरीके से विफल हो जाती हैं जिनका पता लगाने में कठिनाई होती है और रोकने में असंभव होता है
flowchart LR
subgraph Unconstrained["❌ Unconstrained System"]
U1[Input] --> U2[LLM/Model]
U2 --> U3[Output]
end
subgraph Constrained["✓ Constrained System"]
B1[Input] --> B2[Compute Facts]
B2 --> B3[LLM/Model]
B3 --> B4{Validate}
B4 -->|Pass| B5[Output]
B4 -->|Fail| B6[Fallback]
end
style Unconstrained stroke:#ef4444,stroke-width:2px
style Constrained stroke:#22c55e,stroke-width:2px
असीमित विफल मोड
स्वाभाविकता यह है कि अधिक प्रेरक जोड़ें।
पैटर्न में क्रिस्टल हो गया परिचालन नियम जो संकीर्ण अस्पष्टता को कोडित करता है (selectedM SK1
कमांड |-------------|------------------------------| | एलएलएम को राज्य का स्वामित्व नहीं होगा राज्य substrate में निवास करता है | LLM side-effects के एकमात्र कारण नहीं होंगे | कंस्ट्रेनर कमिट करता है ; एलएलएम सिफारिश करता है | IV. LLMs का प्रयोग करें जहाँ संभाव्यता स्वीकार्य है वर्गीकरण | V. कभी भी LLM से डेरिवेबल बूलियन तय करने के लिए पूछें नहीं | यदि आप इसे संगणित कर सकते हैं तो यह संगणन करें | VIII. सलाहकार को एलएलएम को डेमोट करें प्रस्तावक
प्रतिफल आप नहीं need frontier मॉडलवस्तु उपकरण पर एक छोटा स्थानीय LLM बल गुणक बन जाता है जब यह वर्गीकरण और hypothesis generation करता है. , डाटाबेस या राज्य मशीन होने का बहाना नहीं करता.
इस नमूने में गहरी जड़ें हैं नियंत्रण सिद्धांतगवर्नर जो एक उच्च को प्रतिबंधित करता है
Classical Control: Steam Engine → Governor → Constrained Speed
Constrained Fuzziness: LLM/Heuristic → Constrainer → Constrained Output
You don't make the engine "understand" it shouldnMSC3t explodeM SK4 You physically prevent itMST5 Same with probabilistic systemsMSP6 you doMSV7t prompt the LLM to MSR8not hallucinateMSS9 You computationally prevent hallucinations from reaching outputMSSK10
संबंधित कार्य शैक्षिक रूप से झुकाव के लिए
स्पष्ट आपत्ति: "सत्यतः, लेकिन जीपीटी-5 / क्लाउड4/GeminiUltra इतनी अच्छी होगी कि ये बन्धन जीतेंगे
Maybe. फ्रंटियर मॉडल शक़्ति छोटे प्रणालियों के सामने खुलने वाले बहुत से छेदों पर कागज लगाते हैं।
लेकिन "से कम बार " नहीं है।
लघु मॉडल अनुच्छेद यह गहराई से खोजता है, लेकिन मुख्य अंतर्दृष्टि है सीमांत मॉडल भिन्न रूप से असफल होते हैं. उनकी विफलता संरचनात्मक की बजाय अर्थात्मक है कड़ा पता लगाने के लिए आसान नहीं है
और अधिक महत्वपूर्ण है त्वरित अभियांत्रिकी, इंजीनियरिंग विधा का स्थान नहीं ले सकती।. चाहे मॉडल कितना अच्छा हो जाए, , ये समस्याएं बनी रहती हैं
समस्या |---------|---------------------------| राज्य प्रबंधन | मॉडलों में कॉल के बीच स्थायी स्मृति नहीं है | गौण प्रभाव | मॉडल कार्य सिफारिश कर सकते हैं लेकिन निष्पादन की गारंटी नहीं दे सकते लेखापरीक्षा योग्यता निर्णायकता | एक ही प्रवर्धन विभिन्न आउटपुटों को उत्पन्न कर सकता है | पैमाने पर लागत
अगर एक अग्रणी मॉडल विश्वसनीय रूप से सही आउटपुट उत्पन्न कर सकता है तो भी समय के 99.9%
कि constrainer परत है
अंतर यह है कि क्या आप इसे बनाते हैं पहले असफलता तुम्हें सिखाती है कि यह क्यों महत्वपूर्ण है बादप्रतिबंधित अस्पष्टता कहती है।
मॉडल चयन परिवर्तन कितनी बार आप कंसट्रेनर को हिटते हैं
क्या होना चाहिए कभी नहीं उल्लंघन किया जाए
public class SummaryInvariants
{
public bool ValidateSummary(Summary summary, SourceDocument source)
{
// No claims without evidence pointers (e.g., "[chunk-3]" must exist in source)
if (summary.Claims.Any(c => !source.ChunkIds.Contains(c.EvidenceChunkId)))
return false;
// No color assertions unless we computed a palette from the image
if (summary.ColorClaims.Any() && !source.HasComputedPalette)
return false;
// No PII in output
if (PiiDetector.ContainsPii(summary.Text))
return false;
return true;
}
}
सामान्य अपरिवर्ती शामिल हैं
क्या होना चाहिए हमेशा सीमित होना?
public record ProcessingBudget(
int MaxContextTokens = 4000,
int MaxModelCalls = 5,
TimeSpan MaxLatency = default, // e.g., 30 seconds
int MaxVramMb = 2048,
decimal MaxCostUsd = 0.10m
)
{
public ProcessingBudget() : this(MaxLatency: TimeSpan.FromSeconds(30)) { }
}
बजट एक सुझाव नहीं है, यह एक सर्किट ब्रेकर है।
कंस्ट्रेनर सिर्फ़ अस्वीकार नहीं करता है फिर से लिखता है प्रतिरक्षित विवरणों में अति विश्वसनीय आउटपुट्स ("नहीं,", "असंदिग्ध","मौजूद साक्ष्य के आधार पर"), या पूरी तरह असमर्थ दावे को हटा देता है-. पुनः लेखन से संकेत सुरक्षित रहता है जबकि अति विश्वसन को हटाता है।
सामान्य कंस्ट्रेनर्स आप को उपयोग में लाएंगे
स्कीमा गेटJSON स्कीमा
public class SchemaGate<T>
{
public (bool Valid, T? Result, string? Error) Validate(string json)
{
try
{
var result = JsonSerializer.Deserialize<T>(json, _options);
return (true, result, null);
}
catch (JsonException ex)
{
return (false, default, ex.Message);
}
}
}
साक्ष्य गेट: प्रत्येक दावा स्रोत टुकड़ों से लिंक करना चाहिए
public class EvidenceGate
{
public Summary EnforceEvidence(Summary proposed, IReadOnlySet<string> sourceChunkIds)
{
// Keep only claims that reference chunks we actually have
var validClaims = proposed.Claims
.Where(claim => sourceChunkIds.Contains(claim.EvidenceChunkId))
.ToList();
return proposed with { Claims = validClaims };
}
}
नीति गेट: गोपनीयता बजट गेट: समयM SK1 संगणन गेट फिर से लिखें (R): दावा को प्रतिभूति विवरणों में बदलें
जब अस्पष्ट भाग असफल होता है
public async Task<SummaryResult> SummarizeWithFallback(Document doc)
{
try
{
var proposed = await _llm.GenerateSummary(doc);
var constrained = _constrainer.Enforce(proposed, doc);
if (constrained.Claims.Count > 0)
return SummaryResult.Success(constrained);
// LLM output was entirely invalid. Fall back to extractive
return SummaryResult.Degraded(
_extractiveSummarizer.Summarize(doc),
reason: "LLM claims failed validation");
}
catch (BudgetExceededException ex)
{
// Log for evolution, return deterministic-only
_logger.LogWarning(ex, "Budget exceeded for {DocId}", doc.Id);
return SummaryResult.Degraded(
_extractiveSummarizer.Summarize(doc),
reason: ex.Message);
}
}
प्रमुख सिद्धांत
| प्रणाली | उपstrate |
|---|---|
| डॉक-सममैरिजर | BERT [chunk-N]) |
| छवि कैप्सन छवि आकार पैलेट | |
| डेटा-सममारीजरName डकडीबी स्कीमा | |
| मीडिया विश्लेषण | दृश्य समयtamps |
पैटर्न हमेशा एक ही है
यह खंड जानबूझकर विस्तृत है क्योंकि यह किसी भी LLM के बिना पैटर्न दिखाता है
मेरी बोट पहचान प्रणाली (सर्वाधिक स्पष्ट.BotDetectionयह प्रदर्शित करता है कि संकीर्ण अस्पष्टता LLM आधारित प्रणालियों तक सीमित नहीं है
तीन परतें
उपstrate (true layer): एकल डिटेक्टर HTTP अनुरोधों से उद्देश्य संकेतों का संगणन करते हैं
ua.is_bot, ua.contains_automation_keywordhdr.accept_language_count, hdr.missing_standard_headersip.is_datacenter, ip.reputation_scorebeh.requests_per_minute, beh.path_entropyप्रस्तावक ( सृजनात्मकता परत): हृदीय मॉडल भारित सिगमोइड के माध्यम से संकेतों को एकत्र करता है
// Each detector emits a contribution, not a verdict
DetectionContribution.Bot(
source: "UserAgent",
category: "BotSignature",
confidence: 0.85,
reason: "Contains 'Googlebot' signature",
weight: 1.0
);
// Aggregation via weighted sigmoid
var weightedSum = contributions.Sum(c => c.ConfidenceDelta * c.Weight);
var botProbability = 1.0 / (1.0 + Math.Exp(-weightedSum));
कंसट्रेनर (संविदा परत: नीति इंजन कठोर थ्रेसहोल्ड और कार्यों को लागू करता है
public record DetectionPolicy(
double EarlyExitThreshold = 0.3, // Exit if < 30% = confident human
double ImmediateBlockThreshold = 0.95, // Block only if 95%+ certain
double AiEscalationThreshold = 0.6 // Escalate if risk unclear
);
प्रमुख अंतर्दृष्टि
प्रत्येक डिटेक्टर स्वयं निर्णय करने के बिना अंतिम निर्णय में योगदान करता है DetectionContribution रिकार्ड कैप्चर
ConfidenceDeltaकितना यह bot (+) या मानव की ओर धकेलता हैWeight: इस डिटेक्टर का कितना प्रभाव हैSignals: संगणित तथ्यReason: मानवइस पृथक्करण का अर्थ है कि आप कर सकते हैं
वैकल्पिक एलएलएम Escalation
यहाँ-'-जहां यह दिलचस्प हो जाता है-:-मानव समर्थन करता है LLM में वैकल्पिक वृद्धि जब हेरिस्टिक मॉडल अनिश्चित है, तो यह नीति के माध्यम से कॉन्फ़िगर किया जाता है
// Default policy: fast heuristics only
var defaultPolicy = new DetectionPolicy {
FastPath = ["UserAgent", "Header", "Ip", "Behavioral"],
EscalateToAi = false
};
// High-security policy: escalate uncertain cases to LLM
var strictPolicy = new DetectionPolicy {
FastPath = ["UserAgent", "Header", "Ip"],
SlowPath = ["Behavioral", "ClientSide"],
AiPath = ["Onnx", "Llm"], // Optional ML/LLM detectors
EscalateToAi = true,
AiEscalationThreshold = 0.4 // Escalate when 40-60% uncertain
};
जब उत्तेजना ट्रिगर करती है, तो एलएलएम संचित संकेतों को प्राप्त करता है और प्राकृतिक भाषा विश्लेषण प्रदान करता है, लेकिन कंस्ट्रेनर अभी भी थ्रेसहोल्ड लागू करता है.
तरंग
सिस्टम तरंगों में डिटेक्टर चलाता है
flowchart LR
subgraph Wave0["Wave 0: Fast & Free"]
W0A[UserAgent]
W0B[Header]
W0C[IP]
end
C1{Consensus?}
subgraph Wave1["Wave 1: Expensive"]
W1A[Behavioral]
W1B[ClientSide]
end
C2{Still Uncertain?}
subgraph Wave2["Wave 2: AI"]
W2A[ONNX Model]
W2B[LLM]
end
subgraph Policy["Policy Enforcement"]
P1{Score > 0.95?}
P2[Block]
P3[Allow]
P4[Log & Learn]
end
Wave0 --> C1
C1 -->|"Yes: 3+ agree"| Policy
C1 -->|"No"| Wave1
Wave1 --> C2
C2 -->|"No"| Policy
C2 -->|"Yes + AI enabled"| Wave2
Wave2 --> Policy
P1 -->|Yes| P2
P1 -->|No| P3
P3 --> P4
style Wave0 stroke:#22c55e,stroke-width:2px
style Wave1 stroke:#f59e0b,stroke-width:2px
style Wave2 stroke:#ef4444,stroke-width:2px
style Policy stroke:#8b5cf6,stroke-width:2px
यह संकीर्ण अस्पष्टता है प्रगतिशील वृद्धिसस्ती हिuristics स्पष्ट मामलों को संभालता है। ,। expensive AI edge cases को संभालती है।
जोखिम के बिना सीखना
चूंकि कंस्ट्रेनर किसी भी डिटेक्टर के आउटपुट को निर्दिष्ट करने पर भी सुरक्षा को लागू करता है, सिस्टम सुरक्षित रूप से सीख सकता है
// After each request, submit learning event (non-blocking)
LearningCoordinator.TrySubmit("ua.pattern", new LearningEvent {
Features = extractedFeatures,
Label = actualOutcome, // Was it actually a bot?
Confidence = detectionConfidence
});
// Background: EMA weight update
var alpha = 0.1; // Learning rate
newWeight = existingWeight * (1 - alpha) + observedDelta * alpha;
भार समय के साथ सही नमूने की ओर झुकते हैं।
यह क्यों महत्वपूर्ण है
बोट-डिटेक्शन यह साबित करता है कि सीमित अस्पष्टता LLMs के बारे में विशेष रूप से नहीं है
एलएलएम केवल एक संभव अस्पष्ट घटक है
पैटर्न में एक लागत है
जब इसे छोड़ें
कार्य पूर्ण रूप से निर्णायक है अगर आप लिख सकते हैं if X then Yआप नहीं need a proposer
You're prototyping आप नहीं जानते' अभी तक यह पता नहीं है कि क्या अवरोधों का महत्व है।
आउटपुट एकल है मस्तिष्कstorming, ड्राफ्ट्स, रचनात्मक अन्वेषणM SK2 यदि मानव किसी भी तरह से सब कुछ समीक्षा करता है तो constrainer अनावश्यक है
कभी-कभी त्रुटि स्वीकार्य हैं यदि आपके उपयोग के मामले में 5% भ्रम दर ठीक है, तो कंट्रिनेशन की इंजीनियरिंग लागत असफलताओं की लागत से अधिक हो सकती है
आपके पास कोई आधार नहीं है अगर आप सतह को संगणित नहीं कर सकते, तो आप इसे वश में नहीं रख सकते,
पैटर्न प्रणालियों के लिए है जहां
अगर यह आपके स्थिति नहीं है-'
नियंत्रित अस्पष्टता DiSE के साथ संयोजित होने पर और भी अधिक शक्तिशाली हो जाती है।
प्रमुख अंतर्दृष्टि आप सिस्टम को जोखिम के बिना प्रस्तावक विकसित कर सकते हैं, क्योंकि कंस्ट्रेनर प्रस्तावक आउटपुट के बावजूद सुरक्षा और सहीता को लागू करता है
public async Task<EvolvedPrompt> EvolvePromptAsync(
Prompt current,
IReadOnlyList<FailureCase> failures)
{
// Failures are safe to collect because constrainers caught them
var patterns = AnalyzeFailurePatterns(failures);
// Generate candidate prompt mutations
var candidates = await _llm.GeneratePromptVariants(current, patterns);
// Test each against held-out validation set
var scored = await Task.WhenAll(candidates.Select(async c =>
{
var results = await RunValidationSet(c);
return (Prompt: c, Score: CalculateScore(results));
}));
return scored.OrderByDescending(x => x.Score).First().Prompt;
}
संकीर्ण अस्पष्टता संभाव्यात्मक घटकों को अर्थ प्रस्तावित करने की प्रथा है जबकि निर्णायक प्रणालियां सत्य को लागू करती हैं
उस LRU कैश में वापस जाना कि जब यह स्मृति के बाहर चला गया तो अधिक स्मार्ट हो गया
यह अधिक क्षमता प्रदान नहीं करता था बन्धन को अपना काम करने देना. सीमित आकार के बल पर चुने जाने के लिए बाध्य selection. स्लाइडिंग समाप्ति के बल से भूलने को बाध्य
यही मुख्य अंतर्दृष्टि है आप probabilistic प्रणालियों को बनाने के द्वारा ठीक नहीं कर सकते कम संभाव्यात्मकआप उन्हें निश्चित कर सकते हैं संभावना को अपने गारंटी में बाहर नहीं छोड़कर
flowchart LR
E[🔥 High-Variance<br/>Engine] --> G[⚙️ Governor] --> O[✓ Constrained<br/>Output]
style E stroke:#ef4444,stroke-width:2px
style G stroke:#22c55e,stroke-width:3px
style O stroke:#3b82f6,stroke-width:2px
वाष्प इंजन को नहीं समझता है।
एक ही नमूना
अगली बार जब आप आपके तंत्र में एक अन्य पैराग्राफ जोड़ने के लिए प्रोत्साहित होते हैं उम्मीद करते हुए कि मॉडल को समझेगा क्या मैं उस प्रतिबंध का संगणन कर सकता हूँ
अगर हाँ है तो इसे कम्प्यूटर करें
कठोर सीमाएं नरम सुझावों को हराती हैं
| भाग | पैटर्न |
|---|---|
| एकल अवयव | |
| 2 | प्रतिबंधित अस्पष्ट मोएम बहुआयामी अवयव |
| 3 | प्रतिबंधित अस्पष्ट संदर्भ खींचना समय |
| 4 | छवि सारणी व्यावहारिक कार्यान्वयन |
भाग 2 इस संरचना को कई तक विस्तारित करता है
भाग 3 समय अक्ष के साथ इसे विस्तारित करता है
भाग 4 सभी तीन पैटर्नों में लागू दिखाता है ImageSummarizerComment—एक तरंग-आधारित छवि विश्लेषण पाइपलाइन जहां ColorWave तथ्यों को संगणित करता है
© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.