# Fuzziness restreinte: Modèle de système de contrôle pour les composants probabilistes ## Le modèle qui reste à émerger Il a commencé avec mon blog's [Outil de traduction](/blog/fire-and-dont-quite-forget-ephemeral-execution). Le cache ne tient que les tâches suivantes par utilisateur: 5 des heures absolues et des heures d’expiration progressive de la durée de l’utilisation; La plupart des développeurs les considéreraient comme des contraintes pour travailler autour de. Mais le cache est devenu *auto- nettoyant* et *auto-specialisation*. Il a conservé ce dont les utilisateurs avaient besoin et oublié ce qu’ils n’avaient pas fait. *a été* le système. J’ai extrait ce primitive dans [La plupart du temps, il est clair.Éphemaire](https://github.com/scottgal/mostlylucid.atoms): concurrence restreinte , expiration en glissement M SK2 signal - coordination entre les opérations fondée sur la même idée généralisée Le modèle a continué à apparaître. Dans [DiSE](/blog/dise-architecture-overview), Les LLM élaborent un code , mais les essais d'unité et les contrôles de qualité déterminent ce qui surviendra M SK2 Le LLM propose ; des contraintes aux essais [Détection des bottes](/blog/learning-lrus-when-capacity-makes-systems-better), les détecteurs héuristiques font des demandes de cotes d’échantillonnage , mais les seuils de politique exécutent le verdict final Quatre systèmes. La même formeM SK1 La contrainte est toujours l’enseignant. Une contrainte fait de l’ambiguïté un choix forcé. *Ressources* (size,timeM SK2coût ).Sousfois ilMSC4s *épistemiques* (éléments de preuveM SK1invariantes). Rôle identique : exécuter la sélection et prévenir la certitude non acquise ```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 ``` Il s’agit là de l’influence fondamentale [Système d'intelligence sémantique](/blog/semantidintelligence-part1) et [DiSE (Evolution synthétique dirigée)](/blog/dise-architecture-overview): **Les contraintes ne limitent pas l’intelligence. *créer un comportement utile* dans les systèmes qui autrement se déplacent** Le cache des LRU sous pression. La LLM restreinte par les faits computés. Le modèle héuriste restreint par les seuils de politiqueM SK2 Chaque contrainte oblige le système à prendre des décisions . Ces décisions créent la pression de sélectionMSC4 | Système | Constraint |--------|----------------------|-------------------| | Cache LRU | Limite de taille Sliding expiry MSC2 Forgets irrelevant patterns | Sommaire du LLM | Il faut citer les tronçons de source | Détecteur de bottes | seuils de politique MSC2 MSC3 Évacue seulement lorsqu’il est vraiment incertain SMC4 | Capseur d'image | Palette de couleurs calculée | Peut-il inventer des couleurs qui ne sont pas existantes ? Le même modèle. Domaines différents . La contrainte est l’enseignant. --- > **TL;DR**: Laissez les modèles probabilistes *proposer*; laisser les systèmes déterministes *Décision*. Computez les faits que vous pouvez vérifier , laissez-lui interpréter par l'AI M SK2 puis validez toutes les allégations contre ces faits . Travaux pour les LLMs --- ### Carte du modèle | | | |---|---| | **Intention** | Utiliser de façon sécuritaire les composants probabilistes dans des systèmes avec garanties réelles | | **Forces** | élevéeM SK1 sorties variables , défaillance silencieuse M SK3 compute restreint , besoin d'apprentissage | **Solution** | Sous-stratégie (facts) → Proposition SSK4incertitudeM SK5 | | SSK6 | Contrôleur | validation | S+ réécriture |S+ | budget | MVSK10 | SVSK11 | production | SMP12 | déclin | FS13 | **Conséquences** | Plus d’ingénierie à l’avant-plan ; Évolution et opérations nettement plus sûres **Ce que vous obtiendrez:** - Modes de défaillance plus clairs (extrants dégradés avec traces d'audit , non corrompus silencieux - Évolution plus sûre (muter librement l’auteur de la proposition - Modèle-Architecture agnotique M SK1swap 7B pour la frontière sans changement structurel) **Coût:** - Plus de plomberie à l’avant-plan: vous bâtissez une extraction des preuves et des mesures avant de voir le rendement --- ## Fuzziness restreinte Constréint ici signifie **bounded**: limites strictes imposées mécaniquement plutôt que négociées par le biais de mécanismes d’appels à propositionsM SK1 Budgets , invariantes M SK3 et constrainers Après la mise en place de systèmes dans des domaines très différents ( résumé du document , analyse d'images M SK2 détection de bottes , recherche de données MSC4 cette architecture a continué à émerger ```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’incertitude fondamentale: **laisser les composantes probabilistes proposer, mais ne les laisser jamais décider**. Utilisez-les pour ce qu'elles font'ils sont bons à (interprétationM SK3 classementM Sk4 génération d'hypothèsesM sk5 tout en imposant des contraintes déterministes à chaque frontièreM KS7 Ce qui rend ce modèle puissant, c’est sa souplesse. - Un LLM génère des résumés de langue naturelle - Modèle héuristique avec pondérations apprises et probabilité de cotation du robot - Modèle de vision proposant des captions d'image - Un ensemble de classificateurs faibles votant sur une décision L'architecture demeure la même. Seules les composants changent. ## Le problème: Les systèmes non restreints échouent silencieusement Sans contraintes, Les systèmes probabilistes échouent de façon difficile à détecter et impossible à empêcher ```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 ``` **Modes de défaillance non contraints:** - Le LLM décrit avec confiance les couleurs qui ne sont pas présentes dans l'image. - Les résumés citent des faits qui ne figurent pas dans le matériel de source. - Les scores de détection des bottes fluctuent sauvagement en fonction de signaux irrelevant - Un heuriste étudié se déplace à mesure que les patrons de trafic changent et bloque silencieusement les utilisateurs légitimes - Les demandes de SQL comprennent les déclarations UPDATE et DELETE lorsque vous ne voulez que lire. - Les coûts s’écroulent à mesure que les cas-marchés consomment des ressources illimitées L’instinct est d’ajouter des exemples plus incitants. ## Les dix commandements de la loi Le modèle a été cristallisé en [Règles d'exploitation](/blog/tencommandments) (selectedM SK1 | Commandement | Traduction de la fuzziness restreinte | |-------------|------------------------------| | **I. Les LLM ne doivent pas être propriétaires d’un État** | L’État vit dans le substrat, non le promoteur | | **II. Les LLM ne doivent pas être la seule cause des effets secondaires** | Le constrainer s’engage ; le LLM recommande | **IV. Utiliser des LLM lorsque la probabilité est acceptable** | Classification | **V. Ne demandez jamais à un LLM de décider d'un boolean dérivé** | Si vous pouvez le calculer, | **VIII. Démonter le LLM à l’avocat, non agent** | ProposerM SK1 non décideur | La rémunération: **vous n’avez pas besoin de modèles frontaliers**. Un petit LLM local sur le matériel de marchandises devient un multiplicateur de force lorsqu’il effectue la classification et la production d’hypothèses , ne prétend pas être une base de données ou une machine d’État . La machine borne manipule les parties rigides MSC4 Le LLM manipule des parties floues M SK5 Pour un exemple de cette séparation, C# , voir [Utilisation de Nimble du C#](/blog/stylomail-using-nimble-from-csharp), de la partie du [La série StyloMail](/blog/stylomail-behavioural-inference-with-jev). Le modèle de décision locale répond à des questions spécifiques concernant le courrierM SK1 le système entourant combine ces données avec les comportements et la politique explicite. ## Connexion de la théorie du contrôle Le modèle a des racines profondes dans **La théorie du contrôle**: le gouverneur qui limite un processus de variation élevé ``` Classical Control: Steam Engine → Governor → Constrained Speed Constrained Fuzziness: LLM/Heuristic → Constrainer → Constrained Output ``` Vous ne faites pas le moteur " comprenez " il ne devrait pas exploder M SK3 vous l’empêchez physiquement . C’est la même chose avec les systèmes probabilistes **Travaux connexes** pour les personnes académiques: - Herbert Simon's [Rationalité limitée](https://en.wikipedia.org/wiki/Bounded_rationality) - décisionM SK1 prise sous contrainte - "[Une étude approfondie du RAG](https://arxiv.org/abs/2410.12837)" (2024) ≥- récupérationM SK3 patrons de génération améliorés - Mitchell's M SK1La nécessité de préjugés dans l’apprentissage généralisations" (1980) | - pourquoi les contraintes aident à apprendre ## Qu'en est-il des modèles Frontier? L’objection évidente: M SK1Sure, mais le GPT -5 \/ Claude M SK5 |/ Gemini Ultra sera tellement bon que ces contraintes gagneront Peut-être. Modèles Frontier *utilisation* de papier sur de nombreuses fissures que les systèmes plus petits exposent. Ils hallucinaient moins fréquemment. Ils suivent l’instruction avec plus de fiabilité . Ils manipulent les cases en bordure de façon plus gracieuseM SK3 Si vous construisez un prototype ou un outil où des défaillances occasionnelles sont acceptablesMSC5 un modèle frontalier comportant de bonnes indications pourrait suffireMST6 Mais " moins fréquemment" n’est pas "ne jamaisM SK3 Et MSC4 plus fiableMSC5 n'est pas L'article 5 de la Loi sur l'immigration et le statut des réfugiés [article sur les petits modèles](/blog/small-models-not-budget-option) Il s’agit d’une étude approfondie de cette question, mais le point central est : **Les modèles frontaliers échouent différemment, pas moins**. Les défaillances sont sémantiques plutôt que structurelles. *plus difficile* pour détecter, pas plus facileM SK1 Plus important encore: **L'ingénierie rapide ne peut pas remplacer la discipline en génie.**. Quelle que soit la qualité du modèle, les problèmes demeurent. | Problème | Pourquoi le dépistage peut-il corriger les problèmes ? |---------|---------------------------| | Gestion de l'État | Les modèles ne possèdent pas de mémoire persistante à travers les appels | Effets secondaires | Les modèles peuvent recommander des actions mais ne peuvent garantir l’exécution | Vérifiabilité | "Le modèle a dit que ce n’est pas une piste de vérification acceptable. | Déterminisme | Le même prompt peut produire des sorties différentes. | Coût à l'échelle | Par -combinaisons de prix en tonnage avec volume Même si un modèle de frontière pouvait produire avec fiabilité une sortie correcte 99.9% du temps , vous avez encore besoin: - Validation pour capturer le 0.1% - Retours lorsque la validation échoue - Enregistrement pour comprendre ce qui s'est passé - Metriques pour suivre la dérive au fil du temps Il s’agit là de la couche de constérisseur. La différence réside dans le fait que vous la bâtissez ou non. *précédemment* les échecs vous expliquent pourquoi cela est important *après*. Constrained Fuzziness dit : construisez-le d’abord. Ensuite, la taille du modèle devient une option de déploiementM SK3 pas un modèle architecturalMSC4 Un modèle B avec de bonnes contraintes outrepasse souvent un modèle frontalier avec de mauvaises. Changements dans le choix du modèle *• le nombre d’heures consacrées à l’éducation* Il n’y a pas de contrainte à l’utiliser. ## Mise en œuvre de l'incertitude restreinte ### 1. Définir vos invariantes Qu'est-ce qui doit **Aucune fois** être violée? ```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; } } ``` Les invariantes communes comprennent: - Aucune réclamation sans indicateurs de preuve - Aucune couleur à moins d'être dérivée des statistiques de la palette - Aucune émission de PII - Aucune écriture, seule lecture-seulement SQL - Aucune attribution d'identité à moins qu'elle ne soit explicitement justifiée ### 2. Fixer des budgets rigoureux Qu'est-ce qui doit **toujours** être restreint? ```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)) { } } ``` Le budget n’est pas une suggestion, c’est un brise-circuit. Lorsque le budget est dépassé, le système se dégrade gracieusement plutôt que de continuer à brûler les ressources. ### 3. Construisez vos types de portes Le constrainer ne rejette pas seulement le ', mais aussi celui du .. *réécrire* ("moyenne", "incerteM SK3MSC4 fondée sur les éléments de preuve disponiblesMNK5 ou retire entièrement des allégations non corroboréesMRK6 La réécriture préserve le signal tout en retirant la surconfidenceMMK7 permettant aux systèmes d’être utiles sous l’incertitude plutôt que dans une situation fragileMKK8 QueMEK9est la partie distinctiveMZK10 ilMGK11il ne s’agit pas de validation des intrantsMTK12 il\'la gouvernance de la productionMKZ14 Constrainers communs que vous reutiliserez dans tous les systèmes **Porte Schema**Validation du type + ```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); } } } ``` **Porte des preuves**: Chaque revendication doit être liée aux tronçons de source ```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 }; } } ``` **Porte des politiques**:Privacy/Règles de sécurité **Porte budgétaire**: TempsM SK1computation /caps de tocène **Réécrire la porte**: Transformer les affirmations en déclarations garanties ### 4. Définir le traitement des défauts Lorsque la partie floue échoue, don 't crashM SK2 Degrade: ```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); } } ``` Principes clés: - Dégrader gracieusement à un mode déterministe-seulement - Retour de la sortie partielle avec des marqueurs d'incertitude explicites - Inscrire des propositions invalides en tant que signaux de formation pour une évolution rapide ## Exemples du monde réel- ### LLM-Systèmes basés (BriefM SK2 | Système | Sous-strate |--------|-----------|----------|---------| | **DocSummarizer** | BERTM SK1 Extraction de blocs RAG | Synthèse narrative du LLM | Validateur de la citation \ les revendications doivent être citées `[chunk-N]`) | | **Caption de l'image** | Palette ImageSharp/métriques |FlorenceM SK3Titre de l'LLaVA | Les revendications relatives aux couleurs doivent correspondre à la palette calculée S| | **Système de gestion des données** | Système du DuckDB | LLM → SQL S| Aucune écriture M, liste d'autorisations de table R| | **Analyse des médias** | Timbre des scènesM SK1 transcription | Feuille de beat du LLM Le modèle est toujours le même. ### Détection des bottes: Exemple non -LLM *Cette section est intentionnellement détaillée parce qu’elle montre le modèle sans aucun LLM.* Mon système de détection des robots ([Mostlylucid.BotDetection](https://www.nuget.org/packages/Mostlylucid.BotDetection)) démontre que la fuzziness restreinte n’est pas limitée à des systèmes basés sur le LLMM SK2 . C’est là qu’un ensemble de détecteurs héuristiques avec pondérations apprises est proposé par ,. **Les trois couches:** - **Sous-strate (Layer de la véritéM SK1**: Les détecteurs individuels calculent les signaux objectifs des demandes HTTP - Analyse de l'agent d'utilisateur: `ua.is_bot`, `ua.contains_automation_keyword` - Analyse des titres: `hdr.accept_language_count`, `hdr.missing_standard_headers` - Analyse IP: `ip.is_datacenter`, `ip.reputation_score` - Analyse comportementale: `beh.requests_per_minute`, `beh.path_entropy` - **Proposition (Layer de créativitéM SK1**: Le modèle héuriste regroupe les signaux par sigmoïde pondéré ```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)); ``` - **Conducteur (Layer de contratM SK1**: Le moteur de la politique impose des seuils et des mesures rigoureuses ```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 ); ``` **Le point de vue clef: Les détecteurs fournissent des preuves, Aucun verdict** Chaque détecteur contribue à la décision finale sans prendre sa propre décision. `DetectionContribution` captures de dossiers: - `ConfidenceDelta`: Combien cela pousse vers le robot (+) ou l’humain МSK2 - `Weight`: Combien d'influence a ce détecteur? - `Signals`: Les faits calculés - `Reason`: HommeM SK1explication lisible Cette séparation signifie que vous pouvez - Ajouter/d'enlever les détecteurs sans changer la logique d'agrégation - Poids de tune indépendants de la logique de détection - Apprenez les poids optimaux à partir de la rétroaction au fil du temps **É Escalation facultative du LLM** Voici' c'est là où il devient intéressant : le modèle supporte **escalation facultative à LLM** lorsque le modèle héuristique est incertain. Cette configuration se fait par l’entremise de la politique: ```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 }; ``` Lorsque l’escalade déclenche le score, la LLM reçoit les signaux accumulés et fournit une analyse linguistique naturelle, mais le constrainer continue d’imposer des seuils. **Orchestre basé sur la vague-** Le système fait fonctionner des détecteurs dans les vagues, avec des vagues ultérieures déclenchées par des signaux antérieursM SK1 ```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 ``` Il s'agit de confusion restreinte avec **éclaration progressive**: les héuristiques peu coûteuses traitent des cas clairs , l’AI coûteuse traite des cas étroits M SK2 et la politique impose des contraintes à chaque étape . **Apprentissage sans risque** Puisque le constrainer impose la sécurité indépendamment de ce que les détecteurs produisent, le système peut apprendre en toute sécurité. ```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; ``` Les pondérations convergent vers des tendances réelles au fil du temps. élevées- les observations de confiance ont plus d’incidence . Mais une mauvaise mise à jour du poids ne peut jamais causer un préjudice incontrôléM SK3 Les seuils de politique continuent d’être appliqués **Pourquoi cela importe?** BotDetection prouve que l’incertitude restreinte n’est pas 't liée aux LLMs spécifiquement . ElleM SK2 est liée à tout système où: 1. Il faut combiner plusieurs signaux incertains 2. Différents signaux ont une fiabilité différente 3. Les contraintes strictes doivent être imposées indépendamment des points obtenus 4. Le système devrait apprendre et s'améliorer au fil du temps. 5. L'analyse coûteuse ne devrait être effectuée que lorsque l'analyse peu coûteuse est insuffisante. Le LLM n'est qu'un élément flou possible. ## Quand ne pas utiliser la fuzziness restreinte Le modèle comporte un coût. **Passer quand:** - **La tâche est entièrement déterministe.** Si vous pouvez écrire `if X then Y`, vous n’avez pas besoin d’un promoteur ' il n’y a pas lieu de proposer - **You're prototyping.** Vous ne savez pas ce que les contraintes signifient. - **La sortie est disposable.** Brainstorming, DraftsM SK1 creative exploration : if a human reviews everything anyway, the constrainer is redundantMSC4 - **Les défaillances occasionnelles sont acceptables.** Si 5% le taux d’allucination est bon pour votre cas d’utilisation , le coût de l’ingénierie des contraintes peut dépasser le coût des défaillances - **Vous n'avez pas de substrat.** Si vous pouvez' ne pas calculer la vérité fondée , vous pouvez–' ne l’empêcherM SK3 Ne pas la fausser' ne rien faire de fauxMSC5 Vous devez soit trouver des faits computables, soit accepter le flou. **Le modèle est pour les systèmes où:** - Les résultats probabilistes atteignent les utilisateurs ou d'autres systèmes sans examen humain - Les défaillances sont silencieuses, coûteuses , ou composées - Vous devez apprendre à évoluer sans risquer la production Si ce n’est pas votre situation, les approches plus simples gagnent. ## Intégration avec les systèmes évolutifs Constrained Fuzziness devient encore plus puissant lorsqu’il est combiné avec DiSE (Evolution synthétique dirigéeM SK1 Patterns . Parce que vous pouvez attribuer des points aux candidats de façon peu coûteuse et déterministe: 1. **Générer** plusieurs propositions non claires 2. **Valider** contre les invariantes 3. **Sommaire** basée sur les mesures de satisfaction des contraintes + 4. **Maintenir** la meilleure , jeter le reste 5. **Accumuler** Défaillances en tant que signaux de formation pour une évolution rapide Le point de vue clé: **vous pouvez élaborer la proposition sans risquer le système**, parce que le constrainer assure la sécurité et l’exactitude, indépendamment de ce qu’il produit ```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; } ``` ## Définition de l’une-Sentence > "Constrained Fuzziness est la pratique consistant à laisser les composantes probabilistes proposer leur signification alors que les systèmes déterministes exécutent la vérité , la sûreté M SK2 et les budgets à chaque frontière ." ## Conclusion : Le gouverneur, Non le moteur Retour à ce cache LRU qui est devenu plus intelligent lorsqu’il a épuisé la mémoire. La solution consistait à ', ce qui ne lui donnait pas plus de capacité. **permettre à la contrainte de faire son travail**. La taille restreinte a forcé la sélection . L’expiration slidante a forcié à perdre de vue M SK2 Ensemble , ils ont créé l’apprentissage MSC4 C’est là l’incertitude clé: **Vous ne fixez pas les systèmes probabilistes en les faisant *moins* probabiliste**. Vous les réglagez en ne permettant pas à la probabilité d’échapper aux garanties. ```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 ``` Le moteur à vapeur ne comprend pas 't " comprendre " il ne devrait pas exploder ' le gouverneur l’empêche physiquement Le même modèle. Centenaire différentM SK1 La prochaine fois que vous 'êtes tentés d’ajouter un autre paragraphe à votre prompt de système, dans l’espoir que le modèle comprendra les contraintes "understand" a constraintMSC3 stopM SK4 Demandez plutôtMST5 *Puis-je calculer cette contrainte?* Si oui, le calculer. alors le constrégner sur ce modèleM SK2 Les limites strictes battent les suggestions douces. Chaque foisM SK1 --- ## La série | Partie | Pattern MSC2 Axe MSC3 |------|---------|------| Composante unique | | 2 | [MoM Fuzzy restreint](/blog/constrained-mom-mixture-of-models) | Composantes multiples | | 3 | [Traçage de contexte fuzzy restreint](/blog/constrained-fuzzy-context-dragging) | Temps / mémoire | | 4 | [Sommaire de l'image](/blog/constrained-fuzzy-image-intelligence) | Mise en œuvre pratique | **Partie 2** Cette architecture s’étend à plusieurs systèmes d’agents. Les modèles ne parlent pas les uns avec les autres. Ils publient des signaux types sur un substrat partagé. **Partie 3** Les modèles peuvent remarquer ce qui persiste, mais l’ingénierie décide ce qui demeure. **Partie 4** montre les trois modèles mis en œuvre dans [ImageSummarizer](https://github.com/scottgal/lucidrag)—une vagueM SK1basée sur un pipeline d'analyse de l'image où ColorWave calcule les faits , VisionLlmWave propose, et la sélection déterministe limite le résultatMSC4