EvalApp.Neural · machine learning

A tuner that keeps learning while your pipeline runs.

EvalApp's built-in concurrency tuner works well on clean, predictable workloads but falls flat when conditions shift or resources couple — a database racing CPU racing disk. EvalApp.Neural plugs a tiny, always-learning neural policy into EvalApp in its place. It trains on a real workload's own experience, so it adapts live as conditions change, ships warm (pre-trained on diverse scenarios), and keeps learning from every decision.

v1.0.1 net8.0+ ~0.4ms per decision d48/L1 holographic model free to use

dotnet add package EvaluatedApplications.EvalApp.Neural

NuGet → See EvalApp →

Why it works

online, not frozen

Online learning

Unlike a frozen prior, it reacts to real-time shifts in contention, load, or workload shape. The built-in heuristic, tuned on static assumptions, can't do this.

Proven on real workloads

Matches the built-in heuristic on lean, single-gate pipelines (no edge there — the optimum is obvious), but beats it by roughly 25% on EvalApp.Neural.Train's Sisyphus benchmark, a coupled DB + CPU + disk workload deliberately built to fight itself.

Opt-in, no refactor

Add .WithNeuralTuning() to your app builder; nothing else about the pipeline changes.

How to use it

one line, or process-wide

var app = Eval.App(...)
    .WithResource(...)
    .WithNeuralTuning()
    .DefineDomain(...);

Install it globally for every pipeline in the process (useful if you're running multiple):

using var _ = NeuralTuning.UseGlobally(NeuralTuning.NewModel());

Or train on your own workload by pointing a shared model file at every runner — the model grows as they train:

using var _ = NeuralTuning.UseGloballyPersisted("model.bin");

Key features

what you get

Warm-start

Ships pre-trained on diverse workloads; nothing to configure before it's useful.

Always learning

Real-time adaptation to non-stationary conditions — no manual retuning needed.

Tiny footprint

A d48/L1 holographic model (HoloFormer, via AlgFormer) at roughly 0.4ms per decision.

No license gate

Runs at full effect regardless of license tier — free, period.

Production ready

Coordinate descent handles multi-gate coupling cleanly; deterministic under a repeated seed.

What you need to know

good to know

Best on coupled, noisy workloads

Clean single-gate CPU-bound pipelines won't see much gain — the optimum there is already obvious. Real multi-gate scenarios are where it shines.

Online by default

Always learning from its own decisions. You can freeze it for reproducibility, but production paths always enable learning.

Dependencies

Depends on EvalApp and AlgFormer — AlgFormer ships built into the DLL, no separate install needed.

Growing the warm-start: the dogfood trainer (EvalApp.Neural.Train, not part of the NuGet package) lets you add your own workload's experience to the shipped model for future releases — dotnet run --project EvalApp.Neural.Train -- sisyphus [args...], pointed at a shared model file via the EVALAPP_NEURAL_MODEL environment variable. Compatible: .NET 8.0+, Windows/Linux. License: proprietary, same terms as every EA product.