Question

我想使用粒子群优化优化CNN的权重。基本上权重是倒数第二层，过滤器是优化的。 PSO取代了优化器，休息工作也以同样的方式完成。是否可以使用Keras或Tensorflow？编写了下面附带的PSO代码。

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()

Answer 1

好吧，您需要定义一个好的成本函数，该函数可以测量最佳层和滤波器数与当前层和滤波器之间的误差。

但是您想要获得什么目标？最小化时间成本还是最小化准确性？

顺便说一句，如果它的准确性很高，可能会太昂贵，因为对于每个粒子群优化种群，它都会训练您的CNN模型一次。

如何使用PSO优化CNN的权重？

1 个答案: