Більшість архітектур програмного забезпечення вважають, що система є статичною. DiSE припускає, що система жива.
Примітка: Це частина 4 у серії серіалів " Пошук з DiSE ." Див. Частина 1, Частина 2: Випускні програми, і Частина 3: Ненадійні боги Тло. Ця стаття є архітектурним оглядом, а тепер ми маємо реалізацію для роботи з C#: three locid. bottom definition.
Ключова концепція: "Бехворий вихід." За допомогою цієї архітектури можна створити нову категорію, де буде показано прозорий, придатний до налаштування " об' єкти " детекторів і систем навчання рефлективно маршрутизувати трафік на основі набутих шаблонів поведінки, а не статичних правил. Шлюз YARP, боти ніколи не досягають вашого сервера або використовуйте середню програму для побудови поведінкових маршрутизаторів безпосередньо у шарі вашої програми.
Роками ми будували програмне забезпечення, як-от годинник: вхідні, вихідні дані, правила, трубопроводи, тести, розповсюдження, всі лінійні, всі передбачувані.
Але сучасні системи, особливо ШІ, більше не поводяться, як годинники, вони поводяться як екосистеми:
Статична архітектура не може продовжуватися. Ви залатуєте одну дірку, з' явиться ще три. Ви налаштовуєте одну поріг, щось інше ламається. Ви завжди реагуєте, ніколи не пристосовуєтесь.
Архітектура DiSE (Свинтована Синтетична еволюція) ставиться до програмного забезпечення так, як біологи ставляться до організмів: як до чогось, що має адаптуватися, самовиправитись і поліпшуватись під тиском.
Традиційна архітектура:
flowchart LR
B[Build] --> S[Ship] --> P[Patch] --> B
style B stroke:#6366f1,stroke-width:2px
style P stroke:#ef4444,stroke-width:2px
Архітектура DiSE:
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
Система діЕ має чотири основні процеси поведінки:
♪ Behaviour ♪ Що вона робить ♪ |-----------|--------------|----------------------| | Проникливий Дзвінки з навколишнього середовища | Обчислити Д_ д. д. д. д. д. д. д. д. д. д. д. д. | Mutate Д. д. д. д. д. д. д. д. д. д. д. д. д. д. ст. | Вибрати ♪ Keep what works, die what does not't Natural select ♪
Це не метафора, а те, як ваша система з часом розвиває розумну поведінку.
three locid. bottom definition Це перша C# реалізація принципів DiSE. Давайте оглянемо архітектуру:
Система використовує a Орхіатор дошки - детектори надають свідчення спільному штату, викликаючи інші детектори під час накопичення сигналів:
// 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
}
}
Невдалі детектори тимчасово вимкнено. Після охолодження програма повторить спробу (піввідкритого стану). тиск вибору на рівні інфраструктури.
Коли система виявляє з високою впевненістю, learns опублікувати в автобусі для навчання події:
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
}
});
}
Це живиться у крамничку ваги, і з часом в нього з'являються набуті геуристичні детектори.
Замість одного "АІ-мозка," ДіСЕ використовує шарну когнітивну систему:
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
♪ |-------|-------|---------|----------------------| | Статична евристика <1 мм} Унстинтіт bot UA patterns | Detectors \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ >\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ >\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ > | Навчання евристики 1'ms} Динамічна класифікація ♪ Логічна регресія з набутими вагами ♪ | LLM * 50-500 мм' см ♪' Порівняно з малюнними шаблонами ♪ | Навчання ♪ Someground applications, rememberization ♪
Ключове визначення: система вчиться самостійної ваги у режимі реального часу. Зовнішні моделі ML не потрібні. Геуристичний детектор починається з типових і розвивається на основі зворотного пошуку.
Майбутнє: Моделі ONNX за допомогою RAG і вбудовування плануються для v2. Поточний вивід геуристичної моделі слугує міткою тренувальних даних для майбутніх моделей. У архітектурі вже є артефакти " genetic " (постачальники, ваги, сигнали), які роблять додавання прямого штучного еволюції простим - його розроблено як точку додатка.
Це відображення біологічної когнітивності:
Ось ще один розумний крок. Замість надсилання зовнішньої моделі ML, система вчиться власного класифікатора за допомогою простого логістичного регресії з динамічним видобуванням функцій:
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, ...);
}
}
Це мутація через спостереженняЗ часом ваги сходяться до оптимальних значень для ваших специфічних трафіків.
У DiSE галюцинація LLM не є вадою. Це генеративна субстратація еволюції.
Високомодернірний 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;
}
Лише найбільш пристосовані до виживання у виробництві. Це перетворює LLM від ламких chatbots на Еволюційні оператори.
У центрі ДіЕ система правил - іменовані налаштування, за допомогою яких можна визначити спосіб виявлення поведінки:
{
"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
}
}
}
Правила визначають:
Система може перехід між двома правилами середньо- реquest...Непевні результати швидкого маршруту розширюються до повного демонстраційного трубопроводу. адаптивне маршрутизування - геном відповідає на докази в реальному часі.
Ви не пересилаєте статичні налаштування. Поведінковий вид це адаптується до трафіку.
Кожна система 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
}
}
Ми не оптимізуємо точність самостійно. виживання в динамічному середовищі.
Забагато комп'ютерного інтелекту → Висока вартість, погана спізнення. Замало комп'ютера → Погане виявлення нових нападів. Надто агресивні → фальшиві позитивності, сердиті користувачі. Надто поблажливі → ботинки.
Система повинна знайти стабільну рівновагу. Тиск керує еволюцією.
Зріла система DISE зміщує комп' ютерний гравець з гарячого шляху:
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
З часом:
І стає так:
Це не залежить від ритму. Адаптивне риштування.
З Шлюз 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
Ключові концепції:
Це не просто "виявлення роботів на межі." Це новий примітивний шлях, де трафік змінюється завдяки набутим шаблонам поведінки, а не лише статичним правилам.
Більшість інженерних культур бояться:
DISE використовує їх як будівельні матеріали.
Статичні системи гинуть.
Кожна індустрія, що має справу з противниками, дрейфами чи масштабним тиском, врешті-решт потребуватиме таких архітектур:
Давайте я поясню, чому це не є:
DiSE контролюється, і її можна пояснити:
Це спрямований Еволюція - керована, а не випадкова.
three locid. bottom definition реалізує ці принципи:
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 - це перехід від програмного забезпечення як машини до програмного забезпечення як організми.
Це архітектура:
Статична архітектура не може стежити за динамічними середовищами. Розвиток атак. Користувачі розвиваються. Вимоги розвиваються.
Системи також повинні розвиватися.
Якщо ви хочете, щоб системи, які просто працюють, вибудували їх по-старому. Якщо вам потрібні системи пережити - Збудуйте з DiSE.
© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.