Construa uma CNN em Python com TensorFlow e Keras
Tabela de Conteúdos
- Introdução
- Importando as bibliotecas necessárias
- Pré-processamento do conjunto de treinamento
3.1. Aplicando Transformações
3.2. Escalonamento de recursos
- Pré-processamento do conjunto de teste
4.1. Aplicando Escalonamento de recursos
- Construindo a Rede Neural Convolucional
5.1. Camada de Convolução
5.2. Camada de Pooling
5.3. Camada de Flattening
5.4. Camada Totalmente Conectada
- Compilando e Treinando o Modelo
- Avaliando o Modelo
- Conclusão
Introdução
O mundo da aprendizagem profunda evoluiu muito nos últimos anos, e uma das áreas em destaque é o processamento de imagens. Neste Tutorial, iremos explorar como construir uma Rede Neural Convolucional (CNN) para classificar imagens de gatos e cachorros. Através do uso da biblioteca TensorFlow, iremos percorrer todos os passos necessários, desde o pré-processamento dos dados até a construção e treinamento do modelo. Vamos começar importando as bibliotecas necessárias.
Importando as bibliotecas necessárias
Para começar, precisamos importar as bibliotecas TensorFlow e a biblioteca de pré-processamento de imagens do Keras. Isso pode ser feito através do seguinte código:
import tensorflow as tf
from keras.preprocessing.image import ImageDataGenerator
print(tf.__version__)
Ao executar o código acima, iremos imprimir a versão do TensorFlow que estamos usando. Certifique-se de estar usando a versão 2.0 ou superior, pois ela traz várias melhorias em relação à versão 1.x.
Pros:
- A versão 2.0 do TensorFlow traz melhorias significativas em relação à versão 1.x.
- A biblioteca de pré-processamento de imagens do Keras facilita a aplicação de transformações nas imagens de treinamento.
Cons:
- É necessário verificar se a versão do TensorFlow é compatível com as outras bibliotecas utilizadas.
Pré-processamento do conjunto de treinamento
Antes de começar a construir a CNN, é importante pré-processar o conjunto de treinamento. Isso envolve a aplicação de transformações nas imagens para evitar o overfitting e o dimensionamento dos recursos.
3.1. Aplicando Transformações
Para evitar que o modelo aprenda padrões específicos das imagens de treinamento, vamos aplicar algumas transformações geométricas. Isso irá aumentar a diversidade das imagens de treinamento, impedindo que o modelo se torne muito dependente de características específicas. Podemos fazer isso utilizando a classe ImageDataGenerator
do Keras.
train_data_gen = ImageDataGenerator(
rescale = 1/255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True
)
Aqui estamos criando um objeto train_data_gen
da classe ImageDataGenerator
e especificando as transformações que queremos aplicar. Além disso, estamos realizando o escalonamento dos recursos, dividindo os valores de pixel por 255 para normalizá-los entre 0 e 1.
Pros:
- A aplicação de transformações é uma técnica eficaz para evitar o overfitting.
- O Keras oferece uma classe
ImageDataGenerator
que facilita a aplicação dessas transformações nas imagens de treinamento.
Cons:
- A escolha das transformações corretas pode ser uma tarefa desafiadora e requer algum conhecimento do domínio.
3.2. Escalonamento de recursos
Após a aplicação das transformações, é importante escalonar os recursos para facilitar o treinamento do modelo. O escalonamento de recursos garante que todas as variáveis estejam na mesma escala, evitando assim que algumas variáveis dominem as outras. Podemos fazer isso novamente usando a classe ImageDataGenerator
do Keras.
training_set = train_data_gen.flow_from_directory(
'caminho/para/a/pasta/de/treinamento',
target_size = (64, 64),
batch_size = 32,
class_mode = 'binary'
)
Aqui estamos usando o método flow_from_directory
para importar o conjunto de treinamento, especificando o caminho para a pasta de treinamento, o tamanho final das imagens (64x64), o tamanho do lote (32) e o modo de classe (binário). Este método irá criar batches de 32 imagens e aplicar as transformações especificadas anteriormente.
Pré-processamento do conjunto de teste
Após o pré-processamento do conjunto de treinamento, é importante pré-processar também o conjunto de teste. Aqui não precisamos aplicar transformações nas imagens, pois queremos mantê-las intactas para testar a eficácia do modelo. No entanto, ainda é necessário redimensionar os recursos.
4.1. Aplicando Escalonamento de recursos
Assim como fizemos anteriormente, vamos aplicar o escalonamento dos recursos utilizando a classe ImageDataGenerator
do Keras.
test_data_gen = ImageDataGenerator(
rescale = 1/255
)
test_set = test_data_gen.flow_from_directory(
'caminho/para/a/pasta/de/teste',
target_size = (64, 64),
batch_size = 32,
class_mode = 'binary'
)
Aqui estamos criando um objeto test_data_gen
da classe ImageDataGenerator
e especificando apenas o escalonamento dos recursos. Em seguida, utilizamos o método flow_from_directory
para importar o conjunto de teste, especificando o caminho para a pasta de teste, o tamanho final das imagens (64x64), o tamanho do lote (32) e o modo de classe (binário).
Construindo a Rede Neural Convolucional
Agora que concluímos o pré-processamento dos dados, podemos começar a construir a CNN propriamente dita. A CNN é composta por camadas de convolução, camadas de pooling, camadas de flattening e camadas totalmente conectadas.
5.1. Camada de Convolução
A primeira camada da nossa CNN é uma camada de convolução, responsável por extrair características das imagens. Podemos adicionar essa camada ao nosso modelo utilizando a classe Conv2D
do TensorFlow.
model.add(Conv2D(filters = 32, kernel_size = 3, activation = 'relu', input_shape = (64, 64, 3)))
Aqui estamos adicionando uma camada de convolução com 32 filtros, um tamanho de kernel de 3x3, uma função de ativação ReLU e uma entrada de formato 64x64x3.
5.2. Camada de Pooling
Em seguida, adicionamos uma camada de pooling para reduzir a dimensionalidade das características extraídas e melhorar a eficiência do modelo. Podemos fazer isso adicionando uma camada de pooling após cada camada de convolução.
model.add(MaxPooling2D(pool_size = (2, 2)))
Aqui estamos adicionando uma camada de pooling com uma janela de pooling de tamanho 2x2.
5.3. Camada de Flattening
Após a camada de pooling, adicionamos uma camada de flattening para transformar os dados em um vetor unidimensional antes de passá-los para as camadas totalmente conectadas.
model.add(Flatten())
5.4. Camada Totalmente Conectada
Finalmente, adicionamos algumas camadas totalmente conectadas para realizar a classificação final das imagens. Podemos fazer isso utilizando a classe Dense
do TensorFlow.
model.add(Dense(units = 128, activation = 'relu'))
model.add(Dense(units = 1, activation = 'sigmoid'))
Aqui estamos adicionando uma camada densa com 128 neurônios e uma função de ativação ReLU. Em seguida, adicionamos uma camada densa de saída com 1 neurônio (pois estamos realizando uma classificação binária) e uma função de ativação sigmoid.
Compilando e Treinando o Modelo
Agora que construímos o modelo, precisamos compilá-lo e treiná-lo com os conjuntos de treinamento e teste. Para isso, utilizamos as funções compile
e fit
do TensorFlow.
6.1. Compilando o Modelo
model.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
Aqui estamos compilando o modelo utilizando o otimizador Adam, a função de perda binary_crossentropy (pois estamos realizando uma classificação binária) e a métrica de avaliação da precisão.
6.2. Treinando o Modelo
model.fit(x = training_set, validation_data = test_set, epochs = 25)
Aqui estamos treinando o modelo utilizando o conjunto de treinamento como dados de treinamento e o conjunto de teste como dados de validação. Estamos executando 25 épocas de treinamento, ou seja, o modelo será treinado 25 vezes em todo o conjunto de treinamento.
Avaliando o Modelo
Após o treinamento, é importante avaliar o desempenho do modelo usando métricas como a precisão e a perda. Podemos fazer isso usando a função evaluate
do TensorFlow.
loss, accuracy = model.evaluate(test_set)
print('Test accuracy:', accuracy)
Aqui estamos avaliando o modelo utilizando o conjunto de teste e armazenando a perda e a precisão resultantes. Em seguida, imprimimos a precisão do conjunto de teste para ter uma ideia do desempenho do modelo.
Conclusão
Neste tutorial, exploramos todos os passos necessários para construir uma Rede Neural Convolucional (CNN) para classificação de imagens de gatos e cachorros. Através do pré-processamento dos dados, construção do modelo e treinamento, conseguimos obter ótimos resultados. A aprendizagem profunda continua a evoluir e a CNN se mostra uma ferramenta poderosa para a classificação de imagens. Experimente este modelo em diferentes conjuntos de dados e explore outras técnicas e arquiteturas para melhorar ainda mais o desempenho. Divirta-se aprendendo e continue explorando as possibilidades oferecidas pelo TensorFlow!
URLs úteis: