20.4. Construindo Redes Neurais com Keras e TensorFlow: Construção de modelos sequenciais em Keras

Página 71

20.4. Construindo Redes Neurais com Keras e TensorFlow

O desenvolvimento de redes neurais tornou-se mais acessível com a introdução de bibliotecas de alto nível como Keras, que opera sobre o TensorFlow, uma poderosa biblioteca de machine learning. Neste capítulo, vamos explorar como construir modelos sequenciais em Keras, permitindo a criação de redes neurais profundas de maneira simplificada e eficiente.

Introdução ao Keras

Keras é uma API de redes neurais de alto nível escrita em Python que é capaz de rodar em cima do TensorFlow, CNTK ou Theano. Foi desenvolvida com o foco na experimentação rápida e na produtividade, permitindo que ideias sejam transformadas em resultados com o mínimo de atraso. A simplicidade e a facilidade de uso do Keras o tornaram uma das ferramentas mais populares entre os cientistas de dados e engenheiros de machine learning.

Modelos Sequenciais em Keras

Um modelo sequencial no Keras é uma pilha linear de camadas. É o tipo de modelo mais simples e é adequado para a maioria dos problemas de deep learning. Com ele, você pode criar uma rede neural adicionando camadas uma após a outra de forma sequencial.

Instalando o Keras e TensorFlow

Antes de começar a construir um modelo, é necessário instalar o Keras e o TensorFlow. Isso pode ser feito facilmente usando o pip, o gerenciador de pacotes do Python:

pip install tensorflow
pip install keras

Após a instalação, você pode importar o Keras e verificar a versão do TensorFlow para garantir que tudo está configurado corretamente:

import tensorflow as tf
import keras
print(tf.__version__)
print(keras.__version__)

Construindo um Modelo Sequencial

Para construir um modelo sequencial em Keras, você começa importando a classe Sequential e adicionando camadas usando o método add(). Vamos construir um modelo simples para classificação de imagens:

from keras.models import Sequential
from keras.layers import Dense, Flatten, Conv2D, MaxPooling2D

# Inicializa o modelo sequencial
model = Sequential()

# Adiciona uma camada convolucional
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))

# Adiciona uma camada de pooling
model.add(MaxPooling2D((2, 2)))

# Achata o output para fornecer como entrada para as camadas densas
model.add(Flatten())

# Adiciona uma camada densa (fully-connected)
model.add(Dense(100, activation='relu'))

# Adiciona a camada de saída
model.add(Dense(10, activation='softmax'))

Esse modelo consiste em uma camada convolucional seguida por uma camada de pooling, uma camada de achatamento e duas camadas densas. A última camada densa usa a função de ativação softmax para obter probabilidades de classificação para cada uma das 10 classes possíveis.

Compilando o Modelo

Depois de construir o modelo, você precisa compilá-lo. Isso é feito usando o método compile(), onde você define a função de perda (loss function), o otimizador e as métricas de avaliação:

model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

A função de perda categorical_crossentropy é comumente usada em problemas de classificação multiclasse. O otimizador adam é uma escolha popular devido à sua eficiência e ajuste automático da taxa de aprendizado.

Treinando o Modelo

Com o modelo compilado, você pode treiná-lo usando o método fit(). Você precisará fornecer os dados de treinamento, os rótulos, o número de épocas e o tamanho do lote:

history = model.fit(train_data, train_labels, epochs=10, batch_size=32)

O objeto history contém informações sobre o processo de treinamento, como a perda e a precisão em cada época, que podem ser usadas para análise e ajuste do modelo.

Avaliando e Salvando o Modelo

Após o treinamento, você pode avaliar o desempenho do modelo nos dados de teste usando o método evaluate():

test_loss, test_acc = model.evaluate(test_data, test_labels)
print('Test accuracy:', test_acc)

Se estiver satisfeito com o desempenho do modelo, você pode salvá-lo usando o método save(), permitindo carregá-lo posteriormente para fazer previsões ou continuar o treinamento:

model.save('my_model.h5')

Conclusão

Construir redes neurais com Keras e TensorFlow é um processo direto e eficiente. A API sequencial do Keras permite que você crie modelos camada por camada, enquanto o TensorFlow fornece a robustez e a escalabilidade necessárias para treinar modelos complexos. Com a capacidade de compilar, treinar, avaliar e salvar modelos facilmente, Keras é uma ferramenta indispensável para qualquer pessoa interessada em deep learning com Python.

Siguiente página del libro electrónico gratuito:

7220.5. Construindo Redes Neurais com Keras e TensorFlow: Trabalhando com camadas densas, convolucionais e recorrentes