Descarga self attention cv - Descarga de código fuente self attention cv

self attention cv

Código Fuente de IA

v2

Descargar

Bloques de construcción de autoatención para aplicaciones de visión por computadora en PyTorch

Implementación de mecanismos de autoatención para visión por computadora en PyTorch con einsum y einops. Enfocado en módulos de autoatención de visión por computadora.

Instálalo vía pip

$ pip install self-attention-cv

Sería bueno preinstalar pytorch en su entorno, en caso de que no tenga una GPU. Para ejecutar las pruebas desde la terminal $ pytest es posible que necesites ejecutar export PYTHONPATH=$PATHONPATH:`pwd` antes.

Ejemplos de código

Atención multicabezal

 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 )

atención 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 de vainilla

 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 con/sin red troncal ResNet50 para clasificación de imágenes

 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]

Una reimplementación de Unet con el 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]

Bloqueo de atención de cuello de botella

 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 )

Las incrustaciones de posición también están disponibles

Incrustaciones posicionales 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 )

Incrustaciones posicionales 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 )

Expresiones de gratitud

Gracias a Alex Rogozhnikov @arogozhnikov por el fantástico paquete einops. Para mis reimplementaciones, estudié y tomé prestado código de muchos repositorios de Phil Wang @lucidrains. Al estudiar su código, logré captar la atención personal, descubrir cosas de PNL que nunca se mencionan en los artículos y aprender de su estilo de codificación limpio.

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},
  }

Referencias

Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, AN, ... y Polosukhin, I. (2017). Atención es todo lo que necesitas. preimpresión de arXiv arXiv:1706.03762.
Wang, H., Zhu, Y., Green, B., Adam, H., Yuille, A. y Chen, LC (agosto de 2020). Axial-deeplab: atención axial independiente para segmentación panóptica. En Conferencia europea sobre visión por computadora (págs. 108-126). Springer, Cham.
Srinivas, A., Lin, TY, Parmar, N., Shlens, J., Abbeel, P. y Vaswani, A. (2021). Transformadores de cuello de botella para reconocimiento visual. Preimpresión de arXiv arXiv:2101.11605.
Dosovitskiy, A., Beyer, L., Kolesnikov, A., Weissenborn, D., Zhai, X., Unterthiner, T., ... y Houlsby, N. (2020). Una imagen vale 16x16 palabras: Transformadores para el reconocimiento de imágenes a escala. Preimpresión de arXiv arXiv:2010.11929.
Ramachandran, P., Parmar, N., Vaswani, A., Bello, I., Levskaya, A. y Shlens, J. (2019). Autoatención independiente en modelos de visión. Preimpresión de arXiv arXiv:1906.05909.
Chen, J., Lu, Y., Yu, Q., Luo, X., Adeli, E., Wang, Y., ... y Zhou, Y. (2021). Transunet: Los transformadores son potentes codificadores para la segmentación de imágenes médicas. Preimpresión de arXiv arXiv:2102.04306.
Wang, S., Li, B., Khabsa, M., Fang, H. y Ma, H. (2020). Linformer: Autoatención con complejidad lineal. Preimpresión de arXiv arXiv:2006.04768.
Bertasius, G., Wang, H. y Torresani, L. (2021). ¿Es la atención espacio-temporal todo lo que necesita para comprender los vídeos? Preimpresión de arXiv arXiv:2102.05095.
Shaw, P., Uszkoreit, J. y Vaswani, A. (2018). Autoatención con representaciones de posición relativa. Preimpresión de arXiv arXiv:1803.02155.

Apoyo

Si realmente le gusta este repositorio y lo encuentra útil, considere (★) destacarlo para que pueda llegar a una audiencia más amplia de personas con ideas afines. ¡Sería muy apreciado :)!

Expandir

Información adicional