self attention cv Download - self attention cv Download do código-fonte

self attention cv

Código-Fonte de IA

v2

Baixar

Blocos de construção de autoatenção para aplicativos de visão computacional em PyTorch

Implementação de mecanismos de autoatenção para visão computacional em PyTorch com einsum e einops. Focado em módulos de autoatenção de visão computacional.

Instale-o via pip

$ pip install self-attention-cv

Seria bom pré-instalar o pytorch em seu ambiente, caso você não tenha uma GPU. Para executar os testes a partir do terminal $ pytest você pode precisar executar export PYTHONPATH=$PATHONPATH:`pwd` antes.

Exemplos de código

Atenção multi-cabeça

 import torch
from self_attention_cv import MultiHeadSelfAttention

model = MultiHeadSelfAttention ( dim = 64 )
x = torch . rand ( 16 , 10 , 64 )  # [batch, tokens, dim]
mask = torch . zeros ( 10 , 10 )  # tokens X tokens
mask [ 5 : 8 , 5 : 8 ] = 1
y = model ( x , mask )

Atenção axial

 import torch
from self_attention_cv import AxialAttentionBlock
model = AxialAttentionBlock ( in_channels = 256 , dim = 64 , heads = 8 )
x = torch . rand ( 1 , 256 , 64 , 64 )  # [batch, tokens, dim, dim]
y = model ( x )

Codificador de transformador Vanilla

 import torch
from self_attention_cv import TransformerEncoder
model = TransformerEncoder ( dim = 64 , blocks = 6 , heads = 8 )
x = torch . rand ( 16 , 10 , 64 )  # [batch, tokens, dim]
mask = torch . zeros ( 10 , 10 )  # tokens X tokens
mask [ 5 : 8 , 5 : 8 ] = 1
y = model ( x , mask )

Vision Transformer com/sem backbone ResNet50 para classificação de imagens

 import torch
from self_attention_cv import ViT , ResNet50ViT

model1 = ResNet50ViT ( img_dim = 128 , pretrained_resnet = False , 
                        blocks = 6 , num_classes = 10 , 
                        dim_linear_block = 256 , dim = 256 )
# or
model2 = ViT ( img_dim = 256 , in_channels = 3 , patch_dim = 16 , num_classes = 10 , dim = 512 )
x = torch . rand ( 2 , 3 , 256 , 256 )
y = model2 ( x ) # [2,10]

Uma reimplementação do Unet com o codificador Vision Transformer

 import torch
from self_attention_cv . transunet import TransUnet
a = torch . rand ( 2 , 3 , 128 , 128 )
model = TransUnet ( in_channels = 3 , img_dim = 128 , vit_blocks = 8 ,
vit_dim_linear_mhsa_block = 512 , classes = 5 )
y = model ( a ) # [2, 5, 128, 128]

Bloqueio de atenção de gargalo

 import torch
from self_attention_cv . bottleneck_transformer import BottleneckBlock
inp = torch . rand ( 1 , 512 , 32 , 32 )
bottleneck_block = BottleneckBlock ( in_channels = 512 , fmap_size = ( 32 , 32 ), heads = 4 , out_channels = 1024 , pooling = True )
y = bottleneck_block ( inp )

Incorporações de posição também estão disponíveis

Incorporações posicionais 1D

 import torch
from self_attention_cv . pos_embeddings import AbsPosEmb1D , RelPosEmb1D

model = AbsPosEmb1D ( tokens = 20 , dim_head = 64 )
# batch heads tokens dim_head
q = torch . rand ( 2 , 3 , 20 , 64 )
y1 = model ( q )

model = RelPosEmb1D ( tokens = 20 , dim_head = 64 , heads = 3 )
q = torch . rand ( 2 , 3 , 20 , 64 )
y2 = model ( q )

Incorporações posicionais 2D

 import torch
from self_attention_cv . pos_embeddings import RelPosEmb2D
dim = 32  # spatial dim of the feat map
model = RelPosEmb2D (
    feat_map_size = ( dim , dim ),
    dim_head = 128 )

q = torch . rand ( 2 , 4 , dim * dim , 128 )
y = model ( q )

Agradecimentos

Obrigado a Alex Rogozhnikov @arogozhnikov pelo incrível pacote einops. Para minhas reimplementações, estudei e peguei código emprestado de vários repositórios de Phil Wang @lucidrains. Ao estudar seu código, consegui captar a autoatenção, descobrir coisas de PNL que nunca são mencionadas nos jornais e aprender com seu estilo de codificação limpo.

Citado como

 @article{adaloglou2021transformer,
    title   = "Transformers in Computer Vision",
    author  = "Adaloglou, Nikolas",
    journal = "https://theaisummer.com/",
    year    = "2021",
    howpublished = {https://github.com/The-AI-Summer/self-attention-cv},
  }

Referências

Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, AN, ... & Polosukhin, I. (2017). Atenção é tudo que você precisa. Pré-impressão do arXiv arXiv:1706.03762.
Wang, H., Zhu, Y., Green, B., Adam, H., Yuille, A., & Chen, LC (2020, agosto). Axial-deeplab: Atenção axial autônoma para segmentação panóptica. Na Conferência Europeia sobre Visão Computacional (pp. 108-126). Springer, Cham.
Srinivas, A., Lin, TY, Parmar, N., Shlens, J., Abbeel, P., & Vaswani, A. (2021). Transformadores de gargalo para reconhecimento visual. Pré-impressão do arXiv arXiv:2101.11605.
Dosovitskiy, A., Beyer, L., Kolesnikov, A., Weissenborn, D., Zhai, X., Unterthiner, T., ... & Houlsby, N. (2020). Uma imagem vale 16x16 palavras: Transformadores para reconhecimento de imagens em escala. Pré-impressão do arXiv arXiv:2010.11929.
Ramachandran, P., Parmar, N., Vaswani, A., Bello, I., Levskaya, A., & Shlens, J. (2019). Autoatenção autônoma em modelos de visão. Pré-impressão do arXiv arXiv:1906.05909.
Chen, J., Lu, Y., Yu, Q., Luo, X., Adeli, E., Wang, Y., ... e Zhou, Y. (2021). Transunet: Os transformadores são codificadores fortes para segmentação de imagens médicas. Pré-impressão do arXiv arXiv:2102.04306.
Wang, S., Li, B., Khabsa, M., Fang, H., & Ma, H. (2020). Linformer: Autoatenção com complexidade linear. Pré-impressão do arXiv arXiv:2006.04768.
Bertasius, G., Wang, H. e Torresani, L. (2021). A atenção do espaço-tempo é tudo que você precisa para compreender o vídeo? Pré-impressão do arXiv arXiv:2102.05095.
Shaw, P., Uszkoreit, J. e Vaswani, A. (2018). Autoatenção com representações de posição relativa. Pré-impressão do arXiv arXiv:1803.02155.

Apoiar

Se você realmente gosta deste repositório e o acha útil, considere (★) marcá-lo com uma estrela, para que ele possa atingir um público mais amplo de pessoas com interesses semelhantes. Seria muito apreciado :)!

Expandir

Informações adicionais