# 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
Supporting functions
def fun(X):
output = sum(np.square(X))
return output
# This function is to initialize the Honey Badger 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 Honey Badger.
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 Honey Badger 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 Intensity(pop,GbestPositon,X):
epsilon = 0.00000000000000022204
di = np.zeros(pop)
S = np.zeros(pop)
I = np.zeros(pop)
for j in range(pop):
if (j <= pop):
di[j]=LA.norm([[X[j,:]-GbestPositon+epsilon]])
S[j]= LA.norm([X[j,:]-X[j+1,:]+epsilon])
di[j] = np.power(di[j], 2)
S[j]= np.power(S[j], 2)
else:
di[j]=[ LA.norm[[X[pop,:]-GbestPositon+epsilon]]]
S[j]=[LA.norm[[X[pop,:]-X[1,:]+epsilon]]]
di[j] = np.power(di[j], 2)
S[j]= np.power(S[j], 2)
for i in range(pop):
n = random.random()
I[i] = n*S[i]/[4*math.pi*di[i]]
return I
HBO Algorithm
def hba(pop,dim,lb,ub,Max_iter,fun):
X = initial(pop, dim, lb,ub) # Initialize the number of honey badgers
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 honey badger.
X = SortPosition(X, sortIndex) # Sort the honey badger.
GbestScore = fitness[0] # The optimal value for the current iteration.
GbestPositon = np.zeros([1, dim])
GbestPositon[0, :] = X[0, :]
Curve = np.zeros([Max_iter, 1])
C = 2 # constant in Eq. (3)
beta = 6 # the ability of HB to get the food Eq.(4)
vec_flag=[1,-1]
vec_flag=np.array(vec_flag)
Xnew = np.zeros([pop, dim])
for t in range(Max_iter):
#print("iteration: ",t)
alpha=C*math.exp(-t/Max_iter); # density factor in Eq. (3)
I=Intensity(pop,GbestPositon,X); # intensity in Eq. (2)
Vs=random.random()
for i in range(pop):
Vs=random.random()
F=vec_flag[math.floor((2*random.random()))]
for j in range(dim):
di=GbestPositon[0,j]-X[i,j]
if (Vs <0.5): # Digging phase Eq. (4)
r3=np.random.random()
r4=np.random.randn()
r5=np.random.randn()
Xnew[i,j]=GbestPositon[0,j] +F*beta*I[i]* GbestPositon[0,j]+F*r3*alpha*(di)*np.abs(math.cos(2*math.pi*r4)*(1-math.cos(2*math.pi*r5)));
else:
r7=random.random()
Xnew[i,j]=GbestPositon[0,j]+F*r7*alpha*di; # Honey phase Eq. (6)
#print(di)
Xnew[i,:] = BorderCheck1(Xnew[i,:], lb, ub, dim)
tempFitness = CaculateFitness1(Xnew[i,:], fun)
if (tempFitness <= fitness[i]):
fitness[i] = tempFitness
X[i,:] = Xnew[i,:]
for i in range(pop):
X[i,:] = BorderCheck1(X[i,:], lb, ub ,dim)
Ybest,index = SortFitness(fitness) # Sort fitness values.
if (Ybest[0] <= GbestScore):
GbestScore = Ybest[0] # Update the global optimal solution.
GbestPositon[0, :] = X[index[0], :] # Sort fitness values
Curve[t] = GbestScore
return GbestScore,GbestPositon,Curve
Main code
rng = np.random.default_rng()
time_start = time.time()
pop = 50 # Honey Badger population size.
MaxIter = 300 # Maximum number of iterations.
dim = 20 # The dimension.
fl=-10 # The lower bound of the search interval.
ul=10 # The upper bound of the search interval.
lb = fl*np.ones([dim, 1])
ub = ul*np.ones([dim, 1])
GbestScore, GbestPositon, Curve = hba(pop, dim, lb, ub, MaxIter, fun)
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)