Back to "Fuzzine limitate: Un modello di sistema di controllo per componenti probabilistici"

This is a viewer only at the moment see the article on how this works.

To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk

This is a preview from the server running through my markdig pipeline

AI Architecture DiSE LLM Patterns

Fuzzine limitate: Un modello di sistema di controllo per componenti probabilistici

Monday, 05 January 2026

Il modello che è emerso

È iniziato con il mio blog's strumento di traduzione. 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.EphemeralLa stessa idea è generalizzata.

Il modello continuava a mostrarsi. In DiSE, 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, 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

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 e DiSE (Evoluzione sintetica diretta):

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

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:

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 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:

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 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?

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?

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 SchemaValidazione del tipo : schema 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);
        }
    }
}

Porta della prova: Ogni richiesta deve collegarsi a parti della fonte.

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 };
    }
}

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

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);
    }
}

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) 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.

    // 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.

    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:

// 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:

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.

// 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

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;
}

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.

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

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 Numerosi componenti
3 Dragging Contexto Fuzzy Constrained Tempo / memoria
4 Summarizatore dell'immagine 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—un'ondaM SK1fonda un tubo di analisi dell'immagine dove ColorWave calcola i fatti , VisionLlmWave propone, e la selezione deterministica restringe il risultatoMSC4

logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.