# स्टिलियोबोट रिलेस शृंखला

*हेड्स अप: यह एक तंत्रिकाओं के लिए है. यहM SK2 स्टिलियोबोट में एक गहरी तकनीकी डुबोकी है ' अनुकूलन सीखने की प्रणाली। `Mostlylucid.BotDetection` और समान मशीन के लिए संकेतक। <s> -<s> सीखने का निर्माण करता है ताकि ML पाठकों को एक प्रविष्टि बिंदु प्राप्त हो।*

> ## ड्राफ्ट
> 
> यह स्टीलोबोट रिलीज श्रृंखला में एक कार्यशील ड्राफ्ट है

> **स्टिलियोबोट रिलेस शृंखला**
> 
> 1. [**व्यवहार, पहचान नहीं**](/blog/stylobot-fingerprint) - क्यों StyloBot ग्राहक व्यवहारिक रूप से मॉडल करता है
> 2. [**व्यवहार-Aware ASP.NET UI**](/blog/behaviour-aware-ux) - सर्वर\-\ऐसे पता लगाने के परिणाम पर सतह दे दिया
> 3. [**लंबे समय तक चलाने वाले नेट सेवाओं में असीमित विकास का पता लगाना और स्थिर करना**](/blog/stylobot-release-reliability) - विश्वसनीयता अनुशासन जो उत्पादन में इंजन को नीरस बनाए रखता है
> 4. [**व्यवहार-Aware TypeScript UI**](/blog/typescript-sdk) - Express , Fastify, और ब्राउज़र घटक
> 5. [**साइडकार वास्तुकला**](/blog/sidecar-architecture) - कैसे पता लगाने की इंजन गैर--.NET स्टाक से जुड़ता है
> 6. **तेजी से सीखना** अनुकूलन सीखने की प्रणाली
> 7. [**उस चीज़ का परीक्षण जो सफल नहीं हो रही है**](/blog/stylobot-release-nondeterministic-testing) - सत्यापन अनुशासन
> 8. [**स्टिलियोएक्सट्रैक्ट - एक स्थानीय सीखने के HTML को मार्कडाउन रूपांतरक में**](/blog/stylobot-release-styloextract) - एचटीएमएल\→\मार्कडाउन परत जो डिटेक्टर के साथ जोड़ता है\,\walker bug lucidVIEW पकड़ा\M SK3\ और कुत्तेfood लूप कि यह ईमानदार बना

<!--category-- ASP.NET, StyloBot, Bot Detection, Performance, Machine Learning -->
<datetime class="hidden">2026-05-13T11:00</datetime>

व्यवहार मॉडल में है [व्यवहार, पहचान नहीं](/blog/stylobot-fingerprint); विश्वसनीयता अनुशासन में [असीमित विकास का पता लगाना और स्थिर करना](/blog/stylobot-release-reliability); स्रोत पर [github.comM SK1scottgal/stylobot](https://github.com/scottgal/stylobot).

[TOC]

---


## StyloBot इस के साथ परेशानी क्यों करता है

स्टिलियोबोट का सारा काम है मानव को बूट्स से बताना-वह करता है-, और सबसे बुनियादी स्तर पर यह ऐसा करता है कि एक औसत बूट कैसा दिखता है और एक औसत आदमी क्या दिखता हैं, इसका चित्र बनाकर। **यथार्थता पहली बार बेहतर होती है** (इस के क्लस्टरिंग पक्ष में शामिल है [व्यवहार, पहचान नहीं](/blog/stylobot-fingerprint)इस पोस्ट के बारे में है कि एक बार आप उन्हें centroids के साथ क्या होता है

यह तंत्र भी है जो StyloBot को मूर्खता से अलग स्थानों में लागू करने योग्य बनाता है।

एक डिटेक्टर जो प्रत्येक अनुरोध पर पूरी पाइपलाइन चलाता है पूरी तरह से, लेकिन कम लागत वाला है।

इस स्थान में अधिक परिचित नामों के विरुद्ध संदर्भ हेतु

| | स्थानांतरण | | | प्रति- | अनुरोध लागत || | क्या आप वापस पाते हैं
|---|---|---|---|
क्लाउडफ्लेर बोट प्रबंधन
CHEQ / डेटाडॉम | | | सर्वर |- | साइड API कॉलआउट |
| स्टेलोबोट **~10-50 μs** Skip के माध्यम से गर्म किया गया **400-900 μs** पूर्ण तीव्र पथ पाइपलाइन चलाने के लिए`BotProbability`, `Confidence`, `RiskBand`, `ThreatScore`directly in your handler |

किनारे उत्पाद मूल से पहले ब्लॉक में महान हैं। "; क्या वे नहीं कर सकते है अपने अनुप्रयोग को एक प्रति-- अनुरोध संभाव्यता प्रदान करना और आपके चेकआउट पृष्ठ को यह तय करने के लिए कि उससे क्या किया जाना चाहिए।

लिवर जो कैश को सुरक्षित करता है यह है **नीति**. निर्णय कैश एक द्वारा नियंत्रित होता है `SignatureCacheOptions` रिकॉर्ड करता है कि \'\s पर सेट करता है \ -\ policy \ , \ so an admin endpoint can demand | 0.95 \ confidence and a 60- \ second freshness window while a content path accepts |0.7 | confidence over an hour \. \ Same code \ {\displaystyle \mathbf {,}\,\ } different knobs \ (विभिन्न नोब्स) \ [ASP.NET मध्यware](/blog/behaviour-aware-ux), एक के रूप में [जीआरपीसी पार्श्वगाड़ी](/blog/sidecar-architecture)Caddy प्लगइन के पीछे की प्रक्रिया में , या मे

इस पोस्ट का बाकी मशीनरी है जो कैश को सुरक्षित करता है।

## मेटास्टेबल अंगुल छाप

Everything below anchors to "the fingerprintM SK1 so it'it's worth being precise about what that means here. [व्यवहार, पहचान नहीं](/blog/stylobot-fingerprint)TLS पर रेखांकन *व्यवहारिक* बदलें: एक भिन्न पथ अनुक्रम

जो अंगुलियों की छाप बनाता है **मेटास्टबल**स्थिर enough that an actor remains recognisable across short

यह गुण है कि पूरी सीखने की प्रणाली पर अवलंबित होती है. यदि अंगुलियों के अंक शोरपूर्ण होते हैं | ( | हर अनुरोध किसी जगह अनियमित ढंग से उतरता है |) EWMA औसतन कुछ भी नहीं Sharpen करेगा और कैश हमेशा गलत होगा | *और* drift पहचाना जा सकता है क्योंकि वास्तविक परिवर्तन किसी अन्य स्थिर पृष्ठभूमि के खिलाफ गति के रूप में दिखाई देता है

इस गुण को क्यों रखने के लिए संरचनात्मक तर्क (मानव ध्वनियुक्त, लेकिन संरचना में सुसंगत है, लेकिन रचना में गलत है [**व्यवहार, पहचान नहीं**](/blog/stylobot-fingerprint), और यदि यहाँ ज्यामिति में से कोई भी स्पष्ट नहीं है कि यह लेख पहले पढ़ने के लिए है *एक बार* यह दावा हाथ में है

## thesis: detection should get better and cheaper the more you see

प्रत्येक अवलोकन दो बातें करता है-: यह केंद्रक को तीक्ष्ण बनाता है यह अंगुठा छाप के लिए आता है ( अक्षरता ), और यह प्रणाली को ऊँचा करता है \' \ यह विश्वास कि यह अंगूठा छाप उस केंद्रक की तरह व्यवहार करता है जो गति सक्षम करता है\). \ एक अनुकूलन डिटेक्टर का हार्ड हिस्सा यह दोनों कर रहा है बिना पुराने गलतियों को स्थायी बनना छोड़ देता है\ .

एक बोट डिटेक्टर को दिन में लाखों बार एक ही महंगा सवाल पूछा जाता है *यह अभिनेता अभी भी हम पहले से ही सीखा था की तरह व्यवहार कर रहा है यह था* इन अनुरोधों के बहुत अधिकतर के लिए, सिस्टम को पहले से ही एक राय है. यह एक ही TLS अंगुली छाप देखा थाMSC2 एक ही शीर्षिका क्रमM SK3 एक समान उपयोगकर्ताMST4 अभिकर्ता परिक्रमण पैटर्नMSP5 दस मिनट पहले एक ही आईपी पड़ोसMSM6 और निष्कर्षित `bot, 0.93`वहाँ एक ही कर्ता पर पूरा पता लगाने की पाइपलाइन फिर चलाने का कोई बिंदु नहीं है जब तक कि उस कर्ता के बारे में कुछ प्रत्यक्ष रूप से बदल गया है

StyloBot' सीखने की प्रणाली उस विचार के चारों ओर निर्मित है। *केंद्रक बनाता है और परिष्कृत करता है* पहले स्थान पर. जब पाइपलाइन नहीं चलाता है, तो यंत्रित परिस्थितियों में पिछला स्थानन पुनः प्रयोग किया जाता है।

> **एक ओर ML** यह है **अनुकूलन संगणना** तंत्रिका नेटवर्क में [आरंभिक](https://arxiv.org/abs/1709.01686),\ Mixture\ -\ of\-\ Experts gating\ M SK3\ cheap classifier first\ ,\ expensive classifier only when the cheap one\ MSC5\ its confidence is low\ MST6\ The detector pipeline is the expensive inference path\ MSP7\ per\ MSV8\ fingerprint cache is the cheap MSV9\ did we already learn this

## स्मृति के चार स्तर

स्टिलियोबोट में सीखना परतबद्ध है इसलिए प्रत्येक स्तर एक अलग जीवनकाल के लिए अनुरूप होता है

1. **त्वरित** इस रूप में वर्गीकृत नमूने की एक संक्षिप्त सूची `ConfirmedBad` में `PatternReputation` भंडारित करें. इनमें से एक के अनुरूप एक अनुरोध प्राथमिकता पर पाइपलाइन को छोड़ता है 3 किसी अन्य डिटेक्टर चलाने से पहले
2. **इंट्राः-request ब्लैकबोर्ड** डिटेक्टर साझा में संकेत लिखते हैं `BlackboardState.Signals` अनुरोध के दौरान sink; बाद में डिटेक्टर उन संकेतों को पढ़ते हैं।
3. **इंटर-request reputation (minutes to days** पैटर्न `InMemoryPatternReputationCache` प्रति ट्रैक्स EWMA ऑनलाइन अद्यतन और समय विघटन के साथ पैटर्न बोट स्कोर्स `ReputationState` (`Neutral` → `Suspect` → `ConfirmedBad`, प्लस `ConfirmedGood`, `ManuallyBlocked`, `ManuallyAllowed`) असमित संवर्धन और निष्कासन थ्रेसहोल्डों के साथ
4. **Per-fingerprint verdict cache (minutesM SK2** Per-actor memory: में जीवंत स्लाइडिंग विंडो `SignatureCoordinator` प्रत्येक पर्यवेक्षण अंगुलियों का अंकन करता है। `SignatureVerdictGate.DecideAsync` प्रत्येक अनुरोध पर यह पढ़ता है.

टियर 1 छोटा\-पाईपलाइन को परिपथित करता है\.\ टियर () \ 2\ इसके भीतर समकक्ष होते हैं\M SK4\ टयर () {\displaystyle ()} 3\ दिनों में जीवित रहने वाला लंबा स्मृति होती है\

```mermaid
flowchart LR
    classDef input fill:none,stroke:#3b82f6,stroke-width:2px
    classDef fast fill:none,stroke:#22c55e,stroke-width:2px
    classDef async fill:none,stroke:#a855f7,stroke-width:2px
    classDef store fill:none,stroke:#f59e0b,stroke-width:2px

    REQ["Incoming request<br\>(TLS fingerprint, headers, IP)"]:::input
    T1["Tier 1 · Fast-path reputation<br\>ConfirmedBad list<br\>priority 3, pre-pipeline"]:::fast
    T2["Tier 2 · Intra-request blackboard<br\>BlackboardState.Signals<br\>lifetime: one request"]:::async
    T3[("Tier 3 · PatternReputation<br\>EWMA + state machine<br\>lifetime: minutes to days")]:::store
    T4[("Tier 4 · SignatureCoordinator<br\>sliding window<br\>lifetime: minutes")]:::store
    PIPE["Detector pipeline<br\>(BlackboardOrchestrator)"]:::async
    OUT["Verdict"]:::fast

    REQ --> T1
    T1 -->|match| OUT
    T1 -->|no match| T4
    T4 -->|Skip| OUT
    T4 -->|Miss / Bias / Watchdog| PIPE
    PIPE <--> T2
    PIPE <--> T3
    PIPE --> T4
    PIPE --> OUT
```

## EWMA: कैसे सिस्टम भूलता है

सिस्टम में प्रत्येक संख्यात्मक स्मृति में एक ही अद्यतन नियम का उपयोग करता है `Helpers/Ewma.cs`:

```csharp
public static class Ewma
{
    /// <summary>new = (1 - alpha) * previous + alpha * observation</summary>

    public static double Update(double previous, double observation, double alpha)
        => (1.0 - alpha) * previous + alpha * observation;
}
```

यह पूरी बात है `alpha` नए अवलोकन पर भार है `1 - alpha` पिछली काल की जड़ता है

पैटर्न प्रतिष्ठा इसे सीधे उपयोग करता है `PatternReputationUpdater.ApplyEvidence`:

```csharp
// EMA update: alpha clamped to [0,1] preserves EMA semantics (alpha > 1 inverts
// the old score contribution).
var alpha = Math.Min(_options.LearningRate * evidenceWeight, 1.0);
var newScore = Ewma.Update(decayed.BotScore, label, alpha);
```

`LearningRate` defaults to 0.1, so a single observation moves the score by 10% of the gap to that observation

> **एक ओर ML** EWMA = क्लासिक [एक्सपोनेन्शल गतिशील औसत](https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average) जो दिखाता है [आदम](https://arxiv.org/abs/1412.6980) (the `β₁`, `β₂` गति और विपरिवर्तन संग्राहक [पॉलिक औसत](https://en.wikipedia.org/wiki/Stochastic_approximation)बैच सामान्य चल औसत में ,variance [TD(0) मूल्य अद्यतन](https://en.wikipedia.org/wiki/Temporal_difference_learning) (`V ← V + α(r + γV' - V)`). `α = 0.1` यहाँ वही रेंज में है जो आप देख सकते हैं गति बफर के लिए ' slow enough that one bad observation can

हमने इस अद्यतन को स्पष्ट से ऊपर उठाया, लेकिन, अधिकतम संभाव्यता को दर्शाने के गलत विकल्प को भंडारित करने के लिए, एमएसके0, परन्तु, एम्सके1, इतिहास भंडार में एक अधिकतम, एम एसके4 का अधिकतम, एक एकल स्पाइक पिन एक नमूना को हमेशा के लिए एमएसका6 पर छोड़ देता है।

क्षय स्वयं नमूने तक विस्तारित होता है `ReputationOptions` कोड से डिफ़ॉल्ट

```csharp
public double ScoreDecayTauHours { get; set; } = 3;             // generic
public double SupportDecayTauHours { get; set; } = 6;
public double ConfirmedBadScoreDecayTauHours { get; set; } = 12; // ConfirmedBad
public double ConfirmedBadSupportDecayTauHours { get; set; } = 24;
public int GcEligibleDays { get; set; } = 90;
```

एक दिन में नहीं देखा गया है कि एक नमूना अपने समर्थन का अधिकांश खो दिया है। `Neutral` कूड़ा है `ConfirmedBad` patterns get a longer tau (they earned their status through strong evidence and shouldn

> **एक ओर ML** प्राप्ताङ्क-DecayM SK1toward-prior step is first [ओर्नस्टाइन](https://en.wikipedia.org/wiki/Ornstein%E2%80%93Uhlenbeck_process) आकार): कोई नया साक्ष्य नहीं है, अंक दर पर पूर्व की ओर वापस लेता है `1/τ`.

हाइस्टेरेसिस राज्य मशीन में निर्मित है `ReputationOptions`:

| संक्रमण | स्कोर थ्रेसहोल्ड
|---|---|---|
| `Neutral → Suspect` | ≥ 0.6 | ≥ 10 |
| `Suspect → ConfirmedBad` | ≥ 0.9 | ≥ 50 |
| `Suspect → Neutral` | ≤
| `ConfirmedBad → Suspect` | ≤
| `Neutral → ConfirmedGood` | ≤ 0.1 | ≥ 100 |

```mermaid
stateDiagram-v2
    direction LR
    [*] --> Neutral
    Neutral --> Suspect : score &ge; 0.6<br/>support &ge; 10
    Suspect --> ConfirmedBad : score &ge; 0.9<br/>support &ge; 50
    Suspect --> Neutral : score &le; 0.4
    ConfirmedBad --> Suspect : score &le; 0.5<br/>(support &ge; 100 OR<br/>support &lt; 50)
    Neutral --> ConfirmedGood : score &le; 0.1<br/>support &ge; 100
    ConfirmedBad --> [*] : 90 days unseen<br/>+ neutral + low support
    Neutral --> [*] : 90 days unseen<br/>+ low support

    note left of ConfirmedBad
        Fast-path eligible
        (Tier 1 short-circuit)
    end note
    note right of Neutral
        Promote at score 0.9 / sup 50
        Demote at score 0.5 / sup 100
        Wider gap = oscillation-resistant
    end note
```

promote थ्रेसहोल्ड (0.9) और demote थ्रेस्होल्ड `ConfirmedBad` है जानबूझकर : यह \ ' \ s एक oscillation | - | suppression band \ . | Anything that flips between `Suspect`केवल एक दिशा में पाया गया प्रमाण सीमा को पार करता है

> **एक ओर ML** यह एक है [स्मिट ट्रिगर](https://en.wikipedia.org/wiki/Schmitt_trigger)राज्य संक्रमण के लिए symmetric थ्रेसहोल्ड्स

## आप अर्जित करने के लिए verdict cache: गति

per-fingerprint स्लाइडिंग विंडो परत है जो अनुरोध गर्म पथ अब सीधे परामर्श करता है `SignatureVerdictGate.DecideAsync` पूरा निर्णय है और यह

```csharp
public async Task<GateDecision> DecideAsync(
    string? signature, SignatureCacheOptions options, CancellationToken ct = default)
{
    if (!options.Enabled || string.IsNullOrEmpty(signature))
        return new GateDecision(GateAction.Miss, null);

    var verdict = await _coordinator.TryGetVerdictAsync(signature, ct);
    if (verdict is null)
        return new GateDecision(GateAction.Miss, null);

    if (verdict.Confidence < options.BiasMinConfidence)
        return new GateDecision(GateAction.Miss, verdict);          // too noisy

    var ageSeconds = (DateTime.UtcNow - verdict.LastSeenUtc).TotalSeconds;

    var skipEligible =
        verdict.Confidence >= options.SkipMinConfidence
        && ageSeconds <= options.SkipMaxAgeSeconds;

    if (skipEligible && !ShouldRefresh(signature, options.SkipSamplingRate))
        return new GateDecision(GateAction.Skip, verdict);          // cache hit

    var biasEligible = ageSeconds <= options.BiasMaxAgeSeconds;
    return new GateDecision(biasEligible ? GateAction.Bias : GateAction.Miss, verdict);
}
```

per-policy थ्रेसहोल्ड्स से `SignatureCacheOptions` डिफ़ॉल्ट दिखाया गया

```csharp
public double SkipMinConfidence { get; init; } = 0.85;
public int    SkipMaxAgeSeconds { get; init; } = 300;        // 5 min
public double BiasMinConfidence { get; init; } = 0.30;
public int    BiasMaxAgeSeconds { get; init; } = 86_400;     // 24 h
public double SkipSamplingRate  { get; init; } = 0.05;       // 5 %
```

विश्वास स्वयं में व्युत्पन्न होता है `SignatureCoordinator.TryGetVerdictAsync` नमूना आकार से , पूर्ण विश्वास के साथ 10 अवलोकनों और रेखात्मक रम्प नीचे | : |

```csharp
var confidence = Math.Min(1.0, behavior.RequestCount / 10.0);
```

तो `SkipMinConfidence = 0.85` का अर्थ है कि एक अंगुली छाप को ~9 वर्तमान विंडो में अवलोकनों की आवश्यकता होती है इससे पहले कि यह Skip हो सकता है

चार कार्य

- **मिस** इस अंगुल छाप के लिए कोई उपयोग योग्य रिकार्ड नहीं है `BiasMaxAgeSeconds`. पूरी डिटेक्टर पाइपलाइन चलाता है
- **पक्षपात** एक रिकार्ड में मध्यम विश्वास के साथ मौजूद है।
- **Skip** रिकार्ड हाल ही में है और इतना विश्वास है कि पाइपलाइन योगदान सीमांत होगा
- **वॉचडोग** Skip-eligible cache hit, but the variance watchdog detected something atypical

```mermaid
flowchart TD
    classDef input fill:none,stroke:#3b82f6,stroke-width:2px
    classDef decision fill:none,stroke:#f59e0b,stroke-width:2px
    classDef fast fill:none,stroke:#22c55e,stroke-width:2px
    classDef slow fill:none,stroke:#a855f7,stroke-width:2px
    classDef trip fill:none,stroke:#ef4444,stroke-width:2px

    REQ["Request arrives"]:::input --> LOOKUP{"TryGetVerdictAsync<br\>(sliding window<br\>+ family fallback)"}:::decision
    LOOKUP -->|"null OR low-conf OR stale"| MISS["MISS<br\>full pipeline"]:::slow
    LOOKUP -->|"record found"| CONF{"conf ≥ 0.85<br\>+ age ≤ 300s?"}:::decision
    CONF -->|"no"| BIAS["BIAS<br\>pipeline + prior contribution"]:::slow
    CONF -->|"yes"| REFRESH{"In 5% refresh<br\>(hash bucket)?"}:::decision
    REFRESH -->|"yes"| BIAS
    REFRESH -->|"no"| WD{"VarianceWatchdog<br\>OK?"}:::decision
    WD -->|"tripped"| TRIP["WATCHDOG-TRIP<br\>X-StyloBot-VerdictSource = pipeline<br\>X-StyloBot-WatchdogTrip = reason"]:::trip
    WD -->|"ok"| SKIP["SKIP<br\>X-StyloBot-VerdictSource = cache<br\>orchestrator bypassed"]:::fast

    MISS --> UPDATE[("Update sliding window<br\>+ RecordObservation")]:::slow
    BIAS --> UPDATE
    TRIP --> UPDATE
    SKIP --> UPDATE
```

मिडलवेयर बाहर निकलता है `X-StyloBot-VerdictSource` (`cache` या `pipeline`) और `X-StyloBot-WatchdogTrip` जब लागू हो तो (reason string

Skip क्या होता है जब वहाँ कोई नया सीखने के लिए कुछ नहीं है।

## एक योगदान के रूप में फ़ैश निर्णय नहीं

पुनर्प्राप्ति यांत्रिकी में प्रवेश करने से पहले-, फ्रेमिंग जो उन्हें सुसंगत बनाता है-: कैशित निर्णय एक भंडारित उत्तर नहीं होता है सिस्टम अंधेरी रूप से पुनः उपयोग करता है। *अंशदान*, विश्वास और आयु द्वारा भारित `FingerprintPriorContributor.ContributeAsync` पूरी मशीन है

```csharp
var horizon = AgeDecayHorizon;                                 // default 86,400s
var decay = horizon > 0.0 ? Math.Max(0.0, 1.0 - age / horizon) : 1.0;
var effectiveWeight = conf * WeightMultiplier * decay;

if (effectiveWeight <= 0.0) return _emptyResult;

var delta = 2.0 * (prob - 0.5);   // map [0,1] probability to [-1,+1] confidence delta

var contribution = new DetectionContribution
{
    DetectorName = DetectorName,
    Category = DetectorName,
    ConfidenceDelta = delta,
    Weight = effectiveWeight,
    Reason = $"Cached fingerprint verdict (prob={prob:F2}, conf={conf:F2}, age={age:F0}s)"
};
```

एक 30-सेकेंड-सेकेण्डसेकेन्डसेकेंन्डसेमेंअभिज्ञतापूर्वककानिर्णय-0.9सेकेल्डसेकेन्जरसेअभिभिज्ञततापूर्वकअभिन्नसेकेबलसेकेकण्डसेमेनेअभिध्य्य्य्यीय्य्यय्य्य्या4सेकेंडरसेकेनियरसेकेपर्य्यिय्या5सेकेयनियरसेसेकेनरसेकेडीईसेकेपीडीईसीपीडीएपीडीआईसीपीटीपीडीडीईसापीडीजीपीडीटीपीटीटीपीपीडीएफपीडीपीडीएमएसीपीडीओपीडीएलपीडीएनडीईपीडीयूपीडीएसआईपीडीसीपीजीपीटीबीडीई पीडीई सीपीडी आईपीडी एपीडीआरपीडी ईपीडी आइपीडी एनडीईआईपीटीआईपी डीईपीआईपीजी बीडीआईपीडाईपीडी टीईपीटीईपीजी वीडीआई पीडीआईटीपीजी पीडीडीआईआईपीपीजी जीडीआईवीपीडी

> **एक ओर ML** यह वास्तव में है **बेयसी**पहले (कैच किया गया निर्णय | ) |× | संभाव्यता | ( | यह अनुरोध | ' | साक्ष्य | ) | → | posterior `decay = 1 - age/horizon` शब्द एक भूलकारक के रूप में एक ही भूमिका निभाता है [पुनरावर्ती बेयजियन अनुमान](https://en.wikipedia.org/wiki/Recursive_Bayesian_estimation); पुराने पूर्ववर्ती शक्ति खोते हैं तो संभावना पहले आयु के रूप में प्रभुत्व रखता है `RequestContributionDelta` (यह अनुरोध किया गया परिवर्तन चलती पीछला पेजरी के लिए नहीं कच किए गए निर्णयों पर कच्चे per\-request संभाव्यता के बजाय `delta` यह हिस्सा है कि वास्तव में नया सूचना है

## कैसे गलत सकारात्मक don't संयोजन

इस बिंदु तक सिस्टम खतरनाक रूप से कैश ध्वनि देता है।

```mermaid
flowchart TD
    classDef store fill:none,stroke:#f59e0b,stroke-width:2px
    classDef defense fill:none,stroke:#22c55e,stroke-width:2px
    classDef recover fill:none,stroke:#a855f7,stroke-width:2px

    CACHE[("Cached verdict<br\>(EWMA posterior + sample count)")]:::store

    D1["Direction-agnostic confidence<br\>caches confident verdicts,<br\>not just bot verdicts"]:::defense
    D2["EWMA, not MAX<br\>one spike contributes 10%,<br\>not 100%"]:::defense
    D3["Sample-size gating<br\>full trust at 10 samples,<br\>Bias below that"]:::defense
    D4["Variance watchdog<br\>IP rotation, rate spike,<br\>path divergence"]:::defense
    D5["Skip-path observation<br\>cache hits still record,<br\>history stays whole"]:::recover
    D6["Refresh sampling<br\>5% of Skips downgraded<br\>to Bias by signature hash"]:::recover

    D1 --> CACHE
    D2 --> CACHE
    D3 --> CACHE
    D4 --> CACHE
    D5 --> CACHE
    D6 --> CACHE
```

**दिशा** `SkipMinConfidence` के विरुद्ध जाँच किया जाता है `verdict.Confidence`, के खिलाफ नहीं `verdict.BotProbability`. एक निश्चित--बॉट निर्णय और एक निश्चित–-मानव निर्णय समान रूप से Skip के लिए पात्र हैं। *विश्वासी* निर्णयों" (प्रणाली किसी भी तरह के साक्ष्य की ओर पक्षपात करती है

**EWMA, नहीं MAX.** एक ही उच्च '-' संभाव्यता का अवलोकन चल रहे अंक को इस द्वारा ले जाता है `α = 0.1` उस अवलोकन के अंतर से . एक असली हमलावर तेजी से प्रमाण इकट्ठा करता है क्योंकि *हर* पर्यवेक्षण विरोधी है. एक वैध दर्शक जो एक अनुरोध के लिए एक स्करपर की तरह दिखता है बाद में पर्यवहारों पर भयानक की ओर वापस विकृत होता है

**नमूना** `confidence = min(1, request_count / 10)`. नीचे ~9 अवलोकनों, यहां तक कि एक मजबूत पीछला पेजरी को Skip के बजाय Bias के लिए रखा जाता है

> **एक ओर ML** यह एक है **पूर्व संकुचन**जब तक पर्याप्त प्रमाण इकट्ठा नहीं हो जाता है, :,'. Same reason [यूसीबी बैंडिट](https://en.wikipedia.org/wiki/Multi-armed_bandit#Upper_Confidence_Bound) एक नमूना शामिल करें `n`, व्यापक विश्वास अंतराल

**वेरिएन्स वॉचलडॉग** एक विश्वसनीय के साथ भी `VarianceWatchdog.Check` तीन स्वतंत्र परीक्षण के विरुद्ध चलाता है `VarianceWatchdogOptions` डिफ़ॉल्ट

```csharp
public int    IpRotationWindowSeconds { get; init; } = 300;   // same fingerprint, new /24
public double RateSpikeMultiplier     { get; init; } = 10.0;  // last minute vs rolling 5
public bool   CheckPathCentroid       { get; init; } = true;  // never-seen path family
```

पथ-विभिन्नता जांच को कम से कम आवश्यक है।

```csharp
if (options.CheckPathCentroid && hist.PathFamilyCount >= PathFamilyBaseline)
{
    var family = PathFamily(ctx.Request.Path.Value);
    if (family is not null && !ContainsFamily(hist, family))
        return new WatchdogResult(true, $"path-divergence:{family}");
}
```

कोई भी एक यात्रा और पाइपलाइन ताजा चलाता है ; प्रतिक्रिया लेती है `X-StyloBot-WatchdogTrip: ip-rotation:1.2.3.0->5.6.7.0` या जो भी फायर किया गया है

> **एक ओर ML** देखdog है **अवधारणा-ड्राइप पता लगाने** एक अंगुली छाप के लिए. शास्त्रीय अनुरूप हैं [एडविन](https://www.cs.upc.edu/~gavalda/papers/adwin06.pdf), [पृष्ठ–Hinkley](https://en.wikipedia.org/wiki/CUSUM), और [डीडीएम](https://link.springer.com/chapter/10.1007/978-3-540-28645-5_29)इन सभी से पता चलता है कि एक ऑनलाइन धारा के वितरण में काफी परिवर्तन हो गया है कि मौजूदा मॉडल अब विश्वसनीय नहीं है।

**छोड़ें** जब भी गेट पाइपलाइन को छोड़ता है, middleware अभी भी अनुरोध रिकॉर्ड करता है

```csharp
_watchdog.RecordObservation(precomputedSig, clientIp, pathStr);
_ = _signatureCoordinator.NotifyObservationAsync(
    precomputedSig, pathStr, v.BotProbability, context.RequestAborted);
```

यह तथ्य कि पता चलाने को छोड़ दिया गया है, नहीं create a hole in the per-fingerprint history

**नमूना ताजा करें.** `ShouldRefresh` विनिर्धारित रूप से Skip के एक कॉन्फ़िगर किए जा सकने वाले भिन्न को ह्रास करता है- Bias में पात्र अनुरोध इस प्रकार पाइपलाइन चलाता है और जीवित रिकॉर्ड को ताज़ा करता है`DeterministicBucket.ShouldFire`), तो एक ही क्लाइंट से वापसी समान रूप से भूमि लेता है ; समय के साथ प्रत्येक अंगुली छाप एक आवधिक पूर्ण पुनः प्राप्त करता है

> **एक ओर ML** यह एक निर्धारणात्मक संस्करण है **ε-कृपण अन्वेषण** मजबूती सीखने से : अधिकांश समय मौजूदा नीति का उपयोग करता है |( |Skip | ), | कुछ समय खोज करने की लागत का भुगतान करता है

**Entity-family fallback** जब एक अंगुली छाप घूमती है और उसके नए पहचान के पास अपना कोई कैशित निर्णय नहीं होता है [लीडन क्लस्टर एन्कर](/blog/stylobot-fingerprint) व्यवहारिक मॉडल से `TryGetVerdictAsync`:

csharp
if (!_signatureCac