Desenvolvendo a sua primeira rede neural com Keras – parte 2

Se você acompanhou o último tutorial, deve ter um código guardado em seus arquivos que consegue carregar um conjunto de dados que serão usados para o desenvolvimento de nossa rede neural. Aprendemos a acessar os dados com a biblioteca numpy e a tratá-los através de funções da biblioteca sklearn. Agora estamos prontos para estruturar a nossa rede usando a biblioteca Keras (finalmente).

O primeiro passo é importarmos os módulos Sequential e Dense da biblioteca Keras (lembre-se: antes de importar os módulos a biblioteca precisa ser instalada. Isso pode ser feito através do prompt, com ajuda do comando: pip install nome_da_bilioteca).

from keras.models import Sequential
from keras.layers import Dense

Os módulos importados nos permitem montar o modelo de rede que será posteriormente treinado. Nossa rede será uma sequência de layers (ou camadas) e em cada camada definimos: número de neurônios e função de ativação: 

#definindo o modelo
model=Sequential()

#a primeira camada traz, como segundo parâmetro, a dimensão do input (quantas colunas tem o dataset. Em nosso caso são 4 colunas)
#existem diversas funções de ativação. Para este exercício usaremos a Unidade Linear Retificada para as camadas iniciais e a Sigmoid para a função final
model.add(Dense(4, input_dim=4, activation='relu')) #primeira camada
model.add(Dense(8, activation='relu')) #a segunda camada tem 8 neurônios
model.add(Dense(1, activation='sigmoid')) #a última camada tem apenas 1 neurônio pois a saída será binária

#depois de definida a rede, compilamos o modelo.
model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy'])

A configuração desta rede, com 3 camadas, e o número de neurônios utilizados nas duas primeiras camadas são bastante arbitrários. O mais interessante das redes neurais é que elas não são determinísticas, e aceitam mais de uma configuração no intuito de se obter o melhor aprendizado. Isso significa que você pode testar outras configurações, com mais ou menos camadas, e com mais ou menos neurônios em cada camada, além de outras funções de ativação. Faça isso para perceber se os resultados (acurácia) se alteram até que alguma configuração seja adequada ao seu julgamento.

Com a arquitetura da nossa rede pronta, chegou o grande momento: vamos fazer com que ela aprenda o que são notas falsas e verdadeiras. Para a nossa sorte, esta tarefa é muito simples:

#treinando a rede
#epochs=quantas vezes os dados serão visitados para o treinamento
#batch=depois de quantas iterações os pesos das funções serão atualizados
model.fit(scaled_X_train, y_train, validation_split=0.2, epochs=60, batch_size=9, verbose=2)

Até este momento nosso modelo teve contato apenas como grupo de dados de treinamento. A etapa de treinamento pode demorar um pouco a depender dos parâmetros definidos na função e da capacidade da sua máquina. Dito isso, podemos comemorar pois já temos nossa rede que aprendeu a identificar as notas (pode se dar um tapinha nas suas costas). A questão que fica é: será que a rede aprendeu bem? Para responder a esta questão, podemos fazer um teste deste modelo com os dados de teste que já separamos anteriormente.

#avaliando a performance da rede (acuracia)
#avaliação em dados nunca vistos pela rede (test)
_, accuracy = model.evaluate(scaled_X_test, y_test)
print('Accuracy: %.2f' % (accuracy*100))

Percebeu o que fizemos? Já temos o nosso modelo treinado e conseguimos avaliar o seu desempenho através da acurácia (percentual de acerto). Assim, concluímos o nosso objetivo. 

Ainda há algumas coisas que podemos fazer, como por exemplo: salvar o modelo, imprimir um gráfico de desempenho, além de testarmos configurações de rede que nos dê um valor maior de acerto. Por hora vou deixar estes refinamentos com você, mas se precisar de ajuda me avisa que voltamos com mais uma parte deste tutorial.  Para este exemplo, consegui em média 93% de acurácia. Se você conseguiu valores melhores, primeiro comemore e depois posta aqui nos comentários para aprendermos juntos sobre as configurações da sua rede. 

resultados para a rede desenvolvida no tutorial.

Em tempo, antes de apresentar o código completo, deixo aqui o endereço do guia para a Keras, deste modo você poderá se aprofundar em cada ítem estudado por aqui: https://keras.io/guides/

#importando as bibliotecas necessárias
from numpy import loadtxt
from keras.models import Sequential
from keras.layers import Dense
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler

dataset = loadtxt('caminho/do/arquivo/notas.txt', delimiter=',')

#dividir o conjunto de dados em valores (X) e seus labels equivalentes (y)
X = dataset[:,0:4]
y = dataset[:,4]

#dividir os grupos em treinamento e teste
X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.3) #, random_state=42)

scaler_object = MinMaxScaler()
scaler_object.fit(X_train)
scaled_X_train = scaler_object.transform(X_train)
scaled_X_test = scaler_object.transform(X_test)

model = Sequential()
model.add(Dense(4, input_dim=4, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy'])

model.fit(scaled_X_train, y_train, validation_split=0.2, epochs=60, batch_size=9, verbose=2)

_, accuracy = model.evaluate(scaled_X_test, y_test)
print('Accuracy: %.2f' % (accuracy*100))

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *