Hopfield networks - minimal Haskell implementation

Hopfield-mini.hs

import Data.Vector ((!))
import qualified Data.Vector as V
import Data.Vector.Generic.Mutable (write)

step ws state = case updatable of []      -> state
                                  (i,_):_ -> V.modify (\v -> write v i (o i)) state
  where
    n     = V.length state
    w i j = ws ! i ! j
    x i   = state ! i
    h i   = sum [ w i j *. x j | j <- [0..n-1] ]
    o i | h i >= 0  =  1
        | otherwise = -1
    updatable = [ (i, s) | (i, s) <- zip [0..n-1] (V.toList state), o i /= s ]

converge ws s = if new == s then s else converge ws new where new = step ws s

train patterns n = generateVector2d w
  where
    w i j | i == j    = 0
          | otherwise = sum (map (\p -> (p ! i) .*. (p ! j)) patterns) /. n
    generateVector2d f = V.generate n (V.generate n . f)

query patterns n queryState = converge (train patterns n) queryState

x *. y  = x * fromIntegral y
x .*. y = fromIntegral x * fromIntegral y
x /. y  = x / fromIntegral y