# Ruoanlaitto DiSE:n kanssa (osa 4): Rakennusjärjestelmät, jotka oppivat, sopeutuvat ja kehittyvät

<!--category-- AI, DiSE, Architecture, Bot Detection, Machine Learning, Systems Design -->
<datetime class="hidden">2025-12-08T12:00</datetime>

Useimmat ohjelmistoarkkitehtuurit olettavat, että järjestelmä on staattinen. DiSE olettaa, että järjestelmä on elossa.

> **Huomaa:** Tämä on osa 4 "Cooking with DiSE" -sarjassa. Katso [Osa 1](/blog/semantidintelligence-part1), [Osa 2: Valmistuneet oppisopimuskoulut](/blog/blog-article-cooking-dise-part2-apprenticeships), ja [Osa 3: Epäluotettavat jumalat](/blog/blog-article-cooking-dise-part3-untrustworthy-gods) Tämä artikkeli on arkkitehtuurin yleiskatsaus - ja nyt meillä on toimiva C#-toteutus: [Enimmäkseen lucid.bottihavaitseminen](/blog/botdetection-introduction).

**Avainkäsite: Käyttäytyminen Roting.** Arkkitehtuuri mahdollistaa uuden kategorian, jossa ilmaisimien ja oppimisjärjestelmien läpinäkyvät, säädettävissä olevat "tiimit" refleksiivisesti reitillä, joka perustuu opittuihin käyttäytymismalleihin, ei staattisiin sääntöihin. [YARP Gateway](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway), botit eivät koskaan saavuta takaosaasi. Tai käytä keskiohjelmistoa rakentaaksesi käyttäytymisreitityksen suoraan sovelluskerrokseen.

[TOC]

## Ongelma: Staattiset järjestelmät dynaamisessa maailmassa

Vuosien ajan olemme rakentaneet ohjelmistoja, kuten kellotöitä: syöttöjä, ulostuloja, sääntöjä, putkistoja, testejä, käyttöönottoa.

Nykyaikaiset järjestelmät, erityisesti tekoälyä käyttävät, eivät kuitenkaan enää käyttäydy kuin kellot. Ne käyttäytyvät kuin ekosysteemit:

- Hyökkääjät kehittävät tekniikoitaan
- Käyttäjät muuttavat käytöstään
- Vaatimukset muuttuvat ajan myötä
- Ympäristö muuttuu jatkuvasti

Staattinen arkkitehtuuri ei pysy mukana, yksi reikä täytetään, kolme ilmestyy, yksi kynnys viritetään, jokin muu murtuu. Reagoit aina, et koskaan mukautu.

**DiSE-arkkitehtuuri** (Directed Synthetic Evolution) kohtelee ohjelmistoja tavalla, jolla biologit kohtelevat organismeja: se on asia, jonka täytyy mukautua, korjata itseään ja parantua paineen alla.

## Ydinidea: Järjestelmät kehittyvät organismeiksi

Perinteinen arkkitehtuuri:

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

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

DiSE-arkkitehtuuri:

```mermaid
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
```

DiSE-järjestelmällä on neljä olennaista käytöstä:

Käyttäytyminen Mitä se tekee Biologisesti vastaava
|-----------|--------------|----------------------|
| **Havaintokyky** Kerää signaaleja ympäristöstä Sensuroivat elimet
| **Arvioi** Tulossignaalit päämääriä vastaan Hermosto
| **Mutaatti** Luo strategioiden muunnelmia Geneettistä mutaatiota
| **Valitse** Pidä mikä toimii, hylkää se, mikä ei ole luonnonvalintaa

Tämä ei ole metafora, vaan kirjaimellisesti se, miten järjestelmäsi kehittyy ajan myötä älykkäämmäksi.

## Konkreettinen esimerkki: Bot detection

[Enimmäkseen lucid.bottihavaitseminen](https://github.com/scottgal/mostlylucid.nugetpackages/tree/main/Mostlylucid.BotDetection) on DiSE-periaatteiden ensimmäinen C#-toteutus. Jäljitetään arkkitehtuuri:

### Havaitseminen: Blackboard Architecture

Järjestelmässä käytetään **liitutauluorkesteri** - ilmaisimet antavat näyttöä yhteisestä tilasta ja laukaisevat muut ilmaisimet signaalien kertyessä:

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

Useita ilmaisimia käynnissä **rinnakkaisaalloissa**Järjestelmä havaitsee ympäristön monien linssien kautta:

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

### Arviointi: painotettu konsensus Sigmoidin kanssa

Näyttö aggregoidaan päätökseksi sigmoid-muunnoksen avulla – näin saadaan aikaan vahvoja signaaleja suuripainoisilta ilmaisimilta:

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

Arvioinnissa ei ole kyse yhdestä ainoasta mallista, joka tekee päätöksen. **painotettu konsensus** Useita erikoistunnistimia - ja ratkaisevaa on, että kun tekoäly ei ole käynnissä, todennäköisyys on **kiristetty** liiallisen itseluottamuksen välttämiseksi:

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

### Varhainen uloskäynti: Nopean polun optimointi

Järjestelmä ei aina suorita kaikkia ilmaisimia. Kun varhainen näyttö on varma, se lähtee nopeasti:

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

Tuotannossa **korkean luottamuksen pyynnöt poistuvat alle 10 ms** Kun vain 2-3 ilmaisinta on samaa mieltä, täysi putki kulkee vain epävarmoja tapauksia varten.

### Circuit Breakers: Itseparannus

Havaittajat voivat epäonnistua. Järjestelmä suojaa itseään:

```csharp
// 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
    }
}
```

Epäonnistuneet ilmaisimet poistetaan väliaikaisesti käytöstä. Jäähdytyksen jälkeen niitä kokeillaan uudelleen (puolittain auki). **Valintapainetta infrastruktuurin tasolla**.

### Mutaatio: Oppimisjärjestelmä

Kun järjestelmä havaitsee suurella varmuudella, se **oppii** julkaisemalla oppimistapahtumabussiin:

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

Tämä syöttää painokauppaan päivittäen heuristisen ilmaisimen opittuja painoja ajan myötä.

## Kognitiivinen pino

DiSE käyttää yhden ainoan "AI-aivon" sijasta kerrostettua kognitiota:

```mermaid
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
```

Layer Speed, Purpose Bot Detection -esimerkki
|-------|-------|---------|----------------------|
| **Staattinen heuristiikka** Aistinvaraiset vastaukset Tunnetut bot UA -mallit
| **Ilmaisimet** Trait-havainnointi Pääanalyysi, IP-tarkastukset
| **Opittu heuristiseksi** Dynaaminen luokitus Logistinen regressio oppineine painoineen
| **LLM** 50-500 ms Syvällinen päättely Uusia malleja analysoidaan
| **Oppiminen** Taustaa Muistinmuodostus Painon päivitykset, maineen muutokset

Avainymmärrys: järjestelmä oppii omat painonsa reaaliajassa. Ulkopuolisia ML-malleja ei tarvita. Heuristinen ilmaisin alkaa järkevillä oletuksilla ja kehittyy havainnointipalautteen perusteella.

> **Tulevaisuus:** ONNX-mallit, joissa on RAG ja upotus, suunnitellaan v2:lle. Nykyisen heuristisen mallin tuotos toimii merkittynä koulutustietona tulevaan mallikoulutukseen. Arkkitehtuurilla on jo "geneettiset" esineet (osuudet, painot, signaalit), jotka tekevät ohjatun synteettisen evoluution lisäämisestä yksinkertaista - se on suunniteltu lisäpisteeksi.

Tämä heijastaa biologista kognitiota:

- **Luontainen immuunijärjestelmä** → Staattinen heuristiikka
- **Adaptatiivinen immuunijärjestelmä** → Opittu heuristinen malli
- **Muistisolut** → Painovarasto + maine

## Heuristinen detektori: Oppiminen ilman ulkoisia malleja

Sen sijaan, että järjestelmä lähettäisi ulkoisen ML-mallin, se oppii oman luokittajansa käyttämällä yksinkertaista logistista regressiota, jossa on dynaamista ominaisuutta:

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

Ominaisuudet poimitaan dynaamisesti pyynnöstä ja kootuista todisteista:

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

Uudet ominaisuudet saavat automaattisesti oletuspainot ja oppivat ajan myötä. Järjestelmä selvittää, mikä on tärkeää.

## Painokauppa: jatkuva oppiminen

Painot pysyvät SQLitessä ja päivittyvät eksponentiaalisen liikkuvan keskiarvon avulla:

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

Tämä on **mutaatio havainnon kautta**Jokainen havainnointi opettaa järjestelmälle jotain. Ajan myötä painot lähentyvät optimaalisia arvoja tiettyihin liikennemalleihin.

## Hallusinaatio mutaationa

DiSE:ssä LLM-hallusinaatio ei ole ötökkä, vaan evoluution generatiivinen substraatti.

Korkean lämpötilan LLM, joka ehdottaa kymmenen muunnelmaa havaintosäännöstä, ei "hallusinoi" – se on **Genomin muuntaminen** järjestelmän kuvaus:

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

Mutaatiot arvioidaan historiallisten tietojen perusteella:

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

Vain vahvimmat selviytyvät tuotantoon. Tämä muuttaa LLM:t hauraasta chatbotista **evolutionaariset toimijat**.

## Genome: Policy-based Configuration

DiSE:n keskiössä on **poliittinen järjestelmä** - nimetyt konfiguraatiot, jotka määrittelevät, miten havainnointi käyttäytyy:

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

Politiikassa määritellään:

- **FastPath-ilmaisimet** - ajaa rinnakkain, sukellusveneitä 10 ms
- **Tekoälypolku** - Heuristinen (1-5 ms) ja/tai LLM (500 ms+)
- **Kynnysarvot** - milloin varhainen poistuminen, milloin tukkiminen
- **Siirtymät** - automaattinen siirtyminen muihin politiikkoihin, kun se on epävarmaa
- **Politiikan mukaiset painot** - viritysilmaisimen merkitys käyttökertaa kohti

Järjestelmä voi **Siirtyminen politiikasta toiseen kesken pyynnön**Epävarmat pikajuoksutulokset yltyvät täyteen demoputkeen. **adaptiivinen reititys** - genomi reagoi todisteisiin reaaliajassa.

Et lähetä staattisia konfiguraatioita, vaan lähetät **Käyttäytymislajit** että sopeutuu liikenteeseen.

## Fitnesstoiminnot: What Survives

Jokainen diSE-järjestelmä optimoituu kuntoiluun:

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

Emme optimoi tarkkuutta yksin, vaan optimoimme **selviytyminen dynaamisessa ympäristössä**.

Liikaa tekoälyä → kalliiksi, huono latenssi.
Liian vähän tekoälyä → uusien hyökkäysten heikkoa havaitsemista.
Liian aggressiivinen → väärät positiiviset, vihaiset käyttäjät.
Liian lempeä → bottitulvat.

Järjestelmän on löydettävä vakaa tasapaino.

## Tekoäly opettajana, ei työntekijänä

Kypsä DiSE-järjestelmä siirtää tekoälyn pois kuumalta polulta:

```mermaid
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
```

Ajan myötä:

- Staattinen ilmaisin parantaa (ai-etikettien avulla)
- Heuristiikka tarkentuu (valinnassa kuntoilu)
- tekoäly käsittelee vain uutuutta ja mutaatiota

Tekoälystä tulee:

- Erytropoietiini **Oraakkeli** uutuuskäytöksille
- Erytropoietiini **generaattori** mutaatioiden määrä
- Erytropoietiini **ajotunnistin**
- Erytropoietiini **opettaja** joka leimaa rajatapaukset

Ei juoksuriippuvuus, vaan mukautuva rakennusteline.

## Käyttäytyminen: Uusi kategoria

• • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • • [YARP Gateway](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway)Tämä arkkitehtuuri mahdollistaa jotain uutta: **Käyttäytymisreititys**.

Perinteinen reititys on staattinen: polku → backend. Käyttäytymisen reititys on refleksiivistä: liikenteen ominaisuudet → dynaamiset reitityspäätökset.

```mermaid
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
```

Avainkäsitteet:

- **Detektoriryhmät** - konfiguroitavat ryhmittymät, jotka toimivat yhdessä, säädettävissä per politiikka
- **Avoimet päätökset** - jokainen reittipäätös on selitettävä (ks. maksuosuuksien erittely)
- **Refleksiivinen säätö** - järjestelmä oppii päätöksistään ja säätää painoja ajan myötä
- **Edge-tasosuojaus** - botit eivät koskaan saavuta takaosaa, reititin on tukossa

Kyse ei ole vain "robottihavaitsemisesta reunalla". Kyseessä on uusi reititysalkukanta, jossa liikennevirtaa muokkaavat opitut käyttäytymismallit, eivät vain staattiset säännöt.

## Miksi tämä on tärkeää

Useimmat insinöörikulttuurit pelkäävät:

- Ei-determinismi
- Ajelehtiminen
- Mutaatio
- Hallusinaatiot
- Vastasyntynyttä käyttäytymistä

DiSE käyttää näitä **rakennusmateriaalit**.

Staattinen järjestelmä sammuu ja kehittyvät järjestelmät selviävät.

Jokainen teollisuudenala, joka on tekemisissä vastustajien, ajelehtimisen tai mittakaavapaineiden kanssa, tarvitsee lopulta tämänkaltaisia arkkitehtuureja:

- Bottihavaitseminen
- Petosmoottorit
- Mukautuvat palomuurit
- LLM-ekosysteemit
- Omaehtoiset mikropalvelut
- Autonomiset vianetsintäjärjestelmät
- **Käyttäytymisen reititys** - liikenteen muokkaaminen opittujen mallien perusteella

## Mitä DiSE ei ole

Haluan tehdä selväksi, mitä tämä ei ole:

- **Ei "isoja LLM:itä kaikkialla"** - LLM:t ovat kalliita, käytä niitä strategisesti.
- **Ei "korvata liikelogiikkaa tekoälyllä"** Heuristiikka on nopeampaa ja ennustettavampaa.
- **Ei "antaa järjestelmän villiintyä"** Evoluutiota ohjataan, ohjataan ja hallitaan.
- **Ei "AutoML steroideja"** Tässä on kyse käytöksestä, ei vain malliäänestämisestä.

DiSE on kontrolloitu, selittävä evoluutio:

- Rajoitusten sitoma
- Hallittu selkeillä kuntotoiminnoilla
- Muistitietoisuus
- Muokattu
- Turvallista käyttöönottoa

Se johtuu siitä, että *ohjattu* Evoluutio - ohjattu, ei satunnainen.

## Kokeile

[Enimmäkseen lucid.bottihavaitseminen](https://www.nuget.org/packages/mostlylucid.botdetection/) toteuttaa nämä periaatteet:

```bash
dotnet add package Mostlylucid.BotDetection
```

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

Määritä tuotanto oppimisella:

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

Heuristinen ilmaisin oppii jokaisesta pyynnöstä ja päivittää painonsa vastaamaan liikennekuvioitasi.

## Päätelmät

DiSE Architecture on siirtyminen ohjelmistoista koneina ohjelmistoihin eliönä.

Se on seuraavien arkkitehtuuri:

- Mukautuvuus
- Kestävyys
- Hallittu kehitys
- Lasillinen kognitio
- Muistiin perustuva oppiminen
- Mutaatio + valinta
- Strateginen käyttäytyminen

Staattinen arkkitehtuuri ei pysy dynaamisen ympäristön tahdissa. Hyökkääjät kehittyvät, käyttäjät kehittyvät ja vaatimukset kehittyvät.

Myös järjestelmien on kehityttävä.

Jos haluat järjestelmiä, jotka vain kulkevat, rakenna ne vanhalla tavalla.
Jos haluat järjestelmiä, jotka **Selviytykää** - Rakenna ne DiSE:n kanssa.