[Tradução] Explicação visual do Vision Transformer (A Visual Guide to Vision Transformers)

(discuss.pytorch.kr)

13 pontos por ninebow 2024-04-22 | 1 comentários | Compartilhar no WhatsApp

ℹ️ Após ler o artigo guia visual de Visual Transformers, apresentado pelo xguru, e com a autorização do autor Dennis Turp, cientista de dados e engenheiro de software, traduzi o texto que ele escreveu, explicação visual do Vision Transformer (ViT) (A Visual Guide to Vision Transformers).
O Vision Transformer (ViT) é um modelo que aplica Transformers à área de CV (Computer Vision) e apresenta excelente desempenho em áreas como detecção de objetos e classificação de imagens. Em especial, ele é bastante usado como Visual Encoder para extrair características (features) de imagens.
Como a explicação do texto original é breve e pode ser difícil de entender, alguns comentários foram adicionados para facilitar a compreensão.

Explicação visual do Vision Transformer (ViT)

Este texto é uma explicação visual sobre os Vision Transformers (ViTs), modelos de deep learning que apresentam desempenho de ponta (SotA, State-of-the-Art) em tarefas de classificação de imagens. O Vision Transformer aplica a arquitetura Transformer, originalmente criada para processamento de linguagem natural (NLP), a dados de imagem. Aqui, você poderá entender como o Vision Transformer funciona por meio de explicações simples junto com visualizações que ajudam a acompanhar o fluxo dos dados conforme se avança pela página. (:pytorch::kr:: Como aqui é difícil reproduzir a explicação com rolagem, ela foi substituída por capturas de imagem. Vale a pena consultar também o texto original.)
> This is a visual guide to Vision Transformers (ViTs), a class of deep learning models that have achieved state-of-the-art performance on image classification tasks. Vision Transformers apply the transformer architecture, originally designed for natural language processing (NLP), to image data. This guide will walk you through the key components of Vision Transformers in a scroll story format, using visualizations and simple explanations to help you understand how these models work and how the flow of the data through the model looks like.

0. Observando os dados / Lets start with the data

Assim como as redes neurais convolucionais (CNNs) comuns, o Vision Transformer também é treinado de forma supervisionada (Supervised Learning). Ou seja, o modelo é treinado com um conjunto de dados composto por imagens e seus respectivos rótulos (labels).
> Like normal convolutional neural networks, vision transformers are trained in a supervised manner. This means that the model is trained on a dataset of images and their corresponding labels.

1. Focando em apenas um dado / Focus on one data point

Para entender melhor como o Vision Transformer funciona internamente, vamos primeiro focar em apenas um dado (tamanho de batch 1). E vamos pensar juntos nesta pergunta: como esse dado deve ser preparado (pré-processado) para ser consumido por um Transformer?
> To get a better understanding of what happens inside a vision transformer lets focus on a single data point (batch size of 1). And lets ask the question: How is this data point prepared in order to be consumed by a transformer?

2. Deixando o rótulo de lado por enquanto / Forget the label for the moment

O rótulo ficará mais relevante mais adiante. Por enquanto, o que nos resta é apenas uma única imagem.
> The label will become more relevant later. For now the only thing that we are left with is a single image.

3. Dividindo a imagem em patches / Create patches of the image

A imagem inteira é dividida em patches de tamanho uniforme (p x p) para prepará-la para uso dentro do Transformer.
> To prepare the image for the use inside the transformer we divide the image into equally sized patches of size p x p.

4. Achatando os patches da imagem / Flatting of the image patches

Os patches são achatados (flatten) em vetores de dimensão p' = p² x c. Aqui, p é o tamanho de um lado do patch, e c é o número de canais. (:pytorch::kr:: Por exemplo, no caso de uma imagem RGB, o número de canais é 3.)
> The patches are now flattened into vectors of dimension p'= p²*c where p is the size of the patch and c is the number of channels.

5. Criando embeddings a partir dos patches / Creating patch embeddings

Os vetores criados anteriormente a partir dos patches da imagem são então codificados por meio de uma transformação linear. O vetor de embedding de patch (Patch Embedding Vector) resultante tem tamanho fixo d.
> These image patch vectors are now encoded using a linear transformation. The resulting Patch Embedding Vector has a fixed size d.

6. Fazendo embedding de todos os patches / Embedding all patches

Depois de embutir todos os patches da imagem em vetores de tamanho fixo, obtemos um arranjo de tamanho n x d, em que n é o número de patches da imagem e d é o tamanho do embedding de cada patch.
> Now that we have embedded our image patches into vectors of fixed size, we are left with an array of size n x d where n is the the number of image patches and d is the size of the patch embedding

7. Adicionando um token de classificação (CLS) / Appending a classification token

Para treinar o modelo de forma eficaz, adicionamos aos embeddings de patch um vetor extra chamado token de classificação (token CLS). Esse vetor é um parâmetro aprendível da rede neural e é inicializado aleatoriamente. Observação: há apenas um token CLS, e o mesmo vetor é adicionado a todos os dados. (:pytorch::kr:: Ao fazer isso, somamos o token CLS aos n embeddings de patch, resultando em (n+1) elementos, cada um com tamanho de embedding d, ou seja, (n+1) x d.)

In order for us to effectively train our model we extend the array of patch embeddings by an additional vector called classification token (cls token). This vector is a learnable parameter of the network and is randomly initialized. Note: We only have one cls token and we append the same vector for all data points.

8. Adicionar vetores de embedding de posição / Add positional embedding Vectors

Até agora, os embeddings de patch não possuem informação de posição associada. Resolvemos isso adicionando a todos os embeddings de patch um vetor de embedding de posição (Positional Embedding Vector) aprendível e inicializado aleatoriamente. Também adicionamos esse tipo de vetor de posição ao token de classificação (token CLS) que foi incluído anteriormente. (:pytorch::kr:: No Transformer, os valores de Positional Encoding são "somados". Portanto, não há mudança no tamanho do vetor.)

Currently our patch embeddings have no positional information associated with them. We remedy that by adding a learnable randomly initialized positional embedding vector to all our patch embeddings. We also add a such a positional embedding vector to our classification token.

9. Inserir no Transformer / Transformer Input

Depois de adicionar os vetores de embedding de posição, ficamos com um array de tamanho (n+1) x d. Esse será o input do Transformer, que será explicado com mais detalhes nas próximas etapas.

After the positional embedding vectors have been added we are left with an array of size (n+1) x d. This will be our input for the transformer which will be explained in greater detail in the next steps.

10.1. Transformer: criação de QKV / QKV Creation

Os vetores de embedding de patch de entrada do Transformer são projetados linearmente em vários vetores grandes. Esses novos vetores são então divididos em três partes de mesmo tamanho. Elas correspondem a Q, o vetor de consulta (Query), K, o vetor-chave (Key) e V, o vetor de valor (Value). Teremos (n+1) vetores de cada um deles.

Our transformer input patch embedding vectors are linearly embedded into multiple large vectors. These new vectors are than separated into three equal sized parts. The Q - Query Vector, the K - Key Vector and the V - Value Vector . We will have (n+1) of a all of those vectors.

10.2. Transformer: calcular os scores de atenção / Attention Score Calculation

Primeiro, para calcular os scores de atenção A, multiplicamos todos os vetores de consulta Q por todos os vetores-chave K.

To calculate our attention scores A we will now multiply all of our query vectors Q with all of our key vectors K.

10.3. Transformer: matriz de scores de atenção / Attention Score Matrix

Com a matriz de scores de atenção A obtida, aplicamos a função softmax a cada linha para que a soma dos elementos de cada linha seja 1.

Now that we have the attention score matrix A we apply a softmax function to every row such that every row sums up to 1.

10.4. Transformer: calcular a informação contextual agregada / Aggregated Contextual Information Calculation

Para calcular a informação contextual agregada (aggregated contextual information) do primeiro vetor de embedding de patch, focamos na primeira linha da matriz de atenção. Em seguida, usamos as entradas dessa linha como pesos para os vetores de valor V, gerando o vetor de informação contextual agregada (aggregated vector) do primeiro embedding de patch da imagem.

To calculate the aggregated contextual information for the first patch embedding vector. We focus on the first row of the attention matrix. And use the entires as weights for our Value Vectors V. The result is our aggregated contextual information vector for the first image patch embedding.

10.5. Transformer: obter a informação contextual agregada para todos os patches / Aggregated Contextual Information for every patch

Agora repetimos esse processo para cada linha da matriz de scores de atenção, e o resultado será N+1 vetores de informação contextual agregada. Um para cada patch + um para o token de classificação. Essa etapa conclui nosso primeiro Attention Head.

Now we repeat this process for every row of our attention score matrix and the result will be N+1 aggregated contextual information vectors. One for every patch + one for the classification token. This steps concludes our first Attention Head.

10.6. Transformer: atenção multi-head / Multi-Head Attention

Como estamos lidando com a atenção multi-head (do Transformer), repetimos todo o processo de 10.1 a 10.5 novamente com um mapeamento QKV diferente. Na nossa configuração explicativa, assumimos 2 heads, mas normalmente um ViT tem muitos mais. No fim, isso resulta em vários vetores de informação contextual agregada (Multiple Aggregated Contextual Information Vectors).

Now because we are dealing multi head attention we repeat the entire process from step 10.1 - 10-5 again with a different QKV mapping. For our explanatory setup we assume 2 Heads but typically a VIT has many more. In the end this results in multiple Aggregated contextual information vectors.

10.7. Transformer: última etapa da camada de atenção / Last Attention Layer Step

Depois de empilhar esses vários heads, eles são mapeados para vetores de tamanho d, o mesmo tamanho dos patch embeddings.

These heads are stacked together and are mapped to vectors of size d which was the same size as our patch embeddings had.

10.8. Transformer: obter o resultado da camada de atenção / Attention Layer Result

Com isso, a camada de atenção foi concluída a partir da etapa anterior, e obtivemos embeddings com exatamente o mesmo tamanho dos usados na entrada.

The previous step concluded the attention layer and we are left with the same amount of embeddings of exactly the same size as we used as input.

10.9. Transformer: adicionar conexões residuais / Residual connections

No Transformer, conexões residuais (Residual Connection) são muito usadas; isso significa simplesmente somar a entrada da camada anterior à saída da camada atual. Aqui também faremos essa conexão residual.

Transformers make heavy use of residual connections which simply means adding the input of the previous layer to the output the current layer. This is also something that we will do now.

10.10. Transformer: obter o resultado da conexão residual / Residual connection Result

Por meio dessas conexões residuais, ao somar vetores do mesmo tamanho d, são gerados vetores do mesmo tamanho.

The addition results in vectors of the same size.

10.11. Transformer: passar pela rede feed-forward / Feed Forward Network

A saída obtida até aqui é passada por uma rede neural artificial feed-forward com funções de ativação não lineares.

Now these outputs are feed through a feed forward neural network with non linear activation functions

10.12. Transformer: obter o resultado final / Final Result

No Transformer, ainda há outra conexão residual após as operações realizadas até aqui, mas vamos ignorá-la para simplificar a explicação e encerrar a operação da camada Transformer. No fim, o Transformer produz saídas do mesmo tamanho da entrada.

After the transformer step there is another residual connections which we will skip here for brevity. And so the last step concluded the transformer layer. In the end the transformer produced outputs of the same size as input.

11. Repetir as operações do Transformer / Repeat Transformers

Repetimos várias vezes toda a operação do Transformer realizada até aqui, da etapa 10.1 até a 10.12. Aqui, usamos 6 repetições como exemplo.

Repeat the entire transformer calculation Steps 10.1 - Steps 10.12 for the Transformer several times e.g. 6 times.

12. Identificar a saída do token de classificação / Identify Classification token output

A última etapa é identificar a saída do token de classificação (CLS token). Esse vetor será usado na etapa final da jornada do Vision Transformer.

Last step is to identify the classification token output. This vector will be used in the final step of our Vision Transformer journey.

13. Etapa final: prever probabilidades de classificação / Final Step: Predicting classification probabilities

Na etapa final, usamos esse token de saída de classificação e outra rede neural totalmente conectada (fully-connected) para prever as probabilidades de classificação da imagem de entrada.

In the final and last step we use this classification output token and another fully connected neural network to predict the classification probabilities of our input image.

14. Treinando o Vision Transformer / Training of the Vision Transformer

Treinamos o Vision Transformer usando uma função de perda de entropia cruzada padrão (Cross-Entropy Loss Function), que compara as probabilidades de classe previstas com os rótulos verdadeiros (true class label). O modelo é treinado com backpropagation e gradient descent, atualizando os parâmetros do modelo na direção que minimiza a função de perda.

We train the Vision Transformer using a standard cross-entropy loss function, which compares the predicted class probabilities with the true class labels. The model is trained using backpropagation and gradient descent, updating the model parameters to minimize the loss function.

Conclusão / Conclusion

Até aqui, vimos os principais componentes do Vision Transformer, da preparação dos dados ao treinamento do modelo, por meio de uma explicação visual. Esperamos que esta explicação tenha ajudado você a entender como o Vision Transformer funciona e como ele pode ser usado para classificar imagens.

In this visual guide, we have walked through the key components of Vision Transformers, from the data preparation to the training of the model. We hope this guide has helped you understand how Vision Transformers work and how they can be used to classify images.

Também preparamos um pequeno Colab Notebook para ajudar você a entender ainda melhor o Vision Transformer. Dê uma olhada também no comentário do 'Blogpost'. Este código foi tirado da excelente implementação de ViT em PyTorch do @lucidrains, então não deixe de conferir o trabalho dele também.

I prepared this little Colab Notebook to help you understand the Vision Transformer even better. Please have look for the 'Blogpost' comment. The code was taken from @lucidrains great VIT Pytorch implementation be sure to checkout his work.

Se você tiver alguma dúvida ou feedback, sinta-se à vontade para entrar em contato. Obrigado pela leitura! (GitHub](https://github.com/mdturp), X(Twitter), Threads, LinkedIn)

If you have any questions or feedback, please feel free to reach out to me. Thank you for reading!

Agradecimentos / Acknowledgements

Implementação de VIT em PyTorch por @lucidrains](https://github.com/lucidrains/vit-pytorch/blob/main/vit_pytorch/vit.py)
Todas as imagens foram obtidas da Wikipedia e seu uso é permitido sob a licença CC BY-SA 4.0.

VIT Pytorch implementation

All images have been taken from Wikipedia and are licensed under the Creative Commons Attribution-Share Alike 4.0 International license.

Leituras adicionais

⚠️Publicidade⚠️: Você achou útil este texto organizado pela :pytorch:comunidade coreana de usuários de PyTorch? Se se cadastrar como membro, enviaremos os principais textos por e-mail! (O padrão é Weekly, mas você também pode mudar para Daily.)

1 comentários

gcback 2024-04-22

Obrigado pelo esforço em disponibilizar este material útil.^