self attention cv

Selbstaufmerksamkeitsbausteine ​​für Computer-Vision-Anwendungen in PyTorch

Implementierung von Selbstaufmerksamkeitsmechanismen für Computer Vision in PyTorch mit einsum und einops. Konzentriert sich auf Selbstaufmerksamkeitsmodule für Computer Vision.

Installieren Sie es über Pip

$ pip install self-attention-cv

Es wäre schön, Pytorch in Ihrer Umgebung vorzuinstallieren, falls Sie keine GPU haben. Um die Tests vom Terminal $ pytest aus auszuführen, müssen Sie möglicherweise vorher export PYTHONPATH=$PATHONPATH:`pwd` ausführen.

Verwandte Artikel

• Wie Aufmerksamkeit beim Deep Learning funktioniert
• Wie Transformers beim Deep Learning und NLP funktionieren
• So funktioniert der Vision Transformer (ViT) in 10 Minuten: Ein Bild sagt mehr als 16x16 Worte
• Einsum für Deep Learning verstehen: Implementieren Sie einen Transformator mit Multi-Head-Selbstaufmerksamkeit von Grund auf
• Wie Positionseinbettungen in der Selbstaufmerksamkeit funktionieren
• Warum Multi-Head-Selbstaufmerksamkeit funktioniert: Mathematik, Intuitionen und 10+1 versteckte Erkenntnisse

Codebeispiele

Mehrköpfige Aufmerksamkeit

 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 )

Axiale Aufmerksamkeit

 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 )

Vanilla Transformer Encoder

 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 mit/ohne ResNet50-Backbone zur Bildklassifizierung

 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] 

Eine Neuimplementierung von Unet mit dem Vision Transformer-Encoder

 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] 

Engpass. Aufmerksamkeitsblockade

 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 )

Positionseinbettungen sind ebenfalls verfügbar

1D-Positionseinbettungen

 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 )

2D-Positionseinbettungen

 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 )

Danksagungen

Vielen Dank an Alex Rogozhnikov @arogozhnikov für das tolle Einops-Paket. Für meine Neuimplementierungen habe ich Code aus vielen Repositories von Phil Wang @lucidrains studiert und ausgeliehen. Durch das Studium seines Codes ist es mir gelungen, Selbstaufmerksamkeit zu erlangen, NLP-Sachen zu entdecken, auf die in den Aufsätzen nie Bezug genommen wird, und von seinem sauberen Codierungsstil zu lernen.

Zitiert als

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

Referenzen

1. Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, AN, ... & Polosukhin, I. (2017). Aufmerksamkeit ist alles, was Sie brauchen. arXiv-Vorabdruck arXiv:1706.03762.
2. Wang, H., Zhu, Y., Green, B., Adam, H., Yuille, A. & Chen, LC (2020, August). Axial-Deeplab: Eigenständige axiale Aufmerksamkeit für panoptische Segmentierung. In European Conference on Computer Vision (S. 108-126). Springer, Cham.
3. Srinivas, A., Lin, TY, Parmar, N., Shlens, J., Abbeel, P. & Vaswani, A. (2021). Engpasstransformatoren für die visuelle Erkennung. arXiv-Vorabdruck arXiv:2101.11605.
4. Dosovitskiy, A., Beyer, L., Kolesnikov, A., Weissenborn, D., Zhai, X., Unterthiner, T., ... & Houlsby, N. (2020). Ein Bild sagt mehr als 16x16 Worte: Transformatoren für die Bilderkennung im Maßstab. arXiv-Vorabdruck arXiv:2010.11929.
5. Ramachandran, P., Parmar, N., Vaswani, A., Bello, I., Levskaya, A. & Shlens, J. (2019). Eigenständige Selbstaufmerksamkeit in Visionsmodellen. arXiv-Vorabdruck arXiv:1906.05909.
6. Chen, J., Lu, Y., Yu, Q., Luo, X., Adeli, E., Wang, Y., ... & Zhou, Y. (2021). Transunet: Transformatoren sind leistungsstarke Encoder für die Segmentierung medizinischer Bilder. arXiv-Vorabdruck arXiv:2102.04306.
7. Wang, S., Li, B., Khabsa, M., Fang, H. & Ma, H. (2020). Linformer: Selbstaufmerksamkeit mit linearer Komplexität. arXiv-Vorabdruck arXiv:2006.04768.
8. Bertasius, G., Wang, H. & Torresani, L. (2021). Ist Raum-Zeit-Aufmerksamkeit alles, was Sie zum Verstehen von Videos benötigen? arXiv-Vorabdruck arXiv:2102.05095.
9. Shaw, P., Uszkoreit, J. & Vaswani, A. (2018). Selbstaufmerksamkeit mit relativen Positionsdarstellungen. arXiv-Vorabdruck arXiv:1803.02155.

Unterstützung

Wenn Ihnen dieses Repository wirklich gefällt und Sie es nützlich finden, denken Sie bitte darüber nach (★), es mit einem Sternchen zu versehen, damit es ein breiteres Publikum von Gleichgesinnten erreichen kann. Es wäre sehr dankbar :)!