# Fuzzine limitate: Un modello di sistema di controllo per componenti probabilistici ## Il modello che è emerso È iniziato con il mio blog's [strumento di traduzione](/blog/fire-and-dont-quite-forget-ephemeral-execution). Il cache ha conservato solo 5 compiti pro-utente, con 6- ore absolte e S1- interruzione di un'ora in frettaM SK5 Sesto compitoMNK6 Il più vecchio è stato espulsoMRK7 Dopo un'ore di inattivitàMMK8 tutto è finitoSSK9 La maggior parte dei sviluppatori li vederebbe come restrizioni per lavorare intorno a. Ma il cache è diventato *auto-cleaning* e *auto-specializzarsi*. Ha conservato ciò che gli utenti avevano bisogno e ha dimenticato quello che non avevano fatto 't. La finestra limitata non era la ' non combatteva il sistemaM SK4 *e' stato* Il sistema. Ho estratto quel primitivo. [Mostlylucid.Ephemeral](https://github.com/scottgal/mostlylucid.atoms)La stessa idea è generalizzata. Il modello continuava a mostrarsi. In [DiSE](/blog/dise-architecture-overview), I LLM sviluppano il codice , ma i test di unità e i controlli di qualità decidono cosa sopravviveM SK2 Il LLM propone; la restrizione dei testMSC4 In [Detezione del bot](/blog/learning-lrus-when-capacity-makes-systems-better), i rilevatori heuristici fanno richieste di punteggio, ma i sogliamenti delle politiche forniscono il giudizio finaleM SK2 Nell'intelligenza dei clienti , I LLM generano segmenti comportamentali , ma le misurazioni calcolate limitano ciò che possono affermareMSC5 Quattro sistemi. Stessa formaM SK1 La limitazione è sempre l'insegnante. Una restrizione trasforma l'ambiguità in una scelta forzata. *Ressource* (grandezzaM SK1 tempo , costo). Qualche volta èMSC4s *epistemico.* (evidenza ,invariantiM SK2 Lo stesso ruolo: forzare la selezione e prevenire la certezza non acquisitaMSC4 ```mermaid 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 ``` Questo è il punto di vista fondamentale del [Serie di Intelligenza Semantice](/blog/semantidintelligence-part1) e [DiSE (Evoluzione sintetica diretta)](/blog/dise-architecture-overview): **I limiti non limitano l'intelligenza. *creare un comportamento utile.* nei sistemi che altrimenti si muovono.** Il cache LRU sotto pressione. Il LLM limitato dai fatti calcolati. Il modello heuristico limitato dalle soglie politicheM SK2 Ogni limitazione costringe il sistema a prendere decisioni . Queste decisioni creano la pressione di selezioneMSC4 | Systemo | Constrizione (Primitivo) SSK4 Comportamento emergente S| |--------|----------------------|-------------------| | Cache LRU | Limito di dimensione Sliding expiry | Forgets irrelevant patterns, remembers useful ones S| | Summarizer LLM | Dobbiamo citare frammenti di sorgente | Può' non avere allucinazioni alle affermazioni non supportate | Detettore del bot | Soglia di politica (0.3/0.95) M| Esce solo quando è davvero incerto R| | Capitore d'immagine | Palette di colore calcolata | | | Non può |' | inventare colori che non esistono | Lo stesso schema. Differite domenzeM SK1 La limitazione è l'insegnante. --- > **TL;DR**: Lasciare modelli probabilistici *Proporre*; lascia sistemi deterministici *Decidere.*. calcolare i fatti che si possono verificare , lasciare che l'AI li interpretiM SK2 poi validare ogni affermazione contro i fatti. Funziona per LLMsMSC4 euristicaMST5 modelli visiviMst6 qualsiasi cosa incertaM st7 --- ### La carta dello schema | | | |---|---| | **Intenzione** | Usare in modo sicuro i componenti probabilistici in sistemi con garanzioni reali | | **Le forze** | alto-emissioni di variazioneM SK2 fallimento silenzioso , calcolo limitatoMST4 bisogno di apprendimento MST5 | **Soluzione** | Soggetto ( fatti) → Proponente incertezzaM SK5 \→ Conduttore Svalidazione R+ riscrivere M+ budgetMSC10 | | → outputMNK12incorrenza P| | **Le conseguenze** | Più ingegneria all'inizioM SK1 evoluzione e operazioni più sicure | **Cosa ottenete:** - Mode di fallimento più chiari (Output degradati con tracciate di revisione,Non corruzione silenziosaM SK2 - Un'evoluzione più sicura (mutare il proposere liberamenteM SK1 il constrainer cattura gli errori) - Modello-architettura agnostica M SK1swap 7B per la frontiera senza cambiamenti strutturali) **Quanto costa:** - : si costruiscono le prove e le misurazioni prima di vedere il risultato. --- ## Fuzzinesse limitata Constritto qui significa **I confini sono limitati.**: limiti rigidi imposcati meccanicamente piuttosto che negoziati attraverso i prontiM SK1 Budgets, invariantiMSC3 e constrainers ( validare + riscrivere i cancelliMNK6 che fisicamente impediscono l'eccesso di raggiungimentoMMK7 non " alcune cavie di guardiaMRK9 o SNK10bestMDK11promptazione dell'effortMZK12 Dopo aver costruito sistemi in domeni molto diversi (summarizizzazione del documento,analisi dell'immagineM SK2 rilevamento dei bot , ricerca di datiMSC4 questa architettura è continuata ad emergere ```mermaid 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 ``` L'intuizione principale: **Lasciate che i componenti probabilistici propongano, ma non fate loro decidere mai.**. Usarli per quello che fannoM SK1 sono bravi a ( interpretare, classificareMSL4 generare ipotesiMSR5 mentre applicano dure restrizioni deterministiche ad ogni confineMsl7 Ciò che rende questo modello potente è la sua flessibilità. - Un LLM che genera riassunti linguistici naturali. - Un modello heuristico con pesci imparati e probabilità di punteggio dei robot. - Un modello di visione che propone i sottotitoli delle immagini. - Un gruppo di classificatori deboli che vota una decisione. L'architettura rimane la stessa. Solo i componenti cambiano. ## Il problema: I sistemi senza restrizioni falliscono silenziosamente Senza limiti, i sistemi probabilistici falliscono in modi difficili da rilevare e impossibili da prevenire: ```mermaid 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 ``` **Mode di fallimento non limitati:** - Il LLM descrive con sicurezza i colori che non esistono nell'immagine. - I riassunti citano fatti che non si trovano da nessuna parte nel materiale sorgente. - I punteggi di rilevamento dei bot fluctuano in maniera selvaggia basati su segnali irrilevanti. - Un learned heuristic drifts mentre i modelli di traffico cambiano e blocca silenziosamente gli utenti legittimi. - Le domande SQL includono le dichiarazioni UPDATE e DELETE quando volevate solo leggere. - I costi sono in spirale, perché i casi marginali consumano risorse illimitate. L'istinto è aggiungere più stimoli, più esempi, più cinture di sicurezza morbideM SK2 Ma i sistemi probabilistici non possono essere affidati a rispettare i confini morbidi . Ne richiedono quelli difficiliMSC5 ## La legge: Dieci comandamenti Il modello si è cristallizzato in [Regole operative](/blog/tencommandments) che codificano l'incertezza limitata (selezionatoM SK1 | Comandamento | Traduzione constratta di Fuzzinesse | |-------------|------------------------------| | **I. Le LLM non possiedono lo stato** | Lo stato vive nel substrato, non il proposere | | **II. Le LLM non sono l'unica causa degli effetti collaterali.** | Il constrainer si impegna; il LLM raccomanda | | **IV. Usare LLM dove la probabilità è accettabile** | ClassificazioneM SK1 riassunto, classificazione (non invariantiMSC4 | | **V. Non chiedere mai a un LLM di decidere un boolean derivabile** | Se lo puoi calcolare, lo puoi computare | | **VIII. Demontare il LLM al consulente, non agente** | ProponenteM SK1 non decidente | La ricompensa: **Non c'è bisogno di modelli frontiere.**. Un piccolo LLM locale sull'hardware di merci diventa un moltiplicatore di forza quando fa la classificazione e la creazione delle ipotesi, non finge di essere una banca dati o una macchina dello statoM SK3 La macchina noiosa gestisce le parti dureMSC4 Il LLM gestisce i pezzi sfuzzy . ## La connessione della teoria del controllo Il modello ha profonde radici. **La teoria del controllo.**: il governatore che restringe un processo di variazione alto ``` Classical Control: Steam Engine → Governor → Constrained Speed Constrained Fuzziness: LLM/Heuristic → Constrainer → Constrained Output ``` Non si fa il motore "si capisce " non dovrebbe esplodere'non deve scoppiareM SK4 Si lo impedisce fisicamenteMSC5 Lo stesso vale per i sistemi probabilisticiMST6 non si fa l'impulso al LLM a " non halucinareSST9 Si impedisca dal calcolo che le allucinazioni raggiungano il risultato. **Lavoro connesso** per gli studenti con inclinazione accademica: - Herbert Simon [Razionalità limitata](https://en.wikipedia.org/wiki/Bounded_rationality) - decisioni- decisione sotto vincoli - "[Un'indagine approfondita della RAG](https://arxiv.org/abs/2410.12837)" - Mitchell's "La necessità di pregiudizi nell'apprendimento Generalizzazioni ## Che ne dite dei modelli Frontier? L'opposizione ovvia: "Sure, ma il GPTM SK3 MSC4 Claude 4 \/ Gemini Ultra sarà così buona che queste restrizioni vinconoMST7 non importaMSST8 Forse. I modelli Frontier *Possiamo fare un po' di più.* carta su molte crepe che i sistemi più piccoli esibiscono. Hanno allucinazioni meno frequenti. Mantengono le istruzioni in modo più affidabile . Maneggiano le case a bordo con più graziaM SK3 Se vi state costruendo un prototipo o uno strumento dove i fallimenti occasionali sono accettabiliMSC5 un modello di confine con un buon suggerimento potrebbe essere sufficienteMST6 Ma " meno frequentementeM SK1 non è " mai." E " più affidabileMST5 non é SSK6guarantedMSM7 L'informazione figura nella parte dispositiva. [piccolo modello articolo](/blog/small-models-not-budget-option) Lo studiano in profondità, ma l'intuizione centrale è: **I modelli di confine falliscono diversamente, non meno**. I loro fallimenti sono semantici piuttosto che strutturali. *più difficile.* per rilevare, non è più facile. Ancora più importante: **L'ingegneria rapida non può sostituire la disciplina di ingegneria.**. Non importa quanto il modello divenga buonoM SK1 questi problemi rimangono: | Problemo | Perché fare delle protuberanze può'non ripararlo | |---------|---------------------------| | Gestione dello stato | I modelli non hanno memoria persistente per tutte le chiamate | Effetti collaterali | I modelli possono raccomandare le azioni ma non possono garantirne l'esecuzione. | Riducibilità | "Il modello ha detto così" non è un percorso di revisione accettabile MSC4 | Determinismo | Lo stesso prompt può produrre diverse emissioni. | Costo su scala | Per-compositi di prezzo a tocco con volume | Anche se un modello di confine può produrre in modo affidabile un risultato corretto 99.9% del tempo, avete ancora bisognoM SK2 - Validazione per catturare il 0.1% - Fallback quando la validazione fallisce - Loggare per capire cosa è successo. - Metrica per tracciare la deriva nel tempo Quello' è la strata di constraineri . VoiM SK2 lo costruite comunque. La differenza è che lo costruisci o no. *prima.* I fallimenti ci insegnano perché è importante. *dopo.*. Constrizione Fuzziness dice : costruirlo prima. Poi la dimensione del modello diventa una scelta di deploiamentoM SK3 non un modello architettonicoMSC4 Un modello B con buone restrizioni spesso supera un modello frontiere con cattive. Cambiamenti nella scelta del modello *Quante volte?* Si colpisce il constrainer. Non elimina la necessità di usarlo. ## Implementare l'incertezza limitata ### 1. Definite le vostre invarianti Cosa deve fare? **mai.** essere violato? ```csharp 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; } } ``` Gli invarianti comuni sono:: - No claims without evidence pointers - No colors unless derived from palette statistics - Nessuna emissione di PII - No writes, solo leggere-solo SQL - Nessun'attribuzione di identità a meno che non sia esplicitamente basata. ### 2. Richiede budget difficili Cosa deve fare? **sempre.** essere limitato? ```csharp 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)) { } } ``` Il budget non è un suggerimento, ma una rottura di circuiti. Quando è superato, il sistema si degrada graziosamente invece che continuare a bruciare risorse. ### 3. Costruite i vostri tipi di porta Il constrainer non recluta soltanto il .. *riscrivere.* Emissioni superconfidenti in declarazioni hedged ("potenzialmente", "incerteM SK3MSC4 basata sulle prove disponibiliMska5 o cancella completamente le affermazioni non supportateMske6 Riscrivere preserva il segnale mentre cancella l'overconfidenzaMsek7 mantenendo i sistemi utili sotto l'incertezza invece di fragiliM Ske8 Che'è la parte differenziale:itMsc11non è la validazione dell'inputMSS12it\MSS13il controllo delle emissioni. Constrainer comuni che si riutilizzano in tutti i sistemi. **Torno Schema**Validazione del tipo : schema JSON ```csharp public class SchemaGate { public (bool Valid, T? Result, string? Error) Validate(string json) { try { var result = JsonSerializer.Deserialize(json, _options); return (true, result, null); } catch (JsonException ex) { return (false, default, ex.Message); } } } ``` **Porta della prova**: Ogni richiesta deve collegarsi a parti della fonte. ```csharp public class EvidenceGate { public Summary EnforceEvidence(Summary proposed, IReadOnlySet 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 }; } } ``` **Porta della politica**:Privatezza/Regole di sicurezza **La porta del budget**: TempoM SK1 calcolo/cappi di toccane **Riscrivere la porta.**: Trasformere le affermazioni in dichiarazioni hedged ### 4. Definire il trattamento dei fallimenti Quando la parte confusa fallisce, don't crashM SK2 DegradiMSC3 ```csharp public async Task 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); } } ``` I principi chiave: - Degrado graziosamente in modo deterministico-solo. - Rendere il risultato parziale con dei marcatori di incertezza espliciti. - Registrare le proposte non valide come segnali di allenamento per l'evoluzione rapida. ## Esempi reali-World ### LLM-Systemi basati (BriefM SK2 | Il sistema | Il substrato |--------|-----------|----------|---------| | **DocSummarizer** | BERT/ Extrazione di frammenti RAG | Syntesi narrativa del LLM | Validatore della citazione Certificazioni devono citare `[chunk-N]`) | | **Captionazione dell'immagine** | Palette di ImageSharp/metrics | FlorenceM SK3LLaVA caption | Le affermazioni di colore devono corrispondere alla palette calcolata SSK5 | **DataSummarizer** | Schema del DuckDB | | | LLM |→ | SQL | | | No writes | | Table allowlist | | **Analizza dei media** | Timmi della scenaM SK1 traduzione | foglio di battimento LLM | I battimenti devono citare timmi di scenaSSK4quotes SSM5 Il modello è sempre lo stesso. ### Detezione del bot: Esempio di non--LLM *Questa sezione è intenzionalmente dettagliata perché mostra il modello senza nessun LLM.* Il mio sistema di rilevazione dei bot ([Mostlylucid.BotDetection](https://www.nuget.org/packages/Mostlylucid.BotDetection)) dimostra che Constrained Fuzziness non è' non è limitato a sistemi basati su LLMM SK2 . QuiMSC4 il proponente fuzzy è una collezione di rilevatori heuristici con pesci imparatiMST5 Non c'è un modello linguistico necessario per la funzione centraleMst6 **Le Tre Layeri:** - **Il substrato (Layere della verità)**: Detettori individuali calcolano segnali oggettivi dalle richieste HTTP - UserAgent analysis: `ua.is_bot`, `ua.contains_automation_keyword` - Analizza dei titoli: `hdr.accept_language_count`, `hdr.missing_standard_headers` - Analyse IP: `ip.is_datacenter`, `ip.reputation_score` - Analisi comportamentali: `beh.requests_per_minute`, `beh.path_entropy` - **Proponente (Lo strato di creatività)**: Il modello heuristico aggrega i segnali tramite un sigmoide pesato. ```csharp // 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)); ``` - **Construitore (Contratta Layer)**: Il motore delle politiche impone limiti e azioni difficili. ```csharp 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 ); ``` **L'intuizione chiave: I detetti emetteno prove, Non giudizi** Ogni rilevatore contribuisce alla decisione finale senza prendere la decisione stessa. `DetectionContribution` Record captures: - `ConfidenceDelta`: Quanto questo spinge verso il robot (+) o l'uomo - `Weight`: Quanto influenza questo rilevatore? - `Signals`: I fatti calcolati (non mai crudo PIIM SK2 - `Reason`: UmanoM SK1e' una spiegazione legabile Questa separazione significa che si può: - Aggiungere/removare i rilevatori senza cambiare la logica dell'aggregazione - Pesi di tune indipendentemente dalla logica della rilevazione - Impara il peso ottimale dal feedback nel tempo. **Escalazione LLM opzionale** Qui' è il punto in cui diventa interessante: il modello supporta **escalazione opzionale a LLM** quando il modello heuristico è incerto. Questo è configurato tramite la politica: ```csharp // 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 }; ``` Quando l'escalazione si attiva, il LLM riceve i segnali accumulati e fornisce un'analisi linguistica naturale, ma il constrainer impone ancora dei sogliamentiM SK2 L'opinione del LLM ' influenza la classificaMSL4 non supera la politicaMSC5 **Orchestrazione basata su Wave-** Il sistema fa funzionare dei rilevatori in onde, con onde più tardi attivate da segnali precedenti: ```mermaid 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 ``` Questo è un'incertezza limitata. **Una escalazione graduale.**: le heuristiche economiche affrontano casi chiari , l'intelligenza artificiale costosa affronta casi marginali M SK2 e la politica impone restrizioni a ogni passo . **Imparare senza rischio** Dato che il constrainer fornisce sicurezza a prescindere dal risultato dei rilevatori, il sistema può imparare in modo sicuro. ```csharp // 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; ``` I pesci si convergono verso schemi veri nel tempo. alti - le osservazioni di fiducia hanno un impatto maggiore. Ma una cattiva aggiornazione del peso non può mai causare danni non limitatiM SK3 i limiti delle politiche continuano ad applicarsiMSC4 **Perché è importante?** BotDetection dimostra che l'incertezza limitata non riguarda gli LLM in particolare, ma ogni sistema dove. 1. Dobbiamo combinare molti segnali incerti. 2. Diversi segnali hanno una diversa affidabilità. 3. Le restrizioni difficili devono essere imposte a prescindere dalle punteggi. 4. Il sistema dovrebbe imparare e migliorare nel tempo. 5. L'analisi costosa dovrebbe funzionare solo quando l'analisi economica è insufficiente. Il LLM è solo un possibile componente fuzzy. I modelli heuristici , I classificatori dell'ensemble, e la regolaM SK3 i punteggi basati sui scorri si adattano alla stessa architetturaMSC4 ## Quando non usare l'incertezza limitata Il modello ha un costo. **Skip it when:** - **Il compito è completamente deterministico.** Se riuscite a scrivere `if X then Y`, non c'è ' non hai bisogno di un proposeri. Semplicemente scrivere il codiceM SK3 - **Voi'ste in fase di prototipo.** Non lo sapete'non sapete ancora quali sono le restrizioni che contano. Lasciatelo fallire primaM SK2 La limitate dopo aver capito i modi di fallimento . MSC4A meno che il raggio dell'esplosione sia altoMNK5 la limitate prestoMRK6 - **Il risultato è univoco.** Brainstorming, draftsM SK1 creative exploration: if a human reviews everything anywayMSC3 the constrainer is redundant . - **I fallimenti occasionali sono accettabili.** Se 5% il tasso di allucinazione è buono per il vostro caso d'uso, il costo di ingegneria delle restrizioni può superare il costo dei fallimentiM SK2 - **Non avete substrato.** Se riesci a' non calcolare la verità di fondoM SK1 puoi' non limitarlaMSC3 Non farlo finta ' o trovare fatti calcolabili o accettare l'incertezzaMST6 **Il modello è per i sistemi dove:** - I risultati probabilistici raggiungono gli utenti o altri sistemi senza revisione umana. - I fallimenti sono silenziosi, costosi, o composti. - Dovete imparare a evolvere senza rischiare la produzione. Se quella ' non è la vostra situazione, approcci più semplici vinconoM SK2 ## Integrazione con i sistemi evolutivi L'incertezza limitata diventa ancora più potente quando combinata con DiSE (Evoluzione sintetica guidata)PatterniM SK2Perchè si possono valutare i candidati in modo economico e deterministico : 1. **Generare** Propositione multiple sfuzzy 2. **Validare.** contro le invarianti. 3. **Il punteggio** basata sulla soddisfazione con le restrizioni + metriche utilitarie 4. **Tenere.** il migliore, getta via il resto 5. **Accumulare** i fallimenti come segnali di allenamento per l'evoluzione rapida Il punto di vista chiave: **Potete sviluppare il proposere senza rischiare il sistema.**, perché il constrainer fornisce sicurezza e correttezza a prescindere da ciò che il proponente produce ```csharp public async Task EvolvePromptAsync( Prompt current, IReadOnlyList 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; } ``` ## La definizione di One-Sentence > "Constrained Fuzziness è la pratica di lasciare che i componenti probabilistici propongano il significato mentre i sistemi deterministici impongono la verità , la sicurezza M SK2 e i budget a ogni confine ." ## Conclusione: Il governatore, Non il motore Tornando a quella cache LRU che è diventata più intelligente quando ha finito la memoria. La soluzione era: ' non dà più capacità. **lasciare che il vincolo faccia il suo lavoro.**. La dimensione limitata ha forzato la selezione. L'estremità scorrente l'ha costretta a dimenticareM SK2 Insieme , hanno creato l'apprendimentoMSC4 Questo è il punto di vista chiave: **Non si riparano sistemi probabilistici facendoli. *meno* probabilista.**. Li riparate non lasciando che la probabilità scappara nelle vostre garanzie. ```mermaid flowchart LR E[🔥 High-Variance
Engine] --> G[⚙️ Governor] --> O[✓ Constrained
Output] style E stroke:#ef4444,stroke-width:2px style G stroke:#22c55e,stroke-width:3px style O stroke:#3b82f6,stroke-width:2px ``` Il motore a vapore non capisce, non dovrebbe esplodere, il governatore lo impedisce fisicamente. Same pattern. Different century. La prossima volta che ' siete tentati di aggiungere un altro paragrafo al vostro sistema, sperate che il modello capisca " compresa *Posso calcolare quel vincolo?* Se sì, lo calcoliamo. Poi constrainiamo il modello a essoM SK2 I limiti difficili battono le suggestioni morbide. Ogni voltaM SK1 --- ## La serie | Parte | Tipo | Asse S| |------|---------|------| | 1 ≥| Fuzzinesse limitate Questo articoloM SK4 \| Componenti uniche || | 2 | [MoM Fuzzy Constretto](/blog/constrained-mom-mixture-of-models) | Numerosi componenti | | 3 | [Dragging Contexto Fuzzy Constrained](/blog/constrained-fuzzy-context-dragging) | Tempo / memoria | | 4 | [Summarizatore dell'immagine](/blog/constrained-fuzzy-image-intelligence) | Implementazione pratica | **Parte 2** Questa architettura si estende a molti sistemi multi-agente systems. I modelli non parlano tra di loroM SK2 pubblicano segnali tipizzati su un substrato condiviso . La constrazione diventa la comunicazione stessa **Parte 3** si estende lungo l'asse temporale. I modelli possono notare, ma l'ingegneria decide cosa persistaM SK2 La constrazione diventa la memoria stessa . **Parte 4** mostra tutti i tre modelli implementati in [ImageSummarizer](https://github.com/scottgal/lucidrag)—un'ondaM SK1fonda un tubo di analisi dell'immagine dove ColorWave calcola i fatti , VisionLlmWave propone, e la selezione deterministica restringe il risultatoMSC4