Однією з найпростіших способів пошкодити штучний інтелект - дозволити йому забагато запам 'ятати.

Більшість підходів "зрозумівання контекстуM SK1 зводяться до однієї з двох помилок

• Помістити все в про prompt і сподіваюсь, що модель зрозуміть, що має значення
• Повторно переглянути підсумки і сприймати дрейф як факт життя

Обидві підходи дорого коштують, непрозрачні , і нестабільні на довгому горизонтіM SK2

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

Я називаю це Перетягування обмеженого неясного контексту МSK0CFCD).

Модель в одному реченні

Перетягування обмеженого неясного контексту це модель, в якій можливими моделями запропонують, що є вагомим, але лише детерміністичними правилами можна передати цю вагомість вперед, щоб вплинути на майбутнє мислення або покоління.

Або ще ясніше:

Моделі можуть помітити

Це те ж саме філософське розкол, що і Стримана неясність і Обмежений фузій МСМ - щойно застосували вздовж вісь часу замість вісь прийняття рішень.

Найважливіша помилка в тому, як сприймати контекст як текст

ЛЛМ не мають МСК0 пам 'ятайтеМSK1 Вони мають шаблон - співпадіння над символами МSK3

Коли ми розглядаємо контекст як "just more text", ми отримуємоM SK2

• тихий дрейф
• неоднозначна термінологія
• втрачена вартість
• підсумки, які суперечать попереднім підсумкам
• переклади, які перетворюють одне й те ж слово п 'ять разів
• контекст стає неверізованою залежністю ( ніхто не знає, що змінилося , але результати змінилися МSK2

Довгі контекстні вікна не розв 'язують цього. Вони просто затримають невдачі.

Справжнє питання - скільки контексту, щоб зберегти, алеM SK1

Що заслуговує на виживання?

Правило CFCD

CFCD стверджує жорстке відокремлення:

Ймовірність може запропонувати. Детермінізм вирішує, що рухається вперед

Детерміністичне значення: ті самі вхідні дані + ті самі правила МSK1 ті ж ланцюги. Ви все ще можете використовувати ймовірністі бали ; ви просто прокручуєте їх через фіксоване підвищення МSK2 функції, що закінчуються

CFCD - це те, як ви отримуєте переваги контексту без платити за контекст

До прикладу 1: Підсумування ( вертикальне перетягуванняM SK2

Наївний підхід

• Дорожній документ
• Підсумувати кожен шматок
• Підсумувати підсумки
• Прийміть дрейф

Це не працює, тому що:

• поєднання ранніх помилок
• акцент змінюється навмисно
• протиріччя приховані

Погляньмо на CFCD

Найголовніша думка: виявлення salience не потребує LLM. Ви можете використати детермінативний ML (вбудовані модулі МSK2 TF МSK3IDF \ , BM \ МSK5 для того, щоб знайти те, що має значення

DocSummarizer implements this:

1. Розглянемо документ у сегменти ( реченняM SK1 заголовки , переліки МSK3 кодові блоки )
2. Виgenerувати вбудова використовуючи ONNX речення-трансформатори (MLM SK2 не LLM)
3. Вирахуйте показники salience за допомогою:
   • Схожість косину з документом центроїд
   • TF-IDF для значення терміну
   • Веси місця (introM SK1conclusion boost)
   • Содержание-регулювання типу M SK1наративний vs екзпозиторний)
4. Виbierz верхню частину-K, використовуючи MMR (Максимальна маргинальна важливістьM SK1
   • Досконалість балансу (подібність до центроїдів МSK1 з різноманіттю
   • Детерміністичне: ті самі вхідні дані M SK1 той самий вибір
5. LLM синтезує лише з обраних сегментів

LLM ніколи не бачить повного документу.

// From DocSummarizer: SegmentExtractor.cs
public class SegmentExtractor
{
    private readonly OnnxEmbeddingService _embeddingService;  // ML, not LLM

    public async Task<ExtractionResult> ExtractAsync(string docId, string markdown)
    {
        // 1. Parse document into typed segments
        var segments = ParseToSegments(docId, markdown);

        // 2. For large docs: semantic pre-filtering with multi-anchor approach
        //    - Guaranteed coverage: first/last sentences per section, constraints
        //    - BM25 candidate generation with pseudo-query from TF-IDF terms
        //    - Topic anchors via k-means clustering on sample embeddings
        if (segments.Count > _config.MaxSegmentsToEmbed)
        {
            (segmentsToEmbed, centroid) = await SemanticPreFilterAsync(segments, targetCount);
        }
        else
        {
            await GenerateEmbeddingsAsync(segments);
            centroid = CalculateCentroid(segments);
        }

        // 3. Score by salience using MMR (deterministic)
        //    Salience = lambda * sim(segment, centroid) * position_weight * content_weight
        //             - (1 - lambda) * max_sim(segment, higher_ranked_segments)
        ComputeSalienceScores(segments, centroid, contentType);

        // 4. Return top-K as anchors for synthesis
        var topBySalience = segments
            .OrderByDescending(s => s.SalienceScore)
            .Take(Math.Max(_config.FallbackBucketSize, targetCount))
            .ToList();

        return new ExtractionResult
        {
            AllSegments = segments,
            TopBySalience = topBySalience,
            Centroid = centroid,
            ContentType = contentType
        };
    }

    /// <summary>
    /// Greedy MMR selection: balances relevance with diversity
    /// </summary>

    private void ComputeSalienceScores(List<Segment> segments, float[] centroid, ContentType contentType)
    {
        var candidates = new HashSet<Segment>(segments.Where(s => s.Embedding != null));
        var ranked = new List<Segment>();

        // Pre-compute centroid similarities with content-type adjustments
        foreach (var segment in candidates)
        {
            var baseSim = CosineSimilarity(segment.Embedding!, centroid);
            var contentWeight = ComputeContentTypeWeight(segment, contentType);
            segment.SalienceScore = baseSim * segment.PositionWeight * contentWeight;
        }

        // Greedy MMR: pick best, penalise similar, repeat
        while (candidates.Count > 0)
        {
            var best = candidates
                .Select(c => new {
                    Segment = c,
                    Score = _config.MmrLambda * c.SalienceScore
                          - (1 - _config.MmrLambda) * MaxSimToRanked(c, ranked)
                })
                .OrderByDescending(x => x.Score)
                .First();

            best.Segment.SalienceScore = 1.0 - ((double)ranked.Count / segments.Count);
            ranked.Add(best.Segment);
            candidates.Remove(best.Segment);
        }
    }
}

Адаптивний вибір: Усвідомлення контексту

Тому що вихідний код рейтингова колекція, ви можете адаптувати число засадок до моделі синтезу під час запуску

public class AdaptiveSynthesizer
{
    public int ComputeAnchorBudget(ModelProfile model, ExtractionResult extraction)
    {
        // Larger context windows → more anchors
        var baseTokenBudget = model.ContextWindow / 4;  // Reserve 25% for output

        // More powerful models → can handle more complex synthesis
        var complexityMultiplier = model.Tier switch
        {
            ModelTier.Small => 0.5,   // tinyllama: fewer, simpler anchors
            ModelTier.Medium => 1.0,  // llama3.2:3b: standard
            ModelTier.Large => 1.5,   // llama3.1:8b+: more context, nuanced synthesis
            _ => 1.0
        };

        var anchorBudget = (int)(baseTokenBudget * complexityMultiplier / _avgTokensPerSegment);

        // Never exceed what we have
        return Math.Min(anchorBudget, extraction.TopBySalience.Count);
    }

    public async Task<Summary> SynthesizeAsync(
        ExtractionResult extraction,
        ModelProfile model)
    {
        var budget = ComputeAnchorBudget(model, extraction);

        // Take top-K from already-ranked segments
        var anchors = extraction.TopBySalience.Take(budget).ToList();

        // Synthesis model only sees what survived selection + adaptation
        return await _llm.SynthesizeAsync(anchors, model);
    }
}

Це все ще детерміністичне: ті самі вхідні дані + той самий модельний профиль МSK1 ті самі ланцюги. Рейтинг відбувається один раз МSK1 адаптація - це лише шматок МSK2

Це означає, що

• Використовуйте швидку маленьку модель з анкерами 5 для швидких підсумків
• Використовуйте потужну модель з 50 засадками для комплексного аналізу
• Динамично врегулювати середню трубу -, якщо перший спроба не має по coverage

Найголовніша думка: прикріплення - це структура, а не проза. Вбудова та MMR є детерміністичними МSK1 LLM робить тільки остаточну синтезу МSK2 обмеженою тим, що вижили .

Контракт на ancoraння: генерація може відрізнятися формулюванням, але не повинна протистояти ланцюгам

Конкретне представлення锚а:

{
  "policyVersion": "cfcd-v1",
  "segments": [
    {"id":"seg-12","text":"Reset requires holding button 10s","salience":0.92},
    {"id":"seg-45","text":"Factory reset clears all settings","salience":0.88}
  ],
  "coverage": "3.2% semantic sample",
  "hedging": "sampled 3% - avoid definitive conclusions"
}

До прикладу 2: Перетворення

Перевод exposses this pattern even more clearly.

Модій провалу

Перевести речення

• неоднозначна термінологія
• переименовані об 'єкти
• тонкий семантичний дрейф

Навіть з величезним контекстним вікном , моделі все ще " почуваються вільними МSK2 змінювати фрази

Погляньмо на CFCD

1. Спочатку в уривок dokumentu, кандидати в термінологію:
   • відповідних іменників
   • технічні терміни
   • повторювані фрази
2. Збудувати терміновий банкнот:
   • джерело →
   • впевненість
   • перший-ви бачили місце розташування
3. Для кожного речення:
   • дозволити незрозумілий переклад
   • стримати вибір, використовуючи книгу
   • дозволити відхилення лише з сильним локальним доказом
4. Обновлюйте ledger детерміністично, якщо:
   • знов і знову з 'являється краще картування
   • або оголошується explicit override

Що є сильним локальним доказом?

• Термин з 'являється в словнику, таблиціM SK1 або блокі визначення ( структурні знакиMSC3
• В налаштуваннях explicit user override
• Повторюється впродовж останніх частин W (швидкішний вікноM SK1 з послідовним використанням

Це детерміністичне: структурні сигнали виявлені за допомогою класифікації шаблону або аналітикаM SK1 а не модельного судження.

Поліція за замовчанням МСК0 Δ МSK1 розрив у довірі , W=50 шматки M SK4 fortuna per domain ).

public class TermLedger
{
    private readonly Dictionary<string, TermMapping> _mappings = new();

    public record TermMapping(
        string SourceTerm,
        string TargetTerm,
        float Confidence,
        string FirstSeenChunkId,
        int LastSeenChunkIndex,               // Track recency
        int VotesForCurrentTarget,
        int TotalVotes,                       // Preserve history
        string? ChallengerTarget = null,
        int ChallengerVotes = 0,
        float ChallengerConfidence = 0);

    public void ProposeMapping(string source, string target, float confidence, string chunkId, int chunkIndex)
    {
        source = source.ToLowerInvariant().Trim();

        if (_mappings.TryGetValue(source, out var existing))
        {
            if (existing.TargetTerm == target)
            {
                // Same as current: accumulate votes
                _mappings[source] = existing with
                {
                    Confidence = Math.Max(existing.Confidence, confidence),
                    VotesForCurrentTarget = existing.VotesForCurrentTarget + 1,
                    TotalVotes = existing.TotalVotes + 1,
                    LastSeenChunkIndex = chunkIndex
                };
            }
            else if (existing.ChallengerTarget == target)
            {
                // Same as challenger: accumulate challenger votes
                var newChallengerVotes = existing.ChallengerVotes + 1;
                var newChallengerConfidence = Math.Max(existing.ChallengerConfidence, confidence);

                // Switch if challenger has >= 2 votes AND higher confidence
                if (newChallengerVotes >= 2 && newChallengerConfidence > existing.Confidence)
                {
                    // Swap: old current becomes challenger, challenger becomes current
                    _mappings[source] = existing with
                    {
                        TargetTerm = target,
                        Confidence = newChallengerConfidence,
                        VotesForCurrentTarget = newChallengerVotes,
                        TotalVotes = existing.TotalVotes + 1,
                        LastSeenChunkIndex = chunkIndex,
                        ChallengerTarget = existing.TargetTerm,  // Preserve old mapping as challenger
                        ChallengerVotes = existing.VotesForCurrentTarget,
                        ChallengerConfidence = existing.Confidence
                    };
                }
                else
                {
                    _mappings[source] = existing with
                    {
                        ChallengerVotes = newChallengerVotes,
                        ChallengerConfidence = newChallengerConfidence,
                        TotalVotes = existing.TotalVotes + 1,
                        LastSeenChunkIndex = chunkIndex
                    };
                }
            }
            else if (confidence > existing.ChallengerConfidence)
            {
                // New challenger replaces old challenger
                _mappings[source] = existing with
                {
                    ChallengerTarget = target,
                    ChallengerVotes = 1,
                    ChallengerConfidence = confidence,
                    TotalVotes = existing.TotalVotes + 1,
                    LastSeenChunkIndex = chunkIndex
                };
            }
        }
        else
        {
            _mappings[source] = new TermMapping(
                source, target, confidence, chunkId, chunkIndex,
                VotesForCurrentTarget: 1, TotalVotes: 1);
        }
    }

    public string? GetCanonicalTranslation(string source)
    {
        source = source.ToLowerInvariant().Trim();
        return _mappings.TryGetValue(source, out var mapping)
            ? mapping.TargetTerm
            : null;
    }
}

У практиці ви також хочете, щоб голос застарів. ( або ліхтарне вікно. ) так, що ранні помилки не стають постійними. МSK3 Головне, що правило застарівання є детерміністичним.

Чому це важливо для виправлення: Якщо переклад перевертається: "factory reset " mid-documentM SK3 ви можете відокремити ledger і побачити точно, коли та чому

chunk-12: "factory reset" → "Werkseinstellungen" (votes: 3, conf: 0.82)
chunk-47: challenger "Zurücksetzen" reaches 2 votes, conf: 0.91
chunk-47: SWITCH - "factory reset" → "Zurücksetzen" (old mapping preserved as challenger)

Ніяких підозрювань МСК0 Ні МSK1модель тільки-но вирішила ". Невидимий, детерміністичнийМSK4 перевіряєтьсяM SK5

Це дає вам:

• локальна гнучкість (модель управляє формулюваннямиM SK1
• глобальна послідовність (лідер встановлює термінологіюM SK1
• обмежені витрати ( не обов 'язково перекладати
• перевірямі рішення ( залог піддається інспектації )

Ось чому послідовність термінів не можна розв 'язати за допомогою " тільки більше контекстуM SK1

Це не пам 'ять - Це просування обмежень

CFCD робить не дати модель пам 'яті.

Він дає система пам 'ять.

Модель:

• не володіє державою
• не вирішує, що залишається
• не має власного контексту

Система:

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

Правила закінчування терміну (детерміністичнийM SK1 немодельний -останавлений МSK3

• Час-на основіM SK1 прикріплення закінчуються після T не звертаючись до
• Використовуйте-на основі: ланкери з нульовими відбитками N наступні шматочки руйнуються
• Контрадіція-на основіM SK1 спірник має ≥2 голоси І перевершує теперішній рівень довіри ΔM SK1 в скрутному вікні частин W

Ця різниця - це все.

flowchart TB
    subgraph Model["Probabilistic Model"]
        M1[Detect Salience]
        M2[Generate Output]
    end

    subgraph System["Deterministic System"]
        S1[Promote Anchors]
        S2[Store in Ledger]
        S3[Enforce on Generation]
        S4[Expire Stale Context]
    end

    M1 --> S1 --> S2
    S2 --> S3 --> M2
    S2 --> S4

    style Model stroke:#f59e0b,stroke-width:2px
    style System stroke:#22c55e,stroke-width:3px

Трубопровод CFCD

Ось модель з рахунком як першим об 'єктом klasy-

flowchart LR
    S[Stream: chunks/sentences] --> M[Model proposes salience]
    M --> P[Promotion rules]
    P --> L[Ledger / Anchors]
    L --> G[Generation constrained by anchors]
    G --> O[Output]
    L --> E[Expiry rules]
    E -.-> L

    style L stroke:#22c55e,stroke-width:3px
    style P stroke:#22c55e,stroke-width:2px
    style E stroke:#22c55e,stroke-width:2px
    style M stroke:#f59e0b,stroke-width:2px
    style G stroke:#f59e0b,stroke-width:2px

Зелені коробки - детерміністики. Оранжеві - ймовірностіM SK1 Переводник сидить між ними, тримаючи те, що вижилиMSC3

Що змінилося в практиці?

Три зміни:

• Ви перестанете продовжувати прозу
• Ви наполегливо надруковані ланкери
• Ви сприймаєте рахунку як API,, а не прохання

Про prompt стає перегляд not the ledger itself.

Те, що - це момент - це не контекст

Що зветься як Anchor?

Анкори не є "важливий текстM SK1 Вони є надруковані, структуровані факти що обмежують генерацію:

• Термінологічні картографії: factory reset → restore factory settings
• Об 'єкти та ID: ProductName, ModelNumber, UserID
• Обмеження / інваріантів: МSK1Reset потребує втримки кнопки
• Настрої користувача / обмеження стилюМSK0 "Використовуйте офіційний тонM SK2 ♫ ♫ МSK3 ♫ Британське правописання ♫ "
• Метадані об 'ємуМSK0 "3.2% семантичний зразок МSK2
• Версію: policyVersion: "cfcd-v1", anchorSchemaVersion: 2

Справа в тому, що ланкери не проза, вони структурні. Модель пише навколо них.

Біологічне поєднання

Це аналогія МСК0 не біологічна твердження МSK1 пунктом є вибіркова консолідація , не літеральний механізм.

Мозок не відтворює весь сенсорний поток.

Вони:

• виявити привабливість
• сконsolidувати вибірково
• стримувати шум
• заморозити представлення, коли вони стали стабільними

Мова, МСК0, рухові здібності, МSK1 та сприйняття залежать від стриманий ріст-вперед, не сировий зворотній зв 'язокM SK1

CFCD - це той самий принцип

Об 'єднати візерунки

CFMoM і CFCD - це одна і та сама ідея, яка розглядається з різних куточків:

Усі троє підтримують одне й те саме правило.

Ймовірність запропонує. Детермінізм залишаєтьсяM SK1

Як тільки ви internalizуєте це правило,

flowchart LR
    subgraph CFP["Part 1: Constrained Fuzziness"]
        P1[Single Proposer] --> C1[Constrainer] --> O1[Output]
    end

    subgraph CFMoM["Part 2: Constrained Fuzzy MoM"]
        P2A[Proposer A] --> CS[Consensus Space]
        P2B[Proposer B] --> CS
        P2C[Proposer C] --> CS
        CS --> C2[Coordination Constrainer] --> O2[Output]
    end

    subgraph CFCD["Part 3: Context Dragging"]
        T1[Time T] --> A1[Anchors]
        T2[Time T+1] --> A1
        A1 --> C3[Constrained Generation] --> O3[Output]
    end

    style CFP stroke:#22c55e,stroke-width:2px
    style CFMoM stroke:#3b82f6,stroke-width:2px
    style CFCD stroke:#8b5cf6,stroke-width:2px

Чому це не головне?

Тому що це

• знизує витрати на обчислення (не переM SK1розробка для консенсусу МSK2
• працює з маленькими моделями (anchors do heavyliftingM SK1
• здається нудним в демо. (не "репертуальна пам 'ять МSK2 заяви
• producs fewer dramatic failures (failures are explicitM SK1
• вимагає реального мислення систем. ( не тільки про prompt engineering )

Іншими словами, це оптимізує виробництво

Анти-Patterns це замінює

Субстрат Implementation: Невичерпний

Найяскравіший.Ефемеральний є субстратом, який робить CFCD практичною.

• Огонь і не забувай - філософія
• Бібліотека швидкого виконання - Implementation
• Ефемеральні сигнали - сигнал
• Навчитися ЛРУ - чому значення має обмежена пам 'ять

Ефемеральний не " пам 'ятаєM SK1 Він вирішує, що можна запам 'ятати, і на який час.

Це саме те, що вимагає CFCD.

public class CFCDCoordinator
{
    private readonly SignalSink _sink;
    private readonly TermLedger _ledger;
    private readonly TimeSpan _anchorLifetime = TimeSpan.FromHours(1);

    public void PromoteAnchor(string term, string translation, string chunkId, int chunkIndex)
    {
        _ledger.ProposeMapping(term, translation, 0.8f, chunkId, chunkIndex);

        // Emit signal for observability (key = chunkId for correlation)
        _sink.Raise($"anchor.promoted:{term}", key: chunkId);
    }

    public void ExpireStaleAnchors()
    {
        var cutoff = DateTimeOffset.UtcNow - _anchorLifetime;

        // Ledger entries older than cutoff without recent usage are removed
        // This is deterministic, not model-decided
        _ledger.ExpireOlderThan(cutoff);
        _sink.Raise("anchors.expired");
    }
}

Втілення Скетч: Перевод Dokumentів

Об 'єднати їх для створення повної системи перекладу документів:

public class CFCDTranslationPipeline
{
    private readonly ILlmService _llm;
    private readonly TermLedger _ledger;
    private readonly SignalSink _sink;
    private readonly int _seedChunks = 3;  // K: configurable seed window

    public async Task<TranslatedDocument> TranslateAsync(
        Document source,
        string targetLanguage)
    {
        var chunks = Chunker.Chunk(source, maxTokens: 500).ToList();
        var translated = new List<TranslatedChunk>();

        // Phase 1: Extract terminology candidates (first pass, fuzzy)
        // Seed from first K chunks: front-loads terminology, avoids churn later
        for (var i = 0; i < Math.Min(_seedChunks, chunks.Count); i++)
        {
            var chunk = chunks[i];
            var candidates = await _llm.ExtractTerminologyAsync(chunk);
            foreach (var term in candidates)
            {
                _ledger.ProposeMapping(
                    term.Source,
                    term.ProposedTranslation,
                    term.Confidence,
                    chunkId: chunk.Id,
                    chunkIndex: i);
            }
        }

        _sink.Raise("terminology.seeded");

        // Phase 2: Translate with ledger constraints
        for (var i = 0; i < chunks.Count; i++)
        {
            var chunk = chunks[i];

            // Get canonical translations for terms in this chunk
            var constraints = ExtractConstraints(chunk, _ledger);

            // Translate with constraints (model must respect ledger)
            var result = await _llm.TranslateWithConstraintsAsync(
                chunk,
                targetLanguage,
                constraints);

            // Update ledger with any new terms (deterministic rules)
            foreach (var newTerm in result.NewTerminology)
            {
                if (ShouldPromote(newTerm, _ledger))
                {
                    _ledger.ProposeMapping(
                        newTerm.Source,
                        newTerm.Target,
                        newTerm.Confidence,
                        chunkId: chunk.Id,
                        chunkIndex: i);

                    _sink.Raise($"anchor.promoted:{newTerm.Source}");
                }
            }

            translated.Add(result.Chunk);
        }

        return new TranslatedDocument(translated, _ledger.GetAllMappings());
    }

    private bool ShouldPromote(TermCandidate term, TermLedger ledger)
    {
        // Deterministic rules, not model judgment:
        // - Proper nouns always promoted
        // - Technical terms promoted if repeated
        // - Common words never promoted
        return term.Type == TermType.ProperNoun ||
               (term.Type == TermType.Technical && term.OccurrenceCount >= 2);
    }
}

Закінчується думка

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

Взагалі-то, інтелект МСК0 вирішує, що робити ніколи більше не думати.

CFCD - це те, як ви це робите, не брехаючи собі.

Серіал

Усі три моделі мають однакову інваріантність: ймовірнісні компоненти запропонують; детерміністичні системи тривають.

І Десять заповідей використання LLM кодувати ці правила. Архітектура DiSE implements them for code evolution. Розпізнавання Bot implements them for request classification. DocSummarizer implements them for document retrieval. ImageSummarizer implements them for image analysis.

Різні домени. Схожа модельM SK1 Спеціальне правило. Доум-Суммарізер впроваджує відтягування контексту для паралельного довгого-форму генерації dokumentu M SK1 запуск сумісел , негативні про prompts M SK3 континуитет об 'єктів , і детекцію дрейфу підтримують послідовність над одночасними LLM wywołaннями MSC5

Наступне: Практична Implementation

Частина 4 тепер доступна: Обкладач зображення : Конstrained Fuzzy Image RAG Engine. Він реалізує всі три візерунки в хвилі - базується на аналізі зображення каналу МSK2 КолірWave обчислює факти M SK3 VisionLlmWave пропонує , ImageLedger накопичує важливі риси MSC5 і детерміністичне відбору обмежує вихідні дані MNK6 Клоні його з github.comM SK1scottgal/lucidrag.