EvaluatedApplications.EvalApp.Neural 1.0.0

EvalApp.Neural

An always-learning neural concurrency tuner for EvalApp. Instead of the built-in heuristic, a tiny holographic policy model (HoloFormer) tunes your resource-gate concurrency online and reacts in real time as conditions change.

Why

EvalApp gates concurrency per resource (CPU, DB, disk, network, ...). The right level is usually hidden and it drifts — load changes, a downstream service slows, a cache warms. A fixed number is wrong; the built-in heuristic is good but hunts on noisy, coupled workloads. This tuner learns the workload from its own experience and keeps adapting.

Use it

using EvalApp.Consumer;
using EvalApp.Neural;

Eval.App("orders")
    .WithContext(ctx)
    .WithResource(ResourceKind.Cpu, Tunable.Between(1, 32, 4))
    .WithResource(ResourceKind.Of("db"), Tunable.Between(1, 24, 4))
    .WithNeuralTuning()               // <- the only change; ships warm, keeps learning
    .DefineDomain("orders", state)
        .DefineTask<Batch>("process")
            .ForEach(/* ... */)
            .Run(out var pipe)
        .Build(licenseKey);

That's it. .WithNeuralTuning() installs the tuner in place of the heuristic. It loads a warm-start model shipped in the package and keeps learning online — it is never frozen.

What it does

• Reacts in real time. When the optimum shifts (a gate widens or tightens), it re-converges live to the new best. A frozen policy can't; this one is always learning.
• Never the wrong default. It matches the heuristic on lean, clean pipelines and beats it on hard ones — about 25% higher throughput on a real coupled multi-gate workload (random DB reads, text processing, file write/read, DB writes back, three gates that contend).
• Cheap. One small forward+backward per pipeline drain (~0.4 ms), so the overhead is a rounding error on any workload where tuning matters.
• Handles coupled gates. Coordinate descent moves the bottleneck gate, so multiple interacting resources converge together.

When to use it vs the heuristic

Reach for .WithNeuralTuning() when your pipeline has multiple gates that interact, a noisy or drifting optimum, or concurrency that isn't simply "= core count." For a single obvious CPU fan-out, the built-in heuristic is already fine (this tuner will match it, not hurt it).

Requires

.WithNeuralTuning() enables tuning; concurrency above the core count and the adaptive tuner run under a licensed EvalApp app. Depends on EvaluatedApplications.EvalApp and EvaluatedApplications.AlgFormer.

Part of the Evaluated Applications product line. Proprietary license — see LICENSE.