python - 测试函数上的 pso 算法。但我被python代码困住了

Question

所以我必须对 Swarm 和 Particles 进行分类，以及对 Sphere 函数进行分类。但是当我尝试运行优化时，我在迭代时遇到错误，我不明白为什么：

TypeError：“NoneType”和“NoneType”的实例之间不支持“<”

最后，如果你能给我一些关于移动球体功能的提示。

从 abc 导入 ABCMeta，抽象方法

导入 numpy 导入 numpy.random

从粒子导入粒子

类群（对象）：

__metaclass__ = ABCMeta

def __init__ (self, 
        swarmsize, 
        minvalues, 
        maxvalues, 
        currentVelocityRatio,
        localVelocityRatio, 
        globalVelocityRatio):
    
    self.__swarmsize = swarmsize

    assert len (minvalues) == len (maxvalues)
    assert (localVelocityRatio + globalVelocityRatio) > 4

    self.__minvalues = numpy.array (minvalues[:])
    self.__maxvalues = numpy.array (maxvalues[:])

    self.__currentVelocityRatio = currentVelocityRatio
    self.__localVelocityRatio = localVelocityRatio
    self.__globalVelocityRatio = globalVelocityRatio

    self.__globalBestFinalFunc = None
    self.__globalBestPosition = None

    self.__swarm = self.__createSwarm ()


def __getitem__ (self, index):
    """
    Возвращает частицу с заданным номером
    """
    return self.__swarm[index]


def __createSwarm (self):
    
    return [Particle (self) for _ in range (self.__swarmsize) ]



def nextIteration (self):
    
    for particle in self.__swarm:
        return particle.nextIteration (self)


@property
def minvalues (self):
    return self.__minvalues


@property
def maxvalues (self):
    return self.__maxvalues


@property
def currentVelocityRatio (self):
    return self.__currentVelocityRatio


@property
def localVelocityRatio (self):
    return self.__localVelocityRatio


@property
def globalVelocityRatio (self):
    return self.__globalVelocityRatio


@property
def globalBestPosition (self):
    return self.__globalBestPosition


@property
def globalBestFinalFunc (self):
    return self.__globalBestFinalFunc


def getFinalFunc (self, position):
    assert len (position) == len (self.minvalues)

    finalFunc = self._finalFunc (position)

    if (self.__globalBestFinalFunc == None or
            finalFunc < self.__globalBestFinalFunc):
        self.__globalBestFinalFunc = finalFunc
        self.__globalBestPosition = position[:]


@abstractmethod
def _finalFunc (self, position):
    pass


@property
def dimension (self):
    
    return len (self.minvalues)


def _getPenalty (self, position, ratio):
    
    penalty1 = sum ([ratio * abs (coord - minval)
        for coord, minval in zip (position, self.minvalues) 
        if coord < minval ] )

    penalty2 = sum ([ratio * abs (coord - maxval)
        for coord, maxval in zip (position, self.maxvalues) 
        if coord > maxval ] )

    return penalty1 + penalty2

类粒子（对象）：

def __init__ (self, swarm):
    
    self.__currentPosition = self.__getInitPosition (swarm)

   
    self.__localBestPosition = self.__currentPosition[:]

    self.__localBestFinalFunc = swarm.getFinalFunc (self.__currentPosition)

    self.__velocity = self.__getInitVelocity (swarm)


@property
def position (self):
    return self.__currentPosition


@property
def velocity (self):
    return self.__velocity


def __getInitPosition (self, swarm):
    return numpy.random.rand (swarm.dimension) * (swarm.maxvalues - swarm.minvalues) + swarm.minvalues


def __getInitVelocity (self, swarm):
    
    assert len (swarm.minvalues) == len (self.__currentPosition)
    assert len (swarm.maxvalues) == len (self.__currentPosition)

    minval = -(swarm.maxvalues - swarm.minvalues)
    maxval = (swarm.maxvalues - swarm.minvalues)

    return numpy.random.rand (swarm.dimension) * (maxval - minval) + minval


def nextIteration (self, swarm):
    
    rnd_currentBestPosition = numpy.random.rand (swarm.dimension)

    rnd_globalBestPosition = numpy.random.rand (swarm.dimension)

    veloRatio = swarm.localVelocityRatio + swarm.globalVelocityRatio
    commonRatio = (2.0 * swarm.currentVelocityRatio / 
            (numpy.abs (2.0 - veloRatio - numpy.sqrt (veloRatio ** 2 - 4.0 * veloRatio) ) ) )

  
    newVelocity_part1 = commonRatio * self.__velocity

    newVelocity_part2 = (commonRatio * 
            swarm.localVelocityRatio * 
            rnd_currentBestPosition * 
            (self.__localBestPosition - self.__currentPosition) )

    newVelocity_part3 = (commonRatio * 
            swarm.globalVelocityRatio * 
            rnd_globalBestPosition * 
            (swarm.globalBestPosition - self.__currentPosition) )
    
    self.__velocity = newVelocity_part1 + newVelocity_part2 + newVelocity_part3

    self.__currentPosition += self.__velocity

    finalFunc = swarm.getFinalFunc (self.__currentPosition)
    if finalFunc < self.__localBestFinalFunc:
        self.__localBestPosition = self.__currentPosition[:]
        self.__localBestFinalFunc = finalFunc

类 Swarm_X2 (Swarm): def init (self, swarmsize, minvalues, maxvalues, currentVelocityRatio, localVelocityRatio, globalVelocityRatio): Swarm。init (self, swarmsize, minvalues, maxvalues, currentVelocityRatio, localVelocityRatio, globalVelocityRatio)

def _finalFunc (self, position):
    penalty = self._getPenalty (position, 10000.0)
    finalfunc = sum (position * position)

    return finalfunc + penalty

从 swarm_x2 导入 Swarm_X2 从 utils 导入 printResult

如果名称== “主”：iterCount = 300

dimension = 5
swarmsize = 200

minvalues = numpy.array ([-100] * dimension)
maxvalues = numpy.array ([100] * dimension)

currentVelocityRatio = 0.1
localVelocityRatio = 1.0
globalVelocityRatio = 5.0

swarm = Swarm_X2 (swarmsize, 
        minvalues, 
        maxvalues,
        currentVelocityRatio,
        localVelocityRatio, 
        globalVelocityRatio
        )

for n in range (iterCount):
    print "Position", swarm[0].position
    print "Velocity", swarm[0].velocity

    print printResult (swarm, n)

    swarm.nextIteration()

标签： pythonshiftparticle-swarm