Several commentators have mentioned Particle Swarm Optimisation so I have researched it and coded an example below in Haskell. PSO is a search algorithm that mimics the swarming tendencies seen in nature e.g. flocks of birds, shoals of fish, etc. To visualize how it works it’s best to think of a natural example.

Imagine a single bird in search of food, as it moves about over a landscape its nose will pick up the scent of food – the closer the food the stronger the scent. It knows where it registered the strongest scent so it will concentrate it’s search around that location i.e. slowing down and moving around more closely until it finds it. One bird on it’s own will take a long time to search a large area so now let’s imagine that two birds are searching and they can communicate with each other to notify where they have a strong scent – this will induce swarming as the other bird travels towards the stronger scent.

This is how the algorithm works, so the x and y coordinates in the landscape are the parameters to be optimised i.e. find the value that gives the strongest scent – the location of the food ! The birds change their velocities i.e. how quickly they move over those parameters to home in on stronger values so the birds will swarm around likely solutions. The ‘scent’ is provided by a fitness function that basically takes the parameters (x, y) and returns a score.

module Main where

import System.Random
import Data.List (find, maximum)
import Data.Maybe

c1 = 2.0
c2 = 2.0
vMax = 5.0

-- infinite list of infinite random lists (TODO: Remove fixed seed 42)
rl :: [[Double]]
rl = [randomRs ((0.0), 1.0) g | g <- gl (mkStdGen 42)]
   where gl gen = gen:(gl (fst $ split gen)) 

-- Particle data type representing one particle
data Particle = Particle {
                  pbest :: [Double],           -- particle's best solution
                  pbestFitness :: Double,
                  velocities :: [Double],      -- particle's velocities
                  present :: [Double],         -- particle's present solution
                  fitness :: Double            -- current fitness
                  } deriving (Show)

cap :: Double -> Double
cap x | x < 0.0   = max x (-vMax)
      | otherwise = min x vMax    

-- Calculate the new velocities for a particle
calcVelocities :: Particle -> [Double] -> [Double] -> [Double]
calcVelocities p gbest rand = [ cap (v + c1 * r1 * (pb - pr) + c2 * r2 * (gb - pr))
                                    | v <- velocities p
                                    | pr <- present p
                                    | pb <- pbest p
                                    | gb <- gbest
                                    | r1 <- rand
                                    | r2 <- drop (length $ velocities p) rand]

-- Update a particle's present solution and velocities
updateParticle :: Particle -> [Double] -> [Double] -> Particle
updateParticle p gbest rands = p { present = [pr + v | pr <- present p
                                                     | v <- newVelocities ],
                                   velocities = newVelocities }
    where newVelocities = calcVelocities p gbest rands                                                                                                            

-- Find the best global solution in the population
getBest :: [Particle] -> [Double]
getBest p = if (isJust b) then pbest (fromJust b) else []
    where  b = find (\x -> pbestFitness x == m) p
           m = maximum [pbestFitness f | f <- p]

-- Return the next generation
psoEvolve :: [[Double]] -> [Particle] -> [Particle]
psoEvolve rands population = [updateParticle p gbest r | p <- pbests | r <- rands]
    where fitnesses = [p { fitness = fitnessFunction (present p) } | p <- population]
          pbests    = [if (fitness p > pbestFitness p) then
                          p { pbest = (present p), pbestFitness = fitness p }
                       else
                          p  | p <- fitnesses ]
          gbest     = getBest pbests         

-- Solve the problem using the ranges and fitness function
psoSolve :: [(Double, Double)] -> Int -> Int -> [Double]
psoSolve ranges numParticles numGenerations = getBest $ foldl (\a x -> psoEvolve (drop (2 + x) rl) a) pop [1..numGenerations]
    where pop = [Particle [] 0.0
                     (take l (head rl))
                     [(fst r) + x * ((snd r) - (fst r)) |r <- ranges |x <- (take l (rl !! 1))]
                     0.0 | n <- [1..numParticles]]
          l   = length ranges

-- Fitness function takes the particles 'present' solution and returns a score
fitnessFunction :: [Double] -> Double
fitnessFunction xs = (100.0 / sqrt (dx1 * dx1 + dy1 * dy1 + dz1 * dz1)) +
                     (50.0 / sqrt (dx2 * dx2 + dy2 * dy2 + dz2 * dz2))
    where dx1 = 53.4 - (xs !! 0)
          dy1 = 67.8 - (xs !! 1)
          dz1 = 32.6 - (xs !! 2)
          dx2 = 23.8 - (xs !! 0)
          dy2 = 18.0 - (xs !! 1)
          dz2 = 4.6 - (xs !! 2)

main = do
       print $ psoSolve [(0.0, 100.0), (0.0, 100.0), (0.0, 100.0)] 100 100 

The fitness function evaluates how close the particle (bird) is to two food sources in 3d space and returns the value. There is a large food source at (53.4, 67.8, 32.6) and a small food source at (23.8, 18.0, 4.6) so the optimum solution is the position of the large food source.

Here’s the result :-

[1 of 1] Compiling Main             ( /home/andrew/workspace/pso/src/Main.hs, interpreted )
Ok, modules loaded: Main.
*Main> main
[53.422443402059535,67.83854324652401,32.637809690239244]
*Main>

Notice that it has found the large food source with an error rate of only around 0.03 on each axis i.e. 0.03 % this is with 100 particles and 100 generations so 10,000 evaluations of the fitness function. An exhaustive search would have had to to 1000 evaluations in each axis i.e. 0.1 increments = 1,000,000,000 evaluations ! Depending on the granularity of the exhaustive search, it could have easily misidentified the smaller food source as the optimum solution which PSO avoided.

As you can see PSO is a very efficient search algorithm that can be several orders of magnitude faster than an exhaustive search and, as can be seen, is relatively simple to implement and use over a very wide range of problem domains.

So how is it going to help me in my quest to produce profitable trading strategies ? Well there are several possibilities :-

• Use to optimise GP solutions, i.e. use GP to create the structure of the solutions but PSO to optimise the constants used in the structure,
• Use PSO to optimise the parameters used in the GP evolutions,
• Use PSO to optimise the parameters to hand coded strategies.