Redes Neurais Convolucionais (CNN): O que é Normalização em lote (Batch normalization), e como podemos implementá-la.

As redes neurais convolucionais (CNNs) são um tipo de modelo de aprendizado profundo, amplamente utilizado em tarefas de visão computacional como reconhecimento de imagens e detecção de objetos. Inspiradas pela organização do córtex visual do cérebro humano, as CNNs são projetadas para extrair características relevantes de imagens por meio de camadas de convolução e pooling, comumente seguidas por camadas totalmente conectadas quando o objetivo alvo é classificação.

A normalização em lote é uma etapa crucial no processo de convolução, pois ela visa melhorar a similaridade angular entre os vetores que representam os patches de imagens e os kernels convolucionais. A convolução computa essa similaridade por meio do produto interno entre os vetores, o que implica na necessidade de escalar essa similaridade pela magnitude de ambos vetores. No entanto, o produto interno pode acabar aumentando a similaridade mesmo para patches que estão em ângulos piores, mas distantes. A normalização, como a z-score, ajuda a distribuir os patches em torno da origem do sistema, tornando o espaço de características mais adequado para a operação de convolução. Ela consiste em subtrair a média e dividir pelo desvio-padrão, reduzindo as magnitudes e aumentando os ângulos. A normalização em lote não depende apenas do mini-batch, pois os kernels valem para todo o conjunto de dados, permitindo aprender características da distribuição do dado como um todo, o que não seria possível se a normalização fosse feita apenas no mini-batch.

O processo de normalização em lote segue os seguintes passos:

Cálculo das estatísticas do lote

Para cada mini-lote, são calculadas a média e o desvio padrão das ativações de entrada.

A média do lote (mean) é calculada para cada característica (ou dimensão) como:

mean = (1/m) * ∑(X)

Onde ∑(X) é a soma dos valores de X em todas as dimensões para todos os exemplos no mini-lote.

O desvio padrão do lote (std) é calculado para cada característica como:

std = sqrt((1/m) * ∑((X - mean)^2))

Onde ∑((X — mean)²) é a soma dos quadrados das diferenças entre os valores de X e a média do lote, em todas as dimensões, para todos os exemplos no mini-lote.

Normalização das entradas

As ativações de entrada do mini-lote são normalizadas subtraindo a média do lote e dividindo pelo desvio padrão do lote. Onde as entradas mini-lote X são normalizadas em cada dimensão:

X_norm = (X - mean) / std

Isso garante que as ativações de entrada tenham média zero e variância unitária.

Escalonamento e deslocamento

As entradas normalizadas são escalonadas por um parâmetro ajustável chamado gamma e deslocadas por outro parâmetro ajustável chamado beta. Esses parâmetros são aprendidos durante o treinamento e permitem que o modelo recupere a capacidade de representação da rede, fornecendo a flexibilidade para aprender padrões complexos.

As entradas normalizadas são escalonadas por um parâmetro ajustável gamma e deslocadas por outro parâmetro ajustável beta, em cada dimensão:

Z = gamma * X_norm + beta

Onde gamma e beta são parâmetros aprendidos durante o treinamento e permitem que o modelo restaure a capacidade de representação da rede, dando-lhe a flexibilidade para aprender padrões complexos.

Incorporação no processo de otimização

As entradas normalizadas e escalonadas são passadas pela função de ativação e usadas nas camadas subsequentes da rede neural. Durante a retropropagação, os gradientes são calculados em relação às entradas normalizadas, gamma e beta, e os parâmetros do modelo são atualizados de acordo.

Implementação

Dentro do escopo da linguagem Python, temos alguns frameworks como TensorFlow, PyTorch, Keras, Caffe e MXNet que oferecem suporte para a normalização em lote.

No TensorFlow, a camada tf.keras.layers.BatchNormalization é integrada aos modelos de CNN, melhorando a estabilidade e o desempenho da rede.

O PyTorch disponibiliza a camada torch.nn.BatchNorm2d, projetada especificamente para dados 2D, como imagens, facilitando sua incorporação em modelos de CNN. O Keras, construído sobre o TensorFlow, possui a camada keras.layers.BatchNormalization, permitindo a aplicação da normalização em lote em arquiteturas personalizadas.

O Caffe, focado em eficiência e simplicidade, suporta a normalização em lote por meio da camada BatchNorm, que pode ser facilmente integrada em arquiteturas de CNN.

Por fim, o MXNet oferece a camada mxnet.gluon.nn.BatchNorm para aplicação direta da normalização em lote em modelos de CNN, proporcionando benefícios sem complicações adicionais aos pesquisadores e profissionais.

A implementação com a utilização desses frameworks é bem simples, um exemplo seria uma implementação pequena utilizando TensorFlow, aplicando a camada de normalização, como podemos ver a seguir:

import tensorflow as tf
from tensorflow.keras import layers

# Create a simple CNN model with batch normalization
model = tf.keras.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu',input_shape=(32, 32, 3)),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.BatchNormalization(),
    layers.MaxPooling2D((2, 2)),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.BatchNormalization(),
    layers.Dense(10, activation='softmax')
])

# Compile the model
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Load and preprocess the CIFAR-10 dataset
(x_train, y_train),(x_test, y_test) = tf.keras.datasets.cifar10.load_data()
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

# Train the model
model.fit(x_train, y_train, epochs=10, batch_size=64,
          validation_data=(x_test, y_test))

# Evaluate the model
test_loss, test_acc = model.evaluate(x_test, y_test)
print('Test accuracy:', test_acc)

Conclusão

Em conclusão, a normalização em lote é uma técnica essencial no uso de redes neurais para melhorar o desempenho e estabilidade do modelo. Ao normalizar as entradas dentro de cada mini-lote durante o treinamento, a média zero e variância unitária são garantidas, o que ajuda a evitar problemas de convergência lenta ou divergência do modelo. Além disso, o escalonamento e deslocamento das entradas normalizadas por meio de parâmetros ajustáveis durante o processo de otimização permitem que o modelo recupere a capacidade de representação da rede, permitindo a aprendizagem de padrões complexos. Portanto, compreender e aplicar corretamente a normalização em lote é fundamental para maximizar o potencial do machine learning e obter resultados mais precisos e confiáveis em diversas áreas de aplicação.

→ Siga o nosso blog pelo Medium e fique por dentro de tudo o que acontece no Ateliê de Software.

Dê um alô pra gente! E nos acompanhe nas redes sociais:

→ E-mail: contato@atelie.software
→ Site
→ Facebook
→ Instagram
→ LinkedIn