Construa uma CNN em Python com TensorFlow e Keras

Find AI Tools
No difficulty
No complicated process
Find ai tools

Construa uma CNN em Python com TensorFlow e Keras

Tabela de Conteúdos

  1. Introdução
  2. Importando as bibliotecas necessárias
  3. Pré-processamento do conjunto de treinamento 3.1. Aplicando Transformações 3.2. Escalonamento de recursos
  4. Pré-processamento do conjunto de teste 4.1. Aplicando Escalonamento de recursos
  5. 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
  6. Compilando e Treinando o Modelo
  7. Avaliando o Modelo
  8. 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:

Most people like

Are you spending too much time looking for ai tools?
App rating
4.9
AI Tools
100k+
Trusted Users
5000+
WHY YOU SHOULD CHOOSE TOOLIFY

TOOLIFY is the best ai tool source.