Portability | portable |
---|---|
Stability | experimental |
Maintainer | amy@nualeargais.ie |
Safe Haskell | Safe-Inferred |
Tools for identifying patterns in data.
- class Pattern p where
- type Metric p
- difference :: p -> p -> Metric p
- makeSimilar :: p -> Metric p -> p -> p
- adjustNum :: (Num a, Ord a, Eq a) => a -> a -> a -> a
- absDifference :: Num a => a -> a -> a
- adjustVector :: (Num a, Ord a, Eq a) => [a] -> a -> [a] -> [a]
- euclideanDistanceSquared :: Num a => [a] -> [a] -> a
- magnitudeSquared :: Num a => [a] -> a
- data NormalisedVector a
- normalise :: Floating a => [a] -> NormalisedVector a
- data ScaledVector a
- scale :: Fractional a => [(a, a)] -> [a] -> ScaledVector a
- scaleAll :: (Fractional a, Ord a) => [[a]] -> [ScaledVector a]
Patterns
A pattern to be learned or classified.
difference :: p -> p -> Metric pSource
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 -> 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) | |
(Floating a, Fractional a, Ord a, Eq a) => Pattern (NormalisedVector a) |
Numbers as patterns
If you wish to use, say, a Double
as a pattern, one option is to
use no-warn-orphans
and add the following to your code:
instance Double ⇒ Pattern Double where type Metric Double = Double difference = euclideanDistanceSquared makeSimilar = adjustVector
absDifference :: Num a => a -> a -> aSource
Numeric vectors as patterns
Raw vectors
If you wish to use raw numeric vectors as a pattern, one option is to
use no-warn-orphans
and add the following to your code:
instance (Floating a, Fractional a, Ord a, Eq a) ⇒ Pattern [a] where type Metric [a] = a difference = euclideanDistanceSquared makeSimilar = adjustVector
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
.
euclideanDistanceSquared :: Num a => [a] -> [a] -> aSource
Calculates the square of the Euclidean distance between two vectors.
magnitudeSquared :: Num a => [a] -> aSource
Normalised vectors
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) |
normalise :: Floating a => [a] -> NormalisedVector aSource
Normalises a vector
Scaled vectors
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) |
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 index in
xs
,
scales the vector scale
qs xsxs
element by element,
mapping the maximum value expected at that index 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 index in the vector, and mapping the maximum value to one, and the minimum value to zero.