import random
import math
import matplotlib.pyplot as plt
import numpy as np

def objective_function(X): # Griewank function
    part1 = 0
    for i in range(len(X)):
        part1 += X[i]**2
        part2 = 1
    for i in range(len(X)):
        part2 *= math.cos(float(X[i]) / math.sqrt(i+1))
    return 1 + (float(part1)/4000.0) - float(part2)

bounds = [(-600, 600), (-600, 600)]  # upper and lower bounds of variables - Griewank
dim = 2  # dimensional of solution
minmax = -1  # if minimization problem, minmax = -1; if maximization problem, minmax = 1
Xmed=bounds[1][0]+((bounds[1][1]-bounds[1][0])/2)
Xlb=bounds[1][0]
Xub=bounds[1][1]

# THE FOLLOWING PARAMETERS ARE OPTIONAL
population = 30 # number of chimps
iteration = 100  # max number of iterations
# END OF THE CUSTOMIZATION SECTION
# ------------------------------------------------------------------------------
# Visualization
fig = plt.figure()
ax = fig.add_subplot()
plt.xlabel('Iterations')
plt.ylabel('Fitness')
plt.grid()
fig.show()
# ------------------------------------------------------------------------------
class performance:
    def __init__(self, bounds):
        self.position = []  # chimp position
        self.local_best_position = []  # best position of the chimp
        self.fitness_local_best_position = initial_fitness  # initial objective function value of the best chimp position
        self.fitness_position = initial_fitness  # objective function value of the chimp position
  
        for i in range(dim):
            self.position.append(random.uniform(bounds[i][0], bounds[i][1]))  # generate random initial position
       
    def evaluate(self, objective_function):
        self.fitness_position = objective_function(self.position)
        if minmax == -1:
            if self.fitness_position < self.fitness_local_best_position:
                self.local_best_position = self.position # update the local best
                self.fitness_local_best_position = self.fitness_position # update the fitness of the local best
        if minmax == 1:
            if self.fitness_position > self.fitness_local_best_position:
                self.local_best_position = self.position # update the local best
                self.fitness_local_best_position = self.fitness_position # update the fitness of the local best
    
    def update_capability(self, global_best_position):
        age=np.random.random()
        for i in range(dim):
            self.position[i] = age * self.position[i] + 4 * (age-age**2) * (self.local_best_position[i] - self.position[i])
    
    def update_social_interaction(self,bounds):
        r1=np.random.random()
        r2=np.random.random()
        r3=1-(r1+r2)
        if minmax == -1:
            x_male=np.random.uniform(Xlb,Xmed)
            x_female=np.random.uniform(Xmed,Xub)
        if minmax == 1:
            x_male=np.random.uniform(Xmed,Xub)
            x_female=np.random.uniform(Xlb,Xmed)
        for i in range(dim):
            self.position[i] = self.position[i] + r1 * (x_male-self.position[i]) + r2 * (x_female-self.position[i]) + r3 * (global_best_position[i]-self.position[i])
            #check and repair to satisfy the upper bounds
            if self.position[i] > bounds[i][1]:
                self.position[i] = bounds[i][1]
            #check and repair to satisfy the lower bounds
            if self.position[i] < bounds[i][0]:
                self.position[i] = bounds[i][0]

# -------------------------------------------------------------
if minmax == -1:
    initial_fitness = float("inf")  # for minimization problem
if minmax == 1:
    initial_fitness = -float("inf")  # for maximization problem
# -------------------------------------------------------------
fitness_global_best_position = initial_fitness
global_best_position = []
swarm = []
for i in range(population):
    swarm.append(performance(bounds))
A = []

for i in range(iteration):
    for j in range(population):
        swarm[j].evaluate(objective_function)
        
        if minmax == -1:
            if swarm[j].fitness_position < fitness_global_best_position:
                global_best_position = list(swarm[j].position)
                fitness_global_best_position = float(swarm[j].fitness_position)
        if minmax == 1:
            if swarm[j].fitness_position > fitness_global_best_position:
                global_best_position = list(swarm[j].position)
                fitness_global_best_position = float(swarm[j].fitness_position)
    
    for j in range(population):
        swarm[j].update_capability(global_best_position)
        swarm[j].update_social_interaction(bounds)
    
    A.append(fitness_global_best_position)   # record the best fitness
    
    # Visualization
    ax.plot(A, color='r')
    fig.canvas.draw()
    ax.set_xlim(left=max(0, i - iteration), right=i+3)
    
print('Optimal solution:', global_best_position)
print('Objective function value:', fitness_global_best_position)
print('Best solution found after {iter} iterations'.format(iter=A.index(fitness_global_best_position)))
plt.show()

<ipython-input-4-ea591c3d1a92>:12: UserWarning: Matplotlib is currently using module://ipykernel.pylab.backend_inline, which is a non-GUI backend, so cannot show the figure.
  fig.show()

Optimal solution: [0.09475262255342898, 0.020010254946328132]
Objective function value: 0.004587668683935897
Best solution found after 18 iterations