अपनी सोचने - समझने की शक्‍ति का इस्तेमाल करना: जो तंत्र सीखते हैं, उन्हें बनाने, अनुकूलता और ईवोव्व (हिन्दी (Hindi))

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

टिप्पणीः यह "माइनिंग" श्रृंखला में भाग ४ में है. देखें. पार्ट 1, पार्ट २: स्नातक ऐथेन्स, और भाग ३: अविवाद्य परमेश्‍वर अब हमारे पास एक कार्य - C# कार्यान्वयन है: अधिकतर अल्पपारदर्शिता. बोट्स.

कुंजी धारणा: व्यवहारिंग रो रही है. यह निर्माण एक नया वर्ग - जहां पारदर्शी, पारदर्शी, विकसित करने योग्य "कारम" और सीखने योग्य प्रणालीओं को सीखने के तरीक़े पर आधारित यातायात व्यवस्थाओं के साथ सक्षम करता है, न कि स्थिर नियमों के साथ। वायएआरपी गेटवे, बॉट्स कभी आपके बैकएण्ड तक नहीं पहुंचते ।

समस्या: एक गतिशील दुनिया में स्थिर व्यवस्था

सालों से, हमने सॉफ्टवेयर का निर्माण किया है जैसे घड़ी के काम: इनपुट, आउटपुट, नियम, जांच, न्याय, अनुमतिएँ. सारा लीनियर, सभी भविष्यवाणी की जा सकती है.

लेकिन आधुनिक तंत्र - विशेष रूप से एआई-विष्ट लोगों की तरह नहीं अब घड़ी की तरह व्यवहार करते हैं. वे पर्यावरण जैसे व्यवहार करते हैं:

हमला करनेवाले अपनी तकनीकों पर हमला करते हैं
उपयोक्ता अपना व्यवहार बदलता है
समय पर बहाव
वातावरण लगातार बदलता रहता है

स्थिर संरचनाएं ऊपर नहीं रख सकती. आप एक छेद, तीन और अधिक दिखाई दे सकते हैं. आप एक सीमा, कुछ और टूटता है. आप हमेशा प्रतिक्रिया दिखाते हैं, कभी अनुकूल नहीं.

डिथरिंग (प्रयोगात्मक रसायन - विकास) जीव जीव - जीव के साथ जिस तरह से सॉफ्टवेयर प्रयोग करता है, उसी तरह का व्यवहार करता है: कुछ ऐसा है जो अनुकूल, आत्म - सुधार, और दबाव के अधीन सुधार करना चाहिए ।

कोर इडिया: तंत्रों को पैंक्रियाज़ के रूप में

पारंपरिक रचना:

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

एक मानसिक प्रणाली में चार अनिवार्य व्यवहार होते हैं:

इस बीमारी का इलाज कैसे किया जा सकता है? |-----------|--------------|----------------------| | यू. एस. पर्यावरण में से संकेत इकट्ठा करें | हल करें इनमें से कुछ लक्ष्य हैं, जिन्हें हासिल करना मुश्‍किल हो सकता है । | म्यूट करें GdkEVERELPEVERDELPEALDE( डबल्यू) पत्नियों के लिए तैयार करता है | चुनें जुड़ता है क्या कार्य करता है, छोड़ दें जो स्वाभाविक चयन नहीं करता है

यह लाक्षणिक नहीं है. यह है कि इस तरह आपके तंत्र स्मार्ट व्यवहार समय पर विकसित होता है.

स्वचालित उदाहरण: बोर पता लगाना

अधिकतर अल्पपारदर्शिता. बोट्स Duep सिद्धांतों का पहली 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;
}

मूल्यांकन: सिमाइड के साथ भारदार भार

सबूत एक निर्णय में मौजूद होते हैं

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

मूल्यांकन एक एकल मॉडल नहीं है एक निर्णय बना. यह है भारित बहुत से विशेष रूप से - और निर्णायक रूप से, जब एआई नहीं चला है, संभावना है कि यह संभावना है क्लीड्ड खुद पर हद - से - ज़्यादा भरोसा करने से दूर रहिए:

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

उत्पादन में, 10 बजे के अंदर से बाहर निकलने का निवेदन सिर्फ 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
    }
}

असफलताओं को अस्थायी रूप से अक्षम कर रहे हैं. एक ठंडा होने के बाद वे फिर से कोशिश की जा रही हैं ( आधी- open). यह है अस्थायी रूप से अक्षम कर रहे हैं. अतिप्रयोगक स्तर पर चयन दबाव.

मुख्य अध्ययन: सीखने की व्यवस्था

जब तंत्र उच्च भरोसे के साथ पता चलता है, सीखने की क्रिया कार्यक्रम बस को प्रकाशित करने के द्वारा:

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

यह वजन स्टोर में फ़ीड करता है, Herrerrens 'समय पर सीखा वजन को अद्यतन.

कॉक्लिटर स्टैक

एक एकल "अनुप्रयोग" के बजाय, डायनर परत का प्रयोग करता है:

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

खुदा ने फरमाया था कि हम उसमें से कुछ न करें, मगर हमें पूरा यकीन है कि वह हमारी मदद ज़रूर करेगा । |-------|-------|---------|----------------------| | स्थिर विवेक IMTAN <1ms Instents instatctactiential Melial name | पता लगाएँ DUR <10ms <10mss SERSESES SENS SEAREANT, IP जाँच | बुद्धिमान बनना सीखा सेंटीमीटर 1-5ms गतिशील वर्ग स्थिर करता हैLontroligion द्वारा सीखा वजन के साथ गतिशील लॉग रीग्रेसन | सीएलएम 50-५००ms गहरे तर्क का विश्लेषण करते हुए | समझ रहा है [ पेज 27 पर तसवीर]

कुंजी अन्तर्दृष्टि: तंत्र वास्तविक समय में अपना स्वयं का वजन सीख लेता है. कोई बाहरीएमएल मॉडल जरूरी नहीं है. वह परमप्रयोगी प्रक्षेपन डिफ़ॉल्ट से शुरू होता है तथा पुनः जाँच पर आधारित पुनः विकसित होता है.

भविष्य: RaG और एम्बेडिंग के लिए योजना बनाई जा रही है वी2 के लिए। वर्तमान अभिकलन मॉडल आउटपुट भविष्य मॉडल प्रशिक्षण के लिए निर्देशित प्रशिक्षण डेटा के रूप में काम करता है। डिजाइन पहले से ही "अनुष्ट" सामग्री (संत्र, वजन, संकेत) है कि विनियमित विकास को जोड़ने के लिए निर्देशित किया है - यह एक बिंदु के रूप में सेट किया गया है।

यह आई. वी.

प्रतिरक्षा तंत्र ✔ स्थिर रहना
एडाप्टिव प्रतिरक्षा तंत्र ▪ सोच - समझकर काम करना सीखिए
मेमोरी कक्ष ▪ भारों में + नाम

परमवादी जासूस: बाहरी मॉडलों के बिना सीखना

यहाँ चतुर सा है. एक बाहरीएमएल मॉडल को हटा देने के बजाय, तंत्र अपने स्वयं के वर्गीय लॉगर को सरल लॉगर का प्रयोग करता है।

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

नई विशेषताएँ स्वचालित रूप से डिफ़ॉल्ट भार प्राप्त करती हैं तथा समय के बारे में सीख लेती हैं. तंत्र क्या बात है इसका पता लगाता है.

भार: बड़ी समझ

अतिसक्रियता औसत:

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

यह है देखने के द्वारा उत्परिवर्तनसमय - समय पर, वज़न आपके विशिष्ट यातायात के तरीक़ों के लिए आकर्षक मूल्यों की ओर इकट्ठा होता है ।

हाल के सालों में सजग होइए!

मानसिक रूप से, यह एक बग नहीं है. यह विकास की जीनता है.

एक उच्च-प्रयोगी एक जांच नियम के दस भिन्नों का प्रतिनिधित्व कर रहा है "नहीं" - यह है जीनोएम पैदा करना सिस्टम:

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

सिर्फ़ विकसित करने के लिए फिट जीवित रहने के लिए. यह बद्बोट में परिवर्तनों को बदल देता है विकास ऑपरेटर्स.

जेनम: पॉलिसी- बेस्ड कॉन्फ़िगरेशन

डिथरिंग के केंद्र में नीति तंत्र - नामा कॉन्फ़िगरेशन जो पारिभाषित करता है कि कैसे चेक करें:

{
  "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
    }
  }
}

पारिभाषित पारिभाषित:

फास्ट पथ पथPermissions - समानांतर में चलाएं, सब 10ms
एआई पथ - हेयरिस्ट (1- 5ms) और / या तोलीएम (00ms+)
देहलीज: - कब जल्दी बाहर निकलने के लिए, जब ब्लॉक करने के लिए
स्लाइड संक्रमण: - जब अनिश्‍चित हो, अन्य नियमों को स्वचालित योग दें
पर- प्रायोगिक भार - किसी केस का उपयोग करने के लिए उपयोग करने की धुन लगाना महत्व

तंत्र संख्याओं के बीच संक्रमण. अनिश्‍चित तेजी के परिणाम पूरे डेमो को बढ़ते जा रहे हैं. यह है एडाप्टिव routing - वास्तविक समय में सबूतों के लिए जीनोएम जवाब देता है.

आप स्थिर कॉन्फ़िग नहीं है. आप जहाज व्यवहारक जाति ट्रैफिक के मुताबिक खुद को ढालना ।

अनुरूप: कौन - से बच पाते हैं

हर घटना की वजह से पर्यावरण पर बुरा असर पड़ता है:

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

हम अकेले सही के लिए स्तर निर्धारित नहीं कर रहे हैं. हम समाधान के लिए कर रहे हैं गतिशील वातावरण में अस्तित्व.

बहुत ज्यादा एआई बहुत ज्यादा खर्च, कम देर के बारे में. बहुत कम एआई-किंग हमले की अच्छी जांच. बहुत ही उपद्रवी सकारात्मक, क्रोधित उपभोक्ता । बहुत आसानी से बाढ़ आ जाती है.

दबाव में आकर विकासवाद को बढ़ावा देता है ।

शिक्षक के रूप में एआई, काम करनेवाला नहीं

एक प्रौढ़ डिथरिंग सिस्टम गर्म पथ से एआई को बदलता है:

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

समय:

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

एआईहो जाता है:

वह दर्शन उपन्यास व्यवहार के लिए
वह जेनरेटर उत्परिवर्तन का
वह बहावक
वह शिक्षक किनारा लाइन के मामलों पर लेबल लगाएँ

एक बंद अधिकारी नहीं है. एक एडाप्टिव प्रवेश कर रहा है.

व्यवहारिंग रो रही है: एक नया वर्ग

के साथ वायएआरपी गेटवे, यह निर्माण कुछ नया करने के लिए सक्षम करता है: बर्तावक घुसना.

आम तौर पर गाड़ी चलाते वक्‍त: रास्ते पर चलते वक्‍त ।

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

कुंजी मूल्य:

टाइमर टीमें - एक साथ काम करता है कि कॉन्फ़िगरेबल समूह, प्रति नीति समायोजित किया जा सकता है
पारदर्शी निर्णय - प्रत्येक routing निर्णय स्पष्ट किया जा सकता है (प्रचलित ब्रेक देखते हैं)
सुधार समायोजन - प्रणाली अपने निर्णय से सीख और समय पर वजन समायोजित करता है
किनारा-स्तर सुरक्षा - अपने बैकएण्ड तक कभी पहुंचता नहीं है; रास्ते में बंद

यह सिर्फ "बोच में जांच" नहीं है। यह एक नया photing है जहां यातायात प्रवाह सीखा व्यवहार पैटर्न द्वारा आकार किया जाता है, सिर्फ स्थिर नियमों द्वारा नहीं।

ऐसा क्यों?

अधिकतर इंजीनियरिंग संस्कृतियों को डर है:

अ- निर्धारितता
बहाव
म्यूशन
हाल ही में सजग होइए!
व्यवहार

मानसिक रूप से इस्तेमाल किया जाता है निर्माण सामग्री.

स्थिर व्यवस्थाएं मर जाती हैं ।

हर उद्योग विरोधी, बहाव, या पैमाने पर दबाव के साथ व्यवहार करता है, इस तरह की बनावट की ज़रूरत होगी:

बोकेट जांच
फ्रॉड इंजन
एडाप्टिव फायरवाल्स
समुद्र - तट
माइक्रोफ़ॉर्मेट को स्व-रूपित किया जा रहा है
एक डिबगिंग तंत्र
बर्तावल routing - सीखने के पैटर्नों पर आधारित ट्रैफिक बनाने का प्रभाव

क्या डिथरिंग नहीं है

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

"हर जगह विशाल" नहीं - वे बहुत महँगी हैं।
एआई के साथ व्यापार तर्क "संकृत करें" नहीं है - अतिवादी तेजी से कर रहे हैं और अधिक अनुमानीय हैं.
" सिस्टम चलाने जंगली" नहीं है - एवोल्यूशन निर्देशित किया गया है, बाध्य किया गया है, नियंत्रित.
"Awideids" पर उपलब्ध नहीं है - यह व्यवहार के बारे में है, न कि सिर्फ मॉडल डायटिंग के बारे में है.

दिमाग को काबू में रखा जाता है, समझाता है:

प्रतिबन्धों द्वारा अनदेखा
साफ - सफाई के कामों से शासी निकाय
मेमोरी साफ- साफ
संस्करण
तैनात करने के लिए सुरक्षित

यह है निर्देशित विकासवाद पर विश्‍वास कीजिए ।

इसे कोशिश करें

अधिकतर अल्पपारदर्शिता. बोट्स इन सिद्धान्तों को लागू करता है:

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

इस अध्ययन से पता चलता है कि इस समस्या का सामना करने के लिए आप क्या कर सकते हैं ।

कंटेनमेंट

मगर इन चीज़ों के बारे में क्या कहा जा सकता है?

यह की बनावट है:

अनुकूलनशीलता
रेफ़रेंस
एवोल्यूशन पर नियंत्रण
लेयर पोंछना प्रभाव
स्मृति- विकसित सीखने के लिए
MATAN + चयन
रणनीतिक व्यवहार

स्थिर बनावटों को गतिशील वातावरण के साथ नहीं रखा जा सकता. हमला करनेवाले उभरे. उपयोक्ता उभरे.

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

यदि आप उन व्यवस्थाओं को चाहते हैं जो केवल चलते हैं, तो उन्हें पुराने तरीके से निर्माण कीजिए । यदि आप तंत्र व्यवस्था चाहते हैं जीवित - उन्हें डिथरिंग के साथ निर्माण.