Back to "Усвідомлення LRUs - Коли надмірна пропускна спроможність покращує вашу систему"

This is a viewer only at the moment see the article on how this works.

To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk

This is a preview from the server running through my markdig pipeline

Architecture ASP.NET Bot Detection Caching CQRS Systems Design

Усвідомлення LRUs - Коли надмірна пропускна спроможність покращує вашу систему

Tuesday, 09 December 2025

Більшість систем погіршується, коли перенавантаження надмірне. Пам 'ять заповнюється , пошуки уповільнюються МSK2 користувачі скаржаться

Кілька незвичайних краще.

Ця стаття показує, як На основі поведінкової пам 'яті стає оптимізованим, коли досягає пропускної спроможності - і як ця модель підштовхує систему навчання у моєму робот-детектор. Це також найменша можлива версія Архітектура DiSE - контрольована еволюція за допомогою ресурсного тискуM SK1

Якщо ви читали мою статтю на CQRS і пошук подій, ви ' зрозумієте деякі з цих шаблонів тут МSK2 Але це CQRS відрізаний до кістки МSK3 ніякого магазину подій МСК4 ніяких проекцій М СК5 ніякої Мартена M СК6 просто пам 'яті в кэші М S К 7 працівника-заходника М ็ С К 8 і SQLite М М С К 9

Базова ідея - Загадування про поведінку на бюджеті

Перед тим, як зануритися в ",", дозвольте мені визначити один термін: підпис. Список - це будь-який стабільний ключ, що представляє модель поведінки. - hash IP.

Що, якби ви могли побудувати систему,

  • Відповіді в 1ms
  • Ніколи не блокує написання бази даних
  • Саморобно оптимізується під тиском
  • Забув, що не має значення
  • Пам 'ятає, що робить

Це саме те, що IMemoryCache з знижуванням терміну випуску дає вам - якщо ви розумієте, що ви будуєте

Що насправді робить LRU Cache

LRU (Скоріше нещодавно використане ) кеши викидають записи, які ще не були доступні M SK2 недавно не accessed . Коли кэш заповнюється МSK4 найхолодніші записи викидаються, щоб зробити місце для гарячих MSC5

Більшість розробників вважають це обмеженням. " Ні, МSK1 моя кэша повна , дані втрачаються

Але у поведінкових системах це - властива риса

// From WeightStore.cs - the bounded memory window
_cache = new MemoryCache(new MemoryCacheOptions
{
    SizeLimit = _cacheSize,           // e.g., 1000 entries
    CompactionPercentage = 0.25       // Remove 25% when limit reached
});

Це SizeLimit Це не просто обмеження пам 'яті, це тиск відбору. Це визначає, наскільки система " пам 'ятає МSK2 і змушує її зосередитися на тому, що має значення

Закінчується Sliding - Час, який забув

Вкупі з повільним вимиранням, ви отримуєте автоматичне забуттяM SK1

// From WeightStore.cs:254-259
private MemoryCacheEntryOptions GetCacheEntryOptions()
{
    return new MemoryCacheEntryOptions()
        .SetSlidingExpiration(_slidingExpiration)  // 30 minutes
        .SetSize(1);  // Each entry counts as 1 toward size limit
}

Якщо підпис не доступний впродовж 30 хвилин МSK2 він МSK3 викидається . Не тому, що він неправильний

Це створює природнє забування:

  • І Пі переназначуються
  • Bots обертає підписи
  • Похилення трафіку
  • Вчора атаки були такими ж, як і сьогодні

Статичні блоквізори застаріли. Слідове вимирання зберігає пам 'ять свіжеюM SK1

Модель IMemoryCache - Невеликий CQRS, не кажучи про це

Ось pattern, який дозволяє йому працювати SqliteWeightStore клас:

/// <summary>
///     SQLite implementation of the weight store with sliding expiration memory cache.
///     Uses a CQRS-style pattern with write-behind:
///     - Reads: Hit memory cache first (fast path), fall back to SQLite on miss
///     - Writes: Update cache immediately, queue SQLite writes for background flush
///     Sliding expiration provides automatic LRU-like eviction behavior.
/// </summary>

public class SqliteWeightStore : IWeightStore, IAsyncDisposable
{
    // Memory cache with sliding expiration - auto-evicts least recently used entries
    private readonly MemoryCache _cache;

    // Write-behind queue for batched SQLite persistence
    private readonly ConcurrentDictionary<string, PendingWrite> _pendingWrites = new();
    private readonly Timer _flushTimer;
    private readonly TimeSpan _flushInterval = TimeSpan.FromMilliseconds(500);

Це Неформальний CQRS - але без нудної невизначностіキャッシュуM SK1 Замість того, щоб невиняти записиキャッシュу після записів, кэш - це модель запису. SQLite - це просто міцний уявний документ

flowchart LR
    subgraph Cache["In-Memory Behaviour Store"]
        A[Hot Signatures] --- B[Sliding Expiry]
    end
    subgraph DB["SQLite Ledger"]
        C[(Durable Write-Behind)]
    end

    A --Periodic Flush--> C
    B --Eviction--> D[Forgotten]

    style Cache fill:none,stroke:#10b981,stroke-width:2px
    style DB fill:none,stroke:#6366f1,stroke-width:2px

Ключеві ідеї: читає і пише у пам 'ять. База даних в кінцевому підсумку є послідовною -, а це МSK2 - штрафом

Шлях для читання - Первісінько вキャッシュі , Завжди

Коли детектор потребує запам 'ятовуваної ваги, він потрапляє в кэшM SK1

// From WeightStore.cs:421-472
public async Task<double> GetWeightAsync(
    string signatureType,
    string signature,
    CancellationToken ct = default)
{
    var key = CacheKey(signatureType, signature);

    // Check cache first (fast path - no DB access)
    if (_cache.TryGetValue(key, out LearnedWeight? cached) && cached != null)
    {
        _metrics?.RecordCacheHit(signatureType);
        return cached.Weight * cached.Confidence;
    }

    _metrics?.RecordCacheMiss(signatureType);

    // Cache miss - load from DB
    await EnsureInitializedAsync(ct);

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

    var sql = $@"
        SELECT weight, confidence, observation_count, first_seen, last_seen
        FROM {TableName}
        WHERE signature_type = @type AND signature = @sig
    ";

    // ... execute query ...

    if (await reader.ReadAsync(ct))
    {
        // Cache the result for future reads
        var learnedWeight = new LearnedWeight { /* ... */ };
        _cache.Set(key, learnedWeight, GetCacheEntryOptions());

        return weight * confidence;
    }

    return 0.0;  // No learned weight exists
}

Горячі шляхи ніколи не вбиває бази даних. Cache - це джерело правдивості для odczytу . SQLite - це тільки резервна копія

Шлях запису - Cache Immediately, Persist Later

Коли система дізнається щось нове, вона миттєво обновлює キャッシュ і чергає базу даних записом:

// From WeightStore.cs:551-582
public Task UpdateWeightAsync(
    string signatureType,
    string signature,
    double weight,
    double confidence,
    int observationCount,
    CancellationToken ct = default)
{
    var key = CacheKey(signatureType, signature);

    // Update cache immediately (source of truth for reads)
    var learnedWeight = new LearnedWeight
    {
        SignatureType = signatureType,
        Signature = signature,
        Weight = weight,
        Confidence = confidence,
        ObservationCount = observationCount,
        FirstSeen = DateTimeOffset.UtcNow,
        LastSeen = DateTimeOffset.UtcNow
    };
    _cache.Set(key, learnedWeight, GetCacheEntryOptions());

    // Queue for async SQLite persistence (write-behind)
    QueueWrite(signatureType, signature, weight, confidence, observationCount);

    return Task.CompletedTask;
}

Застерег: UpdateWeightAsync повертається Task.CompletedTask - це ' по суті синхронний. запис зачеплений в чергах

  • -мілісекундна затримка запису
  • Ніяких блокувань на I/O
  • Письми з 'єднуються: (самісінькі перемоги записуM SK1

Флюшер на фоні - МSK1м Boring Magic

Кожні залишені записи 500msM SK1 переміщаються на SQLite в одному пакеті

// From WeightStore.cs:274-357
public async Task FlushPendingWritesAsync(CancellationToken ct = default)
{
    if (_pendingWrites.IsEmpty) return;

    // Only one flush at a time
    if (!await _flushLock.WaitAsync(0, ct)) return;

    try
    {
        await EnsureInitializedAsync(ct);

        // Snapshot and clear pending writes atomically
        var writes = new List<PendingWrite>();
        foreach (var key in _pendingWrites.Keys.ToList())
        {
            if (_pendingWrites.TryRemove(key, out var write))
            {
                writes.Add(write);
            }
        }

        if (writes.Count == 0) return;

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

        try
        {
            var sql = $@"
                INSERT INTO {TableName}
                    (signature_type, signature, weight, confidence,
                     observation_count, first_seen, last_seen)
                VALUES (@type, @sig, @weight, @conf, @count, @now, @now)
                ON CONFLICT(signature_type, signature) DO UPDATE SET
                    weight = @weight,
                    confidence = @conf,
                    observation_count = @count,
                    last_seen = @now
            ";

            foreach (var write in writes)
            {
                await using var cmd = new SqliteCommand(sql, conn, transaction);
                // ... add parameters and execute ...
            }

            await transaction.CommitAsync(ct);
            _logger.LogDebug("Flushed {Count} pending writes in {Duration:F1}ms",
                writes.Count, sw.ElapsedMilliseconds);
        }
        catch
        {
            await transaction.RollbackAsync(ct);
            throw;
        }
    }
    finally
    {
        _flushLock.Release();
    }
}

Це event-sourcingM SK1light. Ви отримуєте

  • Команда записує: (ефективний I/OM SK2
  • Транзакційна послідовність
  • Коалізовані aktualiзації ( якщо один і той самий підпис буде обновлений МSK1 разів в МSK2 ms , тільки остаточне значення записується
  • SQLite цілком задоволений цим шаблоном доступу

Обновлення EMA - Навчання з експоненційними показниками руху

Коли приходить нове спостереження, система використовує експоненційні рухові середини, щоб підлаштувати ваги,

// From WeightStore.cs:584-635
public Task RecordObservationAsync(
    string signatureType,
    string signature,
    bool wasBot,
    double detectionConfidence,
    CancellationToken ct = default)
{
    var key = CacheKey(signatureType, signature);

    // Calculate new weight using EMA in memory
    var alpha = 0.1;  // Learning rate
    var weightDelta = wasBot ? detectionConfidence : -detectionConfidence;

    double newWeight;
    double newConfidence;
    int newObservationCount;

    if (_cache.TryGetValue(key, out LearnedWeight? existing) && existing != null)
    {
        // Apply EMA: new_weight = old_weight * (1-α) + delta * α
        newWeight = existing.Weight * (1 - alpha) + weightDelta * alpha;
        newConfidence = Math.Min(1.0, existing.Confidence + detectionConfidence * 0.01);
        newObservationCount = existing.ObservationCount + 1;
    }
    else
    {
        // First observation
        newWeight = weightDelta;
        newConfidence = detectionConfidence;
        newObservationCount = 1;
    }

    // Update cache immediately
    var learnedWeight = new LearnedWeight
    {
        SignatureType = signatureType,
        Signature = signature,
        Weight = newWeight,
        Confidence = newConfidence,
        ObservationCount = newObservationCount,
        FirstSeen = existing?.FirstSeen ?? DateTimeOffset.UtcNow,
        LastSeen = DateTimeOffset.UtcNow
    };
    _cache.Set(key, learnedWeight, GetCacheEntryOptions());

    // Queue for persistence
    QueueWrite(signatureType, signature, newWeight, newConfidence, newObservationCount);

    return Task.CompletedTask;
}

Формула EMA полегшує навчання: new_weight = old_weight × (1 - α) + new_value × α

З α = МSK1

  • Нові докази допомагають 10%
  • Історічні факти допомагають 90%
  • Це запобігає диким коливанням від одного спостереження

Чому перетік створює систему Краще

Ось найголовніша думка, яку більшість людей не помічає

Коли кэш заповнений:

  • Нижчі-частотні підписи зникають
  • Лише гарячі (часто доступні МSK1 підписи залишаються в пам 'яті
  • База даних відстає на один цикл поливу -, а МSK1 - на значній.
  • Система фокуси під тиском

Подумайте про це. : якщо 50,000 унікальні підписи потрапили на ваш робот-детектор МSK2 але у вас є лише пам 'ять для МSK3 які підписи мають значення

Найжахливіший 10,000 -, які зазвичай представляють МSK1 реального рухуM SK2

У процесі виробництва я бачу приблизно 40,000 один МSK2 без підписів на день ( зламувачи, які пробують один раз МSK4 випадкові пробои \ , законних користувачів, які ніколи не повертаються \ МSK6 \ і, можливо, \5–10,000 , що повторюються постійно \

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

Переповнення острівнює поведінкова пам 'ять. Самовідтворення системи

Коли перетік не допомагає

Це не магія. МСК1. Є крайні випадки, коли тиск ЛУ працює проти вас. МSK2

  • Кэш занадто маленький: Якщо в вашому кэші є тільки МSK1 записи, але у вас є МSK2 дійсно важливі підписи , ви МСК4 постійно перевертаєтесь і втрачаєте корисні шаблони перед тим, як вони накопичують достатньо доказів М СК5 розмір вашого кэшу для того, щоб комфортно тримати ваш

  • Об 'єднаний рух: Якщо ви' працюєте на крихітній внутрішньой системі, де майже все є гаряче " гаряча МSK3 МSK4 небагато унікальних підписів

  • Cold-починка проблеми: Недавно запущена система не має вчиних кілограмів . Все однаково холодно МSK2 Перші кілька годин будуть мати вищий хибний позитивний рівень, доки гарячі підписи не з 'являться

Модель працює найкраще, коли ви високий кардінальність з потужністю- правового розподілу - багато унікальних підписів , але маленька підмножина, яка домінує трафіком МSK2 Це те, що МSK3 точно так виглядає, як робота-детектор

Утримкаキャッシュу та бази даних в синхронізації - Tag-Based Invalidation

Мережа є джерелом правдивості для odczytів,, але база даних - міцний ledger. Що відбувається, коли вони дрейфуютьM SK2

Синхронізація провалу

Коли вага бази даних руйнується, кэш має слідуватиM SK1 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% із своїх записівM SK1, визначивши пріоритети найменш нещодавно використаних МSK2 Наступне читання перезагрузить нові дані з бази даних.

Tag-На основі Eviction

Інколи вам потрібно зробити цілу категорію закодованих записів недействительними, наприклад: - when retraining a detector or when external data changes

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

МSK0NET's MemoryCache не має нативного бирку, як у Redis, а compaction досягає такого ж результату. МSK3 змушує видаляти застарілі записи, МSK4 дозволяє читателям переповнюватися з бази даних

Стратегия синхронізації

Найголовнішим є те, що ідеальна синхронізація не обов 'язково. Система толерантна до дрейфу, тому що

  1. Перезавантаження キャッシュу з DB пропустилося - якщо запис видаленоM SK1 наступне читання приймає свіжі дані
  2. Sliding expiration handles staleness - записи недоступні впродовж МSK1 хвилин автоматизовано
  3. Проновлення сили Compaction - періодичне стискання викидає старі записи
  4. Написати-за останніми оновленнями - багато швидких оновлень перетворюються на один запис в DB

Це остаточна послідовність, зроблена правильно. Cache залишається " закрити достатньоM SK2 до бази даних, не використовуючи складну логіку недействування

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. Немає складного паубаM SK1sub. Просто стискання і природнє вимирання .

Ми йдемо глибше: Репутація

Nota: Якщо ви просто хочете, щоб LRU + писало МSK1 за моделью МSK2 ви можете зупинитися тут . Решта цієї статті показує, як я применяю ті ж самі ідеї на повну репутацію шаблону | - | станові машини

Гістереза та падіння

Для репутації шаблону ( відстеження того, чи підпис є роботом або людиною впродовж часу ), стосуються тих самих принципів, але з додатковою складністю

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

Переходи штату з істерезом

Patterns don't flip directly from Neutral to ConfirmedBad

// 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. Це навмисно МSK1 це МSK2 важче прощати, ніж підозрювати

Упадок часу - Eksпоненційне забуття

Коли візерунки спокійні, вони розкладаються на нейтральні,

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

Початкові часові константи:

  • Погіршення балу τМSK0 168 години МSK2 дні ) ♫ ♫ МSK4 ♫ показники рухаються до нейтрального рівня після тижня неактивності
  • Підтримка руйнування τМSK0 336 години МSK2 дні ) - рівень самовпевненості втрачається мSK5 після двох тижнів

Це означає, що підтверджений МСК0 , поганий IP, який мовчить місяцями, врешті-решт повернеться до нейтрального . Не тому, що він реформував "-", бо його докази стали застарілими.

Служба підтримки

І 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+ років
  • Підтримка ≤ МSK1
  • У нейтральному стані

Це запобігає росту безмежного словника в пам 'яті, зберігаючи цінні вивчені шаблони

SQLite - це не жарт - Це ' є ідеальним тут

Багато програмістів реакційно прагнуть до PostgreSQL чи Redis. Але для цього шаблону , SQLite ідеальне МSK2

  1. Написати-за спиною вирішує вузли - SQLite 's singleM SK2writer limitation doesn`t matter when writes are batched
  2. Місцеве зберігання - без затримувань в мережі, без підключень
  3. Нульова конфігурація - просто файловий шлях
  4. Чудово для використання на країні - працює на Raspberry Pi
  5. Переnosимий - база даних - це лише файл, який можна копіювати

skeма мінімальна:

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 або репликаціяM SK2 замінить на Redis чи розповсюдну ឃ្លាំងівку . Архітектура не змінюєМSK4 не змінюється MSC5 лише конектовий стрічок МSK6 SQLite default for edge deployment

Вишкодження зв 'язку DiSE-В - в процесі еволюції

Якщо ДиС є повноцінним еволюційним двигуном , ця модельキャッシュу - митохондрия - найменший шматок, який все ще поводиться як еволюція під обмеженням МSK2

Ця модель вводить принципи DiSE на мінімальному рівні:

  • Скорінність ресурсів → Вибірний тиск
  • Виселення з LRU → Природний відбір МSK1виживці найкращіM SK2
  • Упадок часу → Забуття дозволяє адаптуватися
  • Обновлення EMA → Мутація шляхом спостереження
  • Гістереза → Стабільність через стійкість до змін

Полний кэш - це не "'", а МSK1 . еволюційний тиск. Система сама МSK1 оптимізує МSK2 гарячі підписи залишаються , холодні підписи викидають \ , і поведінкова пам 'ять сходиться до того, що насправді має значення

Жодного навчання ML. Жодних зовнішніх моделейM SK1 Тільки архітектура, яка поводиться як жива система.

Завершення - Прості структури МSK1 Невимушене поведінку

Весь візерунок зводиться до:

  1. Кэш є джерелом правди для читання МSK0 під- milliсекундний доступ
  2. Надписує миттєвий Cache для оновлення, залишиться пізніше МSK0 без блокування I/O
  3. Шлідове вимирання дає автоматичний LRU - вбудована в .NET
  4. Обмежений розмір створює тиск вибору - перетік остриблює фокус
  5. Потік фону зберігає синхронність SQLite - остаточна послідовність непогана
  6. Упадок часу дозволяє забути - застарілі докази зникають

Ваша маленька behavioural store більше схожа на живу систему, ніж CRUD. Вона пам 'ятає, що важливе , забуває, що не важливо МSK2tM SK3 і стає краще під тиском .

Minimalна архітектура → невипадкова коректність . Перепоток → кращий фокус МSK1 Натиск → стабільністьM SK1

Якщо ви хочете побачити це в дії, подивіться найбільш зрозуміле.botdetection - і Серії архітектури DiSE для глибшої філософії.

Ліки

logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.