RandAugment para classificação de imagens com Keras/TensorFlow

O aumento de dados vem, há muito tempo, servindo como um meio de substituir um conjunto de dados “estático” por variantes transformadas, reforçando a invariância de Redes Neurais Convolucionais (CNNs), e geralmente levando à robustez da entrada.

Embora o aumento de dados na forma que estamos usando codifica um falta de conhecimento sobre variância translacional, que é importante para detecção de objetos, segmentação semântica e de instâncias, etc. invariância ele fornece muitas vezes é favorável para modelos de classificação e, portanto, o aumento é aplicado mais comumente e de forma mais agressiva aos modelos de classificação.

Tipos de Aumento

O aumento começou a ser muito simples - pequenas rotações, inversões horizontais e verticais, flutuações de contraste ou brilho, etc. Nos últimos anos, métodos mais elaborados foram desenvolvidos, incluindo Cortar fora (desistência espacial introduzindo quadrados pretos aleatoriamente nas imagens de entrada) e Misturar (misturando partes de imagens e atualizando as proporções do rótulo), e sua combinação – CorteMix. Os métodos de aumento mais recentes realmente levam em conta os rótulos, e métodos como CutMix alteram as proporções dos rótulos para serem iguais às proporções da imagem ocupada por partes de cada classe que está sendo misturada.

Com uma lista crescente de possíveis aumentos, alguns começaram a aplicá-los aleatoriamente (ou pelo menos alguns subconjuntos deles), com a ideia de que um conjunto aleatório de aumentos reforçará a robustez dos modelos e substituirá o conjunto original por um conjunto muito maior. espaço de imagens de entrada. Este é o lugar onde RandAugment entra em ação!

KerasCV e RandAugment

Keras CV é um pacote separado, mas ainda uma adição oficial ao Keras, desenvolvido pela equipe Keras. Isso significa que ele obtém a mesma quantidade de polimento e intuitividade do pacote principal, mas também se integra perfeitamente aos modelos Keras regulares e suas camadas. A única diferença que você notará é ligar keras_cv.layers... em vez de keras.layers....

KerasCV ainda está em desenvolvimento e já inclui 27 novas camadas de pré-processamento, RandAugment, CutMix e MixUp sendo alguns deles. Vamos dar uma olhada no que parece para aplicar RandAugment a imagens e como podemos treinar um classificador com e sem aumento aleatório.

Primeiro, instale keras_cv:

$ pip install keras_cv

Agora, vamos importar o TensorFlow, Keras e KerasCV, juntamente com os conjuntos de dados do TensorFlow para facilitar o acesso ao Imagenette:

import tensorflow as tf
from tensorflow import keras
import keras_cv
import tensorflow_datasets as tfds

Vamos carregar uma imagem e exibi-la em sua forma original:

import matplotlib.pyplot as plt
import cv2

cat_img = cv2.cvtColor(cv2.imread('cat.jpg'), cv2.COLOR_BGR2RGB)
cat_img = cv2.resize(cat_img, (224, 224))
plt.imshow(cat_img)

Agora vamos aplicar RandAugment a ele, várias vezes e dê uma olhada nos resultados:

fig = plt.figure(figsize=(10,10))
for i in range(16):
    ax = fig.add_subplot(4,4,i+1)
    aug_img = keras_cv.layers.RandAugment(value_range=(0, 255))(cat_img)
    
    ax.imshow(aug_img.numpy().astype('int'))

A camada tem um magnitude argumento, cujo padrão é 0.5 e pode ser alterado para aumentar ou diminuir o efeito do aumento:

fig = plt.figure(figsize=(10,10))
for i in range(16):
    ax = fig.add_subplot(4,4,i+1)
    aug_img = keras_cv.layers.RandAugment(value_range=(0, 255), magnitude=0.1)(cat_img)
    ax.imshow(aug_img.numpy().astype('int'))

Quando definido para um valor baixo, como 0.1 – você verá um aumento muito menos agressivo:

Sendo uma camada – pode ser usada dentro de modelos ou em tf.data pipelines ao criar conjuntos de dados. Isto faz RandAugment bem flexível! Os argumentos adicionais são os augmentations_per_image e rate argumentos, que trabalham juntos.

Escolha 0...augmentations_per_image, a camada adiciona uma camada de pré-processamento aleatório ao pipeline a ser aplicado a uma imagem. No caso do padrão 3 – três operações diferentes são adicionadas ao pipeline. Em seguida, um número aleatório é amostrado para cada aumento no pipeline - e se for menor que rate (padrão para cerca de 0.9) – o aumento é aplicado.

Em essência – há uma probabilidade de 90% de cada aumento (aleatório) no pipeline ser aplicado à imagem.

Isso naturalmente significa que nem todos os aumentos precisam ser aplicados, especialmente se você diminuir o rate. Você também pode personalizar quais operações são permitidas por meio de um RandomAugmentationPipeline camada, que RandAugment é o caso especial de. Um guia separado sobre RandomAugmentationPipeline será publicado em breve.

Treinando um classificador com e sem RandAugment

Para simplificar o aspecto de preparação/carregamento de dados e focar em RandAugment, vamos usar tfds para carregar em uma parte do Imagenette:

(train, valid_set, test_set), info = tfds.load("imagenette", 
                                           split=["train[:70%]", "validation", "train[70%:]"],
                                           as_supervised=True, with_info=True)

class_names = info.features["label"].names
n_classes = info.features["label"].num_classes
print(f'Class names: {class_names}') 
print('Num of classes:', n_classes) 

print("Train set size:", len(train)) 
print("Test set size:", len(test_set)) 
print("Valid set size:", len(valid_set)) 

Carregamos apenas uma parte dos dados de treinamento para facilitar o superajuste do conjunto de dados em menos épocas (fazendo com que nosso experimento seja executado mais rápido, na verdade). Como as imagens no Imagenette são de tamanhos diferentes, vamos criar um preprocess() função que os redimensiona para mapear o conjunto de dados, bem como um augment() função que aumenta as imagens em um tf.data.Dataset:

def preprocess(images, labels):
  return tf.image.resize(images, (224, 224)), tf.one_hot(labels, 10)
  
def augment(images, labels):
  inputs = {"images": images, "labels": labels}
  outputs = keras_cv.layers.RandAugment(value_range=(0, 255))(inputs)
  return outputs['images'], outputs['labels']

Agora – nós codificamos os rótulos. Não precisávamos necessariamente, mas para aprimoramentos como CutMix que mexem com rótulos e suas proporções, você terá que fazer isso. Como você pode querer aplicá-los, bem como RandAugment funciona muito bem com eles para criar classificadores robustos - vamos deixar a codificação one-hot. Além disso, RandAugment leva em um dicionário com imagens e rótulos exatamente por causa disso – alguns aumentos que você pode adicionar irão realmente alterar os rótulos, então eles são obrigatórios. Você pode extrair as imagens e rótulos aumentados do outputs dicionário facilmente, então este é um passo extra, mas simples, a ser seguido durante o aumento.

Vamos mapear os conjuntos de dados existentes retornados de tfds com o preprocess() função, lote-los e aumentar apenas o conjunto de treinamento:

valid_set = valid_set.map(preprocess).batch(32).prefetch(tf.data.AUTOTUNE)
train_set = train.map(preprocess).batch(32).prefetch(tf.data.AUTOTUNE)
train_set_aug = train.map(preprocess).map(augment_data, 
                                          num_parallel_calls=tf.data.AUTOTUNE).batch(32).prefetch(tf.data.AUTOTUNE)

Vamos treinar uma rede! keras_cv.models tem algumas redes embutidas, semelhantes a keras.applications. Embora a lista ainda seja curta - ela se expandirá com o tempo e assumirá o controle keras.applications. A API é muito semelhante, portanto, portar o código será bastante fácil para a maioria dos praticantes:

effnet = keras_cv.models.EfficientNetV2B0(include_rescaling=True, include_top=True, classes=10)
          
effnet.compile(
    loss='categorical_crossentropy',
    optimizer='adam',
    metrics=['accuracy']
)

history = effnet.fit(train_set, epochs=25, validation_data = valid_set)

Alternativamente, você pode usar o atual keras.applications:

effnet = keras.applications.EfficientNetV2B0(weights=None, classes=10)

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

history1 = effnet.fit(train_set, epochs=50, validation_data=valid_set)

Isso resulta em um modelo que realmente não funciona muito bem:

Epoch 1/50
208/208 [==============================] - 60s 238ms/step - loss: 2.7742 - accuracy: 0.2313 - val_loss: 3.2200 - val_accuracy: 0.3085
...
Epoch 50/50
208/208 [==============================] - 48s 229ms/step - loss: 0.0272 - accuracy: 0.9925 - val_loss: 2.0638 - val_accuracy: 0.6887

Agora, vamos treinar a mesma configuração de rede no conjunto de dados aumentado. Cada lote é aumentado individualmente, portanto, sempre que o mesmo lote de imagens (na próxima época) aparecer - eles terão aumentos diferentes:

effnet = keras.applications.EfficientNetV2B0(weights=None, classes=10)
effnet.compile(
  loss='categorical_crossentropy',
  optimizer='adam',
  metrics=['accuracy']
)

history2 = effnet.fit(train_set_aug, epochs=50, validation_data = valid_set)

Epoch 1/50
208/208 [==============================] - 141s 630ms/step - loss: 2.9966 - accuracy: 0.1314 - val_loss: 2.7398 - val_accuracy: 0.2395
...
Epoch 50/50
208/208 [==============================] - 125s 603ms/step - loss: 0.7313 - accuracy: 0.7583 - val_loss: 0.6101 - val_accuracy: 0.8143

Muito melhor! Embora você ainda queira aplicar outros aprimoramentos, como CutMix e MixUp, juntamente com outras técnicas de treinamento para maximizar a precisão da rede - apenas RandAugment ajudou significativamente e pode ser comparável a um pipeline de aumento mais longo.

Se você comparar as curvas de treinamento, incluindo o treinamento e curvas de validação - só fica claro o quanto RandAugment ajuda:

No pipeline não aumentado, a rede se sobreajusta (a precisão do treinamento atinge o teto) e a precisão da validação permanece baixa. No pipeline aumentado, o a precisão do treinamento permanece menor que a precisão da validação do início ao fim.

Com uma perda de treinamento maior, a rede fica muito mais ciente dos erros que ainda comete, e mais atualizações podem ser feitas para torná-la invariável às transformações. O primeiro não vê necessidade de atualização, enquanto o segundo o faz e eleva o teto do potencial.

Conclusão

Keras CV é um pacote separado, mas ainda uma adição oficial ao Keras, desenvolvido pela equipe Keras, com o objetivo de trazer CV de força da indústria para seus projetos Keras. KerasCV ainda está em desenvolvimento e já inclui 27 novas camadas de pré-processamento, RandAugment, CutMix e MixUp sendo alguns deles.

Neste pequeno guia, analisamos como você pode usar RandAugment para aplicar várias transformações aleatórias de uma determinada lista de transformações aplicadas e como é fácil incluir em qualquer pipeline de treinamento Keras.

Indo além - Aprendizado profundo prático para visão computacional

Sua natureza curiosa faz você querer ir mais longe? Recomendamos verificar nosso Para: “Aprendizado Profundo Prático para Visão Computacional com Python”.

Outro curso de visão computacional?

Não faremos classificação de dígitos MNIST ou moda MNIST. Eles cumpriram sua parte há muito tempo. Muitos recursos de aprendizado estão se concentrando em conjuntos de dados básicos e arquiteturas básicas antes de permitir que arquiteturas de caixa preta avançadas carreguem o fardo do desempenho.

Queremos focar em desmistificação, praticidade, compreensão, intuição e projetos reais. Quero aprender como você pode fazer a diferença? Vamos levá-lo em um passeio desde a maneira como nossos cérebros processam imagens para escrever um classificador de aprendizado profundo de nível de pesquisa para câncer de mama até redes de aprendizado profundo que “alucinam”, ensinando os princípios e a teoria por meio de trabalho prático, equipando você com o know-how e ferramentas para se tornar um especialista na aplicação de aprendizado profundo para resolver a visão computacional.

O que tem dentro?

• Os primeiros princípios da visão e como os computadores podem ser ensinados a “ver”
• Diferentes tarefas e aplicações de visão computacional
• As ferramentas do comércio que facilitarão seu trabalho
• Encontrar, criar e utilizar conjuntos de dados para visão computacional
• A teoria e aplicação das Redes Neurais Convolucionais
• Lidar com mudança de domínio, coocorrência e outros vieses em conjuntos de dados
• Transferir Aprendizagem e utilizar o tempo de treinamento e recursos computacionais de outros para seu benefício
• Construindo e treinando um classificador de câncer de mama de última geração
• Como aplicar uma dose saudável de ceticismo às ideias dominantes e entender as implicações de técnicas amplamente adotadas
• Visualizando o “espaço conceitual” de um ConvNet usando t-SNE e PCA
• Estudos de caso de como as empresas usam técnicas de visão computacional para obter melhores resultados
• Avaliação adequada do modelo, visualização do espaço latente e identificação da atenção do modelo
• Realizando pesquisas de domínio, processando seus próprios conjuntos de dados e estabelecendo testes de modelo
• Arquiteturas de ponta, a progressão das ideias, o que as torna únicas e como implementá-las
• KerasCV – uma biblioteca WIP para criar pipelines e modelos de última geração
• Como analisar e ler artigos e implementá-los você mesmo
• Selecionando modelos dependendo da sua aplicação
• Criando um pipeline de aprendizado de máquina de ponta a ponta
• Paisagem e intuição na detecção de objetos com R-CNNs, RetinaNets, SSDs e YOLO mais rápidos
• Segmentação de instância e semântica
• Reconhecimento de objetos em tempo real com YOLOv5
• Treinamento de detectores de objetos YOLOv5
• Trabalhando com Transformers usando KerasNLP (biblioteca WIP de força da indústria)
• Integrando Transformers com ConvNets para gerar legendas de imagens
• Deepdream
• Otimização de modelo de Deep Learning para visão computacional