azevedolab.net 2018 Dr. Walter F. de Azevedo Jr.

Transcrição

1 azevedolab.net 2018 Dr. Walter F. de Azevedo Jr.

2 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 de inicialização na igura abaixo. Com a biblioteca NumPy, temos a possibilidade de ixarmos uma semente aleatória, para garantir que os números aleatórios iniciais sejam mantidos, para uma dada semente aleatória. Initialização 2

3 Números Pseudo-aleatórios Para deinição da semente aleatória, usamos o comando abaixo. No exemplo abaixo, a semente aleatória é um número inteiro atribuído à variável seed_in. np.random.seed(seed_in) A linha acima deve ser inserida antes da geração do número aleatório. Por exemplo, o código abaixo (random_with_seed.py) gera um número aleatório entre 0 e 9. # Import library import numpy as np # Set up seed np.random.seed(31415) # Generate random number rs = np.random.randint(0,9) print(rs) Veja que a deinição da semente aleatório aparece antes da deinição do número aleatório, que ocorre na linha rs = np.random.randint(0,9). 3

4 Números Pseudo-aleatórios O código random_loop.py repete a geração de número aleatório dentro de um loop or, como mostrado abaixo. # Import library import numpy as np # Loop or generation o random numbers or i in range(10): # Set up seed np.random.seed(31415) # Generate random number rs = np.random.randint(0,9) print(rs) Abaixo temos o resultado obtido com o programa random_loop.py. Anterior a geração do número aleatório em cada iteração, temos a ixação da semente aleatória. O resultado é que temos sempre o mesmo número gerado

5 Números Pseudo-aleatórios Colocando-se a linha da semente aleatória como comentário no código random_loop.py, os números passam a variar. # Import library import numpy as np # Loop or generation o random numbers or i in range(10): # Set up seed # np.random.seed(31415) # Generate random number rs = np.random.randint(0,9) print(rs) Como não temos semente aleatória, o código gera números distintos, como podemos ver no resultado abaixo

6 Números Pseudo-aleatórios Abaixo temos o código do novo método para gerar strings binárias com semente. A principal novidade é que temos um atributo do objeto para a semente, atribuído à variável sel.seed_in. Essa variável é usada na linha np.random.seed(sel.seed_in). de gen_bin_string_seed(sel): """Method to generate binary strings""" # Import library import numpy as np # Set up seed or random number np.random.seed(sel.seed_in) # Set up arrays o zeros sel.max_array = np.zeros(sel.max_iter) sel.mean_array = np.zeros(sel.max_iter) # Set up empty list bin_str_list = [] # Generate binary string or i in range(sel.pop_size): bin1 = np.random.randint(2,size=sel.len_str) bin_str0 = str(bin1) bin_str0 = bin_str0.replace(" ","") bin_str0 = bin_str0.replace("[","") bin_str0 = bin_str0.replace("]","") bin_str_list.append(bin_str0) # Update population sel.current_pop = bin_str_list print("\ninitial Population") # Looping through initial population or bin_string in sel.current_pop: print(bin_string) # Binary (2) strings 6

7 Números Pseudo-aleatórios Uma vez estabelecida a semente, os números aleatórios serão mantidos. No inal do método temos um loop or para exibir a população inicial. O método construtor oi modiicado, de orma a acomodar o atributo sel.seed_in. de gen_bin_string_seed(sel): """Method to generate binary strings""" # Import library import numpy as np # Set up seed or random number np.random.seed(sel.seed_in) # Set up arrays o zeros sel.max_array = np.zeros(sel.max_iter) sel.mean_array = np.zeros(sel.max_iter) # Set up empty list bin_str_list = [] # Generate binary string or i in range(sel.pop_size): bin1 = np.random.randint(2,size=sel.len_str) bin_str0 = str(bin1) bin_str0 = bin_str0.replace(" ","") bin_str0 = bin_str0.replace("[","") bin_str0 = bin_str0.replace("]","") bin_str_list.append(bin_str0) # Update population sel.current_pop = bin_str_list print("\ninitial Population") # Looping through initial population or bin_string in sel.current_pop: print(bin_string) # Binary (2) strings 7

8 Números Pseudo-aleatórios Abaixo temos o trecho inicial da deinição da classe com destaque para o método construtor. Vemos em vermelho o texto que oi adicionado à classe Simple_GA02() para a semente aleatória. Também oram adicionados atributos para os valores mínimo e máximo da aixa de loat (sel._min e sel._max). Outro atributo adicionado reere-se ao ator de conversão para o tamanho das tartarugas. Esses atributos serão discutidos nos próximos slides. class Simple_GA02(object): """A class to implement a simple GA""" # Constructor method de init (sel,pop_size,max_iter,p_cross,len_str,p_mut,_min,_max,conv_,seed_in): # Deine atributes sel.pop_size = pop_size sel.max_iter = max_iter sel.p_cross = p_cross sel.len_str = len_str sel.p_mut = p_mut sel._min = _min sel._max = _max sel.conv_ = conv_ sel.seed_in = seed_in # Population size # Number o iterations # Probability o crossover # String length # Probability o mutation_coley_algo_03 # Minimum loat # Maximum loat # Conversion actor # Seed or generation o random numbers 8

9 Números do Tipo Float Nas últimas aulas implementamos o algoritmo 1 de Colley 1999 que acha o máximo da unção x 2 entre os inteiros 0 e Muitos problemas de otimização não se restringe-se ao conjunto dos inteiros. Para apresentarmos a solução do problema de maximização, vamos considerar que a aixa de números está entre 1,25 e 3,14. Os novos números são chamados de loats mínimo e máximo e são representados pelas variáveis min e max. String binária Integers Floats

10 Números do Tipo Float De uma orma geral, podemos dizer que para cada inteiro temos um equivalente loat, colocando em orma matemática temos: min max i i 1 min max Onde os s representam os loats e os i s representam os inteiros. As constantes s são usadas para convertermos de inteiro para loat. Considerando-se que i min = 0 temos: Calculando-se max min chegamos: min 0 max max min min 0 i 1 i max 1 max 1 0 max i max min 10

11 Números do Tipo Float Assim, o loat equivalente () a um inteiro qualquer i é dado por: 0 1i min 1i min max i max min i Agora temos uma equação geral onde podemos obter qualquer loat, a partir do conhecimento da aixa de inteiros que dispomos e da deinição da aixa de loats que queremos analisar. min max i max min i 11

12 Números do Tipo Float Considerando-se uma string binária de l bits, o número inteiro máximo que pode ser representado é dado por: i max 2 l 1 Assim, substituindo-se esse valor na equação do loat, temos: max min min i l

13 Números do Tipo Float Um aspecto importante na aplicação de algoritmos genéticos é a acurácia. Por exemplo, quando consideramos a equivalência entre a aixa de 0 a 4095 com a aixa de 1,25 a 3,14. Vemos que entre dois números consecutivos em decimal, por exemplo, 1000 e 1001, temos os equivalentes em loat: 3,14 1,25 1, , ,14 1,25 1, , Assim, entre 1,7115 e 1,7120 não temos representação loat. Ou seja, temos aproximadamente 0,0005 de acurácia. Uma orma de aumentarmos a acurácia, é aumentando-se o tamanho das strings binárias. Uma orma de calcularmos a acurácia é dividirmos a aixa de loats ( max min ) pela quantidade de inteiros (i max ). 13

14 Números do Tipo Float No novo código, criamos um método para implementar a equação de conversão de inteiro para loat. O novo método é chamado int2loat(). O código está destacado abaixo. Os parâmetros do método trazem o loat mínimo (_min), o loat máximo (_max) e o inteiro a ser convertido (i). Esses valores são usados para o cálculo do que retorna para onde o método oi invocado, dentro do método coley_algo_03(). de int2loat(sel,i): """Method to convert integer to loat""" = sel._min + i*(sel._max - sel._min)/(2**(sel.len_str) -1) return 14

15 Números do Tipo Float Outra modiicação oi na unção show_pop(), que passa a mostrar os valores loats para o indivíduo e a unção ajuste, além da string binária. de show_pop(sel,string2show,pop2show,_in,unction_in): """Method to show population""" # Show inormation concerning the population print("\n"+string2show) # Looping though the elements o the population or i in range(len(pop2show)): print(pop2show[i]," %.3"%_in[i]," %.3"%unction_in[i]) 15

16 Roleta de Cassino O operador seleção que usamos até o momento é relativamente simples de implementar, mas não é o mais comum no estudo de algoritmos genéticos. Uma abordagem mais robusta do operador seleção leva em conta o valor da unção ajuste na seleção, mas não necessariamente elimina indivíduos com os valores mais baixos. Esta abordagem é chamada roleta de cassino

17 Roleta de Cassino A abordagem de roleta de cassino soma todos os valores da unção ajuste e atribui à variável it sum. Então é gerado um número aleatório (r s ) entre zero e it sum. Em seguida um loop vai somando os valores da unção ajuste de cada indivíduo da população, esses valores são somados à variável it partial. Quando a condição it partial.> r s or satiseita, o loop é encerrado e o último indivíduo somado é considerado selecionado para a próxima geração. Esse processo se repete até que a população atinja o número de indivíduos estabelecido para a população r s = 23,546 it partial = 24,955 17

18 Roleta de Cassino Para ilustrar uma iteração do operador seleção com roleta de cassino, considere os valores da unção ajuste mostrados no gráico abaixo. Foi gerado um número aleatório entre zero e soma de todos os valores da unção ajuste (52,739), por exemplo, r s = 23,546. Em seguida somamos os valores de cada unção ajuste e testamos a condição it partial.> r s, quando or satiseita paramos a soma. O indivíduo que gerou o último valor da unção ajuste (6,777) é selecionado r s = 23,546 it partial = 24,955 18

19 Roleta de Cassino Abaixo temos o luxograma do algoritmo 2 de Coley 1999, que implementa a roleta de cassino para seleção de indivíduos. Soma os valores da unção ajuste de todos os indivíduos e atribui à variável it sum it partial.> r s Não Seleciona um número aleatório entre 0 e it sum e atribui à variável r s Soma o valor da unção ajuste à variável it partial Sim Retorna o último indivíduo somado 19

20 Roleta de Cassino Abaixo temos o método roulette_wheel(). Inicialmente somamos os valores da unção ajuste de todos os indivíduos e atribuímos à variável it_sum. de roulette_wheel(sel): """Method or application o roulette wheel to a population""" # Import library import numpy as np # Sum itness unction vaules it_sum = np.sum(sel.it) # Set up empty list new_pop = [] # Looping through all individuals or j in range(sel.pop_size): # Generate random number rs =np.random.uniorm(0,it_sum) # Set up initial value or it_partial it_partial = 0 # Looping through inidividual until it_partial > rs or i in range(sel.pop_size): it_partial += sel.it[i] # Check i condition is satisied i it_partial > rs: new_pop.append(sel.current_pop[i]) break # Update population sel.current_pop = new_pop 20

21 Roleta de Cassino Agora dentro de um loop or, geramos uma número aleatório entre zero e a soma dos valores da unção ajuste e atribuímos à variável rs. de roulette_wheel(sel): """Method or application o roulette wheel to a population""" # Import library import numpy as np # Sum itness unction vaules it_sum = np.sum(sel.it) # Set up empty list new_pop = [] # Looping through all individuals or j in range(sel.pop_size): # Generate random number rs =np.random.uniorm(0,it_sum) # Set up initial value or it_partial it_partial = 0 # Looping through inidividual until it_partial > rs or i in range(sel.pop_size): it_partial += sel.it[i] # Check i condition is satisied i it_partial > rs: new_pop.append(sel.current_pop[i]) break # Update population sel.current_pop = new_pop 21

22 Roleta de Cassino Esse primeiro loop or varre toda população. Interno ao primeiro loop, temos um segundo loop or para realizarmos a unção da roleta de cassino. de roulette_wheel(sel): """Method or application o roulette wheel to a population""" # Import library import numpy as np # Sum itness unction vaules it_sum = np.sum(sel.it) # Set up empty list new_pop = [] # Looping through all individuals or j in range(sel.pop_size): # Generate random number rs =np.random.uniorm(0,it_sum) # Set up initial value or it_partial it_partial = 0 # Looping through inidividual until it_partial > rs or i in range(sel.pop_size): it_partial += sel.it[i] # Check i condition is satisied i it_partial > rs: new_pop.append(sel.current_pop[i]) break # Update population sel.current_pop = new_pop 22

23 Roleta de Cassino No segundo loop vamos somando os valores da unção ajuste até que este ultrapasse o número aleatório rs. Ao passar, adicionamos o último elemento à nova população. de roulette_wheel(sel): """Method or application o roulette wheel to a population""" # Import library import numpy as np # Sum itness unction vaules it_sum = np.sum(sel.it) # Set up empty list new_pop = [] # Looping through all individuals or j in range(sel.pop_size): # Generate random number rs =np.random.uniorm(0,it_sum) # Set up initial value or it_partial it_partial = 0 # Looping through inidividual until it_partial > rs or i in range(sel.pop_size): it_partial += sel.it[i] # Check i condition is satisied i it_partial > rs: new_pop.append(sel.current_pop[i]) break # Update population sel.current_pop = new_pop 23

24 Roleta de Cassino O processo é repetido até que a nova população, atribuída à variável new_pop, volte a ter o número original de indivíduos. Por último, a população é atualizada. de roulette_wheel(sel): """Method or application o roulette wheel to a population""" # Import library import numpy as np # Sum itness unction vaules it_sum = np.sum(sel.it) # Set up empty list new_pop = [] # Looping through all individuals or j in range(sel.pop_size): # Generate random number rs =np.random.uniorm(0,it_sum) # Set up initial value or it_partial it_partial = 0 # Looping through inidividual until it_partial > rs or i in range(sel.pop_size): it_partial += sel.it[i] # Check i condition is satisied i it_partial > rs: new_pop.append(sel.current_pop[i]) break # Update population sel.current_pop = new_pop 24

25 Elitismo O uso da roleta no operador seleção pode levar a perda do melhor indivíduo de uma dada geração. Assim, é comum usarmos a opção de elitismo no algoritmo genético. Com elitismo o melhor indivíduo do operador seleção é salvo e mantido para próxima geração. Abaixo temos o método elitism(). Nesse método identiicamos o maior valor da unção ajuste na linha max_it = np.max(my_array). de elitism(sel): """Method or elitism""" # Import libraries import numpy as np import test_unction as t # Call bin2dec_array() dec = sel.bin2dec_array(sel.current_pop) # Call int2loat() my_loat = sel.int2loat(dec) # Instantiating an object o the Function() class and assigns it to the variable it0 it0 = t.function(my_loat) # Invoking the itness_unct() method my_it = it0.itness_unc() # Set up an array my_array = np.array(my_it) # Find the maximum or the itness unction and assigns it to max_it max_it = np.max(my_array) # Set up an empty list new_pop = [] # Find the position or the max_it in the my_array pos_array = np.where( my_array == max_it) # Get the integer or index my_index = int(pos_array[0][0]) # Assign elite member to sel.elite sel.elite = sel.current_pop[my_index] # Show elite member print("elite member: ", sel.elite, max_it 25

26 Elitismo O valor atribuído à variável max_it é usado para identiicar o índice do elemento do array que tem o máximo. Isso é eito em pos_array = np.where( my_array == max_it). Como podemos ter mais de um índice com o máximo, é atribuído à variável pos_array um array, onde nos interessa só uma das posições. Na linha my_index = int(pos_array[0][0]) atribuímos o índice do elemento máximo à variável my_index. de elitism(sel): """Method or elitism""" # Import libraries import numpy as np import test_unction as t # Call bin2dec_array() dec = sel.bin2dec_array(sel.current_pop) # Call int2loat() my_loat = sel.int2loat(dec) # Instantiating an object o the Function() class and assigns it to the variable it0 it0 = t.function(my_loat) # Invoking the itness_unct() method my_it = it0.itness_unc() # Set up an array my_array = np.array(my_it) # Find the maximum or the itness unction and assigns it to max_it max_it = np.max(my_array) # Set up an empty list new_pop = [] # Find the position or the max_it in the my_array pos_array = np.where( my_array == max_it) # Get the integer or index my_index = int(pos_array[0][0]) # Assign elite member to sel.elite sel.elite = sel.current_pop[my_index] # Show elite member print("elite member: ", sel.elite, max_it 26

27 Elitismo Agora obtemos elemento elite com a linha sel.elite = sel.current_pop[my_index]. Essa variável será usada no método include_elite. de elitism(sel): """Method or elitism""" # Import libraries import numpy as np import test_unction as t # Call bin2dec_array() dec = sel.bin2dec_array(sel.current_pop) # Call int2loat() my_loat = sel.int2loat(dec) # Instantiating an object o the Function() class and assigns it to the variable it0 it0 = t.function(my_loat) # Invoking the itness_unct() method my_it = it0.itness_unc() # Set up an array my_array = np.array(my_it) # Find the maximum or the itness unction and assigns it to max_it max_it = np.max(my_array) # Set up an empty list new_pop = [] # Find the position or the max_it in the my_array pos_array = np.where( my_array == max_it) # Get the integer or index my_index = int(pos_array[0][0]) # Assign elite member to sel.elite sel.elite = sel.current_pop[my_index] # Show elite member print("elite member: ", sel.elite, max_it 27

28 Elitismo O método include_elite() usa o elemento sel.elite para substituir um elemento aleatório da população. Assim garantimos que o elemento elite está na população ao inal da geração. O método include_elite() será evocado logo após a evocação do método do operador mutação. de include_elite(sel): """Method to include elite member in the current population""" # Import library import numpy as np # Generate random number rs = np.random.randint(0,sel.pop_size) # Set up empty list new_pop = [] # Looping through population and change or elite meber at random position or i in range(sel.pop_size): i i!= rs: new_pop.append(sel.current_pop[i]) else: new_pop.append(sel.elite) # Update current_pop 28 sel.current_pop = new_pop

29 Elitismo Nesse método geramos um número aleatório entre zero e o tamanho da população e atribuímos à variável rs. Em seguida criamos uma lista vazia que é atribuída à variável new_pop. Na sequência, temos um loop or que varre a população e testa se o índice do elemento da população é dierente do número interior aleatório. Se or mantém o elemento, caso contrário o elemento é substituído pelo elemento elite. Por último, a população é atualizada, garantindo-se a presença do elemento elite. de include_elite(sel): """Method to include elite member in the current population""" # Import library import numpy as np # Generate random number rs = np.random.randint(0,sel.pop_size) # Set up empty list new_pop = [] # Looping through population and change or elite meber at random position or i in range(sel.pop_size): i i!= rs: new_pop.append(sel.current_pop[i]) else: new_pop.append(sel.elite) # Update current_pop 29 sel.current_pop = new_pop

30 Turtle Algoritmo do Programa lga01.py Gera uma população aleatória de strings binárias (sel.gen_bin_strings_seed()) Ordena aleatoriamente os pais (sel.shule()) Converte cada string binária em um número decimal (sel.bin2dec_array()) Aplica cruzamento de um ponto (sel.single_point_crossover() Atingiu o número máximo de iterações? Não Converte de inteiro decimal para loat (sel.int2loat()) Operador mutação (sel. mutation_coley_algo_03) Sim Calcula a unção ajuste para cada indivíduo (it1.itness_unc()) Troca elemento aleatório pelo elemento elite (sel.include_elite()) Retorna os resultados Identiica o elemento elite (sel.elitism()) Seleciona a população usando a roleta de cassino (sel.roulette_wheel() ) 30

31 = sel.x**2 # [1.25,3.14] conv_actor = 0.45 max = return Função Teste Até agora implementamos um algoritmo genético para achar o máximo da unção (x) = x 2, uma unção relativamente simples. Normalmente as unções para os quais estamos interessados em achar o mínimo ou o máximo são mais complexas. A im de padronizar testes de eiciência de algoritmos de otimização, são usadas unções matemáticas que apresentam maiores variações. Há diversas unções que são consideradas padrões para testes, principalmente para unções de mais de uma variável. Iremos aqui parte nos restringir a unções de uma variável. Para acilitar a codiicação, criamos uma classe a parte do código lga01.py onde está implementada a unção ajuste. Abaixo temos o código test_unction.py. A linha em vermelho traz a codiicação da unção (x) = x 2, que é a nossa unção teste. Resumindo, usamos como unção ajuste uma unção teste, como objetivo de avaliar o desempenho do algoritmo. class Function(object): """Class to calculate an one-variable mathematical unction""" de init (sel,x): sel.x = x # Deinition o itness_unc() de itness_unc(sel): """Method to calculate itness unction""" import numpy as np

32 Função Teste Abaixo temos o gráico de algumas unções que podem ser implementadas em test_unction.py. 2 2 ( x) x ( x) 6x x ( x) 7x x 2 12 ( x) x 2.sin( x) 32

33 Turtle lga01.py Usamos os seguintes parâmetros para o programa lga01.py. pop_size = 8 # Population size max_iter = 25 # Number o iterations p_cross = 0.8 # Probability o crossover len_str = 12 # Length o strings p_mut = 0.01 # Probability o mutation_coley_algo_03 seed = # Seed or generation o random number min_ = 0.0 # Minimum loat max_ = # Maximum loat conv_actor = # Conversion actor (itness unction to dimensions) Foi usada a seguinte unção teste, (x) = x 2.sin(x), com intervalo entre 0 e

34 Turtle lga01.py Abaixo temos os resultados obtidos com os parâmetros do slide anterior para o programa lga01.py. Population or generation

35 Turtle lga01.py O melhor resultado é obtido para x = , que é o máximo indicado na unção abaixo. Population or generation x =

36 Projeto 1 Projeto 1 - Algoritmo Genético Programa: lga02.py Data de entrega:

37 Projeto 1 Modiique o código do programa lga01.py, de orma que o programa leia os parâmetros do algoritmo genético a partir de uma arquivo de entrada (lga.in). O arquivo de entrada deve ter as seguintes inormações: pop_size max_iter p_cross len_str p_mut seed min_ max_ conv_actor elitism_in draw_turtle plot_unc Os parâmetros elitism_in, draw_turtle e plot_unc são variáveis booleanas que podem ser True ou False. O parâmetro elitism_in indica se o elitismo será considerado. O parâmetro draw_turtle é uma variável booleana e indica se as tartarugas serão desenhadas ou não. O último parâmetro (plot_unc) indica se será gerado o gráico da unção ajuste. Esses três últimos parâmetros não estão no código lga01.py e devem ser incorporados no novo código. 37

38 Projeto 1 Além disso, o novo código irá gerar um arquivo lga.log com as inormações de cada geração (população, valor em loat e valor da unção ajuste). É similar ao que o programa lga01.py mostra na tela para cada geração, só que agora será gravado num arquivo.log. No inal do arquivo lga.log, deve ser gravada uma linha com as inormações do melhor indivíduo (string binária, valor em loat e valor da unção ajuste). O programa também gera um arquivo CSV, chamado lga.csv, com as seguintes inormações: Generation Elite Member Mean Fitness Function Maximum Fitness Function... O novo programa deve chamar-se lga02.py e tem que ser testado para as seguintes unções: ( x) x 2, no intervalo [1.25, 3.14] e conv_actor = 0.45, ( x) 6x x 2, no intervalo [0, 6], e conv_actor = 0.45, ( x) 7x x 2 12, no intervalo [0, 6] e conv_actor = 0.6, ( x) x 2.sin( x), no intervalo [0, 100] e conv_actor =

39 Projeto 1 O programa deve ser entregue até o dia com um relatório sucinto descrevendo o desempenho do programa com as unções descritas no slide anterior. Devem ser testados diversos valores dos parâmetros de entrada do arquivo lga.in. Procurem o conjunto de parâmetros que gerem os melhores resultados para a localização do máximo das unções descritas no slide anterior. 39

40 Lista de Programas de Aula 05 A seguir temos a lista de programas da presente aula. Lista de programas: hexadec.py lga01.py random_loop.py random_with_seed.py test_unction.py touche.py 40

41 Colophon This text was produced in a HP Pavillon dm4 notebook with 6GB o memory, a 500 GB hard disk, and an Intel Core i7 M GHz running Windows 7 Proessional. Text and layout were generated using PowerPoint Turtles drawings on slides 2 and 34 were generated with Turtle library. Plots on slides 32, 34, and 35 were generated by Matplotlib. The pizza charts on slides 16, 17, and 18 were generated with Excel The image on the irst slide was taken rom on April 11, This text uses Arial ont. 41

42 Reerências -BRESSERT, Eli. SciPy and NumPy. Sebastopol: O Reilly Media, Inc., p. Link -DAWSON, Michael. Python Programming, or the Absolute Beginner. 3ed. Boston: Course Technology, p. -COLEY, David A. An Introduction to Genetic Algorithms or Scientists and Engineers. Singapore: World Scientiic 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 perormance, Python based ree 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 or Python Developers. Birmingham: Packt Publishing Ltd., p. Link Última atualização: 11 de abril de