Data.Datamining.Clustering.SOM

A Kohonen Self-organising Map (SOM). A SOM maps input patterns onto a regular grid (usually two-dimensional) where each node in the grid is a model of the input data, and does so using a method which ensures that any topological relationships within the input data are also represented in the grid. This implementation supports the use of non-numeric patterns.

In layman's terms, a SOM can be useful when you you want to discover the underlying structure of some data. A tutorial is available at https://github.com/mhwombat/som/wiki

References:

• Kohonen, T. (1982). Self-organized formation of topologically correct feature maps. Biological Cybernetics, 43 (1), 59–69.

NOTE: Version 3.0 changed the order of parameters for many functions. This makes it easier for the user to write mapping and folding operations.

Patterns

class Pattern p where

A pattern to be learned or classified by a self-organising map.

Associated Types

type Metric p

Methods

difference :: p -> p -> Metric p

Compares two patterns and returns a non-negative number representing how different the patterns are. A result of 0 indicates that the patterns are identical.

makeSimilar :: p -> Metric p -> p -> p

makeSimilar target amount pattern returns a modified copy of pattern that is more similar to target than pattern is. The magnitude of the adjustment is controlled by the amount parameter, which should be a number between 0 and 1. Larger values for amount permit greater adjustments. If amount=1, the result should be identical to the target. If amount=0, the result should be the unmodified pattern.

Instances

(Fractional a, Ord a, Eq a) => Pattern (ScaledVector a)

(Floating a, Fractional a, Ord a, Eq a) => Pattern (NormalisedVector a)

Using the SOM

train :: (Ord m, GridMap gm p, GridMap gm m, GridMap gm (Int, p), GridMap gm (m, p), Grid (gm p), Pattern p, Metric p ~ m, Index (BaseGrid gm p) ~ Index (gm p), BaseGrid gm m ~ BaseGrid gm p) => gm p -> (Int -> m) -> p -> gm p

If f d is a function that returns the learning rate to apply to a node based on its distance dfrom the node that best matches the input pattern, then train c f pattern returns a modified copy of the classifier c that has partially learned the target.

trainBatch :: (Ord m, GridMap gm p, GridMap gm m, GridMap gm (Int, p), GridMap gm (m, p), Grid (gm p), Pattern p, Metric p ~ m, Index (BaseGrid gm p) ~ Index (gm p), BaseGrid gm m ~ BaseGrid gm p) => gm p -> (Int -> m) -> [p] -> gm p

Same as train, but applied to multiple patterns.

classify :: (GridMap gm p, Pattern p, GridMap gm m, Metric p ~ m, Ord m, k ~ Index (BaseGrid gm p), BaseGrid gm m ~ BaseGrid gm p) => gm p -> p -> k

classify c pattern returns the position of the node in c whose pattern best matches the input pattern.

classifyAndTrain :: (Ord m, GridMap gm p, GridMap gm m, GridMap gm (Int, p), GridMap gm (m, p), Grid (gm p), Pattern p, Metric p ~ m, Index (BaseGrid gm p) ~ Index (gm p), BaseGrid gm m ~ BaseGrid gm p) => gm p -> (Int -> m) -> p -> (Index (gm p), gm p)

If f is a function that returns the learning rate to apply to a node based on its distance from the node that best matches the target, then classifyAndTrain c f target returns a tuple containing the position of the node in c whose pattern best matches the input target, and a modified copy of the classifier c that has partially learned the target. Invoking classifyAndTrain c f p may be faster than invoking (p classify c, train c f p), but they should give identical results.

diff :: (GridMap gm p, Pattern p, GridMap gm m, Metric p ~ m, BaseGrid gm p ~ BaseGrid gm m) => gm p -> p -> gm m

diff c pattern returns the positions of all nodes in c, paired with the difference between pattern and the node's pattern.

diffAndTrain :: (Ord m, GridMap gm p, GridMap gm m, GridMap gm (Int, p), GridMap gm (m, p), Grid (gm p), Pattern p, Metric p ~ m, Index (BaseGrid gm p) ~ Index (gm p), BaseGrid gm m ~ BaseGrid gm p) => gm p -> (Int -> m) -> p -> (gm m, gm p)

If f is a function that returns the learning rate to apply to a node based on its distance from the node that best matches the target, then diffAndTrain c f target returns a tuple containing: 1. The positions of all nodes in c, paired with the difference between pattern and the node's pattern 2. A modified copy of the classifier c that has partially learned the target. Invoking diffAndTrain c f p may be faster than invoking (p diff c, train c f p), but they should give identical results.

Numeric vectors as patterns

Normalised vectors

normalise :: Floating a => [a] -> NormalisedVector a

Normalises a vector

data NormalisedVector a

A vector that has been normalised, i.e., the magnitude of the vector = 1.

Instances

Show a => Show (NormalisedVector a)

(Floating a, Fractional a, Ord a, Eq a) => Pattern (NormalisedVector a)

Scaled vectors

scale :: Fractional a => [(a, a)] -> [a] -> ScaledVector a

Given a vector qs of pairs of numbers, where each pair represents the maximum and minimum value to be expected at each position in xs, scale qs xs scales the vector xs element by element, mapping the maximum value expected at that position to one, and the minimum value to zero.

data ScaledVector a

A vector that has been scaled so that all elements in the vector are between zero and one. To scale a set of vectors, use scaleAll. Alternatively, if you can identify a maximum and minimum value for each element in a vector, you can scale individual vectors using scale.

Instances

Show a => Show (ScaledVector a)

(Fractional a, Ord a, Eq a) => Pattern (ScaledVector a)

Useful functions

If you wish to use a SOM with raw numeric vectors, use no-warn-orphans and add the following to your code:

 instance (Floating a, Fractional a, Ord a, Eq a) ⇒ Pattern [a] a where
   difference = euclideanDistanceSquared
   makeSimilar = adjustVector

adjustVector :: (Num a, Ord a, Eq a) => [a] -> a -> [a] -> [a]

adjustVector target amount vector adjusts vector to move it closer to target. The amount of adjustment is controlled by the learning rate r, which is a number between 0 and 1. Larger values of r permit more adjustment. If r=1, the result will be identical to the target. If amount=0, the result will be the unmodified pattern.

euclideanDistanceSquared :: Num a => [a] -> [a] -> a

Calculates the square of the Euclidean distance between two vectors.

gaussian :: Double -> Double -> Int -> Double

Calculates ce^(-d^2/2w^2). This form of the Gaussian function is useful as a learning rate function. In gaussian c w d, c specifies the highest learning rate, which will be applied to the SOM node that best matches the input pattern. The learning rate applied to other nodes will be applied based on their distance d from the best matching node. The value w controls the 'width' of the Gaussian. Higher values of w cause the learning rate to fall off more slowly with distance.