Aprendizado profundo com Keras: treinamento de rede neural com Keras [com código]
Publicados: 2020-12-24Keras é uma biblioteca Python que fornece uma API para trabalhar com redes neurais e estruturas de aprendizado profundo. Keras fornece funções e módulos que são extremamente úteis ao lidar com vários aplicativos de Deep Learning em Python.
Ao final deste tutorial, você terá o conhecimento do seguinte:
- O que é Keras?
- APIs Keras
- Treinando uma rede neural em Keras
Índice
O que é Keras?
Para fazer Deep Learning, a biblioteca mais usada anteriormente era o Tensorflow 1.x, que era difícil de lidar para iniciantes. Exigiu muita codificação para fazer apenas uma rede básica de 1 camada. No entanto, com o Keras, o processo completo de fazer a estrutura de uma Rede Neural e depois treiná-la e rastreá-la ficou extremamente fácil.
Keras é uma API de alto nível que pode ser executada no backend Tensorflow, Theano e CNTK. Ele nos dá a capacidade de executar experimentos usando redes neurais usando API de alto nível e fácil de usar. Também é capaz de rodar em CPUs e GPUs.
APIs Keras
Keras tem 10 módulos de API diferentes destinados a lidar com modelagem e treinamento de redes neurais. Vamos analisar cada um deles para entender o que tudo Keras tem a oferecer.
Modelos
A API Models fornece a funcionalidade para construir redes neurais complexas adicionando/removendo camadas. O modelo pode ser Sequencial, o que significa que as camadas serão empilhadas sequencialmente com uma única entrada e saída. O modelo também pode ser funcional, ou seja, com modelos totalmente personalizáveis. Isso é o que é usado principalmente na indústria.

A API também possui o módulo de treinamento que fornece métodos para compilar o modelo junto com o otimizador e a função de perda, um método para ajustar o modelo, um método para avaliar e prever novos dados também. Além disso, também possui métodos para treinamento, teste e previsão em dados em lote. A API de modelos também possui o salvamento e a serialização dos modelos.
Camadas
As camadas são os blocos de construção de qualquer rede neural. A API Layers oferece um conjunto completo de métodos para construir a arquitetura da rede neural. A API Layers tem a classe Base Layer que contém métodos necessários para construir camadas personalizadas com pesos e inicializadores personalizados.
Ele contém a classe Layer Activations que consiste em várias funções de ativação como ReLU, Sigmoid, Tanh, Softmax, etc. A classe Layer Weight Initializers oferece métodos para inicializar pesos de diferentes maneiras.
Ela também consiste na classe Core Layers, que consiste em classes necessárias para adicionar camadas centrais, como camada Densa, Camada de Ativação, camada Embedding, etc. A classe Camada de Convolução oferece vários métodos para adicionar diferentes tipos de camadas de Convolução. A classe Pooling Layers contém os métodos necessários para diferentes tipos de pooling, como Max Pooling, Average Pooling, Global Max Pooling e Global Average Pooling.
Retornos de chamada
Os retornos de chamada são uma maneira de rastrear o processo de treinamento do modelo. Com o retorno de chamada ativado, várias ações podem ser executadas antes ou depois do final de uma época ou de um lote. Com os retornos de chamada, você pode:
- Monitore as métricas de treinamento registrando as métricas no TensorFlow Board
- Salvando o modelo em disco periodicamente
- Parada antecipada caso a perda não esteja diminuindo significativamente após certas épocas
- Visualize estados internos e estatísticas de um modelo durante o treinamento
Pré-processamento do conjunto de dados
Os dados geralmente estão em formato bruto e estão em diretórios organizados e precisam ser pré-processados antes de alimentar o modelo para ajuste. A classe Image Data Preprocessing tem muitas dessas funções dedicadas. Por exemplo, os dados da imagem precisam estar na matriz numérica para a qual podemos usar a função img_to_array. Ou se as imagens estiverem presentes dentro de um diretório e subpastas, podemos usar a função image_dataset_from_directory.
A API de pré-processamento de dados também possui classes para dados de séries temporais e dados de texto.
Otimizadores
Os otimizadores são a espinha dorsal de qualquer rede neural. Toda rede neural trabalha na otimização de uma função de perda para encontrar os melhores pesos para previsão. Existem vários tipos de otimizadores que seguem técnicas ligeiramente diferentes para encontrar os pesos ideais. Todos esses otimizadores estão disponíveis na API de Otimizadores – SGD, RMSProp, Adam, Adadelta, Adagrad, Adamax, Nadal, FTRL.
Perdas
As funções de perda precisam ser especificadas ao compilar um modelo. Esta função de perda seria otimizada pelo otimizador que também foi passado como parâmetro no método de compilação. As três principais classes de perdas são: Perdas Probabilísticas, Perdas por Regressão, Perdas de Dobradiça.
Métricas
As métricas são usadas em todos os modelos de ML para quantificar seu desempenho nos dados de teste. As métricas são semelhantes às funções de perda, exceto pelo fato de serem usadas em dados de teste. Existem muitas métricas de precisão disponíveis, como precisão, precisão binária, precisão categórica, etc. Ele também contém métricas probabilísticas, como entropia cruzada binária, entropia cruzada categórica, etc. Existem métricas para verificar falsos positivos/negativos, como AUC, Precisão, Recall, etc.
Além dessas métricas de classificação, também possui métricas de regressão, como erro quadrático médio, erro quadrático médio, erro médio absoluto, etc.
Leia também: O que é o Keras e o TensorFlow

Aplicativos Keras
A classe Keras Applications consiste em alguns modelos pré-construídos juntamente com pesos pré-treinados. Esses modelos pré-treinados são usados para o processo de Transferência de Aprendizagem. Esses modelos pré-treinados são diferentes dependendo da arquitetura, número de camadas, pesos treináveis, etc. Alguns deles são Xception, VGG16, Resnet50, MobileNet, etc.
Treinando uma rede neural com Keras
Vamos considerar um conjunto de dados simples como o MNIST que está disponível na classe de conjuntos de dados do Keras. Faremos uma Rede Neural Convolucional sequencial simples para classificar as imagens manuscritas dos dígitos 0-9.
#Carregando o conjunto de dados de keras.datasets import mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() |
Normalizando o conjunto de dados dividindo cada pixel por 255. Além disso, é necessário transformar as imagens em 4 dimensões antes de alimentá-las para um modelo CNN.
x_train = x_train.astype( 'float32' ) x_test = x_test.astype( 'float32' ) x_train /= 255 x_test /= 255 x_train = X_train.reshape(X_train.shape[ 0 ], 28 , 28 , 1 ) x_test = X_test.reshape(X_test.shape[ 0 ], 28 , 28 , 1 ) |
Precisamos rotular codificar as classes antes de alimentá-las ao modelo. Faremos isso usando a classe Utils do Keras.
de keras.utils importar para_categorical
|
Agora, podemos começar a criar o modelo usando a API Sequential.
de keras.models import Sequencial from keras.layers import Conv2D, MaxPool2D, Dense, Flatten, Dropout model = Sequential() model.add(Conv2D(filters= 32 , kernel_size=( 5 , 5 ), activation= 'relu' , input_shape=x_train.shape[ 1 :])) model.add(MaxPool2D(pool_size=( 2 , 2 ))) model.add(Dropout(rate= 0,25 )) model.add(Conv2D(filtros= 64 , kernel_size=( 3 , 3 ), ativação= 'relu' )) model.add(MaxPool2D(pool_size=( 2 , 2 ))) model.add(Dropout(rate= 0,25 )) model.add(Achatar()) model.add(Dense( 256 , ativação= 'relu' )) model.add(Dropout(rate= 0,5 )) model.add(Dense( 10 , ativação= 'softmax' )) |
No código acima, declaramos um modelo sequencial e adicionamos várias camadas a ele. A camada convolucional, seguida por uma camada Max Pooling e, em seguida, uma camada dropout para regularização. Mais tarde, achatamos a saída usando a camada achatada e a última camada é uma camada densa totalmente conectada com 10 nós.
Em seguida, precisamos compilá-lo passando a função de perda, o otimizador e a métrica.
model.compile( loss= 'categorical_crossentropy' , otimizador = 'adam' , métricas=[ 'precisão' ] ) |
Agora precisaríamos adicionar imagens aumentadas das imagens originais para aumentar o conjunto de treinamento e a precisão do modelo. Faremos isso usando a função ImageDataGenerator.
de keras.preprocessing.image import ImageDataGenerator datagen = ImageDataGenerator( range_rotação= 10 , zoom_range= 0.1 , largura_deslocamento_intervalo= 0,1 , height_shift_range= 0,1 ) |
Agora que o modelo está compilado e as imagens aumentadas, podemos iniciar o processo de treinamento. Como usamos um Image Data Generator acima, usaremos o método fit_generator em vez de apenas ajustar.

épocas = 3 batch_size = 32 history = model.fit_generator( datagen.flow(x_train, y_train, batch_size=batch_size), epochs=epochs, validation_data=(x_test, y_test), steps_per_epoch=x_train.shape[ 0 ]//batch_size ) |
A saída do processo de treinamento é a seguinte:
3Agora, o modelo está treinado e pode ser avaliado executando-o em dados de teste não vistos.
Leitura relacionada: Deep Learning e Redes Neurais com Keras
Antes de você ir
Neste tutorial, vimos como o Keras está estruturado e facilita a construção de uma rede neural complexa. O Keras agora está integrado ao Tensorflow 2.x, o que oferece ainda mais recursos. Experimente mais exemplos e explore as funções e recursos do Keras.
Se você estiver interessado em aprender mais sobre aprendizado de máquina, confira o PG Diploma in Machine Learning & AI do IIIT-B e upGrad, projetado para profissionais que trabalham e oferece mais de 450 horas de treinamento rigoroso, mais de 30 estudos de caso e atribuições, IIIT- B Status de ex-aluno, mais de 5 projetos práticos práticos e assistência de trabalho com as principais empresas.