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