Modular ANN: activities, skills and compositions

Modular ANN: activities, skills and compositions

Architectural answer

We do not need to retrain a whole model for every new activity. The architecture
can train a selected head, adapter, layer set or separate small model while
holding the remaining state fixed. Current full-layer training is a recipe
choice. Broad regression evaluation is still needed when a small change can
affect a larger composition.

The current baseline already has separate models per role and shared numerical
machinery. The research weighting plan proposes shared frozen features followed
by head or low-rank adaptation. A general tensor-selection training API and a
named learned-skill registry are not implemented in this checkpoint.

An arbitrary neural layer is not necessarily a semantic skill. Represent skills
as explicit modules with observation contracts, outputs, objectives and tests.
Shared features may support multiple heads only when their encoders and feature
basis are compatible. Independent models remain appropriate across incompatible
domains.

Proposed components

flowchart LR
    O[Typed observations] --> E[Versioned encoder]
    E --> B[Frozen or explicitly adapted feature basis]
    B --> H1[Skill head: probability decisions]
    B --> H2[Skill head: task-specific decisions]
    X[Exact maths and legality tools] --> C[Typed coordinator]
    H1 --> C
    H2 --> C
    M[Session memory and resource controller] --> C
    C --> P[Proposal]
    P --> K[Independent effect admission]

This is a proposed composition, not a claim that these named heads already
exist. Exact arithmetic, legality and resource accounting need not be neural.

TrainScope contract: proposed, not implemented

Start with all and head-only; add arbitrary layer masks and low-rank adapters
after the simpler boundary works.

Frozen state must skip parameter updates and optimizer-moment mutation. Zero
gradients alone can leave retained momentum able to move a parameter. Training
an earlier layer can require gradients through later frozen layers; head-only
training can avoid trunk backpropagation.

For the research E3 geometry 32 -> 256 -> 256 -> 256 -> 4, a policy head has
1,028 parameters out of 141,060. A head-only experiment would update 1,028 and
freeze 140,032. This geometry belongs to the separate E3 trainer, not this
baseline's two-hidden-layer core. The smaller trainable count is not a measured
speedup: forward inference, feature extraction and evaluation still have costs.

SkillSpec contract: proposed, not implemented

Each skill needs identity/version, objective, observation units and time
semantics, implementation kind (exact function/rule/ANN), dependencies, model and
feature-basis bindings, legal outputs, abstention, state/memory, TrainScope,
training provenance, held-out evaluation, retention coverage and rollback
artifact. Composition binds skill versions and typed handoffs; equal dimensions
or a shared skill name do not establish compatibility.

Example: arithmetic and odds activities can become a probability skill. Combine
that skill with a Poker-specific decision policy, legality checker and session
resource controller. Define "endurance" in that use case as decision stability,
time/budget management and memory across a long session. Physical fitness does
not establish probability or Poker competence. Each transfer needs its own
operational definition and measurement.

Dependency-ordered delivery

1. Tiny activity baseline: select a simple task with dependable labels and
a rules/exact baseline. Define held-out cases and success before training.
2. Selective update boundary: add head-only training, preserve the existing
full-training recipe, test frozen weights/buffers/moments and checkpoint
lineage, and compare the same examples, seeds and measured costs.
3. Named skill: package observation/output semantics, state, tests and
checkpoint. Demonstrate target improvement and old-task retention.
4. Two-skill composition: route typed outputs through the existing workflow,
evaluate the combined outcome and use component ablations to locate value.
5. Compatible adaptation: try adapters or progressive unfreezing only when a
frozen basis cannot represent the task. Requalify every dependent head after
shared-basis or encoder changes.
6. Harness evolution: propose alternative widths, modules or routing based
on measured failures; compare fixed predecessors and retain rollback. This
needs an explicit controller and evidence lifecycle, not automatic mutation
of the baseline architecture.

Frozen parameters establish preserved bytes, not preserved behavior when an
encoder, route, memory dependency or input distribution changes. Retention must
exercise the complete skill path. Mathematical checks may provide exact baselines
while learned policies handle uncertain decisions.

Research references

PyTorch's transfer-learning tutorial
demonstrates a frozen network with a trainable final layer; the forward pass
still runs. LoRA adds trainable low-rank updates
to frozen pretrained weights. Its published Transformer results do not qualify
an adapter for our small MLP. Progressive Neural Networks
freeze earlier task columns and add new columns with lateral feature reuse;
this provides a reference for preserving old modules, with increasing model
size and explicit task-selection concerns. These support the architectural
direction; implementation and useful transfer here remain to be measured.