Ver para crer

Os algoritmos evolucionários são processos estocásticos que fazem uma procura paralela no espaço das soluções candidatas. Aprende-se muito sobre o funcionamento destes algoritmos vendo o modo como a qualidade dos indivíduos evolui ao longo das gerações. Esta breve nota destina-se a exemplificar de modo simples como se pode usar o módulo matplotlib do python para visualizar o resultado das execuções destes algoritmos.

O caso mais simples de gráfico é aquele em que temos os dados e mandamos fazer o gráfico correspondente. Não precisamos de muito:

import matplotlib.pyplot as plt

def visual_1(data):
    plt.plot(data)
    plt.show() 

Podemos começar com a cosmética, dando um título ao gráfico, nomes aos eixos, incluir uma grelha, acrescentar uma legenda, desenhar mais do que uma função, salvar o ra imagem num ficheiro:

import matplotlib.pyplot as plt

def visual_5(data_1,data_2):
    x = list(range(1,len(data_1)+1))
    plt.title('Two plots ')
    plt.grid(True)
    plt.xlabel('X')
    plt.ylabel('Y')
    plt.plot(x,data_1, label= 'Log')
    plt.plot(x,data_2,label= 'Sqrt')
    plt.legend(loc='lower right')
    plt.savefig('/Users/ernestojfcosta/tmp/matplotlib_test.png')
    plt.show() 

Podemos controlar o aspecto das linhas:

def visual_6(data_1,data_2):
    x = list(range(1,len(data_1)+1))
    plt.title('Two plots ')
    plt.grid(True)
    plt.xlabel('X')
    plt.ylabel('Y')
    plt.plot(x,data_1, 'r-o',label= 'Log')
    plt.plot(x,data_2,'g-.v',label= 'Sqrt')
    plt.legend(loc='lower right')
    plt.savefig('/Users/ernestojfcosta/tmp/matplotlib_test.png')
    plt.show() 

Nos exemplos acima os dados foram calculados antes de chamar a função de visualização. Mas podemos ter soluções diferentes. Por exemplo, podemos ter como argumento a função e o intervalo de valores de ‘X’ e o incremento:

def display_3(f, x_min, x_max, delta=0.001):
    """Compute values and display."""
    x = list(drange(x_min, x_max,delta))
    y = [f(i) for i in x]
    plt.title(f.__name__)
    plt.grid(True)
    plt.xlabel('X')
    plt.ylabel('Y= '+f.__name__ + '(X)')
    plt.plot(x,y, 'r')
    plt.show()
    
 def drange(start,stop,step=0.1):
    """ range for floats."""
    number = start
    while number < stop:
        yield number
        number += step

Veja-se o modo como se obtém o título do gráfico. Note-se ainda o uso de drange para gerar valores com um intervalo delta definido pelo utilizador. Para os leitores conhecedores de python podemos não usar drange se passarmos para arrays disponibilizados pelo módulo numpy:

import matplotlib.pyplot as plt
import numpy as np

def visual_22(data):
    plt.title('One more example...')
    plt.xlabel('X')
    plt.ylabel('Y')
    plt.plot(data)
    plt.show() 

if __name__ == '__main__':
    data_6 = [i**2 for i in np.arange(1,10,0.01)]
    visual_22(data_6)

Também podemos fazer gráficos 3D ... mas isso custa um pouco mais. Vejamos um casos ilustrativo.

from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
import matplotlib.pyplot as plt
import numpy as np

def rastrigin():
    fig = plt.figure()
    fig.suptitle('Rastrigin', fontsize=18, fontweight='bold')
    ax = Axes3D(fig)
    
    
    X = np.arange(-5.12, 5.12, 0.1)
    Y = np.arange(-5.12, 5.12, 0.1)
    
    X, Y = np.meshgrid(X, Y)
    Z = 10*(X**2 - 10* np.cos(2*3.14159*X)) + 20*(Y**2 - 10* np.cos(2*3.14159*Y))
    
    ax.plot_surface(X, Y, Z, rstride=1,cstride=1,cmap=cm.jet)
    ax.legend()
    plt.show()

if __name__ == '__main__':
    rastrigin()

Agora o leitor interessado só tem que de consultar o manual do Matplotlib para ver a multiplicidade de possibilidades.