Copyright  (c) Amy de Buitléir 20122018 

License  BSDstyle 
Maintainer  amy@nualeargais.ie 
Stability  experimental 
Portability  portable 
Safe Haskell  Safe 
Language  Haskell2010 
A Selfgenerating Model (SGM). An SGM maps input patterns onto a set, where each element in the set is a model of the input data. An SGM is like a Kohonen Selforganising Map (SOM), except:
 Instead of a grid, it uses a simple set of unconnected models. Since the models are unconnected, only the model that best matches the input is ever updated. This makes it faster, however, topological relationships within the input data are not preserved.
 New models are created onthefly when no existing model is similar enough to an input pattern. If the SGM is at capacity, the least useful model will be deleted.
This implementation supports the use of nonnumeric patterns.
In layman's terms, a SGM can be useful when you you want to build a set of models on some data. A tutorial is available at https://github.com/mhwombat/som/wiki.
References:
 Amy de Buitléir, Mark Daly, and Michael Russell. The Selfgenerating Model: an Adaptation of the Selforganizing Map for Intelligent Agents and Data Mining. In: Artificial Life and Intelligent Agents: Second International Symposium, ALIA 2016, Birmingham, UK, June 1415, 2016, Revised Selected Papers. Ed. by Peter R. Lewis et al. Springer International Publishing, 2018, pp. 59–72. Available at http://amydebuitleir.eu/publications/.
 Amy de Buitléir, Michael Russell, and Mark Daly. Wains: A patternseeking artificial life species. Artificial Life, (18)4:399–423, 2012. Available at http://amydebuitleir.eu/publications/.
 Kohonen, T. (1982). Selforganized formation of topologically correct feature maps. Biological Cybernetics, 43 (1), 59–69.
Synopsis
 data SGM t x k p = SGM {
 toMap :: Map k (p, t)
 learningRate :: t > x
 maxSize :: Int
 diffThreshold :: x
 allowDeletion :: Bool
 difference :: p > p > x
 makeSimilar :: p > x > p > p
 nextIndex :: k
 makeSGM :: Bounded k => (t > x) > Int > x > Bool > (p > p > x) > (p > x > p > p) > SGM t x k p
 time :: Num t => SGM t x k p > t
 isEmpty :: SGM t x k p > Bool
 numModels :: SGM t x k p > Int
 modelMap :: SGM t x k p > Map k p
 counterMap :: SGM t x k p > Map k t
 modelAt :: Ord k => SGM t x k p > k > p
 exponential :: (Floating a, Integral t) => a > a > t > a
 classify :: (Num t, Ord t, Num x, Ord x, Enum k, Ord k) => SGM t x k p > p > (k, x, Map k (p, x))
 trainAndClassify :: (Num t, Ord t, Num x, Ord x, Enum k, Ord k) => SGM t x k p > p > (k, x, Map k (p, x), SGM t x k p)
 train :: (Num t, Ord t, Num x, Ord x, Enum k, Ord k) => SGM t x k p > p > SGM t x k p
 trainBatch :: (Num t, Ord t, Num x, Ord x, Enum k, Ord k) => SGM t x k p > [p] > SGM t x k p
Construction
A Simplified SelfOrganising Map (SGM).
t
is the type of the counter.
x
is the type of the learning rate and the difference metric.
k
is the type of the model indices.
p
is the type of the input patterns and models.
SGM  

Instances
makeSGM :: Bounded k => (t > x) > Int > x > Bool > (p > p > x) > (p > x > p > p) > SGM t x k p Source #
creates a new SGM that does not (yet)
contain any models.
It will learn at the rate determined by the learning function makeSGM
lr n dt diff mslr
,
and will be able to hold up to n
models.
It will create a new model based on a pattern presented to it when
(1) the SGM contains no models, or
(2) the difference between the pattern and the closest matching
model exceeds the threshold dt
.
It will use the function diff
to measure the similarity between
an input pattern and a model.
It will use the function ms
to adjust models as needed to make
them more similar to input patterns.
Deconstruction
time :: Num t => SGM t x k p > t Source #
The current "time" (number of times the SGM has been trained).
counterMap :: SGM t x k p > Map k t Source #
Returns a map from node ID to counter (number of times the node's model has been the closest match to an input pattern).
Learning and classification
exponential :: (Floating a, Integral t) => a > a > t > a Source #
A typical learning function for classifiers.
returns the learning rate at time exponential
r0 d tt
.
When t = 0
, the learning rate is r0
.
Over time the learning rate decays exponentially; the decay rate is
d
.
Normally the parameters are chosen such that:
 0 < r0 < 1
 0 < d
classify :: (Num t, Ord t, Num x, Ord x, Enum k, Ord k) => SGM t x k p > p > (k, x, Map k (p, x)) Source #
identifies the model classify
s ps
that most closely
matches the pattern p
.
It will not make any changes to the classifier.
Returns the ID of the node with the best matching model,
the difference between the best matching model and the pattern,
and the SGM labels paired with the model and the difference
between the input and the corresponding model.
The final paired list is sorted in decreasing order of similarity.
trainAndClassify :: (Num t, Ord t, Num x, Ord x, Enum k, Ord k) => SGM t x k p > p > (k, x, Map k (p, x), SGM t x k p) Source #
identifies the model in trainAndClassify
s ps
that most
closely matches p
, and updates it to be a somewhat better match.
If necessary, it will create a new node and model.
Returns the ID of the node with the best matching model,
the difference between the best matching model and the pattern,
the differences between the input and each model in the SGM,
and the updated SGM.