def __init__(self, obj_func=None, lb=None, ub=None, problem_size=50, batch_size=10, verbose=True,
epoch=750, pop_size=100, bout_size=0.05):
Root.__init__(self, obj_func, lb, ub, problem_size, batch_size, verbose)
self.epoch = epoch
self.pop_size = pop_size
if bout_size < 1: # Number of tried with tournament selection (5% of pop_size)
self.bout_size = int(bout_size * self.pop_size)
else:
self.bout_size = int(bout_size)
self.distance = 0.05 * (self.ub - self.lb)
def __init__(self,
objective_func=None,
problem_size=50,
domain_range=(-1, 1),
log=True,
epoch=750,
pop_size=100):
Root.__init__(self, objective_func, problem_size, domain_range, log)
self.epoch = epoch
self.pop_size = pop_size
def __init__(self, obj_func=None, lb=None, ub=None, verbose=True, epoch=750, pop_size=100, lamda=0.5, xichma=0.3, **kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.xichma = xichma # Weight factor
self.lamda = lamda # Number of the best will keep
if lamda < 1:
self.n_best = int(lamda * self.pop_size)
else:
self.n_best = int(lamda)
def __init__(self, obj_func=None, lb=None, ub=None, verbose=True, epoch=750, pop_size=100,
RT=3, g=0.2, alp=0.4, c=0.4, max_v=0.3, **kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.RT = RT # RT coefficient
self.g = g # gravitational constant
self.alp = alp # constants in the update equation
self.c = c # coriolis effect
self.max_v = max_v # maximum allowed speed
def __init__(self, objective_func=None, problem_size=50, domain_range=(-1, 1), log=True,
epoch=750, pop_size=100, couple_bees=(16, 4), patch_variables=(5.0, 0.985), sites=(3, 1)):
Root.__init__(self, objective_func, problem_size, domain_range, log)
self.epoch = epoch
self.pop_size = pop_size
self.e_bees = couple_bees[0] # number of bees which provided for good location and other location
self.o_bees = couple_bees[1]
self.patch_size = patch_variables[0] # patch_variables = patch_variables * patch_factor (0.985)
self.patch_factor = patch_variables[1]
self.num_sites = sites[0] # 3 bees (employed bees, onlookers and scouts), 1 good partition
self.elite_sites = sites[1]
def __init__(self,
obj_func=None,
lb=None,
ub=None,
verbose=True,
epoch=750,
pop_size=100,
**kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
def __init__(self,
root_paras=None,
epoch=750,
pop_size=100,
wf=0.8,
cr=0.9):
Root.__init__(self, root_paras)
self.epoch = epoch
self.pop_size = pop_size
self.weighting_factor = wf
self.crossover_rate = cr
def __init__(self, obj_func=None, lb=None, ub=None, verbose=True, epoch=750, pop_size=100,
gamma=1, beta_base=1, alpha=0.2, alpha_damp=0.99, delta=0.05, m=2, **kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.gamma = gamma # Light Absorption Coefficient
self.beta_base = beta_base # Attraction Coefficient Base Value
self.alpha = alpha # Mutation Coefficient
self.alpha_damp = alpha_damp # Mutation Coefficient Damp Rate
self.delta = delta # Mutation Step Size
self.m = m # Exponent
def __init__(self, obj_func=None, lb=None, ub=None, verbose=True, epoch=750, pop_size=100,
m=5, p1=0.25, p2=0.5, p3=0.75, p4=0.5, **kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.m = m # n: pop_size, m: clusters
self.p1 = p1 # 25% percent
self.p2 = p2 # 50% percent changed by its own (local search), 50% percent changed by outside (global search)
self.p3 = p3 # 75% percent develop the old idea, 25% invented new idea based on levy-flight
self.p4 = p4 # Need more weights on the centers instead of the random position
self.m_solution = int(self.pop_size / self.m)
def __init__(self,
root_paras=None,
epoch=750,
pop_size=100,
r=0.95,
pf=(0, 10)):
Root.__init__(self, root_paras)
self.epoch = epoch
self.pop_size = pop_size
self.r = r # (r_min, r_max): pulse rate / emission rate
self.pf = pf # (pf_min, pf_max): pulse frequency
def __init__(self, obj_func=None, lb=None, ub=None, problem_size=50, batch_size=10, verbose=True,
epoch=750, pop_size=100, n_best=5, partition=0.5, max_step_size=1.0):
Root.__init__(self, obj_func, lb, ub, problem_size, batch_size, verbose)
self.epoch = epoch
self.pop_size = pop_size
self.n_best = n_best # how many of the best moths to keep from one generation to the next
self.partition = partition # The proportional of first partition
self.max_step_size = max_step_size
self.n_moth1 = int(ceil(self.partition * self.pop_size)) # np1 in paper
self.n_moth2 = self.pop_size - self.n_moth1 # np2 in paper
self.golden_ratio = (sqrt(5) - 1) / 2.0 # you can change this ratio so as to get much better performance
def __init__(self, obj_func=None, lb=None, ub=None, problem_size=50, batch_size=10, verbose=True,
epoch=750, pop_size=100, pc=0.98, pm=0.025, p_local=0.5, max_local_gens=10, bits_per_param=16):
Root.__init__(self, obj_func, lb, ub, problem_size, batch_size, verbose)
self.epoch = epoch
self.pop_size = pop_size
self.pc = pc
self.pm = pm
self.p_local = p_local
self.max_local_gens = max_local_gens
self.bits_per_param = bits_per_param
self.bits_total = self.problem_size * self.bits_per_param
def __init__(self,
root_paras=None,
epoch=750,
pop_size=100,
pc=0.95,
pm=0.025):
Root.__init__(self, root_paras)
self.epoch = epoch
self.pop_size = pop_size
self.pc = pc
self.pm = pm
def __init__(self,
objective_func=None,
problem_size=50,
domain_range=(-1, 1),
log=True,
epoch=750,
pop_size=100,
S=2):
Root.__init__(self, objective_func, problem_size, domain_range, log)
self.epoch = epoch
self.pop_size = pop_size
self.S = S # somersault factor that decides the somersault range of manta rays
def __init__(self,
objective_func=None,
problem_size=50,
domain_range=(-1, 1),
log=True,
epoch=750,
pop_size=100,
fp=(0.65, 0.9)):
Root.__init__(self, objective_func, problem_size, domain_range, log)
self.epoch = epoch
self.pop_size = pop_size
self.fp = fp # (fp_min, fp_max): Female Percent
def __init__(self,
objective_func=None,
problem_size=50,
domain_range=(-1, 1),
log=True,
epoch=750,
pop_size=100,
wep_minmax=(1.0, 0.2)):
Root.__init__(self, objective_func, problem_size, domain_range, log)
self.epoch = epoch
self.pop_size = pop_size
self.wep_minmax = wep_minmax # Wormhole Existence Probability (min and max in Eq.(3.3) paper
def __init__(self,
objective_func=None,
problem_size=50,
domain_range=(-1, 1),
log=True,
epoch=750,
pop_size=100,
pp=0.05):
Root.__init__(self, objective_func, problem_size, domain_range, log)
self.epoch = epoch
self.pop_size = pop_size # SailFish pop size
self.pp = pp # the rate between SailFish and Sardines (N_sf = N_s * pp) = 0.25, 0.2, 0.1
def __init__(self, obj_func=None, lb=None, ub=None, verbose=True, epoch=750, pop_size=100,
max_sub_iter=10, t0=1000, t1=1, move_count=5, mutation_rate=0.1,
mutation_step_size=0.1, mutation_step_size_damp=0.99, **kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.max_sub_iter = max_sub_iter # Maximum Number of Sub-Iteration (within fixed temperature)
self.t0 = t0 # Initial Temperature
self.t1 = t1 # Final Temperature
self.move_count = move_count # Move Count per Individual Solution
self.mutation_rate = mutation_rate # Mutation Rate
self.mutation_step_size = mutation_step_size # Mutation Step Size
self.mutation_step_size_damp = mutation_step_size_damp # Mutation Step Size Damp
def __init__(self,
obj_func=None,
lb=None,
ub=None,
verbose=True,
epoch=750,
pop_size=100,
wep_minmax=(0.2, 1.0),
**kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.wep_minmax = wep_minmax # Wormhole Existence Probability (min and max in Eq.(3.3) paper
def __init__(self,
obj_func=None,
lb=None,
ub=None,
verbose=True,
epoch=750,
pop_size=100,
fp=(0.65, 0.9),
**kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.fp = fp # (fp_min, fp_max): Female Percent
def __init__(self,
obj_func=None,
lb=None,
ub=None,
verbose=True,
epoch=750,
pop_size=100,
pp=0.1,
**kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size # SailFish pop size
self.pp = pp # the rate between SailFish and Sardines (N_sf = N_s * pp) = 0.25, 0.2, 0.1
def __init__(self,
objective_func=None,
problem_size=50,
domain_range=(-1, 1),
log=True,
epoch=750,
pop_size=100):
Root.__init__(self, objective_func, problem_size, domain_range, log)
self.epoch = epoch
self.pop_size = pop_size
self.ST = 0.8 # ST in [0.5, 1.0]
self.PD = 0.2 # number of producers
self.SD = 0.1 # number of sparrows who perceive the danger
def __init__(self,
obj_func=None,
lb=None,
ub=None,
verbose=True,
epoch=750,
pop_size=100,
S=2,
**kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.S = S # somersault factor that decides the somersault range of manta rays
def __init__(self,
obj_func=None,
lb=None,
ub=None,
problem_size=50,
batch_size=10,
verbose=True,
epoch=750,
pop_size=100):
Root.__init__(self, obj_func, lb, ub, problem_size, batch_size,
verbose)
self.epoch = epoch
self.pop_size = pop_size
def __init__(self,
obj_func=None,
lb=None,
ub=None,
verbose=True,
epoch=750,
pop_size=100,
c_minmax=(0.00004, 1),
**kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.c_minmax = c_minmax
def __init__(self,
obj_func=None,
lb=None,
ub=None,
verbose=True,
epoch=750,
pop_size=100,
**kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.n1 = int(ceil(sqrt(self.pop_size))) # n best position
self.n2 = self.n1 + int(
(self.pop_size - self.n1) / 2) # 50% for both 2 group left
def __init__(self, obj_func=None, lb=None, ub=None, verbose=True, epoch=750, pop_size=100,
m=5, p1=0.2, p2=0.8, p3=0.4, p4=0.5, k=20, miu=0, xichma=1, **kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size # n: pop_size, m: clusters
self.m = m
self.p1 = p1
self.p2 = p2
self.p3 = p3
self.p4 = p4
self.k = k
self.miu = miu
self.xichma = xichma
self.m_solution = int(self.pop_size / self.m)
def __init__(self,
objective_func=None,
problem_size=50,
domain_range=(-1, 1),
log=True,
epoch=750,
pop_size=100,
r=0.95,
pf=(0, 10)):
Root.__init__(self, objective_func, problem_size, domain_range, log)
self.epoch = epoch
self.pop_size = pop_size
self.r = r # (r_min, r_max): pulse rate / emission rate
self.pf = pf # (pf_min, pf_max): pulse frequency
def __init__(self,
objective_func=None,
problem_size=50,
domain_range=(-1, 1),
log=True,
epoch=750,
pop_size=100):
Root.__init__(self, objective_func, problem_size, domain_range, log)
self.epoch = epoch
self.pop_size = pop_size
self.r1 = 2.35
self.n1 = int(ceil(sqrt(self.pop_size))) # n best solution
self.n2 = int(
(self.pop_size - self.n1) / 2) # 50% for both 2 group left
def __init__(self,
objective_func=None,
problem_size=50,
domain_range=(-1, 1),
log=True,
epoch=750,
pop_size=100,
brr=0.06,
max_age=150):
Root.__init__(self, objective_func, problem_size, domain_range, log)
self.epoch = epoch
self.pop_size = pop_size
self.brr = brr
self.max_age = max_age
