def Follow(Xi):
Yi = problem.reso(Xi)
#print("Yi", Yi)
Xj = Xi # 最优点，暂定
#print("Xj", Xj)
Yj = Yi # 范围内最优值，如果有更好的就更新
#print("Yj", Yj)
nf = 1 # 统计有多少个 粒子 在 Vision 范围之内
#print("开始遍历")
for n in range(psize): # 遍历一遍所有粒子
#print("X", X)
#print("X[n]", X[n])
#print("距离", Distan(X[n], Xi))
if Distan(X[n], Xi) <= V: # 如果在视野范围内
#print("发现了一个")
nf += 1 # 计数 + 1
#print("X[n]", X[n])
Yn = problem.reso(X[n])
#print("Yn", Yn)
if Yn < Yj:
Xj = X[n] # 更新最优
Yj = Yn
if Yj / nf > delta * Yi:
Xnext = Xj + (Xj - Xi) / np.linalg.norm(Xj - Xi) * S * random.random()
#Xnext = Xj + (Xj - Xi)/np.linalg.norm(Xj - Xi) * Step()
return Xnext
else:
return Prey(Xi)
def update():
global BestX
global BestY
for i in range(psize): # 3 对每个个体进行评价，对其要执行的行为进行选择，包括觅食、聚群、追尾和随机行为
tempX = X[i]
tempY = Adapt[i]
Xs = Swarm(X[i]) # 尝试 聚群
Ys = problem.reso(Xs) # 求适应度
if Ys < tempY:
tempX = Xs
tempY = Ys
Xf = Follow(X[i]) # 尝试 追尾
Yf = problem.reso(Xf) # 求适应度
if Yf < tempY:
tempX = Xf
tempY = Yf
Xp = Prey(X[i]) # 尝试 觅食
Yp = problem.reso(Xp) # 求适应度
if Yp < tempY:
tempX = Xp
tempY = Yp
X[i] = tempX #
Adapt[i] = tempY
if tempY < BestY: # 5 评价所有个体。若某个体优于公告牌，则将公告牌更新为该个体
BestX = tempX
BestY = tempY
def update(): # 一次迭代更新
global xl
global xr
global x
global step
global dire
global fbest
global xbest
fleft = problem.reso(xl) # 左须适应度
fright = problem.reso(xr) # 右须适应度
if fleft < fright: # 如果左须优于右须
x = x + step * dire * d0 * 2 # 质心向左须方向移动
if fleft < fbest: # 如果左须比当前最优结果要好
fbest = fleft # 更新最好适应度
xbest = xl
else: # 操作同上
x = x - step * dire * d0 * 2
if fright < fbest:
fbest = fright # 更新最好适应度
xbest = xr
dire = np.array([random.random() for i in range(R)]) # 更新天牛运动方向，随机产生
np.linalg.norm(dire) # 归一化
xl = x + d0 * (dire) # 更新天牛左须位置
xr = x - d0 * (dire) # 更新天牛右须位置
step = step * eta # 更新步长
def Prey(Xi):
Yi = problem.reso(Xi)
tn = 0
while tn < maxt: # 最多尝试 maxt 次
tn += 1
Xj = Xi + S * Rand(4) # 视野范围内随机移动一步 S or V ?
#Xj = Xi + V * Rand(4) # 视野范围内随机移动一步
Yj = problem.reso(Xj)
if Yj < Yi: # 如果视野内的新点更优
#Xnext = Xi + (Xj - Xi)/np.linalg.norm(Xj - Xi) * Step()
Xnext = Xi + (Xj - Xi) / np.linalg.norm(Xj -
Xi) * S * random.random()
return (Xnext)
else:
return Move(Xi) # 随机行为
def Swarm(Xi):
Yi = problem.reso(Xi)
nf = 1 # 统计有多少个 粒子 在 Vision 范围之内
Xct = VacantC(4) # 群体的中心位置
for n in range(psize): # 遍历一遍所有粒子
if Distan(X[n], Xi) <= V:
nf += 1 # 计数 + 1
Xct = Xct + X[n] # 中心点坐标积累 加上
Xc = Xct / nf # 中心点
Yc = problem.reso(Xc)
if Yc / nf > delta * Yi:
#Xnext = Xi + (Xc - Xi)/np.linalg.norm(Xc - Xi) * Step()
Xnext = Xi + (Xc - Xi) / np.linalg.norm(Xc - Xi) * S * random.random()
return Xnext
else:
return Prey(Xi)
def update(n): # 对排名第 n 的 X 向量进行试探更新
explor = probe(
X[Rank[n]]) # Rank[n] 为第 n 好的 X 向量位置，固定根据 X[Rank[n]]向三个方向延申的 探测向量值
resexp = problem.reso(explor) # 对 探测值 求解
if resexp <= Adapt[Rank[n]]: # 如果新 PX 值更优
X[Rank[
n]] = explor # X[i] 更新为 探测值 ********************************************************** 用 onea 归一化
Adapt[Rank[n]] = resexp # 排名第 n 的 X 向量对应的适应度值更新为 resexp
# 外部子程序
import problem_2 as problem # 导入 problem problem_1 简单问题 problem_2 调度问题
###########################-设置迭代次数及种群大小-#############################
maxitr = 20 # 最大迭代次数 max iteration generation
psize = 200 # 种群数量 population size
t0 = time.process_time()
###########################-随机生成初始种群-##################################
X = problem.criarRand(psize) # 生成数量为 psize 的初始解集
###########################-对初始种群求解-####################################
Adapt = [] # 适应度值的集合
for i in range(psize): # 都求解一遍
Adapt.append(problem.reso(X[i])) # 结果保存到 adapt[] 中
Adapt = np.array(Adapt)
# print('初始适应度值：\n', Adapt)
Rank = Adapt.argsort()
# print('适应度值 adapt 顺序索引:')
# print(Rank)
# solu 是一个待更新的解
def probe(solu): # 根据原 X 向 XA XB XC 三个方向探测 （A 和 C 每次都是随机？） 经测试，此种效果更好
a = 0.2 + 2 * (
2 - 2 * t / maxitr
) # 控制距离参数（从第 1 代开始） t 当前迭代次数，a 控制距离参数，MI 最大迭代次数 # 测试学习率系数 # 增大学习率，增加随机性？ 产生一定变异有助于随机寻优？
X1 = X[Rank[0]] + (2 * a * random.random() - a) * abs(
# Move 随机
def Move(Xi):
return Xi + S * Rand(4)
# 算法流程
# 1 初始化设置
maxitr = 32 # 最大迭代次数 max iteration generation
psize = 20 # 种群数量 population size
#V = 30 # Visual 视野
#S = 50 # Step 步长
delta = 0.3 * psize # 拥挤度因子 在求极大值问题中，δ=1/(αnmax),α∈(0,1]δ=1/(αnmax),α∈(0,1]；在求极小值问题中，δ=αnmax,α∈(0,1]δ=αnmax,α∈(0,1]。其中α为极值接近水平， nmax为期望在该邻域内聚集的最大人工鱼数目。
maxt = 5 # 觅食行为最多尝试次数
BestX = VacantC(4) # 初始最优点，选默认点
BestY = problem.reso(BestX) # 最优适应度值（暂定）
# 2 计算初始鱼群各个体的适应值，取最优人工鱼状态及其值赋予给公告牌
X = problem.criarRand(psize) # 生成数量为 psize 的初始种群
#X[1] = [109.76040464, 420.46471964, 156.15767451, 396.00807855]
print(X)
Adapt = [] # 适应度值的集合
for i in range(psize): # 都求解一遍
Adapt.append(problem.reso(X[i])) # 结果保存到 adapt[] 中
Adapt = np.array(Adapt) # Adapt[n]： X[n]的适应度值
# print('初始适应度值：\n', Adapt)
Rank = Adapt.argsort()
# print('适应度值 adapt 顺序索引:')
def fitness(self, ind_var):
"""
个体适应值计算
"""
return problem.reso(ind_var)
import numpy as np
import random # random 0，1 之间 uniform 自定义区间 random.random()
#import copy
import time
import matplotlib.pyplot as plt
# 外部子程序
import problem_2 as problem # 导入 problem 2
t0 = time.process_time()
###########################-最大迭代次数（百次）-##################################
maxitr = 16
###########################-生成初始天牛-##################################
x = problem.defalt() # 天牛的初始质心，选取默认点
xbest = x
fbest = problem.reso(xbest)
#x = [100, 100, 100, 100]
R = len(x) # 粒子的维度
print('初始天牛质心：\n', x)
d0 = 1.0 # 两须之间距离的1/2 1.0
dire = np.array([random.random() for i in range(R)]) # 天牛右须指向左须的向量，天牛运动方向，随机生成
np.linalg.norm(dire) # 归一化
xl = x + d0 * (dire) # 天牛左须位置
xr = x - d0 * (dire) # 天牛右须位置
step = 20 # 初始步长 20
eta = 0.997 # 步长更新系数 997