Competitive learning

What it is
- Winner-take-all output units compete to classify input patterns, only one (roughly) coming on at a time
- Clustering unlabelled data
- Categorization, vector quantization
Simple, single-layer competitive learning
- Binary output (or hidden) units fully connected to (usually binary) input units by non-negative weights
- Only one output unit fires at a time, the one whose input weight vector is closest to the input vector (j* is the winning unit):
  `|vec w_{j text{*}} - vec x| le |vec w_{j} - vec x|` (for all j)
  For normalized weights, the winner is always the one with highest input (dot product of input pattern and weight vector):
  `vec w_{j text{*}} * vec x ge vec w_j` (for all j)
- Winner-take-all process can be implemented by simply picking the unit with the highest activation or through lateral inhibitory connections.

Learning in simple competitive learning

Weights initially random
For each input pattern p, update the weights into the winning unit only
The standard rule moves the winning weight vector directly towards the input pattern.
`Delta w_{j text{*} i} = eta (x_i^p - w_{j text{*} i})`
Because losers are not activated, the rule is equivalent to the following (y_j is the activation of the jth category unit)
`Delta w_{ji} = eta y_j (x_j^p - w_{j text{*} i})`
Geometric analogy
The learning rate may be decreased during learning so that the finer adjustments can be made and the category positions do not oscillate.

Error for a pattern: distance between the input vector and the weights into the winning unit
Error function
`E = 1/2 sum_{i,j,p} M_j^p (x_i^p - w_{ji})^2`
i, j, p indexing input units, output (category) units, patterns; `M_j^p` the category membership matrix, indicating whether or not input pattern p activates category unit j as winner
Gradient descent on error: `(del E)/(del w_{ji}) = -sum_p M_j^p (x_i^p - w_{ji})`
This yields a batch learning rule, the sum of the standard rule over all of the patterns for which j is the winner.
Incremental update can lead to changes in the category assigned to a given input pattern within one pass through the patterns.
The problem of local minima

Problem of "dead units", units which start out far away from input patterns and never win
Some solutions:
- Update the weights of losers too but with a smaller learning rate: leaky learning, equivalent to activating the losers with a value much smaller than 1 and using the rule
  `Delta w_{ji} = eta y_j (x_j^p - w_{j text{*} i})`
- Initialize the weights to samples from the patterns.
- Arrange the units geometrically, and update the weights of neighboring units as well as winners (self-organizing map)
- Subtract a threshold term, varying with the unit, from the input to units. Units that win often raise their thresholds, those that lose lower theirs. Units have a conscience.
- Add noise to the input patterns.