pso algorithm on test function. But I'm stuck with python code

Question

So I have to classes Swarm and Particles, and a class for Sphere function. But when I'm trying to run the optimization, I get error on iteretation and I don't understand why:

TypeError: '<' not supported between instances of 'NoneType' and 'NoneType'

Eventually, if you can give me some tipf for shifted sphere function.

from abc import ABCMeta, abstractmethod

import numpy import numpy.random

from particle import Particle

class Swarm (object):

__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

class Particle (object):

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

class 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

from swarm_x2 import Swarm_X2 from utils import printResult

if name == "main": 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()

pso algorithm on test function. But I'm stuck with python code

0 Answers0