अधिकतर सॉफ्टवेयर संरचनाएँ मानते हैं कि सिस्टम स्थिर है

नोट यह भाग 4 में है। भाग 1, भाग 2: स्नातक अध्यापक, और भाग 3: अविश्वसनीय देवता पृष्ठभूमि के लिए mostlylucid.botdetection.

प्रमुख संकल्पना: व्यवहारिक रूटिंग यह वास्तुकला एक नई श्रेणी - सक्षम करता है जहां पारदर्शी , समायोज्य |" |समूहों " |सूचक और सीखने वाली प्रणालियों को सीखा गया व्यवहार पैटर्न पर आधारित प्रतिक्रियात्मक रूप से ट्रैफिक का मार्ग दिखाता है YARP गेटवेबॉट्स कभी भी आपके बैकएण्ड तक नहीं पहुँचते

एक गतिशील विश्व में स्थिर प्रणालियां

वर्षों के लिए हम clockwork जैसे सॉफ्टवेयर बना चुके हैं

लेकिन आधुनिक प्रणालियां, विशेष रूप से AI

• हमलावर अपनी तकनीक विकसित करते हैं
• उपयोगकर्ता अपना व्यवहार बदलते हैं
• आवश्यकताएं समय के साथ बढ़ती हैं
• वातावरण लगातार बदलता है।

स्थिर वास्तुशिल्प स्थायित्व नहीं रख सकते'न रखने के लिए-. आप एक छेद को पैच करता है,, तीन और प्रकट होते हैं।

डिएसई वास्तुकला निर्देशित सिंथेटिक एवोल्यूशन

विकासशील जीवों के रूप में मुख्य विचार

पारंपरिक वास्तुकला

flowchart LR
    B[Build] --> S[Ship] --> P[Patch] --> B

    style B stroke:#6366f1,stroke-width:2px
    style P stroke:#ef4444,stroke-width:2px

डिएसई वास्तुकला

flowchart LR
    P[Perceive] --> E[Evaluate] --> M[Mutate] --> S[Select] --> P

    style P stroke:#10b981,stroke-width:2px
    style M stroke:#f59e0b,stroke-width:2px
    style S stroke:#6366f1,stroke-width:2px

एक डिएसई प्रणाली के चार अनिवार्य व्यवहार हैं

व्यवहार |-----------|--------------|----------------------| | अनुभव करना पर्यावरण से संकेत एकत्रित करें | मूल्यांकन करें लक्ष्यों के विरुद्ध प्राप्ताङ्क संकेत | तंत्रिका प्रणाली | उत्परिवर्तन रणनीतियों के भिन्नताओं को उत्पन्न करें | चुनें जो काम करता है उसे बनाए रखें।

यह रूपरेखा नहीं है।

Concrete Example: Bot Detection

mostlylucid.botdetection DiSE सिद्धांतों का पहला C# कार्यान्वयन है

धारणा: ब्लैकबोर्ड वास्तुशिल्प

सिस्टम एक का उपयोग करता है ब्लैकबोर्ड वाद्यकार डिटेक्टर एक साझा स्थिति के लिए साक्ष्य का योगदान देते हैं

// Detectors emit contributions (evidence), not verdicts
public sealed record DetectionContribution
{
    public required string DetectorName { get; init; }
    public required string Category { get; init; }

    // Positive = bot signal, Negative = human signal
    public required double ConfidenceDelta { get; init; }
    public double Weight { get; init; } = 1.0;

    public required string Reason { get; init; }
    public BotType? BotType { get; init; }

    // Signals for triggering other detectors
    public ImmutableDictionary<string, object> Signals { get; init; }
}

कई डिटेक्टर चलाएँ समांतर तरंगों मेंप्रत्येक एक साक्ष्य का योगदान करता है

// Wave 0: All detectors with no trigger conditions run in parallel
// Wave N: Detectors whose triggers are now satisfied run in parallel
while (waveNumber < MaxWaves && !cancellationToken.IsCancellationRequested)
{
    var readyDetectors = availableDetectors
        .Where(d => !ranDetectors.Contains(d.Name))
        .Where(d => CanRun(d, state.Signals))
        .ToList();

    await ExecuteWaveAsync(readyDetectors, state, aggregator, ...);

    // Check for early exit on high confidence
    if (aggregator.ShouldEarlyExit)
        break;
}

मूल्यांकन: सिगमोइड के साथ भारित सहमति

प्रमाणों को साइनमोइड रूपांतरण के प्रयोग से एक निर्णय में एकत्रित करता है - यह अच्छी तरह से उच्च से मजबूत संकेत leverages

private (double botProbability, double confidence) CalculateWeightedScore()
{
    var weighted = _contributions
        .Where(c => c.Weight > 0)
        .Select(c => (delta: c.ConfidenceDelta, weight: c.Weight))
        .ToList();

    var weightedSum = weighted.Sum(w => w.delta * w.weight);

    // Sigmoid maps any real number to (0, 1)
    // Strong human signal (-3) → ~5% bot probability
    // Neutral (0) → 50% bot probability
    // Strong bot signal (+3) → ~95% bot probability
    var botProbability = 1.0 / (1.0 + Math.Exp(-weightedSum));

    return (botProbability, confidence);
}

मूल्यांकन एक एकल मॉडल एक निर्णय करने के लिए नहीं है भारित सहमति कई विशेषज्ञ डिटेक्टरों के बीच - और महत्वपूर्ण रूप से , जब AI है नहीं चलाता है, चिपकाया हुआ अधिक विश्वास से बचने के लिए

// CRITICAL: Clamp probability when AI hasn't run
var botProbability = aiRan
    ? rawBotProbability
    : Math.Clamp(rawBotProbability, 0.20, 0.80);

आरंभिक बाहर निकलना: तीव्र मार्ग अनुकूलन

सिस्टम सभी डिटेक्टरों को हमेशा चलाता नहीं है

// Early exit on verified bots (good or bad)
public static DetectionContribution VerifiedGoodBot(
    string detector, string botName, string reason) => new()
{
    DetectorName = detector,
    Category = "Verification",
    ConfidenceDelta = 0,
    TriggerEarlyExit = true,
    EarlyExitVerdict = EarlyExitVerdict.VerifiedGoodBot
};

उत्पादन में उच्च -विश्वसनीयता अनुरोध 10ms के तहत बाहर निकलते हैं के बाद सिर्फ 2-3 डिटेक्टर सहमत होते हैं

सर्किट ब्रेकर्स

डिटेक्टर विफल हो सकते हैं

// Circuit breaker per detector
private void RecordFailure(string detectorName)
{
    var state = _circuitStates.GetOrAdd(detectorName, _ => new CircuitState());
    state.FailureCount++;
    state.LastFailure = DateTimeOffset.UtcNow;

    if (state.FailureCount >= CircuitBreakerThreshold)
    {
        state.State = CircuitBreakerState.Open;
        // Detector disabled until reset time passes
    }
}

विफल डिटेक्टरों को अस्थायी रूप से अक्षम कर दिया गया है। अवसंरचना स्तर पर चयन दबाव.

परिवर्तन: सीखने की प्रणाली

जब सिस्टम उच्च विश्वसनीयता से पता लगाता है सीखता है शिक्षण कार्यक्रम बस को प्रकाशित करके

private void PublishLearningEvent(AggregatedEvidence result, ...)
{
    var eventType = result.BotProbability >= 0.8
        ? LearningEventType.HighConfidenceDetection
        : LearningEventType.FullDetection;

    _learningBus.TryPublish(new LearningEvent
    {
        Type = eventType,
        Confidence = result.Confidence,
        Label = result.BotProbability >= 0.5,
        Metadata = new Dictionary<string, object>
        {
            ["botProbability"] = result.BotProbability,
            ["categoryBreakdown"] = result.CategoryBreakdown,
            ["contributingDetectors"] = result.ContributingDetectors
        }
    });
}

यह वजन भंडार में फीड करता है।

ज्ञानी स्टैक

एक एकल मस्तिष्क के बजाय "AI मस्तिष्क," DiSE लेयरेड cognition का उपयोग करता है

flowchart TB
    subgraph Fast["Fast Path (< 100ms)"]
        H[Static Heuristics]
        D[Detectors]
        ML[Learned Heuristic Model]
    end

    subgraph Slow["Slow Path (Async)"]
        LLM[Ollama LLM]
    end

    subgraph Learn["Learning Layer"]
        W[Weight Store]
        Rep[Reputation]
    end

    Fast --> |escalate uncertain| Slow
    Slow --> |label| Learn
    Learn --> |update weights| Fast

    style Fast stroke:#10b981,stroke-width:2px
    style Slow stroke:#6366f1,stroke-width:2px
    style Learn stroke:#f59e0b,stroke-width:2px

कुंजी अंतर्दृष्टि: सिस्टम वास्तविक में अपना वजन सीखता है।

भविष्य RAG और सम्मिलित ONNX मॉडल v के लिए योजनाबद्ध हैं।

यह जैविक ज्ञान को प्रतिबिंबित करता है

• आनुवंशिक प्रतिरक्षा प्रणाली → स्टैटिक हेयूरिसिक्स
• अनुकूल प्रतिरक्षा प्रणाली → सीखा हैरिस्टिक मॉडल
• स्मृति कोशिकाएँ वज़न भंडार

बाहरी मॉडलों के बिना हेरिस्टिक डेटेक्टर

यहाँ-' clever bit है। . बाहरी एमएल मॉडल भेजने के बजाय।

public class HeuristicDetector : IDetector
{
    // Default weights - sensible starting points
    private static readonly Dictionary<string, float> DefaultWeights = new()
    {
        // Human-like patterns (negative = more likely human)
        ["hdr:accept-language"] = -0.6f,
        ["hdr:referer"] = -0.4f,
        ["fp:received"] = -0.7f,      // Fingerprint = strong human signal
        ["fp:legitimate"] = -0.8f,

        // Bot indicators (positive = more likely bot)
        ["ua:contains_bot"] = 0.9f,
        ["ua:headless"] = 0.8f,
        ["ua:selenium"] = 0.7f,
        ["ua:curl"] = 0.6f,
        ["accept:wildcard"] = 0.4f,
    };

    private (bool IsBot, double Probability) RunInference(Dictionary<string, float> features)
    {
        // Simple linear model: score = bias + Σ(feature * weight)
        float score = _bias;

        foreach (var (featureName, featureValue) in features)
        {
            var weight = _weights.TryGetValue(featureName, out var w)
                ? w
                : DefaultNewFeatureWeight;
            score += featureValue * weight;
        }

        // Sigmoid gives us probability
        var probability = 1.0 / (1.0 + Math.Exp(-score));
        return (probability > 0.5, probability);
    }
}

विशेषताओं को अनुरोध और संकलित साक्ष्य से गतिशील रूप से निकाला जाता है

public static class HeuristicFeatureExtractor
{
    public static Dictionary<string, float> ExtractFeatures(
        HttpContext context,
        AggregatedEvidence evidence)
    {
        var features = new Dictionary<string, float>();

        // Request metadata
        features["req:header_count"] = Math.Min(headers.Count / 20f, 1f);
        features["req:cookie_count"] = Math.Min(cookies.Count / 10f, 1f);

        // Header presence
        features["hdr:accept-language"] = headers.ContainsKey("Accept-Language") ? 1f : 0f;

        // UA patterns (dynamic - only present if detected)
        if (ua.Contains("bot")) features["ua:contains_bot"] = 1f;
        if (ua.Contains("selenium")) features["ua:selenium"] = 1f;

        // Detector results (named by actual detector)
        foreach (var contrib in evidence.Contributions)
            features[$"det:{contrib.DetectorName}"] = contrib.ConfidenceDelta;

        // Client-side fingerprint - STRONG human signal
        if (hasFingerprint)
        {
            features["fp:received"] = 1f;
            features["fp:legitimate"] = 1f;
        }

        return features;
    }
}

नई सुविधाएँ स्वचालित रूप से डिफ़ॉल्ट वजन प्राप्त करती हैं और समय के साथ सीखती है

वज़न भंडार

भार SQLite में बना रहता है और एक्सपोनेन्शल गतिशील औसत के माध्यम से अद्यतन करता है

public class SqliteWeightStore : IWeightStore
{
    public async Task RecordObservationAsync(
        string signatureType,
        string signature,
        bool wasBot,
        double detectionConfidence,
        CancellationToken ct = default)
    {
        // EMA update: weight = weight * (1 - α) + new_value * α
        var alpha = 0.1; // Learning rate
        var weightDelta = wasBot ? detectionConfidence : -detectionConfidence;

        var sql = @"
            INSERT INTO learned_weights (signature_type, signature, weight, ...)
            VALUES (@type, @sig, @delta, ...)
            ON CONFLICT(signature_type, signature) DO UPDATE SET
                weight = weight * (1 - @alpha) + @delta * @alpha,
                confidence = MIN(1.0, confidence + @conf * 0.01),
                observation_count = observation_count + 1,
                last_seen = @now
        ";

        await ExecuteAsync(sql, ...);
    }
}

यह है निरीक्षण के माध्यम से उत्परिवर्तनप्रत्येक पता लगाने से सिस्टम को कुछ सिखाया जाता है

विकृति के रूप में भ्रम

डीआईएसई में LLM भ्रम एक बग नहीं है

एक उच्च-temperature LLM जो खोज नियम के दस भिन्नताओं को प्रस्तावित करता है, यह है जीनोम में उत्परिवर्तन प्रणाली के:

public async Task<List<DetectionRule>> GenerateMutationsAsync(DetectionContext context)
{
    var prompt = $"""
        Given this traffic pattern:
        {JsonSerializer.Serialize(context)}

        Generate 5 variant detection rules that might catch similar patterns.
        Return JSON array of rules with: pattern, weight, confidence.
        Be creative. Some variants should be strict, some lenient.
        """;

    var response = await _ollama.GenerateAsync(new GenerateRequest
    {
        Model = "gemma3:1b",
        Prompt = prompt,
        Options = new RequestOptions { Temperature = 0.9 } // High creativity
    });

    return ParseRules(response.Response);
}

इसके बाद उत्परिवर्तन को ऐतिहासिक डेटा के आधार पर मूल्यांकन किया जाता है

public async Task<DetectionRule?> SelectFittestAsync(
    List<DetectionRule> mutations,
    List<LabeledRequest> testData)
{
    var results = new List<(DetectionRule Rule, double Fitness)>();

    foreach (var rule in mutations)
    {
        var tp = testData.Count(r => rule.Matches(r) && r.IsBot);
        var fp = testData.Count(r => rule.Matches(r) && !r.IsBot);
        var fn = testData.Count(r => !rule.Matches(r) && r.IsBot);

        // F1 score as fitness
        var precision = tp / (double)(tp + fp);
        var recall = tp / (double)(tp + fn);
        var f1 = 2 * (precision * recall) / (precision + recall);

        results.Add((rule, f1));
    }

    return results.OrderByDescending(r => r.Fitness).First().Rule;
}

केवल fittest उत्पादन के लिए जीवित रहते हैं. यह टूटी हुई chatbots से LLMs में बदलता है विकासात्मक प्रचालक.

जीनोम नीति

DiSE के केंद्र में है नीति प्रणाली नामित कॉन्फ़िगरेशन जो परिभाषित करता है कि पता लगाने का व्यवहार कैसे होता है

{
  "Policies": {
    "fastpath": {
      "Description": "Fast path + Heuristic for sync decisions",
      "FastPath": ["UserAgent", "Header", "Ip", "Behavioral", "ClientSide", "Inconsistency", "VersionAge"],
      "AiPath": ["Heuristic"],
      "EscalateToAi": true,
      "EarlyExitThreshold": 0.15,
      "ImmediateBlockThreshold": 0.90,
      "Weights": {
        "ClientSide": 0.2,
        "Heuristic": 1.5
      },
      "Transitions": [
        { "WhenRiskExceeds": 0.5, "WhenRiskBelow": 0.85, "GoTo": "demo" }
      ]
    },
    "demo": {
      "Description": "Full pipeline sync for demonstration",
      "FastPath": [],
      "AiPath": [],
      "BypassTriggerConditions": true,
      "ForceSlowPath": true
    }
  }
}

नीति परिभाषित

• फास्टपाथ डिटेक्टर समांतर में चलाएँ
• एआई पथ - हेरिस्टिक (1-5ms) औरM SK3या एलएलएम 500ms
• थ्रेसहोल्ड - जब आरंभिक बाहर निकलना है
• संक्रमण - अनिश्चित होने पर अन्य नीतियों में स्वचालित वृद्धि
• Per-policy weights - ध्वनि डिटेक्टर उपयोग के लिए महत्वपूर्ण

सिस्टम कर सकता है नीतियों के बीच संक्रमण मध्य. अनिश्चित फास्टपाथ परिणाम पूर्ण डेमो पाइपलाइन तक बढ़ते हैं अनुकूलित रूटिंग जीनोम वास्तविक प्रमाणों के प्रति प्रतिक्रिया करता है

आप नहीं ship static configs. You ship व्यवहारिक प्रजातियां ट्रैफिक से अनुकूलित

Fitness Functions: What Survives

प्रत्येक DiSE प्रणाली एक स्वस्थ परिदृश्य के विरुद्ध अनुकूल होती है

public class FitnessEvaluator
{
    public double Evaluate(GenomeConfig genome, EvaluationData data)
    {
        var fpRate = data.FalsePositives / (double)data.TotalHumans;
        var fnRate = data.FalseNegatives / (double)data.TotalBots;
        var latency = data.P99LatencyMs;
        var cost = data.AiCallsPerRequest * _config.CostPerAiCall;

        // Multi-objective fitness
        return 1.0
            - (fpRate * _config.FalsePositivePenalty)   // Don't block humans
            - (fnRate * _config.FalseNegativePenalty)   // Don't miss bots
            - (latency / _config.MaxLatencyMs)          // Stay fast
            - (cost / _config.MaxCostPerRequest);       // Stay cheap
    }
}

हम केवल सटीकता के लिए अनुकूलन नहीं कर रहे हैं गतिशील वातावरण में जीवित रहना.

बहुत अधिक AI → उच्च लागत , कम लाटेन्सी | . बहुत कम AI → novel attacks की कम पहचान बहुत आक्रामक → गलत सकारात्मकताएँ, क्रोधित उपयोक्ता बहुत लचीला → बोट बाढ़

सिस्टम को एक स्थिर संतुलन ढूंढना होगा

शिक्षक के रूप में AI

एक परिपक्व डीआईएसई प्रणाली AI को गर्म मार्ग से बाहर ले जाती है

flowchart TB
    subgraph Early["Early Stage"]
        AI1[AI handles most cases]
    end

    subgraph Middle["Middle Stage"]
        AI2[AI handles edge cases]
        H1[Heuristics handle common cases]
    end

    subgraph Mature["Mature Stage"]
        AI3[AI teaches and mutates]
        H2[Heuristics handle almost everything]
        M[Memory provides context]
    end

    Early --> Middle --> Mature

    style Early stroke:#ef4444,stroke-width:2px
    style Middle stroke:#f59e0b,stroke-width:2px
    style Mature stroke:#10b981,stroke-width:2px

समय के साथ-साथ

• स्थिर डिटेक्टर improve (प्रशिक्षित AI लेबलों द्वारा
• हियूरिसिक्स अधिक सटीक हो जाता है (फिस्टिट द्वारा चुना गया
• एआई केवल नवीनता और उत्परिवर्तन को नियंत्रित करता है

AI becomes:

• मौखना नए व्यवहारों के लिए
• जनरेटर उत्परिवर्तन
• ड्रिफ्ट डिटेक्टर
• अध्यापक जो सीमांत मामलों को लेबल करता है

रनटाइम निर्भरता नहीं

व्यवहार रूटिंग: एक नया वर्ग

के साथ YARP गेटवेयह वास्तुकला कुछ नया सक्षम करता है व्यवहारिक रूटिंग.

पारंपरिक रूटिंग स्थिर है।

flowchart LR
    subgraph Gateway["YARP Gateway"]
        D[Detector Team]
        P[Policy Engine]
        R[Router]
    end

    Traffic[Traffic] --> D
    D --> P
    P --> R
    R -->|Human| App[Your App]
    R -->|Bot| Block[403]
    R -->|Uncertain| Challenge[Challenge]
    R -->|Learning| Queue[Async Analysis]

    style Gateway stroke:#10b981,stroke-width:2px

प्रमुख संकल्पनाएं

• डिटेक्टर टीम - एक साथ काम करने वाले डिटेक्टरों के कॉन्फ़िगर किए जा सकने योग्य समूह
• पारदर्शी निर्णय प्रत्येक रूटिंग निर्णय समझा जा सकता है
• प्रतिवर्ती समायोजन - सिस्टम अपने निर्णयों से सीखता है और समय के साथ वजनों को समायोजन करता है
• किनारा---स्तर संरक्षण - बॉट्स कभी भी आपके बैकएण्ड तक नहीं पहुँचते

यह सिर्फ ' नहीं है, """bot detection at the edge" ."" यह एक नया रूटिंग आदिम है जहां ट्रैफिक प्रवाहों को सीखा गया व्यवहार पैटर्न द्वारा आकार दिया जाता है"

यह क्यों महत्वपूर्ण है

अधिकतर इंजीनियरी संस्कारों से डरते हैं

• निर्णायात्मकता
• ड्राइप
• परिवर्तन
• भ्रम
• तात्कालिक व्यवहार

DiSE इन के रूप में उपयोग करता है निर्माण सामग्री.

स्थिर प्रणालियां मर जाती हैं

प्रतिद्वंद्वियों के साथ काम करने वाले प्रत्येक उद्योग को अंततः इस तरह की संरचनाओं की आवश्यकता होगी

• बोट पहचान
• धोखाधड़ी के इंजन
• अनुकूलित फायरवाल
• एलएलएम पारिस्थितिक
• Self-सूक्ष्म सेवाओं का अनुकूलन
• स्वायत्त डिबगिंग सिस्टम
• व्यवहारिक रूटिंग सीखी गई नमूनाओं पर आधारित ट्रैफिक आकार

क्या है DiSE

मुझे यह क्या है के बारे में स्पष्ट करें

• नहीं "हर जगह बड़े LLMs - एलएलएम महंगे हैं
• नहीं "आर्थिक तर्क को AI के साथ बदलें - हियूरिसिक्स तेज और अधिक भविष्यवाणी योग्य हैं
• नहीं "प्रणाली को wild चलाएँ एवोल्यूशन निर्देशित है
• स्टेरॉयड परAutoML नहीं यह व्यवहार के बारे में है

DiSE नियंत्रित है

• प्रतिबंधों से घिरा
• स्पष्ट fitness कार्यों द्वारा नियंत्रित
• मेमोरी
• संस्करणित
• चलाने के लिए सुरक्षित

एमएसके0 निदेशित विकास - निर्देशित

कोशिश करें

mostlylucid.botdetection इन सिद्धांतों को लागू करता है

dotnet add package Mostlylucid.BotDetection

builder.Services.AddBotDetection();
app.UseBotDetection();

शिक्षण सक्षम के साथ उत्पादन हेतु कॉन्फ़िगर करें:

{
  "BotDetection": {
    "BotThreshold": 0.7,
    "Policies": {
      "default": {
        "FastPath": ["UserAgent", "Header", "Ip", "Behavioral", "ClientSide", "Inconsistency", "VersionAge"],
        "AiPath": ["Heuristic", "Llm"],
        "EscalateToAi": true,
        "EarlyExitThreshold": 0.85
      }
    },
    "AiDetection": {
      "Provider": "Heuristic",
      "Heuristic": {
        "Enabled": true,
        "LoadLearnedWeights": true,
        "EnableWeightLearning": true,
        "LearningRate": 0.01
      }
    }
  }
}

यह विकास देखें. हर अनुरोध से हीरिस्टिक डिटेक्टर सीखता है

निष्कर्ष

डिएसई आर्किटेक्चर मशीन के रूप में सॉफ्टवेयर से जीवों के रूप मे सॉफ़्टवेयर को स्थानांतरित करता है

यह' का वास्तुकला है

• अनुकूलता
• प्रतिरोध
• नियंत्रित विकास
• परतित बोध
• मेमोरी
• परिवर्तन + चयन
• रणनीतिक व्यवहार

स्थिर वास्तुकला गतिशील परिवेशों के साथ अनुसरण नहीं कर सकते

तंत्रों को भी विकसित होना चाहिए

यदि आप केवल चलाने वाली प्रणालियां चाहते हैं अगर आप सिस्टम चाहते हैं कि बचना उन्हें DiSE के साथ बनाना