Skip to content

Self-Organizing Map Training

Training method — instantiates Neighborhood-Preserving Substrate Mapping

Trains a fixed grid of prototype units by competitive learning so that, over many passes, neighbouring units come to represent neighbouring regions of the source.

Self-Organizing Map Training builds a neighborhood-preserving map by learning it. A fixed grid of prototype units is exposed to source samples over many passes; each sample pulls its best-matching unit — and, crucially, that unit's grid neighbours — toward itself. Over time, neighbouring units come to represent neighbouring regions of the source, and denser source regions capture more units. Its defining idea is competitive learning with a neighbourhood: co-adapting a winner together with its grid-neighbours is what turns an unordered set of prototypes into an ordered, topology-preserving map — and the same coupling is what makes the map devote more resolution to common cases and keep re-organising as data arrives. Unlike a distance-table method, it never sees a global distance matrix; it learns online, locally, on a grid.[1]

Example

A retailer trains a 12×12 self-organizing map on years of shopping baskets, each customer a vector of what they buy. Training runs many epochs: every customer picks the closest grid unit, and that unit plus its neighbours shift toward the customer. The grid self-organises into a 2D "market landscape" — a corner for bulk family shoppers, an opposite region for single-serve convenience buyers, smooth price-sensitivity gradients between. Dense customer types claim many cells (magnification); rare types get a single cell. Marketers then read the map like terrain: adjacent cells are similar segments, so a campaign tuned for one cell can be nudged outward to its neighbours. Nobody defined the segments — the training laid them out so that neighbourhood on the grid means similarity in behaviour.

How it works

  • Fix a grid topology and initialise the prototype units.
  • Find the best-matching unit (BMU) for each incoming sample — the closest prototype.
  • Pull the BMU and its grid-neighbours toward the sample, by an amount set by a learning rate and a neighbourhood function.
  • Anneal — shrink the learning rate and neighbourhood radius over training, so the map orders globally first and refines locally later.

The result is a learned correspondence with data-dependent magnification. It produces the map and its magnification through the update rule; it does not preserve source distances metrically, nor grade its own fidelity.

Tuning parameters

  • Grid size and shape — how many units and how arranged; more units give a finer map but slower, sparser training per unit.
  • Neighbourhood function and decay — how far a win spreads and how fast that reach shrinks. Wide-and-slow orders the map globally; too-fast leaves folds frozen in.
  • Learning-rate schedule — high early for coarse ordering, low late for refinement; the whole quality hinges on annealing this well.
  • Number of epochs — too few and the map has not unfolded; too many wastes compute after convergence.
  • Magnification strength — through sampling or rate weighting, how hard dense regions are allowed to claim extra units versus keeping rare-but-important types visible.

When it helps, and when it misleads

Its strength is learning a legible 2D map straight from raw feature vectors — no distance table required — discovering structure nobody specified and naturally spending resolution where cases are common.

Its failure mode is that training can leave topological defects — folds and twists — when the neighbourhood shrinks too fast or the grid is ill-sized, and these are easy to miss by eye; magnification, meanwhile, can crush a rare-but-critical type into a single cell. The classic misuse is reading a poorly-converged map as ground truth, trusting cluster boundaries the training never actually separated. The discipline is to check the trained map with a topology metric and a fold scan before interpreting it, and to anneal the schedule patiently rather than rushing it.

How it implements the components

  • topographic_correspondence_rule — the trained grid is the learned source→substrate placement; each unit's prototype is where that region of the source lands.
  • magnification_allocation_policy — the update rule spends more units on denser source regions, allocating resolution by data density.
  • map_update_and_reorganization_policy — training is itself the iterative update; the learning-rate and neighbourhood schedule is the reorganization policy that unfolds the map.

It builds and magnifies the map but does not evaluate it: the discrete adjacency check is Topographic Error Measure, rank-based neighbourhood fidelity is Neighborhood Trustworthiness and Continuity Metric, and folds and collisions are logged by Map Fold and Collision Scan. The Magnification Function and Adaptive Remeshing and Reallocation siblings express as standalone policies what training here produces implicitly.

Notes

The grid topology is chosen before training and never changes — only the prototypes move. That fixed shape is the map's greatest convenience and its main limit: it makes every result laid out on a stable, readable lattice, but it also means a source whose intrinsic shape does not match the grid (a sphere forced onto a flat sheet) will always fold somewhere, no matter how carefully the schedule is annealed.

References

[1] The self-organizing map (Kohonen map) is the canonical competitive-learning method for topology-preserving mapping. Its signature is the neighbourhood function: without it, the units would merely quantise the data (like k-means); with it, they also come to order themselves so that grid-adjacency tracks source-similarity. ↩