def update(self, space: Space) -> None: """Wraps Boolean Particle Swarm Optimization over all agents and variables. Args: space: Space containing agents and update-related information. """ # Iterates through all agents for i, agent in enumerate(space.agents): # Defines random binary numbers r1 = r.generate_binary_random_number(agent.position.shape) r2 = r.generate_binary_random_number(agent.position.shape) # Calculates the local and global partials local_partial = np.logical_and( self.c1, np.logical_xor( r1, np.logical_xor(self.local_position[i], agent.position)), ) global_partial = np.logical_and( self.c2, np.logical_xor( r2, np.logical_xor(space.best_agent.position, agent.position)), ) # Updates current agent velocities (eq. 1) self.velocity[i] = np.logical_or(local_partial, global_partial) # Updates current agent positions (eq. 2) agent.position = np.logical_xor(agent.position, self.velocity[i])
def _somersault_foraging(self, position, best_position): """Performs the somersault foraging procedure. Args: position (np.array): Agent's current position. best_position (np.array): Global best position. Returns: A new somersault foraging. """ # Generates binary random numbers r1 = r.generate_binary_random_number(best_position.shape) r2 = r.generate_binary_random_number(best_position.shape) # Calculates the somersault foraging somersault_foraging = np.logical_or( position, np.logical_and( self.S, np.logical_xor(np.logical_xor(r1, best_position), np.logical_xor(r2, position)))) return somersault_foraging
def _chain_foraging(self, agents, best_position, i): """Performs the chain foraging procedure. Args: agents (list): List of agents. best_position (np.array): Global best position. i (int): Current agent's index. Returns: A new chain foraging. """ # Generates binary random numbers r1 = r.generate_binary_random_number(best_position.shape) alpha = r.generate_binary_random_number(best_position.shape) # Checks if the index is equal to zero if i == 0: # Calculates the chain foraging partial_one = np.logical_and(r1, np.logical_xor(best_position, agents[i].position)) partial_two = np.logical_and(alpha, np.logical_xor(best_position, agents[i].position)) chain_foraging = np.logical_or(agents[i].position, np.logical_or(partial_one, partial_two)) # If index is different than zero else: # Calculates the chain foraging partial_one = np.logical_and(r1, np.logical_xor(agents[i - 1].position, agents[i].position)) partial_two = np.logical_and(alpha, np.logical_xor(best_position, agents[i].position)) chain_foraging = np.logical_or(agents[i].position, np.logical_or(partial_one, partial_two)) return chain_foraging
def _update_velocity(self, position, best_position, local_position): """Updates a particle velocity. Args: position (np.array): Agent's current position. best_position (np.array): Global best position. local_position (np.array): Agent's local best position. Returns: A new velocity based on boolean bPSO's paper velocity update equation. """ # Defining a random binary number r1 = r.generate_binary_random_number(position.shape) # Defining another random binary number r2 = r.generate_binary_random_number(position.shape) # Calculating the local partial local_partial = np.logical_and( self.c1, np.logical_xor(r1, np.logical_xor(local_position, position))) # Calculating the global partial global_partial = np.logical_and( self.c2, np.logical_xor(r2, np.logical_xor(best_position, position))) # Updating new velocity new_velocity = np.logical_or(local_partial, global_partial) return new_velocity
def _cyclone_foraging(self, agents, best_position, i, iteration, n_iterations): """Performs the cyclone foraging procedure. Args: agents (list): List of agents. best_position (np.array): Global best position. i (int): Current agent's index. iteration (int): Current iteration. n_iterations (int): Maximum number of iterations. Returns: A new cyclone foraging. """ # Generates binary random numbers r1 = r.generate_binary_random_number(best_position.shape) beta = r.generate_binary_random_number(best_position.shape) # Generates a uniform random number u = r.generate_uniform_random_number() # Checks if current iteration proportion is smaller than random generated number if iteration / n_iterations < u: # Generates binary random positions r_position = r.generate_binary_random_number(size=(agents[i].n_variables, agents[i].n_dimensions)) # Checks if the index is equal to zero if i == 0: # Calculates the cyclone foraging partial_one = np.logical_or(r1, np.logical_xor(r_position, agents[i].position)) partial_two = np.logical_or(beta, np.logical_xor(r_position, agents[i].position)) cyclone_foraging = np.logical_and(r_position, np.logical_and(partial_one, partial_two)) # If index is different than zero else: # Calculates the cyclone foraging partial_one = np.logical_or(r1, np.logical_xor(agents[i - 1].position, agents[i].position)) partial_two = np.logical_or(beta, np.logical_xor(r_position, agents[i].position)) cyclone_foraging = np.logical_and(r_position, np.logical_and(partial_one, partial_two)) # If current iteration proportion is bigger than random generated number else: # Checks if the index is equal to zero if i == 0: # Calculates the cyclone foraging partial_one = np.logical_or(r1, np.logical_xor(best_position, agents[i].position)) partial_two = np.logical_or(beta, np.logical_xor(best_position, agents[i].position)) cyclone_foraging = np.logical_and(best_position, np.logical_and(partial_one, partial_two)) # If index is different than zero else: # Calculates the cyclone foraging partial_one = np.logical_or(r1, np.logical_xor(agents[i - 1].position, agents[i].position)) partial_two = np.logical_or(beta, np.logical_xor(best_position, agents[i].position)) cyclone_foraging = np.logical_and(best_position, np.logical_and(partial_one, partial_two)) return cyclone_foraging
def test_bpso_hyperparams(): hyperparams = { 'c1': r.generate_binary_random_number(size=(1, 1)), 'c2': r.generate_binary_random_number(size=(1, 1)) } new_bpso = bpso.BPSO(hyperparams=hyperparams) assert new_bpso.c1 == 0 or new_bpso.c1 == 1 assert new_bpso.c2 == 0 or new_bpso.c2 == 1
def test_bpso_params(): params = { "c1": r.generate_binary_random_number(size=(1, 1)), "c2": r.generate_binary_random_number(size=(1, 1)), } new_bpso = bpso.BPSO(params=params) assert new_bpso.c1 == 0 or new_bpso.c1 == 1 assert new_bpso.c2 == 0 or new_bpso.c2 == 1
def test_bpso_hyperparams_setter(): new_bpso = bpso.BPSO() try: new_bpso.c1 = 'a' except: new_bpso.c1 = r.generate_binary_random_number(size=(1, 1)) assert new_bpso.c1 == 0 or new_bpso.c1 == 1 try: new_bpso.c2 = 'b' except: new_bpso.c2 = r.generate_binary_random_number(size=(1, 1)) assert new_bpso.c2 == 0 or new_bpso.c2 == 1
def fill_with_binary(self) -> None: """Fills the agent's decision variables with a binary distribution.""" # Iterates through all the decision variables for j in range(self.n_variables): # Fills the array based on a binary distribution self.position[j] = r.generate_binary_random_number(self.n_dimensions)
def test_bmrfo_params(): params = { 'S': r.generate_binary_random_number(size=(1, 1)) } new_bmrfo = bmrfo.BMRFO(params=params) assert new_bmrfo.S == 0 or new_bmrfo.S == 1
def test_bmrfo_params_setter(): new_bmrfo = bmrfo.BMRFO() try: new_bmrfo.S = "a" except: new_bmrfo.S = r.generate_binary_random_number(size=(1, 1)) assert new_bmrfo.S == 0 or new_bmrfo.S == 1
def _initialize_agents(self): """Initialize agents' position array with boolean random numbers. """ logger.debug('Running private method: initialize_agents().') # Iterates through all agents for agent in self.agents: # Iterates through all decision variables for j, (lb, ub) in enumerate(zip(self.lb, self.ub)): # For each decision variable, we generate binary random numbers agent.position[j] = r.generate_binary_random_number(size=agent.n_dimensions) # Applies the lower bound to the agent's lower bound agent.lb[j] = lb # And also the upper bound agent.ub[j] = ub logger.debug('Agents initialized.')
def _nomad_attack( self, nomads: List[Lion], prides: List[List[Lion]]) -> Tuple[List[Lion], List[List[Lion]]]: """Performs the nomad's attacking procedure (s. 2.2.6). Args: nomads: Nomad lions. prides: List of prides holding their corresponding lions. Returns: (Tuple[List[Lion], List[List[Lion]]]): Both updated nomad and pride lions. """ # Iterates through all nomads for agent in nomads: # If current agent is female if agent.female: # Generates a binary array of prides to be attacked attack_prides = r.generate_binary_random_number(self.P) # Iterates through every pride for i, pride in enumerate(prides): # If pride is supposed to be attacked if attack_prides[i]: # Gathers all the males in the pride males = [agent for agent in pride if not agent.female] # If there is at least a male if len(males) > 0: # If current nomad agent is better than male in pride if agent.fit < males[0].fit: # Swaps them agent, males[0] = copy.deepcopy( males[0]), copy.deepcopy(agent) return nomads, prides
# Predicts new data preds = opf.predict(X_val_selected) # Calculates accuracy acc = g.opf_accuracy(Y_val, preds) return 1 - acc # Number of agents and decision variables n_agents = 5 n_variables = 64 # Parameters for the optimizer params = { 'c1': r.generate_binary_random_number(size=(n_variables, 1)), 'c2': r.generate_binary_random_number(size=(n_variables, 1)) } # Creates the space, optimizer and function space = BooleanSpace(n_agents, n_variables) optimizer = BPSO() function = Function(supervised_opf_feature_selection) # Bundles every piece into Opytimizer class opt = Opytimizer(space, optimizer, function) # Runs the optimization task opt.start(n_iterations=3)
import opytimizer.math.random as r # Generating a binary random number array b = r.generate_binary_random_number(size=10) print(b) # Generating a integer random number array i = r.generate_integer_random_number(low=0, high=1, size=1) print(i) # Generating a random uniform number array u = r.generate_uniform_random_number(low=0.0, high=1.0, size=1) print(u) # Generating a random gaussian number array g = r.generate_gaussian_random_number(mean=0.5, variance=1.0, size=10) print(g)
def test_generate_binary_random_number(): binary_array = random.generate_binary_random_number(5) assert binary_array.shape == (5, )
# Predicts new data preds = opf.predict(X_val_selected) # Calculates accuracy acc = g.opf_accuracy(Y_val, preds) return 1 - acc # Number of agents and decision variables n_agents = 5 n_variables = 64 # Parameters for the optimizer params = { "c1": r.generate_binary_random_number(size=(n_variables, 1)), "c2": r.generate_binary_random_number(size=(n_variables, 1)), } # Creates the space, optimizer and function space = BooleanSpace(n_agents, n_variables) optimizer = BPSO() function = Function(supervised_opf_feature_selection) # Bundles every piece into Opytimizer class opt = Opytimizer(space, optimizer, function) # Runs the optimization task opt.start(n_iterations=3)