2018 Dr. Walter F. de Azevedo Jr. azevedolab.net
|
|
|
- Gilberto Conceição
- 5 Há anos
- Visualizações:
Transcrição
1 2018 Dr. Walter F. de Azevedo Jr. azevedolab.net 1
2 Algoritmo Genético Vimos anteriormente um algoritmo genético simples para resolução de um problema de maximização. O algoritmo visa encontrar o maior número entre 0 e 4095 que maximiza a função x 2. No próximo slide temos o fluxograma do programa sg01.py. String binária Decimal
3 Turtle sga01.py Gera uma população aleatória de strings binárias (self.gen_bin_strings()) Ordena aleatoriamente os melhores pais (self.shuffle()) Converte cada string binária em um número decimal (self.bin2dec_array()) Calcula a função ajuste para cada indivíduo (self.fitness_func()) Seleciona parte da população para seguir (self.sort_popupation()) Seleciona pares de pais seguindo uma ordem aleatória. Faz cruzamento e atualiza população (self.update_pop()) Mutação dos descendentes (operador mutação) Critério de parada satisfeito? Sim Não Retorna os resultados 3
4 Turtle sga01.py Veremos hoje a implementação em Python do algoritmo 1 relatado por Coley Usaremos o paradigma de programação orientada a objeto. Abaixo temos a função main(). Os atributos são previamente definidos e indicados em vermelho abaixo. Após a definição dos parâmetros, criamos um objeto da classe Simple_GA01() com a linha p1 = Simple_GA01(pop_size,max_iter,p_cross,len_str,p_mut,2). def main(): # Set up initial values for GA pop_size = 8 # Population size max_iter = 60 # Number of iterations p_cross = 0.8 # Probability of cross-over len_str = 12 # Length of strings p_mut = 0.02 # Probability of mutation_coley_algo_01 # Instantiating an object of the Simple_GA01() class and assigns it to p1 p1 = Simple_GA01(pop_size,max_iter,p_cross,len_str,p_mut,2) # Invoking the plot_ga_evolution() method p1.coley_algo_01() # Invoking the coley_algo_01() method p1.plot_ga_evolution("generation","fitness function, f","maximum value of f","mean value of f","ga01.png") main() 4
5 Turtle sga01.py Após a criação do objeto, o método com a implementação do algoritmo 1 de Coley é invocado com a linha de código p1.coley_algo_01(). Por último, invocamos o método plot_ga_evolution() para gerarmos o gráfico com a evolução da média e do valor máximo da função ajuste para cada geração. def main(): # Set up initial values for GA pop_size = 8 # Population size max_iter = 60 # Number of iterations p_cross = 0.8 # Probability of cross-over len_str = 12 # Length of strings p_mut = 0.02 # Probability of mutation_coley_algo_01 # Instantiating an object of the Simple_GA01() class and assigns it to p1 p1 = Simple_GA01(pop_size,max_iter,p_cross,len_str,p_mut,2) # Invoking the plot_ga_evolution() method p1.coley_algo_01() # Invoking the coley_algo_01() method p1.plot_ga_evolution("generation","fitness function, f","maximum value of f","mean value of f","ga01.png") main() 5
6 Turtle sga01.py Abaixo temos o código inicial da classe Simple_GA01(), nele vemos o método construtor onde definimos os atributos para tamanho da população (self.pop_size), número máximo de iterações (self.max_iter), probabilidade de cross-over (self.p_cross), tamanho de cada string binária (self.len_str), probabilidade de mutação (self.p_mut) e divisor que indica que parte da população é selecionada (self.div_in). No último atributo (self.div_in) o valor 2 indica que pegamos a metade da população. Também definimos como atributos arrays para os valores máximo (self.max_array) e médio (self.mean_array) da função ajuste em cada geração. class Simple_GA01(object): """A class to implement a very simple GA""" # Constructor method def init (self,pop_size,max_iter,p_cross,len_str,p_mut,div_in): # Import library import numpy as np # Define atributes self.pop_size = pop_size # Population size self.max_iter = max_iter # Number of iterations self.p_cross = p_cross # Probability of crossover self.len_str = len_str # String length self.p_mut = p_mut # Probability of mutation_coley_algo_01 self.div_in = div_in # Set up arrays of zeros self.max_array = np.zeros(self.max_iter) self.mean_array = np.zeros(self.max_iter) 6
7 Turtle sga01.py Em seguida temos o método str () que define uma string com a descrição da classe. # str method def str (self): info = "Simple_GA01 class\n" info += "Class to generate a model based on a very simple genetic algorithm.\n""" info += "It is a OOP implementation of algorithm 1 described by Coley, 1999.\n" info += "Reference:\n" info += " Coley, David A. An Introduction to Genetic Algorithms for Scientists and Engineers.\n" info += "Singapore: World Scientific Publishing Co. Pte. Ltd., pp." return info 7
8 Turtle sga01.py O principal método da classe Simple_GA01() é o coley_algo_01(self), mostrado abaixo. # Definition of coley_algo_01 method def coley_algo_01(self): """Method to implement algorithm 1 from Coley 1999""" # Call gen_bin_strings() self.gen_bin_strings() self.show_pop("\ninitial Population",self.current_pop) # Looping through the number of iteractions for i in range(self.max_iter): # Call selection_coley_algo_01() self.selection_coley_algo_01() # Call cross_over_coley_algo_01() method self.cross_over_coley_algo_01() # Call mutation_coley_algo_01 method self.mutation_coley_algo_01() self.show_pop("\npopulation for generation "+str(i),self.current_pop) # Call bin2dec_array() d = self.bin2dec_array(self.current_pop) # Call fitness_func() d_2 = self.fitness_func(d) # Call get_max() self.max_array[i] = self.get_max(d_2) # Call get_mean() self.mean_array[i] = self.get_mean(d_2) self.show_pop("\nfinal Population",self.current_pop) 8
9 Turtle sga01.py Inicialmente geramos uma população aleatória de strings binárias com o método self.gen_bin_strings(). Usamos o self. para invocarmos um método na classe. # Definition of coley_algo_01 method def coley_algo_01(self): """Method to implement algorithm 1 from Coley 1999""" # Call gen_bin_strings() self.gen_bin_strings() self.show_pop("\ninitial Population",self.current_pop) # Looping through the number of iteractions for i in range(self.max_iter): # Call selection_coley_algo_01() self.selection_coley_algo_01() # Call cross_over_coley_algo_01() method self.cross_over_coley_algo_01() # Call mutation_coley_algo_01 method self.mutation_coley_algo_01() self.show_pop("\npopulation for generation "+str(i),self.current_pop) # Call bin2dec_array() d = self.bin2dec_array(self.current_pop) # Call fitness_func() d_2 = self.fitness_func(d) # Call get_max() self.max_array[i] = self.get_max(d_2) # Call get_mean() self.mean_array[i] = self.get_mean(d_2) self.show_pop("\nfinal Population",self.current_pop) 9
10 Turtle sga01.py No próximo slide temos o fluxograma com destaque para o método self.gen_bin_strings(). # Definition of coley_algo_01 method def coley_algo_01(self): """Method to implement algorithm 1 from Coley 1999""" # Call gen_bin_strings() self.gen_bin_strings() self.show_pop("\ninitial Population",self.current_pop) # Looping through the number of iteractions for i in range(self.max_iter): # Call selection_coley_algo_01() self.selection_coley_algo_01() # Call cross_over_coley_algo_01() method self.cross_over_coley_algo_01() # Call mutation_coley_algo_01 method self.mutation_coley_algo_01() self.show_pop("\npopulation for generation "+str(i),self.current_pop) # Call bin2dec_array() d = self.bin2dec_array(self.current_pop) # Call fitness_func() d_2 = self.fitness_func(d) # Call get_max() self.max_array[i] = self.get_max(d_2) # Call get_mean() self.mean_array[i] = self.get_mean(d_2) self.show_pop("\nfinal Population",self.current_pop) 10
11 Turtle sga01.py Gera uma população aleatória de strings binárias (self.gen_bin_strings()) Ordena aleatoriamente os melhores pais (self.shuffle()) Converte cada string binária em um número decimal (self.bin2dec_array()) Calcula a função ajuste para cada indivíduo (self.fitness_func()) Seleciona parte da população para seguir (self.sort_popupation()) Seleciona pares de pais seguindo uma ordem aleatória. Faz cruzamento e atualiza população (self.update_pop()) Mutação dos descendentes (operador mutação) Critério de parada satisfeito? Sim Não Retorna os resultados 11
12 Turtle sga01.py Depois mostramos a população na tela com o método self.show_pop(). # Definition of coley_algo_01 method def coley_algo_01(self): """Method to implement algorithm 1 from Coley 1999""" # Call gen_bin_strings() self.gen_bin_strings() self.show_pop("\ninitial Population",self.current_pop) # Looping through the number of iteractions for i in range(self.max_iter): # Call selection_coley_algo_01() self.selection_coley_algo_01() # Call cross_over_coley_algo_01() method self.cross_over_coley_algo_01() # Call mutation_coley_algo_01 method self.mutation_coley_algo_01() self.show_pop("\npopulation for generation "+str(i),self.current_pop) # Call bin2dec_array() d = self.bin2dec_array(self.current_pop) # Call fitness_func() d_2 = self.fitness_func(d) # Call get_max() self.max_array[i] = self.get_max(d_2) # Call get_mean() self.mean_array[i] = self.get_mean(d_2) self.show_pop("\nfinal Population",self.current_pop) 12
13 Turtle sga01.py Em seguida temos o loop for que gera a sequência de operadores seleção, cross-over e mutação. O loop se repete o número de iterações definido no atributo self.max_iter. # Definition of coley_algo_01 method def coley_algo_01(self): """Method to implement algorithm 1 from Coley 1999""" # Call gen_bin_strings() self.gen_bin_strings() self.show_pop("\ninitial Population",self.current_pop) # Looping through the number of iteractions for i in range(self.max_iter): # Call selection_coley_algo_01() self.selection_coley_algo_01() # Call cross_over_coley_algo_01() method self.cross_over_coley_algo_01() # Call mutation_coley_algo_01 method self.mutation_coley_algo_01() self.show_pop("\npopulation for generation "+str(i),self.current_pop) # Call bin2dec_array() d = self.bin2dec_array(self.current_pop) # Call fitness_func() d_2 = self.fitness_func(d) # Call get_max() self.max_array[i] = self.get_max(d_2) # Call get_mean() self.mean_array[i] = self.get_mean(d_2) self.show_pop("\nfinal Population",self.current_pop) 13
14 Turtle sga01.py As populações de cada iteração são mostradas na tela. Por último, mostramos a população final. Veremos a seguir os métodos dos operadores genéticos. # Definition of coley_algo_01 method def coley_algo_01(self): """Method to implement algorithm 1 from Coley 1999""" # Call gen_bin_strings() self.gen_bin_strings() self.show_pop("\ninitial Population",self.current_pop) # Looping through the number of iteractions for i in range(self.max_iter): # Call selection_coley_algo_01() self.selection_coley_algo_01() # Call cross_over_coley_algo_01() method self.cross_over_coley_algo_01() # Call mutation_coley_algo_01 method self.mutation_coley_algo_01() self.show_pop("\npopulation for generation "+str(i),self.current_pop) # Call bin2dec_array() d = self.bin2dec_array(self.current_pop) # Call fitness_func() d_2 = self.fitness_func(d) # Call get_max() self.max_array[i] = self.get_max(d_2) # Call get_mean() self.mean_array[i] = self.get_mean(d_2) self.show_pop("\nfinal Population",self.current_pop) 14
15 Turtle sga01.py O método selection_coley_algo_01() inicialmente converte para decimal cada elemento da lista de strings binárias do atributo self.current_pop. Em seguida, é calculada a função ajuste para cada decimal com o método self.fitness_func(). Depois, o método self.sort_popupation(self.current_pop) classifica em ordem decrescente de valores da função ajuste os elementos da população. Assim, o primeiro elemento da lista é aquele de maior valor da função ajuste. Na parte seguinte, varremos a metade da população (self.div_in = 2), que é atribuída à variável new_pop. Por último, atribuímos a nova população (new_pop) ao atributo self.current_pop. No slide seguinte temos o fluxograma do algoritmo 1 com destaque para o operador seleção. # Definition of selection_coley_algo_01() (selection operator) def selection_coley_algo_01(self): """Method for selection operator using aklgorithm 1 from Coley 1999""" # Call bin2dec_array() self.x = self.bin2dec_array(self.current_pop) # Call fitness_func() self.fit = self.fitness_func(self.x) # Sort population self.current_pop = self.sort_popupation(self.current_pop) # Set up empty list for temporary population new_pop = [] # Looping throguh population (get half of the population if self.div_in = 2) for i in range( int( self.pop_size/self.div_in) ): new_pop.append(self.current_pop[i]) # Update self.current_pop with best indivudual self.current_pop = new_pop 15
16 Turtle sga01.py Gera uma população aleatória de strings binárias (self.gen_bin_strings()) Ordena aleatoriamente os melhores pais (self.shuffle()) Converte cada string binária em um número decimal (self.bin2dec_array()) Calcula a função ajuste para cada indivíduo (self.fitness_func()) Seleciona parte da população para seguir (self.sort_popupation()) Seleciona pares de pais seguindo uma ordem aleatória. Faz cruzamento e atualiza população (self.update_pop()) Mutação dos descendentes (operador mutação) Critério de parada satisfeito? Sim Não Retorna os resultados 16
17 Turtle sga01.py No método cross_over_coley_algo_01() temos a implementação do operador crossover como proposto no algoritmo 1 de Coley, Inicialmente a lista com a população corrente é embaralhada com o método self.shuffle(). O último método a ser invocado é o self.update_pop(), que pega pares aleatórios de strings pais e gera um par de strings filhas para cada par de pais. É usada a probabilidade de cross-over. Assim, nem todos os pares de pais geram pares de filhas, para probabilidades de cross-over menores que 1. No slide seguinte temos o fluxograma do algoritmo 1 com destaque para o operador cross-over. # Definition of cross_over def cross_over_coley_algo_01(self): """Method to apply cross-over operator to a population""" # Call shuffle() self.current_pop = self.shuffle(self.current_pop) # Call update_pop self.update_pop(self.current_pop) 17
18 Turtle sga01.py Gera uma população aleatória de strings binárias (self.gen_bin_strings()) Ordena aleatoriamente os melhores pais (self.shuffle()) Converte cada string binária em um número decimal (self.bin2dec_array()) Calcula a função ajuste para cada indivíduo (self.fitness_func()) Seleciona parte da população para seguir (self.sort_popupation()) Seleciona pares de pais seguindo uma ordem aleatória. Faz cruzamento e atualiza população (self.update_pop()) Mutação dos descendentes (operador mutação) Critério de parada satisfeito? Sim Não Retorna os resultados 18
19 Turtle sga01.py No método mutation_coley_algo_01() implementamos o operador mutação. Inicialmente transformamos todas as strings numa única string. # Definition of mutation_coley_algo_01 method def mutation_coley_algo_01(self): """Method to apply mutation_coley_algo_01 operator""" # Import library import random # Determine total total = self.pop_size*self.len_str # Some editing list-> string str_pop = "".join(self.current_pop) str_pop = str_pop.replace("\n","") # Set up empty string str_pop_out = "" # Carry out mutation for i in range(total): if i == int(1/self.p_mut): if str_pop[i] == 1: str_pop_out+="0" else: str_pop_out+="1" else: str_pop_out+=str_pop[i] # Back to string. Set up empty list pop = [] # Loop to recover population after mutation_coley_algo_01 for i in range(self.pop_size): aux = "" for j in range(self.len_str): aux += str_pop_out[i+j] pop.append(aux) self.current_pop = pop 19
20 Turtle sga01.py Em seguida varremos a string única criada e trocamos cada bit na posição determinada a partir da probabilidade de mutação (1 self.p_mut). # Definition of mutation_coley_algo_01 method def mutation_coley_algo_01(self): """Method to apply mutation_coley_algo_01 operator""" # Import library import random # Determine total total = self.pop_size*self.len_str # Some editing list-> string str_pop = "".join(self.current_pop) str_pop = str_pop.replace("\n","") # Set up empty string str_pop_out = "" # Carry out mutation for i in range(total): if i == int(1/self.p_mut): if str_pop[i] == 1: str_pop_out+="0" else: str_pop_out+="1" else: str_pop_out+=str_pop[i] # Back to string. Set up empty list pop = [] # Loop to recover population after mutation_coley_algo_01 for i in range(self.pop_size): aux = "" for j in range(self.len_str): aux += str_pop_out[i+j] pop.append(aux) self.current_pop = pop 20
21 Turtle sga01.py No loop seguinte recuperamos as strings binárias. O operador mutação é o último operador genético do loop for do método coley_algo_01(). # Definition of mutation_coley_algo_01 method def mutation_coley_algo_01(self): """Method to apply mutation_coley_algo_01 operator""" # Import library import random # Determine total total = self.pop_size*self.len_str # Some editing list-> string str_pop = "".join(self.current_pop) str_pop = str_pop.replace("\n","") # Set up empty string str_pop_out = "" # Carry out mutation for i in range(total): if i == int(1/self.p_mut): if str_pop[i] == 1: str_pop_out+="0" else: str_pop_out+="1" else: str_pop_out+=str_pop[i] # Back to string. Set up empty list pop = [] # Loop to recover population after mutation_coley_algo_01 for i in range(self.pop_size): aux = "" for j in range(self.len_str): aux += str_pop_out[i+j] pop.append(aux) self.current_pop = pop 21
22 Turtle sga01.py Abaixo temos resultado da execução do código sga01.py. Final population
23 Turtle sga01.py Modifique os parâmetros para os valores mostrados abaixo. # Set up initial values for GA pop_size = 8 # Population size max_iter = 50 # Number of iterations p_cross = 0.8 # Probability of cross-over len_str = 12 # Length of strings p_mut = 0.17 # Probability of mutation_coley_algo_01 1) No método coley_algo_01() modifique o código de forma que não seja aplicado o operador mutação. Dica: coloque o símbolo de comentário (#) no início da linha: 2) O programa acha a reposta certa 23
24 Turtle tartaruga01.py O programa tartaruga01.py invoca a classe touche() para desenhar uma tartaruga. Este programa desenha uma tartaruga a partir de parâmetros definidos. # Program to import touch class and draw turtles # Import libraries import touche as tart import hexadec as hx import numpy as np # Instantiating an object of the Hexa() class and assigns it to the variable h1 h1 = hx.hexa() # String for hexadecimal # Invoking the gen_hex() method h1.gen_hex() hex = h1.my_hex_string # Assign hexadecimal string to hex # Define parameters for a turtle x = 0 # x coordinate in pixels y = 0 # y coordinate in pixels length = 3.2 # Length for the turtle width = 3.2 # Width for the turtle rotate = np.random.randint(0,8) # Rotation angle 8*45 degrees # Instantiating an object of the Touche() class and assigns it to the variable t1 t1 = tart.touche(x, y, length, width, rotate, "#"+hex) # Invoking the draw() method t1.draw() # Invoking the bye method 24 t1.bye()
25 Turtle tartaruga01.py Inicialmente o programa importa bibliotecas. Além da nossa conhecida NumPy, o programa importa duas bibliotecas. A touche é usada para desenhar uma tartaruga. A hexadec gera uma string com um número hexadecimal. # Program to import touch class and draw turtles # Import libraries import touche as tart import hexadec as hx import numpy as np # Instantiating an object of the Hexa() class and assigns it to the variable h1 h1 = hx.hexa() # String for hexadecimal # Invoking the gen_hex() method h1.gen_hex() hex = h1.my_hex_string # Assign hexadecimal string to hex # Define parameters for a turtle x = 0 # x coordinate in pixels y = 0 # y coordinate in pixels length = 3.2 # Length for the turtle width = 3.2 # Width for the turtle rotate = np.random.randint(0,8) # Rotation angle 8*45 degrees # Instantiating an object of the Touche() class and assigns it to the variable t1 t1 = tart.touche(x, y, length, width, rotate, "#"+hex) # Invoking the draw() method t1.draw() # Invoking the bye method 25 t1.bye()
26 Turtle tartaruga01.py Os códigos das bibliotecas touche e hexadec devem estar no mesmo diretório do código tartaruga01.py. Essas bibliotecas são módulos em Python (touche.py e hexadec.py). # Program to import touch class and draw turtles # Import libraries import touche as tart import hexadec as hx import numpy as np # Instantiating an object of the Hexa() class and assigns it to the variable h1 h1 = hx.hexa() # String for hexadecimal # Invoking the gen_hex() method h1.gen_hex() hex = h1.my_hex_string # Assign hexadecimal string to hex # Define parameters for a turtle x = 0 # x coordinate in pixels y = 0 # y coordinate in pixels length = 3.2 # Length for the turtle width = 3.2 # Width for the turtle rotate = np.random.randint(0,8) # Rotation angle 8*45 degrees # Instantiating an object of the Touche() class and assigns it to the variable t1 t1 = tart.touche(x, y, length, width, rotate, "#"+hex) # Invoking the draw() method t1.draw() # Invoking the bye method 26 t1.bye()
27 Turtle tartaruga01.py Agora criamos um objeto da classe Hexa(). Em seguida invocamos o método gen_hex(). Para termos a string, acessamos o atributo do objeto com a linha hex = h1.my_hex_string. # Program to import touch class and draw turtles # Import libraries import touche as tart import hexadec as hx import numpy as np # Instantiating an object of the Hexa() class and assigns it to the variable h1 h1 = hx.hexa() # String for hexadecimal # Invoking the gen_hex() method h1.gen_hex() hex = h1.my_hex_string # Assign hexadecimal string to hex # Define parameters for a turtle x = 0 # x coordinate in pixels y = 0 # y coordinate in pixels length = 3.2 # Length for the turtle width = 3.2 # Width for the turtle rotate = np.random.randint(0,8) # Rotation angle 8*45 degrees # Instantiating an object of the Touche() class and assigns it to the variable t1 t1 = tart.touche(x, y, length, width, rotate, "#"+hex) # Invoking the draw() method t1.draw() # Invoking the bye method 27 t1.bye()
28 Turtle tartaruga01.py Para desenharmos a tartaruga com o módulo touche precisamos definir os parâmetros para o desenho. Depois criamos um objeto da classe Touche() e invocamos os métodos draw() e bye(), como destacado abaixo. # Program to import touch class and draw turtles # Import libraries import touche as tart import hexadec as hx import numpy as np # Instantiating an object of the Hexa() class and assigns it to the variable h1 h1 = hx.hexa() # String for hexadecimal # Invoking the gen_hex() method h1.gen_hex() hex = h1.my_hex_string # Assign hexadecimal string to hex # Define parameters for a turtle x = 0 # x coordinate in pixels y = 0 # y coordinate in pixels length = 3.2 # Length for the turtle width = 3.2 # Width for the turtle rotate = np.random.randint(0,8) # Rotation angle 8*45 degrees # Instantiating an object of the Touche() class and assigns it to the variable t1 t1 = tart.touche(x, y, length, width, rotate, "#"+hex) # Invoking the draw() method t1.draw() # Invoking the bye method 28 t1.bye()
29 Turtle tartaruga01.py Abaixo temos resultado da execução do código tartaruga01.py. 29
30 Turtle sga02.py Usaremos os módulos touche e hexadec para modificarmos o programa sga01.py, de forma que a evolução da função ajuste seja expressa pelo crescimento das tartarugas em cada iteração do algoritmo genético. O programa usa os atributos de largura (width) e comprimento (length) da classe Touche() para expressar o tamanho que será proporcional ao valor da função ajuste de cada indivíduo da população. O programa mostra os indivíduos da população em cada geração. A posição e as cores serão aleatórias, só o tamanho será proporcional ao valor da função ajuste. O novo programa será chamado sga02.py. 30
31 Turtle sga02.py As modificações no código ficam restritas ao método coley_algo_01(). Como o código do referido método é extenso, mostraremos as modificações por etapas. Inicialmente importamos os módulo touche e hexadec. A biblioteca NumPy também é importada, ela será usada para geração de números aleatórios. # Definition of coley_algo_01 method def coley_algo_01(self): """Method to implement algorithm 1 from Coley 1999""" # Import libraries import numpy as np import touche as tart import hexadec as hx # General parameters for the turtles x_min = -240 # Minimum x coordinate in pixels x_max = 240 # Maximum x coordinate in pixels y_min = -240 # Minimum y coordinate in pixels y_max = 240 # Maximum y coordinate in pixels max_rotate = 8 # Maximum rotation angle 8*45 degrees conv_f = 3e-7 # Conversion factor (fitness function to dimensions) # Call gen_bin_strings() self.gen_bin_strings() self.show_pop("\ninitial Population",self.current_pop) 31
32 Turtle sga02.py Em seguida definimos parâmetros gerais que serão usados para desenhar as tartarugas. Temos quatro parâmetros que definem a faixa onde serão desenhadas as tartarugas (x_min, x_max, y_min, e y_maxi). Os valores estão em pixels. O parâmetro max_rotate define o número máximo de rotações em múltiplos de 45 º. # Definition of coley_algo_01 method def coley_algo_01(self): """Method to implement algorithm 1 from Coley 1999""" # Import libraries import numpy as np import touche as tart import hexadec as hx # General parameters for the turtles x_min = -240 # Minimum x coordinate in pixels x_max = 240 # Maximum x coordinate in pixels y_min = -240 # Minimum y coordinate in pixels y_max = 240 # Maximum y coordinate in pixels max_rotate = 8 # Maximum rotation angle 8*45 degrees conv_f = 3e-7 # Conversion factor (fitness function to dimensions) # Call gen_bin_strings() self.gen_bin_strings() self.show_pop("\ninitial Population",self.current_pop) 32
33 Turtle sga02.py O fator de conversão do valor da função ajuste para as dimensões das tartarugas foi atribuído à variável conv_f. Este valor é razoável para o desenho das tartarugas, sabendo-se que o máximo valor da função ajuste é # Definition of coley_algo_01 method def coley_algo_01(self): """Method to implement algorithm 1 from Coley 1999""" # Import libraries import numpy as np import touche as tart import hexadec as hx # General parameters for the turtles x_min = -240 # Minimum x coordinate in pixels x_max = 240 # Maximum x coordinate in pixels y_min = -240 # Minimum y coordinate in pixels y_max = 240 # Maximum y coordinate in pixels max_rotate = 8 # Maximum rotation angle 8*45 degrees conv_f = 3e-7 # Conversion factor (fitness function to dimensions) # Call gen_bin_strings() self.gen_bin_strings() self.show_pop("\ninitial Population",self.current_pop) 33
34 Turtle sga02.py Em seguida criamos um objeto da classe Hexa() e invocamos o método gen_hex(). Acessamos o atributo my_hex_string e o atribuímos à variável hex. Esta string hexadecimal será usada para definir a cor das tartarugas de uma dada geração. # Looping through the number of iteractions for i in range(self.max_iter): # Call selection_coley_algo_01() self.selection_coley_algo_01() # Call cross_over_coley_algo_01() method self.cross_over_coley_algo_01() # Call mutation_coley_algo_01 method self.mutation_coley_algo_01() self.show_pop("\npopulation for generation "+str(i),self.current_pop) # Call bin2dec_array() d = self.bin2dec_array(self.current_pop) # Call fitness_func() d_2 = self.fitness_func(d) # Instantiating an object of the Hexa() class and assigns it to the h1 h1 = hx.hexa() # String for hexadecimal # Invoking the method gen_hex() h1.gen_hex() 34 hex = h1.my_hex_string
35 Turtle sga02.py Dentro to loop for das iterações temos um loop for para varrer os indivíduos da população de uma dada geração, em vermelho abaixo. As coordenadas x,y de cada tartaruga a ser desenhada são definidas por números aleatórios dentro das faixas previamente estabelecidas. # Looping through all elements for j in range(len(d_2)): # Define parameters for each turtle x = np.random.randint(x_min,x_max) y = np.random.randint(y_min,y_max) length = d_2[j]*conv_f width = d_2[j]*conv_f # x coordinate in pixels # y coordinate in pixels # Length for the turtle # Width for the turtle rotate = np.random.randint(0,max_rotate) # Rotation angle 8*45 def # Instantiating an object of the Touche() class and assigns it to t t = tart.touche(x, y, length, width, rotate, "#"+hex) # Invoking the method draw() t.draw() # Call get_max() self.max_array[i] = self.get_max(d_2) # Call get_mean() self.mean_array[i] = self.get_mean(d_2) # Invoking the method bye() t.bye() self.show_pop("\nfinal Population",self.current_pop) 35
36 Turtle sga02.py As dimensões das tartarugas (length e width) são obtidas a partir da multiplicação do valor da função ajuste de cada indivíduo (d_2[j]) pelo fator de conversão (conv_f). # Looping through all elements for j in range(len(d_2)): # Define parameters for each turtle x = np.random.randint(x_min,x_max) y = np.random.randint(y_min,y_max) length = d_2[j]*conv_f width = d_2[j]*conv_f # x coordinate in pixels # y coordinate in pixels # Length for the turtle # Width for the turtle rotate = np.random.randint(0,max_rotate) # Rotation angle 8*45 def # Instantiating an object of the Touche() class and assigns it to t t = tart.touche(x, y, length, width, rotate, "#"+hex) # Invoking the method draw() t.draw() # Call get_max() self.max_array[i] = self.get_max(d_2) # Call get_mean() self.mean_array[i] = self.get_mean(d_2) # Invoking the method bye() t.bye() self.show_pop("\nfinal Population",self.current_pop) 36
37 Turtle sga02.py Em seguida, criamos um objeto da classe Touche(), usando-se como atributos do objeto os parâmetros previamente definidos. Depois invocamos o método draw(). Por último, fora dos loops for, invocamos o método bye(). O restante do código é idêntico ao do programa sga01.py. # Looping through all elements for j in range(len(d_2)): # Define parameters for each turtle x = np.random.randint(x_min,x_max) y = np.random.randint(y_min,y_max) length = d_2[j]*conv_f width = d_2[j]*conv_f # x coordinate in pixels # y coordinate in pixels # Length for the turtle # Width for the turtle rotate = np.random.randint(0,max_rotate) # Rotation angle 8*45 def # Instantiating an object of the Touche() class and assigns it to t t = tart.touche(x, y, length, width, rotate, "#"+hex) # Invoking the method draw() t.draw() # Call get_max() self.max_array[i] = self.get_max(d_2) # Call get_mean() self.mean_array[i] = self.get_mean(d_2) # Invoking the method bye() t.bye() self.show_pop("\nfinal Population",self.current_pop) 37
38 Turtle sga02.py Abaixo temos resultado da execução do código sga02.py. Final population
39 Exercícios de Programação A seguir temos a descrição de dois programas a serem desenvolvidos, usando-se o conteúdo discutido na presente aula. Lista de programas: tartaruga02.py sga03.py 39
40 Programa: tartaruga02.py Desenho de Tartarugas de Cores, Dimensões e Posições Aleatórias Programa: tartaruga02.py Resumo Modifique o código do programa tartaruga01.py, de forma que sejam geradas tartarugas com posições, cores e dimensões aleatórias. 40
41 Programa: sga03.py Algoritmo Genético Simples (Versão 3) Programa: sga03.py Resumo Modifique o código do programa sga02.py, de forma que o novo programa ache o valor mínimo da função x 2. 41
42 Lista de Programas de Aula 04 A seguir temos a lista de programas da presente aula. Lista de programas: sga01.py sga02.py tartaruga01.py touche.py hexadec.py
43 Colophon This text was produced in a HP Pavillon dm4 notebook with 6GB of memory, a 500 GB hard disk, and an Intel Core i7 M GHz running Windows 7 Professional. Text and layout were generated using PowerPoint Turtles drawings on slides 29, 30, and 38 were generated with Turtle library. Plots on slides 22, 30, and 38 were generated by Matplotlib. The image on the first slide was taken from on April 11, This text uses Arial font.
44 Referências -BRESSERT, Eli. SciPy and NumPy. Sebastopol: O Reilly Media, Inc., p. Link -DAWSON, Michael. Python Programming, for the Absolute Beginner. 3ed. Boston: Course Technology, p. -COLEY, David A. An Introduction to Genetic Algorithms for Scientists and Engineers. Singapore: World Scientific Publishing Co. Pte. Ltd., p. -EIBEN, A. E., SMITH, J. E. Introduction to Evolutionary Computing. Natural Computing Series. 2nd ed. Berlin: Springer- Verlag, p. Link -HACKELING G. Mastering Machine Learning with scikit-learn. Birmingham: Packt Publishing Ltd., p. Link -HETLAND, Magnus Lie. Python Algorithms. Mastering Basic Algorithms in the Python Language. 2ed. Nova York: Springer Science+Business Media LLC, p. Link -IDRIS, Ivan. NumPy 1.5. An action-packed guide dor the easy-to-use, high performance, Python based free open source NumPy mathematical library using real-world examples. Beginner s Guide. Birmingham: Packt Publishing Ltd., p. Link -LUTZ, Mark. Programming Python. 4ed. Sebastopol: O Reilly Media, Inc., p. Link -TOSI, Sandro. Matplotlib for Python Developers. Birmingham: Packt Publishing Ltd., p. Link Última atualização: 11 de abril de 2018.
azevedolab.net 2018 Dr. Walter F. de Azevedo Jr.
azevedolab.net 2018 Dr. Walter F. de Azevedo Jr. Reerências No algoritmo genético, a geração aleatória de indivíduos de uma dada população é uma etapa de importância undamental. Esse processo é chamado
2018 Dr. Walter F. de Azevedo Jr. azevedolab.net
2018 Dr. Walter F. de Azevedo Jr. azevedolab.net 1 Programação Orientada a Objeto Iremos ver o uso da abordagem de programação orientada a objeto (object-oriented programming (OOP)). Nosso objetivo é usar
Vimos na aula passada um algoritmo genético simples para resolver o problema do máximo da função x 2. Veremos sua implementação em Python.
azevedolab.net Implementação de um Algoritmo Genético Simples Vimos na aula passada um algoritmo genético simples para resolver o problema do máimo da função. Veremos sua implementação em Python. Gera
2016 Dr. Walter F. de Azevedo Jr.
2016 Dr. Walter F. de Azevedo Jr. > 1 Download do pyzo A partir do pyzo (disponível em http:///), o processo de instalação do Python fica facilitado. A instalação integra, além do Python, um conjunto de
2018 Dr. Walter F. de Azevedo Jr. azevedolab.net
2018 Dr. Walter F. de Azevedo Jr. azevedolab.net 1 Turtle A biblioteca Turtle permite a partir de poucos comandos realizarmos desenhos de formas geométricas simples na tela. Não é objetivo da presente
2016 Dr. Walter F. de Azevedo Jr.
2016 Dr. Walter F. de Azevedo Jr. 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000111111111110001100000000000 000000000001111111111111111111000000001 000000000111111111111111111111111000000
2016 Dr. Walter F. de Azevedo Jr. > >
2016 Dr. Walter F. de Azevedo Jr. > > 1 Download do eclipse www.eclipse.org Antes de fazer o download do eclipse, certifique-se que você tem o Java (JDK) instalado no seu computador. Vá ao site www.eclipse.org.
2017 Dr. Walter F. de Azevedo Jr.
2017 Dr. Walter F. de Azevedo Jr. 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000111111111110001100000000000 000000000001111111111111111111000000001 000000000111111111111111111111111000000
azevedolab.net 2015 Dr. Walter F. de Azevedo Jr. Arrays
azevedolab.net 2015 Dr. Walter F. de Azevedo Jr. Arrays 1 Programa: flying_saucer0.pde FlyingSaucer mysaucer; float speed; float score; // Declares an object // speed of flying saucer // score void setup()
2016 Dr. Walter F. de Azevedo Jr.
2016 Dr. Walter F. de Azevedo Jr. 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000111111111110001100000000000 000000000001111111111111111111000000001 000000000111111111111111111111111000000
azevedolab.net 2015 Dr. Walter F. de Azevedo Jr. Programação Orientada a Objetos em Processing
azevedolab.net 2015 Dr. Walter F. de Azevedo Jr. Programação Orientada a Objetos em Processing 1 Programação Orientada a Objeto O uso de programação orientada a objeto (POO) não irá introduzir necessariamente
2015 Dr. Walter F. de Azevedo Jr.
2015 Dr. Walter F. de Azevedo Jr. 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000111111111110001100000000000 000000000001111111111111111111000000001 000000000111111111111111111111111000000
azevedolab.net 2015 Dr. Walter F. de Azevedo Jr. Aula 09 Strings, Leitura e Escrita de Arquivos (continuação)
azevedolab.net 2015 Dr. Walter F. de Azevedo Jr. Aula 09 Strings, Leitura e Escrita de Arquivos (continuação) 1 Programa read_fasta_01.pde Exercício de programação: Elabore um programa que leia um arquivo
Programação I Aula 16 Mais exemplos de recursão Pedro Vasconcelos DCC/FCUP
Programação I Aula 16 Mais exemplos de recursão DCC/FCUP DCC/FCUP 2019 1/ 28 Nesta aula 1 Desenhar árvores 2 Calcular potências 3 Ordenação Quicksort DCC/FCUP 2019 2/ 28 Desenhar árvores Vamos fazer uma
2018 Dr. Walter F. de Azevedo Jr. azevedolab.net
2018 Dr. Walter F. de Azevedo Jr. azevedolab.net 1 Introdução às Expressões Booleanas Circuitos digitais encontrados nos processadores são baseados num formalismo matemático chamado Álgebra de Boole. Não
Bioinformática Aplicada
000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000111111111110001100000000000 000000000001111111111111111111000000001 000000000111111111111111111111111000000 000000000111111111111111111111111000000
1. Computação Evolutiva
Computação Bioinspirada - 5955010-1 1. Computação Evolutiva Prof. Renato Tinós Programa de Pós-Graduação Em Computação Aplicada Depto. de Computação e Matemática (FFCLRP/USP) 2 Computação Bioinspirada
2017 Dr. Walter F. de Azevedo Jr.
01 Dr. Walter F. de Azevedo Jr. 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000111111111110001100000000000 000000000001111111111111111111000000001 000000000111111111111111111111111000000
1. Computação Evolutiva
Computação Bioinspirada - 5955010-1 1. Computação Evolutiva Prof. Renato Tinós Programa de Pós-Graduação Em Computação plicada Depto. de Computação e Matemática (FFCLRP/USP) 2 Computação Bioinspirada -
2016 Dr. Walter F. de Azevedo Jr. azevedolab.net
2016 Dr. Walter F. de Azevedo Jr. 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000000000000000010000000000000 000000000000000000000111111111100000000 000000000000000000001111110000000000110
Programação orientada a objetos
Programação orientada a objetos Python fornece suporte para programação orientada a objetos: foco na criação de objetos, contendo simultaneamente dados e funcionalidade definição de objetos corresponde
Computação e Programação 2009 / 2010
Computação e Programação 2ª Aula de Problemas Instituto Superior Técnico, Dep. de Engenharia Mecânica - ACCAII Exercícios Resolvidos [Livro 1] (Ver referências no slide 20) 3.3 Write a program to convert
2016 Dr. Walter F. de Azevedo Jr. azevedolab.net
2016 Dr. Walter F. de Azevedo Jr. 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000000000000000010000000000000 000000000000000000000111111111100000000 000000000000000000001111110000000000110
azevedolab.net 2015 Dr. Walter F. de Azevedo Jr. Definição de Funções em Processing
azevedolab.net 2015 Dr. Walter F. de Azevedo Jr. Definição de Funções em Processing 1 Programa flying_saucer01.pde O programa flying_saucer01.pde traz um jogo simples que simula a queda de um disco voador.
Classes e Objetos POO
Classes e Objetos POO Prof. Marcio Delamaro 1/40 POO (wikipedia) Object-oriented programming (OOP) is a programming paradigm based on the concept of "objects", which are data structures that contain data,
2019 Dr. Walter F. de Azevedo Jr.
2019 Dr. Walter F. de Azevedo Jr. 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000111111111110001100000000000 000000000001111111111111111111000000001 000000000111111111111111111111111000000
PROGRAMAÇÃO PARA INTERNET RICA INTRODUÇÃO AO ACTIONSCRIPT 3. Prof. Dr. Daniel Caetano
PROGRAMAÇÃO PARA INTERNET RICA INTRODUÇÃO AO ACTIONSCRIPT 3 Prof. Dr. Daniel Caetano 2012-2 Objetivos Apresentar os conceitos básicos da linguagem ActionScript 3.0 Capacitar o aluno para criar programas
Course Review for Midterm Exam 1. Cpt S 223 Fall 2010
Course Review for Midterm Exam 1 Cpt S 223 Fall 2010 1 Midterm Exam 1 When: Friday (10/15) 10:10-11am Where: in class Closed book, closed notes Comprehensive Material for preparation: Lecture slides &
2016 Dr. Walter F. de Azevedo Jr.
2016 Dr. Walter F. de Azevedo Jr. 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000111111111110001100000000000 000000000001111111111111111111000000001 000000000111111111111111111111111000000
LOM3260 Computação científica em Python Informações sobre o curso
LOM3260 Computação científica em Python Informações sobre o curso Prof. Luiz T. F. Eleno Departamento de Engenharia de Materiais Escola de Engenharia de Lorena Universidade de São Paulo 2018 LOM3260 (EEL-USP,
Algoritmos Genéticos 1
Algoritmos Genéticos 1 Esquema de um GA Algoritmos Genéticos são um ramo da computação evolucionária Seu funcionamento pode ser resumido algoritimicamente através dos seguintes passos: Inicialize a população
Codificação das variáveis: binária Iniciação da população: aleatória Avaliação: função aptidão Operadores. Critério de parada: número de gerações
AG Simples/Canônico (AGS) AG introduzido por Holland Funciona bem para problemas de otimização simples e/ou de pequenas dimensões A maior parte da teoria dos AGs está baseada no AGS Utilidade didática
Programação de Computadores
Programação de Computadores Instituto de Computação UFF Departamento de Ciência da Computação Otton Teixeira da Silveira Filho Conteúdo Mais um tipo numérico print() formatado: clássico pythônico Tuplas
Programação I Aula 18 Programação com objetos Pedro Vasconcelos DCC/FCUP
Programação I Aula 18 Programação com objetos DCC/FCUP DCC/FCUP 2019 1/ 32 Nesta aula 1 Programação com objetos 2 Exemplo: turtle graphics 3 Definição de classes DCC/FCUP 2019 2/ 32 Programação com objetos
Técnicas de Inteligência Artificial
Universidade do Sul de Santa Catarina Ciência da Computação Técnicas de Inteligência Artificial Aula 9 Algoritmos Genéticos Max Pereira Algoritmos Genéticos Algoritmos Genéticos São técnicas de busca e
Computação 1 - Python Aula 8 - Teórica: Estrutura de Repetição : for 1/ 10
Computação 1 - Python Aula 8 - Teórica: Estrutura de Repetição : for 1/ 10 Estrutura de Repetição while Estrutura que permite a repetição de um conjunto de comandos. Até o momento vimos o while: while
COMPUTAÇÃO E PROGRAMAÇÃO
COMPUTAÇÃO E PROGRAMAÇÃO º Semestre 205/206 MEMec, LEAN Ficha da Aula Prática 3: Estruturas de repetição. Sumário das tarefas e objectivos da aula:. Estruturas de repetição controladas por contador 2.
Inteligência Artificial
Inteligência Artificial Fabrício Olivetti de França 07 de Junho de 2018 1 Heurísticas e Meta-Heurísticas 2 Heurística Heurística, derivada do grego encontrar ou descobrir, são técnicas para encontrar a
Computação II (MAB 225)
Computação II (MAB 225) Fabio Mascarenhas - 2015.1 http://www.dcc.ufrj.br/~fabiom/pythonoo Introdução No curso de Computação I vocês viram os conceitos básicos de programação em Python: expressões e comandos,
PROGRAMAÇÃO PARA INTERNET RICA INTRODUÇÃO AO ACTIONSCRIPT 3. Prof. Dr. Daniel Caetano
PROGRAMAÇÃO PARA INTERNET RICA INTRODUÇÃO AO ACTIONSCRIPT 3 Prof. Dr. Daniel Caetano 2012-1 Objetivos Apresentar os conceitos básicos da linguagem ActionScript 3.0 Capacitar o aluno para criar programas
Programação de Computadores II
Programação de Computadores II 1. Programação Básica 2019.1 Slides adaptados do material de Karina Mochetti Problema, Algoritmo, Programa Um programa de computador é a implementação de um algoritmo para
Algoritmos e estrutura de dados
Algoritmos e estrutura de dados Introdução Marco A L Barbosa cba Este trabalho está licenciado com uma Licença Creative Commons - Atribuição-CompartilhaIgual 4.0 Internacional. Conteúdo A linguagem Python
Strings e Arrays POO
Strings e Arrays POO Prof. Marcio Delamaro Programação Orientada a Objetos Prof Marcio Delamaro ICMC/USP 1/27 String Uma sequência de caracteres que representa uma informação textual Em Java existe um
Introdução à Computação
Conteúdo de hoje... Your Logo Here O módulo Turtle Prof. Lucas Amorim lucas@ic.ufal.br Primeiros programas com Turtle Instâncias um bando de tartarugas A função range() Introdução à Computação Um pouco
Programação 2012/2013 1º Semestre MEEC Laboratório 2 Semana de 22 de Outubro de 2012
Programação 2012/2013 1º Semestre MEEC Laboratório 2 Semana de 22 de Outubro de 2012 1. Implemente os programas cujos fluxogramas foram definidos na aula de problemas da semana passada: Exercício 7- Calculo
Programação de Computadores
Programação de Computadores Instituto de Computação UFF Departamento de Ciência da Computação Otton Teixeira da Silveira Filho Conteúdo Módulos: math random Funções definidas pelo usuário Mais sobre notações
Otimização com Algoritmos Evolutivos
Otimização com Algoritmos Evolutivos Francisco Pereira (xico@dei.uc.pt) ELBCE 2016 (Setembro 2016) Resumo Problem Optimization Method Solution } Algoritmos Evolutivos } Propriedades e funcionamento } Exemplos
Um sistema de numeração posicional utiliza um conjunto de símbolos. O valor que cada
APÊNDICE B Sistema de Numeração Posicional Um sistema de numeração posicional utiliza um conjunto de símbolos O valor que cada símbolo representa, no entanto, depende do seu valor nominal e do valor posicional,
UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ ALGORITMOS GENÉTICOS. Metaheurísticas de Buscas
PR UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ ALGORITMOS GENÉTICOS Metaheurísticas de Buscas ALGORITMOS GENÉTICOS (AG) Popularizados por John Holland podem ser considerados os primeiros modelos algorítmicos
Computação 2. Aula 3 Teórica professor: Leonardo Carvalho
Computação 2 Aula 3 Teórica professor: Leonardo Carvalho Na vida precisamos de muitos tipos de dados Tipos de dados conhecidos int long float complex str tuple list dict Verificando tipos >>> i = 32 >>>
PLANO DE ENSINO. 1. Ementa
CURSO: Graduação em Matemática 1º semestre de 2016 DISCIPLINA: INTRODUÇÃO Á COMPUTAÇÃO PROFESSOR(ES): Renato Rocha Souza REGIME DE TRABALHO: Tempo Integral CARGA HORÁRIA: 90h PRÉ-REQUISITO: Não há HORÁRIO
Estratégias Evolucionárias (Evolution Strategies - ES) Disciplina: Inteligência Artificial
Estratégias Evolucionárias (Evolution Strategies - ES) Disciplina: Inteligência Artificial UFPR: Departamento de Informática. Aula de Leila e Aurora. Data: 23/05/2005 ES: pertence à Computação Evolucionária
Funções. Prof. Alberto Costa Neto Programação em Python
Funções Prof. Alberto Costa Neto Programação em Python Passos armazenados (e reusados) def imprimir(): Programa: imprimir() print 'Zip' imprimir() print 'Hello' print 'Fun' def imprimir(): print 'Hello'
Python para quem sabe Python
Python para quem sabe Python Turma 0, aula 4 Metaclasses, programação funcional e programação assíncrona Exercício: execucao.py Para entender como o interpretador Python lê um arquivo.py Tudo é executável
Introdução à Programação Aula 19 Programação com objetos
Introdução à Programação Aula 19 Programação com objetos Pedro Vasconcelos DCC/FCUP 2015 Pedro Vasconcelos (DCC/FCUP) Introdução à Programação Aula 19 Programação com objetos 2015 1 / 20 Nesta aula 1 Programação
Programação I Aula 15 Definições recursivas Pedro Vasconcelos DCC/FCUP
Programação I Aula 15 Definições recursivas DCC/FCUP DCC/FCUP 2019 1/ 30 Nesta aula 1 Definições recursivas 2 Exemplos Factorial Floco de neve de Koch Torre de Hanoi DCC/FCUP 2019 2/ 30 Recursividade Uma
ESTUDO DO EFEITO DOS PARÂMETROS GENÉTICOS DE UM ALGORITMO GENÉTICO NA SOLUÇÃO OTIMIZADA E NO TEMPO DE CONVERGÊNCIA EM UMA FUNÇÃO DE DUAS VARIÁVEIS
ESTUDO DO EFEITO DOS PARÂMETROS GENÉTICOS DE UM ALGORITMO GENÉTICO NA SOLUÇÃO OTIMIZADA E NO TEMPO DE CONVERGÊNCIA EM UMA FUNÇÃO DE DUAS VARIÁVEIS Marcelo Henrique dos Santos Universidade de Uberaba, Engenharia
Integração numérica. Prof. Luiz T. F. Eleno. Departamento de Engenharia de Materiais Escola de Engenharia de Lorena Universidade de São Paulo
Integração numérica Prof. Luiz T. F. Eleno Departamento de Engenharia de Materiais Escola de Engenharia de Lorena Universidade de São Paulo 2018 LOM3260 (EEL-USP, 2018) Integração numérica Prof. Luiz T.
Usando gráficos python e arduino
[1] maregito [1] 11:04 30 jun, 2015 [2] Bom final de dia Galerinha do Módulo 2! Segue um pequeno exemplo de como juntar o arduino com o pyhon. Este gráfico permite até 6 linhas simultaneamente, basta conectar
Processamento Digital de Imagens
Processamento Digital de Imagens Aula 03 Prof. Diemesleno Souza Carvalho diemesleno@iftm.edu.br http://www.diemesleno.com.br Na aula passada vimos... Na aula passada vimos... Unidade II - Básico sobre
PROGRAMAÇÃO de COMPUTADORES: LINGUAGEM FORTRAN 90/95
PROGRAMAÇÃO de COMPUTADORES: LINGUAGEM FORTRAN 90/95 Exercícios de revisão Lista 01: a) Monte um mapa conceitual indicando as relações entre os seguintes conceitos, no contexto do assunto visto em aula:
Otimização com Algoritmos Genéticos no MATLAB. Prof. Rafael Saraiva Campos CEFET-RJ
Otimização com Algoritmos Genéticos no MATLAB Prof. Rafael Saraiva Campos CEFET-RJ Conteúdo do Mini-Curso PARTE 1 Teoria PARTE 2 Prática Conteúdo do Mini-Curso PARTE 1 Teoria 1.1. Conceitos Básicos de
azevedolab.net 2015 Dr. Walter F. de Azevedo Jr. Aula 08 Strings, Leitura e Escrita de Arquivos
azevedolab.net 2015 Dr. Walter F. de Azevedo Jr. Aula 08 Strings, Leitura e Escrita de Arquivos 1 Classe String Em Python não precisamos definir o tipo da variável, já em Processing temos que definir os
Algoritmos genéticos Abordagem unificada de algoritmos evolutivos simples
Introdução Inspiração biológica Histórico da computação evolutiva Algoritmo evolutivo simples Programação evolutiva Estratégias evolutivas Algoritmos genéticos Abordagem unificada de algoritmos evolutivos
GT-JeDi - Curso de Desenv. de Jogos IA para Jogos. Gustavo Pessin 2007
GT-JeDi - Curso de Desenv. de Jogos IA para Jogos Gustavo Pessin 2007 Cronograma Base conceitual Exemplo: Achando o máximo de uma função... Como criar uma pequena aplicação: Exercício-Exemplo [Animal selvagem...]
Técnicas de Inteligência Artificial
Universidade do Sul de Santa Catarina Ciência da Computação Técnicas de Inteligência Artificial Aula 9 Algoritmos Genéticos Max Pereira Algoritmos Genéticos São técnicas de busca e otimização. Uma metáfora
2015 Dr. Walter F. de Azevedo Jr. www.python.org
2015 Dr. Walter F. de Azevedo Jr. 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000111111111110001100000000000 000000000001111111111111111111000000001 000000000111111111111111111111111000000
Programação de Computadores II Aula 03. Linguagem C I
Programação de Computadores II Slides cedidos por Karina Mochetti 2018.1 C vs Python Python é uma linguagem muito mais nova, de 1991. C é muito mais eciente, os programas rodam mais rápido. Seu objetivo
Métodos de pesquisa e Optimização
Métodos de pesquisa e Optimização Victor Lobo Importância para os SAD Definir o caminho a tomar depois de se ter trabalhado os dados 1ª Fase: Analisar os dados disponíveis Visualização OLAP, relatórios
Árvores. Thiago Martins, Fabio Gagliardi Cozman. PMR2300 / PMR3201 Escola Politécnica da Universidade de São Paulo
PMR2300 / PMR3201 Escola Politécnica da Universidade de São Paulo Árvore: estrutura composta por nós e arestas entre nós. As arestas são direcionadas ( setas ) e: um nó (e apenas um) é a raiz; todo nó
Transparent application acceleration by intelligent scheduling of shared library calls on heterogeneous systems September 9, 2013
Transparent application acceleration by intelligent scheduling of shared library calls on heterogeneous systems João Colaço, Adrian Matoga, Aleksandar Ilic, Nuno Roma, Pedro Tomás, Ricardo Chaves adrian.matoga@inesc-id.pt
Simples Experimentos com Algoritmos Genéticos
Simples Experimentos com Algoritmos Genéticos Ronie Miguel Uliana Universidade Presbiteriana Mackenzie, ronie.uliana@gmail.com Resumo Esse trabalho analisa o efeito da aplicacão de diferentes valores nos
caminho A B C A H G F H I A B C D E F G H I D E B A H G F I D E B A H G F I C D E B D E F G I C problema: crossover Cidades repetidas - inválido!!!
Caixeiro viajante Algoritmos Genéticos aula 2 - exemplos Caixeiro viajante representação intuitiva de indivíduo: o próprio caminho D E B A H G F I C Exemplo: recombinação de 2 pontos 1 2 A B C D E F G
Aprendizado de Supervisionado
Aprendizado de Supervisionado Fabrício Olivetti de França Universidade Federal do ABC Tópicos 1. Aprendendo com Exemplos 2. Classificação 3. Conceitos Gerais 4. Vizinho Mais Próximo 1 Aprendendo com Exemplos
Computação e Programação
Computação e Programação 10ª Aula de Problemas Tópicos Avançados sobre Funções Instituto Superior Técnico, Dep. de Engenharia Mecânica - ACCAII Problema 1 3. The velocity of sound in air is 49.02xT^(1/2)
English version at the end of this document
English version at the end of this document Ano Letivo 2017-18 Unidade Curricular COMPUTAÇÃO EVOLUTIVA Cursos ENGENHARIA INFORMÁTICA (2.º ciclo) Unidade Orgânica Faculdade de Ciências e Tecnologia Código
Programação I Aula 19 Aritmética com racionais Pedro Vasconcelos DCC/FCUP
Programação I Aula 19 Aritmética com racionais DCC/FCUP DCC/FCUP 2019 1/ 30 Nesta aula 1 Aritmética com racionais 2 Simplificação 3 Operações 4 Comparações DCC/FCUP 2019 2/ 30 Aritmética com racionais
Python. Resumo e Exercícios P3
Python Resumo e Exercícios P3 Resuminho Teórico Classes e Objetos Tudo em python é um objeto, objetos são instâncias de classes, como int, float, list, etc. a = 5 # a é um objeto da classe int b = 2.0
Programação I Aula 6 Números pseudo-aleatórios Pedro Vasconcelos DCC/FCUP
Programação I Aula 6 Números pseudo-aleatórios DCC/FCUP DCC/FCUP 2019 1/ 28 Nesta aula 1 Números pseudo-aleatórios 2 Jogo Hi-Lo 3 Passeio aleatório DCC/FCUP 2019 2/ 28 Números pseudo-aleatórios Por vezes
Algoritmos e Programação
ESTADO DE MATO GROSSO SECRETARIA DE ESTADO DE CIÊNCIA E TECNOLOGIA UNIVERSIDADE DO ESTADO DE MATO GROSSO CAMPUS UNIVERSITÁRIO DE SINOP FACULDADE DE CIÊNCIAS EXATAS E TECNOLÓGICAS Algoritmos e Programação
Aula 5 POO 1 Encapsulamento. Profa. Elaine Faria UFU
Aula 5 POO 1 Encapsulamento Profa. Elaine Faria UFU - 2019 Sobre o Material Agradecimentos Aos professores José Gustavo e Fabiano, por gentilmente terem cedido seus materiais. Os slides consistem de adaptações
azevedolab.net Variáveis, Condicionais e Loops 2015 Dr. Walter F. de Azevedo Jr.
azevedolab.net 2015 Dr. Walter F. de Azevedo Jr. Loops Variáveis, Condicionais e 1 Exercício de Programação Exercício de programação: 1) Use a figura da joaninha que você gerou na aula anterior e a transforme
Tratamento de Caracteres
Tratamento de Caracteres Notas de Aula Prof. Francisco Rapchan www.geocities.com/chicorapchan A tabela ASCII Se os computadores manipulam apenas números, como eles podem armazenar os caracteres de um nome
2019 Dr. Walter F. de Azevedo Jr.
2019 Dr. Walter F. de Azevedo Jr. 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000111111111110001100000000000 000000000001111111111111111111000000001 000000000111111111111111111111111000000
Aplicação de algoritmos genéticos. Problema da Mochila (knapsack problem)
Aplicação de algoritmos genéticos Problema da Mochila (knapsack problem) Algoritmos genéticos Passos inspirados no processo biológico de evolução Ideia de sobrevivência dos mais adaptados Soluções cada
Padrão para a codificação em Python
Padrão para a codificação em Python Bonito é melhor que feio. Explícito é melhor que implícito. Simples é melhor que complexo. Complexo é melhor que complicado. Esparso é melhor que denso. Legibilidade
Algoritmos Genéticos e Evolucionários
Algoritmos Genéticos e Evolucionários Djalma M. Falcão COPPE/UFRJ PEE e NACAD falcao@nacad.ufrj.br http://www.nacad.ufrj.br/~falcao/ http://www.nacad.ufrj.br/~falcao/ag/ag.htm Resumo do Curso Introdução
Introdução à Programação
Introdução à Programação Aula 21: Programação com objetos Rita P. Ribeiro 2017/2018 Departamento de Ciência de Computadores Nesta aula 1. Programação com objetos 2. Exemplo: módulo turtle 3. Tipos de dados
Algoritmos Genéticos
Universidade de São Paulo Instituto de Ciências Matemáticas e de Computação Algoritmos Genéticos Aluno: Fabricio Aparecido Breve Prof.: Dr. André Ponce de Leon F. de Carvalho São Carlos São Paulo Maio
Programação I Aula 6 Números pseudo-aleatórios
Programação I Aula 6 Números pseudo-aleatórios Pedro Vasconcelos DCC/FCUP 2018 Pedro Vasconcelos (DCC/FCUP) Programação I Aula 6 Números pseudo-aleatórios 2018 1 / 28 Nesta aula 1 Números pseudo-aleatórios
1. Computação Evolutiva
Computação Bioinspirada - 5955010-1 1. Computação Evolutiva Prof. Renato Tinós Programa de Pós-Graduação Em Computação Aplicada Depto. de Computação e Matemática (FFCLRP/USP) 2 Computação Bioinspirada
Computação 1 - Python Aula 7 - Teórica: Estrutura de Repetição com teste de parada: while 1/ 23
Computação 1 - Python Aula 7 - Teórica: Estrutura de Repetição com teste de parada: while 1/ 23 Permite que o programador especifique que o programa deve repetir um conjunto de comandos enquanto uma dada
Exemplo de Aplicação de Algoritmos Genéticos. Prof. Juan Moisés Mauricio Villanueva cear.ufpb.br/juan
Exemplo de Aplicação de Algoritmos Genéticos Prof. Juan Moisés Mauricio Villanueva jmauricio@cear.ufpb.br cear.ufpb.br/juan Estrutura do Algoritmo Genético Algoritmo genético Inicio t = 0 inicializar P(t)
Árvores. Fabio Gagliardi Cozman. PMR2300 Escola Politécnica da Universidade de São Paulo
PMR2300 Escola Politécnica da Universidade de São Paulo Árvore: estrutura composta por nós e arestas entre nós. As arestas são direcionadas ( setas ) e: um nó (e apenas um) é a raiz; todo nó (exceto a
Linguagens para Programação Paralela. October 26, 2010
October 26, 2010 Linguagens X Bibliotecas expressividade facilidade de uso integração com programas e programadores Modelos de Linguagens Paralelas (lista não completa) paralelismo de dados (data-parallel)
Variáveis e instruções de repetição
Variáveis e instruções de repetição Marco A L Barbosa malbarbo.pro.br Departamento de Informática Universidade Estadual de Maringá cba Este trabalho está licenciado com uma Licença Creative Commons - Atribuição-CompartilhaIgual
Licenciatura em Informática Programação III Obrigatória X
CURSO UNIDADE CURRICULAR ÁREA CIENTÍFICA Licenciatura em Informática Programação III Obrigatória X Opcional Engenharia Informática Ano: 1º Semestre: 1º ECTS: 6 Horas de Contacto teórico práticas: 60 Docente
Produtividade e qualidade em Python através da metaprogramação
Produtividade e qualidade em Python através da metaprogramação ou a visão radical na prática Luciano Ramalho ramalho@python.pro.br @ramalhoorg Fluent Python (O Reilly) Early Release: out/2014 First Edition:
Descritores de atributos em Python
Descritores de atributos em Python outubro/2012 Luciano Ramalho luciano@ramalho.org Ritmo desta palestra Recomendação: manter os olhos abertos Pré-requistos da palestra Para acompanhar os slides a seguir,