flowchart TB
    subgraph Input["50,000 Unique Signatures"]
        Hot[Hot Signatures\n~10,000]
        Cold[Cold Signatures\n~40,000]
    end

    subgraph Cache["Bounded Cache (10,000)"]
        Kept[Kept in Memory]
    end

    subgraph Evicted["Evicted"]
        Lost[Forgotten\nNoise Traffic]
    end

    Hot --> Kept
    Cold --> Lost

    style Hot fill:none,stroke:#10b981,stroke-width:2px
    style Cold fill:none,stroke:#94a3b8,stroke-width:2px
    style Kept fill:none,stroke:#10b981,stroke-width:2px
    style Lost fill:none,stroke:#ef4444,stroke-width:2px

अधिप्रवाह मज़बूत व्यवहारिक स्मृति

जब ओवरफ्लो नहीं करता है

यह magic नहीं है

• कैश बहुत छोटा हैयदि आपके कैश में केवल 100 प्रविष्टियों को ही रखा जाता है लेकिन आप के पास 1,000 वास्तविक रूप से महत्वपूर्ण हस्ताक्षर हैं।

• एकरूप यातायातयदि आप एक छोटे आंतरिक प्रणाली पर चल रहे हैं जहां लगभग सब कुछ है

• आरंभ समस्याएक नए ढंग से स्थापित प्रणाली में कोई सीखा हुआ वजन नहीं है

पैटर्न सबसे अच्छा काम करता है जब आप पावर के साथ उच्च cardinality-law वितरण बहुत सारे अद्वितीय हस्ताक्षर, लेकिन एक छोटा उपसंचय जो ट्रैफिक पर प्रभाव डालता है

Sync में कैश और डाटाबेस रखें

कैश पढ़ने के लिए सत्य का स्रोत है, लेकिन डेटाबेस स्थायी खाता है।

डिसे सिंक्रोनाइजेशन

जब डेटाबेस वज़न टूटता है, कैश को अनुसरण करने की आवश्यकता होती है DecayOldWeightsAsync विधि दोनों को संभालती है

// From WeightStore.cs:725-766
public async Task DecayOldWeightsAsync(TimeSpan maxAge, double decayFactor, CancellationToken ct = default)
{
    await EnsureInitializedAsync(ct);

    await using var conn = new SqliteConnection(_connectionString);
    await conn.OpenAsync(ct);

    var cutoff = DateTimeOffset.UtcNow.Subtract(maxAge).ToString("O");

    // Decay old weights in the database
    var sql = $@"
        UPDATE {TableName}
        SET weight = weight * @decay,
            confidence = confidence * @decay
        WHERE last_seen < @cutoff
    ";

    await using var cmd = new SqliteCommand(sql, conn);
    cmd.Parameters.AddWithValue("@decay", decayFactor);
    cmd.Parameters.AddWithValue("@cutoff", cutoff);

    var updated = await cmd.ExecuteNonQueryAsync(ct);

    // Delete weights that have decayed below threshold
    var deleteSql = $@"
        DELETE FROM {TableName}
        WHERE confidence < 0.01 OR (ABS(weight) < 0.01 AND observation_count < 5)
    ";

    await using var deleteCmd = new SqliteCommand(deleteSql, conn);
    var deleted = await deleteCmd.ExecuteNonQueryAsync(ct);

    if (updated > 0 || deleted > 0)
    {
        _logger.LogInformation(
            "Weight decay: {Updated} decayed, {Deleted} deleted",
            updated, deleted);

        // Compact cache to remove stale entries
        _cache.Compact(0.25);
    }
}

क्षय डाटाबेस रिकार्डों, के बाद हम कॉल _cache.Compact(0.25) - यह शक्ति MemoryCache अपने प्रविष्टियों से बाहर निकालने के लिए 25%

टैग-आधारित बहिष्करण

कभी-कभी आपको कैश प्रविष्टियों की पूरी श्रेणी को अवैध करने की आवश्यकता होती है उदाहरण के लिए - जब एक डिटेक्टर का पुनर्प्रशिक्षण किया जाता है या जब बाहरी डेटा परिवर्तन होते हैं

// From WeightStore.cs:768-777
/// <summary>
///     Evicts all cached entries for a specific signature type (tag-based eviction).
/// </summary>

public void EvictByTag(string signatureType)
{
    // MemoryCache doesn't natively support tag-based eviction, but we can compact
    // For now, just compact - sliding expiration will handle stale entries
    _cache.Compact(0.1);
    _logger.LogDebug("Compacted cache for signature type: {SignatureType}", signatureType);
}

.NET MemoryCache में मूल टैग नहीं है

समक्रमण रणनीति

प्रमुख अंतर्दृष्टि यह है कि पूर्ण समन्वयन आवश्यक नहीं हैसिस्टम ड्रिफ्ट सहन करता है क्योंकि

1. क्यास डीबी से पुनः लोड करने में त्रुटि हुई - यदि कोई प्रविष्टि निकाला जाता है तो , अगला पठन ताजा डाटा लेता है
2. स्लाइडिंग समाप्ति अस्थिरता को संभालती है - प्रविष्टियों को minutes auto के भीतर पहुँच नहीं मिला
3. संकुचन शक्तियां नवीकरण - आवधिक संकुचन पुराने प्रविष्टि बाहर धकेलता है
4. Write-behind coalesces updates - कई त्वरित अद्यतन एक डीबी लिखने में हो जाते हैं

यह अंततः सुसंगतता सही किया जाता है. कैश बिना जटिल अमान्यीकरण तर्क की आवश्यकता के डाटाबेस से काफी बंद रहता है

flowchart TB
    subgraph Sync["Cache-Database Synchronisation"]
        D[Database Decay] --> C[Cache Compact]
        E[Tag Eviction] --> C
        S[Sliding Expiration] --> M[Cache Miss]
        M --> R[Reload from DB]
    end

    style Sync fill:none,stroke:#6366f1,stroke-width:2px

कोई कैश अमान्यीकरण hell नहीं है. कोई जटिल pub नहीं है

गाइडिंग गियर

नोट अगर आप सिर्फ LRU चाहते हैं + लिखने के लिए - पैटर्न के पीछे-, आप यहाँ रुक सकते है .\ इस आलेख का शेष यह दिखाता है कि मैं पूरी पैट्नर प्रतिष्ठा के लिए उसी विचारों को लागू कैसे करता हूँ।

हाइस्टेरेसिस और डिसे

पैटर्न प्रतिष्ठा के लिए ( समय पर एक हस्ताक्षर या मानव है या नहीं ट्रैक करने के लिए वही सिद्धांत लागू होते हैं लेकिन अतिरिक्त जटिलता के साथ

// From PatternReputation.cs:42-108
public record PatternReputation
{
    public required string PatternId { get; init; }
    public required string PatternType { get; init; }
    public required string Pattern { get; init; }

    /// <summary>Current bot probability [0,1]. 0 = human, 1 = bot, 0.5 = neutral</summary>

    public double BotScore { get; init; } = 0.5;

    /// <summary>Effective sample count - decays over time, increases with observations</summary>

    public double Support { get; init; } = 0;

    /// <summary>Current reputation state - determines fast-path behavior</summary>

    public ReputationState State { get; init; } = ReputationState.Neutral;

    // Computed properties
    public double Confidence => Math.Min(1.0, Support / 100.0);

    public bool CanTriggerFastAbort =>
        State is ReputationState.ConfirmedBad or ReputationState.ManuallyBlocked;

    public bool CanTriggerFastAllow =>
        State is ReputationState.ConfirmedGood or ReputationState.ManuallyAllowed;
}

हाइस्टेरेसिस के साथ राज्य संक्रमण

पैटर्न न्युट्रल से कनफिगर्ड बैड के लिए सीधे फ्लिप नहीं करता है

// From PatternReputation.cs:367-421 - simplified
public PatternReputation EvaluateStateChange(PatternReputation reputation)
{
    if (reputation.IsManual)
        return reputation;

    var newState = reputation.State;
    var score = reputation.BotScore;
    var support = reputation.Support;

    switch (reputation.State)
    {
        case ReputationState.Neutral:
            // Can promote to Suspect or ConfirmedGood
            if (score >= 0.6 && support >= 10)
                newState = ReputationState.Suspect;
            else if (score <= 0.1 && support >= 100)
                newState = ReputationState.ConfirmedGood;
            break;

        case ReputationState.Suspect:
            // Can promote to ConfirmedBad or demote to Neutral
            if (score >= 0.9 && support >= 50)
                newState = ReputationState.ConfirmedBad;
            else if (score <= 0.4 || support < 10)
                newState = ReputationState.Neutral;
            break;

        case ReputationState.ConfirmedBad:
            // Can demote to Suspect (requires MORE evidence to forgive)
            if (score <= 0.7 && support >= 100)
                newState = ReputationState.Suspect;
            break;
    }

    // ... log state change and return ...
}

असममितता को नोट करें ConfirmedBad → Suspect समर्थन 100 की आवश्यकता होती है Neutral → Suspect सिर्फ की जरूरत है 10. यह जानबूझकर है | - | यह |' | संदेह से अधिक क्षमा करना कठिन है

समय समाप्ति - एक्सपोनेन्शल भूल

जब नमूने शांत हो जाते हैं तो वे तटस्थ की ओर पतन होते हैं

// From PatternReputation.cs:334-361
public PatternReputation ApplyTimeDecay(PatternReputation reputation)
{
    if (reputation.IsManual)
        return reputation;

    var hoursSinceLastSeen = (DateTimeOffset.UtcNow - reputation.LastSeen).TotalHours;

    if (hoursSinceLastSeen < 1)
        return reputation;  // Too recent to decay

    // Score decay toward prior (0.5 = neutral)
    // new_score = old_score + (prior - old_score) × (1 - e^(-Δt/τ))
    var scoreDecayFactor = 1 - Math.Exp(-hoursSinceLastSeen / _options.ScoreDecayTauHours);
    var newScore = reputation.BotScore + (0.5 - reputation.BotScore) * scoreDecayFactor;

    // Support decay
    // new_support = old_support × e^(-Δt/τ)
    var supportDecayFactor = Math.Exp(-hoursSinceLastSeen / _options.SupportDecayTauHours);
    var newSupport = reputation.Support * supportDecayFactor;

    return reputation with
    {
        BotScore = Math.Clamp(newScore, 0, 1),
        Support = newSupport
    };
}

डिफ़ॉल्ट समय स्थिरांक

• अंक ह्रास τएक सप्ताह की निष्क्रियता के बाद प्राप्तियां तटस्थ की ओर बढ़ती हैं
• समर्थन विघटन τ2 सप्ताह के बाद विश्वास गिरता है

इसका मतलब यह है कि एक महीने के लिए मौन रहने वाली एक सटीक”-“छोटी आईपी की पुष्टि के बाद अंततः न्यूट्रल में वापस आ जाएगी।

पृष्ठभूमि मरम्मत सेवा

ReputationMaintenanceService तीन आवधिक कार्य चलाता है

// From ReputationMaintenanceService.cs:48-129
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    _logger.LogInformation("Reputation maintenance service starting");

    // Load persisted reputations on startup
    await _cache.LoadAsync(stoppingToken);

    var decayInterval = TimeSpan.FromMinutes(60);    // Hourly decay sweep
    var gcInterval = TimeSpan.FromHours(24);          // Daily garbage collection
    var persistInterval = TimeSpan.FromMinutes(5);   // Persist every 5 minutes

    var lastDecay = DateTimeOffset.UtcNow;
    var lastGc = DateTimeOffset.UtcNow;
    var lastPersist = DateTimeOffset.UtcNow;

    while (!stoppingToken.IsCancellationRequested)
    {
        await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
        var now = DateTimeOffset.UtcNow;

        // Decay sweep: push stale scores toward neutral
        if (now - lastDecay >= decayInterval)
        {
            await _cache.DecaySweepAsync(stoppingToken);
            lastDecay = now;
        }

        // Garbage collection: remove old neutral patterns
        if (now - lastGc >= gcInterval)
        {
            await _cache.GarbageCollectAsync(stoppingToken);
            lastGc = now;

            var stats = _cache.GetStats();
            _logger.LogInformation(
                "Reputation stats: {Total} patterns, {Bad} bad, {Suspect} suspect",
                stats.TotalPatterns, stats.ConfirmedBadCount, stats.SuspectCount);
        }

        // Persistence: save to SQLite
        if (now - lastPersist >= persistInterval)
        {
            await _cache.PersistAsync(stoppingToken);
            lastPersist = now;
        }
    }

    // Final persist on shutdown
    await _cache.PersistAsync(CancellationToken.None);
}

कचरे का संग्रहणकर्ता उन पैटर्न को हटाता है जो हैं

• 90+ दिन पुराना
• समर्थन
• तटस्थ अवस्था में

इससे स्मृति शब्दकोश में मूल्यवान सीखे गए पैटर्नों को सुरक्षित रखते हुए बिना सीमाओं के बढ़ने से बचा जाता है

एसक्यूलाइट एक मजाक नहीं है

बहुत से विकासकर्ता प्रतिक्रियात्मक रूप से PostgreSQL या Redis के लिए पहुँचते हैं

1. Write-behind bottlenecks eliminates - SQLite 's singleM SK2writer limitation doesn't matter when writes are batched
2. स्थानीय भंडारण - कोई नेटवर्क विलंब नहीं
3. शून्य विन्यास - सिर्फ फ़ाइल पथ
4. किनारा विनियोजन के लिए पूर्ण - Raspberry Pi पर चलता है
5. पोर्टेबल - डाटाबेस सिर्फ एक फ़ाइल है जिसे आप चारों ओर कॉपी कर सकते हैं

स्कीमा न्यूनतम है

CREATE TABLE IF NOT EXISTS learned_weights (
    signature_type TEXT NOT NULL,
    signature TEXT NOT NULL,
    weight REAL NOT NULL,
    confidence REAL NOT NULL,
    observation_count INTEGER NOT NULL DEFAULT 1,
    first_seen TEXT NOT NULL,
    last_seen TEXT NOT NULL,
    PRIMARY KEY (signature_type, signature)
);

CREATE INDEX IF NOT EXISTS idx_signature_type ON learned_weights(signature_type);
CREATE INDEX IF NOT EXISTS idx_confidence ON learned_weights(confidence);
CREATE INDEX IF NOT EXISTS idx_last_seen ON learned_weights(last_seen);

यदि आप को बड़े पैमाने पर स्केल की आवश्यकता है, PostgreSQL में स्व्वाप करें. यदि आपको HA या अनुकरण की जरूरत है, Redis या एक वितरित कैश से स्वॉप करें।

एवोल्यूशन के रूप में DiSE Tie-In - असफलता