How Training Affects Neural Networks

The debate has flipped from wiring to training

For decades the central question in cognitive science was whether a connectionist model could hold symbols at all. Fodor and Pylyshyn’s classic objection, and the parallel distributed processing tradition that answered it, treated architecture as the battleground: either you hardcode role-filler binding into the network, or you lose compositionality. A 2026 reading of the evidence points elsewhere. The same backbone, trained under different regimes, produces sharply different symbolic behavior, documented across curriculum order, input structure, and supervision target.

The clearest example is a study in the Proceedings of the National Academy of Sciences by Dekker, Otto, and Summerfield. They gave human participants a task built from symbolic cues, five shapes crossed with five colors, mapping to spatial locations across a series of blocks where a subset of cues trained and the remainder were held out. People generalized compositionally when training items were axis aligned and temporally correlated, and lost that advantage when the same cues were presented axis misaligned. Standard networks did not show the effect; the authors had to add a Hebbian gating modification before their model reproduced both the human transfer and the sensitivity to curricula.

The older literature, reviewed by Do and Hasselmo in Neurobiology of Learning and Memory, treated symbols as a representation problem: conjunctive coding, tensor products, circular convolution, and semantic pointer architectures were all proposals for how a circuit could bind a role to a filler. The newer work shifts the focus. The representation question remains, but the main empirical focus is now on the training procedure that determines which representations form.

Key Takeaways:

• Symbolic and compositional behavior in neural networks largely emerges from the training regime, not from fixed architectural features.
• Curriculum order alone changes what generalizes: axis-aligned, temporally correlated presentations help humans and, with the right gating, networks.
• Input structure matters: models trained on more compositional languages generalize more systematically and match human learners more closely.
• Supervision target matters: training an output layer to read out symbols produces combinatorial generalization over novel combinations.
• There is a hard boundary: without direct symbol supervision, a network cannot generally be made symbol correct, only output correct.

Curriculum order: what gets shown first changes what transfers

The PNAS result isolates one variable: presentation order. In the axis-aligned condition, training examples sampled one factor at a time, holding the other constant, then switched to the second factor. In the axis-misaligned condition, the two dimensions changed together on every trial. Both conditions exposed participants to the same total set of cues, so any difference in generalization had to come from how the material was sequenced. Compositional transfer appeared only in the aligned, temporally correlated case.

The network result is the more striking part. The authors describe a model built around a Hebbian gating process that captures how human generalization benefits from different training curricula. Without that modification, a standard network trained on identical input does not recompose the learned factors on held-out cues. The same data, the same optimizer, different internal dynamics: the curriculum only pays off once the network is wired to compose rather than memorize. This challenges any claim that compositionality depends purely on data volume or model scale.

Adults in the study also learned composable functions asynchronously, with discontinuities in learning that resemble those seen in child development. Symbolic structure does not build up smoothly with exposure; it appears in fits, and the schedule of presentation influences when and whether it appears. The experiment crossed grid versus polar mappings with axis-aligned versus misaligned curricula, and separately compared blocked versus interleaved ordering. In every comparison, the aligned, correlated schedule was the one that produced transfer.

Input structure: compositional data begets compositional behavior

Order is one factor; the statistical structure of the training set is another. A Nature Communications paper by Galke, Ram, and Raviv tested this directly. They trained a large language model doing in-context learning, and a recurrent network trained from scratch, on the same ten emergent languages used in a preregistered adult learning study. The languages describe four novel shapes moving in directions spanning a full circle. They range from fully idiosyncratic, where two related meanings get unrelated labels such as kuim and goom, to highly structured, where parts of a descriptive label are reused across scenes, as in fest-ii and fest-ui.

The models were trained on exactly the stimuli humans saw, in the same order and task, then evaluated on the same memorization and generalization tests. The paper’s structure score is the correlation between pairwise semantic differences and pairwise length-normalized edit distance of the produced labels. On that measure, more compositional input produced more systematic generalization, greater agreement between different agents, and closer alignment with human learners. The effect held for both the pretrained language model and the from-scratch recurrent net.

The metric definition, where semantic difference adds a shape term plus a scaled angle difference, makes the advantage concrete rather than anecdotal. When recurring units of meaning appear more often because they are reused across contexts, the network learns them better through repeated presentation. Compositionality in the data creates an inductive pressure that shapes the learned mapping. Earlier work on emergent communication had found no correlation between the compositional structure of a network’s self-developed protocol and its generalization, which makes the supervised-input result more significant: structure in the data helps even when structure the network invents on its own does not.

Supervision target: reading out symbols to get symbols

A third factor is what the output layer is trained to produce. The vectors approach to representing symbols, VARS for short, from Vankov and Bowers in the Philosophical Transactions of the Royal Society B, trains standard recurrent architectures so that symbolic knowledge is encoded explicitly at the output layer. In two simulations the networks learned to produce these vector representations and, in doing so, achieved combinatorial generalization across novel symbolic and non-symbolic combinations.

No purpose-built symbolic mechanism was added to the architecture. The authors raise the question of whether specific mechanisms or specific training routines are needed to support symbolic processing. The VARS result suggests the training routine, here an output representation that forces symbol-like readout, can be enough. The complexity of the symbolic structures that VARS can encode depends on two parameters: the number of addressable representational slots and the size of the vectors used to fill them.

Contrast that with the SCAN experiments from Lake and Baroni. Sequence-to-sequence recurrent networks trained on compositional navigation commands generalize well when the gap between training and test is small enough to apply a mix-and-match strategy, but they fail when the task demands systematic compositional skill, as in the dax reversal. The difference between the VARS outcome and the SCAN failure is not the backbone; it is whether the objective ever required the model to bind a symbol to a stable, reusable role. The code sketch below illustrates the split without reproducing either paper.

Note: The following code is an illustrative example and has not been verified against official documentation. Please refer to the official docs for production-ready code.

# Schematic: flat sequence loss versus a symbol-readout objective.
# Illustrative only; not a faithful reproduction of VARS or SCAN.

def flat_loss(logits, target_tokens):
 # Standard next-token / classification objective.
 return cross_entropy(logits, target_tokens)

def symbol_readout_loss(hidden, symbol_vectors):
 # Force the final hidden state to land near a stable symbol vector,
 # the VARS idea of encoding symbolic knowledge at the output layer.
 return mse(hidden, symbol_vectors)
 # Production use should add a projection head, per-example masking,
 # and explicit handling of variable sequence lengths.

The boundary: when output correctness is not symbol correctness

The supervision factor has a clear limit. Bembenek and Murray define symbol correctness for neuro-symbolic deep networks: whether the neural layers map raw input to the correct intermediate symbol that the downstream symbolic layer consumes. In the canonical visual addition task, a network that reads handwritten digits and maps them to a different pair of numbers that sums to the same total still returns the right answer, because the arithmetic works out either way. It is output correct but not symbol correct. The authors show that in general a network cannot be trained to be symbol correct without direct supervision at the neural-symbolic boundary, because alternative well-fitting mappings can be indistinguishable from the desired one at the level of the final output.

That result limits the entire training-regime story. Curriculum order, input structure, and output supervision can each push a network toward more compositional, human-aligned, or symbol-like behavior. None of them can guarantee that the internal symbols the model uses match the ground-truth symbols an external observer would assign. A regime can make behavior symbolic in the sense that novel combinations generalize. It cannot, by itself, make the representation symbol correct in the sense that an explainability or transfer argument requires.

For practitioners the practical takeaway is to pick the factor that matches the failure mode. If a model memorizes rather than composes, reorder the curriculum toward axis-aligned, correlated presentations. If it cannot generalize across novel combinations, move to input that reuses stable units of meaning or add an output objective that forces symbol-like readout. If the requirement is auditable reasoning about intermediate states, plan for explicit symbol supervision, because no amount of clever scheduling will recover the correct intermediate mapping on its own.

Reading the evidence as a working engineer

The four studies form a continuum. The PNAS curriculum work isolates ordering. The Nature Communications language work isolates input compositionality. The VARS work isolates the output supervision target. The symbol-correctness work sets the ceiling on all three. Together they support one practical position: treat symbolic competence as a training objective, then verify it the way you would verify any other capability, because it does not come automatically from scale or from a particular layer count.

Two cautions. First, the effects in these studies are measured in controlled, small-scale settings, and the gap between a lab task with a few dozen cues or a ten-language artificial corpus and a production deployment is large. Second, the Hebbian gating result in the PNAS paper reminds us that the training regime operates on top of whatever inductive bias the architecture already carries. A regime can amplify a disposition to compose, but it works best when the network is built to be composable in the first place.

The direction of travel in the field, visible across the 2022 through 2025 papers, treats symbols as an emergent consequence of how a network is trained rather than as a module to be added on. The 2025 position paper by Griffiths, Lake, McCoy, Pavlick, and Webb argues that modern neural networks, trained on data generated by symbolic systems and shaped by meta-learning, show productivity, compositionality, and inductive biases that were once taken as evidence of an irreducibly symbolic mind. GPT-2’s rate of producing novel n-grams matches the baseline rate in human-generated text, and a meta-learned network can learn formal languages from very few examples. The symbols, in this view, exist in the data and the training procedure as much as anywhere else.

That framing should be held loosely. The same authors note that small input changes can still flip a large model into piecemeal behavior, and that humans and machines share a sensitivity to priors that is not purely algebraic. The most accurate summary of the 2026 evidence is narrower and more practical: when a network fails to generalize symbolically, the first question to ask is what training regime produced it, not what architecture to buy.

Sources and References

Sources cited while researching and writing this article:

• Neural Circuits and Symbolic Processing – PMC
• Deep neural networks and humans both benefit from compositional …
• Lake and Baroni
• Bembenek and Murray
• Griffiths et al.