Warrior_EA/AI_NETWORK.md

# AI/ — neural network subsystem

The engine behind the four AI signal modules (`CSignalPAI`, `CSignalCONV`,
`CSignalLSTM`, `CSignalHYBRID`). It is a from-scratch MQL5 network — no external
ML runtime — with four interchangeable compute tiers behind one interface.

## File layout

`AI\Network.mqh` is the entry point and the only file anything outside `AI\`
includes. It holds **declarations only**: every neuron/layer/net class, the
compile-time constants, and the nested include chain that orders them. Each
nested `#include` sits exactly where its base class becomes visible, so that
order is a dependency graph, not a preference — do not reorder it.

| file | holds |
|---|---|
| `Network.mqh` | every class declaration, tuning constants, include chain |
| `Network.cl` | OpenCL kernels (see below) |
| `ArrayLayer.mqh` | `CArrayLayer` — the layer collection |
| `LayerDescription.mqh` | `CLayerDescription` — the topology descriptor |
| `BufferDouble.mqh` | `CBufferDouble` — host/device buffer |

Method **bodies** live in `AI\Impl\`, included at the bottom of `Network.mqh`
after every declaration. This is a pure relocation — a body cannot run during
compilation, and every declaration it could reference is already visible above it.

| `AI\Impl\` | holds |
|---|---|
| `NeuronPrimitives.mqh` | `CConnection` / `CArrayCon` — weight storage |
| `NeuronBase.mqh` | `CNeuronBase` — init, forward, gradients, activation, persistence |
| `NeuronCPU.mqh` | `CNeuron` — pure-MQL5 dense neuron |
| `NeuronConvPool.mqh` | `CNeuronConv`, `CNeuronPool` |
| `NeuronLSTM.mqh` | `CNeuronLSTM` — gate layers, BPTT |
| `Layer.mqh` | `CLayer` — element construction from a descriptor or a `.nnw` stream |
| `NetBuild.mqh` | `CNet` lifecycle: topology construction, OpenCL init |
| `NetForward.mqh` | `feedForward`, `backProp`, `getResults`, logit adjustment |
| `NetPersistence.mqh` | `CNet::Save` / `CNet::Load` — the `.nnw` format |
| `NetWeights.mqh` | EMA blend, in-memory snapshot/restore, per-layer learning report |
| `NeuronOCLBase.mqh` | `CNeuronBaseOCL` |
| `NeuronOCLConvPool.mqh` | `CNeuronConvOCL`, `CNeuronPoolOCL` |
| `NeuronBatchNorm.mqh` | `CNeuronBatchNormOCL` — host-side batch norm, all tiers |
| `NeuronOCLLSTM.mqh` | `CNeuronLSTMOCL` — sequence LSTM, fused kernels, BPTT caches |

## Compute tiers

Selected once at construction and logged; each layer runs entirely on one tier.

1. **OpenCL** — `Network.cl`, compiled from the `#resource` at startup.
2. **DirectML** — `WarriorDML.dll` (D3D12 compute).
3. **CPU DLL** — `WarriorCPU.dll`, a threaded fallback. Thread count is fixed at
   `CPU_THREADS_PER_NETWORK` per net rather than a share of the machine; see the
   comment on that constant for why a machine-wide budget was wrong.
4. **Pure MQL5** — no DLL, no GPU. Single backtests run here so a Market build
   (which strips every `#import`) is still able to infer.

A Market build (`WARRIOR_MARKET_BUILD`) compiles tiers 2 and 3 out entirely.

## Classes

- **`CNet`** — owns the layer stack, the forward/backward passes and `.nnw`
  persistence. Note that a `.nnw` pins the **architecture**, not just the
  weights: `Save` writes each layer's activation and `Load` restores it, so a
  head activation changed in source only ever reaches a brand-new topology.
  `EnforceOutputActivation()` re-asserts it after every load.
- **`CLayer` / `CArrayLayer`** — neuron containers; `CreateElementScaled()` is
  the single construction point for every neuron type, from a descriptor or from
  a file stream.
- **`CNeuronBase` → `CNeuron` / `CNeuronPool` / `CNeuronConv` / `CNeuronLSTM`** —
  the pure-MQL5 family.
- **`CNeuronBaseOCL` → `CNeuronLSTMOCL` / `CNeuronConvOCL` / `CNeuronPoolOCL` /
  `CNeuronBatchNormOCL`** — the accelerated family. Despite the `OCL` suffix
  these also drive the DirectML and CPU-DLL tiers.

`ENUM_ACTIVATION` is `NONE, TANH, SIGMOID, PRELU`; `ENUM_OPTIMIZATION` is
`SGD, ADAM`. `NativeActivationCode()` translates to the int code the backends
share — and deliberately makes `NONE` fall through every backend switch.

## Network.cl

22 kernels in four groups: dense (`FeedForward`, `CaclOutputGradient`,
`CaclHiddenGradient`, `UpdateWeightsMomentum/Adam`), conv/pool (`FeedForwardConv`,
`FeedForwardProof`, `CalcHiddenGradientConv`, `CalcInputGradientProof`,
`UpdateWeightsConv*`), single-step LSTM (`LSTM_Gates`, `LSTM_State`,
`LSTM_*Gradient`) and sequence LSTM (`LSTM_SeqStep*`, `LSTM_UpdateWeights*`).

Two invariants worth knowing before touching them:

- `MIN_ACTIVATION_DERIVATIVE` (1.0e-3f) floors every LSTM gate derivative in both
  gradient kernels. It is already there — do not "add" it.
- Kernel math is mirrored in `DirectML\WarriorCPU.cpp` and `WarriorDML.cpp`.
  A change to one is a change to all three, or the tiers silently diverge.

## Usage

```
CNet *net = new CNet(topology);   // CArrayObj of CLayerDescription
net.feedForward(inputs);          // CArrayDouble
net.backProp(targets, weight);
net.getResults(out);
net.Save(path, ...); net.Load(path, ...);
```

The 3-output classification case is special-cased in `backProp`/`backPropOCL`:
it computes a joint softmax + cross-entropy gradient across all three neurons
rather than three independent per-neuron deltas.

## Known gaps

- No unit tests. Changes are validated by compile + a live era's `dW/W` line
  (`CNet::LayerLearningReport`), which is the only reliable check that a layer is
  actually receiving gradient in the assembled net.
- No dedicated SoftMax layer; the head is `Dense(SIGMOID)` with the gradient
  short-circuited. See `REFACTOR_NOTES.md` §G for why, and for what would have to
  move together to change it.