python code for African Vulture Optimization

# import packages

import random

import time

import numpy as np

rng = np.random.default_rng()

import math

import sys

from numpy import linalg as LA

import numpy as np

import math

Supporting functions

def fun(X):

output = sum(np.square(X))+random.random()

return output

# This function is to initialize the Vulture population.

def initial(pop, dim, ub, lb):

X = np.zeros([pop, dim])

for i in range(pop):

for j in range(dim):

X[i, j] = random.random()*(ub[j] - lb[j]) + lb[j]

return X

# Calculate fitness values for each Vulture

def CaculateFitness1(X,fun):

fitness = fun(X)

return fitness

# Sort fitness.

def SortFitness(Fit):

fitness = np.sort(Fit, axis=0)

index = np.argsort(Fit, axis=0)

return fitness,index

# Sort the position of the Vulture according to fitness.

def SortPosition(X,index):

Xnew = np.zeros(X.shape)

for i in range(X.shape[0]):

Xnew[i,:] = X[index[i],:]

return Xnew

# Boundary detection function.

def BorderCheck1(X,lb,ub,dim):

for j in range(dim):

if X[j]<lb[j]:

X[j] = ub[j]

elif X[j]>ub[j]:

X[j] = lb[j]

return X

def rouletteWheelSelection(x):

CS = np.cumsum(x)

Random_value = random.random()

index = np.where(Random_value <= CS)

index = sum(index)

return index

def random_select(Pbest_Vulture_1,Pbest_Vulture_2,alpha,betha):

probabilities=[alpha, betha ]

index = rouletteWheelSelection( probabilities )

if ( index.all()> 0):

random_vulture_X=Pbest_Vulture_1

else:

random_vulture_X=Pbest_Vulture_2

return random_vulture_X

def exploration(current_vulture_X, random_vulture_X, F, p1, upper_bound, lower_bound):

if random.random()<p1:

current_vulture_X=random_vulture_X-(abs((2*random.random())*random_vulture_X-current_vulture_X))*F;

else:

current_vulture_X=(random_vulture_X-(F)+random.random()*((upper_bound-lower_bound)*random.random()+lower_bound));

return current_vulture_X

def exploitation(current_vulture_X, Best_vulture1_X, Best_vulture2_X,random_vulture_X, F, p2, p3, variables_no, upper_bound, lower_bound):

if abs(F)<0.5:

if random.random()<p2:

A=Best_vulture1_X-((np.multiply(Best_vulture1_X,current_vulture_X))/(Best_vulture1_X-current_vulture_X**2))*F

B=Best_vulture2_X-((Best_vulture2_X*current_vulture_X)/(Best_vulture2_X-current_vulture_X**2))*F

current_vulture_X=(A+B)/2

else:

current_vulture_X=random_vulture_X-abs(random_vulture_X-current_vulture_X)*F*levyFlight(variables_no)

if random.random()>=0.5:

if random.random()<p3:

current_vulture_X=(abs((2*random.random())*random_vulture_X-current_vulture_X))*(F+random.random())-(random_vulture_X-current_vulture_X)

else:

s1=random_vulture_X*(random.random()*current_vulture_X/(2*math.pi))*np.cos(current_vulture_X)

s2=random_vulture_X*(random.random()*current_vulture_X/(2*math.pi))*np.sin(current_vulture_X)

current_vulture_X=random_vulture_X-(s1+s2)

return current_vulture_X

# eq (18)

def levyFlight(d):

beta=3/2;

sigma=(math.gamma(1+beta)*math.sin(math.pi*beta/2)/(math.gamma((1+beta)/2)*beta*2**((beta-1)/2)))**(1/beta)

u=np.random.randn(1,d)*sigma;

v=np.random.randn(1,d);

step=u/abs(v)**(1/beta);

o=step;

return o

AVO Algorithm

def AVA(pop,dim,lb,ub,Max_iter,fun):

alpha=0.8

betha=0.2

p1 = 0.6

p2=0.4

p3=0.6

Gama = 2.5

X = initial(pop, dim, lb,ub) # Initialize the random population

fitness = np.zeros([pop, 1])

for i in range(pop):

fitness[i] = CaculateFitness1(X[i, :], fun)

fitness, sortIndex = SortFitness(fitness) # Sort the fitness values of African Vultures

X = SortPosition(X, sortIndex) # Sort the African Vultures population based on fitness

GbestScore = fitness[0] # Stores the optimal value for the current iteration.

GbestPositon = np.zeros([1, dim])

GbestPositon[0, :] = X[0, :]

Curve = np.zeros([Max_iter, 1])

Xnew = np.zeros([pop, dim])

# Main iteration starts here

for t in range(Max_iter):

Pbest_Vulture_1 = X[0,:] #location of Vulture (First best location Best Vulture Category 1)

Pbest_Vulture_2 = X[1,:] #location of Vulture (Second best location Best Vulture Category 1)

t3=np.random.uniform(-2,2,1)*((np.sin((math.pi/2)*(t/Max_iter))**Gama)+np.cos((math.pi/2)*(t/Max_iter))-1)

z = random.randint(-1, 0)

#F= (2*random.random()+1)*z*(1-(t/Max_iter))+t3

P1=(2*random.random()+1)*(1-(t/Max_iter))+t3

F=P1*(2*random.random()-1)

# For each vulture Pi

for i in range(pop):

current_vulture_X = X[i,:]

random_vulture_X=random_select(Pbest_Vulture_1,Pbest_Vulture_2,alpha,betha) # select random vulture using eq(1)

if abs(F) >=1:

current_vulture_X = exploration(current_vulture_X, random_vulture_X, F, p1, ub, lb) # eq (16) & (17)

else:

current_vulture_X = exploitation(current_vulture_X, Pbest_Vulture_1, Pbest_Vulture_2, random_vulture_X, F, p2, p3, dim, ub, lb) # eq (10) & (13)

Xnew[i,:] = current_vulture_X[0]

Xnew[i,:] = BorderCheck1(Xnew[i,:], lb, ub, dim)

tempFitness = CaculateFitness1(Xnew[i,:], fun)

# Update local best solution

if (tempFitness <= fitness[i]):

fitness[i] = tempFitness

X[i,:] = Xnew[i,:]

Ybest,index = SortFitness(fitness)

X = SortPosition(X, index)

# Update global best solution

if (Ybest[0] <= GbestScore):

GbestScore = Ybest[0]

GbestPositon[0, :] = X[index[0], :]

#print(GbestPositon)

Curve[t] = GbestScore

return Curve,GbestPositon,GbestScore

Main code

rng = np.random.default_rng()

time_start = time.time()

pop = 2 # Population size n

MaxIter = 300 # Maximum number of iterations.

dim = 20 # The dimension.

fl=-100 # The lower bound of the search interval.

ul=100 # The upper bound of the search interval.

lb = fl*np.ones([dim, 1])

ub = ul*np.ones([dim, 1])

Curve,GbestPositon,GbestScore = AVA(pop, dim, lb, ub, MaxIter, fun) # Afican Vulture Optimization Algorithm

time_end = time.time()

print(f"The running time is: {time_end - time_start } s")

print('The optimal value：',GbestScore)

print('The optimal solution：',GbestPositon)

View convergence curve

import matplotlib.pyplot as plt

fig, ax = plt.subplots()

ax.plot( Curve,color='dodgerblue', marker='o', markeredgecolor='dodgerblue', markerfacecolor='dodgerblue')

ax.set_xlabel('Number of Iterations',fontsize=15)

ax.set_ylabel('Fitness',fontsize=15)

ax.set_title('African Vulture Optimization')

plt.savefig('image.jpg', format='jpg')

plt.show()