Keras é uma biblioteca aberta de Deep Learning implementada utilizando TensorFlow para diversas linguagens/plataformas, como Python e R, como foco na sua facilidade para utilização. Ela permite modelar e treinar modelos de redes neurais com poucas linhas de código, como você verá no tutorial a seguir.
Nesse tutorial, vamos utilizar o Keras para criar um modelo capaz de classificar se membros de uma população indígena possuem ou não diabetes.
Preparações
Para seguir esse projeto, você precisará ter instalados:
- Python 3;
- Bibliotecas SciPy e Numpy;
- Bibliotecas TensorFlow e Keras;
- Jupyter Notebook;
Alternativamente, você pode realizar este tutorial na plataforma Google Colab, que já possui todas as dependências instaladas e prontas para que você execute o tutorial no seu navegador.
Após isso, basta criar um novo notebook com o título “projeto_deep_learning” (ou qualquer outro nome), e iniciar o tutorial.
1. Carregando os dados
Em uma célula, importe as seguintes bibliotecas Python:
from numpy import loadtxt import numpy as np from keras.models import Sequential from keras.layers import Dense
Na célula seguinte, carregue os dados da base Pima Indians Diabetes. Essa base possui inicialmente 9 colunas, sendo as 8 primeiras as entradas e a última o resultado esperado. Todas as entradas dessa base são numéricas, assim como as saídas, o que facilita a computação dos dados por modelos de Deep Learning.
# carregue a base de dados
dataset = loadtxt('https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv', delimiter=',')
Em seguida, utilizando a funcionalidade de slice do Python, separe o conjunto de dados entre “Entradas” (X) e “Saídas” (y).
# separe os dados entre entradas (X) e saídas (y) X = dataset[:,0:8] y = dataset[:,8]
2. Criar o modelo utilizando Keras
Agora que nossos dados foram carregados e ajustados entre entradas e saídas, podemos definir nosso modelo utilizando a biblioteca Keras.
Modelos Keras são definidos como uma sequência de camadas. Nesse tutorial, vamos criar um modelo sequencial e adicionar uma camada de cada.
Primeiramente, precisamos garantir que a camada de entrada tem a quantidade correta de inputs de entrada. Isso pode ser especificado no Keras utilizando o argumento input_dim e o ajustando para 8, nosso número de entradas.
Para esse tutorial, vamos utilizar camadas completamente conectadas, que são definidas no Keras pela classe Dense. Esse projeto utilizará 3 camadas, as quais as duas primeiras utilizarão a função de ativação ReLU e a função Sigmoid na última. Podemos especificar o número de neurônios no primeiro argumento, e a função de ativação com o parâmetro activation.
# definir o modelo com keras # inicializar o modelo sequencial model = Sequential() # inicializar a primeira camada, com 12 neurônios, 8 entradas utilizando a função ReLU model.add(Dense(12, input_dim=8, activation='relu')) # inicializar a segunda camada com 8 neurônios e a função ReLU model.add(Dense(8, activation='relu')) # inicializar a última camada (camada de saída) com um neurônio e a função Sigmoid model.add(Dense(1, activation='sigmoid'))
3. Compilando o modelo
Com nosso modelo definido, precisamos compilá-lo. A compilação ocorre utilizando bibliotecas como Theano ou TensorFlow, onde a melhor forma de representar a rede para treinar e fazer predições utilizando o hardware disponível é selecionada.
Ao compilar, precisamos especificar algumas propriedades, como a função de perda, otimizador e a métrica que será utilizada para avaliar o modelo. Foge ao escopo do tutorial apresentar esses conceitos, mas vamos utilizar a função de perda de Entropia Cruzada Binária, o otimizador Adam (que utiliza o gradiente descendente) e acurácia como métrica.
# compile the keras model model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
4. Treinando o modelo
Como nosso modelo definido e compilado, precisamos treiná-lo, ou seja, executar o modelo utilizando nossos dados. Para treinar o modelo, basta chamar a função fit() para o modelo.
O treinamento ocorre através de épocas, e cada época é dividida em lotes, onde uma época é uma passagem por todas as linhas do conjunto de testes, e um lote é composto de uma ou mais amostras (quantidade definida pelo usuário) consideradas pelo modelo antes que seja feita a atualização dos seus pesos. Aqui, vamos executar 150 épocas com lotes de tamanho 10 (um número considerado pequeno).
# treinar o modelo keras model.fit(X, y, epochs=150, batch_size=10)
5. Avaliando o modelo
Agora que estamos com nosso modelo treinado, precisamos avaliá-lo. Essa avaliação vai dizer o quão bem o modelo foi construído utilizando o conjunto de dados de treinamento. Esse pequeno projeto foi construído para ser simples, mas você pode separar os dados entre dados de treinamento e de teste para avaliar o desempenho do modelo com novos dados.
Para avaliar como o modelo se comportou para os dados de treinamento, basta passar os mesmos dados de entrada e saída para a função evaluate() . Essa função retorna uma lista com a perda e a acurácia do modelo para o conjunto de dados.
# avaliando o modelo keras
_, accuracy = model.evaluate(X, y)
print('Acurácia: %.2f' % (accuracy*100))
Conclusão
Com esse tutorial, podemos acompanhar em 5 passos o ciclo de vida de um modelo de Deep Learning, da sua concepção até a sua avaliação. Você pode expandir o que foi feito neste tutorial para, por exemplo, ajustar o modelo (é possível obter uma acurácia maior do que a obtida?), salvar o modelo (para utilização em outros projetos), plotar a curva de aprendizado, entre outras ideias.
Para mais tutoriais, continue atento ao nosso Blog.
Este texto foi baseado no tutorial disponibilizado em: Your First Deep Learning Project in Python with Keras Step-By-Step
