Portability | portable |
---|---|
Stability | experimental |
Maintainer | amy@nualeargais.ie |
Safe Haskell | Safe-Inferred |
A module containing private SOM
internals. Most developers should
use SOM
instead. This module is subject to change without notice.
- adjustNode :: Pattern p v => p -> (v, p) -> p
- adjustVector :: (Num a, Ord a, Eq a) => [a] -> a -> [a] -> [a]
- classify :: (Ord v, Pattern p v) => GridMap g k p -> p -> k
- classifyAndTrain :: (Eq k, Ord v, Pattern p v, Grid g s k) => (Int -> v) -> GridMap g k p -> p -> (k, GridMap g k p)
- differences :: Pattern p v => p -> GridMap g k p -> GridMap g k v
- euclideanDistanceSquared :: Num a => [a] -> [a] -> a
- magnitudeSquared :: Num a => [a] -> a
- normalise :: Floating a => [a] -> NormalisedVector a
- data NormalisedVector a
- scale :: Fractional a => [(a, a)] -> [a] -> ScaledVector a
- scaleAll :: (Fractional a, Ord a) => [[a]] -> [ScaledVector a]
- data ScaledVector a
- train :: (Ord v, Pattern p v, Grid g s k) => (Int -> v) -> GridMap g k p -> p -> GridMap g k p
- trainBatch :: (Ord v, Grid g s k, Pattern p v) => (Int -> v) -> GridMap g k p -> [p] -> GridMap g k p
- class Pattern p v | p -> v where
- difference :: p -> p -> v
- makeSimilar :: p -> v -> p -> p
Documentation
adjustNode :: Pattern p v => p -> (v, p) -> pSource
adjustVector :: (Num a, Ord a, Eq a) => [a] -> a -> [a] -> [a]Source
adjusts adjustVector
target amount vectorvector
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
.
classify :: (Ord v, Pattern p v) => GridMap g k p -> p -> kSource
returns the position of the node in classify
pattern cc
whose pattern best matches the input pattern
.
classifyAndTrain :: (Eq k, Ord v, Pattern p v, Grid g s k) => (Int -> v) -> GridMap g k p -> p -> (k, GridMap g k p)Source
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
returns a tuple containing the position
of the node in classifyAndTrain
f c targetc
whose pattern best matches the input target
, and a
modified copy of the classifier c
that has partially learned the
target
.
differences :: Pattern p v => p -> GridMap g k p -> GridMap g k vSource
pattern `'differences'\` c
returns the positions of all nodes in
c
, paired with the difference between pattern
and the node's
pattern.
euclideanDistanceSquared :: Num a => [a] -> [a] -> aSource
Calculates the square of the Euclidean distance between two vectors.
magnitudeSquared :: Num a => [a] -> aSource
normalise :: Floating a => [a] -> NormalisedVector aSource
Normalises a vector
data NormalisedVector a Source
A vector that has been normalised, i.e., the magnitude of the vector = 1.
Show a => Show (NormalisedVector a) | |
(Floating a, Fractional a, Ord a, Eq a) => Pattern (NormalisedVector a) a |
scale :: Fractional a => [(a, a)] -> [a] -> ScaledVector aSource
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
,
scales the vector scale
qs xsxs
element by element, mapping the
maximum value expected at that position to one, and the minimum value to
zero.
scaleAll :: (Fractional a, Ord a) => [[a]] -> [ScaledVector a]Source
Scales a set of vectors by determining the maximum and minimum values at each position in the vector, and mapping the maximum value to one, and the minimum value to zero.
data ScaledVector a Source
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
.
Alternatively, if you can identify a maximum and minimum value for
each element in a vector, you can scale individual vectors using
scaleAll
.
scale
Show a => Show (ScaledVector a) | |
(Fractional a, Ord a, Eq a) => Pattern (ScaledVector a) a |
train :: (Ord v, Pattern p v, Grid g s k) => (Int -> v) -> GridMap g k p -> p -> GridMap g k pSource
If f d
is a function that returns the learning rate to apply to a node
based on its distance d
from the node that best matches the input
pattern, then
returns a modified copy of the
classifier train
f c patternc
that has partially learned the target
.
trainBatch :: (Ord v, Grid g s k, Pattern p v) => (Int -> v) -> GridMap g k p -> [p] -> GridMap g k pSource
Same as train
, but applied to multiple patterns.
class Pattern p v | p -> v whereSource
A pattern to be learned or classified by a self-organising map.
difference :: p -> p -> vSource
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 -> v -> p -> pSource
returns a modified copy of
makeSimilar
target amount patternpattern
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
.
(Fractional a, Ord a, Eq a) => Pattern (ScaledVector a) a | |
(Floating a, Fractional a, Ord a, Eq a) => Pattern (NormalisedVector a) a |