How can I optimise the weights of CNN using PSO?

Question

I want to optimize the weights of CNN using Particle Swarm Optimization. Basically weights are at penultimate layer and filters that are tobe optimised. The PSO replaces the optimisers and rest work is done in same way. Will it be possible by using Keras or Tensorflow? Have written a PSO code that is attached below.

import random

w = 0.729844 # Inertia weight to prevent velocities becoming too large
c1 = 1.496180 # Scaling co-efficient on the social component
c2 = 1.496180 # Scaling co-efficient on the cognitive component
dimension = 20 # Size of the problem
iterations = 3000
swarmSize = 30

# This class contains the code of the Particles in the swarm
class Particle:
    velocity = []
    pos = []
    pBest = []

    def __init__(self):
        for i in range(dimension):
            self.pos.append(random.random())
            self.velocity.append(0.01 * random.random())
            self.pBest.append(self.pos[i])
        return

    def updatePositions(self):
        for i in range(dimension):
            self.pos[i] = self.pos[i] + self.velocity[i]   
        return

    def updateVelocities(self, gBest):
        for i in range(dimension):
            r1 = random.random()
            r2 = random.random()
            social = c1 * r1 * (gBest[i] - self.pos[i])
            cognitive = c2 * r2 * (self.pBest[i] - self.pos[i])
            self.velocity[i] = (w * self.velocity[i]) + social + cognitive
        return

    def satisfyConstraints(self):
        #This is where constraints are satisfied
        return

# This class contains the particle swarm optimization algorithm
class ParticleSwarmOptimizer:
    solution = []
    swarm = []

    def __init__(self):
        for h in range(swarmSize):
            particle = Particle()
            self.swarm.append(particle)
        return

    def optimize(self):
        for i in range(iterations):
            print "iteration ", i
            #Get the global best particle
            gBest = self.swarm[0]
            for j in range(swarmSize):
                pBest = self.swarm[j].pBest
                if self.f(pBest) &gt; self.f(gBest):
                    gBest = pBest  
            solution = gBest
            #Update position of each paricle
            for k in range(swarmSize):
                self.swarm[k].updateVelocities(gBest)
                self.swarm[k].updatePositions()
                self.swarm[k].satisfyConstraints()
            #Update the personal best positions
            for l in range(swarmSize):
                pBest = self.swarm[l].pBest
                if self.f(self.swarm[l]) &gt; self.f(pBest):
                    self.swarm[l].pBest = self.swarm[l].pos
        return solution

    def f(self, solution):
        #This is where the metaheuristic is defined
        return  random.random()

def main():
    pso = ParticleSwarmOptimizer()
    pso.optimize()

score 0 · Answer 1 · answered Dec 17 '20 at 14:44

Well, you need to define a good cost function, which measures the error between the optimal number of layers and filters and current layers and filters.

But what goal you want to obtain? Minimize time cost or minimize the accuracy?

By the way, if its accuracy, it might be too costy, because for each population of particle swarm optimization, it would train your CNN model once.

How can I optimise the weights of CNN using PSO?

1 Answers1