Transformadores de Visão (ViTs): Visão Computacional com Modelos de Transformer

Tutoriais
Python

Nos últimos anos, os transformers transformaram o domínio de NLP em aprendizado de máquina. Modelos como GPT e BERT estabeleceram novos padrões na compreensão e geração da linguagem humana. Agora, o mesmo princípio está sendo aplicado ao domínio da visão computacional.
Um desenvolvimento recente no campo da visão computacional são os vision transformers ou ViTs. Como detalhado no artigo “Uma Imagem Vale 16×16 Palavras: Transformers para Reconhecimento de Imagens em Escala”, os ViTs e modelos baseados em transformers foram projetados para substituir redes neurais convolucionais (CNNs).
Os Vision Transformers são uma nova abordagem para resolver problemas na visão computacional. Em vez de depender de redes neurais convolucionais tradicionais (CNNs), que têm sido a espinha dorsal das tarefas relacionadas a imagens por décadas, os ViTs usam a arquitetura transformer para processar imagens. Eles tratam os recortes de imagem como palavras em uma frase, permitindo que o modelo aprenda as relações entre esses recortes, assim como aprende o contexto em um parágrafo de texto.

Ao contrário das CNNs, os ViTs dividem as imagens de entrada em patches, as serializam em vetores e reduzem sua dimensionalidade usando multiplicação de matrizes. Um codificador de transformador então processa esses vetores como incorporações de token. Neste artigo, exploraremos os transformadores de visão e suas principais diferenças das redes neurais convolucionais. O que os torna particularmente interessantes é sua capacidade de entender padrões globais em uma imagem, algo com o qual as CNNs podem ter dificuldade.

Pré-requisitos

  1. Fundamentos de Redes Neurais: Compreensão de como as redes neurais processam dados.
  2. Redes Neurais Convolucionais (CNNs): Familiaridade com CNNs e seu papel em visão computacional.
  3. Arquitetura de Transformadores: Conhecimento sobre transformadores, especialmente seu uso em processamento de linguagem natural.
  4. Processamento de Imagens: Compreensão de conceitos básicos como representação de imagem, canais e matrizes de pixels.
  5. Mecanismo de Atenção: Compreensão da autoatenção e sua capacidade de modelar relacionamentos entre entradas.

O que são transformadores de visão?

Transformadores de visão usam o conceito de atenção e transformadores para processar imagens—isso é semelhante aos transformadores em um contexto de processamento de linguagem natural (NLP). No entanto, em vez de usar tokens, a imagem é dividida em pequenos pedaços e fornecida como uma sequência de incorporações lineares. Esses pedaços são tratados da mesma maneira que tokens ou palavras são tratados em NLP.

Em vez de olhar para a imagem inteira simultaneamente, um ViT corta a imagem em pequenas partes como um quebra-cabeça. Cada parte é transformada em uma lista de números (um vetor) que descreve suas características, e então o modelo analisa todas as partes e descobre como elas se relacionam usando um mecanismo de transformador.

Diferente das CNNs, os ViTs funcionam aplicando filtros ou núcleos específicos sobre uma imagem para detectar características específicas, como padrões de bordas. Este é o processo de convolução que é muito semelhante a uma impressora digitalizando uma imagem. Esses filtros deslizam pela imagem inteira e destacam características significativas. A rede então empilha várias camadas desses filtros, identificando gradualmente padrões mais complexos.
Com as CNNs, camadas de pooling reduzem o tamanho dos mapas de características. Essas camadas analisam as características extraídas para fazer previsões úteis para reconhecimento de imagem, detecção de objetos, etc. No entanto, as CNNs têm um campo receptivo fixo, limitando assim a capacidade de modelar dependências de longo alcance.

Como as CNNs veem imagens?

ViTs, apesar de possuírem mais parâmetros, utilizam mecanismos de autoatenção para uma melhor representação de características e reduzem a necessidade de camadas mais profundas. CNNs requerem arquiteturas significativamente mais profundas para alcançar um poder representacional similar, o que leva a um aumento do custo computacional.

Além disso, CNNs não conseguem capturar padrões de imagem em nível global porque seus filtros focam em regiões locais de uma imagem. Para compreender a imagem inteira ou relações distantes, CNNs dependem de empilhar várias camadas e pooling, expandindo o campo de visão. No entanto, esse processo pode perder informações globais à medida que agrega detalhes passo a passo.

Por outro lado, ViTs dividem a imagem em patches que são tratados como tokens de entrada individuais. Usando autoatenção, ViTs comparam todos os patches simultaneamente e aprendem como eles se relacionam. Isso permite que capturem padrões e dependências em toda a imagem sem construí-los camada por camada.

O que é Viés Indutivo?

Antes de prosseguir, é importante entender o conceito de viés indutivo. Viés indutivo refere-se à suposição que um modelo faz sobre a estrutura dos dados; durante o treinamento, isso ajuda o modelo a ser mais generalizado e reduzir o viés. Nas CNNs, os viéses indutivos incluem:

  1. Localidade: Características em imagens (como bordas ou texturas) são localizadas em pequenas regiões.
  2. Estrutura de vizinhança bidimensional: Pixels próximos têm maior probabilidade de estarem relacionados, então filtros operam em regiões espacialmente adjacentes.
  3. Equivariança de tradução: Características detectadas em uma parte da imagem, como uma borda, mantêm o mesmo significado se aparecerem em outra parte.

Esses vieses tornam as CNNs altamente eficientes para tarefas de imagem, pois são projetadas para explorar as propriedades espaciais e estruturais das imagens.

Os Vision Transformers (ViTs) têm um viés indutivo específico de imagem significativamente menor do que as CNNs. Em ViTs:

  • Processamento global: Camadas de autoatenção operam em toda a imagem, permitindo que o modelo capture relacionamentos e dependências globais sem ser restrito por regiões locais.
  • Estrutura 2D mínima: A estrutura 2D da imagem é utilizada apenas no início (quando a imagem é dividida em patches) e durante o ajuste fino (para ajustar embeddings posicionais para diferentes resoluções). Ao contrário das CNNs, os ViTs não assumem que pixels próximos estão necessariamente relacionados.
  • Relações espaciais aprendidas: Embeddings posicionais em ViTs não codificam relações espaciais 2D específicas na inicialização. Em vez disso, o modelo aprende todas as relações espaciais a partir dos dados durante o treinamento.

Como os Vision Transformers Funcionam

Os Vision Transformers utilizam a arquitetura Transformer padrão desenvolvida para sequências de texto 1D. Para processar as imagens 2D, elas são divididas em patches menores de tamanho fixo, como P x P pixels, que são achatados em vetores. Se a imagem tem dimensões H x W com C canais, o número total de patches é N = H x W / P x P, o comprimento efetivo da sequência de entrada para o Transformer. Esses patches achatados são então projetados linearmente em um espaço dimensional fixo D, chamado de incorporações de patch.

Um token especial aprendível, semelhante ao token [CLS] no BERT, é prefixado à sequência de incorporações de patch. Este token aprende uma representação global da imagem que é posteriormente utilizada para classificação. Além disso, incorporações posicionais são adicionadas às incorporações de patch para codificar informações posicionais, ajudando o modelo a entender a estrutura espacial da imagem.

A sequência de embeddings é passada pelo codificador Transformer, que alterna entre duas operações principais: Autoatenção Multicabeça (MSA) e uma rede neural feedforward, também chamada de bloco MLP. Cada camada inclui Normalização de Camada (LN) aplicada antes dessas operações e conexões residuais adicionadas posteriormente para estabilizar o treinamento. A saída do codificador Transformer, especificamente o estado do token [CLS], é usada como a representação da imagem.

Uma cabeça simples é adicionada ao token [CLS] final para tarefas de classificação. Durante o pré-treinamento, esta cabeça é um pequeno perceptron de múltiplas camadas (MLP), enquanto no ajuste fino, é tipicamente uma única camada linear. Essa arquitetura permite que os ViTs modelem efetivamente as relações globais entre os patches e utilizem todo o poder da autoatenção para compreensão de imagens.

Em um modelo híbrido de Vision Transformer, em vez de dividir diretamente imagens brutas em patches, a sequência de entrada é derivada de mapas de características gerados por uma CNN. A CNN processa a imagem primeiro, extraindo características espaciais significativas, que são então usadas para criar patches. Esses patches são achatados e projetados em um espaço dimensional fixo usando a mesma projeção linear treinável que em Vision Transformers padrão. Um caso especial dessa abordagem é usar patches de tamanho 1×1, onde cada patch corresponde a uma única localização espacial no mapa de características da CNN.

Neste caso, as dimensões espaciais do mapa de características são achatadas, e a sequência resultante é projetada na dimensão de entrada do Transformer. Assim como no ViT padrão, um token de classificação e incorporações posicionais são adicionados para manter informações posicionais e permitir a compreensão global da imagem. Esta abordagem híbrida aproveita as forças de extração de características locais das CNNs enquanto as combina com as capacidades de modelagem global dos Transformers.

Demonstração de Código

Aqui está o bloco de código sobre como usar os transformadores de visão em imagens.

# Instalar as bibliotecas necessárias
pip install -q transformers

from transformers import ViTForImageClassification  
from PIL import Image  
from transformers import ViTImageProcessor

import requests  
import torch

# Carregar o modelo e movê-lo para a 'GPU'
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

model = ViTForImageClassification.from_pretrained('google/vit-base-patch16-224')  
model.to(device)

# Carregar a imagem para realizar previsões
url = 'link to your image'  
image = Image.open(requests.get(url, stream=True).raw)

processor = ViTImageProcessor.from_pretrained('google/vit-base-patch16-224')  
inputs = processor(images=image, return_tensors="pt").to(device)  
pixel_values = inputs.pixel_values  
# print(pixel_values.shape)

O modelo ViT processa a imagem. Ele compreende um codificador semelhante ao BERT e uma cabeça de classificação linear localizada no topo do estado oculto final do token [CLS].

with torch.no_grad():  
  outputs = model(pixel_values)  
logits = outputs.logits

# logits.shape

prediction = logits.argmax(-1)  
print("Predicted class:", model.config.id2label[prediction.item()])

Aqui está uma implementação básica do Vision Transformer (ViT) usando o PyTorch. Este código inclui os componentes principais: incorporação de patches, codificação posicional e o codificador Transformer. Isso pode ser usado para tarefas simples de classificação.

import torch
import torch.nn as nn
import torch.nn.functional as F

class VisionTransformer(nn.Module):
    def __init__(self, img_size=224, patch_size=16, num_classes=1000, dim=768, depth=12, heads=12, mlp_dim=3072, dropout=0.1):
        super(VisionTransformer, self).__init__()
        
        # Dimensões da imagem e do patch
        assert img_size % patch_size == 0, "Image size must be divisible by patch size"
        self.num_patches = (img_size // patch_size) ** 2
        self.patch_dim = (3 * patch_size ** 2)  # Considerando 3 canais (RGB)
        
        # Camadas
        self.patch_embeddings = nn.Linear(self.patch_dim, dim)
        self.position_embeddings = nn.Parameter(torch.randn(1, self.num_patches + 1, dim))
        self.cls_token = nn.Parameter(torch.randn(1, 1, dim))
        self.dropout = nn.Dropout(dropout)
        
        # Codificador do Transformer
        self.transformer = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(d_model=dim, nhead=heads, dim_feedforward=mlp_dim, dropout=dropout),
            num_layers=depth
        )
        
        # Cabeça MLP para classificação
        self.mlp_head = nn.Sequential(
            nn.LayerNorm(dim),
            nn.Linear(dim, num_classes)
        )
    
    def forward(self, x):
        # Achatamento dos patches e incorporação
        batch_size, channels, height, width = x.shape
        patch_size = height // int(self.num_patches ** 0.5)

        x = x.unfold(2, patch_size, patch_size).unfold(3, patch_size, patch_size)
        x = x.contiguous().view(batch_size, 3, patch_size, patch_size, -1)
        x = x.permute(0, 4, 1, 2, 3).flatten(2).permute(0, 2, 1)
        x = self.patch_embeddings(x)
        
        # Adicionar incorporações posicionais
        cls_tokens = self.cls_token.expand(batch_size, -1, -1)
        x = torch.cat((cls_tokens, x), dim=1)
        x = x + self.position_embeddings
        x = self.dropout(x)
        
        # Codificador do Transformer
        x = self.transformer(x)
        
        # Cabeça de classificação
        x = x[:, 0]  # Token CLS
        return self.mlp_head(x)

# Exemplo de uso
if __name__ == "__main__":
    model = VisionTransformer(img_size=224, patch_size=16, num_classes=10, dim=768, depth=12, heads=12, mlp_dim=3072)
    print(model)
    
    dummy_img = torch.randn(8, 3, 224, 224)  # Lote de 8 imagens, 3 canais, tamanho 224x224
    preds = model(dummy_img)
    print(preds.shape)  # Saída: [8, 10] (Tamanho do lote, Número de classes)

Componentes principais:

  1. Incorporação de Patches: As imagens são divididas em patches menores, achatadas e transformadas linearmente em incorporações.
  2. Codificação Posicional: Informações posicionais são adicionadas às incorporações dos patches, pois os Transformers são agnósticos em relação à posição.
  3. Codificador do Transformer: Aplica camadas de autoatenção e feed-forward para aprender as relações entre os patches.
  4. Cabeça de Classificação: Produz as probabilidades de classes usando o token CLS.

Você pode treinar este modelo em qualquer conjunto de dados de imagem usando um otimizador como Adam e uma função de perda como entropia cruzada. Para melhor desempenho, considere o pré-treinamento em um grande conjunto de dados antes de ajustar finamente.

  • DeiT (Transformadores de Imagem Eficientes em Dados) do Facebook AI: Estes são transformadores de visão treinados de forma eficiente com destilação de conhecimento. O DeiT oferece quatro variantes: deit-tiny, deit-small, e dois modelos deit-base. Use DeiTImageProcessor para preparar as imagens.

  • BEiT (Treinamento prévio do BERT com Transformadores de Imagem) pela Microsoft Research: Inspirado pelo BERT, o BEiT utiliza modelagem de imagem mascarada auto-supervisionada e supera os ViTs supervisionados. Ele depende do VQ-VAE para treinamento.

  • DINO (Treinamento Auto-supervisionado do Transformador de Visão) pela Facebook AI: Os ViTs treinados pelo DINO podem segmentar objetos sem treinamento explícito. Pontos de verificação estão disponíveis online.

  • MAE (Autoencoders Máscara) do Facebook pré-treina ViTs reconstruindo patches mascarados (75%). Quando ajustado, esse método simples supera o pré-treinamento supervisionado.

Conclusão

Em conclusão, ViTs são uma excelente alternativa para CNNs, pois aplicam transformers ao reconhecimento de imagens, minimizam o viés indutivo e tratam imagens como patches de sequência. Essa abordagem simples, mas escalável, demonstrou desempenho de ponta em muitos benchmarks de classificação de imagens, especialmente quando combinada com pré-treinamento em grandes conjuntos de dados. No entanto, desafios potenciais permanecem, incluindo a extensão dos ViTs para tarefas como detecção de objetos e segmentação, aprimoramento adicional dos métodos de pré-treinamento auto-supervisionados e exploração do potencial de escalar os ViTs para um desempenho ainda melhor.

Recursos Adicionais

Source:
https://www.digitalocean.com/community/tutorials/vision-transformer-for-computer-vision