2018 Dr. Walter F. de Azevedo Jr. azevedolab.net
|
|
- Derek Lencastre Escobar
- 5 Há anos
- Visualizações:
Transcrição
1 2018 Dr. Walter F. de Azevedo Jr. azevedolab.net 1
2 Turtle A biblioteca Turtle permite a partir de poucos comandos realizarmos desenhos de formas geométricas simples na tela. Não é objetivo da presente disciplina ensinar a biblioteca Turtle, mas iremos usar alguns comandos para ilustrarmos conceitos de programação orientada a objeto. Página de entrada do site: Acesso em 9 de abril de
3 Turtle square01.py Abaixo temos o código para desenharmos um quadrado na tela. Inicialmente a biblioteca Turtle é importada. # Program to draw a square using Turtle library # Import library from turtle import * x = -340 # x coordinate in pixels y = 285 # y coordinate in pixels size = 100 # Square size in pixels wn = Screen() # Call screen with dimensions 680 x 570 _ = Turtle() # Create a turtle.hideturtle() # Hide turtle _.penup() # Move pen up _.setx(x) # Set up initial position (x coordinate) _.sety(y) # Set up initial position (y coordinate) _.pendown() # Move pen down # Looping through to draw a square for i in range(4): # repeat four times _.forward(size) # Move forward (draw a line) _.right(90) # Rotate an angle in degrees wn.exitonclick() # Close when mouse click 3
4 Turtle square01.py Em seguida definimos alguns parâmetros necessários para posicionarmos a caneta (pen) para o desenho do quadrado. A tela padrão (default) da biblioteca Turtle tem dimensões de 680 x 570 pixels, com as coordenadas 0, 0 no centro. Aqui definimos as coordenadas -340, 285 para o início de um desenho do quadrado com lado 100 pixels. # Program to draw a square using Turtle library # Import library from turtle import * x = -340 # x coordinate in pixels y = 285 # y coordinate in pixels size = 100 # Square size in pixels wn = Screen() # Call screen with dimensions 680 x 570 _ = Turtle() # Create a turtle.hideturtle() # Hide turtle _.penup() # Move pen up _.setx(x) # Set up initial position (x coordinate) _.sety(y) # Set up initial position (y coordinate) _.pendown() # Move pen down # Looping through to draw a square for i in range(4): # repeat four times _.forward(size) # Move forward (draw a line) _.right(90) # Rotate an angle in degrees wn.exitonclick() # Close when mouse click 4
5 Turtle square01.py A linha de comando wn = Screen() cria a tela com os valores padronizados das dimensões. Você pode mudar as dimensões da tela com o comando setup(width, height) a ser colocando antes do comando wn = Screen(). Os parâmetros width e height definem a largura e altura da tela em pixels, respectivamente. # Program to draw a square using Turtle library # Import library from turtle import * x = -340 # x coordinate in pixels y = 285 # y coordinate in pixels size = 100 # Square size in pixels wn = Screen() # Call screen with dimensions 680 x 570 _ = Turtle() # Create a turtle.hideturtle() # Hide turtle _.penup() # Move pen up _.setx(x) # Set up initial position (x coordinate) _.sety(y) # Set up initial position (y coordinate) _.pendown() # Move pen down # Looping through to draw a square for i in range(4): # repeat four times _.forward(size) # Move forward (draw a line) _.right(90) # Rotate an angle in degrees wn.exitonclick() # Close when mouse click 5
6 Turtle square01.py Criamos uma tartaruga e atribuímos à variável _ com o comando _ = Turtle(). Agora podemos acessar os métodos da biblioteca Turtle com a notação dot (.). Por exemplo, a linha de comando _.hideturtle() esconde a figura da tartaruga da tela. # Program to draw a square using Turtle library # Import library from turtle import * x = -340 # x coordinate in pixels y = 285 # y coordinate in pixels size = 100 # Square size in pixels wn = Screen() # Call screen with dimensions 680 x 570 _ = Turtle() # Create a turtle.hideturtle() # Hide turtle _.penup() # Move pen up _.setx(x) # Set up initial position (x coordinate) _.sety(y) # Set up initial position (y coordinate) _.pendown() # Move pen down # Looping through to draw a square for i in range(4): # repeat four times _.forward(size) # Move forward (draw a line) _.right(90) # Rotate an angle in degrees wn.exitonclick() # Close when mouse click 6
7 Turtle square01.py A linha de comando _.penup() levanta a caneta. Em seguida definimos as coordenadas x e y para onde movemos a caneta, comandos _.setx(x) e _.sety(y). Por último, baixamos a caneta para começarmos a desenhar com o comando _.pendown(). # Program to draw a square using Turtle library # Import library from turtle import * x = -340 # x coordinate in pixels y = 285 # y coordinate in pixels size = 100 # Square size in pixels wn = Screen() # Call screen with dimensions 680 x 570 _ = Turtle() # Create a turtle.hideturtle() # Hide turtle _.penup() # Move pen up _.setx(x) # Set up initial position (x coordinate) _.sety(y) # Set up initial position (y coordinate) _.pendown() # Move pen down # Looping through to draw a square for i in range(4): # repeat four times _.forward(size) # Move forward (draw a line) _.right(90) # Rotate an angle in degrees wn.exitonclick() # Close when mouse click 7
8 Turtle square01.py A linha de comando _.forward(size) movimenta a caneta o número de píxels atribuídos à variável size. A linha de comando _.right(90) gira a caneta 90 o o que indica se tivermos um comando forward em seguida desenharemos uma aresta do quadrado. Como os comandos estão num loop for, as linhas serão desenhada quatro vezes. # Program to draw a square using Turtle library # Import library from turtle import * x = -340 # x coordinate in pixels y = 285 # y coordinate in pixels size = 100 # Square size in pixels wn = Screen() # Call screen with dimensions 680 x 570 _ = Turtle() # Create a turtle.hideturtle() # Hide turtle _.penup() # Move pen up _.setx(x) # Set up initial position (x coordinate) _.sety(y) # Set up initial position (y coordinate) _.pendown() # Move pen down # Looping through to draw a square for i in range(4): # repeat four times _.forward(size) # Move forward (draw a line) _.right(90) # Rotate an angle in degrees wn.exitonclick() # Close when mouse click 8
9 Turtle square01.py A linha de comando wn.exitonclick() indica que o programa fica esperando até que um click com o botão esquerdo do mouse seja dado. Ao clicarmos o mouse encerramos a execução do código. # Program to draw a square using Turtle library # Import library from turtle import * x = -340 # x coordinate in pixels y = 285 # y coordinate in pixels size = 100 # Square size in pixels wn = Screen() # Call screen with dimensions 680 x 570 _ = Turtle() # Create a turtle.hideturtle() # Hide turtle _.penup() # Move pen up _.setx(x) # Set up initial position (x coordinate) _.sety(y) # Set up initial position (y coordinate) _.pendown() # Move pen down # Looping through to draw a square for i in range(4): # repeat four times _.forward(size) # Move forward (draw a line) _.right(90) # Rotate an angle in degrees wn.exitonclick() # Close when mouse click 9
10 Turtle square01.py Abaixo temos o resultado da execução do código square01.py 10
11 Turtle square_oop_01.py Abaixo temos o código com programação orientada a objeto para desenharmos um quadrado. Antes da definição da classe, importamos a biblioteca Turtle. from turtle import * # Define a class class Square(object): """A class to draw a square""" # Define constructor method def init (self,x,y,size): self.x = x # x coordinate in pixels self.y = y # y coordinate in pixels self.size = size # Square size in pixels # Define draw() method def draw(self): self.wn = Screen() # Call screen with dimensions 680 x 570, 0,0 at the center self._ = Turtle() # Create a turtle self._ self._.hideturtle() # Hide turtle self._.penup() # Move pen up self._.setx(self.x) # Set up initial position x coordinate self._.sety(self.y) # Set up initial position y coordinate self._.pendown() # Move pen down # Looping through to draw a square for i in range(4): # Repeat four times self._.forward(self.size) # Move forward (draw a line) self._.right(90) # Rotate an angle in degrees # Define bye() method def bye(self): self.wn.exitonclick() # Close when mouse click def main(): # Instantiating an object of the Square() class and assigns it to the variable s1 s1 = Square(-340,285.0,100) # Screen size 680 x 570, 0,0 at the center # Invoking the method draw() s1.draw() # Invoking the method bye() s1.bye() main() 11
12 Turtle square_oop_01.py Definimos a classe Square() com um método construtor que tem como atributos as coordenadas x e y e o lado (size) do quadrado. from turtle import * # Define a class class Square(object): """A class to draw a square""" # Define constructor method def init (self,x,y,size): self.x = x # x coordinate in pixels self.y = y # y coordinate in pixels self.size = size # Square size in pixels # Define draw() method def draw(self): self.wn = Screen() # Call screen with dimensions 680 x 570, 0,0 at the center self._ = Turtle() # Create a turtle self._ self._.hideturtle() # Hide turtle self._.penup() # Move pen up self._.setx(self.x) # Set up initial position x coordinate self._.sety(self.y) # Set up initial position y coordinate self._.pendown() # Move pen down # Looping through to draw a square for i in range(4): # Repeat four times self._.forward(self.size) # Move forward (draw a line) self._.right(90) # Rotate an angle in degrees # Define bye() method def bye(self): self.wn.exitonclick() # Close when mouse click def main(): # Instantiating an object of the Square() class and assigns it to the variable s1 s1 = Square(-340,285.0,100) # Screen size 680 x 570, 0,0 at the center # Invoking the method draw() s1.draw() # Invoking the method bye() s1.bye() main() 12
13 Turtle square_oop_01.py O método draw() traz os comandos da biblioteca Turtle para desenharmos o quadrado. O funcionamento dos comandos já foram detalhados no programa square01.py. from turtle import * # Define a class class Square(object): """A class to draw a square""" # Define constructor method def init (self,x,y,size): self.x = x # x coordinate in pixels self.y = y # y coordinate in pixels self.size = size # Square size in pixels # Define draw() method def draw(self): self.wn = Screen() # Call screen with dimensions 680 x 570, 0,0 at the center self._ = Turtle() # Create a turtle self._ self._.hideturtle() # Hide turtle self._.penup() # Move pen up self._.setx(self.x) # Set up initial position x coordinate self._.sety(self.y) # Set up initial position y coordinate self._.pendown() # Move pen down # Looping through to draw a square for i in range(4): # Repeat four times self._.forward(self.size) # Move forward (draw a line) self._.right(90) # Rotate an angle in degrees # Define bye() method def bye(self): self.wn.exitonclick() # Close when mouse click def main(): # Instantiating an object of the Square() class and assigns it to the variable s1 s1 = Square(-340,285.0,100) # Screen size 680 x 570, 0,0 at the center # Invoking the method draw() s1.draw() # Invoking the method bye() s1.bye() main() 13
14 Turtle square_oop_01.py A classe Square() tem um método para encerramento da execução. Este método foi denominado bye(). from turtle import * # Define a class class Square(object): """A class to draw a square""" # Define constructor method def init (self,x,y,size): self.x = x # x coordinate in pixels self.y = y # y coordinate in pixels self.size = size # Square size in pixels # Define draw() method def draw(self): self.wn = Screen() # Call screen with dimensions 680 x 570, 0,0 at the center self._ = Turtle() # Create a turtle self._ self._.hideturtle() # Hide turtle self._.penup() # Move pen up self._.setx(self.x) # Set up initial position x coordinate self._.sety(self.y) # Set up initial position y coordinate self._.pendown() # Move pen down # Looping through to draw a square for i in range(4): # Repeat four times self._.forward(self.size) # Move forward (draw a line) self._.right(90) # Rotate an angle in degrees # Define bye() method def bye(self): self.wn.exitonclick() # Close when mouse click def main(): # Instantiating an object of the Square() class and assigns it to the variable s1 s1 = Square(-340,285.0,100) # Screen size 680 x 570, 0,0 at the center # Invoking the method draw() s1.draw() # Invoking the method bye() s1.bye() main() 14
15 Turtle square_oop_01.py No programa principal, criamos um objeto da classe Square() que é atribuído à variável s1. Os argumentos definem as coordenadas de início e o tamanho do quadrado. from turtle import * # Define a class class Square(object): """A class to draw a square""" # Define constructor method def init (self,x,y,size): self.x = x # x coordinate in pixels self.y = y # y coordinate in pixels self.size = size # Square size in pixels # Define draw() method def draw(self): self.wn = Screen() # Call screen with dimensions 680 x 570, 0,0 at the center self._ = Turtle() # Create a turtle self._ self._.hideturtle() # Hide turtle self._.penup() # Move pen up self._.setx(self.x) # Set up initial position x coordinate self._.sety(self.y) # Set up initial position y coordinate self._.pendown() # Move pen down # Looping through to draw a square for i in range(4): # Repeat four times self._.forward(self.size) # Move forward (draw a line) self._.right(90) # Rotate an angle in degrees # Define bye() method def bye(self): self.wn.exitonclick() # Close when mouse click def main(): # Instantiating an object of the Square() class and assigns it to the variable s1 s1 = Square(-340,285.0,100) # Screen size 680 x 570, 0,0 at the center # Invoking the method draw() s1.draw() # Invoking the method bye() s1.bye() main() 15
16 Turtle square_oop_01.py Em seguida são invocados os métodos draw() e bye(). from turtle import * # Define a class class Square(object): """A class to draw a square""" # Define constructor method def init (self,x,y,size): self.x = x # x coordinate in pixels self.y = y # y coordinate in pixels self.size = size # Square size in pixels # Define draw() method def draw(self): self.wn = Screen() # Call screen with dimensions 680 x 570, 0,0 at the center self._ = Turtle() # Create a turtle self._ self._.hideturtle() # Hide turtle self._.penup() # Move pen up self._.setx(self.x) # Set up initial position x coordinate self._.sety(self.y) # Set up initial position y coordinate self._.pendown() # Move pen down # Looping through to draw a square for i in range(4): # Repeat four times self._.forward(self.size) # Move forward (draw a line) self._.right(90) # Rotate an angle in degrees # Define bye() method def bye(self): self.wn.exitonclick() # Close when mouse click def main(): # Instantiating an object of the Square() class and assigns it to the variable s1 s1 = Square(-340,285.0,100) # Screen size 680 x 570, 0,0 at the center # Invoking the method draw() s1.draw() # Invoking the method bye() s1.bye() main() 16
17 Turtle square_oop_01.py Abaixo temos o resultado da execução do código square_oop_01.py 17
18 Turtle rectangle_oop_01.py O programa rectangle_oop_01.py desenha um retângulo. O código é similar ao usado anteriormente para o quadrado. As diferenças estão em vermelho no código abaixo. from turtle import * class Rectangle(object): # Define a class """A class to draw a rectangle""" def init (self,x,y,size_x,size_y): # Define constructor method self.x = x # x coordinate in pixels self.y = y # y coordinate in pixels self.size_x = size_x # Rectangle side self.size_y = size_y # Rectangle side # Define draw() method def draw(self): aelf.wn = Screen() # Call screen with dimensions 680 x 570, 0,0 at the center self._ = Turtle() # Create a turtle self._ self._.hideturtle() # Hide turtle self._.penup() # Move pen up self._.setx(self.x) # Set up initial position x coordinate self._.sety(self.y) # Set up initial position y coordinate self._.pendown() # Move pen down # Looping through to draw a rectangle for i in range(2): # Repeat twoice self._.forward(self.size_x) # Move forward (draw a line) self._.right(90) # Rotate an angle in degrees self._.forward(self.size_y) # Move forward (draw a line) self._.right(90) # Rotate an angle in degrees # Define bye() method def bye(self): self.wn.exitonclick() # Close when mouse click def main(): # Instantiating an object of the Rectangle() class and assigns it to the variable r1 r1 = Rectangle(-340,285,150,70) # Screen size 680 x 570, 0,0 at the center r1.draw() # Invoking the method draw() r1.bye() # Invoking the method bye() main() 18
19 Turtle rectangle_oop_01.py No retângulo temos dois lados distintos, assim usamos dois atributos, atribuídos às variáveis self.size_x e self.size_y. from turtle import * class Rectangle(object): # Define a class """A class to draw a rectangle""" def init (self,x,y,size_x,size_y): # Define constructor method self.x = x # x coordinate in pixels self.y = y # y coordinate in pixels self.size_x = size_x # Rectangle side self.size_y = size_y # Rectangle side # Define draw() method def draw(self): aelf.wn = Screen() # Call screen with dimensions 680 x 570, 0,0 at the center self._ = Turtle() # Create a turtle self._ self._.hideturtle() # Hide turtle self._.penup() # Move pen up self._.setx(self.x) # Set up initial position x coordinate self._.sety(self.y) # Set up initial position y coordinate self._.pendown() # Move pen down # Looping through to draw a rectangle for i in range(2): # Repeat twoice self._.forward(self.size_x) # Move forward (draw a line) self._.right(90) # Rotate an angle in degrees self._.forward(self.size_y) # Move forward (draw a line) self._.right(90) # Rotate an angle in degrees # Define bye() method def bye(self): self.wn.exitonclick() # Close when mouse click def main(): # Instantiating an object of the Rectangle() class and assigns it to the variable r1 r1 = Rectangle(-340,285,150,70) # Screen size 680 x 570, 0,0 at the center r1.draw() # Invoking the method draw() r1.bye() # Invoking the method bye() main() 19
20 Turtle rectangle_oop_01.py No loop for do método draw() temos que desenhar cada lado aos pares, assim repetimos o processo duas vezes para desenharmos o retângulo. from turtle import * class Rectangle(object): # Define a class """A class to draw a rectangle""" def init (self,x,y,size_x,size_y): # Define constructor method self.x = x # x coordinate in pixels self.y = y # y coordinate in pixels self.size_x = size_x # Rectangle side self.size_y = size_y # Rectangle side # Define draw() method def draw(self): aelf.wn = Screen() # Call screen with dimensions 680 x 570, 0,0 at the center self._ = Turtle() # Create a turtle self._ self._.hideturtle() # Hide turtle self._.penup() # Move pen up self._.setx(self.x) # Set up initial position x coordinate self._.sety(self.y) # Set up initial position y coordinate self._.pendown() # Move pen down # Looping through to draw a rectangle for i in range(2): # Repeat twoice self._.forward(self.size_x) # Move forward (draw a line) self._.right(90) # Rotate an angle in degrees self._.forward(self.size_y) # Move forward (draw a line) self._.right(90) # Rotate an angle in degrees # Define bye() method def bye(self): self.wn.exitonclick() # Close when mouse click def main(): # Instantiating an object of the Rectangle() class and assigns it to the variable r1 r1 = Rectangle(-340,285,150,70) # Screen size 680 x 570, 0,0 at the center r1.draw() # Invoking the method draw() r1.bye() # Invoking the method bye() main() 20
21 Turtle rectangle_oop_01.py Ao criarmos um objeto da classe Rectangle() no programa principal, as informações sobre os lados do retângulo são passadas. from turtle import * class Rectangle(object): # Define a class """A class to draw a rectangle""" def init (self,x,y,size_x,size_y): # Define constructor method self.x = x # x coordinate in pixels self.y = y # y coordinate in pixels self.size_x = size_x # Rectangle side self.size_y = size_y # Rectangle side # Define draw() method def draw(self): aelf.wn = Screen() # Call screen with dimensions 680 x 570, 0,0 at the center self._ = Turtle() # Create a turtle self._ self._.hideturtle() # Hide turtle self._.penup() # Move pen up self._.setx(self.x) # Set up initial position x coordinate self._.sety(self.y) # Set up initial position y coordinate self._.pendown() # Move pen down # Looping through to draw a rectangle for i in range(2): # Repeat twoice self._.forward(self.size_x) # Move forward (draw a line) self._.right(90) # Rotate an angle in degrees self._.forward(self.size_y) # Move forward (draw a line) self._.right(90) # Rotate an angle in degrees # Define bye() method def bye(self): self.wn.exitonclick() # Close when mouse click def main(): # Instantiating an object of the Rectangle() class and assigns it to the variable r1 r1 = Rectangle(-340,285,150,70) # Screen size 680 x 570, 0,0 at the center r1.draw() # Invoking the method draw() r1.bye() # Invoking the method bye() main() 21
22 Turtle rectangle_oop_01.py Abaixo temos o resultado da execução do código rectangle_oop_01.py 22
23 Turtle ellipse_oop_01.py O código ellipse_oop_01.py desenha uma elipse. As coordenadas iniciais, os tamanhos dos semieixos e a cor de preenchimento são definidos como parâmetros. O código é similar aos anteriores, as diferenças estão em vermelho. from turtle import * class Ellipse(object): # Define a class """A class to draw an ellipse""" # Define constructor method def init (self,x,y,size_x,size_y,color): self.x = x # x coordinate in pixels self.y = y # y coordinate in pixels self.size_x = size_x # Ellipse axis self.size_y = size_y # Ellipse axis self.color = color # Filling color # Define draw() method def draw(self): self.wn = Screen() # Call screen with dimensions 680 x 570, 0,0 at the center self._ = Turtle() # Create a turtle self._ self._.penup() # Move pen up self._.setx(self.x) # Set up initial position (x coordinate) self._.sety(self.y) # Set up initial position (y coordinate) self._.pendown() # Move pen down self._.shape("circle") # Draw an ellipse self._.shapesize(self.size_x, self.size_y, 1) # Define size self._.fillcolor(self.color) # Define color # Define bye() method def bye(self): self.wn.exitonclick() # Close when mouse click def main(): # Instantiating an object of the Ellipse() class and assigns it to the variable e1 e1 = Ellipse(0, 0, 10, 10,"blue") # Screen size 680 x 570, 0,0 at the center e1.draw() # Invoking the method draw() e1.bye() # Invoking the method bye() main() 23
24 Turtle ellipse_oop_01.py Às variáveis self.size_x, self.size_y e self.color são atribuídos os valores para os semieixos e a cor de preenchimento, respectivamente. A linha de código self._.shape("circle") define que um círculo será desenhado. from turtle import * class Ellipse(object): # Define a class """A class to draw an ellipse""" # Define constructor method def init (self,x,y,size_x,size_y,color): self.x = x # x coordinate in pixels self.y = y # y coordinate in pixels self.size_x = size_x # Ellipse axis self.size_y = size_y # Ellipse axis self.color = color # Filling color # Define draw() method def draw(self): self.wn = Screen() # Call screen with dimensions 680 x 570, 0,0 at the center self._ = Turtle() # Create a turtle self._ self._.penup() # Move pen up self._.setx(self.x) # Set up initial position (x coordinate) self._.sety(self.y) # Set up initial position (y coordinate) self._.pendown() # Move pen down self._.shape("circle") # Draw an ellipse self._.shapesize(self.size_x, self.size_y, 1) # Define size self._.fillcolor(self.color) # Define color # Define bye() method def bye(self): self.wn.exitonclick() # Close when mouse click def main(): # Instantiating an object of the Ellipse() class and assigns it to the variable e1 e1 = Ellipse(0, 0, 10, 10,"blue") # Screen size 680 x 570, 0,0 at the center e1.draw() # Invoking the method draw() e1.bye() # Invoking the method bye() main() 24
25 Turtle ellipse_oop_01.py Na verdade com a linha de código self._.shapesize(self.size_x, self.size_y, 1) podemos desenhar uma elipse, pois temos a definição dos semieixos. O último parâmetro define a espessura da linha em pixels. from turtle import * class Ellipse(object): # Define a class """A class to draw an ellipse""" # Define constructor method def init (self,x,y,size_x,size_y,color): self.x = x # x coordinate in pixels self.y = y # y coordinate in pixels self.size_x = size_x # Ellipse axis self.size_y = size_y # Ellipse axis self.color = color # Filling color # Define draw() method def draw(self): self.wn = Screen() # Call screen with dimensions 680 x 570, 0,0 at the center self._ = Turtle() # Create a turtle self._ self._.penup() # Move pen up self._.setx(self.x) # Set up initial position (x coordinate) self._.sety(self.y) # Set up initial position (y coordinate) self._.pendown() # Move pen down self._.shape("circle") # Draw an ellipse self._.shapesize(self.size_x, self.size_y, 1) # Define size self._.fillcolor(self.color) # Define color # Define bye() method def bye(self): self.wn.exitonclick() # Close when mouse click def main(): # Instantiating an object of the Ellipse() class and assigns it to the variable e1 e1 = Ellipse(0, 0, 10, 10,"blue") # Screen size 680 x 570, 0,0 at the center e1.draw() # Invoking the method draw() e1.bye() # Invoking the method bye() main() 25
26 Turtle ellipse_oop_01.py A linha de código self._.fillcolor(self.color) define a cor de preenchimento da elipse. No programa principal é criado um objeto da classe Ellipse(). Os tamanhos dos semieixos não estão em pixels, cada unidade vale 0,45 cm. from turtle import * class Ellipse(object): # Define a class """A class to draw an ellipse""" # Define constructor method def init (self,x,y,size_x,size_y,color): self.x = x # x coordinate in pixels self.y = y # y coordinate in pixels self.size_x = size_x # Ellipse axis self.size_y = size_y # Ellipse axis self.color = color # Filling color # Define draw() method def draw(self): self.wn = Screen() # Call screen with dimensions 680 x 570, 0,0 at the center self._ = Turtle() # Create a turtle self._ self._.penup() # Move pen up self._.setx(self.x) # Set up initial position (x coordinate) self._.sety(self.y) # Set up initial position (y coordinate) self._.pendown() # Move pen down self._.shape("circle") # Draw an ellipse self._.shapesize(self.size_x, self.size_y, 1) # Define size self._.fillcolor(self.color) # Define color # Define bye() method def bye(self): self.wn.exitonclick() # Close when mouse click def main(): # Instantiating an object of the Ellipse() class and assigns it to the variable e1 e1 = Ellipse(0, 0, 10, 10,"blue") # Screen size 680 x 570, 0,0 at the center e1.draw() # Invoking the method draw() e1.bye() # Invoking the method bye() main() 26
27 Turtle ellipse_oop_01.py Abaixo temos o resultado da execução do código ellipse_oop_01.py 27
28 Turtle robot5.py No programa robot5.py temos as classes Square(), RectangleI) e Ellipse() que são usadas para montar partes do corpo do robô. Abaixo temos o programa principal. Veja que cada objeto é uma parte do corpo do robô. def main(): head = Square(-42, 250, 84) # Instantiating an object of the Square() class head.draw() # Invoking the method draw() body = Square(-108, 166, 216) # Instantiating an object of the Square() class body.draw() # Invoking the method draw() plataform = Square(-84,-50, 168) # Instantiating an object of the Square() class plataform.draw() # Invoking the method draw() base = Rectangle(-108,-218, 216, 30) # Instantiating an object of the Rectangle() class base.draw() # Invoking the method draw() right_shoulder = Square(-156, 166, 48) # Instantiating an object of the Square() class right_shoulder.draw() # Invoking the method draw() left_shoulder = Square(108, 166, 48) # Instantiating an object of the Square() class left_shoulder.draw() # Invoking the method draw() right_arm = Rectangle(-150,118, 36, 180) # Instantiating an object of the Rectangle() class right_arm.draw() # Invoking the method draw() left_arm = Rectangle(114,118, 36, 180) # Instantiating an object of the Rectangle() class left_arm.draw() # Invoking the method draw() eye = Ellipse(0, 220, 1.0, 2.2,"blue") # Instantiating an object of the Ellipse() class eye.draw() # Invoking the method draw() right_wheel = Ellipse(-80, -240, 2.2, 0.8,"black") # Instantiating an object of the Ellipse() class right_wheel.draw() # Invoking the method draw() left_wheel = Ellipse(80, -240, 2.2, 0.8,"black") # Instantiating an object of the Ellipse() class left_wheel.draw() # Invoking the method draw() right_claw = Ellipse(-133, -60, 2.2, 1.2,"white") # Instantiating an object of the Ellipse() class right_claw.draw() # Invoking the method draw() left_claw = Ellipse(133, -60, 2.2, 1.2,"white") # Instantiating an object of the Ellipse() class left_claw.draw() # Invoking the method draw() plataform.bye() # Invoking the method bye() main() 28
29 Turtle robot5.py Abaixo temos o resultado da execução do código robot5.py 29
30 Evolução, um Paradigma Computacional A Teoria da Evolução de Darwin tem papel fundamental no entendimento da evolução, e seu sucesso como teoria científica fez Theodosius Dobzhansky ( ) a propor: Nothing in Biology makes sense except in the light of evolution. Foto feita por Linus S. Azevedo (4/2/2011). Natural History Museum, London-UK. Viste a página do museu: Esta proposição tem sido usada como introdução em muitos livros e seminários, para destacar a importância da teoria de Darwin. Embora sistemas biológicos são normalmente difíceis de se serem submetidos à modelagem computacional, os conceitos da evolução são simples, sendo a seleção natural o conceito mais importante. 30
31 Evolução, um Paradigma Computacional Normalmente os críticos da teoria de Darwin compartilham dois aspectos em comum. 1) Total desconhecimento do método científico. Toda teoria científica é uma modelagem da natureza, usando de um arcabouço teórico para explicar fenômenos naturais. Como tal pode ser aprimorada, sem contudo, em essência, está errada. 2) Desconhecimento da biologia molecular, onde aspectos moleculares da vida revelam a abrangência da evolução, que manifesta-se no nível molecular. Foto feita por Linus S. Azevedo (4/2/2011). Natural History Museum, London-UK. Viste a página do museu: 31
32 Otimização C d CD d AD d AC A D d BC d AB d BD B As ideias da evolução têm sido usadas na otimização de soluções de problemas específicos. A otimização é um método computacional (algoritmo), que procura achar as condições ótimas para um dado problema. Para evitar uma abordagem mais matemática, vamos ilustrar a otimização com um exemplo, chamado problema do caixeiro viajante (travelling salesman problem). Neste problema temos um vendedor (caixeiro viajante), que tem que passar por diversas cidades, digamos quatro cidades. O objetivo do problema é achar o menor caminho possível, que leva o caixeiro viajante a passar pelas quatro cidades, sem repetir nenhuma cidade. Sabemos as distâncias entre todos os pares de cidades, d AB por exemplo, assim a solução ótima (otimizada) é aquela que leva a um menor percurso total. Este32é o típico problema de otimização.
33 Conceitos Básicos sobre Evolução Indivíduo População A cor das joaninha é um traço do fenótipo Apresentaremos alguns conceitos da evolução usados como inspiração para os algoritmos evolucionários. Vamos considerar um ambiente que pode sustentar só um número restrito de indivíduos (joaninhas nas figuras aqui), a natureza seleciona aquelas joaninhas que lutam pelos os recursos limitados de forma mais eficiente, em outras palavras, a seleção natural dos indivíduos mais adaptados da população (as joaninhas mais adaptadas). Outro conceito básico da teoria de Darwin é a variação do fenótipo entre indivíduos da população. Traços do fenótipo são aqueles aspectos físicos e de comportamento de um indivíduo, que estão relacionados com sua reação ao ambiente, por exemplo, a cor da joaninha. Os traços do fenótipo determinam seu ajuste (fitness) ao ambiente. 33
34 Conceitos Básicos sobre Evolução Indivíduo População A cor das joaninha é um traço do fenótipo Referência: HOLLAND JH. Adaptation in Natural and Artificial Systems. MIR Press. Cambridge MA, Numa população, cada indivíduo mostra um conjunto de traços do fenótipo exclusivos, que estão continuamente sendo testados pelo ambiente [HOLLAND, 1992]. O ajuste de cada indivíduo pode ser quantificado numa análise matemática do sistema biológico, os indivíduos com maior sucesso apresentam um ajuste mais alto, ou seja, uma função ajuste (fitness function) mais alta. Veja que estamos modelando nosso sistema biológico para capturar os aspectos essenciais do sistema, que possibilitarão o seu uso para resolver problemas de otimização. Colocando de outra forma, estamos simplificando o sistema biológico, para extrairmos suas características mais fundamentais, como a seleção natural. 34
35 Conceitos Básicos sobre Evolução População inicial da primeira geração Resumindo os conceitos básicos, uma população é um conjunto de indivíduos, cada um sendo considerado uma unidade de seleção. Seu sucesso depende de o quão bem adaptado ao ambiente eles estão. Indivíduos mais bem adaptados apresentam probabilidade mais alta de gerar descendentes, e, mutações ocasionais dão origem a novos indivíduos que serão testados pelo ambiente. Assim, de uma geração para outra, há variação no genótipo (conjunto de genes) da população. Cada gene codifica uma proteína, e pode ser responsável por uma característica do indivíduo, ou um conjunto de genes ser o responsável por uma característica. Na figura vemos claramente diferenças nos padrões de cores, embora alguns indivíduos tenham sobrevivido de uma geração para outra sem alterações. População inicial da segunda geração 35
36 Conceitos Básicos sobre Evolução Ajuste y x Superfície adaptativa (adaptive surface) O processo de evolução pode ser visualizado usando uma superfície adaptativa (adaptive surface). No gráfico ao lado, a altura z representa a função ajuste (fitness function), também chamada de função escore (scoring function). Aqui, quanto maior a altura na superfície, melhor o ajuste do indivíduo. Os eixos x-y representam todas as combinações possíveis de dois traços do fenótipo. Cada ponto na superfície representa um indivíduo, com a combinação de traços do fenótipo representados pelo valores de x e y. Para exemplificar, o eixo x pode representar a capacidade de mimetismo (camuflagem) das joaninhas e o eixo y a capacidade de escalar obstáculos. A combinação de x e y dará a função ajuste. Os picos mais altos na figura representam os indivíduos mais bem adaptados. 36
37 Conceitos Básicos sobre Evolução Máximo global Máximo local Ajuste y x Superfície adaptativa (adaptive surface) Os vales indicam indivíduos menos adaptados ao ambiente. Cada pico na superfície indica um ponto ótimo local (ou simplesmente máximo local). O pico mais alto o ponto de ótimo global (ou máximo global). A partir desta analogia, está clara as implicações da evolução em problemas de otimização, que podemos pensar que é representado pelo ponto de ótimo global. Num problema de otimização, como o do caixeiro viajante, nós podemos ter uma lista de soluções para o problema (diferentes rotas) e tentamos achar a melhor solução. O conjunto de soluções possíveis é chamado de espaço de busca, a superfície adaptativa, da figura ao lado, é uma representação gráfica do espaço de busca. 37
38 Números Binários = Referência: GOLDBERG DE. Genetic Algorithms in Search, Optimization, and Machine Learning. Addison Wesley Longman, Ins.,Indiana, USA, Um dos primeiros algoritmos evolucionários foi o algoritmo genético (genetic algorithm). Na abordagem original dos algoritmos genéticos, foram usados números binários para a representação de cromossomos [GOLDENBERG, 1989]. Faremos uma introdução (ou revisão) da matemática básica envolvida na conversão de um sistema para outro. Um número binário é um número que usa somente os algarismos zero e um, para representar uma quantidade. Por exemplo, 101 em binário representa 5 no decimal. Veremos exemplos para esclarecer o processo. Vamos converter 75 em decimal para sua representação binária. Para isto temos que dividir continuamente 75 por 2, o resto da divisão é o último algarismo do número binário equivalente ao 75, como mostrado ao lado. O último resultado da divisão 1 é o algarismo mais significativo do número binário. 38
39 Números Binários Para converter de binário (subscrito 2) de volta para decimal (subscrito 10), é ainda mais fácil. Temos que multiplicar 0 ou 1 por 2 elevado à potencia, que é a posição do número binário, começando na posição zero no lado direito, até o último número na sequência, como segue: = = = Como ilustrado acima, somamos os resultados parciais das multiplicações, o resultado final é 75, o número na base decimal. 39
40 Números Binários Agora que sabemos como operar com números binários, usaremos tais números nos algoritmos genéticos. Em muitos algoritmos genéticos os indivíduos são representados por números binários, tal método tem o benefício de ser rápido na aplicação dos operadores genéticos, como mutação e crossover. Num número binário a mutação é simplesmente uma mudança de 0 para 1 ou vice-versa. A essência de um algoritmo genético é o uso das ideias da evolução, por isso são classificados como algoritmo evolucionário. 75 =
41 Números Binários Assim, a implementação de um algoritmo genético usa as ideias da evolução de Darwin, de forma que os indivíduos de uma dada população são submetidos aos princípios da evolução, tais como, seleção natural, cruzamento (crossover) e mutação. Veja abaixo, um indivíduo será representado por uma string binária. Uma string binária é uma sequência de 0 e 1. No algoritmo genético a string binária é convertida num número decimal, usando as operações matemáticas já vistas. String binária Decimal relacionado à string binária 1777 Representação do genoma de um indivíduo na abordagem de algoritmo genético 41
42 Algoritmo Genético Um algoritmo genético típico usa três operadores para manipular uma população de indivíduos gerados aleatoriamente, são eles: seleção, crossover e mutação. Um diagrama esquemático dá uma visão geral destes passos para uma iteração (geração). A população inicial é formada de strings binárias geradas aleatoriamente, os números indicados à esquerda. Strings binárias (populatção incial) Strings binárias (Nova população) Operador seleção Operador crossover Operador mutação
43 Algoritmo Genético O operador seleção é uma implementação computacional da seleção natural. É uma tentativa de aplicar a pressão evolucionária sobre indivíduos de uma população. Indivíduos com função ajuste (ou função escore) baixa serão descartados. Os indivíduos de mais alto valor de função ajuste apresentam maior probabilidade de sobreviver. Os sobreviventes farão parte da população, que começará a nova geração (iteração). Strings binárias (populatção incial) Strings binárias (Nova população) Operador seleção Operador crossover Operador mutação
44 Algoritmo Genético O operador crossover faz com que os indivíduos (strings binárias) troquem sua informação genética, de forma análoga à reprodução sexuada. O operador crossover é também conhecido como operador recombinação Uma forma de implementar tal operador, é selecionar pares de indivíduos promovidos após a etapa de seleção (pais). Depois selecionamos aleatoriamente um local único (locus) (indicado pela barra vermelha vertical), dentro da string binária. Por último trocamos todos os dígitos à direita deste locus entre os dois pais, conforme indicado abaixo. Pais Locus Crossover Descendentes Locus 44
45 Algoritmo Genético O operador crossover é aplicado a um par de pais, parar gerar um par de novas strings binárias (descendentes). Um par de pais será submetido ao operador crossover, se e somente se, um número aleatório (Rn) for menor que a probabilidade de crossover (Pc). Rn está no intervalo (0,1], e um típico valor de Pc está no intervalo [0,4, 0,9]. Gera um número aleatório (Rn) Pais Locus Descendentes Rn<=Pc? Não Sim Crossover Escolha novo par de pais Locus 45
46 Algoritmo Genético Para ilustrar os princípios do algoritmo genético, vamos resolver o seguinte problema simples, qual o número entre 0 e 4095 maximiza a função quadrática (f(x)=x 2 )? OK, não precisamos de um algoritmo genético para saber a resposta deste problema, tal problema é só para ilustrar o algoritmo. Na implementação deste algoritmo temos strings binárias de comprimento 12 ( = ). Assim, vamos gerar números aleatórios entre 0 e 4095, como mostrado parcialmente na tabela abaixo. Esta faixa de números é nosso espaço de busca. Este algoritmo está discutido na página 12 do livro de COLEY, David A. An Introduction to Genetic Algorithms for Scientists and Engineers. Singapore: World Scientific Publishing Co. Pte. Ltd., p. String binária Decimal 46
47 Implementação de um Algoritmo Genético Simples Neste algoritmo simples, o operador seleção escolherá a melhor metade da população. O algoritmo usa a função quadrática como função ajuste (fitness function). Inicialmente temos que gerar a população de forma aleatória. Tal população é formada por strings binárias (genótipo). Essas strings representam os cromossomos no jargão dos algoritmos genéticos. As strings binárias serão convertidas em números decimais, que serão usados para o cálculo da função quadrática. A função quadrática é nossa função ajuste. Nós classificamos a metade dos melhores indivíduos da população e, então, aplicamos o operador crossover. Estes novos indivíduos gerados pelo operador crossover serão submetidos ao operador mutação. Na mutação nem todos os indivíduos serão submetidos a este operador, só aqueles que passarem no critério de probabilidade de mutação (Pm). Na implementação do algoritmo genético, usaremos o critério de número de iterações (gerações), como critério de parada. Um típico conjunto de entrada para tal algoritmo é o seguinte: Population size (tamanho da população): Maximum number of iterations (Número máximo de iterações): Probability of crossover (probabilidade de crossover): Length of strings (tamanho das strings): Probability of mutation (probabilidade de mutação): 47
48 Turtle sga01.py Gera uma população aleatória de strings binárias Ordena aleatoriamente os melhores pais Converte cada string binária em um número decimal Calcula a função ajuste para cada indivíduo Seleciona parte da população para seguir Seleciona pares de pais seguindo uma ordem aleatória. Faz cruzamento e atualiza população Mutação dos descendentes (operador mutação) Critério de parada satisfeito? Sim Não Retorna os resultados 48
49 Initialização A B D C Inicialização. Números aleatórios são gerados (genótipo), para representar indivíduos numa população. Em algoritmos genéticos tais números são chamados cromossomos. Para cada cromossomo uma função ajuste (função escore) será calculada. 49
50 Initialização A B D C Operador seleção (A). Agora um dos maiores processos da evolução é aplicado. Os cromossomos gerados aleatoriamente são selecionados, usando como critério a função ajuste. Esta função indica o quão adaptado um indivíduo está. Os indivíduos 50 selecionados são chamados pais.
51 Initialização A B D C Operador crossover (B). Os indivíduos selecionados (pais) podem gerar descendentes (filhos). Os pais são gerados aleatoriamente e seus cromossomos são combinados para gerar filhos. A posição de corte é chamada locus, sendo gerada 51 aleatoriamente também.
52 Initialização A B D C Operador mutação (C). É permitido que os descendentes sofram mutação. Em bactéria uma taxa de mutações por genoma por geração é observada. Aqui, o operador mutação possibilita a diversidade genética na simulação da evolução. 52
53 Initialização A B D C Ao final, os indivíduos (pais mais descendentes) passam a formar a população inicial para um novo ciclo. Com objetivo de manter a abordagem biológica, este ciclo é chamado de geração. Em computação um ciclo é chamado de iteração. 53
54 Initialização A B D C Este ciclo está completo e todo o processo é repetido até que um critério de parada seja satisfeito, como por exemplo, o número de iterações (gerações) máximo foi atingido. 54
55 Initialização A B D C Agora temos uma visão geral de como os algoritmos genéticos funcionam. Vamos ver alguns conceitos de como implementá-los. Os indivíduos nesta população podem ser representados por 0 e 1, ou seja, uma string binária. 55
56 Initialização Strings binárias Na inicialização, números aleatórios são gerados para representar cada cromossomo na população. Cada linha (string binária) é um cromossomo de um indivíduo (equivalentes às joaninhas de cores diferentes). 56
57 Initialização A Decimais (x) Strings binárias Converte binário para decimal Função ajuste ou escore Decimals (x) Seleção dos melhores resultados f = x Strings binárias Seleção. Para ilustrar a evolução, vamos considerar que queremos achar o máximo da função quadrática para um inteiro entre 0 e Agora calculamos a função (f=x 2 ) para cada cromossomo. As strings binárias são convertidas para decimal e, então, calculamos a função. Selecionamos a melhor metade da população, segundo 57 a função ajuste.
58 Initialização A B Strings binárias Strings de posição aleatória Nesta etapa temos o operador crossover. Somente os melhores pais são submetidos ao crossover, (recombinação). Inicialmente as strings binárias são aleatoriamente posicionadas e, então, a posição de crossover é escolhida. Esta posição indica onde a troca dos cromossomos acontecerá. Os novos cromossomos agora fazem parte da população, junto como os melhores pais. Strings filhas Strings pais
59 Initialização A B D O operador mutação é usualmente aplicado a um bit da string, mudando-o de 0 para 1, ou vice-versa. Na maioria das aplicações, é sugerida uma probabilidade de mutação (Pm) de 0,001, ou seja, uma mutação para cada 1000 bits. C Strings filhas Strings pais
60 Initialização A B D Há diversas formas de implementar o operador mutação, uma forma é aplicá-lo a um bit (número 0 ou 1 na string) na posição 1/pm e gerar um número aleatório, se o número aleatório é maior que 0,5 muda o bit, caso contrário deixa como está. C Strings filhas Strings pais
61 Initialização O operador mutação funciona para aumentar a diversidade genética, evitando que a população fique confinada a um máximo local. A B Strings filhas Strings pais D Mutação C Strings filhas Strings pais
62 Strings binárias Depois da aplicação do operador mutação, os indivíduos tornam-se a população de uma nova iteração. O ciclo é repetido até que um critério de parada seja satisfeito. Podemos fixar o número de iterações, ou outro critério de parada. Um outro critério de parada possível está baseado na variação da população, ou seja, se os indivíduos de uma geração não estão variando com relação à geração anterior. Quando não há variação durante um certo número de gerações, não faz sentido continuar a simulação, pois não iremos gerar indivíduos que gerem melhores funções ajuste, assim podemos parar a simulação
63 Turtle GA01.py Abaixo temos a função main() do programa GA01.py que implementa o algoritmo genético simples para resolução do problema de maximização da função x 2. Nesta implementação não usamos programação orientada a objeto. Na função main() do programa GA01.py inicialmente definimos os valores da simulação. def main(): # 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 # Call gen_bin_strings() pop_in = gen_bin_strings(pop_size,len_str) # Call algo01_coley() pop = algo01_coley(pop_in,pop_size,max_iter,p_cross,len_str,p_mut) # Show final population print("\nfinal population") for line in pop: print(line) main() 63
64 Turtle GA01.py Em seguida é chamada a função gen_bin_strings() que gera as strings binárias. As strings retornam na forma de uma lista que é atribuída à variável pop_in. def main(): # 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 # Call gen_bin_strings() pop_in = gen_bin_strings(pop_size,len_str) # Call algo01_coley() pop = algo01_coley(pop_in,pop_size,max_iter,p_cross,len_str,p_mut) # Show final population print("\nfinal population") for line in pop: print(line) main() 64
2018 Dr. Walter F. de Azevedo Jr. azevedolab.net
2018 Dr. Walter F. de Azevedo Jr. azevedolab.net 1 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
Evolução Diferencial e Sua Aplicação em Docking do Sistema Proteína-Ligante Prof. Dr. Walter F. de Azevedo Jr.
2017 Dr. Walter F. de Azevedo Jr. 110100111010 101101011100 100110011000 1111111100111 101101011010 100111100111 111110011000 110100111100 Evolução Diferencial e Sua Aplicação em Docking do Sistema Proteína-Ligante
2015 Dr. Walter F. de Azevedo Jr.
2015 Dr. Walter F. de Azevedo Jr. 110100111010 101101011100 100110011000 1111111100111 101101011010 100111100111 111110011000 110100111100 Evolução Diferencial e Sua Aplicação em Docking do Sistema Proteína-Ligante
2016 Dr. Walter F. de Azevedo Jr.
2016 Dr. Walter F. de Azevedo Jr. 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000111111111110001100000000000 000000000001111111111111111111000000001 000000000111111111111111111111111000000
Biofísica. Métodos Teóricos em Biofísica Algoritmos Evolucionários. Prof. Dr. Walter F. de Azevedo Jr Dr. Walter F. de Azevedo Jr.
2015 Dr. Walter F. de Azevedo Jr. Biofísica Métodos Teóricos em Biofísica Algoritmos Evolucionários Prof. Dr. Walter F. de Azevedo Jr. 110100111010 101101011100 100110011000 1111111100111 101101011010
Algoritmos Genéticos. Pontos fracos dos métodos tradicionais. Características de alguns problemas. Tamanho do espaço de busca- Ex. caixeiro viajante:
Algoritmos Genéticos Prof. Luis Otavio Alvares INE/UFSC Características de alguns problemas Tamanho do espaço de busca- Ex. caixeiro viajante: 10 cidades: 181.000 soluções 20 cidades: 10.000.000.000.000
Modelos Evolucionários e Tratamento de Incertezas
Ciência da Computação Modelos Evolucionários e Tratamento de Incertezas Aula 01 Computação Evolucionária Max Pereira Motivação Se há uma multiplicidade impressionante de algoritmos para solução de problemas,
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
Algoritmos Genéticos. Estéfane G. M. de Lacerda DCA/UFRN Outubro/2008
Estéfane G. M. de Lacerda DCA/UFRN Outubro/2008 Introdução São técnicas de busca e otimização. É a metáfora da teoria da evolução das espécies iniciada pelo Fisiologista e Naturalista inglês Charles Darwin.
Inteligência Artificial. Algoritmos Genéticos. Aula I Introdução
Universidade Estadual do Oeste do Paraná Curso de Bacharelado em Ciência da Computação Inteligência Artificial Algoritmos Genéticos Aula I Introdução Roteiro Introdução Computação Evolutiva Algoritmos
Docking de Ligantes em Proteínas
110100111010 101101011100 100110011000 1111111100111 101101011010 100111100111 111110011000 110100111100 Docking de Ligantes em Proteínas Prof. Dr. Walter F. de Azevedo Jr. walter.junior@pucrs.br ou walter@azevedolab.net
Tópicos Especiais em Informática Fatec Indaiatuba
Prof. Dilermando Piva Jr. ((Compilação de diversas fontes na Internet)) Principal motivação para o estudo da computação evolutiva Otimização de processos complexo e que possuem um grande número de variáveis
INF 1771 Inteligência Artificial
INF 1771 Inteligência Artificial Aula 06 Algoritmos Genéticos Edirlei Soares de Lima Algoritmos Genéticos Método de busca local. Boa abordagem para lidar com espaços de busca muito
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
Algoritmos Genéticos. Texto base: Stuart Russel e Peter Norving - Inteligência Artificial
Algoritmos Genéticos Texto base: Stuart Russel e Peter Norving - Inteligência Artificial junho/2007 Algoritmo Genético Uma variante da busca em feixe estocástica Estado sucessor gerado pela combinação
INF 1771 Inteligência Artificial
Edirlei Soares de Lima INF 1771 Inteligência Artificial Aula 04 Algoritmos Genéticos Introdução Algoritmos genéticos são bons para abordar espaços de buscas muito grandes e navegálos
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
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...]
Computação Evolutiva Eduardo do Valle Simões Renato Tinós ICMC - USP
Computação Evolutiva Eduardo do Valle Simões Renato Tinós ICMC - USP 1 Principais Tópicos Introdução Evolução Natural Algoritmos Genéticos Aplicações Conclusão 2 Introdução http://www.formula-um.com/ Como
Algoritmos Genéticos. Princípio de Seleção Natural. Sub-áreas da Computação Evolutiva. Idéias básicas da CE. Computação Evolutiva
Computação Evolutiva Algoritmos Genéticos A computação evolutiva (CE) é uma área da ciência da computação que abrange modelos computacionais inspirados na Teoria da Evolução das Espécies, essencialmente
Algoritmo Genético. Inteligência Artificial. Professor: Rosalvo Ferreira de Oliveira Neto
Algoritmo Genético Inteligência Artificial Professor: Rosalvo Ferreira de Oliveira Neto Estrutura 1. Introdução 2. Conceitos Básicos 3. Aplicações 4. Algoritmo 5. Exemplo Introdução São técnicas de busca
3. Resolução de problemas por meio de busca
Inteligência Artificial - IBM1024 3. Resolução de problemas por meio de busca Prof. Renato Tinós Local: Depto. de Computação e Matemática (FFCLRP/USP) 1 Principais Tópicos 3. Resolução de problemas por
3 Algoritmos Genéticos
Técnicas de Inteligência Computacional 33 3 Algoritmos Genéticos Este capítulo resume os principais conceitos sobre o algoritmo evolucionário empregado nesta dissertação. É apresentada uma breve explicação
ALGORITMOS GENÉTICOS. Adair Santa Catarina Curso de Ciência da Computação Unioeste Campus de Cascavel PR
ALGORITMOS GENÉTICOS Adair Santa Catarina Curso de Ciência da Computação Unioeste Campus de Cascavel PR Fev/2018 Introdução Algoritmos Genéticos são algoritmos heurísticos de busca, que utilizam regras
Otimização. Algoritmos Genéticos. Teoria da Evolução. Otimização
Algoritmos Genéticos Otimização São técnicas de busca e otimização. É a metáfora da teoria da evolução das espécies iniciada pelo Fisiologista e Naturalista inglês Charles Darwin. Desenvolvido por John
UMA INTRODUÇÃO AOS ALGORITMOS GENETICOS
UMA INTRODUÇÃO AOS ALGORITMOS GENETICOS Uma visão geral dos GAs Um algoritmo genético é uma classe de algoritmo de busca. O algoritmo procura uma solução dentro de um espaço para um problema de otimização.
Introdução a Algoritmos Genéticos
Introdução a Algoritmos Genéticos Tiago da Conceição Mota Laboratório de Inteligência Computacional Núcleo de Computação Eletrônica Universidade Federal do Rio de Janeiro Outubro de 2007 O Que São? Busca
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)
Computação Evolutiva. Computação Evolutiva. Principais Tópicos. Evolução natural. Introdução. Evolução natural
Computação Evolutiva Eduardo do Valle Simões Renato Tinós ICMC - USP Principais Tópicos Introdução Evolução Natural Algoritmos Genéticos Aplicações Conclusão 1 2 Introdução Evolução natural http://www.formula-um.com/
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
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
Algoritmos Genéticos
Algoritmos Genéticos Roteiro Introdução Algoritmos Genéticos Otimização Representação Seleção Operadores Genéticos Aplicação Caixeiro Viajante Introdução Algoritmos Genéticos (AGs), são métodos de otimização
Inteligência Artificial
Inteligência Artificial Prof. Kléber de Oliveira Andrade pdjkleber@gmail.com Algoritmos Genéticos Conteúdo Introdução O Algoritmo Genético Binário Noções de Otimização O Algoritmo Genético com Parâmetros
Inteligência Artificial
Inteligência Artificial Aula 6 Algoritmos Genéticos M.e Guylerme Velasco Roteiro Introdução Otimização Algoritmos Genéticos Representação Seleção Operadores Geneticos Aplicação Caixeiro Viajante Introdução
Computação Evolutiva. Prof. Eduardo R. Hruschka (Slides baseados nos originais do Prof. André C. P. L. F. de Carvalho)
Computação Evolutiva Prof. Eduardo R. Hruschka (Slides baseados nos originais do Prof. André C. P. L. F. de Carvalho) Principais Tópicos Computação Evolutiva Algoritmos Genéticos Codificação Função de
Computação Evolutiva. Prof. Eduardo R. Hruschka (Slides baseados nos originais do Prof. André C. P. L. F. de Carvalho)
Computação Evolutiva Prof. Eduardo R. Hruschka (Slides baseados nos originais do Prof. André C. P. L. F. de Carvalho) Principais Tópicos Computação Evolutiva Algoritmos Genéticos Codificação Função de
Max Pereira. Inteligência Artificial
Max Pereira Inteligência Artificial Algoritmos Genéticos Algoritmos Genéticos São técnicas de busca e otimização. Uma metáfora da teoria da evolução das espécies iniciada pelo Naturalista inglês Charles
Algoritmo Genético. Teoria da Evolução Princípio seguido pelos AGs
Algoritmo Genético Técnica de busca e otimização. Metáfora da teoria da evolução das espécies iniciada pelo Fisiologista e Naturalista inglês Charles Darwin. Desenvolvido por John Holland (1975) e seus
Algoritmos Genéticos. 1 Semestre de Cleber Zanchettin UFPE - Universidade Federal de Pernambuco CIn - Centro de Informática
Algoritmos Genéticos 1 Semestre de 2015 Cleber Zanchettin UFPE - Universidade Federal de Pernambuco CIn - Centro de Informática 1 2 Introdução Darwin Naturalistas: cada espécie havia sido criada separadamente
Pós-Graduação em Engenharia de Automação Industrial SISTEMAS INTELIGENTES PARA AUTOMAÇÃO
Pós-Graduação em Engenharia de Automação Industrial SISTEMAS INTELIGENTES PARA AUTOMAÇÃO AULA 06 Algoritmos Genéticos Sumário Introdução Inteligência Artificial (IA) Algoritmos Genéticos Aplicações de
Algoritmos Genéticos
Algoritmos Genéticos Introdução Um Algoritmo Genético (AG), conceitualmente, segue passos inspirados no processo biológico de evolução natural segundo a teoria de Darwin Algoritmos Genéticos seguem a idéia
GA Conceitos Básicos. Capítulo 3 Prof. Ricardo Linden
GA Conceitos Básicos Capítulo 3 Prof. Ricardo Linden Algoritmos Evolucionários Algoritmos evolucionários usam modelos computacionais dos processos naturais de evolução como uma ferramenta para resolver
Metahuerísticas: Algoritmos Genéticos. Sistemas de Informação/Ciências da Computação UNISUL Aran Bey Tcholakian Morales, Dr. Eng.
Metahuerísticas: Algoritmos Genéticos Sistemas de Informação/Ciências da Computação UNISUL Aran Bey Tcholakian Morales, Dr. Eng. (Apostila 8) Meta-heurísticas Classificação de métodos heurísticos: os métodos
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
Métodos de Busca. Inteligência Artificial. Algoritmos Genéticos. Algoritmos Evolucionários. Prof. Ms. Luiz Alberto Contato:
Inteligência Artificial Prof. Ms. Luiz Alberto Contato: lasf.bel@gmail.com Métodos de Busca Busca Cega ou Exaustiva: Não sabe qual o melhor nó da fronteira a ser expandido. Apenas distingue o estado objetivo
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
Créditos. Introdução a Sistemas Inteligentes. Agenda Introdução Breve Histórico. Introdução. Introdução aos Algoritmos Evolutivos
Introdução a Sistemas Inteligentes Introdução aos Algoritmos Evolutivos Créditos Este material consiste de adaptações e extensões dos originais gentilmente cedidos: pelo Prof. Dr. Eduardo Raul Hruschka
Otimização. Unidade 6: Algoritmo Genético. Jaime Arturo Ramírez. 7. Teoria do processo evolutivo num GA. 8. Aspectos avançados
Otimização Jaime Arturo Ramírez Conteúdo 1. Introdução 2. Analogia de mecanismos de seleção natural com sistemas artificiais 3. Algoritmo genético modelo 4. Um GA simples 5. Representação, genes e cromossomos
Algoritmos Evolutivos para Otimização
Algoritmos Evolutivos para Otimização A área de aplicação que tem recebido mais atenção é a otimização. Uma das razões é que existem uma variedade de problemas de otimização e a maioria deles sem solução
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
Diâmetro da Pizza (cm) Número de Coberturas Preço (R$) 1 15,0 2 24, ,0 1 31, ,0 0 45, ,0 2 61, ,0 0 63,00
azevedolab.net 1 SciKit-Learn (Regressão Linear Múltipla) www.python.org Vimos anteriormente a análise dos conjuntos treino e teste. Índice do Dado do Conjunto Treino Diâmetro da Pizza (cm) Número de Coberturas
ESTUDO DOS PARAMETROS DE UM ALGORITMO GENÉTICO PARA POSTERIOR USO NA SOLUÇÃO DE PROBLEMAS DO TIPO JOB-SHOP
ESTUDO DOS PARAMETROS DE UM ALGORITMO GENÉTICO PARA POSTERIOR USO NA SOLUÇÃO DE PROBLEMAS DO TIPO JOB-SHOP Gilson Rogério Batista, Gideon Villar Leandro Universidade Regional do Noroeste do Estado do Rio
Algoritmos Genéticos
Universidade Federal do Paraná (UFPR) Bacharelado em Informática Biomédica Algoritmos Genéticos David Menotti www.inf.ufpr.br/menotti/ci171-182 Hoje Algoritmos Genéticos 2 Objetivos Introduzir os principais
INF 1771 Inteligência Artificial
INF 1771 Inteligência Artificial Aula 06 Algoritmos Genéticos Prof. Augusto Baffa Métodos de Busca Busca Cega ou Exaustiva: Não sabe qual o melhor nó da fronteira a ser expandido.
Sistemas Inteligentes if684. Germano Vasconcelos Página da Disciplina:
Sistemas Inteligentes if684 Germano Vasconcelos gcv@cin.ufpe.br Página da Disciplina: www.cin.ufpe.br/~îf684/ec 1 1 Algoritmos Genéticos 2 Algoritmos Genéticos n Técnicas de busca e otimização n Metáfora
4 Implementação Computacional
4 Implementação Computacional 4.1. Introdução Neste capítulo é apresentada a formulação matemática do problema de otimização da disposição das linhas de ancoragem para minimizar os deslocamentos (offsets)
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()
Breve Avaliação de Parâmetros básicos de Algoritmos Genéticos
https://eventos.utfpr.edu.br//sicite/sicite17/index Breve Avaliação de Parâmetros básicos de Algoritmos Genéticos RESUMO Stéfanie Caroline Pereira Dekker stefanie.c.dekker@gmail.com Universidade Tecnológica
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
3 Algoritmos Genéticos
Algoritmos Genéticos Algoritmos Genéticos (AGs) constituem um mecanismo de busca adaptativa que se baseia no princípio Darwiniano de seleção natural e reprodução genética [101]. AGs são tipicamente empregados
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
Fundamentos de Arquiteturas de Computadores
Fundamentos de Arquiteturas de Computadores Cristina Boeres Instituto de Computação (UFF) Conversões Entre Bases Numéricas Material de Fernanda Passos (UFF) Conversões Entre Bases Numéricas FAC 1 / 42
Introdução aos Algoritmos Genéticos
Introdução aos Algoritmos Genéticos Prof. Matheus Giovanni Pires EXA 868 Inteligência Artificial Não-Simbólica B Universidade Estadual de Feira de Santana 2 Algoritmos Genéticos: Introdução Introduzidos
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
11/1/2012. Agenda. Classe de problemas de interesse. Busca Local. Busca Local. Exemplo de Espaço de Estados
Agenda PCS / PCS 09 Inteligência Artificial Prof. Dr. Jaime Simão Sichman Profa. Dra. Anna Helena Reali Costa Busca Local e Problemas de Otimização. Introdução. Busca Local I. Subida da Encosta (Hill-Climbing)
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
Exercício 2 - modelagem básica de peça.
Exercício 2 - modelagem básica de peça. Abra um arquivo novo, escolha o template de peça. Por padrão, o template já esta em milímetros. Escolha o plano superior como mostrado na imagem abaixo: Agora na
Aprendizado Evolutivo: Introdução aos Algoritmos Genéticos
Aprendizado Evolutivo: Introdução aos Algoritmos Genéticos SCC-230 Inteligência Artificial Thiago A. S. Pardo Solange O. Rezende 1 Computação Evolutiva (CE) Trata de sistemas para a resolução de problemas
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
Aplicação da Metaheurística Algoritmos Genéticos na solução do problema das n Rainhas
Aplicação da Metaheurística Algoritmos Genéticos na solução do problema das n Rainhas Resumo Gardiego Luiz da Silva 1 Henrique Faria de Oliveira 2 Faculdade
Nesta aula... 1 Variáveis, Expressões, Instruções. 2 Desvio: códigos de carateres. 3 Módulos
Nesta aula... Variáveis, Expressões, Instruções 1 Variáveis, Expressões, Instruções 2 3 Operadores e Operandos Ordem das operações P parêntesis E exponenciação MD multiplicação, divisão AS adição, subtracção
4 Sistema de Identificação de Parâmetros em Dados Sísmicos por Algoritmos Genéticos
Genéticos 39 4 Sistema de Identificação de Parâmetros em Dados Sísmicos por Algoritmos Genéticos Neste capítulo são abordadas as especificações de cada módulo e o Algoritmo Genético que compõem o modelo
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
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,
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
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
Algoritmos Evolutivos Canônicos
Algoritmos Evolutivos Canônicos Como representar os indivíduos Vetor de comprimento fixo com L características escolhidas previamente. Ex.: Definição
ALGORITMO GENÉTICO COMO REPRESENTAÇÃO DAS MUTAÇÕES NA BIOLOGIA
Patrocínio, MG, outubro de 2016 ENCONTRO DE PESQUISA & EXTENSÃO, 3., 2016, Patrocínio. Anais... Patrocínio: IFTM, 2016. ALGORITMO GENÉTICO COMO REPRESENTAÇÃO DAS MUTAÇÕES NA BIOLOGIA Igor Acassio Melo
3 Otimização Evolucionária de Problemas com Restrição
3 Otimização Evolucionária de Problemas com Restrição 3.1. Introdução Este capítulo resume os principais conceitos sobre os algoritmos evolucionários empregados nesta dissertação. Primeiramente, se fornece
Agentes Adaptativos. Introdução
Agentes Adaptativos Capítulo 6: Costa, E. e Simões, A. (2015). Inteligência Artificial Fundamentos e Aplicações, 3.ª edição, FCA. AGENTES ADAPTATIVOS 1 Introdução Os seres vivos que não se adaptam ao seu
IF-705 Automação Inteligente Algoritmos Evolucionários
IF-705 Automação Inteligente Algoritmos Evolucionários Aluizio Fausto Ribeiro Araújo Universidade Federal de Pernambuco Centro de Informática - CIn Departamento de Sistemas da Computação aluizioa@cin.ufpe.br
4 Metáforas de Optimização
4 Metáforas de Optimização O gigantesco avanço tecnológico que vem sofrendo os sistemas de computação, mais precisamente as unidades de processamento, criou a base para o uso efetivo da Inteligência Computacional,
Utilizando um Algoritmo Genético para Encontrar os Zeros de uma Função Real
Utilizando um Algoritmo Genético para Encontrar os Zeros de uma Função Real Amarildo de Vicente 1, Rogério Luis Rizzi 1 1 Colegiado do Curso de Matemática Centro de Ciências Exatas e Tecnológicas da Universidade
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
APLICAÇÃO DE ALGORITMOS BIO-INSPIRADOS EM CONTROLE ÓTIMO
APLICAÇÃO DE ALGORITMOS BIO-INSPIRADOS EM CONTROLE ÓTIMO Profa. Mariana Cavalca Baseado em: Material didático do Prof. Dr. Carlos Henrique V. Moraes da UNIFEI Curso de verão da Profa. Gisele L. Pappa Material
Método Simplex dual. Marina Andretta ICMC-USP. 24 de outubro de 2016
Método Simplex dual Marina Andretta ICMC-USP 24 de outubro de 2016 Baseado no livro Introduction to Linear Optimization, de D. Bertsimas e J. N. Tsitsiklis. Marina Andretta (ICMC-USP) sme0211 - Otimização
Estratégias Evolutivas EEs. Prof. Juan Moisés Mauricio Villanueva
Estratégias Evolutivas EEs Prof. Juan Moisés Mauricio Villanueva jmauricio@cear.ufpb.br www.cear.ufpb.br/juan Estratégias Evolutivas Desenvolvidas por Rechenberg e Schwefel, e estendida por Herdy, Kursawe
Inteligência Artificial
Figura: Capa do Livro Hamburger, H., Richards, D. Logic and Language Models for Computer Science, Prentice Hall. Universidade Federal de Campina Grande Departamento de Sistemas e Computação Curso de Pós-Graduação
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,
INSTITUTO DE PÓS GRADUAÇÃO ICPG GESTÃO DA TECNOLOGIA DA INFORMAÇÃO
INSTITUTO DE PÓS GRADUAÇÃO ICPG GESTÃO DA TECNOLOGIA DA INFORMAÇÃO Prof. Msc. Saulo Popov Zambiasi (saulopz@gmail.com) Informação - ICPG - Criciuma - SC 1 Características Gerais, operadores, algoritmo.
Computação Evolutiva Parte 2
Computação Evolutiva Parte 2 Fabricio Breve fabricio@rc.unesp.br 29/03/2017 Fabricio Breve 1 Computação Evolutiva Evolução pode ser visto como: Processo capaz de localizar soluções para problemas oferecidos
Algoritmos Genéticos Fernando Lobo
Algoritmos Genéticos Fernando Lobo Grupo de Análise de Sistemas Ambientais Faculdade de Ciências e Tecnologia Universidade Nova de Lisboa Sumário O que é um algoritmo genético? Para que serve? Como funciona?
OTIMIZAÇÃO FUNÇÕES UTILIZANDO ALGORITMOS GENÉTICOS NO APLICATIVO MS EXCEL RESUMO INTRODUÇÃO
OTIMIZAÇÃO FUNÇÕES UTILIZANDO ALGORITMOS GENÉTICOS NO APLICATIVO MS EXCEL Miquéias Augusto Ferreira Nantes 1, Douglas Peixoto de Carvalho 1 (Alunos do Curso de Matemática da Universidade Anhanguera - Uniderp)
Aula 5: Conversões Entre Bases Numéricas
Aula 5: Conversões Entre Bases Numéricas Diego Passos Universidade Federal Fluminense Fundamentos de Arquiteturas de Computadores Diego Passos (UFF) Conversões Entre Bases Numéricas FAC 1 / 43 Conversão
Unidade III ORGANIZAÇÃO DE COMPUTADORES. O que quer dizer 14?
Unidade III 6 CIRCUITOS DIGITAIS 6.1 Sistemas de numeração O que quer dizer 14? Sabemos, por força de educação e hábito, que os algarismos 1 e 4 colocados desta forma representam a quantidade catorze.
Prof: Heni Mirna Cruz Santos
Prof: Heni Mirna Cruz Santos Email: henimirna@hotmail.com Com esta Ribbon é possível desenhar linhas retas, curvas, formas geométricas, hachuras, tabelas, entre outros. O comando LINE gera um segmento
4 Métodos Existentes. 4.1 Algoritmo Genético
61 4 Métodos Existentes A hibridização de diferentes métodos é em geral utilizada para resolver problemas de escalonamento, por fornecer empiricamente maior eficiência na busca de soluções. Ela pode ser