def __init__(self,
obj_func=None,
lb=None,
ub=None,
verbose=True,
epoch=750,
pop_size=100,
site_ratio=(0.5, 0.4),
site_bee_ratio=(0.1, 2),
recruited_bee_ratio=0.1,
dance_radius=0.1,
dance_radius_damp=0.99,
**kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs=kwargs)
self.epoch = epoch
self.pop_size = pop_size
# (Scout Bee Count or Population Size, Selected Sites Count)
self.site_ratio = site_ratio # (selected_site_ratio, elite_site_ratio)
# Scout Bee Count, Selected Sites Bee Count
self.site_bee_ratio = site_bee_ratio # (selected_site_bee_ratio, elite_site_bee_ratio)
self.recruited_bee_ratio = recruited_bee_ratio
self.dance_radius = dance_radius # Bees Dance Radius
self.dance_radius_damp = dance_radius_damp # Bees Dance Radius Damp Rate
def __init__(self,
root_paras=None,
epoch=750,
pop_size=100,
mixture_ratio=0.15,
smp=20,
spc=False,
cdc=0.8,
srd=0.15,
c1=0.4,
w_minmax=(0.4, 0.9),
selected_strategy=0):
"""
# mixture_ratio - joining seeking mode with tracing mode
# smp - seeking memory pool, 10 clones (lon cang tot, nhung ton time hon)
# spc - self-position considering
# cdc - counts of dimension to change (lon cang tot)
# srd - seeking range of the selected dimension (nho thi tot nhung search lau hon)
# w_minmax - same in PSO
# c1 - same in PSO
# selected_strategy : 0: best fitness, 1: tournament, 2: roulette wheel, 3: random (decrease by quality)
"""
Root.__init__(self, root_paras)
self.epoch = epoch
self.pop_size = pop_size
self.mixture_ratio = mixture_ratio
self.smp = smp
self.spc = spc
self.cdc = cdc
self.srd = srd
self.c1 = c1 # Still using c1 and r1 but not c2, r2
self.w_min = w_minmax[0]
self.w_max = w_minmax[1]
self.selected_strategy = selected_strategy
def __init__(self,
objective_func=None,
problem_size=50,
domain_range=(-1, 1),
log=True,
epoch=750,
pop_size=100,
Ci=(0.1, 0.001),
Ped=0.25,
Ns=4,
N_minmax=(2, 40)):
Root.__init__(self, objective_func, problem_size, domain_range, log)
self.epoch = epoch
self.pop_size = pop_size
self.step_size = Ci # C_s (start), C_e (end) -=> step size # step size in BFO
self.p_eliminate = Ped # Probability eliminate
self.swim_length = Ns # swim_length
# (Dead threshold value, split threshold value) -> N_adapt, N_split
self.N_adapt = N_minmax[0] # Dead threshold value
self.N_split = N_minmax[1] # split threshold value
self.C_s = self.step_size[0] * (self.domain_range[1] -
self.domain_range[0])
self.C_e = self.step_size[1] * (self.domain_range[1] -
self.domain_range[0])
def __init__(self, objective_func=None, problem_size=50, domain_range=(-1, 1), log=True, epoch=750, pop_size=100, n_best=30, alpha=0.7):
Root.__init__(self, objective_func, problem_size, domain_range, log)
self.epoch = epoch
self.pop_size = pop_size
self.alpha = alpha
self.n_best = n_best
self.means, self.stdevs = None, None
def __init__(self,
obj_func=None,
lb=None,
ub=None,
problem_size=50,
batch_size=10,
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):
Root.__init__(self, obj_func, lb, ub, problem_size, batch_size,
verbose)
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,
obj_func=None,
lb=None,
ub=None,
verbose=True,
epoch=750,
pop_size=100,
n_clusters=2,
**kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.n_clusters = n_clusters
self.n_elements = int(self.pop_size / self.n_clusters)
self.T0 = 298.15
self.K = 1.0
self.beta = 1.0
self.alpha = 1
self.epxilon = 0.05
self.l1 = 5E-2
self.l2 = 100.0
self.l3 = 1E-2
self.H_j = self.l1 * uniform()
self.P_ij = self.l2 * uniform()
self.C_j = self.l3 * uniform()
def __init__(self,
objective_func=None,
problem_size=50,
domain_range=(-1, 1),
log=True,
pop_size=50,
Ci=0.01,
Ped=0.25,
Ns=4,
Ned=5,
Nre=50,
Nc=10,
attract_repesls=(0.1, 0.2, 0.1, 10)):
Root.__init__(self, objective_func, problem_size, domain_range, log)
self.pop_size = pop_size
self.step_size = Ci # p_eliminate
self.p_eliminate = Ped # p_eliminate
self.swim_length = Ns # swim_length
self.elim_disp_steps = Ned # elim_disp_steps
self.repro_steps = Nre # reproduction_steps
self.chem_steps = Nc # chem_steps
self.d_attr = attract_repesls[0]
self.w_attr = attract_repesls[1]
self.h_rep = attract_repesls[2]
self.w_rep = attract_repesls[3]
def __init__(self,
obj_func=None,
lb=None,
ub=None,
verbose=True,
epoch=750,
pop_size=100,
Ci=(0.1, 0.001),
Ped=0.01,
Ns=4,
N_minmax=(2, 40),
**kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs=kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.step_size = Ci # C_s (start), C_e (end) -=> step size # step size in BFO
self.p_eliminate = Ped # Probability eliminate
self.swim_length = Ns # swim_length
# (Dead threshold value, split threshold value) -> N_adapt, N_split
self.N_adapt = N_minmax[0] # Dead threshold value
self.N_split = N_minmax[1] # split threshold value
self.C_s = self.step_size[0] * (self.ub - self.lb)
self.C_e = self.step_size[1] * (self.ub - self.lb)
def __init__(self, obj_func=None, lb=None, ub=None, verbose=True, epoch=750, pop_size=100, bp=0.75, **kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.size_b = int(self.pop_size / 5)
self.size_w = self.pop_size - self.size_b
self.bp = bp # breeding probability (0.75)
def __init__(self, objective_func=None, problem_size=50, domain_range=(-1, 1), log=True, epoch=750, pop_size=100, energy=0.3, delta=2, ap=0.5):
Root.__init__(self, objective_func, problem_size, domain_range, log)
self.epoch = epoch
self.pop_size = pop_size
self.energy = energy
self.delta = delta
self.ap = ap # the loss of energy, e = 0.3, the shear force, delta = 2 and the adaptation probability constant, Ap = 0.5.
def __init__(self, root_paras=None, epoch=750, pop_size=100, bp=0.75):
Root.__init__(self, root_paras)
self.epoch = epoch
self.pop_size = pop_size
self.size_b = int(self.pop_size / 5)
self.size_w = self.pop_size - self.size_b
self.bp = bp # breeding probability (0.75)
def __init__(self,
obj_func=None,
lb=None,
ub=None,
verbose=True,
epoch=750,
pop_size=100,
n_s=3,
n_e=3,
eta=0.15,
local_move=(0.9, 0.3),
global_move=(0.2, 0.8),
p_hi=0.9,
delta=(2.0, 2.0),
**kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.n_s = n_s # default = 3, number of exploration step
self.n_e = n_e # default = 3, number of exploitation step
self.eta = eta # default = 0.15, learning rate
self.local_move = local_move # default = (0.9, 0.3), (alpha 1, beta 1) - control local movement
self.global_move = global_move # default = (0.2, 0.8), (alpha 2, beta 2) - control global movement
self.p_hi = p_hi # default = 0.9, the probability of wildebeest move to another position based on herd instinct
self.delta = delta # default = (2.0, 2.0) , (delta_w, delta_c) - (dist to worst, dist to best)
def __init__(self,
obj_func=None,
lb=None,
ub=None,
verbose=True,
epoch=750,
pop_size=100,
empire_count=5,
selection_pressure=1,
assimilation_coeff=1.5,
revolution_prob=0.05,
revolution_rate=0.1,
revolution_step_size=0.1,
revolution_step_size_damp=0.99,
zeta=0.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.empire_count = empire_count # Number of Empires (also Imperialists)
self.selection_pressure = selection_pressure # Selection Pressure
self.assimilation_coeff = assimilation_coeff # Assimilation Coefficient (beta in the paper)
self.revolution_prob = revolution_prob # Revolution Probability
self.revolution_rate = revolution_rate # Revolution Rate (mu)
self.revolution_step_size = revolution_step_size # Revolution Step Size (sigma)
self.revolution_step_size_damp = revolution_step_size_damp # Revolution Step Size Damp Rate
self.zeta = zeta # Colonies Coefficient in Total Objective Value of Empires
def __init__(self, obj_func=None, lb=None, ub=None, verbose=True, epoch=750, pop_size=100, n_best=30, alpha=0.7, **kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.alpha = alpha
self.n_best = n_best
self.means, self.stdevs = None, None
def __init__(self,
objective_func=None,
problem_size=50,
domain_range=(-1, 1),
log=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):
Root.__init__(self, objective_func, problem_size, domain_range, log)
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,
obj_func=None,
lb=None,
ub=None,
problem_size=50,
batch_size=10,
verbose=True,
epoch=750,
pop_size=100,
couple_bees=(16, 4),
patch_variables=(5.0, 0.985),
sites=(3, 1)):
Root.__init__(self, obj_func, lb, ub, problem_size, batch_size,
verbose)
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,
problem_size=50,
batch_size=10,
verbose=True,
epoch=750,
pop_size=100,
p_c=0.9,
p_m=0.01,
n_best=2,
alpha=0.98,
beta=1,
gamma=0.9):
Root.__init__(self, obj_func, lb, ub, problem_size, batch_size,
verbose)
self.epoch = epoch
self.pop_size = pop_size
self.p_c = p_c # default = 0.9, crossover probability
self.p_m = p_m # default = 0.01 initial mutation probability
self.n_best = n_best # default = 2, how many of the best earthworm to keep from one generation to the next
self.alpha = alpha # default = 0.98, similarity factor
self.beta = beta # default = 1, the initial proportional factor
self.gamma = gamma # default = 0.9, a constant that is similar to cooling factor of a cooling schedule in the simulated annealing.
def __init__(self,
obj_func=None,
lb=None,
ub=None,
verbose=True,
epoch=750,
pop_size=100,
Ci=0.01,
Ped=0.25,
Ns=4,
Ned=5,
Nre=50,
Nc=10,
attract_repesls=(0.1, 0.2, 0.1, 10),
**kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs=kwargs)
self.pop_size = pop_size
self.step_size = Ci # p_eliminate
self.p_eliminate = Ped # p_eliminate
self.swim_length = Ns # swim_length
self.elim_disp_steps = Ned # elim_disp_steps
self.repro_steps = Nre # reproduction_steps
self.chem_steps = Nc # chem_steps
self.d_attr = attract_repesls[0]
self.w_attr = attract_repesls[1]
self.h_rep = attract_repesls[2]
self.w_rep = attract_repesls[3]
def __init__(self, obj_func=None, lb=None, ub=None, verbose=True, epoch=750, pop_size=100, bm_teams=5, **kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.bm_teams = bm_teams # Number of blue monkey teams (5, 10, 20, ...)
self.bm_size = int(self.pop_size/2) # Number of all blue monkey
self.bm_numbers = int(self.bm_size / self.bm_teams) # Number of blue monkey in each team
def __init__(self, obj_func=None, lb=None, ub=None, problem_size=50, batch_size=10, verbose=True,
epoch=750, pop_size=100, cr=0.7, f=1.25):
Root.__init__(self, obj_func, lb, ub, problem_size, batch_size, verbose)
self.epoch = epoch
self.pop_size = pop_size
self.cr = cr # Same as DE algorithm # default: 0.7
self.f = f # Same as DE algorithm # default: 1.25
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
self.n_best = int(sqrt(self.pop_size)) # n nest position in CE
self.alpha = 0.94 # alpha in CE
self.epoch_ce = int(sqrt(epoch)) # Epoch in CE
self.means, self.stdevs = None, None
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=30, alpha=0.7):
Root.__init__(self, obj_func, lb, ub, problem_size, batch_size, verbose)
self.epoch = epoch
self.pop_size = pop_size
self.alpha = alpha
self.n_best = n_best
self.means, self.stdevs = None, None
def __init__(self, obj_func=None, lb=None, ub=None, verbose=True, epoch=750, pop_size=100, A=0.8, r=0.95, pf=(0, 10), **kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs=kwargs)
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
self.A = A # (A_min, A_max): loudness
self.r = r # (r_min, r_max): pulse rate / emission rate
def __init__(self, obj_func=None, lb=None, ub=None, verbose=True, epoch=750, pop_size=100,
r_a=1, p_c=0.7, p_m=0.1, **kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.r_a = r_a # the rate of vibration attenuation when propagating over the spider web.
self.p_c = p_c # controls the probability of the spiders changing their dimension mask in the random walk step.
self.p_m = p_m # the probability of each value in a dimension mask to be one
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.V = 1
self.a1 = 2
self.a2 = 1
self.GP = 0.5
def __init__(self, obj_func=None, lb=None, ub=None, verbose=True, epoch=750, pop_size=100, alpha=0.7, **kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.n_best = int(sqrt(self.pop_size)) # n nest position in CE
self.alpha = alpha # alpha in CE
self.epoch_ce = int(sqrt(epoch)) # Epoch in CE
self.means, self.stdevs = None, None
def __init__(self, obj_func=None, lb=None, ub=None, verbose=True, epoch=750, pop_size=100,
c=0.01, p=0.8, alpha=(0.1, 0.3), **kwargs):
Root.__init__(self, obj_func, lb, ub, verbose, kwargs)
self.epoch = epoch
self.pop_size = pop_size
self.c = c # 0.01, is the sensory modality
self.p = p # 0.8, Search for food and mating partner by butterflies can occur at both local and global scale
self.alpha = alpha # 0.1-0.3 (0 -> finite), the power exponent dependent on modality
def __init__(self, root_paras=None, epoch=750, pop_size=100, c1=1.2, c2=1.2, w_min=0.4, w_max=0.9):
Root.__init__(self, root_paras)
self.epoch = epoch
self.pop_size = pop_size
self.c1 = c1 # [0-2] -> [(1.2, 1.2), (0.8, 2.0), (1.6, 0.6)] Local and global coefficient
self.c2 = c2
self.w_min = w_min # [0-1] -> [0.4-0.9] Weight of bird
self.w_max = w_max
def __init__(self, obj_func=None, lb=None, ub=None, problem_size=50, batch_size=10, verbose=True,
epoch=750, pop_size=100, seeds=(2, 10), exponent=2, sigma=(0.5, 0.001)):
Root.__init__(self, obj_func, lb, ub, problem_size, batch_size, verbose)
self.epoch = epoch
self.pop_size = pop_size
self.seeds = seeds # (Min, Max) Number of Seeds
self.exponent = exponent # Variance Reduction Exponent
self.sigma = sigma # (Initial, Final) Value of Standard Deviation
def __init__(self, obj_func=None, lb=None, ub=None, problem_size=50, batch_size=10, verbose=True,
epoch=750, pop_size=100, ST=0.8, PD=0.2, SD=0.1):
Root.__init__(self, obj_func, lb, ub, problem_size, batch_size, verbose)
self.epoch = epoch
self.pop_size = pop_size
self.ST = ST # ST in [0.5, 1.0]
self.PD = PD # number of producers
self.SD = SD # number of sparrows who perceive the danger
