Como melhorar seu modelo de aprendizado de máquina com o aumento de dados do TensorFlow

O aumento de dados é o processo de aplicar várias transformações aos dados de treinamento. Isso ajuda a aumentar a diversidade do conjunto de dados e evitar o overfitting. O overfitting ocorre principalmente quando você tem dados limitados para treinar seu modelo.

Aqui, você aprenderá como usar o módulo de aumento de dados do TensorFlow para diversificar seu conjunto de dados. Isso evitará o overfitting gerando novos pontos de dados ligeiramente diferentes dos dados originais.

O conjunto de dados de amostra que você usará

Você usará o conjunto de dados de cães e gatos de Kaggle. Este conjunto de dados contém aproximadamente 3.000 imagens de cães e gatos. Essas imagens são divididas em conjuntos de treinamento, teste e validação.

O rótulo 1.0 representa um cachorro enquanto o rótulo 0.0 representa um gato.

O código-fonte completo implementando técnicas de aumento de dados e aquele que não está disponível em um Repositório GitHub.

Instalando e importando o TensorFlow

Para seguir, você deve ter um entendimento básico de Python. Você também deve ter conhecimento básico de aprendizado de máquina. Se você precisar de uma atualização, considere seguir algumas tutoriais sobre aprendizado de máquina.

Abrir Google Colab. Altere o tipo de tempo de execução para GPU. Em seguida, execute o seguinte comando mágico na primeira célula de código para instalar o TensorFlow em seu ambiente.

!pip instalar tensorflow

Importe o TensorFlow e seus módulos e classes relevantes.

importar tensorflow como tf
de tensorflow.keras.preprocessing.image importar ImageDataGenerator
de tensorflow.keras.models importar Sequencial
de tensorflow.keras.layers importar Conv2D, MaxPooling2D, achatar, denso, dropout

O tensorflow.keras.preprocessing.image permitirá que você execute o aumento de dados em seu conjunto de dados.

Criando Instâncias da Classe ImageDataGenerator

Crie uma instância do ImageDataGenerator classe para os dados do trem. Você usará esse objeto para pré-processar os dados de treinamento. Ele gerará lotes de dados de imagem aumentados em tempo real durante o treinamento do modelo.

Na tarefa de classificar se uma imagem é um gato ou um cachorro, você pode usar as técnicas de inversão, largura aleatória, altura aleatória, brilho aleatório e ampliação de dados com zoom. Essas técnicas gerarão novos dados que contêm variações dos dados originais que representam cenários do mundo real.

# define o gerador de dados de imagem para treinamento
train_datagen = ImageDataGenerator (rescale =1./255,
 horizontal_flip=Verdadeiro,
 width_shift_range=0.2,
 height_shift_range=0.2,
 intervalo_brilho=[0.2,1.0],
 zoom_range=0.2)

Crie outra instância do ImageDataGenerator classe para os dados de teste. você vai precisar do re-escala parâmetro. Ele normalizará os valores de pixel das imagens de teste para corresponder ao formato usado durante o treinamento.

# define o gerador de dados de imagem para teste
test_datagen = ImageDataGenerator (rescale =1./255)

Crie uma instância final do ImageDataGenerator classe para os dados de validação. Redimensione os dados de validação da mesma forma que os dados de teste.

# define o gerador de dados de imagem para validação
validação_datagen = ImageDataGenerator (redimensionar =1./255)

Você não precisa aplicar as outras técnicas de aumento aos dados de teste e validação. Isso ocorre porque o modelo usa os dados de teste e validação apenas para fins de avaliação. Eles devem refletir a distribuição original dos dados.

Carregando seus dados

Criar uma DirectoryIterator objeto do diretório de treinamento. Ele irá gerar lotes de imagens aumentadas. Em seguida, especifique o diretório que armazena os dados de treinamento. Redimensione as imagens para um tamanho fixo de 64x64 píxeis. Especifique o número de imagens que cada lote usará. Por fim, especifique o tipo de etiqueta a ser binário (ou seja, gato ou cachorro).

# definindo o diretório de treinamento
train_data = train_datagen.flow_from_directory (directory=r'/content/drive/MyDrive/cats_and_dogs_filtered/train',
 target_size=(64, 64),
 batch_size=32,
 class_mode ='binário')

criar outro DirectoryIterator objeto do diretório de teste. Defina os parâmetros com os mesmos valores dos dados de treinamento.

# definindo o diretório de teste
test_data = test_datagen.flow_from_directory (directory='/content/drive/MyDrive/cats_and_dogs_filtered/test',
 target_size=(64, 64),
 batch_size=32,
 class_mode ='binário')

Criar uma final DirectoryIterator objeto do diretório de validação. Os parâmetros permanecem os mesmos dos dados de treinamento e teste.

# definindo o diretório de validação
validação_data = validação_datagen.flow_from_directory (diretório ='/content/drive/MyDrive/cats_and_dogs_filtered/validation',
 target_size=(64, 64),
 batch_size=32,
 class_mode ='binário')

Os iteradores de diretório não aumentam os conjuntos de dados de teste e validação.

Definindo seu modelo

Defina a arquitetura da sua rede neural. Use um Rede Neural Convolucional (CNN). As CNNs são projetadas para reconhecer padrões e recursos em imagens.

modelo = Sequencial()
# camada convolucional com 32 filtros de tamanho 3x3
model.add (Conv2D(32, (3, 3), ativação='relu', forma_de_entrada=(64, 64, 3))) 
# camada máxima de pooling com tamanho de pool 2x2
model.add (MaxPooling2D(pool_size=(2, 2))) 
# camada convolucional com 64 filtros de tamanho 3x3
model.add (Conv2D(64, (3, 3), ativação='relu'))
# camada máxima de pooling com tamanho de pool 2x2 
model.add (MaxPooling2D(pool_size=(2, 2))) 
# nivela a saída das camadas convolucionais e de pooling
model.add (Flatten()) 
# camada totalmente conectada com 128 unidades e ativação ReLU
model.add (Dense(128, ativação='relu')) 
# descarta aleatoriamente 50% das unidades para evitar overfitting
model.add (Desistir(0.5)) 
# camada de saída com ativação sigmoide (classificação binária)
model.add (Dense(1, ativação='sigmoide'))

Compile o modelo usando o binário entropia cruzada função de perda. Problemas de classificação binária geralmente usam It. Para o otimizador, use o otimizador Adam. É um algoritmo de otimização de taxa de aprendizado adaptativo. Finalmente, avalie o modelo em termos de precisão.

model.compile (perda='binary_crossentropy', otimizador='Adão', métricas=['precisão'])

Imprima um resumo da arquitetura do modelo no console.

modelo.resumo()

A captura de tela a seguir mostra a visualização da arquitetura do modelo.

Isso fornece uma visão geral da aparência do design do modelo.

Treinando seu modelo

Treine o modelo usando o ajustar() método. Defina o número de etapas por época para ser o número de amostras de treinamento dividido pelo tamanho do batch. Além disso, defina os dados de validação e o número de etapas de validação.

# Treine o modelo nos dados de treinamento
history = model.fit (train_data,
 steps_per_epoch=train_data.n // train_data.batch_size,
 épocas=50,
 validação_dados=validação_dados,
 validação_passos=validation_data.n // validação_data.batch_size)

O ImageDataGenerator A classe aplica o aumento de dados aos dados de treinamento em tempo real. Isso torna o processo de treinamento do modelo mais lento.

Avaliando seu modelo

Avalie o desempenho do seu modelo nos dados de teste usando o Avalie() método. Além disso, imprima a perda e a precisão do teste no console.

test_loss, test_acc = model.evaluate (test_data,
 steps=test_data.n // test_data.batch_size)
imprimir(f'Perda de teste: {test_loss}')
imprimir(f'Precisão do teste: {test_acc}')

A captura de tela a seguir mostra o desempenho do modelo.

O modelo funciona razoavelmente bem em dados nunca vistos.

Quando você executa o código que não implementa as técnicas de aumento de dados, a precisão do treinamento do modelo é 1. O que significa que superajusta. Ele também tem um desempenho ruim em dados que nunca viu antes. Isso ocorre porque ele aprende as peculiaridades do conjunto de dados.

Quando o aumento de dados não é útil?

• Quando o conjunto de dados já é diverso e grande: o aumento de dados aumenta o tamanho e a diversidade de um conjunto de dados. Se o conjunto de dados já for grande e diversificado, o aumento de dados não será útil.
• Quando o conjunto de dados é muito pequeno: o aumento de dados não pode criar novos recursos que não estão presentes no conjunto de dados original. Portanto, não pode compensar um pequeno conjunto de dados sem a maioria dos recursos que o modelo requer para aprender.
• Quando o tipo de aumento de dados é inadequado: por exemplo, girar imagens pode não ser útil quando a orientação dos objetos é importante.

Do que o TensorFlow é capaz

TensorFlow é uma biblioteca diversificada e poderosa. Ele é capaz de treinar modelos complexos de aprendizado profundo e pode ser executado em uma variedade de dispositivos, desde smartphones até clusters de servidores. Ele ajudou a capacitar os dispositivos de computação de ponta que utilizam aprendizado de máquina.