Training ANNs using Evolutionary Algorithms

Introduction to Data Science Artificial Neural Network Training ANNs using Evolutionary Algorithms

				
					import java.util.* // Accessing all classes and methods in Java
import kotlin.jvm.JvmStatic// Specifies that an additional static method needs to be generated from this element if this is
// a function
import java.util.Random // To generate pseudo-random numbers

				
					typealias Func = (DoubleArray) -&gt; Double
 
class Parameters(val omega: Double, val phip: Double, val phig: Double)//A class for instatiating an object which specifies
//the three important parameters used in PSO.
 
class State(
    val iter: Int, // Number of iterations completed
    val gbpos: DoubleArray, // Global Best Position
    val gbval: Double, // Global Best Value
    val min: DoubleArray, // The lower limit on the value of particles
    val max: DoubleArray, // The Upper limit on the value of particles
    val parameters: Parameters, // Parameters used in PSO
    val pos: Array, // Specifies the current position of the particle
    val vel: Array, // Specifies the current value of the particle
    val bpos: Array, // Specifies the best position of the particle in the flock
    val bval: DoubleArray, // Specifies the best value of the particle in the flock
    val nParticles: Int, // number of particles in the flock
    val nDims: Int // Number of Dimensions
) {
    fun report(testfunc: String) { // Printing the report
        println("Test Function : $testfunc")
        println("Iterations Completed : $iter")
        println("Global Best Position found using PSO: ${gbpos.asList()}")
        println("Global Best Value found using PSO: $gbval")
    }
}

				
					// Function used to initialize the particles in the flock before starting the evolution.
fun psoInit(
    min: DoubleArray, // the array of size (1,dimension) and all the values are min(lower bound)
    max: DoubleArray, // the array of size (1,dimension) and all the values are max(Upper bound)
    parameters: Parameters, 
    nParticles: Int
): State {
    // Initializing different variables used in PSO.
    val nDims = min.size 
    val pos   = Array(nParticles) { min }
    val vel   = Array(nParticles) { DoubleArray(nDims) }
    val bpos  = Array(nParticles) { min }
    val bval  = DoubleArray(nParticles) { Double.POSITIVE_INFINITY}
    val iter  = 0
    val gbpos = DoubleArray(nDims) { Double.POSITIVE_INFINITY }
    val gbval = Double.POSITIVE_INFINITY
    return State(iter, gbpos, gbval, min, max, parameters,
                 pos, vel, bpos, bval, nParticles, nDims)
}
 
val r = Random() // random variable

				
					// Main function involving evolution of the flock of particles using PSO
fun pso(fn: Func, y: State): State {
    val p = y.parameters
    val v = DoubleArray(y.nParticles)
    val bpos  = Array(y.nParticles) { y.min }
    val bval  = DoubleArray(y.nParticles)
    var gbpos = DoubleArray(y.nDims)
    var gbval = Double.POSITIVE_INFINITY
    // Here, for each particle in the flock we update the best position as well as value for the particle
    // if the newly found value is a better one, we also update the global best position and value using the updated values of
    // particles.
    for (j in 0 until y.nParticles) {
        // evaluate
        v[j] = fn(y.pos[j])
        // update
        if (v[j] &lt; y.bval[j]) { // if newly found value is lesser(improved) then update best position and value to the current ones.
            bpos[j] = y.pos[j]
            bval[j] = v[j]
        }
        else {
            bpos[j] = y.bpos[j]// else re-assign it to the previously found best ones.
            bval[j] = y.bval[j]
        }
        if (bval[j] &lt; gbval) {// if value of current particle is smaller than the global value found previously, update it.
            gbval = bval[j]
            gbpos = bpos[j]
        }
    }
    val rg = r.nextDouble()
    val pos = Array(y.nParticles) { DoubleArray(y.nDims) }
    val vel = Array(y.nParticles) { DoubleArray(y.nDims) }
    for (j in 0 until y.nParticles) { // In this loop we try to update the position of all the particles in the flock
        // migrate
        val rp = r.nextDouble() 
        var ok = true // variable to check if all dimension values of a particle fall in range [lower bound,upper bound] or not.
        vel[j].fill(0.0)
        pos[j].fill(0.0)
        for (k in 0 until y.nDims) {// For each dimension of a particle(In our example case it is only two)
            vel[j][k] = p.omega * y.vel[j][k] +
                        p.phip * rp * (bpos[j][k] - y.pos[j][k]) +
                        p.phig * rg * (gbpos[k] - y.pos[j][k]) // Velocity update formula
            pos[j][k] = y.pos[j][k] + vel[j][k] // Position update formula
            ok = ok &amp;&amp; y.min[k]  pos[j][k] // ok will be set as false if range [lower bound,upper bound] is not satisfied.
        }
        if (!ok) { // If found false then re-initialize the position of current particle
            for (k in 0 until y.nDims) {
                pos[j][k]= y.min[k] + (y.max[k] - y.min[k]) * r.nextDouble()
            }
        }
    }
    val iter = 1 + y.iter // Increase the number of iterations.
    return State(
        iter, gbpos, gbval, y.min, y.max, y.parameters,
        pos, vel, bpos, bval, y.nParticles, y.nDims
    )
}

				
					// A simple function to perform required number of iterations using PSO.
fun iterate(fn: Func, n: Int, y: State): State {
    var r = y
    var old = y
    if (n == Int.MAX_VALUE) {
        while (true) {
            r = pso(fn, r)
            if (r == old) break
            old = r
        }
    }
    else {
        repeat(n) { r = pso(fn, r) }
    }
    return r
}

// Defining Mccormic Function 
fun mccormick(x: DoubleArray): Double {
    val (a, b) = x
    return Math.sin(a + b) + (a - b) * (a - b) + 1.0 + 2.5 * b - 1.5 * a
}

				
					// defining different variables which we will use for our example code 
var state = psoInit(
    min = doubleArrayOf(-1.5, -3.0), // lower bound
    max = doubleArrayOf(4.0, 4.0), // upper bound
    parameters = Parameters(0.1, 0.6, 0.3), // (omega , c1 , c2)
    nParticles = 100 // number of candidate particles
)
var number_of_iterations = 30 // Number of iterations of evolution required using PSO
state = iterate(::mccormick, number_of_iterations, state)
state.report("McCormick")
// Theoretical global minimum value of mccormick function is found at position (-.54719, -1.54719)
println("f(-0.54719, -1.54719) : ${mccormick(doubleArrayOf(-.54719, -1.54719))}")

Previous Topic

Back to Lesson

Next Topic