Autoencoders: redes neurais semi-supervisionadas
À medida que a tecnologia continua a evoluir a uma velocidade acelerada, a busca por sistemas mais inteligentes e eficientes fica cada vez mais fundamental. Precisamente por isso que os autoencoders se tornaram muito significativos nos círculos de inteligência artificial (IA).
Em sua essência, autoencoders representam uma classe de redes neurais semi-supervisionadas. (Alguns autores consideram autoencoders modelos com aprendizagem não-supervisionada). Eles são projetados para aprender representações eficientes para reconstrução de dados de entrada com perdas mínimas. Isso permite a esses algoritmos identificar informações importantes sem instruções explícitas.
Os autoencoders são treinados a extrair padrões e recursos em grandes conjuntos de dados não rotulados. Porém, embora o foco principal esteja em dados não rotulados, há um certo grau de supervisão envolvido. A mágica dos autoencoders está em sua capacidade de aprender por analogia. Com base no que viram antes (os dados não rotulados), eles criam uma versão compactada que representa os principais recursos e estruturas na entrada. Como o objetivo de um autoencoder é reconstruir os dados de entrada, os dados atuam como uma forma de supervisão.
O Funcionamento
Autoencoders são uma forma especializada de arquitetura de rede neural artificial projetada para adquirir representações de dados eficientes. Essas redes são treinadas para reconstruir seus dados de entrada em um formato compactado. Mas a compactação deve ocorrer sem perder os detalhes essenciais necessários para tarefas como detecção de anomalias ou redução de ruído de imagens e sons. Os autoencoder aprendem uma representação de dimensão inferior dos dados, comumente chamada de espaço latente.
O funcionamento dos autoencoders envolve uma fase inicial de codificação. Nessa etapa, os dados de entrada são processados por meio de uma rede neural codificadora (encoder) para mapeá-los para um espaço latente de dimensão inferior. Posteriormente, na fase de decodificação, a representação latente é transmitida através de uma rede neural decodificadora (decoder). Esse estágio visa reconstruir os dados de entrada originais a partir da representação comprimida. Durante o treinamento, um autoencoder é otimizado iterativamente para minimizar o erro de reconstrução entre a entrada original e a saída reconstruída.
Estrutura de uma rede neural de um autoencoder mostrando sua parte codificadora (encoder), o espaço latente e a parte decodificadora (decoder) (fonte).
Autoencoders e suas aplicações
A versatilidade dos autoencoders se estende a diversas aplicações em vários domínios.
Os autoencoders são capazes de aprender representações eficientes de imagens e vídeos, levando a uma compactação significativa sem comprometer a qualidade. A rede do codificador compacta os dados, enquanto o decodificador os reconstrói. Ao reduzir o tamanho dos dados, os autoencoders podem economizar espaço de armazenamento e aumentar as velocidades de transmissão.
Os autoencoders podem aprender representações vetoriais de baixa dimensão de dados de textos, capturando seus significados semânticos. Essas incorporações (vector embeddings) são usadas em tarefas como pesquisa de similaridade e sistemas de recomendação.
A capacidade de modelagem generativa dos autoencoders variacionais (VAEs) permite a geração de novas amostras de dados semelhantes aos dados de treinamento.
Autoencoders também podem ser treinados para remover o ruído de imagens e sinais. Essa aplicação tem sido usada com sucesso para reduzir o ruído de imagens médicas, aumentando a precisão das tarefas de diagnóstico.
Autoencoder em código
Para ilustrar como pode ser feita a implementação de um autoencoder, faremos um modelo com Keras. Esse exemplo consiste em treinar uma rede para compactar e descompactar dados de imagens. O conjunto de dados que usaremos é o MNIST. O autoencoder terá camadas convolucionais no codificador e no decodificador. Elas são mais apropriadas para esse exemplo por preservarem a estrutura espacial das imagens durante o processo de codificação e decodificação. Isso permite a captura de recursos e padrões locais que podem ser perdidos em autoencoders tradicionais.
Iniciamos a implementação com as importações necessárias, o carregamento dos dados e seu pré-processamento:
import numpy as np
import matplotlib.pyplot as plt
from keras import Sequential
from keras.layers import Dense, Conv2D, MaxPooling2D, UpSampling2D
from keras.datasets import mnist
# carrega o conjunto de dados e separa um conjunto de treino e teste
(x_train, _), (x_test, _) = mnist.load_data()
# normaliza as imagens
x_train = x_train.astype('float32') / 255
x_test = x_test.astype('float32') / 255
# reformata as imagens para o modelo
x_train = x_train.reshape(len(x_train), 28, 28, 1)
x_test = x_test.reshape(len(x_test), 28, 28, 1)
A estrutura do modelo
Em seguida, definimos o modelo:
model = Sequential([
# Camadas do codificador (encoder): comprimem as imagens em um espaço latente de dimensão inferior
Conv2D(32, 3, activation='relu', padding='same', input_shape=(28, 28, 1)),
MaxPooling2D(2, padding='same'),
Conv2D(16, 3, activation='relu', padding='same'),
MaxPooling2D(2, padding='same'),
# Camadas do decodificador (decoder): recriam as imagens do espaço latente de dimensão inferior em sua dimensão original
Conv2D(16, 3, activation='relu', padding='same'),
UpSampling2D(2),
Conv2D(32, 3, activation='relu', padding='same'),
UpSampling2D(2),
# output layer
Conv2D(1, 3, activation='sigmoid', padding='same')
])
A estrutura desse modelo possui camadas próprias para o encoder (codificador) e para o decoder.
O modelo do encoder utiliza camadas convolucionais com ativação ReLU e padding same. Elas são utilizadas para extrair características das imagens de entrada. A primeira camada extrai 32 filtros de 3×3 píxeis, enquanto a segunda extrai 16 filtros. As camadas de max-pooling reduzem a dimensionalidade das representações, ajudando a capturar características mais abrangentes e invariantes a pequenas translações.
O decoder possui camadas convolucionais transpostas (ou deconvolucionais). Elas são usadas para reconstruir a imagem a partir da representação latente. A ativação ReLU é usada para introduzir não-linearidade, enquanto o padding same ajuda a preservar o tamanho da imagem. As camadas de upsampling aumentam a resolução da imagem, permitindo a reconstrução de detalhes mais finos.
Treinamento e teste
Após a definição do modelo, ele precisa ser compilado e treinado:
# compila modelo
model.compile(optimizer='adam', loss='binary_crossentropy')
# trenamento do modelo
model.fit(x_train, x_train, epochs=20, batch_size=256, validation_data=(x_test, x_test))
Por fim, verificamos a capacidade do modelo de comprimir e reconstruir imagens plotando alguns exemplos dos dados originais e dados gerados:
pred = model.predict(x_test)
plt.figure(figsize=(10, 4))
# plota algumas images originais e geradas pelo modelo
for i in range(3):
idx = np.random.randint(len(x_test))
ax = plt.subplot(3, 2, 1+i*2)
plt.imshow(x_test[idx].reshape(28,28))
plt.gray()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
ax = plt.subplot(3, 2, 2+i*2)
plt.imshow(pred[idx].reshape(28,28))
plt.gray()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
plt.show()
Abaixo, as colunas 1 e 3 mostram imagens selecionadas aleatoriamente do conjunto de dados. Nas colunas 2 e 4 são mostradas as imagens correspondentes geradas pelo modelo.
