Particle Swarm Optimization

Particle swarm optimization (PSO) (Kennedy & Eberhart, 1995) is an emerging population-based meta-heuristic that simulates social behavior such as birds flocking to a promising position to achieve precise solutions in a multidimensional space. It is mainly
developed for the optimization of constrains, multi-object problems, dynamic system, data clustering, and signal process. In the algorithm, to discover the optimal solution, each particle changes its searching direction according to two factors, its own best
previous experience (pbest) and the best experience of all other members (gbest). Shi and Eberhart (1998) called pbest the cognition part, and gbest the social part. 

# -*- coding: utf-8 -*-
"""
Created on 2017/3/18 21:24 2017

@author: Randolph.Lee
"""
import sys
import copy
import numpy as np

class Particle:
def __init__(self, ID, dimension, weight=0.5, c1=2, c2=2):
self.ID = ID
self.weight = weight
self.c1 = c1
self.c2 = c2
self.dimension = dimension
self.max_x = np.ones((1, dimension)) * 30
self.min_x = -np.ones((1, dimension)) * 30
self.max_velocity = np.ones((1, dimension)) * (self.max_x - self.min_x)
self.velocity = (2 * np.random.randn(1, dimension) - 1) * self.max_velocity
self.position = np.random.randn(1, dimension)
self.history_best = np.zeros((1, dimension))
self.history_fit = sys.maxint
self.current_fit = 0.0

def cal_fitness(self):
x_i0 = self.position[0, :-1]
x_i1 = self.position[0, 1:]
self.current_fit = sum(100 * np.power(x_i1 - np.power(x_i0, 2), 2) + np.power(x_i0 - 1, 2))

def update_property(self, g_best):
print g_best
self.velocity *= self.weight
self.velocity += np.random.rand() * self.c1 * (self.history_best - self.position) + np.random.rand() * self.c2 * (g_best - self.position)
self.position += self.velocity
# clip the velocity and the variables
for i in xrange(self.dimension):
if self.velocity[0, i] > self.max_velocity[0, i]:
self.velocity[0, i] = self.max_velocity[0, i]
if self.velocity[0, i] < -self.max_velocity[0, i]:
self.velocity[0, i] = -self.max_velocity[0, i]
if self.position[0, i] > self.max_x[0, i]:
self.position[0, i] = self.max_x[0, i]
if self.position[0, i] < self.min_x[0, i]:
self.position[0, i] = self.min_x[0, i]

def update_pbest(self):
if self.history_fit > self.current_fit:
self.history_fit = self.current_fit
self.history_best = copy.deepcopy(self.position)

if __name__ == "__main__":
max_iteration = 100
particle_num = 10
dimension = 5
# create particle instances and initialize their position and velocity
swarm = [Particle(i, dimension) for i in range(particle_num)]
history_record = []
global_record = []
global_best = np.zeros((1, dimension))
global_fit = sys.maxint
# initialize the global swarm
for i in xrange(particle_num):
print swarm[i].position
swarm[i].cal_fitness()
swarm[i].update_pbest()
if global_fit > swarm[i].current_fit:
global_fit = swarm[i].current_fit
global_best = copy.deepcopy(swarm[i].position)
global_record.append(global_fit)
start = 0
while start < max_iteration:
for i in xrange(particle_num):
swarm[i].cal_fitness()
swarm[i].update_pbest()
swarm[i].update_property(global_best)
# update the global fitness
if global_fit > swarm[i].current_fit:
global_fit = swarm[i].current_fit
global_best = copy.deepcopy(swarm[i].position)
global_record.append(global_fit)
start += 1
print global_best
print global_record