add simple vit, from https://arxiv.org/abs/2205.01580

.github/workflows/python-publish.yml

@@ -1,16 +1,11 @@
-# This workflow will upload a Python Package using Twine when a release is created
+# This workflows will upload a Python Package using Twine when a release is created
 # For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries
 
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
-
 name: Upload Python Package
 
 on:
   release:
-    types: [published]
+    types: [created]
 
 jobs:
   deploy:
@@ -18,19 +13,19 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v2
     - name: Set up Python
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v2
       with:
         python-version: '3.x'
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install build
-    - name: Build package
-      run: python -m build
-    - name: Publish package
-      uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29
-      with:
-        user: __token__
-        password: ${{ secrets.PYPI_API_TOKEN }}
+        pip install setuptools wheel twine
+    - name: Build and publish
+      env:
+        TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
+        TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
+      run: |
+        python setup.py sdist bdist_wheel
+        twine upload dist/*

.github/workflows/python-test.yml

@@ -15,20 +15,19 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.8, 3.9]
+        python-version: [3.7, 3.8, 3.9]
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v2
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v2
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        python -m pip install torch==2.4.0 torchvision==0.19.0 --index-url https://download.pytorch.org/whl/cpu
-        python -m pip install -e .
         python -m pip install pytest
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
     - name: Test with pytest
       run: |
-        pytest -q
+        python setup.py test

README.md

@@ -7,7 +7,6 @@
 - [Usage](#usage)
 - [Parameters](#parameters)
 - [Simple ViT](#simple-vit)
-- [NaViT](#navit)
 - [Distillation](#distillation)
 - [Deep ViT](#deep-vit)
 - [CaiT](#cait)
@@ -25,16 +24,12 @@
 - [MaxViT](#maxvit)
 - [NesT](#nest)
 - [MobileViT](#mobilevit)
-- [XCiT](#xcit)
 - [Masked Autoencoder](#masked-autoencoder)
 - [Simple Masked Image Modeling](#simple-masked-image-modeling)
 - [Masked Patch Prediction](#masked-patch-prediction)
-- [Masked Position Prediction](#masked-position-prediction)
 - [Adaptive Token Sampling](#adaptive-token-sampling)
 - [Patch Merger](#patch-merger)
 - [Vision Transformer for Small Datasets](#vision-transformer-for-small-datasets)
-- [3D Vit](#3d-vit)
-- [ViVit](#vivit)
 - [Parallel ViT](#parallel-vit)
 - [Learnable Memory ViT](#learnable-memory-vit)
 - [Dino](#dino)
@@ -49,7 +44,7 @@
 
 ## Vision Transformer - Pytorch
 
-Implementation of <a href="https://openreview.net/pdf?id=YicbFdNTTy">Vision Transformer</a>, a simple way to achieve SOTA in vision classification with only a single transformer encoder, in Pytorch. Significance is further explained in <a href="https://www.youtube.com/watch?v=TrdevFK_am4">Yannic Kilcher's</a> video. There's really not much to code here, but may as well lay it out for everyone so we expedite the [attention](https://www.youtube.com/watch?v=eMlx5fFNoYc) revolution.
+Implementation of <a href="https://openreview.net/pdf?id=YicbFdNTTy">Vision Transformer</a>, a simple way to achieve SOTA in vision classification with only a single transformer encoder, in Pytorch. Significance is further explained in <a href="https://www.youtube.com/watch?v=TrdevFK_am4">Yannic Kilcher's</a> video. There's really not much to code here, but may as well lay it out for everyone so we expedite the attention revolution.
 
 For a Pytorch implementation with pretrained models, please see Ross Wightman's repository <a href="https://github.com/rwightman/pytorch-image-models">here</a>.
 
@@ -57,8 +52,6 @@ The official Jax repository is <a href="https://github.com/google-research/visio
 
 A tensorflow2 translation also exists <a href="https://github.com/taki0112/vit-tensorflow">here</a>, created by research scientist <a href="https://github.com/taki0112">Junho Kim</a>! 🙏
 
-<a href="https://github.com/conceptofmind/vit-flax">Flax translation</a> by <a href="https://github.com/conceptofmind">Enrico Shippole</a>!
-
 ## Install
 
 ```bash
@@ -93,7 +86,7 @@ preds = v(img) # (1, 1000)
 - `image_size`: int.  
 Image size. If you have rectangular images, make sure your image size is the maximum of the width and height
 - `patch_size`: int.  
-Size of patches. `image_size` must be divisible by `patch_size`.  
+Number of patches. `image_size` must be divisible by `patch_size`.  
 The number of patches is: ` n = (image_size // patch_size) ** 2` and `n` **must be greater than 16**.
 - `num_classes`: int.  
 Number of classes to classify.
@@ -141,95 +134,6 @@ img = torch.randn(1, 3, 256, 256)
 preds = v(img) # (1, 1000)
 ```
 
-## NaViT
-
-<img src="./images/navit.png" width="450px"></img>
-
-<a href="https://arxiv.org/abs/2307.06304">This paper</a> proposes to leverage the flexibility of attention and masking for variable lengthed sequences to train images of multiple resolution, packed into a single batch. They demonstrate much faster training and improved accuracies, with the only cost being extra complexity in the architecture and dataloading. They use factorized 2d positional encodings, token dropping, as well as query-key normalization.
-
-You can use it as follows
-
-```python
-import torch
-from vit_pytorch.na_vit import NaViT
-
-v = NaViT(
-    image_size = 256,
-    patch_size = 32,
-    num_classes = 1000,
-    dim = 1024,
-    depth = 6,
-    heads = 16,
-    mlp_dim = 2048,
-    dropout = 0.1,
-    emb_dropout = 0.1,
-    token_dropout_prob = 0.1  # token dropout of 10% (keep 90% of tokens)
-)
-
-# 5 images of different resolutions - List[List[Tensor]]
-
-# for now, you'll have to correctly place images in same batch element as to not exceed maximum allowed sequence length for self-attention w/ masking
-
-images = [
-    [torch.randn(3, 256, 256), torch.randn(3, 128, 128)],
-    [torch.randn(3, 128, 256), torch.randn(3, 256, 128)],
-    [torch.randn(3, 64, 256)]
-]
-
-preds = v(images) # (5, 1000) - 5, because 5 images of different resolution above
-
-```
-
-Or if you would rather that the framework auto group the images into variable lengthed sequences that do not exceed a certain max length
-
-```python
-images = [
-    torch.randn(3, 256, 256),
-    torch.randn(3, 128, 128),
-    torch.randn(3, 128, 256),
-    torch.randn(3, 256, 128),
-    torch.randn(3, 64, 256)
-]
-
-preds = v(
-    images,
-    group_images = True,
-    group_max_seq_len = 64
-) # (5, 1000)
-```
-
-Finally, if you would like to make use of a flavor of NaViT using <a href="https://pytorch.org/tutorials/prototype/nestedtensor.html">nested tensors</a> (which will omit a lot of the masking and padding altogether), make sure you are on version `2.5` and import as follows
-
-```python
-import torch
-from vit_pytorch.na_vit_nested_tensor import NaViT
-
-v = NaViT(
-    image_size = 256,
-    patch_size = 32,
-    num_classes = 1000,
-    dim = 1024,
-    depth = 6,
-    heads = 16,
-    mlp_dim = 2048,
-    dropout = 0.,
-    emb_dropout = 0.,
-    token_dropout_prob = 0.1
-)
-
-# 5 images of different resolutions - List[Tensor]
-
-images = [
-    torch.randn(3, 256, 256), torch.randn(3, 128, 128),
-    torch.randn(3, 128, 256), torch.randn(3, 256, 128),
-    torch.randn(3, 64, 256)
-]
-
-preds = v(images)
-
-assert preds.shape == (5, 1000)
-```
-
 ## Distillation
 
 <img src="./images/distill.png" width="300px"></img>
@@ -395,7 +299,7 @@ cct = CCT(
     pooling_padding = 1,
     num_layers = 14,
     num_heads = 6,
-    mlp_ratio = 3.,
+    mlp_radio = 3.,
     num_classes = 1000,
     positional_embedding = 'learnable', # ['sine', 'learnable', 'none']
 )
@@ -757,7 +661,7 @@ preds = v(img) # (2, 1000)
 
 <img src="./images/nest.png" width="400px"></img>
 
-This <a href="https://arxiv.org/abs/2105.12723">paper</a> decided to process the image in hierarchical stages, with attention only within tokens of local blocks, which aggregate as it moves up the hierarchy. The aggregation is done in the image plane, and contains a convolution and subsequent maxpool to allow it to pass information across the boundary.
+This <a href="https://arxiv.org/abs/2105.12723">paper</a> decided to process the image in hierarchical stages, with attention only within tokens of local blocks, which aggregate as it moves up the heirarchy. The aggregation is done in the image plane, and contains a convolution and subsequent maxpool to allow it to pass information across the boundary.
 
 You can use it with the following code (ex. NesT-T)
 
@@ -771,7 +675,7 @@ nest = NesT(
     dim = 96,
     heads = 3,
     num_hierarchies = 3,        # number of hierarchies
-    block_repeats = (2, 2, 8),  # the number of transformer blocks at each hierarchy, starting from the bottom
+    block_repeats = (2, 2, 8),  # the number of transformer blocks at each heirarchy, starting from the bottom
     num_classes = 1000
 )
 
@@ -805,38 +709,6 @@ img = torch.randn(1, 3, 256, 256)
 pred = mbvit_xs(img) # (1, 1000)
 ```
 
-## XCiT
-
-<img src="./images/xcit.png" width="400px"></img>
-
-This <a href="https://arxiv.org/abs/2106.09681">paper</a> introduces the cross covariance attention (abbreviated XCA). One can think of it as doing attention across the features dimension rather than the spatial one (another perspective would be a dynamic 1x1 convolution, the kernel being attention map defined by spatial correlations).
-
-Technically, this amounts to simply transposing the query, key, values before executing cosine similarity attention with learned temperature.
-
-```python
-import torch
-from vit_pytorch.xcit import XCiT
-
-v = XCiT(
-    image_size = 256,
-    patch_size = 32,
-    num_classes = 1000,
-    dim = 1024,
-    depth = 12,                     # depth of xcit transformer
-    cls_depth = 2,                  # depth of cross attention of CLS tokens to patch, attention pool at end
-    heads = 16,
-    mlp_dim = 2048,
-    dropout = 0.1,
-    emb_dropout = 0.1,
-    layer_dropout = 0.05,           # randomly dropout 5% of the layers
-    local_patch_kernel_size = 3     # kernel size of the local patch interaction module (depthwise convs)
-)
-
-img = torch.randn(1, 3, 256, 256)
-
-preds = v(img) # (1, 1000)
-```
-
 ## Simple Masked Image Modeling
 
 <img src="./images/simmim.png" width="400px"/>
@@ -968,44 +840,6 @@ for _ in range(100):
 torch.save(model.state_dict(), './pretrained-net.pt')
 ```
 
-## Masked Position Prediction
-
-<img src="./images/mp3.png" width="400px"></img>
-
-New <a href="https://arxiv.org/abs/2207.07611">paper</a> that introduces masked position prediction pre-training criteria. This strategy is more efficient than the Masked Autoencoder strategy and has comparable performance.  
-
-```python
-import torch
-from vit_pytorch.mp3 import ViT, MP3
-
-v = ViT(
-    num_classes = 1000,
-    image_size = 256,
-    patch_size = 8,
-    dim = 1024,
-    depth = 6,
-    heads = 8,
-    mlp_dim = 2048,
-    dropout = 0.1,
-)
-
-mp3 = MP3(
-    vit = v,
-    masking_ratio = 0.75
-)
-
-images = torch.randn(8, 3, 256, 256)
-
-loss = mp3(images)
-loss.backward()
-
-# that's all!
-# do the above in a for loop many times with a lot of images and your vision transformer will learn
-
-# save your improved vision transformer
-torch.save(v.state_dict(), './trained-vit.pt')
-```
-
 ## Adaptive Token Sampling
 
 <img src="./images/ats.png" width="400px"></img>
@@ -1131,119 +965,6 @@ img = torch.randn(4, 3, 256, 256)
 tokens = spt(img) # (4, 256, 1024)
 ```
 
-## 3D ViT
-
-By popular request, I will start extending a few of the architectures in this repository to 3D ViTs, for use with video, medical imaging, etc.
-
-You will need to pass in two additional hyperparameters: (1) the number of frames `frames` and (2) patch size along the frame dimension `frame_patch_size`
-
-For starters, 3D ViT
-
-```python
-import torch
-from vit_pytorch.vit_3d import ViT
-
-v = ViT(
-    image_size = 128,          # image size
-    frames = 16,               # number of frames
-    image_patch_size = 16,     # image patch size
-    frame_patch_size = 2,      # frame patch size
-    num_classes = 1000,
-    dim = 1024,
-    depth = 6,
-    heads = 8,
-    mlp_dim = 2048,
-    dropout = 0.1,
-    emb_dropout = 0.1
-)
-
-video = torch.randn(4, 3, 16, 128, 128) # (batch, channels, frames, height, width)
-
-preds = v(video) # (4, 1000)
-```
-
-3D Simple ViT
-
-```python
-import torch
-from vit_pytorch.simple_vit_3d import SimpleViT
-
-v = SimpleViT(
-    image_size = 128,          # image size
-    frames = 16,               # number of frames
-    image_patch_size = 16,     # image patch size
-    frame_patch_size = 2,      # frame patch size
-    num_classes = 1000,
-    dim = 1024,
-    depth = 6,
-    heads = 8,
-    mlp_dim = 2048
-)
-
-video = torch.randn(4, 3, 16, 128, 128) # (batch, channels, frames, height, width)
-
-preds = v(video) # (4, 1000)
-```
-
-3D version of <a href="https://github.com/lucidrains/vit-pytorch#cct">CCT</a>
-
-```python
-import torch
-from vit_pytorch.cct_3d import CCT
-
-cct = CCT(
-    img_size = 224,
-    num_frames = 8,
-    embedding_dim = 384,
-    n_conv_layers = 2,
-    frame_kernel_size = 3,
-    kernel_size = 7,
-    stride = 2,
-    padding = 3,
-    pooling_kernel_size = 3,
-    pooling_stride = 2,
-    pooling_padding = 1,
-    num_layers = 14,
-    num_heads = 6,
-    mlp_ratio = 3.,
-    num_classes = 1000,
-    positional_embedding = 'learnable'
-)
-
-video = torch.randn(1, 3, 8, 224, 224) # (batch, channels, frames, height, width)
-pred = cct(video)
-```
-
-## ViViT
-
-<img src="./images/vivit.png" width="350px"></img>
-
-This <a href="https://arxiv.org/abs/2103.15691">paper</a> offers 3 different types of architectures for efficient attention of videos, with the main theme being factorizing the attention across space and time. This repository includes the factorized encoder and the factorized self-attention variant.
-The factorized encoder variant is a spatial transformer followed by a temporal one. The factorized self-attention variant is a spatio-temporal transformer with alternating spatial and temporal self-attention layers.
-
-```python
-import torch
-from vit_pytorch.vivit import ViT
-
-v = ViT(
-    image_size = 128,          # image size
-    frames = 16,               # number of frames
-    image_patch_size = 16,     # image patch size
-    frame_patch_size = 2,      # frame patch size
-    num_classes = 1000,
-    dim = 1024,
-    spatial_depth = 6,         # depth of the spatial transformer
-    temporal_depth = 6,        # depth of the temporal transformer
-    heads = 8,
-    mlp_dim = 2048,
-    variant = 'factorized_encoder', # or 'factorized_self_attention'
-)
-
-video = torch.randn(4, 3, 16, 128, 128) # (batch, channels, frames, height, width)
-
-preds = v(video) # (4, 1000)
-```
-
 ## Parallel ViT
 
 <img src="./images/parallel-vit.png" width="350px"></img>
@@ -1358,7 +1079,7 @@ learner = Dino(
     hidden_layer = 'to_latent',        # hidden layer name or index, from which to extract the embedding
     projection_hidden_size = 256,      # projector network hidden dimension
     projection_layers = 4,             # number of layers in projection network
-    num_classes_K = 65536,             # output logits dimensions (referenced as K in paper)
+    num_classes_K = 65336,             # output logits dimensions (referenced as K in paper)
     student_temp = 0.9,                # student temperature
     teacher_temp = 0.04,               # teacher temperature, needs to be annealed from 0.04 to 0.07 over 30 epochs
     local_upper_crop_scale = 0.4,      # upper bound for local crop - 0.4 was recommended in the paper 
@@ -1534,47 +1255,6 @@ logits, embeddings = v(img)
 embeddings # (1, 65, 1024) - (batch x patches x model dim)
 ```
 
-Or say for `CrossViT`, which has a multi-scale encoder that outputs two sets of embeddings for 'large' and 'small' scales
-
-```python
-import torch
-from vit_pytorch.cross_vit import CrossViT
-
-v = CrossViT(
-    image_size = 256,
-    num_classes = 1000,
-    depth = 4,
-    sm_dim = 192,
-    sm_patch_size = 16,
-    sm_enc_depth = 2,
-    sm_enc_heads = 8,
-    sm_enc_mlp_dim = 2048,
-    lg_dim = 384,
-    lg_patch_size = 64,
-    lg_enc_depth = 3,
-    lg_enc_heads = 8,
-    lg_enc_mlp_dim = 2048,
-    cross_attn_depth = 2,
-    cross_attn_heads = 8,
-    dropout = 0.1,
-    emb_dropout = 0.1
-)
-
-# wrap the CrossViT
-
-from vit_pytorch.extractor import Extractor
-v = Extractor(v, layer_name = 'multi_scale_encoder') # take embedding coming from the output of multi-scale-encoder
-
-# forward pass now returns predictions and the attention maps
-
-img = torch.randn(1, 3, 256, 256)
-logits, embeddings = v(img)
-
-# there is one extra token due to the CLS token
-
-embeddings # ((1, 257, 192), (1, 17, 384)) - (batch x patches x dimension) <- large and small scales respectively
-```
-
 ## Research Ideas
 
 ### Efficient Attention
@@ -2027,46 +1707,6 @@ Coming from computer vision and new to transformers? Here are some resources tha
 
 ```
 
-```bibtex
-@article{Arnab2021ViViTAV,
-    title   = {ViViT: A Video Vision Transformer},
-    author  = {Anurag Arnab and Mostafa Dehghani and Georg Heigold and Chen Sun and Mario Lucic and Cordelia Schmid},
-    journal = {2021 IEEE/CVF International Conference on Computer Vision (ICCV)},
-    year    = {2021},
-    pages   = {6816-6826}
-}
-```
-
-```bibtex
-@article{Liu2022PatchDropoutEV,
-    title   = {PatchDropout: Economizing Vision Transformers Using Patch Dropout},
-    author  = {Yue Liu and Christos Matsoukas and Fredrik Strand and Hossein Azizpour and Kevin Smith},
-    journal = {ArXiv},
-    year    = {2022},
-    volume  = {abs/2208.07220}
-}
-```
-
-```bibtex
-@misc{https://doi.org/10.48550/arxiv.2302.01327,
-    doi     = {10.48550/ARXIV.2302.01327},
-    url     = {https://arxiv.org/abs/2302.01327},
-    author  = {Kumar, Manoj and Dehghani, Mostafa and Houlsby, Neil},
-    title   = {Dual PatchNorm},
-    publisher = {arXiv},
-    year    = {2023},
-    copyright = {Creative Commons Attribution 4.0 International}
-}
-```
-
-```bibtex
-@inproceedings{Dehghani2023PatchNP,
-    title   = {Patch n' Pack: NaViT, a Vision Transformer for any Aspect Ratio and Resolution},
-    author  = {Mostafa Dehghani and Basil Mustafa and Josip Djolonga and Jonathan Heek and Matthias Minderer and Mathilde Caron and Andreas Steiner and Joan Puigcerver and Robert Geirhos and Ibrahim M. Alabdulmohsin and Avital Oliver and Piotr Padlewski and Alexey A. Gritsenko and Mario Luvci'c and Neil Houlsby},
-    year    = {2023}
-}
-```
-
 ```bibtex
 @misc{vaswani2017attention,
     title   = {Attention Is All You Need},
@@ -2078,175 +1718,4 @@ Coming from computer vision and new to transformers? Here are some resources tha
 }
 ```
 
-```bibtex
-@inproceedings{dao2022flashattention,
-    title   = {Flash{A}ttention: Fast and Memory-Efficient Exact Attention with {IO}-Awareness},
-    author  = {Dao, Tri and Fu, Daniel Y. and Ermon, Stefano and Rudra, Atri and R{\'e}, Christopher},
-    booktitle = {Advances in Neural Information Processing Systems},
-    year    = {2022}
-}
-```
-
-```bibtex
-@inproceedings{Darcet2023VisionTN,
-    title   = {Vision Transformers Need Registers},
-    author  = {Timoth'ee Darcet and Maxime Oquab and Julien Mairal and Piotr Bojanowski},
-    year    = {2023},
-    url     = {https://api.semanticscholar.org/CorpusID:263134283}
-}
-```
-
-```bibtex
-@inproceedings{ElNouby2021XCiTCI,
-    title   = {XCiT: Cross-Covariance Image Transformers},
-    author  = {Alaaeldin El-Nouby and Hugo Touvron and Mathilde Caron and Piotr Bojanowski and Matthijs Douze and Armand Joulin and Ivan Laptev and Natalia Neverova and Gabriel Synnaeve and Jakob Verbeek and Herv{\'e} J{\'e}gou},
-    booktitle = {Neural Information Processing Systems},
-    year    = {2021},
-    url     = {https://api.semanticscholar.org/CorpusID:235458262}
-}
-```
-
-```bibtex
-@inproceedings{Koner2024LookupViTCV,
-    title   = {LookupViT: Compressing visual information to a limited number of tokens},
-    author  = {Rajat Koner and Gagan Jain and Prateek Jain and Volker Tresp and Sujoy Paul},
-    year    = {2024},
-    url     = {https://api.semanticscholar.org/CorpusID:271244592}
-}
-```
-
-```bibtex
-@article{Bao2022AllAW,
-    title   = {All are Worth Words: A ViT Backbone for Diffusion Models},
-    author  = {Fan Bao and Shen Nie and Kaiwen Xue and Yue Cao and Chongxuan Li and Hang Su and Jun Zhu},
-    journal = {2023 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
-    year    = {2022},
-    pages   = {22669-22679},
-    url     = {https://api.semanticscholar.org/CorpusID:253581703}
-}
-```
-
-```bibtex
-@misc{Rubin2024,
-    author  = {Ohad Rubin},
-    url     = {https://medium.com/@ohadrubin/exploring-weight-decay-in-layer-normalization-challenges-and-a-reparameterization-solution-ad4d12c24950}
-}
-```
-
-```bibtex
-@inproceedings{Loshchilov2024nGPTNT,
-    title   = {nGPT: Normalized Transformer with Representation Learning on the Hypersphere},
-    author  = {Ilya Loshchilov and Cheng-Ping Hsieh and Simeng Sun and Boris Ginsburg},
-    year    = {2024},
-    url     = {https://api.semanticscholar.org/CorpusID:273026160}
-}
-```
-
-```bibtex
-@inproceedings{Liu2017DeepHL,
-    title   = {Deep Hyperspherical Learning},
-    author  = {Weiyang Liu and Yanming Zhang and Xingguo Li and Zhen Liu and Bo Dai and Tuo Zhao and Le Song},
-    booktitle = {Neural Information Processing Systems},
-    year    = {2017},
-    url     = {https://api.semanticscholar.org/CorpusID:5104558}
-}
-```
-
-```bibtex
-@inproceedings{Zhou2024ValueRL,
-    title   = {Value Residual Learning For Alleviating Attention Concentration In Transformers},
-    author  = {Zhanchao Zhou and Tianyi Wu and Zhiyun Jiang and Zhenzhong Lan},
-    year    = {2024},
-    url     = {https://api.semanticscholar.org/CorpusID:273532030}
-}
-```
-
-```bibtex
-@article{Zhu2024HyperConnections,
-    title   = {Hyper-Connections},
-    author  = {Defa Zhu and Hongzhi Huang and Zihao Huang and Yutao Zeng and Yunyao Mao and Banggu Wu and Qiyang Min and Xun Zhou},
-    journal = {ArXiv},
-    year    = {2024},
-    volume  = {abs/2409.19606},
-    url     = {https://api.semanticscholar.org/CorpusID:272987528}
-}
-```
-
-```bibtex
-@inproceedings{Fuller2025SimplerFV,
-    title   = {Simpler Fast Vision Transformers with a Jumbo CLS Token},
-    author  = {Anthony Fuller and Yousef Yassin and Daniel G. Kyrollos and Evan Shelhamer and James R. Green},
-    year    = {2025},
-    url     = {https://api.semanticscholar.org/CorpusID:276557720}
-}
-```
-
-```bibtex
-@misc{xiong2025ndrope,
-    author = {Jerry Xiong},
-    title  = {On n-dimensional rotary positional embeddings},
-    year   = {2025},
-    url    = {https://jerryxio.ng/posts/nd-rope/}
-}
-```
-
-```bibtex
-@inproceedings{anonymous2025vat,
-    title   = {{VAT}: Vision Action Transformer by Unlocking Full Representation of ViT},
-    author  = {Anonymous},
-    booktitle = {Submitted to The Fourteenth International Conference on Learning Representations},
-    year    = {2025},
-    url     = {https://openreview.net/forum?id=TalHOvvLZu},
-    note    = {under review}
-}
-```
-
-```bibtex
-@misc{carrigg2025decorrelationspeedsvisiontransformers,
-    title   = {Decorrelation Speeds Up Vision Transformers}, 
-    author  = {Kieran Carrigg and Rob van Gastel and Melda Yeghaian and Sander Dalm and Faysal Boughorbel and Marcel van Gerven},
-    year    = {2025},
-    eprint  = {2510.14657},
-    archivePrefix = {arXiv},
-    primaryClass = {cs.CV},
-    url     = {https://arxiv.org/abs/2510.14657}, 
-}
-```
-
-```bibtex
-@misc{gopalakrishnan2025decouplingwhatwherepolar,
-    title   = {Decoupling the "What" and "Where" With Polar Coordinate Positional Embeddings}, 
-    author  = {Anand Gopalakrishnan and Robert Csordás and Jürgen Schmidhuber and Michael C. Mozer},
-    year    = {2025},
-    eprint  = {2509.10534},
-    archivePrefix = {arXiv},
-    primaryClass = {cs.LG},
-    url     = {https://arxiv.org/abs/2509.10534}, 
-}
-```
-
-```bibtex
-@misc{qiu2025gatedattentionlargelanguage,
-    title   = {Gated Attention for Large Language Models: Non-linearity, Sparsity, and Attention-Sink-Free}, 
-    author  = {Zihan Qiu and Zekun Wang and Bo Zheng and Zeyu Huang and Kaiyue Wen and Songlin Yang and Rui Men and Le Yu and Fei Huang and Suozhi Huang and Dayiheng Liu and Jingren Zhou and Junyang Lin},
-    year    = {2025},
-    eprint  = {2505.06708},
-    archivePrefix = {arXiv},
-    primaryClass = {cs.CL},
-    url     = {https://arxiv.org/abs/2505.06708}, 
-}
-```
-
-```bibtex
-@misc{chen2026postlayernormbackstableexpressive,
-    title   = {Post-LayerNorm Is Back: Stable, ExpressivE, and Deep}, 
-    author  = {Chen Chen and Lai Wei},
-    year    = {2026},
-    eprint  = {2601.19895},
-    archivePrefix = {arXiv},
-    primaryClass = {cs.LG},
-    url     = {https://arxiv.org/abs/2601.19895}, 
-}
-```
-
 *I visualise a time when we will be to robots what dogs are to humans, and I’m rooting for the machines.* — Claude Shannon

examples/cats_and_dogs.ipynb

@@ -16,7 +16,7 @@
     "\n",
     "* Dogs vs. Cats Redux: Kernels Edition - https://www.kaggle.com/c/dogs-vs-cats-redux-kernels-edition\n",
     "* Base Code - https://www.kaggle.com/reukki/pytorch-cnn-tutorial-with-cats-and-dogs/\n",
-    "* Efficient Attention Implementation - https://github.com/lucidrains/vit-pytorch#efficient-attention"
+    "* Effecient Attention Implementation - https://github.com/lucidrains/vit-pytorch#efficient-attention"
    ]
   },
   {
@@ -342,7 +342,7 @@
     "id": "ZhYDJXk2SRDu"
    },
    "source": [
-    "## Image Augmentation"
+    "## Image Augumentation"
    ]
   },
   {
@@ -497,7 +497,7 @@
     "id": "TF9yMaRrSvmv"
    },
    "source": [
-    "## Efficient Attention"
+    "## Effecient Attention"
    ]
   },
   {
@@ -1307,7 +1307,7 @@
   "celltoolbar": "Edit Metadata",
   "colab": {
    "collapsed_sections": [],
-   "name": "Efficient Attention | Cats & Dogs",
+   "name": "Effecient Attention | Cats & Dogs",
    "provenance": [],
    "toc_visible": true
   },

pyproject.toml

@@ -1,63 +0,0 @@
-[build-system]
-requires = ["setuptools>=61", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "vit-pytorch"
-version = "1.17.8"
-description = "Vision Transformer (ViT) - Pytorch"
-readme = { file = "README.md", content-type = "text/markdown" }
-license = { file = "LICENSE" }
-authors = [
-  { name = "Phil Wang", email = "lucidrains@gmail.com" },
-]
-requires-python = ">=3.8"
-keywords = [
-  "artificial intelligence",
-  "attention mechanism",
-  "image recognition",
-]
-classifiers = [
-  "Development Status :: 4 - Beta",
-  "Intended Audience :: Developers",
-  "Topic :: Scientific/Engineering :: Artificial Intelligence",
-  "License :: OSI Approved :: MIT License",
-  "Programming Language :: Python :: 3",
-  "Programming Language :: Python :: 3 :: Only",
-  "Programming Language :: Python :: 3.8",
-  "Programming Language :: Python :: 3.9",
-  "Programming Language :: Python :: 3.10",
-  "Programming Language :: Python :: 3.11",
-  "Programming Language :: Python :: 3.12",
-]
-dependencies = [
-  "einops>=0.7.0",
-  "torch>=1.10",
-  "torchvision",
-]
-
-[project.optional-dependencies]
-test = [
-  "pytest",
-  "torch==2.4.0",
-  "torchvision==0.19.0",
-]
-
-[project.urls]
-Homepage = "https://github.com/lucidrains/vit-pytorch"
-Repository = "https://github.com/lucidrains/vit-pytorch"
-
-[tool.setuptools]
-include-package-data = true
-
-[tool.setuptools.packages.find]
-include = ["vit_pytorch*"]
-exclude = ["examples*", "tests*", "test*"]
-
-[tool.pytest.ini_options]
-testpaths = ["tests", "."]
-python_files = ["test_*.py", "*_test.py"]
-addopts = "-q"
-filterwarnings = [
-  "ignore::FutureWarning",
-]

setup.py

@@ -0,0 +1,35 @@
+from setuptools import setup, find_packages
+
+setup(
+  name = 'vit-pytorch',
+  packages = find_packages(exclude=['examples']),
+  version = '0.35.2',
+  license='MIT',
+  description = 'Vision Transformer (ViT) - Pytorch',
+  author = 'Phil Wang',
+  author_email = 'lucidrains@gmail.com',
+  url = 'https://github.com/lucidrains/vit-pytorch',
+  keywords = [
+    'artificial intelligence',
+    'attention mechanism',
+    'image recognition'
+  ],
+  install_requires=[
+    'einops>=0.4.1',
+    'torch>=1.10',
+    'torchvision'
+  ],
+  setup_requires=[
+    'pytest-runner',
+  ],
+  tests_require=[
+    'pytest'
+  ],
+  classifiers=[
+    'Development Status :: 4 - Beta',
+    'Intended Audience :: Developers',
+    'Topic :: Scientific/Engineering :: Artificial Intelligence',
+    'License :: OSI Approved :: MIT License',
+    'Programming Language :: Python :: 3.6',
+  ],
+)

tests/test.py

@@ -1,7 +1,7 @@
 import torch
 from vit_pytorch import ViT
 
-def test_vit():
+def test():
     v = ViT(
         image_size = 256,
         patch_size = 32,

train_vit_decorr.py

@@ -1,107 +0,0 @@
-# /// script
-# dependencies = [
-#   "accelerate",
-#   "vit-pytorch",
-#   "wandb"
-# ]
-# ///
-
-import torch
-import torch.nn.functional as F
-from torch.utils.data import DataLoader
-
-import torchvision.transforms as T
-from torchvision.datasets import CIFAR100
-
-# constants
-
-BATCH_SIZE = 32
-LEARNING_RATE = 3e-4
-EPOCHS = 10
-DECORR_LOSS_WEIGHT = 1e-1
-
-TRACK_EXPERIMENT_ONLINE = False
-
-# helpers
-
-def exists(v):
-    return v is not None
-
-# data
-
-transform = T.Compose([
-    T.ToTensor(),
-    T.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
-])
-
-dataset = CIFAR100(
-    root = 'data',
-    download = True,
-    train = True,
-    transform = transform
-)
-
-dataloader = DataLoader(dataset, batch_size = BATCH_SIZE, shuffle = True)
-
-# model
-
-from vit_pytorch.vit_with_decorr import ViT
-
-vit = ViT(
-    dim = 128,
-    num_classes = 100,
-    image_size = 32,
-    patch_size = 4,
-    depth = 6,
-    heads = 8,
-    dim_head = 64,
-    mlp_dim = 128 * 4,
-    decorr_sample_frac = 1. # use all tokens
-)
-
-# optim
-
-from torch.optim import Adam
-
-optim = Adam(vit.parameters(), lr = LEARNING_RATE)
-
-# prepare
-
-from accelerate import Accelerator
-
-accelerator = Accelerator()
-
-vit, optim, dataloader = accelerator.prepare(vit, optim, dataloader)
-
-# experiment
-
-import wandb
-
-wandb.init(
-    project = 'vit-decorr',
-    mode = 'disabled' if not TRACK_EXPERIMENT_ONLINE else 'online'
-)
-
-wandb.run.name = 'baseline'
-
-# loop
-
-for _ in range(EPOCHS):
-    for images, labels in dataloader:
-
-        logits, decorr_aux_loss = vit(images)
-        loss = F.cross_entropy(logits, labels)
-
-
-        total_loss = (
-            loss +
-            decorr_aux_loss * DECORR_LOSS_WEIGHT
-        )
-
-        wandb.log(dict(loss = loss, decorr_loss = decorr_aux_loss))
-
-        accelerator.print(f'loss: {loss.item():.3f} | decorr aux loss: {decorr_aux_loss.item():.3f}')
-
-        accelerator.backward(total_loss)
-        optim.step()
-        optim.zero_grad()

vit_pytorch/accept_video_wrapper.py

@@ -1,161 +0,0 @@
-from contextlib import nullcontext
-
-import torch
-from torch import is_tensor, randn
-from torch.nn import Module, Linear, Parameter
-from torch.utils._pytree import tree_flatten, tree_unflatten
-
-from einops import rearrange, repeat
-
-# helper functions
-
-def exists(v):
-    return v is not None
-
-def default(v, d):
-    return v if exists(v) else d
-
-# classes
-
-class AcceptVideoWrapper(Module):
-    def __init__(
-        self,
-        image_net: Module,
-        forward_function = 'forward',
-        add_time_pos_emb = False,
-        dim_emb = None,
-        time_seq_len = None,
-        embed_is_channel_first = False,
-        output_pos_add_pos_emb = 0, # defaults to first output position to add embedding 
-        proj_embed_to_dim = None
-    ):
-        super().__init__()
-        self.image_net = image_net
-        self.forward_function = forward_function # for openclip, used in TRI-LBM
-
-        self.add_time_pos_emb = add_time_pos_emb
-        self.output_pos_add_pos_emb = output_pos_add_pos_emb
-
-        # maybe project the image embedding
-
-        self.embed_proj = None
-
-        if exists(proj_embed_to_dim):
-            assert exists(dim_emb), '`dim_emb` must be passed in'
-            self.embed_proj = Linear(dim_emb, proj_embed_to_dim)
-
-        # time positional embedding
-
-        if add_time_pos_emb:
-            assert exists(dim_emb) and exists(time_seq_len), '`dim_emb` and `time_seq_len` must be set if adding positional embeddings to the output'
-            self.time_seq_len = time_seq_len
-
-            dim_pos_emb = default(proj_embed_to_dim, dim_emb)
-
-            self.pos_emb = Parameter(randn(time_seq_len, dim_pos_emb) * 1e-2)
-
-        self.embed_is_channel_first = embed_is_channel_first
-
-    def forward(
-        self,
-        video, # (b c t h w)
-        eval_with_no_grad = False,
-        forward_kwargs = dict()
-    ):
-        add_time_pos_emb = self.add_time_pos_emb
-        time = video.shape[2]
-
-        # maybe validate time positional embedding
-
-        if add_time_pos_emb:
-            assert time <= self.time_seq_len, f'received video with {time} frames but `time_seq_len` ({self.time_seq_len}) is too low'
-
-        video = rearrange(video, 'b c t h w -> b t c h w')
-
-        video = rearrange(video, 'b t ... -> (b t) ...')
-
-        # forward through image net for outputs
-
-        func = getattr(self.image_net, self.forward_function)
-
-        if eval_with_no_grad:
-            self.image_net.eval()
-
-        context = torch.no_grad if eval_with_no_grad else nullcontext
-
-        with context():
-            outputs = func(video, **forward_kwargs)
-
-        # handle multiple outputs, say logits and embeddings returned from extractor - also handle some reduce aux loss being returned
-
-        outputs, tree_spec = tree_flatten(outputs)
-
-        outputs = tuple(rearrange(t, '(b t) ... -> b t ...', t = time) if is_tensor(t) and t.numel() > 1 else t for t in outputs)
-
-        # maybe project embedding
-
-        if exists(self.embed_proj):
-            outputs = list(outputs)
-
-            embed = outputs[self.output_pos_add_pos_emb]
-
-            outputs[self.output_pos_add_pos_emb] = self.embed_proj(embed)
-
-        # maybe add time positional embedding
-
-        if add_time_pos_emb:
-
-            outputs = list(outputs)
-            embed = outputs[self.output_pos_add_pos_emb]
-
-            pos_emb = rearrange(self.pos_emb, 't d -> 1 t d')
-
-            # handle the network outputting embeddings with spatial dimensions intact - assume embedded dimension is last
-
-            dims_to_unsqueeze = embed.ndim - pos_emb.ndim
-
-            one_dims = ((1,) * dims_to_unsqueeze)
-
-            if self.embed_is_channel_first:
-                pos_emb = pos_emb.reshape(*pos_emb.shape, *one_dims)
-            else:
-                pos_emb = pos_emb.reshape(*pos_emb.shape[:2], *one_dims, pos_emb.shape[-1])
-
-            pos_emb = pos_emb[:, :embed.shape[1]]
-
-            embed = embed + pos_emb
-
-            outputs[self.output_pos_add_pos_emb] = embed
-
-        return tree_unflatten(outputs, tree_spec)
-
-# main
-
-if __name__ == '__main__':
-    from vit_pytorch import ViT
-
-    v = ViT(
-        image_size = 256,
-        patch_size = 32,
-        num_classes = 1000,
-        dim = 1024,
-        depth = 6,
-        heads = 16,
-        mlp_dim = 2048,
-        dropout = 0.1,
-        emb_dropout = 0.1
-    )
-
-    videos = torch.randn(1, 3, 7, 256, 256)
-
-    # step up the difficulty and return embeddings for robotics
-
-    from vit_pytorch.extractor import Extractor
-    v = Extractor(v)
-
-    video_acceptor = AcceptVideoWrapper(v, add_time_pos_emb = True, output_pos_add_pos_emb = 1, time_seq_len = 12, dim_emb = 1024, proj_embed_to_dim = 512)
-
-    logits, embeddings = video_acceptor(videos, eval_with_no_grad = True) # always (batch, channels, time, height, width) - time is always dimension 2
-
-    assert logits.shape == (1, 7, 1000)
-    assert embeddings.shape == (1, 7, 65, 512)

vit_pytorch/ats_vit.py

@@ -110,11 +110,18 @@ class AdaptiveTokenSampling(nn.Module):
 
 # classes
 
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = nn.LayerNorm(dim)
+        self.fn = fn
+    def forward(self, x, **kwargs):
+        return self.fn(self.norm(x), **kwargs)
+
 class FeedForward(nn.Module):
     def __init__(self, dim, hidden_dim, dropout = 0.):
         super().__init__()
         self.net = nn.Sequential(
-            nn.LayerNorm(dim),
             nn.Linear(dim, hidden_dim),
             nn.GELU(),
             nn.Dropout(dropout),
@@ -131,7 +138,6 @@ class Attention(nn.Module):
         self.heads = heads
         self.scale = dim_head ** -0.5
 
-        self.norm = nn.LayerNorm(dim)
         self.attend = nn.Softmax(dim = -1)
         self.dropout = nn.Dropout(dropout)
 
@@ -148,7 +154,6 @@ class Attention(nn.Module):
     def forward(self, x, *, mask):
         num_tokens = x.shape[1]
 
-        x = self.norm(x)
         qkv = self.to_qkv(x).chunk(3, dim = -1)
         q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
 
@@ -184,8 +189,8 @@ class Transformer(nn.Module):
         self.layers = nn.ModuleList([])
         for _, output_num_tokens in zip(range(depth), max_tokens_per_depth):
             self.layers.append(nn.ModuleList([
-                Attention(dim, output_num_tokens = output_num_tokens, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_dim, dropout = dropout)
+                PreNorm(dim, Attention(dim, output_num_tokens = output_num_tokens, heads = heads, dim_head = dim_head, dropout = dropout)),
+                PreNorm(dim, FeedForward(dim, mlp_dim, dropout = dropout))
             ]))
 
     def forward(self, x):
@@ -225,9 +230,7 @@ class ViT(nn.Module):
 
         self.to_patch_embedding = nn.Sequential(
             Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
             nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim)
         )
 
         self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))

vit_pytorch/cait.py

@@ -44,11 +44,18 @@ class LayerScale(nn.Module):
     def forward(self, x, **kwargs):
         return self.fn(x, **kwargs) * self.scale
 
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = nn.LayerNorm(dim)
+        self.fn = fn
+    def forward(self, x, **kwargs):
+        return self.fn(self.norm(x), **kwargs)
+
 class FeedForward(nn.Module):
     def __init__(self, dim, hidden_dim, dropout = 0.):
         super().__init__()
         self.net = nn.Sequential(
-            nn.LayerNorm(dim),
             nn.Linear(dim, hidden_dim),
             nn.GELU(),
             nn.Dropout(dropout),
@@ -65,7 +72,6 @@ class Attention(nn.Module):
         self.heads = heads
         self.scale = dim_head ** -0.5
 
-        self.norm = nn.LayerNorm(dim)
         self.to_q = nn.Linear(dim, inner_dim, bias = False)
         self.to_kv = nn.Linear(dim, inner_dim * 2, bias = False)
 
@@ -83,7 +89,6 @@ class Attention(nn.Module):
     def forward(self, x, context = None):
         b, n, _, h = *x.shape, self.heads
 
-        x = self.norm(x)
         context = x if not exists(context) else torch.cat((x, context), dim = 1)
 
         qkv = (self.to_q(x), *self.to_kv(context).chunk(2, dim = -1))
@@ -110,8 +115,8 @@ class Transformer(nn.Module):
 
         for ind in range(depth):
             self.layers.append(nn.ModuleList([
-                LayerScale(dim, Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout), depth = ind + 1),
-                LayerScale(dim, FeedForward(dim, mlp_dim, dropout = dropout), depth = ind + 1)
+                LayerScale(dim, PreNorm(dim, Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout)), depth = ind + 1),
+                LayerScale(dim, PreNorm(dim, FeedForward(dim, mlp_dim, dropout = dropout)), depth = ind + 1)
             ]))
     def forward(self, x, context = None):
         layers = dropout_layers(self.layers, dropout = self.layer_dropout)
@@ -145,9 +150,7 @@ class CaiT(nn.Module):
 
         self.to_patch_embedding = nn.Sequential(
             Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_size, p2 = patch_size),
-            nn.LayerNorm(patch_dim),
             nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim)
         )
 
         self.pos_embedding = nn.Parameter(torch.randn(1, num_patches, dim))

vit_pytorch/cct.py

@@ -1,17 +1,9 @@
 import torch
-from torch import nn, einsum
+import torch.nn as nn
 import torch.nn.functional as F
 
-from einops import rearrange, repeat
-
 # helpers
 
-def exists(val):
-    return val is not None
-
-def default(val, d):
-    return val if exists(val) else d
-
 def pair(t):
     return t if isinstance(t, tuple) else (t, t)
 
@@ -58,9 +50,8 @@ def cct_16(*args, **kwargs):
 def _cct(num_layers, num_heads, mlp_ratio, embedding_dim,
          kernel_size=3, stride=None, padding=None,
          *args, **kwargs):
-    stride = default(stride, max(1, (kernel_size // 2) - 1))
-    padding = default(padding, max(1, (kernel_size // 2)))
-
+    stride = stride if stride is not None else max(1, (kernel_size // 2) - 1)
+    padding = padding if padding is not None else max(1, (kernel_size // 2))
     return CCT(num_layers=num_layers,
                num_heads=num_heads,
                mlp_ratio=mlp_ratio,
@@ -70,22 +61,13 @@ def _cct(num_layers, num_heads, mlp_ratio, embedding_dim,
                padding=padding,
                *args, **kwargs)
 
-# positional
-
-def sinusoidal_embedding(n_channels, dim):
-    pe = torch.FloatTensor([[p / (10000 ** (2 * (i // 2) / dim)) for i in range(dim)]
-                            for p in range(n_channels)])
-    pe[:, 0::2] = torch.sin(pe[:, 0::2])
-    pe[:, 1::2] = torch.cos(pe[:, 1::2])
-    return rearrange(pe, '... -> 1 ...')
-
 # modules
 
 class Attention(nn.Module):
     def __init__(self, dim, num_heads=8, attention_dropout=0.1, projection_dropout=0.1):
         super().__init__()
-        self.heads = num_heads
-        head_dim = dim // self.heads
+        self.num_heads = num_heads
+        head_dim = dim // self.num_heads
         self.scale = head_dim ** -0.5
 
         self.qkv = nn.Linear(dim, dim * 3, bias=False)
@@ -95,20 +77,17 @@ class Attention(nn.Module):
 
     def forward(self, x):
         B, N, C = x.shape
+        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv[0], qkv[1], qkv[2]
 
-        qkv = self.qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        q = q * self.scale
-
-        attn = einsum('b h i d, b h j d -> b h i j', q, k)
+        attn = (q @ k.transpose(-2, -1)) * self.scale
         attn = attn.softmax(dim=-1)
         attn = self.attn_drop(attn)
 
-        x = einsum('b h i j, b h j d -> b h i d', attn, v)
-        x = rearrange(x, 'b h n d -> b n (h d)')
-
-        return self.proj_drop(self.proj(x))
+        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
 
 
 class TransformerEncoderLayer(nn.Module):
@@ -118,8 +97,7 @@ class TransformerEncoderLayer(nn.Module):
     """
     def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
                  attention_dropout=0.1, drop_path_rate=0.1):
-        super().__init__()
-
+        super(TransformerEncoderLayer, self).__init__()
         self.pre_norm = nn.LayerNorm(d_model)
         self.self_attn = Attention(dim=d_model, num_heads=nhead,
                                    attention_dropout=attention_dropout, projection_dropout=dropout)
@@ -130,34 +108,50 @@ class TransformerEncoderLayer(nn.Module):
         self.linear2  = nn.Linear(dim_feedforward, d_model)
         self.dropout2 = nn.Dropout(dropout)
 
-        self.drop_path = DropPath(drop_path_rate)
+        self.drop_path = DropPath(drop_path_rate) if drop_path_rate > 0 else nn.Identity()
 
         self.activation = F.gelu
 
-    def forward(self, src, *args, **kwargs):
+    def forward(self, src: torch.Tensor, *args, **kwargs) -> torch.Tensor:
         src = src + self.drop_path(self.self_attn(self.pre_norm(src)))
         src = self.norm1(src)
         src2 = self.linear2(self.dropout1(self.activation(self.linear1(src))))
         src = src + self.drop_path(self.dropout2(src2))
         return src
 
+
+def drop_path(x, drop_prob: float = 0., training: bool = False):
+    """
+    Obtained from: github.com:rwightman/pytorch-image-models
+    Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).
+    This is the same as the DropConnect impl I created for EfficientNet, etc networks, however,
+    the original name is misleading as 'Drop Connect' is a different form of dropout in a separate paper...
+    See discussion: https://github.com/tensorflow/tpu/issues/494#issuecomment-532968956 ... I've opted for
+    changing the layer and argument names to 'drop path' rather than mix DropConnect as a layer name and use
+    'survival rate' as the argument.
+    """
+    if drop_prob == 0. or not training:
+        return x
+    keep_prob = 1 - drop_prob
+    shape = (x.shape[0],) + (1,) * (x.ndim - 1)  # work with diff dim tensors, not just 2D ConvNets
+    random_tensor = keep_prob + torch.rand(shape, dtype=x.dtype, device=x.device)
+    random_tensor.floor_()  # binarize
+    output = x.div(keep_prob) * random_tensor
+    return output
+
+
 class DropPath(nn.Module):
+    """
+    Obtained from: github.com:rwightman/pytorch-image-models
+    Drop paths (Stochastic Depth) per sample  (when applied in main path of residual blocks).
+    """
     def __init__(self, drop_prob=None):
-        super().__init__()
-        self.drop_prob = float(drop_prob)
+        super(DropPath, self).__init__()
+        self.drop_prob = drop_prob
 
     def forward(self, x):
-        batch, drop_prob, device, dtype = x.shape[0], self.drop_prob, x.device, x.dtype
+        return drop_path(x, self.drop_prob, self.training)
 
-        if drop_prob <= 0. or not self.training:
-            return x
-
-        keep_prob = 1 - self.drop_prob
-        shape = (batch, *((1,) * (x.ndim - 1)))
-
-        keep_mask = torch.zeros(shape, device = device).float().uniform_(0, 1) < keep_prob
-        output = x.div(keep_prob) * keep_mask.float()
-        return output
 
 class Tokenizer(nn.Module):
     def __init__(self,
@@ -170,35 +164,34 @@ class Tokenizer(nn.Module):
                  activation=None,
                  max_pool=True,
                  conv_bias=False):
-        super().__init__()
+        super(Tokenizer, self).__init__()
 
         n_filter_list = [n_input_channels] + \
                         [in_planes for _ in range(n_conv_layers - 1)] + \
                         [n_output_channels]
 
-        n_filter_list_pairs = zip(n_filter_list[:-1], n_filter_list[1:])
-
         self.conv_layers = nn.Sequential(
             *[nn.Sequential(
-                nn.Conv2d(chan_in, chan_out,
+                nn.Conv2d(n_filter_list[i], n_filter_list[i + 1],
                           kernel_size=(kernel_size, kernel_size),
                           stride=(stride, stride),
                           padding=(padding, padding), bias=conv_bias),
-                nn.Identity() if not exists(activation) else activation(),
+                nn.Identity() if activation is None else activation(),
                 nn.MaxPool2d(kernel_size=pooling_kernel_size,
                              stride=pooling_stride,
                              padding=pooling_padding) if max_pool else nn.Identity()
             )
-                for chan_in, chan_out in n_filter_list_pairs
+                for i in range(n_conv_layers)
             ])
 
+        self.flattener = nn.Flatten(2, 3)
         self.apply(self.init_weight)
 
     def sequence_length(self, n_channels=3, height=224, width=224):
         return self.forward(torch.zeros((1, n_channels, height, width))).shape[1]
 
     def forward(self, x):
-        return rearrange(self.conv_layers(x), 'b c h w -> b (h w) c')
+        return self.flattener(self.conv_layers(x)).transpose(-2, -1)
 
     @staticmethod
     def init_weight(m):
@@ -221,107 +214,106 @@ class TransformerClassifier(nn.Module):
                  sequence_length=None,
                  *args, **kwargs):
         super().__init__()
-        assert positional_embedding in {'sine', 'learnable', 'none'}
-
+        positional_embedding = positional_embedding if \
+            positional_embedding in ['sine', 'learnable', 'none'] else 'sine'
         dim_feedforward = int(embedding_dim * mlp_ratio)
         self.embedding_dim = embedding_dim
         self.sequence_length = sequence_length
         self.seq_pool = seq_pool
 
-        assert exists(sequence_length) or positional_embedding == 'none', \
+        assert sequence_length is not None or positional_embedding == 'none', \
             f"Positional embedding is set to {positional_embedding} and" \
             f" the sequence length was not specified."
 
         if not seq_pool:
             sequence_length += 1
-            self.class_emb = nn.Parameter(torch.zeros(1, 1, self.embedding_dim), requires_grad=True)
+            self.class_emb = nn.Parameter(torch.zeros(1, 1, self.embedding_dim),
+                                          requires_grad=True)
         else:
             self.attention_pool = nn.Linear(self.embedding_dim, 1)
 
-        if positional_embedding == 'none':
-            self.positional_emb = None
-        elif positional_embedding == 'learnable':
-            self.positional_emb = nn.Parameter(torch.zeros(1, sequence_length, embedding_dim),
-                                               requires_grad=True)
-            nn.init.trunc_normal_(self.positional_emb, std=0.2)
+        if positional_embedding != 'none':
+            if positional_embedding == 'learnable':
+                self.positional_emb = nn.Parameter(torch.zeros(1, sequence_length, embedding_dim),
+                                                   requires_grad=True)
+                nn.init.trunc_normal_(self.positional_emb, std=0.2)
+            else:
+                self.positional_emb = nn.Parameter(self.sinusoidal_embedding(sequence_length, embedding_dim),
+                                                   requires_grad=False)
         else:
-            self.positional_emb = nn.Parameter(sinusoidal_embedding(sequence_length, embedding_dim),
-                                               requires_grad=False)
+            self.positional_emb = None
 
         self.dropout = nn.Dropout(p=dropout_rate)
-
         dpr = [x.item() for x in torch.linspace(0, stochastic_depth_rate, num_layers)]
-
         self.blocks = nn.ModuleList([
             TransformerEncoderLayer(d_model=embedding_dim, nhead=num_heads,
                                     dim_feedforward=dim_feedforward, dropout=dropout_rate,
-                                    attention_dropout=attention_dropout, drop_path_rate=layer_dpr)
-            for layer_dpr in dpr])
-
+                                    attention_dropout=attention_dropout, drop_path_rate=dpr[i])
+            for i in range(num_layers)])
         self.norm = nn.LayerNorm(embedding_dim)
 
         self.fc = nn.Linear(embedding_dim, num_classes)
         self.apply(self.init_weight)
 
     def forward(self, x):
-        b = x.shape[0]
-
-        if not exists(self.positional_emb) and x.size(1) < self.sequence_length:
+        if self.positional_emb is None and x.size(1) < self.sequence_length:
             x = F.pad(x, (0, 0, 0, self.n_channels - x.size(1)), mode='constant', value=0)
 
         if not self.seq_pool:
-            cls_token = repeat(self.class_emb, '1 1 d -> b 1 d', b = b)
+            cls_token = self.class_emb.expand(x.shape[0], -1, -1)
             x = torch.cat((cls_token, x), dim=1)
 
-        if exists(self.positional_emb):
+        if self.positional_emb is not None:
             x += self.positional_emb
 
         x = self.dropout(x)
 
         for blk in self.blocks:
             x = blk(x)
-
         x = self.norm(x)
 
         if self.seq_pool:
-            attn_weights = rearrange(self.attention_pool(x), 'b n 1 -> b n')
-            x = einsum('b n, b n d -> b d', attn_weights.softmax(dim = 1), x)
+            x = torch.matmul(F.softmax(self.attention_pool(x), dim=1).transpose(-1, -2), x).squeeze(-2)
         else:
             x = x[:, 0]
 
-        return self.fc(x)
+        x = self.fc(x)
+        return x
 
     @staticmethod
     def init_weight(m):
         if isinstance(m, nn.Linear):
             nn.init.trunc_normal_(m.weight, std=.02)
-            if isinstance(m, nn.Linear) and exists(m.bias):
+            if isinstance(m, nn.Linear) and m.bias is not None:
                 nn.init.constant_(m.bias, 0)
         elif isinstance(m, nn.LayerNorm):
             nn.init.constant_(m.bias, 0)
             nn.init.constant_(m.weight, 1.0)
 
-# CCT Main model
+    @staticmethod
+    def sinusoidal_embedding(n_channels, dim):
+        pe = torch.FloatTensor([[p / (10000 ** (2 * (i // 2) / dim)) for i in range(dim)]
+                                for p in range(n_channels)])
+        pe[:, 0::2] = torch.sin(pe[:, 0::2])
+        pe[:, 1::2] = torch.cos(pe[:, 1::2])
+        return pe.unsqueeze(0)
 
+
+# CCT Main model
 class CCT(nn.Module):
-    def __init__(
-        self,
-        img_size=224,
-        embedding_dim=768,
-        n_input_channels=3,
-        n_conv_layers=1,
-        kernel_size=7,
-        stride=2,
-        padding=3,
-        pooling_kernel_size=3,
-        pooling_stride=2,
-        pooling_padding=1,
-        dropout_rate=0.,
-        attention_dropout=0.1,
-        stochastic_depth_rate=0.1,
-        *args, **kwargs
-    ):
-        super().__init__()
+    def __init__(self,
+                 img_size=224,
+                 embedding_dim=768,
+                 n_input_channels=3,
+                 n_conv_layers=1,
+                 kernel_size=7,
+                 stride=2,
+                 padding=3,
+                 pooling_kernel_size=3,
+                 pooling_stride=2,
+                 pooling_padding=1,
+                 *args, **kwargs):
+        super(CCT, self).__init__()
         img_height, img_width = pair(img_size)
 
         self.tokenizer = Tokenizer(n_input_channels=n_input_channels,
@@ -343,9 +335,9 @@ class CCT(nn.Module):
                                                            width=img_width),
             embedding_dim=embedding_dim,
             seq_pool=True,
-            dropout_rate=dropout_rate,
-            attention_dropout=attention_dropout,
-            stochastic_depth_rate=stochastic_depth_rate,
+            dropout_rate=0.,
+            attention_dropout=0.1,
+            stochastic_depth=0.1,
             *args, **kwargs)
 
     def forward(self, x):

vit_pytorch/cct_3d.py

@@ -1,388 +0,0 @@
-import torch
-from torch import nn, einsum
-import torch.nn.functional as F
-
-from einops import rearrange, repeat
-
-# helpers
-
-def exists(val):
-    return val is not None
-
-def default(val, d):
-    return val if exists(val) else d
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-# CCT Models
-
-__all__ = ['cct_2', 'cct_4', 'cct_6', 'cct_7', 'cct_8', 'cct_14', 'cct_16']
-
-
-def cct_2(*args, **kwargs):
-    return _cct(num_layers=2, num_heads=2, mlp_ratio=1, embedding_dim=128,
-                *args, **kwargs)
-
-
-def cct_4(*args, **kwargs):
-    return _cct(num_layers=4, num_heads=2, mlp_ratio=1, embedding_dim=128,
-                *args, **kwargs)
-
-
-def cct_6(*args, **kwargs):
-    return _cct(num_layers=6, num_heads=4, mlp_ratio=2, embedding_dim=256,
-                *args, **kwargs)
-
-
-def cct_7(*args, **kwargs):
-    return _cct(num_layers=7, num_heads=4, mlp_ratio=2, embedding_dim=256,
-                *args, **kwargs)
-
-
-def cct_8(*args, **kwargs):
-    return _cct(num_layers=8, num_heads=4, mlp_ratio=2, embedding_dim=256,
-                *args, **kwargs)
-
-
-def cct_14(*args, **kwargs):
-    return _cct(num_layers=14, num_heads=6, mlp_ratio=3, embedding_dim=384,
-                *args, **kwargs)
-
-
-def cct_16(*args, **kwargs):
-    return _cct(num_layers=16, num_heads=6, mlp_ratio=3, embedding_dim=384,
-                *args, **kwargs)
-
-
-def _cct(num_layers, num_heads, mlp_ratio, embedding_dim,
-         kernel_size=3, stride=None, padding=None,
-         *args, **kwargs):
-    stride = default(stride, max(1, (kernel_size // 2) - 1))
-    padding = default(padding, max(1, (kernel_size // 2)))
-
-    return CCT(num_layers=num_layers,
-               num_heads=num_heads,
-               mlp_ratio=mlp_ratio,
-               embedding_dim=embedding_dim,
-               kernel_size=kernel_size,
-               stride=stride,
-               padding=padding,
-               *args, **kwargs)
-
-# positional
-
-def sinusoidal_embedding(n_channels, dim):
-    pe = torch.FloatTensor([[p / (10000 ** (2 * (i // 2) / dim)) for i in range(dim)]
-                            for p in range(n_channels)])
-    pe[:, 0::2] = torch.sin(pe[:, 0::2])
-    pe[:, 1::2] = torch.cos(pe[:, 1::2])
-    return rearrange(pe, '... -> 1 ...')
-
-# modules
-
-class Attention(nn.Module):
-    def __init__(self, dim, num_heads=8, attention_dropout=0.1, projection_dropout=0.1):
-        super().__init__()
-        self.heads = num_heads
-        head_dim = dim // self.heads
-        self.scale = head_dim ** -0.5
-
-        self.qkv = nn.Linear(dim, dim * 3, bias=False)
-        self.attn_drop = nn.Dropout(attention_dropout)
-        self.proj = nn.Linear(dim, dim)
-        self.proj_drop = nn.Dropout(projection_dropout)
-
-    def forward(self, x):
-        B, N, C = x.shape
-
-        qkv = self.qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        q = q * self.scale
-
-        attn = einsum('b h i d, b h j d -> b h i j', q, k)
-        attn = attn.softmax(dim=-1)
-        attn = self.attn_drop(attn)
-
-        x = einsum('b h i j, b h j d -> b h i d', attn, v)
-        x = rearrange(x, 'b h n d -> b n (h d)')
-
-        return self.proj_drop(self.proj(x))
-
-
-class TransformerEncoderLayer(nn.Module):
-    """
-    Inspired by torch.nn.TransformerEncoderLayer and
-    rwightman's timm package.
-    """
-    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
-                 attention_dropout=0.1, drop_path_rate=0.1):
-        super().__init__()
-
-        self.pre_norm = nn.LayerNorm(d_model)
-        self.self_attn = Attention(dim=d_model, num_heads=nhead,
-                                   attention_dropout=attention_dropout, projection_dropout=dropout)
-
-        self.linear1  = nn.Linear(d_model, dim_feedforward)
-        self.dropout1 = nn.Dropout(dropout)
-        self.norm1    = nn.LayerNorm(d_model)
-        self.linear2  = nn.Linear(dim_feedforward, d_model)
-        self.dropout2 = nn.Dropout(dropout)
-
-        self.drop_path = DropPath(drop_path_rate)
-
-        self.activation = F.gelu
-
-    def forward(self, src, *args, **kwargs):
-        src = src + self.drop_path(self.self_attn(self.pre_norm(src)))
-        src = self.norm1(src)
-        src2 = self.linear2(self.dropout1(self.activation(self.linear1(src))))
-        src = src + self.drop_path(self.dropout2(src2))
-        return src
-
-class DropPath(nn.Module):
-    def __init__(self, drop_prob=None):
-        super().__init__()
-        self.drop_prob = float(drop_prob)
-
-    def forward(self, x):
-        batch, drop_prob, device, dtype = x.shape[0], self.drop_prob, x.device, x.dtype
-
-        if drop_prob <= 0. or not self.training:
-            return x
-
-        keep_prob = 1 - self.drop_prob
-        shape = (batch, *((1,) * (x.ndim - 1)))
-
-        keep_mask = torch.zeros(shape, device = device).float().uniform_(0, 1) < keep_prob
-        output = x.div(keep_prob) * keep_mask.float()
-        return output
-
-class Tokenizer(nn.Module):
-    def __init__(
-        self,
-        frame_kernel_size,
-        kernel_size,
-        stride,
-        padding,
-        frame_stride=1,
-        frame_padding=None,
-        frame_pooling_stride=1,
-        frame_pooling_kernel_size=1,
-        frame_pooling_padding=None,
-        pooling_kernel_size=3,
-        pooling_stride=2,
-        pooling_padding=1,
-        n_conv_layers=1,
-        n_input_channels=3,
-        n_output_channels=64,
-        in_planes=64,
-        activation=None,
-        max_pool=True,
-        conv_bias=False
-    ):
-        super().__init__()
-
-        n_filter_list = [n_input_channels] + \
-                        [in_planes for _ in range(n_conv_layers - 1)] + \
-                        [n_output_channels]
-
-        n_filter_list_pairs = zip(n_filter_list[:-1], n_filter_list[1:])
-
-        if frame_padding is None:
-            frame_padding = frame_kernel_size // 2
-
-        if frame_pooling_padding is None:
-            frame_pooling_padding = frame_pooling_kernel_size // 2
-
-        self.conv_layers = nn.Sequential(
-            *[nn.Sequential(
-                nn.Conv3d(chan_in, chan_out,
-                          kernel_size=(frame_kernel_size, kernel_size, kernel_size),
-                          stride=(frame_stride, stride, stride),
-                          padding=(frame_padding, padding, padding), bias=conv_bias),
-                nn.Identity() if not exists(activation) else activation(),
-                nn.MaxPool3d(kernel_size=(frame_pooling_kernel_size, pooling_kernel_size, pooling_kernel_size),
-                             stride=(frame_pooling_stride, pooling_stride, pooling_stride),
-                             padding=(frame_pooling_padding, pooling_padding, pooling_padding)) if max_pool else nn.Identity()
-            )
-                for chan_in, chan_out in n_filter_list_pairs
-            ])
-
-        self.apply(self.init_weight)
-
-    def sequence_length(self, n_channels=3, frames=8, height=224, width=224):
-        return self.forward(torch.zeros((1, n_channels, frames, height, width))).shape[1]
-
-    def forward(self, x):
-        x = self.conv_layers(x)
-        return rearrange(x, 'b c f h w -> b (f h w) c')
-
-    @staticmethod
-    def init_weight(m):
-        if isinstance(m, nn.Conv3d):
-            nn.init.kaiming_normal_(m.weight)
-
-
-class TransformerClassifier(nn.Module):
-    def __init__(
-        self,
-        seq_pool=True,
-        embedding_dim=768,
-        num_layers=12,
-        num_heads=12,
-        mlp_ratio=4.0,
-        num_classes=1000,
-        dropout_rate=0.1,
-        attention_dropout=0.1,
-        stochastic_depth_rate=0.1,
-        positional_embedding='sine',
-        sequence_length=None,
-        *args, **kwargs
-    ):
-        super().__init__()
-        assert positional_embedding in {'sine', 'learnable', 'none'}
-
-        dim_feedforward = int(embedding_dim * mlp_ratio)
-        self.embedding_dim = embedding_dim
-        self.sequence_length = sequence_length
-        self.seq_pool = seq_pool
-
-        assert exists(sequence_length) or positional_embedding == 'none', \
-            f"Positional embedding is set to {positional_embedding} and" \
-            f" the sequence length was not specified."
-
-        if not seq_pool:
-            sequence_length += 1
-            self.class_emb = nn.Parameter(torch.zeros(1, 1, self.embedding_dim))
-        else:
-            self.attention_pool = nn.Linear(self.embedding_dim, 1)
-
-        if positional_embedding == 'none':
-            self.positional_emb = None
-        elif positional_embedding == 'learnable':
-            self.positional_emb = nn.Parameter(torch.zeros(1, sequence_length, embedding_dim))
-            nn.init.trunc_normal_(self.positional_emb, std = 0.2)
-        else:
-            self.register_buffer('positional_emb', sinusoidal_embedding(sequence_length, embedding_dim))
-
-        self.dropout = nn.Dropout(p=dropout_rate)
-
-        dpr = [x.item() for x in torch.linspace(0, stochastic_depth_rate, num_layers)]
-
-        self.blocks = nn.ModuleList([
-            TransformerEncoderLayer(d_model=embedding_dim, nhead=num_heads,
-                                    dim_feedforward=dim_feedforward, dropout=dropout_rate,
-                                    attention_dropout=attention_dropout, drop_path_rate=layer_dpr)
-            for layer_dpr in dpr])
-
-        self.norm = nn.LayerNorm(embedding_dim)
-
-        self.fc = nn.Linear(embedding_dim, num_classes)
-        self.apply(self.init_weight)
-
-    @staticmethod
-    def init_weight(m):
-        if isinstance(m, nn.Linear):
-            nn.init.trunc_normal_(m.weight, std=.02)
-            if isinstance(m, nn.Linear) and exists(m.bias):
-                nn.init.constant_(m.bias, 0)
-        elif isinstance(m, nn.LayerNorm):
-            nn.init.constant_(m.bias, 0)
-            nn.init.constant_(m.weight, 1.0)
-
-    def forward(self, x):
-        b = x.shape[0]
-
-        if not exists(self.positional_emb) and x.size(1) < self.sequence_length:
-            x = F.pad(x, (0, 0, 0, self.n_channels - x.size(1)), mode='constant', value=0)
-
-        if not self.seq_pool:
-            cls_token = repeat(self.class_emb, '1 1 d -> b 1 d', b = b)
-            x = torch.cat((cls_token, x), dim=1)
-
-        if exists(self.positional_emb):
-            x += self.positional_emb
-
-        x = self.dropout(x)
-
-        for blk in self.blocks:
-            x = blk(x)
-
-        x = self.norm(x)
-
-        if self.seq_pool:
-            attn_weights = rearrange(self.attention_pool(x), 'b n 1 -> b n')
-            x = einsum('b n, b n d -> b d', attn_weights.softmax(dim = 1), x)
-        else:
-            x = x[:, 0]
-
-        return self.fc(x)
-
-# CCT Main model
-
-class CCT(nn.Module):
-    def __init__(
-        self,
-        img_size=224,
-        num_frames=8,
-        embedding_dim=768,
-        n_input_channels=3,
-        n_conv_layers=1,
-        frame_stride=1,
-        frame_kernel_size=3,
-        frame_padding=None,
-        frame_pooling_kernel_size=1,
-        frame_pooling_stride=1,
-        frame_pooling_padding=None,
-        kernel_size=7,
-        stride=2,
-        padding=3,
-        pooling_kernel_size=3,
-        pooling_stride=2,
-        pooling_padding=1,
-        *args, **kwargs
-    ):
-        super().__init__()
-        img_height, img_width = pair(img_size)
-
-        self.tokenizer = Tokenizer(
-            n_input_channels=n_input_channels,
-            n_output_channels=embedding_dim,
-            frame_stride=frame_stride,
-            frame_kernel_size=frame_kernel_size,
-            frame_padding=frame_padding,
-            frame_pooling_stride=frame_pooling_stride,
-            frame_pooling_kernel_size=frame_pooling_kernel_size,
-            frame_pooling_padding=frame_pooling_padding,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=padding,
-            pooling_kernel_size=pooling_kernel_size,
-            pooling_stride=pooling_stride,
-            pooling_padding=pooling_padding,
-            max_pool=True,
-            activation=nn.ReLU,
-            n_conv_layers=n_conv_layers,
-            conv_bias=False
-        )
-
-        self.classifier = TransformerClassifier(
-            sequence_length=self.tokenizer.sequence_length(
-                n_channels=n_input_channels,
-                frames=num_frames,
-                height=img_height,
-                width=img_width
-            ),
-            embedding_dim=embedding_dim,
-            seq_pool=True,
-            dropout_rate=0.,
-            attention_dropout=0.1,
-            stochastic_depth=0.1,
-            *args, **kwargs
-        )
-
-    def forward(self, x):
-        x = self.tokenizer(x)
-        return self.classifier(x)

vit_pytorch/cross_vit.py

@@ -13,13 +13,22 @@ def exists(val):
 def default(val, d):
     return val if exists(val) else d
 
+# pre-layernorm
+
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = nn.LayerNorm(dim)
+        self.fn = fn
+    def forward(self, x, **kwargs):
+        return self.fn(self.norm(x), **kwargs)
+
 # feedforward
 
 class FeedForward(nn.Module):
     def __init__(self, dim, hidden_dim, dropout = 0.):
         super().__init__()
         self.net = nn.Sequential(
-            nn.LayerNorm(dim),
             nn.Linear(dim, hidden_dim),
             nn.GELU(),
             nn.Dropout(dropout),
@@ -38,7 +47,6 @@ class Attention(nn.Module):
         self.heads = heads
         self.scale = dim_head ** -0.5
 
-        self.norm = nn.LayerNorm(dim)
         self.attend = nn.Softmax(dim = -1)
         self.dropout = nn.Dropout(dropout)
 
@@ -52,7 +60,6 @@ class Attention(nn.Module):
 
     def forward(self, x, context = None, kv_include_self = False):
         b, n, _, h = *x.shape, self.heads
-        x = self.norm(x)
         context = default(context, x)
 
         if kv_include_self:
@@ -79,8 +86,8 @@ class Transformer(nn.Module):
         self.norm = nn.LayerNorm(dim)
         for _ in range(depth):
             self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_dim, dropout = dropout)
+                PreNorm(dim, Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout)),
+                PreNorm(dim, FeedForward(dim, mlp_dim, dropout = dropout))
             ]))
 
     def forward(self, x):
@@ -114,8 +121,8 @@ class CrossTransformer(nn.Module):
         self.layers = nn.ModuleList([])
         for _ in range(depth):
             self.layers.append(nn.ModuleList([
-                ProjectInOut(sm_dim, lg_dim, Attention(lg_dim, heads = heads, dim_head = dim_head, dropout = dropout)),
-                ProjectInOut(lg_dim, sm_dim, Attention(sm_dim, heads = heads, dim_head = dim_head, dropout = dropout))
+                ProjectInOut(sm_dim, lg_dim, PreNorm(lg_dim, Attention(lg_dim, heads = heads, dim_head = dim_head, dropout = dropout))),
+                ProjectInOut(lg_dim, sm_dim, PreNorm(sm_dim, Attention(sm_dim, heads = heads, dim_head = dim_head, dropout = dropout)))
             ]))
 
     def forward(self, sm_tokens, lg_tokens):
@@ -170,19 +177,16 @@ class ImageEmbedder(nn.Module):
         dim,
         image_size,
         patch_size,
-        dropout = 0.,
-        channels = 3
+        dropout = 0.
     ):
         super().__init__()
         assert image_size % patch_size == 0, 'Image dimensions must be divisible by the patch size.'
         num_patches = (image_size // patch_size) ** 2
-        patch_dim = channels * patch_size ** 2
+        patch_dim = 3 * patch_size ** 2
 
         self.to_patch_embedding = nn.Sequential(
             Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_size, p2 = patch_size),
-            nn.LayerNorm(patch_dim),
             nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim)
         )
 
         self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))
@@ -224,12 +228,11 @@ class CrossViT(nn.Module):
         cross_attn_dim_head = 64,
         depth = 3,
         dropout = 0.1,
-        emb_dropout = 0.1,
-        channels = 3
+        emb_dropout = 0.1
     ):
         super().__init__()
-        self.sm_image_embedder = ImageEmbedder(dim = sm_dim, channels= channels, image_size = image_size, patch_size = sm_patch_size, dropout = emb_dropout)
-        self.lg_image_embedder = ImageEmbedder(dim = lg_dim, channels = channels, image_size = image_size, patch_size = lg_patch_size, dropout = emb_dropout)
+        self.sm_image_embedder = ImageEmbedder(dim = sm_dim, image_size = image_size, patch_size = sm_patch_size, dropout = emb_dropout)
+        self.lg_image_embedder = ImageEmbedder(dim = lg_dim, image_size = image_size, patch_size = lg_patch_size, dropout = emb_dropout)
 
         self.multi_scale_encoder = MultiScaleEncoder(
             depth = depth,

vit_pytorch/cvt.py

@@ -34,11 +34,19 @@ class LayerNorm(nn.Module): # layernorm, but done in the channel dimension #1
         mean = torch.mean(x, dim = 1, keepdim = True)
         return (x - mean) / (var + self.eps).sqrt() * self.g + self.b
 
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = LayerNorm(dim)
+        self.fn = fn
+    def forward(self, x, **kwargs):
+        x = self.norm(x)
+        return self.fn(x, **kwargs)
+
 class FeedForward(nn.Module):
     def __init__(self, dim, mult = 4, dropout = 0.):
         super().__init__()
         self.net = nn.Sequential(
-            LayerNorm(dim),
             nn.Conv2d(dim, dim * mult, 1),
             nn.GELU(),
             nn.Dropout(dropout),
@@ -67,7 +75,6 @@ class Attention(nn.Module):
         self.heads = heads
         self.scale = dim_head ** -0.5
 
-        self.norm = LayerNorm(dim)
         self.attend = nn.Softmax(dim = -1)
         self.dropout = nn.Dropout(dropout)
 
@@ -82,8 +89,6 @@ class Attention(nn.Module):
     def forward(self, x):
         shape = x.shape
         b, n, _, y, h = *shape, self.heads
-
-        x = self.norm(x)
         q, k, v = (self.to_q(x), *self.to_kv(x).chunk(2, dim = 1))
         q, k, v = map(lambda t: rearrange(t, 'b (h d) x y -> (b h) (x y) d', h = h), (q, k, v))
 
@@ -102,8 +107,8 @@ class Transformer(nn.Module):
         self.layers = nn.ModuleList([])
         for _ in range(depth):
             self.layers.append(nn.ModuleList([
-                Attention(dim, proj_kernel = proj_kernel, kv_proj_stride = kv_proj_stride, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_mult, dropout = dropout)
+                PreNorm(dim, Attention(dim, proj_kernel = proj_kernel, kv_proj_stride = kv_proj_stride, heads = heads, dim_head = dim_head, dropout = dropout)),
+                PreNorm(dim, FeedForward(dim, mlp_mult, dropout = dropout))
             ]))
     def forward(self, x):
         for attn, ff in self.layers:
@@ -140,13 +145,12 @@ class CvT(nn.Module):
         s3_heads = 6,
         s3_depth = 10,
         s3_mlp_mult = 4,
-        dropout = 0.,
-        channels = 3
+        dropout = 0.
     ):
         super().__init__()
         kwargs = dict(locals())
 
-        dim = channels
+        dim = 3
         layers = []
 
         for prefix in ('s1', 's2', 's3'):

vit_pytorch/deepvit.py

@@ -5,11 +5,25 @@ import torch.nn.functional as F
 from einops import rearrange, repeat
 from einops.layers.torch import Rearrange
 
+class Residual(nn.Module):
+    def __init__(self, fn):
+        super().__init__()
+        self.fn = fn
+    def forward(self, x, **kwargs):
+        return self.fn(x, **kwargs) + x
+
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = nn.LayerNorm(dim)
+        self.fn = fn
+    def forward(self, x, **kwargs):
+        return self.fn(self.norm(x), **kwargs)
+
 class FeedForward(nn.Module):
     def __init__(self, dim, hidden_dim, dropout = 0.):
         super().__init__()
         self.net = nn.Sequential(
-            nn.LayerNorm(dim),
             nn.Linear(dim, hidden_dim),
             nn.GELU(),
             nn.Dropout(dropout),
@@ -26,7 +40,6 @@ class Attention(nn.Module):
         self.heads = heads
         self.scale = dim_head ** -0.5
 
-        self.norm = nn.LayerNorm(dim)
         self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
 
         self.dropout = nn.Dropout(dropout)
@@ -46,8 +59,6 @@ class Attention(nn.Module):
 
     def forward(self, x):
         b, n, _, h = *x.shape, self.heads
-        x = self.norm(x)
-
         qkv = self.to_qkv(x).chunk(3, dim = -1)
         q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = h), qkv)
 
@@ -75,13 +86,13 @@ class Transformer(nn.Module):
         self.layers = nn.ModuleList([])
         for _ in range(depth):
             self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_dim, dropout = dropout)
+                Residual(PreNorm(dim, Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout))),
+                Residual(PreNorm(dim, FeedForward(dim, mlp_dim, dropout = dropout)))
             ]))
     def forward(self, x):
         for attn, ff in self.layers:
-            x = attn(x) + x
-            x = ff(x) + x
+            x = attn(x)
+            x = ff(x)
         return x
 
 class DeepViT(nn.Module):
@@ -94,9 +105,7 @@ class DeepViT(nn.Module):
 
         self.to_patch_embedding = nn.Sequential(
             Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_size, p2 = patch_size),
-            nn.LayerNorm(patch_dim),
             nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim)
         )
 
         self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))

vit_pytorch/distill.py

@@ -1,8 +1,6 @@
 import torch
-from torch import nn
-from torch.nn import Module
 import torch.nn.functional as F
-
+from torch import nn
 from vit_pytorch.vit import ViT
 from vit_pytorch.t2t import T2TViT
 from vit_pytorch.efficient import ViT as EfficientViT
@@ -14,9 +12,6 @@ from einops import rearrange, repeat
 def exists(val):
     return val is not None
 
-def default(val, d):
-    return val if exists(val) else d
-
 # classes
 
 class DistillMixin:
@@ -25,12 +20,12 @@ class DistillMixin:
         x = self.to_patch_embedding(img)
         b, n, _ = x.shape
 
-        cls_tokens = repeat(self.cls_token, 'n d -> b n d', b = b)
+        cls_tokens = repeat(self.cls_token, '() n d -> b n d', b = b)
         x = torch.cat((cls_tokens, x), dim = 1)
-        x += self.pos_embedding[:(n + 1)]
+        x += self.pos_embedding[:, :(n + 1)]
 
         if distilling:
-            distill_tokens = repeat(distill_token, 'n d -> b n d', b = b)
+            distill_tokens = repeat(distill_token, '() n d -> b n d', b = b)
             x = torch.cat((x, distill_tokens), dim = 1)
 
         x = self._attend(x)
@@ -102,7 +97,7 @@ class DistillableEfficientViT(DistillMixin, EfficientViT):
 
 # knowledge distillation wrapper
 
-class DistillWrapper(Module):
+class DistillWrapper(nn.Module):
     def __init__(
         self,
         *,
@@ -110,8 +105,7 @@ class DistillWrapper(Module):
         student,
         temperature = 1.,
         alpha = 0.5,
-        hard = False,
-        mlp_layernorm = False
+        hard = False
     ):
         super().__init__()
         assert (isinstance(student, (DistillableViT, DistillableT2TViT, DistillableEfficientViT))) , 'student must be a vision transformer'
@@ -125,17 +119,17 @@ class DistillWrapper(Module):
         self.alpha = alpha
         self.hard = hard
 
-        self.distillation_token = nn.Parameter(torch.randn(1, dim))
+        self.distillation_token = nn.Parameter(torch.randn(1, 1, dim))
 
         self.distill_mlp = nn.Sequential(
-            nn.LayerNorm(dim) if mlp_layernorm else nn.Identity(),
+            nn.LayerNorm(dim),
             nn.Linear(dim, num_classes)
         )
 
     def forward(self, img, labels, temperature = None, alpha = None, **kwargs):
-
-        alpha = default(alpha, self.alpha)
-        T = default(temperature, self.temperature)
+        b, *_ = img.shape
+        alpha = alpha if exists(alpha) else self.alpha
+        T = temperature if exists(temperature) else self.temperature
 
         with torch.no_grad():
             teacher_logits = self.teacher(img)

vit_pytorch/efficient.py

@@ -17,9 +17,7 @@ class ViT(nn.Module):
 
         self.to_patch_embedding = nn.Sequential(
             Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_size, p2 = patch_size),
-            nn.LayerNorm(patch_dim),
             nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim)
         )
 
         self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))

vit_pytorch/extractor.py

@@ -4,27 +4,14 @@ from torch import nn
 def exists(val):
     return val is not None
 
-def identity(t):
-    return t
-
-def clone_and_detach(t):
-    return t.clone().detach()
-
-def apply_tuple_or_single(fn, val):
-    if isinstance(val, tuple):
-        return tuple(map(fn, val))
-    return fn(val)
-
 class Extractor(nn.Module):
     def __init__(
         self,
         vit,
         device = None,
-        layer = None,
         layer_name = 'transformer',
         layer_save_input = False,
-        return_embeddings_only = False,
-        detach = True
+        return_embeddings_only = False
     ):
         super().__init__()
         self.vit = vit
@@ -36,24 +23,17 @@ class Extractor(nn.Module):
         self.ejected = False
         self.device = device
 
-        self.layer = layer
         self.layer_name = layer_name
         self.layer_save_input = layer_save_input # whether to save input or output of layer
         self.return_embeddings_only = return_embeddings_only
 
-        self.detach_fn = clone_and_detach if detach else identity
-
     def _hook(self, _, inputs, output):
-        layer_output = inputs if self.layer_save_input else output
-        self.latents = apply_tuple_or_single(self.detach_fn, layer_output)
+        tensor_to_save = inputs if self.layer_save_input else output
+        self.latents = tensor_to_save.clone().detach()
 
     def _register_hook(self):
-        if not exists(self.layer):
-            assert hasattr(self.vit, self.layer_name), 'layer whose output to take as embedding not found in vision transformer'
-            layer = getattr(self.vit, self.layer_name)
-        else:
-            layer = self.layer
-
+        assert hasattr(self.vit, self.layer_name), 'layer whose output to take as embedding not found in vision transformer'
+        layer = getattr(self.vit, self.layer_name)
         handle = layer.register_forward_hook(self._hook)
         self.hooks.append(handle)
         self.hook_registered = True
@@ -82,7 +62,7 @@ class Extractor(nn.Module):
         pred = self.vit(img)
 
         target_device = self.device if exists(self.device) else img.device
-        latents = apply_tuple_or_single(lambda t: t.to(target_device), self.latents)
+        latents = self.latents.to(target_device)
 
         if return_embeddings_only or self.return_embeddings_only:
             return latents

vit_pytorch/jumbo_vit.py

@@ -1,204 +0,0 @@
-# Simpler Fast Vision Transformers with a Jumbo CLS Token
-# https://arxiv.org/abs/2502.15021
-
-import torch
-from torch import nn
-from torch.nn import Module, ModuleList
-
-from einops import rearrange, repeat, reduce, pack, unpack
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-def divisible_by(num, den):
-    return (num % den) == 0
-
-def posemb_sincos_2d(h, w, dim, temperature: int = 10000, dtype = torch.float32):
-    y, x = torch.meshgrid(torch.arange(h), torch.arange(w), indexing="ij")
-    assert divisible_by(dim, 4), "feature dimension must be multiple of 4 for sincos emb"
-
-    omega = torch.arange(dim // 4) / (dim // 4 - 1)
-    omega = temperature ** -omega
-
-    y = y.flatten()[:, None] * omega[None, :]
-    x = x.flatten()[:, None] * omega[None, :]
-    pos_emb = torch.cat((x.sin(), x.cos(), y.sin(), y.cos()), dim=1)
-
-    return pos_emb.type(dtype)
-
-# classes
-
-def FeedForward(dim, mult = 4.):
-    hidden_dim = int(dim * mult)
-    return nn.Sequential(
-        nn.LayerNorm(dim),
-        nn.Linear(dim, hidden_dim),
-        nn.GELU(),
-        nn.Linear(hidden_dim, dim),
-    )
-
-class Attention(Module):
-    def __init__(self, dim, heads = 8, dim_head = 64):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-        self.norm = nn.LayerNorm(dim)
-
-        self.attend = nn.Softmax(dim = -1)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-        self.to_out = nn.Linear(inner_dim, dim, bias = False)
-
-    def forward(self, x):
-        x = self.norm(x)
-
-        qkv = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-
-        attn = self.attend(dots)
-
-        out = torch.matmul(attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class JumboViT(Module):
-    def __init__(
-        self,
-        *,
-        image_size,
-        patch_size,
-        num_classes,
-        dim,
-        depth,
-        heads,
-        mlp_dim,
-        num_jumbo_cls = 1,  # differing from paper, allow for multiple jumbo cls, so one could break it up into 2 jumbo cls tokens with 3x the dim, as an example
-        jumbo_cls_k = 6,    # they use a CLS token with this factor times the dimension - 6 was the value they settled on
-        jumbo_ff_mult = 2,  # expansion factor of the jumbo cls token feedforward
-        channels = 3,
-        dim_head = 64
-    ):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(patch_size)
-
-        assert divisible_by(image_height, patch_height) and divisible_by(image_width, patch_width), 'Image dimensions must be divisible by the patch size.'
-
-        patch_dim = channels * patch_height * patch_width
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange("b c (h p1) (w p2) -> b (h w) (p1 p2 c)", p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.pos_embedding = posemb_sincos_2d(
-            h = image_height // patch_height,
-            w = image_width // patch_width,
-            dim = dim,
-        ) 
-
-        jumbo_cls_dim = dim * jumbo_cls_k
-
-        self.jumbo_cls_token = nn.Parameter(torch.zeros(num_jumbo_cls, jumbo_cls_dim))
-
-        jumbo_cls_to_tokens = Rearrange('b n (k d) -> b (n k) d', k = jumbo_cls_k)
-        self.jumbo_cls_to_tokens = jumbo_cls_to_tokens
-
-        self.norm = nn.LayerNorm(dim)
-        self.layers = ModuleList([])
-
-        # attention and feedforwards
-
-        self.jumbo_ff = nn.Sequential(
-            Rearrange('b (n k) d -> b n (k d)', k = jumbo_cls_k),
-            FeedForward(jumbo_cls_dim, int(jumbo_cls_dim * jumbo_ff_mult)), # they use separate parameters for the jumbo feedforward, weight tied for parameter efficient
-            jumbo_cls_to_tokens
-        )
-
-        for _ in range(depth):
-            self.layers.append(ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head),
-                FeedForward(dim, mlp_dim),
-            ]))
-
-        self.to_latent = nn.Identity()
-
-        self.linear_head = nn.Linear(dim, num_classes)
-
-    def forward(self, img):
-
-        batch, device = img.shape[0], img.device
-
-        x = self.to_patch_embedding(img)
-
-        # pos embedding
-
-        pos_emb = self.pos_embedding.to(device, dtype = x.dtype)
-
-        x = x + pos_emb
-
-        # add cls tokens
-
-        cls_tokens = repeat(self.jumbo_cls_token, 'nj d -> b nj d', b = batch)
-
-        jumbo_tokens = self.jumbo_cls_to_tokens(cls_tokens)
-
-        x, cls_packed_shape = pack([jumbo_tokens, x], 'b * d')
-
-        # attention and feedforwards
-
-        for layer, (attn, ff) in enumerate(self.layers, start = 1):
-            is_last = layer == len(self.layers)
-
-            x = attn(x) + x
-
-            # jumbo feedforward
-
-            jumbo_cls_tokens, x = unpack(x, cls_packed_shape, 'b * d')
-
-            x = ff(x) + x
-            jumbo_cls_tokens = self.jumbo_ff(jumbo_cls_tokens) + jumbo_cls_tokens
-
-            if is_last:
-                continue
-
-            x, _ = pack([jumbo_cls_tokens, x], 'b * d')
-
-        pooled = reduce(jumbo_cls_tokens, 'b n d -> b d', 'mean')
-
-        # normalization and project to logits
-
-        embed = self.norm(pooled)
-
-        embed = self.to_latent(embed)
-        logits = self.linear_head(embed)
-        return logits
-
-# copy pasteable file
-
-if __name__ == '__main__':
-
-    v = JumboViT(
-        num_classes = 1000,
-        image_size = 64,
-        patch_size = 8,
-        dim = 16,
-        depth = 2,
-        heads = 2,
-        mlp_dim = 32,
-        jumbo_cls_k = 3,
-        jumbo_ff_mult = 2,
-    )
-
-    images = torch.randn(1, 3, 64, 64)
-
-    logits = v(images)
-    assert logits.shape == (1, 1000)

vit_pytorch/learnable_memory_vit.py

@@ -118,9 +118,7 @@ class ViT(nn.Module):
 
         self.to_patch_embedding = nn.Sequential(
             Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
             nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim)
         )
 
         self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))

vit_pytorch/local_vit.py

@@ -26,6 +26,16 @@ class ExcludeCLS(nn.Module):
         x = self.fn(x, **kwargs)
         return torch.cat((cls_token, x), dim = 1)
 
+# prenorm
+
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = nn.LayerNorm(dim)
+        self.fn = fn
+    def forward(self, x, **kwargs):
+        return self.fn(self.norm(x), **kwargs)
+
 # feed forward related classes
 
 class DepthWiseConv2d(nn.Module):
@@ -42,7 +52,6 @@ class FeedForward(nn.Module):
     def __init__(self, dim, hidden_dim, dropout = 0.):
         super().__init__()
         self.net = nn.Sequential(
-            nn.LayerNorm(dim),
             nn.Conv2d(dim, hidden_dim, 1),
             nn.Hardswish(),
             DepthWiseConv2d(hidden_dim, hidden_dim, 3, padding = 1),
@@ -68,7 +77,6 @@ class Attention(nn.Module):
         self.heads = heads
         self.scale = dim_head ** -0.5
 
-        self.norm = nn.LayerNorm(dim)
         self.attend = nn.Softmax(dim = -1)
         self.dropout = nn.Dropout(dropout)
         self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
@@ -80,8 +88,6 @@ class Attention(nn.Module):
 
     def forward(self, x):
         b, n, _, h = *x.shape, self.heads
-
-        x = self.norm(x)
         qkv = self.to_qkv(x).chunk(3, dim = -1)
         q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = h), qkv)
 
@@ -100,8 +106,8 @@ class Transformer(nn.Module):
         self.layers = nn.ModuleList([])
         for _ in range(depth):
             self.layers.append(nn.ModuleList([
-                Residual(Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout)),
-                ExcludeCLS(Residual(FeedForward(dim, mlp_dim, dropout = dropout)))
+                Residual(PreNorm(dim, Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout))),
+                ExcludeCLS(Residual(PreNorm(dim, FeedForward(dim, mlp_dim, dropout = dropout))))
             ]))
     def forward(self, x):
         for attn, ff in self.layers:
@@ -120,9 +126,7 @@ class LocalViT(nn.Module):
 
         self.to_patch_embedding = nn.Sequential(
             Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_size, p2 = patch_size),
-            nn.LayerNorm(patch_dim),
             nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
         )
 
         self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))

vit_pytorch/look_vit.py

@@ -1,278 +0,0 @@
-import torch
-from torch import nn
-import torch.nn.functional as F
-from torch.nn import Module, ModuleList
-
-from einops import einsum, rearrange, repeat, reduce
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def exists(val):
-    return val is not None
-
-def default(val, d):
-    return val if exists(val) else d
-
-def divisible_by(num, den):
-    return (num % den) == 0
-
-# simple vit sinusoidal pos emb
-
-def posemb_sincos_2d(t, temperature = 10000):
-    h, w, d, device = *t.shape[1:], t.device
-    y, x = torch.meshgrid(torch.arange(h, device = device), torch.arange(w, device = device), indexing = 'ij')
-    assert (d % 4) == 0, "feature dimension must be multiple of 4 for sincos emb"
-    omega = torch.arange(d // 4, device = device) / (d // 4 - 1)
-    omega = temperature ** -omega
-
-    y = y.flatten()[:, None] * omega[None, :]
-    x = x.flatten()[:, None] * omega[None, :]
-    pos = torch.cat((x.sin(), x.cos(), y.sin(), y.cos()), dim = 1)
-
-    return pos.float()
-
-# bias-less layernorm with unit offset trick (discovered by Ohad Rubin)
-
-class LayerNorm(Module):
-    def __init__(self, dim):
-        super().__init__()
-        self.ln = nn.LayerNorm(dim, elementwise_affine = False)
-        self.gamma = nn.Parameter(torch.zeros(dim))
-
-    def forward(self, x):
-        normed = self.ln(x)
-        return normed * (self.gamma + 1)
-
-# mlp
-
-def MLP(dim, factor = 4, dropout = 0.):
-    hidden_dim = int(dim * factor)
-    return nn.Sequential(
-        LayerNorm(dim),
-        nn.Linear(dim, hidden_dim),
-        nn.GELU(),
-        nn.Dropout(dropout),
-        nn.Linear(hidden_dim, dim),
-        nn.Dropout(dropout)
-    )
-
-# attention
-
-class Attention(Module):
-    def __init__(
-        self,
-        dim,
-        heads = 8,
-        dim_head = 64,
-        dropout = 0.,
-        cross_attend = False,
-        reuse_attention = False
-    ):
-        super().__init__()
-        inner_dim = dim_head *  heads
-
-        self.scale = dim_head ** -0.5
-        self.heads = heads
-        self.reuse_attention = reuse_attention
-        self.cross_attend = cross_attend
-
-        self.split_heads = Rearrange('b n (h d) -> b h n d', h = heads)
-
-        self.norm = LayerNorm(dim) if not reuse_attention else nn.Identity()
-        self.norm_context = LayerNorm(dim) if cross_attend else nn.Identity()
-
-        self.attend = nn.Softmax(dim = -1)
-        self.dropout = nn.Dropout(dropout)
-
-        self.to_q = nn.Linear(dim, inner_dim, bias = False) if not reuse_attention else None
-        self.to_k = nn.Linear(dim, inner_dim, bias = False) if not reuse_attention else None
-        self.to_v = nn.Linear(dim, inner_dim, bias = False)
-
-        self.to_out = nn.Sequential(
-            Rearrange('b h n d -> b n (h d)'),
-            nn.Linear(inner_dim, dim, bias = False),
-            nn.Dropout(dropout)
-        )
-
-    def forward(
-        self,
-        x,
-        context = None,
-        return_qk_sim = False,
-        qk_sim = None
-    ):
-        x = self.norm(x)
-
-        assert not (exists(context) ^ self.cross_attend)
-
-        if self.cross_attend:
-            context = self.norm_context(context)
-        else:
-            context = x
-
-        v = self.to_v(context)
-        v = self.split_heads(v)
-
-        if not self.reuse_attention:
-            qk = (self.to_q(x), self.to_k(context))
-            q, k = tuple(self.split_heads(t) for t in qk)
-
-            q = q * self.scale
-            qk_sim = einsum(q, k, 'b h i d, b h j d -> b h i j')
-
-        else:
-            assert exists(qk_sim), 'qk sim matrix must be passed in for reusing previous attention'
-
-        attn = self.attend(qk_sim)
-        attn = self.dropout(attn)
-
-        out = einsum(attn, v, 'b h i j, b h j d -> b h i d')
-        out = self.to_out(out)
-
-        if not return_qk_sim:
-            return out
-
-        return out, qk_sim
-
-# LookViT
-
-class LookViT(Module):
-    def __init__(
-        self,
-        *,
-        dim,
-        image_size,
-        num_classes,
-        depth = 3,
-        patch_size = 16,
-        heads = 8,
-        mlp_factor = 4,
-        dim_head = 64,
-        highres_patch_size = 12,
-        highres_mlp_factor = 4,
-        cross_attn_heads = 8,
-        cross_attn_dim_head = 64,
-        patch_conv_kernel_size = 7,
-        dropout = 0.1,
-        channels = 3
-    ):
-        super().__init__()
-        assert divisible_by(image_size, highres_patch_size)
-        assert divisible_by(image_size, patch_size)
-        assert patch_size > highres_patch_size, 'patch size of the main vision transformer should be smaller than the highres patch sizes (that does the `lookup`)'
-        assert not divisible_by(patch_conv_kernel_size, 2)
-
-        self.dim = dim
-        self.image_size = image_size
-        self.patch_size = patch_size
-
-        kernel_size = patch_conv_kernel_size
-        patch_dim = (highres_patch_size * highres_patch_size) * channels
-
-        self.to_patches = nn.Sequential(
-            Rearrange('b c (h p1) (w p2) -> b (p1 p2 c) h w', p1 = highres_patch_size, p2 = highres_patch_size),
-            nn.Conv2d(patch_dim, dim, kernel_size, padding = kernel_size // 2),
-            Rearrange('b c h w -> b h w c'),
-            LayerNorm(dim),
-        )
-
-        # absolute positions
-
-        num_patches = (image_size // highres_patch_size) ** 2
-        self.pos_embedding = nn.Parameter(torch.randn(num_patches, dim))
-
-        # lookvit blocks
-
-        layers = ModuleList([])
-
-        for _ in range(depth):
-            layers.append(ModuleList([
-                Attention(dim = dim, dim_head = dim_head, heads = heads, dropout = dropout),
-                MLP(dim = dim, factor = mlp_factor, dropout = dropout),
-                Attention(dim = dim, dim_head = cross_attn_dim_head, heads = cross_attn_heads, dropout = dropout, cross_attend = True),
-                Attention(dim = dim, dim_head = cross_attn_dim_head, heads = cross_attn_heads, dropout = dropout, cross_attend = True, reuse_attention = True),
-                LayerNorm(dim),
-                MLP(dim = dim, factor = highres_mlp_factor, dropout = dropout)
-            ]))
-
-        self.layers = layers
-
-        self.norm = LayerNorm(dim)
-        self.highres_norm = LayerNorm(dim)
-
-        self.to_logits = nn.Linear(dim, num_classes, bias = False)
-
-    def forward(self, img):
-        assert img.shape[-2:] == (self.image_size, self.image_size)
-
-        # to patch tokens and positions
-
-        highres_tokens = self.to_patches(img)
-        size = highres_tokens.shape[-2]
-
-        pos_emb = posemb_sincos_2d(highres_tokens)
-        highres_tokens = highres_tokens + rearrange(pos_emb, '(h w) d -> h w d', h = size)
-
-        tokens = F.interpolate(
-            rearrange(highres_tokens, 'b h w d -> b d h w'),
-            img.shape[-1] // self.patch_size,
-            mode = 'bilinear'
-        )
-
-        tokens = rearrange(tokens, 'b c h w -> b (h w) c')
-        highres_tokens = rearrange(highres_tokens, 'b h w c -> b (h w) c')
-
-        # attention and feedforwards
-
-        for attn, mlp, lookup_cross_attn, highres_attn, highres_norm, highres_mlp in self.layers:
-
-            # main tokens cross attends (lookup) on the high res tokens
-
-            lookup_out, qk_sim = lookup_cross_attn(tokens, highres_tokens, return_qk_sim = True)  # return attention as they reuse the attention matrix
-            tokens = lookup_out + tokens
-
-            tokens = attn(tokens) + tokens
-            tokens = mlp(tokens) + tokens
-
-            # attention-reuse
-
-            qk_sim = rearrange(qk_sim, 'b h i j -> b h j i') # transpose for reverse cross attention
-
-            highres_tokens = highres_attn(highres_tokens, tokens, qk_sim = qk_sim) + highres_tokens
-            highres_tokens = highres_norm(highres_tokens)
-
-            highres_tokens = highres_mlp(highres_tokens) + highres_tokens
-
-        # to logits
-
-        tokens = self.norm(tokens)
-        highres_tokens = self.highres_norm(highres_tokens)
-
-        tokens = reduce(tokens, 'b n d -> b d', 'mean')
-        highres_tokens = reduce(highres_tokens, 'b n d -> b d', 'mean')
-
-        return self.to_logits(tokens + highres_tokens)
-
-# main
-
-if __name__ == '__main__':
-    v = LookViT(
-        image_size = 256,
-        num_classes = 1000,
-        dim = 512,
-        depth = 2,
-        heads = 8,
-        dim_head = 64,
-        patch_size = 32,
-        highres_patch_size = 8,
-        highres_mlp_factor = 2,
-        cross_attn_heads = 8,
-        cross_attn_dim_head = 64,
-        dropout = 0.1
-    ).cuda()
-
-    img = torch.randn(2, 3, 256, 256).cuda()
-    pred = v(img)
-
-    assert pred.shape == (2, 1000)

vit_pytorch/mae.py

@@ -24,14 +24,11 @@ class MAE(nn.Module):
 
         self.encoder = encoder
         num_patches, encoder_dim = encoder.pos_embedding.shape[-2:]
-
-        self.to_patch = encoder.to_patch_embedding[0]
-        self.patch_to_emb = nn.Sequential(*encoder.to_patch_embedding[1:])
-
-        pixel_values_per_patch = encoder.to_patch_embedding[2].weight.shape[-1]
+        self.to_patch, self.patch_to_emb = encoder.to_patch_embedding[:2]
+        pixel_values_per_patch = self.patch_to_emb.weight.shape[-1]
 
         # decoder parameters
-        self.decoder_dim = decoder_dim
+
         self.enc_to_dec = nn.Linear(encoder_dim, decoder_dim) if encoder_dim != decoder_dim else nn.Identity()
         self.mask_token = nn.Parameter(torch.randn(decoder_dim))
         self.decoder = Transformer(dim = decoder_dim, depth = decoder_depth, heads = decoder_heads, dim_head = decoder_dim_head, mlp_dim = decoder_dim * 4)
@@ -49,10 +46,7 @@ class MAE(nn.Module):
         # patch to encoder tokens and add positions
 
         tokens = self.patch_to_emb(patches)
-        if self.encoder.pool == "cls":
-            tokens += self.encoder.pos_embedding[:, 1:(num_patches + 1)]
-        elif self.encoder.pool == "mean":
-            tokens += self.encoder.pos_embedding.to(device, dtype=tokens.dtype) 
+        tokens = tokens + self.encoder.pos_embedding[:, 1:(num_patches + 1)]
 
         # calculate of patches needed to be masked, and get random indices, dividing it up for mask vs unmasked
 
@@ -79,7 +73,7 @@ class MAE(nn.Module):
 
         # reapply decoder position embedding to unmasked tokens
 
-        unmasked_decoder_tokens = decoder_tokens + self.decoder_pos_emb(unmasked_indices)
+        decoder_tokens = decoder_tokens + self.decoder_pos_emb(unmasked_indices)
 
         # repeat mask tokens for number of masked, and add the positions using the masked indices derived above
 
@@ -87,15 +81,13 @@ class MAE(nn.Module):
         mask_tokens = mask_tokens + self.decoder_pos_emb(masked_indices)
 
         # concat the masked tokens to the decoder tokens and attend with decoder
-        
-        decoder_tokens = torch.zeros(batch, num_patches, self.decoder_dim, device=device)
-        decoder_tokens[batch_range, unmasked_indices] = unmasked_decoder_tokens
-        decoder_tokens[batch_range, masked_indices] = mask_tokens
+
+        decoder_tokens = torch.cat((mask_tokens, decoder_tokens), dim = 1)
         decoded_tokens = self.decoder(decoder_tokens)
 
         # splice out the mask tokens and project to pixel values
 
-        mask_tokens = decoded_tokens[batch_range, masked_indices]
+        mask_tokens = decoded_tokens[:, :num_masked]
         pred_pixel_values = self.to_pixels(mask_tokens)
 
         # calculate reconstruction loss

vit_pytorch/max_vit.py

@@ -19,20 +19,20 @@ def cast_tuple(val, length = 1):
 
 # helper classes
 
-class Residual(nn.Module):
+class PreNormResidual(nn.Module):
     def __init__(self, dim, fn):
         super().__init__()
+        self.norm = nn.LayerNorm(dim)
         self.fn = fn
 
     def forward(self, x):
-        return self.fn(x) + x
+        return self.fn(self.norm(x)) + x
 
 class FeedForward(nn.Module):
     def __init__(self, dim, mult = 4, dropout = 0.):
         super().__init__()
         inner_dim = int(dim * mult)
         self.net = nn.Sequential(
-            nn.LayerNorm(dim),
             nn.Linear(dim, inner_dim),
             nn.GELU(),
             nn.Dropout(dropout),
@@ -100,14 +100,12 @@ def MBConv(
     stride = 2 if downsample else 1
 
     net = nn.Sequential(
-        nn.Conv2d(dim_in, hidden_dim, 1),
-        nn.BatchNorm2d(hidden_dim),
-        nn.GELU(),
-        nn.Conv2d(hidden_dim, hidden_dim, 3, stride = stride, padding = 1, groups = hidden_dim),
-        nn.BatchNorm2d(hidden_dim),
-        nn.GELU(),
-        SqueezeExcitation(hidden_dim, shrinkage_rate = shrinkage_rate),
-        nn.Conv2d(hidden_dim, dim_out, 1),
+        nn.Conv2d(dim_in, dim_out, 1),
+        nn.BatchNorm2d(dim_out),
+        nn.SiLU(),
+        nn.Conv2d(dim_out, dim_out, 3, stride = stride, padding = 1, groups = dim_out),
+        SqueezeExcitation(dim_out, shrinkage_rate = shrinkage_rate),
+        nn.Conv2d(dim_out, dim_out, 1),
         nn.BatchNorm2d(dim_out)
     )
 
@@ -132,7 +130,6 @@ class Attention(nn.Module):
         self.heads = dim // dim_head
         self.scale = dim_head ** -0.5
 
-        self.norm = nn.LayerNorm(dim)
         self.to_qkv = nn.Linear(dim, dim * 3, bias = False)
 
         self.attend = nn.Sequential(
@@ -161,8 +158,6 @@ class Attention(nn.Module):
     def forward(self, x):
         batch, height, width, window_height, window_width, _, device, h = *x.shape, x.device, self.heads
 
-        x = self.norm(x)
-
         # flatten
 
         x = rearrange(x, 'b x y w1 w2 d -> (b x y) (w1 w2) d')
@@ -173,7 +168,7 @@ class Attention(nn.Module):
 
         # split heads
 
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = h), (q, k, v))
+        q, k, v = map(lambda t: rearrange(t, 'b n (h d ) -> b h n d', h = h), (q, k, v))
 
         # scale
 
@@ -262,13 +257,13 @@ class MaxViT(nn.Module):
                         shrinkage_rate = mbconv_shrinkage_rate
                     ),
                     Rearrange('b d (x w1) (y w2) -> b x y w1 w2 d', w1 = w, w2 = w),  # block-like attention
-                    Residual(layer_dim, Attention(dim = layer_dim, dim_head = dim_head, dropout = dropout, window_size = w)),
-                    Residual(layer_dim, FeedForward(dim = layer_dim, dropout = dropout)),
+                    PreNormResidual(layer_dim, Attention(dim = layer_dim, dim_head = dim_head, dropout = dropout, window_size = w)),
+                    PreNormResidual(layer_dim, FeedForward(dim = layer_dim, dropout = dropout)),
                     Rearrange('b x y w1 w2 d -> b d (x w1) (y w2)'),
 
                     Rearrange('b d (w1 x) (w2 y) -> b x y w1 w2 d', w1 = w, w2 = w),  # grid-like attention
-                    Residual(layer_dim, Attention(dim = layer_dim, dim_head = dim_head, dropout = dropout, window_size = w)),
-                    Residual(layer_dim, FeedForward(dim = layer_dim, dropout = dropout)),
+                    PreNormResidual(layer_dim, Attention(dim = layer_dim, dim_head = dim_head, dropout = dropout, window_size = w)),
+                    PreNormResidual(layer_dim, FeedForward(dim = layer_dim, dropout = dropout)),
                     Rearrange('b x y w1 w2 d -> b d (w1 x) (w2 y)'),
                 )
 

vit_pytorch/max_vit_with_registers.py

@@ -1,340 +0,0 @@
-from functools import partial
-
-import torch
-from torch import nn, einsum
-import torch.nn.functional as F
-from torch.nn import Module, ModuleList, Sequential
-
-from einops import rearrange, repeat, reduce, pack, unpack
-from einops.layers.torch import Rearrange, Reduce
-
-# helpers
-
-def exists(val):
-    return val is not None
-
-def default(val, d):
-    return val if exists(val) else d
-
-def pack_one(x, pattern):
-    return pack([x], pattern)
-
-def unpack_one(x, ps, pattern):
-    return unpack(x, ps, pattern)[0]
-
-def cast_tuple(val, length = 1):
-    return val if isinstance(val, tuple) else ((val,) * length)
-
-# helper classes
-
-def FeedForward(dim, mult = 4, dropout = 0.):
-    inner_dim = int(dim * mult)
-    return Sequential(
-        nn.LayerNorm(dim),
-        nn.Linear(dim, inner_dim),
-        nn.GELU(),
-        nn.Dropout(dropout),
-        nn.Linear(inner_dim, dim),
-        nn.Dropout(dropout)
-    )
-
-# MBConv
-
-class SqueezeExcitation(Module):
-    def __init__(self, dim, shrinkage_rate = 0.25):
-        super().__init__()
-        hidden_dim = int(dim * shrinkage_rate)
-
-        self.gate = Sequential(
-            Reduce('b c h w -> b c', 'mean'),
-            nn.Linear(dim, hidden_dim, bias = False),
-            nn.SiLU(),
-            nn.Linear(hidden_dim, dim, bias = False),
-            nn.Sigmoid(),
-            Rearrange('b c -> b c 1 1')
-        )
-
-    def forward(self, x):
-        return x * self.gate(x)
-
-class MBConvResidual(Module):
-    def __init__(self, fn, dropout = 0.):
-        super().__init__()
-        self.fn = fn
-        self.dropsample = Dropsample(dropout)
-
-    def forward(self, x):
-        out = self.fn(x)
-        out = self.dropsample(out)
-        return out + x
-
-class Dropsample(Module):
-    def __init__(self, prob = 0):
-        super().__init__()
-        self.prob = prob
-  
-    def forward(self, x):
-        device = x.device
-
-        if self.prob == 0. or (not self.training):
-            return x
-
-        keep_mask = torch.FloatTensor((x.shape[0], 1, 1, 1), device = device).uniform_() > self.prob
-        return x * keep_mask / (1 - self.prob)
-
-def MBConv(
-    dim_in,
-    dim_out,
-    *,
-    downsample,
-    expansion_rate = 4,
-    shrinkage_rate = 0.25,
-    dropout = 0.
-):
-    hidden_dim = int(expansion_rate * dim_out)
-    stride = 2 if downsample else 1
-
-    net = Sequential(
-        nn.Conv2d(dim_in, hidden_dim, 1),
-        nn.BatchNorm2d(hidden_dim),
-        nn.GELU(),
-        nn.Conv2d(hidden_dim, hidden_dim, 3, stride = stride, padding = 1, groups = hidden_dim),
-        nn.BatchNorm2d(hidden_dim),
-        nn.GELU(),
-        SqueezeExcitation(hidden_dim, shrinkage_rate = shrinkage_rate),
-        nn.Conv2d(hidden_dim, dim_out, 1),
-        nn.BatchNorm2d(dim_out)
-    )
-
-    if dim_in == dim_out and not downsample:
-        net = MBConvResidual(net, dropout = dropout)
-
-    return net
-
-# attention related classes
-
-class Attention(Module):
-    def __init__(
-        self,
-        dim,
-        dim_head = 32,
-        dropout = 0.,
-        window_size = 7,
-        num_registers = 1
-    ):
-        super().__init__()
-        assert num_registers > 0
-        assert (dim % dim_head) == 0, 'dimension should be divisible by dimension per head'
-
-        self.heads = dim // dim_head
-        self.scale = dim_head ** -0.5
-
-        self.norm = nn.LayerNorm(dim)
-        self.to_qkv = nn.Linear(dim, dim * 3, bias = False)
-
-        self.attend = nn.Sequential(
-            nn.Softmax(dim = -1),
-            nn.Dropout(dropout)
-        )
-
-        self.to_out = nn.Sequential(
-            nn.Linear(dim, dim, bias = False),
-            nn.Dropout(dropout)
-        )
-
-        # relative positional bias
-
-        num_rel_pos_bias = (2 * window_size - 1) ** 2
-
-        self.rel_pos_bias = nn.Embedding(num_rel_pos_bias + 1, self.heads)
-
-        pos = torch.arange(window_size)
-        grid = torch.stack(torch.meshgrid(pos, pos, indexing = 'ij'))
-        grid = rearrange(grid, 'c i j -> (i j) c')
-        rel_pos = rearrange(grid, 'i ... -> i 1 ...') - rearrange(grid, 'j ... -> 1 j ...')
-        rel_pos += window_size - 1
-        rel_pos_indices = (rel_pos * torch.tensor([2 * window_size - 1, 1])).sum(dim = -1)
-
-        rel_pos_indices = F.pad(rel_pos_indices, (num_registers, 0, num_registers, 0), value = num_rel_pos_bias)
-        self.register_buffer('rel_pos_indices', rel_pos_indices, persistent = False)
-
-    def forward(self, x):
-        device, h, bias_indices = x.device, self.heads, self.rel_pos_indices
-
-        x = self.norm(x)
-
-        # project for queries, keys, values
-
-        q, k, v = self.to_qkv(x).chunk(3, dim = -1)
-
-        # split heads
-
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = h), (q, k, v))
-
-        # scale
-
-        q = q * self.scale
-
-        # sim
-
-        sim = einsum('b h i d, b h j d -> b h i j', q, k)
-
-        # add positional bias
-
-        bias = self.rel_pos_bias(bias_indices)
-        sim = sim + rearrange(bias, 'i j h -> h i j')
-
-        # attention
-
-        attn = self.attend(sim)
-
-        # aggregate
-
-        out = einsum('b h i j, b h j d -> b h i d', attn, v)
-
-        # combine heads out
-
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class MaxViT(Module):
-    def __init__(
-        self,
-        *,
-        num_classes,
-        dim,
-        depth,
-        dim_head = 32,
-        dim_conv_stem = None,
-        window_size = 7,
-        mbconv_expansion_rate = 4,
-        mbconv_shrinkage_rate = 0.25,
-        dropout = 0.1,
-        channels = 3,
-        num_register_tokens = 4
-    ):
-        super().__init__()
-        assert isinstance(depth, tuple), 'depth needs to be tuple if integers indicating number of transformer blocks at that stage'
-        assert num_register_tokens > 0
-
-        # convolutional stem
-
-        dim_conv_stem = default(dim_conv_stem, dim)
-
-        self.conv_stem = Sequential(
-            nn.Conv2d(channels, dim_conv_stem, 3, stride = 2, padding = 1),
-            nn.Conv2d(dim_conv_stem, dim_conv_stem, 3, padding = 1)
-        )
-
-        # variables
-
-        num_stages = len(depth)
-
-        dims = tuple(map(lambda i: (2 ** i) * dim, range(num_stages)))
-        dims = (dim_conv_stem, *dims)
-        dim_pairs = tuple(zip(dims[:-1], dims[1:]))
-
-        self.layers = nn.ModuleList([])
-
-        # window size
-
-        self.window_size = window_size
-
-        self.register_tokens = nn.ParameterList([])
-
-        # iterate through stages
-
-        for ind, ((layer_dim_in, layer_dim), layer_depth) in enumerate(zip(dim_pairs, depth)):
-            for stage_ind in range(layer_depth):
-                is_first = stage_ind == 0
-                stage_dim_in = layer_dim_in if is_first else layer_dim
-
-                conv = MBConv(
-                    stage_dim_in,
-                    layer_dim,
-                    downsample = is_first,
-                    expansion_rate = mbconv_expansion_rate,
-                    shrinkage_rate = mbconv_shrinkage_rate
-                )
-
-                block_attn = Attention(dim = layer_dim, dim_head = dim_head, dropout = dropout, window_size = window_size, num_registers = num_register_tokens)
-                block_ff = FeedForward(dim = layer_dim, dropout = dropout)
-
-                grid_attn = Attention(dim = layer_dim, dim_head = dim_head, dropout = dropout, window_size = window_size, num_registers = num_register_tokens)
-                grid_ff = FeedForward(dim = layer_dim, dropout = dropout)
-
-                register_tokens = nn.Parameter(torch.randn(num_register_tokens, layer_dim))
-
-                self.layers.append(ModuleList([
-                    conv,
-                    ModuleList([block_attn, block_ff]),
-                    ModuleList([grid_attn, grid_ff])
-                ]))
-
-                self.register_tokens.append(register_tokens)
-
-        # mlp head out
-
-        self.mlp_head = nn.Sequential(
-            Reduce('b d h w -> b d', 'mean'),
-            nn.LayerNorm(dims[-1]),
-            nn.Linear(dims[-1], num_classes)
-        )
-
-    def forward(self, x):
-        b, w = x.shape[0], self.window_size
-
-        x = self.conv_stem(x)
-
-        for (conv, (block_attn, block_ff), (grid_attn, grid_ff)), register_tokens in zip(self.layers, self.register_tokens):
-            x = conv(x)
-
-            # block-like attention
-
-            x = rearrange(x, 'b d (x w1) (y w2) -> b x y w1 w2 d', w1 = w, w2 = w)
-
-            # prepare register tokens
-
-            r = repeat(register_tokens, 'n d -> b x y n d', b = b, x = x.shape[1],y = x.shape[2])
-            r, register_batch_ps = pack_one(r, '* n d')
-
-            x, window_ps = pack_one(x, 'b x y * d')
-            x, batch_ps  = pack_one(x, '* n d')
-            x, register_ps = pack([r, x], 'b * d')
-
-            x = block_attn(x) + x
-            x = block_ff(x) + x
-
-            r, x = unpack(x, register_ps, 'b * d')
-
-            x = unpack_one(x, batch_ps, '* n d')
-            x = unpack_one(x, window_ps, 'b x y * d')
-            x = rearrange(x, 'b x y w1 w2 d -> b d (x w1) (y w2)')
-
-            r = unpack_one(r, register_batch_ps, '* n d')
-
-            # grid-like attention
-
-            x = rearrange(x, 'b d (w1 x) (w2 y) -> b x y w1 w2 d', w1 = w, w2 = w)
-
-            # prepare register tokens
-
-            r = reduce(r, 'b x y n d -> b n d', 'mean')
-            r = repeat(r, 'b n d -> b x y n d', x = x.shape[1], y = x.shape[2])
-            r, register_batch_ps = pack_one(r, '* n d')
-
-            x, window_ps = pack_one(x, 'b x y * d')
-            x, batch_ps  = pack_one(x, '* n d')
-            x, register_ps = pack([r, x], 'b * d')
-
-            x = grid_attn(x) + x
-
-            r, x = unpack(x, register_ps, 'b * d')
-
-            x = grid_ff(x) + x
-
-            x = unpack_one(x, batch_ps, '* n d')
-            x = unpack_one(x, window_ps, 'b x y * d')
-            x = rearrange(x, 'b x y w1 w2 d -> b d (w1 x) (w2 y)')
-
-        return self.mlp_head(x)

vit_pytorch/mobile_vit.py

@@ -13,20 +13,29 @@ def conv_1x1_bn(inp, oup):
         nn.SiLU()
     )
 
-def conv_nxn_bn(inp, oup, kernel_size=3, stride=1):
+def conv_nxn_bn(inp, oup, kernal_size=3, stride=1):
     return nn.Sequential(
-        nn.Conv2d(inp, oup, kernel_size, stride, 1, bias=False),
+        nn.Conv2d(inp, oup, kernal_size, stride, 1, bias=False),
         nn.BatchNorm2d(oup),
         nn.SiLU()
     )
 
 # classes
 
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = nn.LayerNorm(dim)
+        self.fn = fn
+
+    def forward(self, x, **kwargs):
+        return self.fn(self.norm(x), **kwargs)
+
+
 class FeedForward(nn.Module):
     def __init__(self, dim, hidden_dim, dropout=0.):
         super().__init__()
         self.net = nn.Sequential(
-            nn.LayerNorm(dim),
             nn.Linear(dim, hidden_dim),
             nn.SiLU(),
             nn.Dropout(dropout),
@@ -44,7 +53,6 @@ class Attention(nn.Module):
         self.heads = heads
         self.scale = dim_head ** -0.5
 
-        self.norm = nn.LayerNorm(dim)
         self.attend = nn.Softmax(dim=-1)
         self.dropout = nn.Dropout(dropout)
 
@@ -56,10 +64,9 @@ class Attention(nn.Module):
         )
 
     def forward(self, x):
-        x = self.norm(x)
         qkv = self.to_qkv(x).chunk(3, dim=-1)
-
-        q, k, v = map(lambda t: rearrange(t, 'b p n (h d) -> b p h n d', h=self.heads), qkv)
+        q, k, v = map(lambda t: rearrange(
+            t, 'b p n (h d) -> b p h n d', h=self.heads), qkv)
 
         dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
 
@@ -81,8 +88,8 @@ class Transformer(nn.Module):
         self.layers = nn.ModuleList([])
         for _ in range(depth):
             self.layers.append(nn.ModuleList([
-                Attention(dim, heads, dim_head, dropout),
-                FeedForward(dim, mlp_dim, dropout)
+                PreNorm(dim, Attention(dim, heads, dim_head, dropout)),
+                PreNorm(dim, FeedForward(dim, mlp_dim, dropout))
             ]))
 
     def forward(self, x):
@@ -160,9 +167,11 @@ class MobileViTBlock(nn.Module):
 
         # Global representations
         _, _, h, w = x.shape
-        x = rearrange(x, 'b d (h ph) (w pw) -> b (ph pw) (h w) d', ph=self.ph, pw=self.pw)
-        x = self.transformer(x)        
-        x = rearrange(x, 'b (ph pw) (h w) d -> b d (h ph) (w pw)', h=h//self.ph, w=w//self.pw, ph=self.ph, pw=self.pw)
+        x = rearrange(x, 'b d (h ph) (w pw) -> b (ph pw) (h w) d',
+                      ph=self.ph, pw=self.pw)
+        x = self.transformer(x)
+        x = rearrange(x, 'b (ph pw) (h w) d -> b d (h ph) (w pw)',
+                      h=h//self.ph, w=w//self.pw, ph=self.ph, pw=self.pw)
 
         # Fusion
         x = self.conv3(x)

vit_pytorch/mp3.py

@@ -1,186 +0,0 @@
-import torch
-from torch import nn, einsum
-import torch.nn.functional as F
-
-from einops import rearrange, repeat
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def exists(val):
-    return val is not None
-
-def default(val, d):
-    return val if exists(val) else d
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-# positional embedding
-
-def posemb_sincos_2d(patches, temperature = 10000, dtype = torch.float32):
-    _, h, w, dim, device, dtype = *patches.shape, patches.device, patches.dtype
-
-    y, x = torch.meshgrid(torch.arange(h, device = device), torch.arange(w, device = device), indexing = 'ij')
-    assert (dim % 4) == 0, 'feature dimension must be multiple of 4 for sincos emb'
-    omega = torch.arange(dim // 4, device = device) / (dim // 4 - 1)
-    omega = 1. / (temperature ** omega)
-
-    y = y.flatten()[:, None] * omega[None, :]
-    x = x.flatten()[:, None] * omega[None, :]
-    pe = torch.cat((x.sin(), x.cos(), y.sin(), y.cos()), dim = 1)
-    return pe.type(dtype)
-
-# feedforward
-
-class FeedForward(nn.Module):
-    def __init__(self, dim, hidden_dim, dropout = 0.):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Dropout(dropout),
-            nn.Linear(hidden_dim, dim),
-            nn.Dropout(dropout)
-        )
-    def forward(self, x):
-        return self.net(x)
-
-# (cross)attention
-
-class Attention(nn.Module):
-    def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0.):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-
-        self.attend = nn.Softmax(dim = -1)
-        self.dropout = nn.Dropout(dropout)
-
-        self.norm = nn.LayerNorm(dim)
-
-        self.to_q = nn.Linear(dim, inner_dim, bias = False)
-        self.to_kv = nn.Linear(dim, inner_dim * 2, bias = False)
-
-        self.to_out = nn.Sequential(
-            nn.Linear(inner_dim, dim),
-            nn.Dropout(dropout)
-        )
-
-    def forward(self, x, context = None):
-        b, n, _, h = *x.shape, self.heads
-
-        x = self.norm(x)
-
-        context = self.norm(context) if exists(context) else x
-
-        qkv = (self.to_q(x), *self.to_kv(context).chunk(2, dim = -1))
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = h), qkv)
-
-        dots = einsum('b h i d, b h j d -> b h i j', q, k) * self.scale
-
-        attn = self.attend(dots)
-        attn = self.dropout(attn)
-
-        out = einsum('b h i j, b h j d -> b h i d', attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(nn.Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0.):
-        super().__init__()
-        self.layers = nn.ModuleList([])
-        for _ in range(depth):
-            self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_dim, dropout = dropout)
-            ]))
-    def forward(self, x, context = None):
-        for attn, ff in self.layers:
-            x = attn(x, context = context) + x
-            x = ff(x) + x
-        return x
-
-class ViT(nn.Module):
-    def __init__(self, *, num_classes, image_size, patch_size, dim, depth, heads, mlp_dim, channels = 3, dim_head = 64, dropout = 0.):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(patch_size)
-
-        assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
-        
-        num_patches = (image_height // patch_height) * (image_width // patch_width)
-        patch_dim = channels * patch_height * patch_width
-
-        self.dim = dim
-        self.num_patches = num_patches
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange('b c (h p1) (w p2) -> b h w (p1 p2 c)', p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout)
-
-        self.to_latent = nn.Identity()
-        self.linear_head = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, num_classes)
-        )
-
-    def forward(self, img):
-        *_, h, w, dtype = *img.shape, img.dtype
-
-        x = self.to_patch_embedding(img)
-        pe = posemb_sincos_2d(x)
-        x = rearrange(x, 'b ... d -> b (...) d') + pe
-
-        x = self.transformer(x)
-        x = x.mean(dim = 1)
-
-        x = self.to_latent(x)
-        return self.linear_head(x)
-
-# Masked Position Prediction Pre-Training
-
-class MP3(nn.Module):
-    def __init__(self, vit: ViT, masking_ratio):
-        super().__init__()
-        self.vit = vit
-
-        assert masking_ratio > 0 and masking_ratio < 1, 'masking ratio must be kept between 0 and 1'
-        self.masking_ratio = masking_ratio
-
-        dim = vit.dim
-        self.mlp_head = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, vit.num_patches)
-        )
-
-    def forward(self, img):
-        device = img.device
-        tokens = self.vit.to_patch_embedding(img)
-        tokens = rearrange(tokens, 'b ... d -> b (...) d')
-
-        batch, num_patches, *_ = tokens.shape
-
-        # Masking
-        num_masked = int(self.masking_ratio * num_patches)
-        rand_indices = torch.rand(batch, num_patches, device = device).argsort(dim = -1)
-        masked_indices, unmasked_indices = rand_indices[:, :num_masked], rand_indices[:, num_masked:]
-
-        batch_range = torch.arange(batch, device = device)[:, None]
-        tokens_unmasked = tokens[batch_range, unmasked_indices]
-
-        attended_tokens = self.vit.transformer(tokens, tokens_unmasked)
-        logits = rearrange(self.mlp_head(attended_tokens), 'b n d -> (b n) d')
-        
-        # Define labels
-        labels = repeat(torch.arange(num_patches, device = device), 'n -> (b n)', b = batch)
-        loss = F.cross_entropy(logits, labels)
-
-        return loss

vit_pytorch/mpp.py

@@ -96,9 +96,6 @@ class MPP(nn.Module):
         self.loss = MPPLoss(patch_size, channels, output_channel_bits,
                             max_pixel_val, mean, std)
 
-        # extract patching function
-        self.patch_to_emb = nn.Sequential(transformer.to_patch_embedding[1:])
-
         # output transformation
         self.to_bits = nn.Linear(dim, 2**(output_channel_bits * channels))
 
@@ -154,7 +151,7 @@ class MPP(nn.Module):
         masked_input[bool_mask_replace] = self.mask_token
 
         # linear embedding of patches
-        masked_input = self.patch_to_emb(masked_input)
+        masked_input = transformer.to_patch_embedding[-1](masked_input)
 
         # add cls token to input sequence
         b, n, _ = masked_input.shape

vit_pytorch/na_vit.py

@@ -1,402 +0,0 @@
-from __future__ import annotations
-
-from functools import partial, lru_cache
-from typing import List
-
-import torch
-import torch.nn.functional as F
-from torch import nn, Tensor
-from torch.nn.utils.rnn import pad_sequence as orig_pad_sequence
-
-from einops import rearrange, repeat
-
-# helpers
-
-def exists(val):
-    return val is not None
-
-def default(val, d):
-    return val if exists(val) else d
-
-def always(val):
-    return lambda *args: val
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-def divisible_by(numer, denom):
-    return (numer % denom) == 0
-
-@lru_cache(maxsize=128)
-def posemb_grid(ph, pw, device):
-    h_idx = torch.arange(ph, device=device).repeat_interleave(pw)
-    w_idx = torch.arange(pw, device=device).repeat(ph)
-    return torch.stack([h_idx, w_idx], dim=-1)
-
-# auto grouping images
-
-def group_images_by_max_seq_len(
-    images: List[Tensor],
-    patch_size: int,
-    calc_token_dropout = None,
-    max_seq_len = 2048
-
-) -> List[List[Tensor]]:
-
-    calc_token_dropout = default(calc_token_dropout, always(0.))
-
-    groups = []
-    group = []
-    seq_len = 0
-
-    if isinstance(calc_token_dropout, (float, int)):
-        calc_token_dropout = always(calc_token_dropout)
-
-    for image in images:
-        assert isinstance(image, Tensor)
-
-        image_dims = image.shape[-2:]
-        ph, pw = map(lambda t: t // patch_size, image_dims)
-
-        image_seq_len = (ph * pw)
-        image_seq_len = int(image_seq_len * (1 - calc_token_dropout(*image_dims)))
-
-        assert image_seq_len <= max_seq_len, f'image with dimensions {image_dims} exceeds maximum sequence length'
-
-        if (seq_len + image_seq_len) > max_seq_len:
-            groups.append(group)
-            group = []
-            seq_len = 0
-
-        group.append(image)
-        seq_len += image_seq_len
-
-    if len(group) > 0:
-        groups.append(group)
-
-    return groups
-
-# normalization
-# they use layernorm without bias, something that pytorch does not offer
-
-class LayerNorm(nn.Module):
-    def __init__(self, dim):
-        super().__init__()
-        self.gamma = nn.Parameter(torch.ones(dim))
-        self.register_buffer('beta', torch.zeros(dim))
-
-    def forward(self, x):
-        return F.layer_norm(x, x.shape[-1:], self.gamma, self.beta)
-
-# they use a query-key normalization that is equivalent to rms norm (no mean-centering, learned gamma), from vit 22B paper
-
-class RMSNorm(nn.Module):
-    def __init__(self, heads, dim):
-        super().__init__()
-        self.scale = dim ** 0.5
-        self.gamma = nn.Parameter(torch.ones(heads, 1, dim))
-
-    def forward(self, x):
-        normed = F.normalize(x, dim = -1)
-        return normed * self.scale * self.gamma
-
-# feedforward
-
-def FeedForward(dim, hidden_dim, dropout = 0.):
-    return nn.Sequential(
-        LayerNorm(dim),
-        nn.Linear(dim, hidden_dim),
-        nn.GELU(),
-        nn.Dropout(dropout),
-        nn.Linear(hidden_dim, dim),
-        nn.Dropout(dropout)
-    )
-
-class Attention(nn.Module):
-    def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0.):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        self.heads = heads
-        self.norm = LayerNorm(dim)
-
-        self.q_norm = RMSNorm(heads, dim_head)
-        self.k_norm = RMSNorm(heads, dim_head)
-
-        self.dropout_p = dropout
-
-        self.to_q = nn.Linear(dim, inner_dim, bias = False)
-        self.to_kv = nn.Linear(dim, inner_dim * 2, bias = False)
-
-        self.to_out = nn.Sequential(
-            nn.Linear(inner_dim, dim, bias = False),
-            nn.Dropout(dropout)
-        )
-
-    def forward(
-        self,
-        x,
-        context = None,
-        mask = None,
-        attn_mask = None
-    ):
-        x = self.norm(x)
-        kv_input = default(context, x)
-
-        qkv = (self.to_q(x), *self.to_kv(kv_input).chunk(2, dim = -1))
-
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        q = self.q_norm(q)
-        k = self.k_norm(k)
-
-        # combine masks if both exist
-        if exists(mask) or exists(attn_mask):
-            if exists(mask):
-                mask = rearrange(mask, 'b j -> b 1 1 j')
-            if exists(mask) and exists(attn_mask):
-                attn_mask = mask & attn_mask
-            elif exists(mask):
-                attn_mask = mask
-
-        out = F.scaled_dot_product_attention(
-            q, k, v,
-            attn_mask = attn_mask,
-            dropout_p = self.dropout_p if self.training else 0.,
-            scale = 1.  # RMSNorm already includes sqrt(dim) scaling
-        )
-
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(nn.Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0.):
-        super().__init__()
-        self.layers = nn.ModuleList([])
-        for _ in range(depth):
-            self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_dim, dropout = dropout)
-            ]))
-
-        self.norm = LayerNorm(dim)
-
-    def forward(
-        self,
-        x,
-        mask = None,
-        attn_mask = None
-    ):
-        for attn, ff in self.layers:
-            x = attn(x, mask = mask, attn_mask = attn_mask) + x
-            x = ff(x) + x
-
-        return self.norm(x)
-
-class NaViT(nn.Module):
-    def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, channels = 3, dim_head = 64, dropout = 0., emb_dropout = 0., token_dropout_prob = None):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-
-        # what percent of tokens to dropout
-        # if int or float given, then assume constant dropout prob
-        # otherwise accept a callback that in turn calculates dropout prob from height and width
-
-        self.calc_token_dropout = None
-
-        if callable(token_dropout_prob):
-            self.calc_token_dropout = token_dropout_prob
-
-        elif isinstance(token_dropout_prob, (float, int)):
-            assert 0. <= token_dropout_prob < 1.
-            token_dropout_prob = float(token_dropout_prob)
-            self.calc_token_dropout = lambda height, width: token_dropout_prob
-
-        # calculate patching related stuff
-
-        assert divisible_by(image_height, patch_size) and divisible_by(image_width, patch_size), 'Image dimensions must be divisible by the patch size.'
-
-        patch_height_dim, patch_width_dim = (image_height // patch_size), (image_width // patch_size)
-        patch_dim = channels * (patch_size ** 2)
-
-        self.channels = channels
-        self.patch_size = patch_size
-
-        self.to_patch_embedding = nn.Sequential(
-            LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            LayerNorm(dim),
-        )
-
-        self.pos_embed_height = nn.Parameter(torch.randn(patch_height_dim, dim))
-        self.pos_embed_width = nn.Parameter(torch.randn(patch_width_dim, dim))
-
-        self.dropout = nn.Dropout(emb_dropout)
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout)
-
-        # final attention pooling queries
-
-        self.attn_pool_queries = nn.Parameter(torch.randn(dim))
-        self.attn_pool = Attention(dim = dim, dim_head = dim_head, heads = heads)
-
-        # output to logits
-
-        self.to_latent = nn.Identity()
-
-        self.mlp_head = nn.Sequential(
-            LayerNorm(dim),
-            nn.Linear(dim, num_classes, bias = False)
-        )
-
-    @property
-    def device(self):
-        return next(self.parameters()).device
-
-    def forward(
-        self,
-        batched_images: List[Tensor] | List[List[Tensor]], # assume different resolution images already grouped correctly
-        group_images = False,
-        group_max_seq_len = 2048
-    ):
-        p, c, device, has_token_dropout = self.patch_size, self.channels, self.device, exists(self.calc_token_dropout) and self.training
-
-        arange = partial(torch.arange, device = device)
-        pad_sequence = partial(orig_pad_sequence, batch_first = True)
-
-        # auto pack if specified
-
-        if group_images:
-            batched_images = group_images_by_max_seq_len(
-                batched_images,
-                patch_size = self.patch_size,
-                calc_token_dropout = self.calc_token_dropout if self.training else None,
-                max_seq_len = group_max_seq_len
-            )
-
-        # if List[Tensor] is not grouped -> List[List[Tensor]]
-
-        if torch.is_tensor(batched_images[0]):
-            batched_images = [batched_images]
-
-        # process images into variable lengthed sequences with attention mask
-
-        num_images = []
-        batched_sequences = []
-        batched_positions = []
-        batched_image_ids = []
-
-        for images in batched_images:
-            num_images.append(len(images))
-
-            # compute patch dimensions for all images
-            patch_dims = []
-            for image in images:
-                assert image.ndim == 3 and image.shape[0] == c
-                image_dims = image.shape[-2:]
-                assert all([divisible_by(dim, p) for dim in image_dims]), f'height and width {image_dims} of images must be divisible by patch size {p}'
-                patch_dims.append((image_dims[0] // p, image_dims[1] // p))
-
-            # extract patches for all images
-            sequences = [rearrange(img, 'c (h p1) (w p2) -> (h w) (c p1 p2)', p1=p, p2=p) for img in images]
-
-            # compute positions - uses lru_cache to avoid redundant computation across forward passes
-            positions = [posemb_grid(ph, pw, device) for ph, pw in patch_dims]
-
-            # handle token dropout
-            if has_token_dropout:
-                for i, (seq, pos) in enumerate(zip(sequences, positions)):
-                    image_dims = images[i].shape[-2:]
-                    token_dropout = self.calc_token_dropout(*image_dims)
-                    seq_len = seq.shape[0]
-                    num_keep = max(1, int(seq_len * (1 - token_dropout)))
-                    keep_indices = torch.randn((seq_len,), device=device).topk(num_keep, dim=-1).indices
-                    sequences[i] = seq[keep_indices]
-                    positions[i] = pos[keep_indices]
-
-            # build image_ids efficiently using repeat_interleave
-            patch_counts = [seq.shape[0] for seq in sequences]
-            image_ids = torch.repeat_interleave(
-                arange(len(images)),
-                torch.tensor(patch_counts, device=device)
-            )
-
-            batched_image_ids.append(image_ids)
-            batched_sequences.append(torch.cat(sequences, dim=0))
-            batched_positions.append(torch.cat(positions, dim=0))
-
-        # derive key padding mask
-
-        lengths = torch.tensor([seq.shape[-2] for seq in batched_sequences], device = device, dtype = torch.long)
-        seq_arange = arange(lengths.amax().item())
-        key_pad_mask = rearrange(seq_arange, 'n -> 1 n') < rearrange(lengths, 'b -> b 1')
-
-        # derive attention mask, and combine with key padding mask from above
-
-        batched_image_ids = pad_sequence(batched_image_ids)
-        attn_mask = rearrange(batched_image_ids, 'b i -> b 1 i 1') == rearrange(batched_image_ids, 'b j -> b 1 1 j')
-        attn_mask = attn_mask & rearrange(key_pad_mask, 'b j -> b 1 1 j')
-
-        # combine patched images as well as the patched width / height positions for 2d positional embedding
-
-        patches = pad_sequence(batched_sequences)
-        patch_positions = pad_sequence(batched_positions)
-
-        # need to know how many images for final attention pooling
-
-        num_images = torch.tensor(num_images, device = device, dtype = torch.long)        
-
-        # to patches
-
-        x = self.to_patch_embedding(patches)        
-
-        # factorized 2d absolute positional embedding
-
-        h_indices, w_indices = patch_positions.unbind(dim = -1)
-
-        h_pos = self.pos_embed_height[h_indices]
-        w_pos = self.pos_embed_width[w_indices]
-
-        x = x + h_pos + w_pos
-
-        # embed dropout
-
-        x = self.dropout(x)
-
-        # attention
-
-        x = self.transformer(x, attn_mask = attn_mask)
-
-        # do attention pooling at the end
-
-        max_queries = num_images.amax().item()
-
-        queries = repeat(self.attn_pool_queries, 'd -> b n d', n = max_queries, b = x.shape[0])
-
-        # attention pool mask
-
-        image_id_arange = arange(max_queries)
-
-        attn_pool_mask = rearrange(image_id_arange, 'i -> i 1') == rearrange(batched_image_ids, 'b j -> b 1 j')
-
-        attn_pool_mask = attn_pool_mask & rearrange(key_pad_mask, 'b j -> b 1 j')
-
-        attn_pool_mask = rearrange(attn_pool_mask, 'b i j -> b 1 i j')
-
-        # attention pool
-
-        x = self.attn_pool(queries, context = x, attn_mask = attn_pool_mask) + queries
-
-        x = rearrange(x, 'b n d -> (b n) d')
-
-        # each batch element may not have same amount of images
-
-        is_images = image_id_arange < rearrange(num_images, 'b -> b 1')
-        is_images = rearrange(is_images, 'b n -> (b n)')
-
-        x = x[is_images]
-
-        # project out to logits
-
-        x = self.to_latent(x)
-
-        return self.mlp_head(x)

vit_pytorch/na_vit_nested_tensor.py

@@ -1,330 +0,0 @@
-from __future__ import annotations
-
-from typing import List
-from functools import partial
-
-import torch
-import packaging.version as pkg_version
-
-from torch import nn, Tensor
-import torch.nn.functional as F
-from torch.nn import Module, ModuleList
-from torch.nested import nested_tensor
-
-from einops import rearrange
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def exists(val):
-    return val is not None
-
-def default(val, d):
-    return val if exists(val) else d
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-def divisible_by(numer, denom):
-    return (numer % denom) == 0
-
-# feedforward
-
-def FeedForward(dim, hidden_dim, dropout = 0.):
-    return nn.Sequential(
-        nn.LayerNorm(dim, bias = False),
-        nn.Linear(dim, hidden_dim),
-        nn.GELU(),
-        nn.Dropout(dropout),
-        nn.Linear(hidden_dim, dim),
-        nn.Dropout(dropout)
-    )
-
-class Attention(Module):
-    def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0., qk_norm = True):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim, bias = False)
-
-        dim_inner = heads * dim_head
-        self.heads = heads
-        self.dim_head = dim_head
-
-        self.to_queries = nn.Linear(dim, dim_inner, bias = False)
-        self.to_keys = nn.Linear(dim, dim_inner, bias = False)
-        self.to_values = nn.Linear(dim, dim_inner, bias = False)
-
-        # in the paper, they employ qk rmsnorm, a way to stabilize attention
-        # will use layernorm in place of rmsnorm, which has been shown to work in certain papers. requires l2norm on non-ragged dimension to be supported in nested tensors
-
-        self.query_norm = nn.LayerNorm(dim_head, bias = False) if qk_norm else nn.Identity()
-        self.key_norm = nn.LayerNorm(dim_head, bias = False) if qk_norm else nn.Identity()
-
-        self.dropout = dropout
-
-        self.to_out = nn.Linear(dim_inner, dim, bias = False)
-
-    def forward(
-        self, 
-        x,
-        context: Tensor | None = None
-    ):
-        x = self.norm(x)
-
-        # for attention pooling, one query pooling to entire sequence
-
-        context = default(context, x)
-
-        # queries, keys, values
-
-        query = self.to_queries(x)
-        key = self.to_keys(context)
-        value = self.to_values(context)
-
-        # split heads
-
-        def split_heads(t):
-            return t.unflatten(-1, (self.heads, self.dim_head))
-
-        def transpose_head_seq(t):
-            return t.transpose(1, 2)
-
-        query, key, value = map(split_heads, (query, key, value))
-
-        # qk norm for attention stability
-
-        query = self.query_norm(query)
-        key = self.key_norm(key)
-
-        query, key, value = map(transpose_head_seq, (query, key, value))
-
-        # attention
-
-        out = F.scaled_dot_product_attention(
-            query, key, value,
-            dropout_p = self.dropout if self.training else 0.
-        )
-
-        # merge heads
-
-        out = out.transpose(1, 2).flatten(-2)
-
-        return self.to_out(out)
-
-class Transformer(Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0., qk_norm = True):
-        super().__init__()
-        self.layers = ModuleList([])
-
-        for _ in range(depth):
-            self.layers.append(ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout, qk_norm = qk_norm),
-                FeedForward(dim, mlp_dim, dropout = dropout)
-            ]))
-
-        self.norm = nn.LayerNorm(dim, bias = False)
-
-    def forward(self, x):
-
-        for attn, ff in self.layers:
-            x = attn(x) + x
-            x = ff(x) + x
-
-        return self.norm(x)
-
-class NaViT(Module):
-    def __init__(
-        self,
-        *,
-        image_size,
-        patch_size,
-        num_classes,
-        dim,
-        depth,
-        heads,
-        mlp_dim,
-        channels = 3,
-        dim_head = 64,
-        dropout = 0.,
-        emb_dropout = 0.,
-        qk_rmsnorm = True,
-        token_dropout_prob: float | None = None
-    ):
-        super().__init__()
-
-        if pkg_version.parse(torch.__version__) < pkg_version.parse('2.5'):
-            print('nested tensor NaViT was tested on pytorch 2.5')
-
-
-        image_height, image_width = pair(image_size)
-
-        # what percent of tokens to dropout
-        # if int or float given, then assume constant dropout prob
-        # otherwise accept a callback that in turn calculates dropout prob from height and width
-
-        self.token_dropout_prob = token_dropout_prob
-
-        # calculate patching related stuff
-
-        assert divisible_by(image_height, patch_size) and divisible_by(image_width, patch_size), 'Image dimensions must be divisible by the patch size.'
-
-        patch_height_dim, patch_width_dim = (image_height // patch_size), (image_width // patch_size)
-        patch_dim = channels * (patch_size ** 2)
-
-        self.channels = channels
-        self.patch_size = patch_size
-        self.to_patches = Rearrange('c (h p1) (w p2) -> h w (c p1 p2)', p1 = patch_size, p2 = patch_size)
-
-        self.to_patch_embedding = nn.Sequential(
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.pos_embed_height = nn.Parameter(torch.randn(patch_height_dim, dim))
-        self.pos_embed_width = nn.Parameter(torch.randn(patch_width_dim, dim))
-
-        self.dropout = nn.Dropout(emb_dropout)
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout, qk_rmsnorm)
-
-        # final attention pooling queries
-
-        self.attn_pool_queries = nn.Parameter(torch.randn(dim))
-        self.attn_pool = Attention(dim = dim, dim_head = dim_head, heads = heads)
-
-        # output to logits
-
-        self.to_latent = nn.Identity()
-
-        self.mlp_head = nn.Sequential(
-            nn.LayerNorm(dim, bias = False),
-            nn.Linear(dim, num_classes, bias = False)
-        )
-
-    @property
-    def device(self):
-        return next(self.parameters()).device
-
-    def forward(
-        self,
-        images: List[Tensor], # different resolution images
-    ):
-        batch, device = len(images), self.device
-        arange = partial(torch.arange, device = device)
-
-        assert all([image.ndim == 3 and image.shape[0] == self.channels for image in images]), f'all images must have {self.channels} channels and number of dimensions of 3 (channels, height, width)'
-
-        all_patches = [self.to_patches(image) for image in images]
-
-        # prepare factorized positional embedding height width indices
-
-        positions = []
-
-        for patches in all_patches:
-            patch_height, patch_width = patches.shape[:2]
-            hw_indices = torch.stack(torch.meshgrid((arange(patch_height), arange(patch_width)), indexing = 'ij'), dim = -1)
-            hw_indices = rearrange(hw_indices, 'h w c -> (h w) c')
-            positions.append(hw_indices)
-
-        # need the sizes to compute token dropout + positional embedding
-
-        tokens = [rearrange(patches, 'h w d -> (h w) d') for patches in all_patches]
-
-        # handle token dropout
-
-        seq_lens = torch.tensor([i.shape[0] for i in tokens], device = device)
-
-        if self.training and self.token_dropout_prob > 0:
-
-            keep_seq_lens = ((1. - self.token_dropout_prob) * seq_lens).int().clamp(min = 1)
-
-            kept_tokens = []
-            kept_positions = []
-
-            for one_image_tokens, one_image_positions, seq_len, num_keep in zip(tokens, positions, seq_lens, keep_seq_lens):
-                keep_indices = torch.randn((seq_len,), device = device).topk(num_keep, dim = -1).indices
-
-                one_image_kept_tokens = one_image_tokens[keep_indices]
-                one_image_kept_positions = one_image_positions[keep_indices]
-
-                kept_tokens.append(one_image_kept_tokens)
-                kept_positions.append(one_image_kept_positions)
-
-            tokens, positions, seq_lens = kept_tokens, kept_positions, keep_seq_lens
-
-        # add all height and width factorized positions
-
-        height_indices, width_indices = torch.cat(positions).unbind(dim = -1)
-        height_embed, width_embed = self.pos_embed_height[height_indices], self.pos_embed_width[width_indices]
-
-        pos_embed = height_embed + width_embed
-
-        # use nested tensor for transformers and save on padding computation
-
-        tokens = torch.cat(tokens)
-
-        # linear projection to patch embeddings
-
-        tokens = self.to_patch_embedding(tokens)
-
-        # absolute positions
-
-        tokens = tokens + pos_embed
-
-        tokens = nested_tensor(tokens.split(seq_lens.tolist()), layout = torch.jagged, device = device)
-
-        # embedding dropout
-
-        tokens = self.dropout(tokens)
-
-        # transformer
-
-        tokens = self.transformer(tokens)
-
-        # attention pooling
-        # will use a jagged tensor for queries, as SDPA requires all inputs to be jagged, or not
-
-        attn_pool_queries = [rearrange(self.attn_pool_queries, '... -> 1 ...')] * batch
-
-        attn_pool_queries = nested_tensor(attn_pool_queries, layout = torch.jagged)
-
-        pooled = self.attn_pool(attn_pool_queries, tokens)
-
-        # back to unjagged
-
-        logits = torch.stack(pooled.unbind())
-
-        logits = rearrange(logits, 'b 1 d -> b d')
-
-        logits = self.to_latent(logits)
-
-        return self.mlp_head(logits)
-
-# quick test
-
-if __name__ == '__main__':
-
-    v = NaViT(
-        image_size = 256,
-        patch_size = 32,
-        num_classes = 1000,
-        dim = 1024,
-        depth = 6,
-        heads = 16,
-        mlp_dim = 2048,
-        dropout = 0.,
-        emb_dropout = 0.,
-        token_dropout_prob = 0.1
-    )
-
-    # 5 images of different resolutions - List[Tensor]
-
-    images = [
-        torch.randn(3, 256, 256), torch.randn(3, 128, 128),
-        torch.randn(3, 128, 256), torch.randn(3, 256, 128),
-        torch.randn(3, 64, 256)
-    ]
-
-    assert v(images).shape == (5, 1000)
-
-    v(images).sum().backward()

vit_pytorch/na_vit_nested_tensor_3d.py

@@ -1,356 +0,0 @@
-from __future__ import annotations
-
-from typing import List
-from functools import partial
-
-import torch
-import packaging.version as pkg_version
-
-from torch import nn, Tensor
-import torch.nn.functional as F
-from torch.nn import Module, ModuleList
-from torch.nested import nested_tensor
-
-from einops import rearrange
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def exists(val):
-    return val is not None
-
-def default(val, d):
-    return val if exists(val) else d
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-def divisible_by(numer, denom):
-    return (numer % denom) == 0
-
-# feedforward
-
-def FeedForward(dim, hidden_dim, dropout = 0.):
-    return nn.Sequential(
-        nn.LayerNorm(dim, bias = False),
-        nn.Linear(dim, hidden_dim),
-        nn.GELU(),
-        nn.Dropout(dropout),
-        nn.Linear(hidden_dim, dim),
-        nn.Dropout(dropout)
-    )
-
-class Attention(Module):
-    def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0., qk_norm = True):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim, bias = False)
-
-        dim_inner = heads * dim_head
-        self.heads = heads
-        self.dim_head = dim_head
-
-        self.to_queries = nn.Linear(dim, dim_inner, bias = False)
-        self.to_keys = nn.Linear(dim, dim_inner, bias = False)
-        self.to_values = nn.Linear(dim, dim_inner, bias = False)
-
-        # in the paper, they employ qk rmsnorm, a way to stabilize attention
-        # will use layernorm in place of rmsnorm, which has been shown to work in certain papers. requires l2norm on non-ragged dimension to be supported in nested tensors
-
-        self.query_norm = nn.LayerNorm(dim_head, bias = False) if qk_norm else nn.Identity()
-        self.key_norm = nn.LayerNorm(dim_head, bias = False) if qk_norm else nn.Identity()
-
-        self.dropout = dropout
-
-        self.to_out = nn.Linear(dim_inner, dim, bias = False)
-
-    def forward(
-        self, 
-        x,
-        context: Tensor | None = None
-    ):
-
-        x = self.norm(x)
-
-        # for attention pooling, one query pooling to entire sequence
-
-        context = default(context, x)
-
-        # queries, keys, values
-
-        query = self.to_queries(x)
-        key = self.to_keys(context)
-        value = self.to_values(context)
-
-        # split heads
-
-        def split_heads(t):
-            return t.unflatten(-1, (self.heads, self.dim_head))
-
-        def transpose_head_seq(t):
-            return t.transpose(1, 2)
-
-        query, key, value = map(split_heads, (query, key, value))
-
-        # qk norm for attention stability
-
-        query = self.query_norm(query)
-        key = self.key_norm(key)
-
-        query, key, value = map(transpose_head_seq, (query, key, value))
-
-        # attention
-
-        out = F.scaled_dot_product_attention(
-            query, key, value,
-            dropout_p = self.dropout if self.training else 0.
-        )
-
-        # merge heads
-
-        out = out.transpose(1, 2).flatten(-2)
-
-        return self.to_out(out)
-
-class Transformer(Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0., qk_norm = True):
-        super().__init__()
-        self.layers = ModuleList([])
-
-        for _ in range(depth):
-            self.layers.append(ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout, qk_norm = qk_norm),
-                FeedForward(dim, mlp_dim, dropout = dropout)
-            ]))
-
-        self.norm = nn.LayerNorm(dim, bias = False)
-
-    def forward(self, x):
-
-        for attn, ff in self.layers:
-            x = attn(x) + x
-            x = ff(x) + x
-
-        return self.norm(x)
-
-class NaViT(Module):
-    def __init__(
-        self,
-        *,
-        image_size,
-        max_frames,
-        patch_size,
-        frame_patch_size,
-        num_classes,
-        dim,
-        depth,
-        heads,
-        mlp_dim,
-        channels = 3,
-        dim_head = 64,
-        dropout = 0.,
-        emb_dropout = 0.,
-        num_registers = 4,
-        qk_rmsnorm = True,
-        token_dropout_prob: float | None = None
-    ):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-
-        if pkg_version.parse(torch.__version__) < pkg_version.parse('2.5'):
-            print('nested tensor NaViT was tested on pytorch 2.5')
-
-        # what percent of tokens to dropout
-        # if int or float given, then assume constant dropout prob
-        # otherwise accept a callback that in turn calculates dropout prob from height and width
-
-        self.token_dropout_prob = token_dropout_prob
-
-        # calculate patching related stuff
-
-        assert divisible_by(image_height, patch_size) and divisible_by(image_width, patch_size), 'Image dimensions must be divisible by the patch size.'
-        assert divisible_by(max_frames, frame_patch_size)
-
-        patch_frame_dim, patch_height_dim, patch_width_dim = (max_frames // frame_patch_size), (image_height // patch_size), (image_width // patch_size)
-
-        patch_dim = channels * (patch_size ** 2) * frame_patch_size
-
-        self.channels = channels
-        self.patch_size = patch_size
-        self.to_patches = Rearrange('c (f pf) (h p1) (w p2) -> f h w (c pf p1 p2)', p1 = patch_size, p2 = patch_size, pf = frame_patch_size)
-
-        self.to_patch_embedding = nn.Sequential(
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.pos_embed_frame = nn.Parameter(torch.zeros(patch_frame_dim, dim))
-        self.pos_embed_height = nn.Parameter(torch.zeros(patch_height_dim, dim))
-        self.pos_embed_width = nn.Parameter(torch.zeros(patch_width_dim, dim))
-
-        # register tokens
-
-        self.register_tokens = nn.Parameter(torch.zeros(num_registers, dim))
-
-        nn.init.normal_(self.pos_embed_frame, std = 0.02)
-        nn.init.normal_(self.pos_embed_height, std = 0.02)
-        nn.init.normal_(self.pos_embed_width, std = 0.02)
-        nn.init.normal_(self.register_tokens, std = 0.02)
-
-        self.dropout = nn.Dropout(emb_dropout)
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout, qk_rmsnorm)
-
-        # final attention pooling queries
-
-        self.attn_pool_queries = nn.Parameter(torch.randn(dim))
-        self.attn_pool = Attention(dim = dim, dim_head = dim_head, heads = heads)
-
-        # output to logits
-
-        self.to_latent = nn.Identity()
-
-        self.mlp_head = nn.Sequential(
-            nn.LayerNorm(dim, bias = False),
-            nn.Linear(dim, num_classes, bias = False)
-        )
-
-    @property
-    def device(self):
-        return next(self.parameters()).device
-
-    def forward(
-        self,
-        volumes: List[Tensor], # different resolution images / CT scans
-    ):
-        batch, device = len(volumes), self.device
-        arange = partial(torch.arange, device = device)
-
-        assert all([volume.ndim == 4 and volume.shape[0] == self.channels for volume in volumes]), f'all volumes must have {self.channels} channels and number of dimensions of {self.channels} (channels, frame, height, width)'
-
-        all_patches = [self.to_patches(volume) for volume in volumes]
-
-        # prepare factorized positional embedding height width indices
-
-        positions = []
-
-        for patches in all_patches:
-            patch_frame, patch_height, patch_width = patches.shape[:3]
-            fhw_indices = torch.stack(torch.meshgrid((arange(patch_frame), arange(patch_height), arange(patch_width)), indexing = 'ij'), dim = -1)
-            fhw_indices = rearrange(fhw_indices, 'f h w c -> (f h w) c')
-
-            positions.append(fhw_indices)
-
-        # need the sizes to compute token dropout + positional embedding
-
-        tokens = [rearrange(patches, 'f h w d -> (f h w) d') for patches in all_patches]
-
-        # handle token dropout
-
-        seq_lens = torch.tensor([i.shape[0] for i in tokens], device = device)
-
-        if self.training and self.token_dropout_prob > 0:
-
-            keep_seq_lens = ((1. - self.token_dropout_prob) * seq_lens).int().clamp(min = 1)
-
-            kept_tokens = []
-            kept_positions = []
-
-            for one_image_tokens, one_image_positions, seq_len, num_keep in zip(tokens, positions, seq_lens, keep_seq_lens):
-                keep_indices = torch.randn((seq_len,), device = device).topk(num_keep, dim = -1).indices
-
-                one_image_kept_tokens = one_image_tokens[keep_indices]
-                one_image_kept_positions = one_image_positions[keep_indices]
-
-                kept_tokens.append(one_image_kept_tokens)
-                kept_positions.append(one_image_kept_positions)
-
-            tokens, positions, seq_lens = kept_tokens, kept_positions, keep_seq_lens
-
-        # add all height and width factorized positions
-
-
-        frame_indices, height_indices, width_indices = torch.cat(positions).unbind(dim = -1)
-        frame_embed, height_embed, width_embed = self.pos_embed_frame[frame_indices], self.pos_embed_height[height_indices], self.pos_embed_width[width_indices]
-
-        pos_embed = frame_embed + height_embed + width_embed
-
-        tokens = torch.cat(tokens)
-
-        # linear projection to patch embeddings
-
-        tokens = self.to_patch_embedding(tokens)
-
-        # absolute positions
-
-        tokens = tokens + pos_embed
-
-        # add register tokens
-
-        tokens = tokens.split(seq_lens.tolist())
-
-        tokens = [torch.cat((self.register_tokens, one_tokens)) for one_tokens in tokens]
-
-        # use nested tensor for transformers and save on padding computation
-
-        tokens = nested_tensor(tokens, layout = torch.jagged, device = device)
-
-        # embedding dropout
-
-        tokens = self.dropout(tokens)
-
-        # transformer
-
-        tokens = self.transformer(tokens)
-
-        # attention pooling
-        # will use a jagged tensor for queries, as SDPA requires all inputs to be jagged, or not
-
-        attn_pool_queries = [rearrange(self.attn_pool_queries, '... -> 1 ...')] * batch
-
-        attn_pool_queries = nested_tensor(attn_pool_queries, layout = torch.jagged)
-
-        pooled = self.attn_pool(attn_pool_queries, tokens)
-
-        # back to unjagged
-
-        logits = torch.stack(pooled.unbind())
-
-        logits = rearrange(logits, 'b 1 d -> b d')
-
-        logits = self.to_latent(logits)
-
-        return self.mlp_head(logits)
-
-# quick test
-
-if __name__ == '__main__':
-
-    # works for torch 2.5
-
-    v = NaViT(
-        image_size = 256,
-        max_frames = 8,
-        patch_size = 32,
-        frame_patch_size = 2,
-        num_classes = 1000,
-        dim = 1024,
-        depth = 6,
-        heads = 16,
-        mlp_dim = 2048,
-        dropout = 0.,
-        emb_dropout = 0.,
-        token_dropout_prob = 0.1
-    )
-
-    # 5 volumetric data (videos or CT scans) of different resolutions - List[Tensor]
-
-    volumes = [
-        torch.randn(3, 2, 256, 256), torch.randn(3, 8, 128, 128),
-        torch.randn(3, 4, 128, 256), torch.randn(3, 2, 256, 128),
-        torch.randn(3, 4, 64, 256)
-    ]
-
-    assert v(volumes).shape == (5, 1000)
-
-    v(volumes).sum().backward()

vit_pytorch/nest.py

@@ -24,11 +24,19 @@ class LayerNorm(nn.Module):
         mean = torch.mean(x, dim = 1, keepdim = True)
         return (x - mean) / (var + self.eps).sqrt() * self.g + self.b
 
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = LayerNorm(dim)
+        self.fn = fn
+
+    def forward(self, x, **kwargs):
+        return self.fn(self.norm(x), **kwargs)
+
 class FeedForward(nn.Module):
     def __init__(self, dim, mlp_mult = 4, dropout = 0.):
         super().__init__()
         self.net = nn.Sequential(
-            LayerNorm(dim),
             nn.Conv2d(dim, dim * mlp_mult, 1),
             nn.GELU(),
             nn.Dropout(dropout),
@@ -46,7 +54,6 @@ class Attention(nn.Module):
         self.heads = heads
         self.scale = dim_head ** -0.5
 
-        self.norm = LayerNorm(dim)
         self.attend = nn.Softmax(dim = -1)
         self.dropout = nn.Dropout(dropout)
         self.to_qkv = nn.Conv2d(dim, inner_dim * 3, 1, bias = False)
@@ -59,8 +66,6 @@ class Attention(nn.Module):
     def forward(self, x):
         b, c, h, w, heads = *x.shape, self.heads
 
-        x = self.norm(x)
-
         qkv = self.to_qkv(x).chunk(3, dim = 1)
         q, k, v = map(lambda t: rearrange(t, 'b (h d) x y -> b h (x y) d', h = heads), qkv)
 
@@ -88,8 +93,8 @@ class Transformer(nn.Module):
 
         for _ in range(depth):
             self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dropout = dropout),
-                FeedForward(dim, mlp_mult, dropout = dropout)
+                PreNorm(dim, Attention(dim, heads = heads, dropout = dropout)),
+                PreNorm(dim, FeedForward(dim, mlp_mult, dropout = dropout))
             ]))
     def forward(self, x):
         *_, h, w = x.shape
@@ -126,7 +131,7 @@ class NesT(nn.Module):
         fmap_size = image_size // patch_size
         blocks = 2 ** (num_hierarchies - 1)
 
-        seq_len = (fmap_size // blocks) ** 2   # sequence length is held constant across hierarchy
+        seq_len = (fmap_size // blocks) ** 2   # sequence length is held constant across heirarchy
         hierarchies = list(reversed(range(num_hierarchies)))
         mults = [2 ** i for i in reversed(hierarchies)]
 
@@ -139,9 +144,7 @@ class NesT(nn.Module):
 
         self.to_patch_embedding = nn.Sequential(
             Rearrange('b c (h p1) (w p2) -> b (p1 p2 c) h w', p1 = patch_size, p2 = patch_size),
-            LayerNorm(patch_dim),
             nn.Conv2d(patch_dim, layer_dims[0], 1),
-            LayerNorm(layer_dims[0])
         )
 
         block_repeats = cast_tuple(block_repeats, num_hierarchies)

vit_pytorch/normalized_vit.py

@@ -1,264 +0,0 @@
-import torch
-from torch import nn
-from torch.nn import Module, ModuleList
-import torch.nn.functional as F
-import torch.nn.utils.parametrize as parametrize
-
-from einops import rearrange, reduce
-from einops.layers.torch import Rearrange
-
-# functions
-
-def exists(v):
-    return v is not None
-
-def default(v, d):
-    return v if exists(v) else d
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-def divisible_by(numer, denom):
-    return (numer % denom) == 0
-
-def l2norm(t, dim = -1):
-    return F.normalize(t, dim = dim, p = 2)
-
-# for use with parametrize
-
-class L2Norm(Module):
-    def __init__(self, dim = -1):
-        super().__init__()
-        self.dim = dim
-
-    def forward(self, t):
-        return l2norm(t, dim = self.dim)
-
-class NormLinear(Module):
-    def __init__(
-        self,
-        dim,
-        dim_out,
-        norm_dim_in = True
-    ):
-        super().__init__()
-        self.linear = nn.Linear(dim, dim_out, bias = False)
-
-        parametrize.register_parametrization(
-            self.linear,
-            'weight',
-            L2Norm(dim = -1 if norm_dim_in else 0)
-        )
-
-    @property
-    def weight(self):
-        return self.linear.weight
-
-    def forward(self, x):
-        return self.linear(x)
-
-# attention and feedforward
-
-class Attention(Module):
-    def __init__(
-        self,
-        dim,
-        *,
-        dim_head = 64,
-        heads = 8,
-        dropout = 0.
-    ):
-        super().__init__()
-        dim_inner = dim_head * heads
-        self.to_q = NormLinear(dim, dim_inner)
-        self.to_k = NormLinear(dim, dim_inner)
-        self.to_v = NormLinear(dim, dim_inner)
-
-        self.dropout = dropout
-
-        self.q_scale = nn.Parameter(torch.ones(heads, 1, dim_head) * (dim_head ** 0.25))
-        self.k_scale = nn.Parameter(torch.ones(heads, 1, dim_head) * (dim_head ** 0.25))
-
-        self.split_heads = Rearrange('b n (h d) -> b h n d', h = heads)
-        self.merge_heads = Rearrange('b h n d -> b n (h d)')
-
-        self.to_out = NormLinear(dim_inner, dim, norm_dim_in = False)
-
-    def forward(
-        self,
-        x
-    ):
-        q, k, v = self.to_q(x), self.to_k(x), self.to_v(x)
-
-        q, k, v = map(self.split_heads, (q, k, v))
-
-        # query key rmsnorm
-
-        q, k = map(l2norm, (q, k))
-
-        q = q * self.q_scale
-        k = k * self.k_scale
-
-        # scale is 1., as scaling factor is moved to s_qk (dk ^ 0.25) - eq. 16
-
-        out = F.scaled_dot_product_attention(
-            q, k, v,
-            dropout_p = self.dropout if self.training else 0.,
-            scale = 1.
-        )
-
-        out = self.merge_heads(out)
-        return self.to_out(out)
-
-class FeedForward(Module):
-    def __init__(
-        self,
-        dim,
-        *,
-        dim_inner,
-        dropout = 0.
-    ):
-        super().__init__()
-        dim_inner = int(dim_inner * 2 / 3)
-
-        self.dim = dim
-        self.dropout = nn.Dropout(dropout)
-
-        self.to_hidden = NormLinear(dim, dim_inner)
-        self.to_gate = NormLinear(dim, dim_inner)
-
-        self.hidden_scale = nn.Parameter(torch.ones(dim_inner))
-        self.gate_scale = nn.Parameter(torch.ones(dim_inner))
-
-        self.to_out = NormLinear(dim_inner, dim, norm_dim_in = False)
-
-    def forward(self, x):
-        hidden, gate = self.to_hidden(x), self.to_gate(x)
-
-        hidden = hidden * self.hidden_scale
-        gate = gate * self.gate_scale * (self.dim ** 0.5)
-
-        hidden = F.silu(gate) * hidden
-
-        hidden = self.dropout(hidden)
-        return self.to_out(hidden)
-
-# classes
-
-class nViT(Module):
-    """ https://arxiv.org/abs/2410.01131 """
-
-    def __init__(
-        self,
-        *,
-        image_size,
-        patch_size,
-        num_classes,
-        dim,
-        depth,
-        heads,
-        mlp_dim,
-        dropout = 0.,
-        channels = 3,
-        dim_head = 64,
-        residual_lerp_scale_init = None
-    ):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-
-        # calculate patching related stuff
-
-        assert divisible_by(image_height, patch_size) and divisible_by(image_width, patch_size), 'Image dimensions must be divisible by the patch size.'
-
-        patch_height_dim, patch_width_dim = (image_height // patch_size), (image_width // patch_size)
-        patch_dim = channels * (patch_size ** 2)
-        num_patches = patch_height_dim * patch_width_dim
-
-        self.channels = channels
-        self.patch_size = patch_size
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange('b c (h p1) (w p2) -> b (h w) (c p1 p2)', p1 = patch_size, p2 = patch_size),
-            NormLinear(patch_dim, dim, norm_dim_in = False),
-        )
-
-        self.abs_pos_emb = NormLinear(dim, num_patches)
-
-        residual_lerp_scale_init = default(residual_lerp_scale_init, 1. / depth)
-
-        # layers
-
-        self.dim = dim
-        self.scale = dim ** 0.5
-
-        self.layers = ModuleList([])
-        self.residual_lerp_scales = nn.ParameterList([])
-
-        for _ in range(depth):
-            self.layers.append(ModuleList([
-                Attention(dim, dim_head = dim_head, heads = heads, dropout = dropout),
-                FeedForward(dim, dim_inner = mlp_dim, dropout = dropout),
-            ]))
-
-            self.residual_lerp_scales.append(nn.ParameterList([
-                nn.Parameter(torch.ones(dim) * residual_lerp_scale_init / self.scale),
-                nn.Parameter(torch.ones(dim) * residual_lerp_scale_init / self.scale),
-            ]))
-
-        self.logit_scale = nn.Parameter(torch.ones(num_classes))
-
-        self.to_pred = NormLinear(dim, num_classes)
-
-    @torch.no_grad()
-    def norm_weights_(self):
-        for module in self.modules():
-            if not isinstance(module, NormLinear):
-                continue
-
-            normed = module.weight
-            original = module.linear.parametrizations.weight.original
-
-            original.copy_(normed)
-
-    def forward(self, images):
-        device = images.device
-
-        tokens = self.to_patch_embedding(images)
-
-        seq_len = tokens.shape[-2]
-        pos_emb = self.abs_pos_emb.weight[torch.arange(seq_len, device = device)]
-
-        tokens = l2norm(tokens + pos_emb)
-
-        for (attn, ff), (attn_alpha, ff_alpha) in zip(self.layers, self.residual_lerp_scales):
-
-            attn_out = l2norm(attn(tokens))
-            tokens = l2norm(tokens.lerp(attn_out, attn_alpha * self.scale))
-
-            ff_out = l2norm(ff(tokens))
-            tokens = l2norm(tokens.lerp(ff_out, ff_alpha * self.scale))
-
-        pooled = reduce(tokens, 'b n d -> b d', 'mean')
-
-        logits = self.to_pred(pooled)
-        logits = logits * self.logit_scale * self.scale
-
-        return logits
-
-# quick test
-
-if __name__ == '__main__':
-
-    v = nViT(
-        image_size = 256,
-        patch_size = 16,
-        num_classes = 1000,
-        dim = 1024,
-        depth = 6,
-        heads = 8,
-        mlp_dim = 2048,
-    )
-
-    img = torch.randn(4, 3, 256, 256)
-    logits = v(img) # (4, 1000)
-    assert logits.shape == (4, 1000)

vit_pytorch/parallel_vit.py

@@ -19,11 +19,18 @@ class Parallel(nn.Module):
     def forward(self, x):
         return sum([fn(x) for fn in self.fns])
 
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = nn.LayerNorm(dim)
+        self.fn = fn
+    def forward(self, x, **kwargs):
+        return self.fn(self.norm(x), **kwargs)
+
 class FeedForward(nn.Module):
     def __init__(self, dim, hidden_dim, dropout = 0.):
         super().__init__()
         self.net = nn.Sequential(
-            nn.LayerNorm(dim),
             nn.Linear(dim, hidden_dim),
             nn.GELU(),
             nn.Dropout(dropout),
@@ -42,7 +49,6 @@ class Attention(nn.Module):
         self.heads = heads
         self.scale = dim_head ** -0.5
 
-        self.norm = nn.LayerNorm(dim)
         self.attend = nn.Softmax(dim = -1)
         self.dropout = nn.Dropout(dropout)
 
@@ -54,7 +60,6 @@ class Attention(nn.Module):
         ) if project_out else nn.Identity()
 
     def forward(self, x):
-        x = self.norm(x)
         qkv = self.to_qkv(x).chunk(3, dim = -1)
         q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
 
@@ -72,8 +77,8 @@ class Transformer(nn.Module):
         super().__init__()
         self.layers = nn.ModuleList([])
 
-        attn_block = lambda: Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout)
-        ff_block = lambda: FeedForward(dim, mlp_dim, dropout = dropout)
+        attn_block = lambda: PreNorm(dim, Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout))
+        ff_block = lambda: PreNorm(dim, FeedForward(dim, mlp_dim, dropout = dropout))        
 
         for _ in range(depth):
             self.layers.append(nn.ModuleList([

vit_pytorch/pit.py

@@ -17,11 +17,18 @@ def conv_output_size(image_size, kernel_size, stride, padding = 0):
 
 # classes
 
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = nn.LayerNorm(dim)
+        self.fn = fn
+    def forward(self, x, **kwargs):
+        return self.fn(self.norm(x), **kwargs)
+
 class FeedForward(nn.Module):
     def __init__(self, dim, hidden_dim, dropout = 0.):
         super().__init__()
         self.net = nn.Sequential(
-            nn.LayerNorm(dim),
             nn.Linear(dim, hidden_dim),
             nn.GELU(),
             nn.Dropout(dropout),
@@ -40,7 +47,6 @@ class Attention(nn.Module):
         self.heads = heads
         self.scale = dim_head ** -0.5
 
-        self.norm = nn.LayerNorm(dim)
         self.attend = nn.Softmax(dim = -1)
         self.dropout = nn.Dropout(dropout)
         self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
@@ -52,8 +58,6 @@ class Attention(nn.Module):
 
     def forward(self, x):
         b, n, _, h = *x.shape, self.heads
-
-        x = self.norm(x)
         qkv = self.to_qkv(x).chunk(3, dim = -1)
         q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = h), qkv)
 
@@ -72,8 +76,8 @@ class Transformer(nn.Module):
         self.layers = nn.ModuleList([])
         for _ in range(depth):
             self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_dim, dropout = dropout)
+                PreNorm(dim, Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout)),
+                PreNorm(dim, FeedForward(dim, mlp_dim, dropout = dropout))
             ]))
     def forward(self, x):
         for attn, ff in self.layers:

vit_pytorch/regionvit.py

@@ -20,18 +20,6 @@ def divisible_by(val, d):
 
 # helper classes
 
-class ChanLayerNorm(nn.Module):
-    def __init__(self, dim, eps = 1e-5):
-        super().__init__()
-        self.eps = eps
-        self.g = nn.Parameter(torch.ones(1, dim, 1, 1))
-        self.b = nn.Parameter(torch.zeros(1, dim, 1, 1))
-
-    def forward(self, x):
-        var = torch.var(x, dim = 1, unbiased = False, keepdim = True)
-        mean = torch.mean(x, dim = 1, keepdim = True)
-        return (x - mean) / (var + self.eps).sqrt() * self.g + self.b
-
 class Downsample(nn.Module):
     def __init__(self, dim_in, dim_out):
         super().__init__()
@@ -224,10 +212,10 @@ class RegionViT(nn.Module):
         if tokenize_local_3_conv:
             self.local_encoder = nn.Sequential(
                 nn.Conv2d(3, init_dim, 3, 2, 1),
-                ChanLayerNorm(init_dim),
+                nn.LayerNorm(init_dim),
                 nn.GELU(),
                 nn.Conv2d(init_dim, init_dim, 3, 2, 1),
-                ChanLayerNorm(init_dim),
+                nn.LayerNorm(init_dim),
                 nn.GELU(),
                 nn.Conv2d(init_dim, init_dim, 3, 1, 1)
             )

vit_pytorch/rvt.py

@@ -3,14 +3,12 @@ from math import sqrt, pi, log
 import torch
 from torch import nn, einsum
 import torch.nn.functional as F
-from torch.amp import autocast
 
 from einops import rearrange, repeat
 from einops.layers.torch import Rearrange
 
 # rotary embeddings
 
-@autocast('cuda', enabled = False)
 def rotate_every_two(x):
     x = rearrange(x, '... (d j) -> ... d j', j = 2)
     x1, x2 = x.unbind(dim = -1)
@@ -24,7 +22,6 @@ class AxialRotaryEmbedding(nn.Module):
         scales = torch.linspace(1., max_freq / 2, self.dim // 4)
         self.register_buffer('scales', scales)
 
-    @autocast('cuda', enabled = False)
     def forward(self, x):
         device, dtype, n = x.device, x.dtype, int(sqrt(x.shape[-2]))
 
@@ -58,6 +55,14 @@ class DepthWiseConv2d(nn.Module):
 
 # helper classes
 
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = nn.LayerNorm(dim)
+        self.fn = fn
+    def forward(self, x, **kwargs):
+        return self.fn(self.norm(x), **kwargs)
+
 class SpatialConv(nn.Module):
     def __init__(self, dim_in, dim_out, kernel, bias = False):
         super().__init__()
@@ -81,7 +86,6 @@ class FeedForward(nn.Module):
     def __init__(self, dim, hidden_dim, dropout = 0., use_glu = True):
         super().__init__()
         self.net = nn.Sequential(
-            nn.LayerNorm(dim),
             nn.Linear(dim, hidden_dim * 2 if use_glu else hidden_dim),
             GEGLU() if use_glu else nn.GELU(),
             nn.Dropout(dropout),
@@ -99,7 +103,6 @@ class Attention(nn.Module):
         self.heads = heads
         self.scale = dim_head ** -0.5
 
-        self.norm = nn.LayerNorm(dim)
         self.attend = nn.Softmax(dim = -1)
         self.dropout = nn.Dropout(dropout)
 
@@ -118,9 +121,6 @@ class Attention(nn.Module):
         b, n, _, h = *x.shape, self.heads
 
         to_q_kwargs = {'fmap_dims': fmap_dims} if self.use_ds_conv else {}
-
-        x = self.norm(x)
-
         q = self.to_q(x, **to_q_kwargs)
 
         qkv = (q, *self.to_kv(x).chunk(2, dim = -1))
@@ -162,8 +162,8 @@ class Transformer(nn.Module):
         self.pos_emb = AxialRotaryEmbedding(dim_head, max_freq = image_size)
         for _ in range(depth):
             self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout, use_rotary = use_rotary, use_ds_conv = use_ds_conv),
-                FeedForward(dim, mlp_dim, dropout = dropout, use_glu = use_glu)
+                PreNorm(dim, Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout, use_rotary = use_rotary, use_ds_conv = use_ds_conv)),
+                PreNorm(dim, FeedForward(dim, mlp_dim, dropout = dropout, use_glu = use_glu))
             ]))
     def forward(self, x, fmap_dims):
         pos_emb = self.pos_emb(x[:, 1:])

vit_pytorch/scalable_vit.py

@@ -33,6 +33,15 @@ class ChanLayerNorm(nn.Module):
         mean = torch.mean(x, dim = 1, keepdim = True)
         return (x - mean) / (var + self.eps).sqrt() * self.g + self.b
 
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = ChanLayerNorm(dim)
+        self.fn = fn
+
+    def forward(self, x):
+        return self.fn(self.norm(x))
+
 class Downsample(nn.Module):
     def __init__(self, dim_in, dim_out):
         super().__init__()
@@ -56,7 +65,6 @@ class FeedForward(nn.Module):
         super().__init__()
         inner_dim = dim * expansion_factor
         self.net = nn.Sequential(
-            ChanLayerNorm(dim),
             nn.Conv2d(dim, inner_dim, 1),
             nn.GELU(),
             nn.Dropout(dropout),
@@ -84,7 +92,6 @@ class ScalableSelfAttention(nn.Module):
         self.attend = nn.Softmax(dim = -1)
         self.dropout = nn.Dropout(dropout)
 
-        self.norm = ChanLayerNorm(dim)
         self.to_q = nn.Conv2d(dim, dim_key * heads, 1, bias = False)
         self.to_k = nn.Conv2d(dim, dim_key * heads, reduction_factor, stride = reduction_factor, bias = False)
         self.to_v = nn.Conv2d(dim, dim_value * heads, reduction_factor, stride = reduction_factor, bias = False)
@@ -97,8 +104,6 @@ class ScalableSelfAttention(nn.Module):
     def forward(self, x):
         height, width, heads = *x.shape[-2:], self.heads
 
-        x = self.norm(x)
-
         q, k, v = self.to_q(x), self.to_k(x), self.to_v(x)
 
         # split out heads
@@ -140,7 +145,6 @@ class InteractiveWindowedSelfAttention(nn.Module):
         self.attend = nn.Softmax(dim = -1)
         self.dropout = nn.Dropout(dropout)
 
-        self.norm = ChanLayerNorm(dim)
         self.local_interactive_module = nn.Conv2d(dim_value * heads, dim_value * heads, 3, padding = 1)
 
         self.to_q = nn.Conv2d(dim, dim_key * heads, 1, bias = False)
@@ -155,8 +159,6 @@ class InteractiveWindowedSelfAttention(nn.Module):
     def forward(self, x):
         height, width, heads, wsz = *x.shape[-2:], self.heads, self.window_size
 
-        x = self.norm(x)
-
         wsz_h, wsz_w = default(wsz, height), default(wsz, width)
         assert (height % wsz_h) == 0 and (width % wsz_w) == 0, f'height ({height}) or width ({width}) of feature map is not divisible by the window size ({wsz_h}, {wsz_w})'
 
@@ -215,11 +217,11 @@ class Transformer(nn.Module):
             is_first = ind == 0
 
             self.layers.append(nn.ModuleList([
-                ScalableSelfAttention(dim, heads = heads, dim_key = ssa_dim_key, dim_value = ssa_dim_value, reduction_factor = ssa_reduction_factor, dropout = dropout),
-                FeedForward(dim, expansion_factor = ff_expansion_factor, dropout = dropout),
+                PreNorm(dim, ScalableSelfAttention(dim, heads = heads, dim_key = ssa_dim_key, dim_value = ssa_dim_value, reduction_factor = ssa_reduction_factor, dropout = dropout)),
+                PreNorm(dim, FeedForward(dim, expansion_factor = ff_expansion_factor, dropout = dropout)),
                 PEG(dim) if is_first else None,
-                FeedForward(dim, expansion_factor = ff_expansion_factor, dropout = dropout),
-                InteractiveWindowedSelfAttention(dim, heads = heads, dim_key = iwsa_dim_key, dim_value = iwsa_dim_value, window_size = iwsa_window_size, dropout = dropout)
+                PreNorm(dim, FeedForward(dim, expansion_factor = ff_expansion_factor, dropout = dropout)),
+                PreNorm(dim, InteractiveWindowedSelfAttention(dim, heads = heads, dim_key = iwsa_dim_key, dim_value = iwsa_dim_value, window_size = iwsa_window_size, dropout = dropout))
             ]))
 
         self.norm = ChanLayerNorm(dim) if norm_output else nn.Identity()

vit_pytorch/sep_vit.py

@@ -25,6 +25,15 @@ class ChanLayerNorm(nn.Module):
         mean = torch.mean(x, dim = 1, keepdim = True)
         return (x - mean) / (var + self.eps).sqrt() * self.g + self.b
 
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = ChanLayerNorm(dim)
+        self.fn = fn
+
+    def forward(self, x):
+        return self.fn(self.norm(x))
+
 class OverlappingPatchEmbed(nn.Module):
     def __init__(self, dim_in, dim_out, stride = 2):
         super().__init__()
@@ -50,7 +59,6 @@ class FeedForward(nn.Module):
         super().__init__()
         inner_dim = int(dim * mult)
         self.net = nn.Sequential(
-            ChanLayerNorm(dim),
             nn.Conv2d(dim, inner_dim, 1),
             nn.GELU(),
             nn.Dropout(dropout),
@@ -77,8 +85,6 @@ class DSSA(nn.Module):
         self.window_size = window_size
         inner_dim = dim_head * heads
 
-        self.norm = ChanLayerNorm(dim)
-
         self.attend = nn.Sequential(
             nn.Softmax(dim = -1),
             nn.Dropout(dropout)
@@ -132,8 +138,6 @@ class DSSA(nn.Module):
         assert (height % wsz) == 0 and (width % wsz) == 0, f'height {height} and width {width} must be divisible by window size {wsz}'
         num_windows = (height // wsz) * (width // wsz)
 
-        x = self.norm(x)
-
         # fold in windows for "depthwise" attention - not sure why it is named depthwise when it is just "windowed" attention
 
         x = rearrange(x, 'b c (h w1) (w w2) -> (b h w) c (w1 w2)', w1 = wsz, w2 = wsz)
@@ -221,8 +225,8 @@ class Transformer(nn.Module):
 
         for ind in range(depth):
             self.layers.append(nn.ModuleList([
-                DSSA(dim, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mult = ff_mult, dropout = dropout),
+                PreNorm(dim, DSSA(dim, heads = heads, dim_head = dim_head, dropout = dropout)),
+                PreNorm(dim, FeedForward(dim, mult = ff_mult, dropout = dropout)),
             ]))
 
         self.norm = ChanLayerNorm(dim) if norm_output else nn.Identity()

vit_pytorch/simmim.py

@@ -18,11 +18,8 @@ class SimMIM(nn.Module):
 
         self.encoder = encoder
         num_patches, encoder_dim = encoder.pos_embedding.shape[-2:]
-
-        self.to_patch = encoder.to_patch_embedding[0]
-        self.patch_to_emb = nn.Sequential(*encoder.to_patch_embedding[1:])
-
-        pixel_values_per_patch = encoder.to_patch_embedding[2].weight.shape[-1]
+        self.to_patch, self.patch_to_emb = encoder.to_patch_embedding[:2]
+        pixel_values_per_patch = self.patch_to_emb.weight.shape[-1]
 
         # simple linear head
 

vit_pytorch/simple_flash_attn_vit.py

@@ -1,176 +0,0 @@
-from collections import namedtuple
-from packaging import version
-
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-from einops import rearrange
-from einops.layers.torch import Rearrange
-
-# constants
-
-Config = namedtuple('FlashAttentionConfig', ['enable_flash', 'enable_math', 'enable_mem_efficient'])
-
-# helpers
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-def posemb_sincos_2d(patches, temperature = 10000, dtype = torch.float32):
-    _, h, w, dim, device, dtype = *patches.shape, patches.device, patches.dtype
-
-    y, x = torch.meshgrid(torch.arange(h, device = device), torch.arange(w, device = device), indexing = 'ij')
-    assert (dim % 4) == 0, 'feature dimension must be multiple of 4 for sincos emb'
-    omega = torch.arange(dim // 4, device = device) / (dim // 4 - 1)
-    omega = 1. / (temperature ** omega)
-
-    y = y.flatten()[:, None] * omega[None, :]
-    x = x.flatten()[:, None] * omega[None, :] 
-    pe = torch.cat((x.sin(), x.cos(), y.sin(), y.cos()), dim = 1)
-    return pe.type(dtype)
-
-# main class
-
-class Attend(nn.Module):
-    def __init__(self, use_flash = False):
-        super().__init__()
-        self.use_flash = use_flash
-        assert not (use_flash and version.parse(torch.__version__) < version.parse('2.0.0')), 'in order to use flash attention, you must be using pytorch 2.0 or above'
-
-        # determine efficient attention configs for cuda and cpu
-
-        self.cpu_config = Config(True, True, True)
-        self.cuda_config = None
-
-        if not torch.cuda.is_available() or not use_flash:
-            return
-
-        device_properties = torch.cuda.get_device_properties(torch.device('cuda'))
-
-        if device_properties.major == 8 and device_properties.minor == 0:
-            self.cuda_config = Config(True, False, False)
-        else:
-            self.cuda_config = Config(False, True, True)
-
-    def flash_attn(self, q, k, v):
-        config = self.cuda_config if q.is_cuda else self.cpu_config
-
-        # flash attention - https://arxiv.org/abs/2205.14135
-        
-        with torch.backends.cuda.sdp_kernel(**config._asdict()):
-            out = F.scaled_dot_product_attention(q, k, v)
-
-        return out
-
-    def forward(self, q, k, v):
-        n, device, scale = q.shape[-2], q.device, q.shape[-1] ** -0.5
-
-        if self.use_flash:
-            return self.flash_attn(q, k, v)
-
-        # similarity
-
-        sim = einsum("b h i d, b j d -> b h i j", q, k) * scale
-
-        # attention
-
-        attn = sim.softmax(dim=-1)
-
-        # aggregate values
-
-        out = einsum("b h i j, b j d -> b h i d", attn, v)
-
-        return out
-
-# classes
-
-class FeedForward(nn.Module):
-    def __init__(self, dim, hidden_dim):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Linear(hidden_dim, dim),
-        )
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(nn.Module):
-    def __init__(self, dim, heads = 8, dim_head = 64, use_flash = True):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-        self.norm = nn.LayerNorm(dim)
-
-        self.attend = Attend(use_flash = use_flash)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-        self.to_out = nn.Linear(inner_dim, dim, bias = False)
-
-    def forward(self, x):
-        x = self.norm(x)
-
-        qkv = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        out = self.attend(q, k, v)
-
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(nn.Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim, use_flash):
-        super().__init__()
-        self.layers = nn.ModuleList([])
-        for _ in range(depth):
-            self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, use_flash = use_flash),
-                FeedForward(dim, mlp_dim)
-            ]))
-    def forward(self, x):
-        for attn, ff in self.layers:
-            x = attn(x) + x
-            x = ff(x) + x
-        return x
-
-class SimpleViT(nn.Module):
-    def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, channels = 3, dim_head = 64, use_flash = True):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(patch_size)
-
-        assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
-
-        num_patches = (image_height // patch_height) * (image_width // patch_width)
-        patch_dim = channels * patch_height * patch_width
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange('b c (h p1) (w p2) -> b h w (p1 p2 c)', p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, use_flash)
-
-        self.to_latent = nn.Identity()
-        self.linear_head = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, num_classes)
-        )
-
-    def forward(self, img):
-        *_, h, w, dtype = *img.shape, img.dtype
-
-        x = self.to_patch_embedding(img)
-        pe = posemb_sincos_2d(x)
-        x = rearrange(x, 'b ... d -> b (...) d') + pe
-
-        x = self.transformer(x)
-        x = x.mean(dim = 1)
-
-        x = self.to_latent(x)
-        return self.linear_head(x)

vit_pytorch/simple_flash_attn_vit_3d.py

@@ -1,171 +0,0 @@
-from packaging import version
-from collections import namedtuple
-
-import torch
-from torch import nn
-import torch.nn.functional as F
-from torch.nn import Module, ModuleList
-
-from einops import rearrange
-from einops.layers.torch import Rearrange
-
-# constants
-
-Config = namedtuple('FlashAttentionConfig', ['enable_flash', 'enable_math', 'enable_mem_efficient'])
-
-# helpers
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-def posemb_sincos_3d(patches, temperature = 10000, dtype = torch.float32):
-    _, f, h, w, dim, device, dtype = *patches.shape, patches.device, patches.dtype
-
-    z, y, x = torch.meshgrid(
-        torch.arange(f, device = device),
-        torch.arange(h, device = device),
-        torch.arange(w, device = device),
-    indexing = 'ij')
-
-    fourier_dim = dim // 6
-
-    omega = torch.arange(fourier_dim, device = device) / (fourier_dim - 1)
-    omega = 1. / (temperature ** omega)
-
-    z = z.flatten()[:, None] * omega[None, :]
-    y = y.flatten()[:, None] * omega[None, :]
-    x = x.flatten()[:, None] * omega[None, :] 
-
-    pe = torch.cat((x.sin(), x.cos(), y.sin(), y.cos(), z.sin(), z.cos()), dim = 1)
-
-    pe = F.pad(pe, (0, dim - (fourier_dim * 6))) # pad if feature dimension not cleanly divisible by 6
-    return pe.type(dtype)
-
-# main class
-
-class Attend(Module):
-    def __init__(self, use_flash = False, config: Config = Config(True, True, True)):
-        super().__init__()
-        self.config = config
-        self.use_flash = use_flash
-        assert not (use_flash and version.parse(torch.__version__) < version.parse('2.0.0')), 'in order to use flash attention, you must be using pytorch 2.0 or above'
-
-    def flash_attn(self, q, k, v):
-        # flash attention - https://arxiv.org/abs/2205.14135
-        
-        with torch.backends.cuda.sdp_kernel(**self.config._asdict()):
-            out = F.scaled_dot_product_attention(q, k, v)
-
-        return out
-
-    def forward(self, q, k, v):
-        n, device, scale = q.shape[-2], q.device, q.shape[-1] ** -0.5
-
-        if self.use_flash:
-            return self.flash_attn(q, k, v)
-
-        # similarity
-
-        sim = einsum("b h i d, b j d -> b h i j", q, k) * scale
-
-        # attention
-
-        attn = sim.softmax(dim=-1)
-
-        # aggregate values
-
-        out = einsum("b h i j, b j d -> b h i d", attn, v)
-
-        return out
-
-# classes
-
-class FeedForward(Module):
-    def __init__(self, dim, hidden_dim):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Linear(hidden_dim, dim),
-        )
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(Module):
-    def __init__(self, dim, heads = 8, dim_head = 64, use_flash = True):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-        self.norm = nn.LayerNorm(dim)
-
-        self.attend = Attend(use_flash = use_flash)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-        self.to_out = nn.Linear(inner_dim, dim, bias = False)
-
-    def forward(self, x):
-        x = self.norm(x)
-
-        qkv = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        out = self.attend(q, k, v)
-
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim, use_flash):
-        super().__init__()
-        self.layers = ModuleList([])
-        for _ in range(depth):
-            self.layers.append(ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, use_flash = use_flash),
-                FeedForward(dim, mlp_dim)
-            ]))
-
-    def forward(self, x):
-        for attn, ff in self.layers:
-            x = attn(x) + x
-            x = ff(x) + x
-
-        return x
-
-class SimpleViT(Module):
-    def __init__(self, *, image_size, image_patch_size, frames, frame_patch_size, num_classes, dim, depth, heads, mlp_dim, channels = 3, dim_head = 64, use_flash_attn = True):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(image_patch_size)
-
-        assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
-        assert frames % frame_patch_size == 0, 'Frames must be divisible by the frame patch size'
-
-        num_patches = (image_height // patch_height) * (image_width // patch_width) * (frames // frame_patch_size)
-        patch_dim = channels * patch_height * patch_width * frame_patch_size
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange('b c (f pf) (h p1) (w p2) -> b f h w (pf p1 p2 c)', p1 = patch_height, p2 = patch_width, pf = frame_patch_size),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, use_flash_attn)
-
-        self.to_latent = nn.Identity()
-        self.linear_head = nn.Linear(dim, num_classes)
-
-    def forward(self, video):
-        *_, h, w, dtype = *video.shape, video.dtype
-
-        x = self.to_patch_embedding(video)
-        pe = posemb_sincos_3d(x)
-        x = rearrange(x, 'b ... d -> b (...) d') + pe
-
-        x = self.transformer(x)
-        x = x.mean(dim = 1)
-
-        x = self.to_latent(x)
-        return self.linear_head(x)

vit_pytorch/simple_uvit.py

@@ -1,176 +0,0 @@
-import torch
-from torch import nn
-from torch.nn import Module, ModuleList
-
-from einops import rearrange, repeat, pack, unpack
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-def exists(v):
-    return v is not None
-
-def divisible_by(num, den):
-    return (num % den) == 0
-
-def posemb_sincos_2d(h, w, dim, temperature: int = 10000, dtype = torch.float32):
-    y, x = torch.meshgrid(torch.arange(h), torch.arange(w), indexing="ij")
-    assert divisible_by(dim, 4), "feature dimension must be multiple of 4 for sincos emb"
-    omega = torch.arange(dim // 4) / (dim // 4 - 1)
-    omega = temperature ** -omega
-
-    y = y.flatten()[:, None] * omega[None, :]
-    x = x.flatten()[:, None] * omega[None, :]
-    pe = torch.cat((x.sin(), x.cos(), y.sin(), y.cos()), dim=1)
-    return pe.type(dtype)
-
-# classes
-
-def FeedForward(dim, hidden_dim):
-    return nn.Sequential(
-        nn.LayerNorm(dim),
-        nn.Linear(dim, hidden_dim),
-        nn.GELU(),
-        nn.Linear(hidden_dim, dim),
-    )    
-
-class Attention(Module):
-    def __init__(self, dim, heads = 8, dim_head = 64):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-        self.norm = nn.LayerNorm(dim)
-
-        self.attend = nn.Softmax(dim = -1)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-        self.to_out = nn.Linear(inner_dim, dim, bias = False)
-
-    def forward(self, x):
-        x = self.norm(x)
-
-        qkv = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-
-        attn = self.attend(dots)
-
-        out = torch.matmul(attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim):
-        super().__init__()
-        self.depth = depth
-        self.norm = nn.LayerNorm(dim)
-        self.layers = ModuleList([])
-
-        for layer in range(1, depth + 1):
-            latter_half = layer >= (depth / 2 + 1)
-
-            self.layers.append(nn.ModuleList([
-                nn.Linear(dim * 2, dim) if latter_half else None,
-                Attention(dim, heads = heads, dim_head = dim_head),
-                FeedForward(dim, mlp_dim)
-            ]))
-
-    def forward(self, x):
-
-        skips = []
-
-        for ind, (combine_skip, attn, ff) in enumerate(self.layers):
-            layer = ind + 1
-            first_half = layer <= (self.depth / 2)
-
-            if first_half:
-                skips.append(x)
-
-            if exists(combine_skip):
-                skip = skips.pop()
-                skip_and_x = torch.cat((skip, x), dim = -1)
-                x = combine_skip(skip_and_x)
-
-            x = attn(x) + x
-            x = ff(x) + x
-
-        assert len(skips) == 0
-
-        return self.norm(x)
-
-class SimpleUViT(Module):
-    def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, num_register_tokens = 4, channels = 3, dim_head = 64):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(patch_size)
-
-        assert divisible_by(image_height, patch_height) and divisible_by(image_width, patch_width), 'Image dimensions must be divisible by the patch size.'
-
-        patch_dim = channels * patch_height * patch_width
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange("b c (h p1) (w p2) -> b (h w) (p1 p2 c)", p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        pos_embedding = posemb_sincos_2d(
-            h = image_height // patch_height,
-            w = image_width // patch_width,
-            dim = dim
-        )
-
-        self.register_buffer('pos_embedding', pos_embedding, persistent = False)
-
-        self.register_tokens = nn.Parameter(torch.randn(num_register_tokens, dim))
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim)
-
-        self.pool = "mean"
-        self.to_latent = nn.Identity()
-
-        self.linear_head = nn.Linear(dim, num_classes)
-
-    def forward(self, img):
-        batch, device = img.shape[0], img.device
-
-        x = self.to_patch_embedding(img)
-        x = x + self.pos_embedding.type(x.dtype)
-
-        r = repeat(self.register_tokens, 'n d -> b n d', b = batch)
-
-        x, ps = pack([x, r], 'b * d')
-
-        x = self.transformer(x)
-
-        x, _ = unpack(x, ps, 'b * d')
-
-        x = x.mean(dim = 1)
-
-        x = self.to_latent(x)
-        return self.linear_head(x)
-
-# quick test on odd number of layers
-
-if __name__ == '__main__':
-
-    v = SimpleUViT(
-        image_size = 256,
-        patch_size = 32,
-        num_classes = 1000,
-        dim = 1024,
-        depth = 7,
-        heads = 16,
-        mlp_dim = 2048
-    ).cuda()
-
-    img = torch.randn(2, 3, 256, 256).cuda()
-
-    preds = v(img)
-    assert preds.shape == (2, 1000)

vit_pytorch/simple_vit.py

@@ -1,7 +1,7 @@
 import torch
 from torch import nn
 
-from einops import rearrange
+from einops import rearrange, repeat
 from einops.layers.torch import Rearrange
 
 # helpers
@@ -9,15 +9,17 @@ from einops.layers.torch import Rearrange
 def pair(t):
     return t if isinstance(t, tuple) else (t, t)
 
-def posemb_sincos_2d(h, w, dim, temperature: int = 10000, dtype = torch.float32):
-    y, x = torch.meshgrid(torch.arange(h), torch.arange(w), indexing="ij")
-    assert (dim % 4) == 0, "feature dimension must be multiple of 4 for sincos emb"
-    omega = torch.arange(dim // 4) / (dim // 4 - 1)
-    omega = 1.0 / (temperature ** omega)
+def posemb_sincos_2d(patches, temperature = 10000, dtype = torch.float32):
+    _, h, w, dim, device, dtype = *patches.shape, patches.device, patches.dtype
+
+    y, x = torch.meshgrid(torch.arange(h, device = device), torch.arange(w, device = device), indexing = 'ij')
+    assert (dim % 4) == 0, 'feature dimension must be multiple of 4 for sincos emb'
+    omega = torch.arange(dim // 4, device = device) / (dim // 4 - 1)
+    omega = 1. / (temperature ** omega)
 
     y = y.flatten()[:, None] * omega[None, :]
-    x = x.flatten()[:, None] * omega[None, :]
-    pe = torch.cat((x.sin(), x.cos(), y.sin(), y.cos()), dim=1)
+    x = x.flatten()[:, None] * omega[None, :] 
+    pe = torch.cat((x.sin(), x.cos(), y.sin(), y.cos()), dim = 1)
     return pe.type(dtype)
 
 # classes
@@ -38,6 +40,8 @@ class Attention(nn.Module):
     def __init__(self, dim, heads = 8, dim_head = 64):
         super().__init__()
         inner_dim = dim_head *  heads
+        project_out = not (heads == 1 and dim_head == dim)
+
         self.heads = heads
         self.scale = dim_head ** -0.5
         self.norm = nn.LayerNorm(dim)
@@ -64,7 +68,6 @@ class Attention(nn.Module):
 class Transformer(nn.Module):
     def __init__(self, dim, depth, heads, dim_head, mlp_dim):
         super().__init__()
-        self.norm = nn.LayerNorm(dim)
         self.layers = nn.ModuleList([])
         for _ in range(depth):
             self.layers.append(nn.ModuleList([
@@ -75,7 +78,7 @@ class Transformer(nn.Module):
         for attn, ff in self.layers:
             x = attn(x) + x
             x = ff(x) + x
-        return self.norm(x)
+        return x
 
 class SimpleViT(nn.Module):
     def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, channels = 3, dim_head = 64):
@@ -85,33 +88,28 @@ class SimpleViT(nn.Module):
 
         assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
 
+        num_patches = (image_height // patch_height) * (image_width // patch_width)
         patch_dim = channels * patch_height * patch_width
 
         self.to_patch_embedding = nn.Sequential(
-            Rearrange("b c (h p1) (w p2) -> b (h w) (p1 p2 c)", p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
+            Rearrange('b c (h p1) (w p2) -> b h w (p1 p2 c)', p1 = patch_height, p2 = patch_width),
             nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
         )
 
-        self.pos_embedding = posemb_sincos_2d(
-            h = image_height // patch_height,
-            w = image_width // patch_width,
-            dim = dim,
-        ) 
-
         self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim)
 
-        self.pool = "mean"
         self.to_latent = nn.Identity()
-
-        self.linear_head = nn.Linear(dim, num_classes)
+        self.linear_head = nn.Sequential(
+            nn.LayerNorm(dim),
+            nn.Linear(dim, num_classes)
+        )
 
     def forward(self, img):
-        device = img.device
+        *_, h, w, dtype = *img.shape, img.dtype
 
         x = self.to_patch_embedding(img)
-        x += self.pos_embedding.to(device, dtype=x.dtype)
+        pe = posemb_sincos_2d(x)
+        x = rearrange(x, 'b ... d -> b (...) d') + pe
 
         x = self.transformer(x)
         x = x.mean(dim = 1)

vit_pytorch/simple_vit_1d.py

@@ -1,125 +0,0 @@
-import torch
-from torch import nn
-
-from einops import rearrange
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def posemb_sincos_1d(patches, temperature = 10000, dtype = torch.float32):
-    _, n, dim, device, dtype = *patches.shape, patches.device, patches.dtype
-
-    n = torch.arange(n, device = device)
-    assert (dim % 2) == 0, 'feature dimension must be multiple of 2 for sincos emb'
-    omega = torch.arange(dim // 2, device = device) / (dim // 2 - 1)
-    omega = 1. / (temperature ** omega)
-
-    n = n.flatten()[:, None] * omega[None, :]
-    pe = torch.cat((n.sin(), n.cos()), dim = 1)
-    return pe.type(dtype)
-
-# classes
-
-class FeedForward(nn.Module):
-    def __init__(self, dim, hidden_dim):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Linear(hidden_dim, dim),
-        )
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(nn.Module):
-    def __init__(self, dim, heads = 8, dim_head = 64):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-        self.norm = nn.LayerNorm(dim)
-
-        self.attend = nn.Softmax(dim = -1)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-        self.to_out = nn.Linear(inner_dim, dim, bias = False)
-
-    def forward(self, x):
-        x = self.norm(x)
-
-        qkv = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-
-        attn = self.attend(dots)
-
-        out = torch.matmul(attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(nn.Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim)
-        self.layers = nn.ModuleList([])
-        for _ in range(depth):
-            self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head),
-                FeedForward(dim, mlp_dim)
-            ]))
-    def forward(self, x):
-        for attn, ff in self.layers:
-            x = attn(x) + x
-            x = ff(x) + x
-        return self.norm(x)
-
-class SimpleViT(nn.Module):
-    def __init__(self, *, seq_len, patch_size, num_classes, dim, depth, heads, mlp_dim, channels = 3, dim_head = 64):
-        super().__init__()
-
-        assert seq_len % patch_size == 0
-
-        num_patches = seq_len // patch_size
-        patch_dim = channels * patch_size
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange('b c (n p) -> b n (p c)', p = patch_size),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim)
-
-        self.to_latent = nn.Identity()
-        self.linear_head = nn.Linear(dim, num_classes)
-
-    def forward(self, series):
-        *_, n, dtype = *series.shape, series.dtype
-
-        x = self.to_patch_embedding(series)
-        pe = posemb_sincos_1d(x)
-        x = rearrange(x, 'b ... d -> b (...) d') + pe
-
-        x = self.transformer(x)
-        x = x.mean(dim = 1)
-
-        x = self.to_latent(x)
-        return self.linear_head(x)
-
-if __name__ == '__main__':
-
-    v = SimpleViT(
-        seq_len = 256,
-        patch_size = 16,
-        num_classes = 1000,
-        dim = 1024,
-        depth = 6,
-        heads = 8,
-        mlp_dim = 2048
-    )
-
-    time_series = torch.randn(4, 3, 256)
-    logits = v(time_series) # (4, 1000)

vit_pytorch/simple_vit_3d.py

@@ -1,128 +0,0 @@
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-from einops import rearrange
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-def posemb_sincos_3d(patches, temperature = 10000, dtype = torch.float32):
-    _, f, h, w, dim, device, dtype = *patches.shape, patches.device, patches.dtype
-
-    z, y, x = torch.meshgrid(
-        torch.arange(f, device = device),
-        torch.arange(h, device = device),
-        torch.arange(w, device = device),
-    indexing = 'ij')
-
-    fourier_dim = dim // 6
-
-    omega = torch.arange(fourier_dim, device = device) / (fourier_dim - 1)
-    omega = 1. / (temperature ** omega)
-
-    z = z.flatten()[:, None] * omega[None, :]
-    y = y.flatten()[:, None] * omega[None, :]
-    x = x.flatten()[:, None] * omega[None, :] 
-
-    pe = torch.cat((x.sin(), x.cos(), y.sin(), y.cos(), z.sin(), z.cos()), dim = 1)
-
-    pe = F.pad(pe, (0, dim - (fourier_dim * 6))) # pad if feature dimension not cleanly divisible by 6
-    return pe.type(dtype)
-
-# classes
-
-class FeedForward(nn.Module):
-    def __init__(self, dim, hidden_dim):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Linear(hidden_dim, dim),
-        )
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(nn.Module):
-    def __init__(self, dim, heads = 8, dim_head = 64):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-        self.norm = nn.LayerNorm(dim)
-
-        self.attend = nn.Softmax(dim = -1)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-        self.to_out = nn.Linear(inner_dim, dim, bias = False)
-
-    def forward(self, x):
-        x = self.norm(x)
-
-        qkv = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-
-        attn = self.attend(dots)
-
-        out = torch.matmul(attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(nn.Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim)
-        self.layers = nn.ModuleList([])
-        for _ in range(depth):
-            self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head),
-                FeedForward(dim, mlp_dim)
-            ]))
-    def forward(self, x):
-        for attn, ff in self.layers:
-            x = attn(x) + x
-            x = ff(x) + x
-        return self.norm(x)
-
-class SimpleViT(nn.Module):
-    def __init__(self, *, image_size, image_patch_size, frames, frame_patch_size, num_classes, dim, depth, heads, mlp_dim, channels = 3, dim_head = 64):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(image_patch_size)
-
-        assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
-        assert frames % frame_patch_size == 0, 'Frames must be divisible by the frame patch size'
-
-        num_patches = (image_height // patch_height) * (image_width // patch_width) * (frames // frame_patch_size)
-        patch_dim = channels * patch_height * patch_width * frame_patch_size
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange('b c (f pf) (h p1) (w p2) -> b f h w (pf p1 p2 c)', p1 = patch_height, p2 = patch_width, pf = frame_patch_size),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim)
-
-        self.to_latent = nn.Identity()
-        self.linear_head = nn.Linear(dim, num_classes)
-
-    def forward(self, video):
-        *_, h, w, dtype = *video.shape, video.dtype
-
-        x = self.to_patch_embedding(video)
-        pe = posemb_sincos_3d(x)
-        x = rearrange(x, 'b ... d -> b (...) d') + pe
-
-        x = self.transformer(x)
-        x = x.mean(dim = 1)
-
-        x = self.to_latent(x)
-        return self.linear_head(x)

vit_pytorch/simple_vit_with_fft.py

@@ -1,162 +0,0 @@
-import torch
-from torch.fft import fft2
-from torch import nn
-
-from einops import rearrange, reduce, pack, unpack
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-def posemb_sincos_2d(h, w, dim, temperature: int = 10000, dtype = torch.float32):
-    y, x = torch.meshgrid(torch.arange(h), torch.arange(w), indexing="ij")
-    assert (dim % 4) == 0, "feature dimension must be multiple of 4 for sincos emb"
-    omega = torch.arange(dim // 4) / (dim // 4 - 1)
-    omega = 1.0 / (temperature ** omega)
-
-    y = y.flatten()[:, None] * omega[None, :]
-    x = x.flatten()[:, None] * omega[None, :]
-    pe = torch.cat((x.sin(), x.cos(), y.sin(), y.cos()), dim=1)
-    return pe.type(dtype)
-
-# classes
-
-class FeedForward(nn.Module):
-    def __init__(self, dim, hidden_dim):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Linear(hidden_dim, dim),
-        )
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(nn.Module):
-    def __init__(self, dim, heads = 8, dim_head = 64):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-        self.norm = nn.LayerNorm(dim)
-
-        self.attend = nn.Softmax(dim = -1)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-        self.to_out = nn.Linear(inner_dim, dim, bias = False)
-
-    def forward(self, x):
-        x = self.norm(x)
-
-        qkv = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-
-        attn = self.attend(dots)
-
-        out = torch.matmul(attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(nn.Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim)
-        self.layers = nn.ModuleList([])
-        for _ in range(depth):
-            self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head),
-                FeedForward(dim, mlp_dim)
-            ]))
-    def forward(self, x):
-        for attn, ff in self.layers:
-            x = attn(x) + x
-            x = ff(x) + x
-        return self.norm(x)
-
-class SimpleViT(nn.Module):
-    def __init__(self, *, image_size, patch_size, freq_patch_size, num_classes, dim, depth, heads, mlp_dim, channels = 3, dim_head = 64):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(patch_size)
-        freq_patch_height, freq_patch_width = pair(freq_patch_size)
-
-        assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
-        assert image_height % freq_patch_height == 0 and image_width % freq_patch_width == 0, 'Image dimensions must be divisible by the freq patch size.'
-
-        patch_dim = channels * patch_height * patch_width
-        freq_patch_dim = channels * 2 * freq_patch_height * freq_patch_width
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange("b c (h p1) (w p2) -> b (h w) (p1 p2 c)", p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.to_freq_embedding = nn.Sequential(
-            Rearrange("b c (h p1) (w p2) ri -> b (h w) (p1 p2 ri c)", p1 = freq_patch_height, p2 = freq_patch_width),
-            nn.LayerNorm(freq_patch_dim),
-            nn.Linear(freq_patch_dim, dim),
-            nn.LayerNorm(dim)
-        )
-
-        self.pos_embedding = posemb_sincos_2d(
-            h = image_height // patch_height,
-            w = image_width // patch_width,
-            dim = dim,
-        )
-
-        self.freq_pos_embedding = posemb_sincos_2d(
-            h = image_height // freq_patch_height,
-            w = image_width // freq_patch_width,
-            dim = dim
-        )
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim)
-
-        self.pool = "mean"
-        self.to_latent = nn.Identity()
-
-        self.linear_head = nn.Linear(dim, num_classes)
-
-    def forward(self, img):
-        device, dtype = img.device, img.dtype
-
-        x = self.to_patch_embedding(img)
-        freqs = torch.view_as_real(fft2(img))
-
-        f = self.to_freq_embedding(freqs)
-
-        x += self.pos_embedding.to(device, dtype = dtype)
-        f += self.freq_pos_embedding.to(device, dtype = dtype)
-
-        x, ps = pack((f, x), 'b * d')
-
-        x = self.transformer(x)
-
-        _, x = unpack(x, ps, 'b * d')
-        x = reduce(x, 'b n d -> b d', 'mean')
-
-        x = self.to_latent(x)
-        return self.linear_head(x)
-
-if __name__ == '__main__':
-    vit = SimpleViT(
-        num_classes = 1000,
-        image_size = 256,
-        patch_size = 8,
-        freq_patch_size = 8,
-        dim = 1024,
-        depth = 1,
-        heads = 8,
-        mlp_dim = 2048,
-    )
-
-    images = torch.randn(8, 3, 256, 256)
-
-    logits = vit(images)

vit_pytorch/simple_vit_with_hyper_connections.py

@@ -1,233 +0,0 @@
-"""
-ViT + Hyper-Connections + Register Tokens
-https://arxiv.org/abs/2409.19606
-"""
-
-import torch
-from torch import nn, tensor
-from torch.nn import Module, ModuleList
-
-from einops import rearrange, repeat, reduce, einsum, pack, unpack
-from einops.layers.torch import Rearrange
-
-# b - batch, h - heads, n - sequence, e - expansion rate / residual streams, d - feature dimension
-
-# helpers
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-def posemb_sincos_2d(h, w, dim, temperature: int = 10000, dtype = torch.float32):
-    y, x = torch.meshgrid(torch.arange(h), torch.arange(w), indexing="ij")
-    assert (dim % 4) == 0, "feature dimension must be multiple of 4 for sincos emb"
-    omega = torch.arange(dim // 4) / (dim // 4 - 1)
-    omega = 1.0 / (temperature ** omega)
-
-    y = y.flatten()[:, None] * omega[None, :]
-    x = x.flatten()[:, None] * omega[None, :]
-    pe = torch.cat((x.sin(), x.cos(), y.sin(), y.cos()), dim=1)
-    return pe.type(dtype)
-
-# hyper connections
-
-class HyperConnection(Module):
-    def __init__(
-        self,
-        dim,
-        num_residual_streams,
-        layer_index
-    ):
-        """ Appendix J - Algorithm 2, Dynamic only """
-        super().__init__()
-
-        self.norm = nn.LayerNorm(dim, bias = False)
-
-        self.num_residual_streams = num_residual_streams
-        self.layer_index = layer_index
-
-        self.static_beta = nn.Parameter(torch.ones(num_residual_streams))
-
-        init_alpha0 = torch.zeros((num_residual_streams, 1))
-        init_alpha0[layer_index % num_residual_streams, 0] = 1.
-
-        self.static_alpha = nn.Parameter(torch.cat([init_alpha0, torch.eye(num_residual_streams)], dim = 1))
-
-        self.dynamic_alpha_fn = nn.Parameter(torch.zeros(dim, num_residual_streams + 1))
-        self.dynamic_alpha_scale = nn.Parameter(tensor(1e-2))
-        self.dynamic_beta_fn = nn.Parameter(torch.zeros(dim))
-        self.dynamic_beta_scale = nn.Parameter(tensor(1e-2))
-
-    def width_connection(self, residuals):
-        normed = self.norm(residuals)
-
-        wc_weight = (normed @ self.dynamic_alpha_fn).tanh()
-        dynamic_alpha = wc_weight * self.dynamic_alpha_scale
-        alpha = dynamic_alpha + self.static_alpha
-
-        dc_weight = (normed @ self.dynamic_beta_fn).tanh()
-        dynamic_beta = dc_weight * self.dynamic_beta_scale
-        beta = dynamic_beta + self.static_beta
-
-        # width connection
-        mix_h = einsum(alpha, residuals, '... e1 e2, ... e1 d -> ... e2 d')
-
-        branch_input, residuals = mix_h[..., 0, :], mix_h[..., 1:, :]
-
-        return branch_input, residuals, beta
-
-    def depth_connection(
-        self,
-        branch_output,
-        residuals,
-        beta
-    ):
-        return einsum(branch_output, beta, "b n d, b n e -> b n e d") + residuals
-
-# classes
-
-class FeedForward(Module):
-    def __init__(self, dim, hidden_dim):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Linear(hidden_dim, dim),
-        )
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(Module):
-    def __init__(self, dim, heads = 8, dim_head = 64):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-        self.norm = nn.LayerNorm(dim)
-
-        self.attend = nn.Softmax(dim = -1)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-        self.to_out = nn.Linear(inner_dim, dim, bias = False)
-
-    def forward(self, x):
-        x = self.norm(x)
-
-        qkv = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-
-        attn = self.attend(dots)
-
-        out = torch.matmul(attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim, num_residual_streams):
-        super().__init__()
-
-        self.num_residual_streams = num_residual_streams
-
-        self.norm = nn.LayerNorm(dim)
-        self.layers = ModuleList([])
-
-        for layer_index in range(depth):
-            self.layers.append(nn.ModuleList([
-                HyperConnection(dim, num_residual_streams, layer_index),
-                Attention(dim, heads = heads, dim_head = dim_head),
-                HyperConnection(dim, num_residual_streams, layer_index),
-                FeedForward(dim, mlp_dim)
-            ]))
-
-    def forward(self, x):
-
-        x = repeat(x, 'b n d -> b n e d', e = self.num_residual_streams)
-
-        for attn_hyper_conn, attn, ff_hyper_conn, ff in self.layers:
-
-            x, attn_res, beta = attn_hyper_conn.width_connection(x)
-
-            x = attn(x)
-
-            x = attn_hyper_conn.depth_connection(x, attn_res, beta)
-
-            x, ff_res, beta = ff_hyper_conn.width_connection(x)
-
-            x = ff(x)
-
-            x = ff_hyper_conn.depth_connection(x, ff_res, beta)
-
-        x = reduce(x, 'b n e d -> b n d', 'sum')
-
-        return self.norm(x)
-
-class SimpleViT(nn.Module):
-    def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, num_residual_streams, num_register_tokens = 4, channels = 3, dim_head = 64):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(patch_size)
-
-        assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
-
-        patch_dim = channels * patch_height * patch_width
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange("b c (h p1) (w p2) -> b (h w) (p1 p2 c)", p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.register_tokens = nn.Parameter(torch.randn(num_register_tokens, dim))
-
-        self.pos_embedding = posemb_sincos_2d(
-            h = image_height // patch_height,
-            w = image_width // patch_width,
-            dim = dim,
-        ) 
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, num_residual_streams)
-
-        self.pool = "mean"
-        self.to_latent = nn.Identity()
-
-        self.linear_head = nn.Linear(dim, num_classes)
-
-    def forward(self, img):
-        batch, device = img.shape[0], img.device
-
-        x = self.to_patch_embedding(img)
-        x += self.pos_embedding.to(x)
-
-        r = repeat(self.register_tokens, 'n d -> b n d', b = batch)
-
-        x, ps = pack([x, r], 'b * d')
-
-        x = self.transformer(x)
-
-        x, _ = unpack(x, ps, 'b * d')
-
-        x = x.mean(dim = 1)
-
-        x = self.to_latent(x)
-        return self.linear_head(x)
-
-# main
-
-if __name__ == '__main__':
-    vit = SimpleViT(
-        num_classes = 1000,
-        image_size = 256,
-        patch_size = 8,
-        dim = 1024,
-        depth = 12,
-        heads = 8,
-        mlp_dim = 2048,
-        num_residual_streams = 8
-    )
-
-    images = torch.randn(3, 3, 256, 256)
-
-    logits = vit(images)

vit_pytorch/simple_vit_with_patch_dropout.py

@@ -1,141 +0,0 @@
-import torch
-from torch import nn
-
-from einops import rearrange
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-def posemb_sincos_2d(patches, temperature = 10000, dtype = torch.float32):
-    _, h, w, dim, device, dtype = *patches.shape, patches.device, patches.dtype
-
-    y, x = torch.meshgrid(torch.arange(h, device = device), torch.arange(w, device = device), indexing = 'ij')
-    assert (dim % 4) == 0, 'feature dimension must be multiple of 4 for sincos emb'
-    omega = torch.arange(dim // 4, device = device) / (dim // 4 - 1)
-    omega = 1. / (temperature ** omega)
-
-    y = y.flatten()[:, None] * omega[None, :]
-    x = x.flatten()[:, None] * omega[None, :] 
-    pe = torch.cat((x.sin(), x.cos(), y.sin(), y.cos()), dim = 1)
-    return pe.type(dtype)
-
-# patch dropout
-
-class PatchDropout(nn.Module):
-    def __init__(self, prob):
-        super().__init__()
-        assert 0 <= prob < 1.
-        self.prob = prob
-
-    def forward(self, x):
-        if not self.training or self.prob == 0.:
-            return x
-
-        b, n, _, device = *x.shape, x.device
-
-        batch_indices = torch.arange(b, device = device)
-        batch_indices = rearrange(batch_indices, '... -> ... 1')
-        num_patches_keep = max(1, int(n * (1 - self.prob)))
-        patch_indices_keep = torch.randn(b, n, device = device).topk(num_patches_keep, dim = -1).indices
-
-        return x[batch_indices, patch_indices_keep]
-
-# classes
-
-class FeedForward(nn.Module):
-    def __init__(self, dim, hidden_dim):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Linear(hidden_dim, dim),
-        )
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(nn.Module):
-    def __init__(self, dim, heads = 8, dim_head = 64):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-        self.norm = nn.LayerNorm(dim)
-
-        self.attend = nn.Softmax(dim = -1)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-        self.to_out = nn.Linear(inner_dim, dim, bias = False)
-
-    def forward(self, x):
-        x = self.norm(x)
-
-        qkv = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-
-        attn = self.attend(dots)
-
-        out = torch.matmul(attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(nn.Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim)
-        self.layers = nn.ModuleList([])
-        for _ in range(depth):
-            self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head),
-                FeedForward(dim, mlp_dim)
-            ]))
-    def forward(self, x):
-        for attn, ff in self.layers:
-            x = attn(x) + x
-            x = ff(x) + x
-        return self.norm(x)
-
-class SimpleViT(nn.Module):
-    def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, channels = 3, dim_head = 64, patch_dropout = 0.5):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(patch_size)
-
-        assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
-
-        num_patches = (image_height // patch_height) * (image_width // patch_width)
-        patch_dim = channels * patch_height * patch_width
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange('b c (h p1) (w p2) -> b h w (p1 p2 c)', p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim)
-        )
-
-        self.patch_dropout = PatchDropout(patch_dropout)
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim)
-
-        self.to_latent = nn.Identity()
-        self.linear_head = nn.Linear(dim, num_classes)
-
-    def forward(self, img):
-        *_, h, w, dtype = *img.shape, img.dtype
-
-        x = self.to_patch_embedding(img)
-        pe = posemb_sincos_2d(x)
-        x = rearrange(x, 'b ... d -> b (...) d') + pe
-
-        x = self.patch_dropout(x)
-
-        x = self.transformer(x)
-        x = x.mean(dim = 1)
-
-        x = self.to_latent(x)
-        return self.linear_head(x)

vit_pytorch/simple_vit_with_qk_norm.py

@@ -1,141 +0,0 @@
-import torch
-from torch import nn
-import torch.nn.functional as F
-
-from einops import rearrange
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-def posemb_sincos_2d(h, w, dim, temperature: int = 10000, dtype = torch.float32):
-    y, x = torch.meshgrid(torch.arange(h), torch.arange(w), indexing="ij")
-    assert (dim % 4) == 0, "feature dimension must be multiple of 4 for sincos emb"
-    omega = torch.arange(dim // 4) / (dim // 4 - 1)
-    omega = 1.0 / (temperature ** omega)
-
-    y = y.flatten()[:, None] * omega[None, :]
-    x = x.flatten()[:, None] * omega[None, :]
-    pe = torch.cat((x.sin(), x.cos(), y.sin(), y.cos()), dim=1)
-    return pe.type(dtype)
-
-# they use a query-key normalization that is equivalent to rms norm (no mean-centering, learned gamma), from vit 22B paper
-
-# in latest tweet, seem to claim more stable training at higher learning rates
-# unsure if this has taken off within Brain, or it has some hidden drawback
-
-class RMSNorm(nn.Module):
-    def __init__(self, heads, dim):
-        super().__init__()
-        self.scale = dim ** 0.5
-        self.gamma = nn.Parameter(torch.ones(heads, 1, dim) / self.scale)
-
-    def forward(self, x):
-        normed = F.normalize(x, dim = -1)
-        return normed * self.scale * self.gamma
-
-# classes
-
-class FeedForward(nn.Module):
-    def __init__(self, dim, hidden_dim):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Linear(hidden_dim, dim),
-        )
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(nn.Module):
-    def __init__(self, dim, heads = 8, dim_head = 64):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        self.heads = heads
-        self.norm = nn.LayerNorm(dim)
-
-        self.attend = nn.Softmax(dim = -1)
-
-        self.q_norm = RMSNorm(heads, dim_head)
-        self.k_norm = RMSNorm(heads, dim_head)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-        self.to_out = nn.Linear(inner_dim, dim, bias = False)
-
-    def forward(self, x):
-        x = self.norm(x)
-
-        qkv = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        q = self.q_norm(q)
-        k = self.k_norm(k)
-
-        dots = torch.matmul(q, k.transpose(-1, -2))
-
-        attn = self.attend(dots)
-
-        out = torch.matmul(attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(nn.Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim)
-        self.layers = nn.ModuleList([])
-        for _ in range(depth):
-            self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head),
-                FeedForward(dim, mlp_dim)
-            ]))
-    def forward(self, x):
-        for attn, ff in self.layers:
-            x = attn(x) + x
-            x = ff(x) + x
-        return self.norm(x)
-
-class SimpleViT(nn.Module):
-    def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, channels = 3, dim_head = 64):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(patch_size)
-
-        assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
-
-        patch_dim = channels * patch_height * patch_width
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange("b c (h p1) (w p2) -> b (h w) (p1 p2 c)", p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.pos_embedding = posemb_sincos_2d(
-            h = image_height // patch_height,
-            w = image_width // patch_width,
-            dim = dim,
-        ) 
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim)
-
-        self.pool = "mean"
-        self.to_latent = nn.Identity()
-
-        self.linear_head = nn.LayerNorm(dim)
-
-    def forward(self, img):
-        device = img.device
-
-        x = self.to_patch_embedding(img)
-        x += self.pos_embedding.to(device, dtype=x.dtype)
-
-        x = self.transformer(x)
-        x = x.mean(dim = 1)
-
-        x = self.to_latent(x)
-        return self.linear_head(x)

vit_pytorch/simple_vit_with_register_tokens.py

@@ -1,134 +0,0 @@
-"""
-    Vision Transformers Need Registers
-    https://arxiv.org/abs/2309.16588
-"""
-
-import torch
-from torch import nn
-
-from einops import rearrange, repeat, pack, unpack
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-def posemb_sincos_2d(h, w, dim, temperature: int = 10000, dtype = torch.float32):
-    y, x = torch.meshgrid(torch.arange(h), torch.arange(w), indexing="ij")
-    assert (dim % 4) == 0, "feature dimension must be multiple of 4 for sincos emb"
-    omega = torch.arange(dim // 4) / (dim // 4 - 1)
-    omega = 1.0 / (temperature ** omega)
-
-    y = y.flatten()[:, None] * omega[None, :]
-    x = x.flatten()[:, None] * omega[None, :]
-    pe = torch.cat((x.sin(), x.cos(), y.sin(), y.cos()), dim=1)
-    return pe.type(dtype)
-
-# classes
-
-class FeedForward(nn.Module):
-    def __init__(self, dim, hidden_dim):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Linear(hidden_dim, dim),
-        )
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(nn.Module):
-    def __init__(self, dim, heads = 8, dim_head = 64):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-        self.norm = nn.LayerNorm(dim)
-
-        self.attend = nn.Softmax(dim = -1)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-        self.to_out = nn.Linear(inner_dim, dim, bias = False)
-
-    def forward(self, x):
-        x = self.norm(x)
-
-        qkv = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-
-        attn = self.attend(dots)
-
-        out = torch.matmul(attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(nn.Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim)
-        self.layers = nn.ModuleList([])
-        for _ in range(depth):
-            self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head),
-                FeedForward(dim, mlp_dim)
-            ]))
-    def forward(self, x):
-        for attn, ff in self.layers:
-            x = attn(x) + x
-            x = ff(x) + x
-        return self.norm(x)
-
-class SimpleViT(nn.Module):
-    def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, num_register_tokens = 4, channels = 3, dim_head = 64):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(patch_size)
-
-        assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
-
-        patch_dim = channels * patch_height * patch_width
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange("b c (h p1) (w p2) -> b (h w) (p1 p2 c)", p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.register_tokens = nn.Parameter(torch.randn(num_register_tokens, dim))
-
-        self.pos_embedding = posemb_sincos_2d(
-            h = image_height // patch_height,
-            w = image_width // patch_width,
-            dim = dim,
-        ) 
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim)
-
-        self.pool = "mean"
-        self.to_latent = nn.Identity()
-
-        self.linear_head = nn.Linear(dim, num_classes)
-
-    def forward(self, img):
-        batch, device = img.shape[0], img.device
-
-        x = self.to_patch_embedding(img)
-        x += self.pos_embedding.to(device, dtype=x.dtype)
-
-        r = repeat(self.register_tokens, 'n d -> b n d', b = batch)
-
-        x, ps = pack([x, r], 'b * d')
-
-        x = self.transformer(x)
-
-        x, _ = unpack(x, ps, 'b * d')
-
-        x = x.mean(dim = 1)
-
-        x = self.to_latent(x)
-        return self.linear_head(x)

vit_pytorch/simple_vit_with_value_residual.py

@@ -1,159 +0,0 @@
-import torch
-from torch import nn
-from torch.nn import Module, ModuleList
-
-from einops import rearrange
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def exists(v):
-    return v is not None
-
-def default(v, d):
-    return v if exists(v) else d
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-def posemb_sincos_2d(h, w, dim, temperature: int = 10000, dtype = torch.float32):
-    y, x = torch.meshgrid(torch.arange(h), torch.arange(w), indexing="ij")
-    assert (dim % 4) == 0, "feature dimension must be multiple of 4 for sincos emb"
-    omega = torch.arange(dim // 4) / (dim // 4 - 1)
-    omega = 1.0 / (temperature ** omega)
-
-    y = y.flatten()[:, None] * omega[None, :]
-    x = x.flatten()[:, None] * omega[None, :]
-    pe = torch.cat((x.sin(), x.cos(), y.sin(), y.cos()), dim=1)
-    return pe.type(dtype)
-
-# classes
-
-def FeedForward(dim, hidden_dim):
-    return nn.Sequential(
-        nn.LayerNorm(dim),
-        nn.Linear(dim, hidden_dim),
-        nn.GELU(),
-        nn.Linear(hidden_dim, dim),
-    )
-
-class Attention(Module):
-    def __init__(self, dim, heads = 8, dim_head = 64, learned_value_residual_mix = False):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-        self.norm = nn.LayerNorm(dim)
-
-        self.attend = nn.Softmax(dim = -1)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-        self.to_out = nn.Linear(inner_dim, dim, bias = False)
-
-        self.to_residual_mix = nn.Sequential(
-            nn.Linear(dim, heads),
-            nn.Sigmoid(),
-            Rearrange('b n h -> b h n 1')
-        ) if learned_value_residual_mix else (lambda _: 0.5)
-
-    def forward(self, x, value_residual = None):
-        x = self.norm(x)
-
-        qkv = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        if exists(value_residual):
-            mix = self.to_residual_mix(x)
-            v = v * mix + value_residual * (1. - mix)
-
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-
-        attn = self.attend(dots)
-
-        out = torch.matmul(attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-
-        return self.to_out(out), v
-
-class Transformer(Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim)
-        self.layers = ModuleList([])
-        for i in range(depth):
-            is_first = i == 0
-            self.layers.append(ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, learned_value_residual_mix = not is_first),
-                FeedForward(dim, mlp_dim)
-            ]))
-    def forward(self, x):
-        value_residual = None
-
-        for attn, ff in self.layers:
-
-            attn_out, values = attn(x, value_residual = value_residual)
-            value_residual = default(value_residual, values)
-
-            x = attn_out + x
-            x = ff(x) + x
-
-        return self.norm(x)
-
-class SimpleViT(Module):
-    def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, channels = 3, dim_head = 64):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(patch_size)
-
-        assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
-
-        patch_dim = channels * patch_height * patch_width
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange("b c (h p1) (w p2) -> b (h w) (p1 p2 c)", p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.pos_embedding = posemb_sincos_2d(
-            h = image_height // patch_height,
-            w = image_width // patch_width,
-            dim = dim,
-        ) 
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim)
-
-        self.pool = "mean"
-        self.to_latent = nn.Identity()
-
-        self.linear_head = nn.Linear(dim, num_classes)
-
-    def forward(self, img):
-        device = img.device
-
-        x = self.to_patch_embedding(img)
-        x += self.pos_embedding.to(device, dtype=x.dtype)
-
-        x = self.transformer(x)
-        x = x.mean(dim = 1)
-
-        x = self.to_latent(x)
-        return self.linear_head(x)
-
-# quick test
-
-if __name__ == '__main__':
-    v = SimpleViT(
-        num_classes = 1000,
-        image_size = 256,
-        patch_size = 8,
-        dim = 1024,
-        depth = 6,
-        heads = 8,
-        mlp_dim = 2048,
-    )
-
-    images = torch.randn(2, 3, 256, 256)
-
-    logits = v(images)

vit_pytorch/t2t.py

@@ -61,7 +61,10 @@ class T2TViT(nn.Module):
         self.pool = pool
         self.to_latent = nn.Identity()
 
-        self.mlp_head = nn.Linear(dim, num_classes)
+        self.mlp_head = nn.Sequential(
+            nn.LayerNorm(dim),
+            nn.Linear(dim, num_classes)
+        )
 
     def forward(self, img):
         x = self.to_patch_embedding(img)

vit_pytorch/twins_svt.py

@@ -42,11 +42,20 @@ class LayerNorm(nn.Module):
         mean = torch.mean(x, dim = 1, keepdim = True)
         return (x - mean) / (var + self.eps).sqrt() * self.g + self.b
 
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = LayerNorm(dim)
+        self.fn = fn
+
+    def forward(self, x, **kwargs):
+        x = self.norm(x)
+        return self.fn(x, **kwargs)
+
 class FeedForward(nn.Module):
     def __init__(self, dim, mult = 4, dropout = 0.):
         super().__init__()
         self.net = nn.Sequential(
-            LayerNorm(dim),
             nn.Conv2d(dim, dim * mult, 1),
             nn.GELU(),
             nn.Dropout(dropout),
@@ -62,12 +71,7 @@ class PatchEmbedding(nn.Module):
         self.dim = dim
         self.dim_out = dim_out
         self.patch_size = patch_size
-
-        self.proj = nn.Sequential(
-            LayerNorm(patch_size ** 2 * dim),
-            nn.Conv2d(patch_size ** 2 * dim, dim_out, 1),
-            LayerNorm(dim_out)
-        )
+        self.proj = nn.Conv2d(patch_size ** 2 * dim, dim_out, 1)
 
     def forward(self, fmap):
         p = self.patch_size
@@ -90,7 +94,6 @@ class LocalAttention(nn.Module):
         self.heads = heads
         self.scale = dim_head ** -0.5
 
-        self.norm = LayerNorm(dim)
         self.to_q = nn.Conv2d(dim, inner_dim, 1, bias = False)
         self.to_kv = nn.Conv2d(dim, inner_dim * 2, 1, bias = False)
 
@@ -100,8 +103,6 @@ class LocalAttention(nn.Module):
         )
 
     def forward(self, fmap):
-        fmap = self.norm(fmap)
-
         shape, p = fmap.shape, self.patch_size
         b, n, x, y, h = *shape, self.heads
         x, y = map(lambda t: t // p, (x, y))
@@ -126,8 +127,6 @@ class GlobalAttention(nn.Module):
         self.heads = heads
         self.scale = dim_head ** -0.5
 
-        self.norm = LayerNorm(dim)
-
         self.to_q = nn.Conv2d(dim, inner_dim, 1, bias = False)
         self.to_kv = nn.Conv2d(dim, inner_dim * 2, k, stride = k, bias = False)
 
@@ -139,8 +138,6 @@ class GlobalAttention(nn.Module):
         )
 
     def forward(self, x):
-        x = self.norm(x)
-
         shape = x.shape
         b, n, _, y, h = *shape, self.heads
         q, k, v = (self.to_q(x), *self.to_kv(x).chunk(2, dim = 1))
@@ -162,10 +159,10 @@ class Transformer(nn.Module):
         self.layers = nn.ModuleList([])
         for _ in range(depth):
             self.layers.append(nn.ModuleList([
-                Residual(LocalAttention(dim, heads = heads, dim_head = dim_head, dropout = dropout, patch_size = local_patch_size)) if has_local else nn.Identity(),
-                Residual(FeedForward(dim, mlp_mult, dropout = dropout)) if has_local else nn.Identity(),
-                Residual(GlobalAttention(dim, heads = heads, dim_head = dim_head, dropout = dropout, k = global_k)),
-                Residual(FeedForward(dim, mlp_mult, dropout = dropout))
+                Residual(PreNorm(dim, LocalAttention(dim, heads = heads, dim_head = dim_head, dropout = dropout, patch_size = local_patch_size))) if has_local else nn.Identity(),
+                Residual(PreNorm(dim, FeedForward(dim, mlp_mult, dropout = dropout))) if has_local else nn.Identity(),
+                Residual(PreNorm(dim, GlobalAttention(dim, heads = heads, dim_head = dim_head, dropout = dropout, k = global_k))),
+                Residual(PreNorm(dim, FeedForward(dim, mlp_mult, dropout = dropout)))
             ]))
     def forward(self, x):
         for local_attn, ff1, global_attn, ff2 in self.layers:

vit_pytorch/vaat.py

@@ -1,786 +0,0 @@
-# vision-audio-action transformer - vaat
-
-from __future__ import annotations
-from contextlib import nullcontext
-
-import torch
-import torch.nn.functional as F
-from torch import nn, cat, stack, arange, tensor
-from torch.nn import Module, ModuleList
-
-from torchaudio.transforms import Spectrogram
-
-from einops import rearrange, repeat, reduce, pack, unpack
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def exists(v):
-    return v is not None
-
-def default(v, d):
-    return v if exists(v) else d
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-# 2d sinusoidal positional embedding
-# simple vit paper shows it is good enough compared to learned
-
-def posemb_sincos_2d(
-    patches,
-    temperature = 10000,
-    dtype = torch.float32
-):
-    _, h, w, dim, device, dtype = *patches.shape, patches.device, patches.dtype
-
-    y, x = torch.meshgrid(arange(h, device = device), torch.arange(w, device = device), indexing = 'ij')
-    assert (dim % 4) == 0, 'feature dimension must be multiple of 4 for sincos emb'
-
-    omega = arange(dim // 4, device = device) / (dim // 4 - 1)
-    omega = temperature ** -omega
-
-    y = y.flatten()[:, None] * omega[None, :]
-    x = x.flatten()[:, None] * omega[None, :] 
-
-    pe = cat((x.sin(), x.cos(), y.sin(), y.cos()), dim = 1)
-    pe = pe.type(dtype)
-
-    return rearrange(pe, '(h w) d -> h w d', h = h, w = w)
-
-# classes
-
-class FiLM(Module):
-    def __init__(
-        self,
-        dim,
-    ):
-        super().__init__()
-        proj = nn.Linear(dim, dim * 2)
-
-        self.to_gamma_beta = nn.Sequential(
-            proj,
-            Rearrange('b (two d) -> two b 1 d', two = 2)
-        )
-
-        nn.init.zeros_(proj.weight)
-        nn.init.zeros_(proj.bias)
-
-    def forward(self, tokens, cond):
-        gamma, beta = self.to_gamma_beta(cond)
-
-        return tokens * gamma + beta
-
-class FeedForward(Module):
-    def __init__(
-        self,
-        dim,
-        hidden_dim,
-        dropout = 0.
-    ):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Dropout(dropout),
-            nn.Linear(hidden_dim, dim),
-            nn.Dropout(dropout)
-        )
-
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(Module):
-    def __init__(
-        self,
-        dim,
-        heads = 8,
-        dim_head = 64,
-        dropout = 0.,
-        dim_context = None,
-        cross_attend = False
-    ):
-        super().__init__()
-        dim_context = default(dim_context, dim)
-        inner_dim = dim_head *  heads
-        project_out = not (heads == 1 and dim_head == dim)
-
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-
-        self.norm = nn.LayerNorm(dim)
-
-        self.cross_attend = cross_attend
-        self.context_norm = nn.LayerNorm(dim_context) if cross_attend else None
-
-        self.attend = nn.Softmax(dim = -1)
-        self.dropout = nn.Dropout(dropout)
-
-        self.to_q = nn.Linear(dim, inner_dim, bias = False)
-        self.to_kv = nn.Linear(dim_context, inner_dim * 2, bias = False)
-
-        self.to_out_gates = nn.Sequential(
-            nn.Linear(dim, heads),
-            Rearrange('b ... h -> b h ... 1'),
-            nn.Sigmoid()
-        )
-
-        self.to_out = nn.Sequential(
-            nn.Linear(inner_dim, dim),
-            nn.Dropout(dropout)
-        ) if project_out else nn.Identity()
-
-    def forward(self, x, context = None):
-
-        assert not (self.cross_attend ^ exists(context)), 'context must be passed in if cross attending, or vice versa'
-
-        x = self.norm(x)
-
-        # handle norming of context for cross attention
-
-        kv_input = x
-
-        if self.cross_attend:
-            context = self.context_norm(context)
-            kv_input = context
-
-        # project for queries, keys, values
-
-        qkv = (self.to_q(x), *self.to_kv(kv_input).chunk(2, dim = -1))
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-
-        attn = self.attend(dots)
-        attn = self.dropout(attn)
-
-        out = torch.matmul(attn, v)
-
-        out = out * self.to_out_gates(x)
-
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(Module):
-    def __init__(
-        self,
-        dim,
-        depth,
-        heads,
-        dim_head,
-        mlp_dim,
-        dropout = 0.
-    ):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim)
-        self.layers = ModuleList([])
-
-        for _ in range(depth):
-            self.layers.append(ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_dim, dropout = dropout)
-            ]))
-
-    def forward(
-        self,
-        x,
-        return_hiddens = False
-    ):
-
-        hiddens = []
-
-        for attn, ff in self.layers:
-            hiddens.append(x)
-
-            x = attn(x) + x
-            x = ff(x) + x
-
-        x = self.norm(x)
-
-        if not return_hiddens:
-            return x
-
-        return x, hiddens
-
-class AST(Module):
-    # audio spectrogram transformer https://arxiv.org/abs/2104.01778
-
-    def __init__(
-        self,
-        dim,
-        depth,
-        mlp_dim,
-        num_classes = None,
-        patch_size = 16,
-        dim_head = 64,
-        heads = 8,
-        dropout = 0.,
-        accept_spec = False,
-        accept_spec_time_first = True,
-        spec_n_fft = 128,
-        spec_power = 2,
-        spec_win_length = 24,
-        spec_hop_length = None,
-        spec_pad = 0,
-        spec_center = True,
-        spec_pad_mode = 'reflect',
-        num_register_tokens = 4
-    ):
-        super().__init__()
-        self.dim = dim
-        self.depth = depth
-
-        patch_height, patch_width = pair(patch_size)
-        patch_input_dim = patch_height * patch_width
-
-        self.patch_size = (patch_height, patch_width)
-
-        self.to_patch_tokens = nn.Sequential(
-            Rearrange('b (h p1) (w p2) -> b h w (p1 p2)', p1 = self.patch_size[0], p2 = self.patch_size[1]),
-            nn.LayerNorm(patch_input_dim),
-            nn.Linear(patch_input_dim, dim),
-            nn.LayerNorm(dim)
-        )
-
-        self.accept_spec = accept_spec
-        self.accept_spec_time_first = accept_spec_time_first
-
-        self.spec = Spectrogram(
-            n_fft = spec_n_fft,
-            power = spec_power,
-            win_length = spec_win_length,
-            hop_length = spec_hop_length,
-            pad = spec_pad,
-            center = spec_center,
-            pad_mode = spec_pad_mode
-        )
-
-        self.transformer = Transformer(
-            dim = dim,
-            depth = depth,
-            dim_head = dim_head,
-            heads = heads,
-            mlp_dim = mlp_dim,
-            dropout = dropout,
-        )
-
-        self.final_norm = nn.LayerNorm(dim)
-
-        self.mlp_head = nn.Linear(dim, num_classes) if exists(num_classes) else nn.Identity()
-
-        self.register_tokens = nn.Parameter(torch.randn(num_register_tokens, dim) * 1e-2)
-
-    def forward(
-        self,
-        raw_audio_or_spec, # (b t) | (b f t)
-        return_hiddens = False
-    ):
-        batch, device = raw_audio_or_spec.shape[0], raw_audio_or_spec.device
-
-        assert (self.accept_spec and raw_audio_or_spec.ndim == 3) or (not self.accept_spec and raw_audio_or_spec.ndim == 2)
-
-        if self.accept_spec:
-            spec = rearrange(raw_audio_or_spec, 'b t f -> b f t')
-        else:
-            spec = self.spec(raw_audio_or_spec)
-
-        # automatically crop if audio does not yield a 2d spectrogram that is divisible by patch sizes
-
-        height, width = spec.shape[-2:]
-        patch_height, patch_width = self.patch_size
-
-        rounded_height = height // patch_height * patch_height
-        rounded_width = width // patch_width * patch_width
-
-        spec = spec[..., :rounded_height, :rounded_width]
-
-        # to patches
-
-        tokens = self.to_patch_tokens(spec)
-
-        # get number of patches along height and width
-
-        _, num_patch_height, num_patch_width, _ = tokens.shape
-
-        # 2d sinusoidal positional embedding
-
-        tokens = tokens + posemb_sincos_2d(tokens)
-
-        tokens = rearrange(tokens, 'b ... c -> b (...) c')
-
-        # register tokens
-
-        register_tokens = repeat(self.register_tokens, 'n d -> b n d', b = batch)
-
-        tokens, packed_shape = pack((register_tokens, tokens), 'b * d')
-
-        # attention
-
-        attended, hiddens = self.transformer(tokens, return_hiddens = True)
-
-        # final global average and norm (most recent papers show this is superior to CLS token)
-
-        normed = self.final_norm(attended)
-
-        if return_hiddens:
-            return normed, stack(hiddens)
-
-        register_tokens, normed = unpack(normed, packed_shape, 'b * d')
-
-        pooled = reduce(normed, 'b n d -> b d', 'mean')
-
-        maybe_logits = self.mlp_head(pooled)
-
-        return maybe_logits
-
-class ViT(Module):
-    def __init__(
-        self,
-        *,
-        image_size,
-        patch_size,
-        num_classes,
-        dim,
-        depth,
-        heads,
-        mlp_dim,
-        pool = 'cls',
-        channels = 3,
-        dim_head = 64,
-        dropout = 0.,
-        emb_dropout = 0.,
-        num_register_tokens = 0
-    ):
-        super().__init__()
-        self.dim = dim
-        self.depth = depth
-
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(patch_size)
-
-        assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
-
-        num_patches = (image_height // patch_height) * (image_width // patch_width)
-        patch_dim = channels * patch_height * patch_width
-        assert pool in {'cls', 'mean'}, 'pool type must be either cls (cls token) or mean (mean pooling)'
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.pos_embedding = nn.Parameter(torch.randn(num_patches, dim))
-        self.cls_token = nn.Parameter(torch.randn(dim))
-        self.dropout = nn.Dropout(emb_dropout)
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout)
-
-        self.pool = pool
-        self.to_latent = nn.Identity()
-
-        self.mlp_head = nn.Linear(dim, num_classes)
-
-        self.register_tokens = nn.Parameter(torch.randn(num_register_tokens, dim) * 1e-2)
-
-    def forward(self, img, return_hiddens = False):
-        x = self.to_patch_embedding(img)
-        b, n, _ = x.shape
-
-        x += self.pos_embedding[:n]
-
-        cls_tokens = repeat(self.cls_token, 'd -> b d', b = b)
-        register_tokens = repeat(self.register_tokens, 'n d -> b n d', b = b)
-
-        x, packed_shape = pack((register_tokens, cls_tokens, x), 'b * d')
-
-        x = self.dropout(x)
-
-        x, hiddens = self.transformer(x, return_hiddens = True)
-
-        # return the representation trajectory
-
-        if return_hiddens:
-            return x, stack(hiddens)
-
-        register_tokens, cls_tokens, x = unpack(x, packed_shape, 'b * d')
-
-        x = x.mean(dim = 1) if self.pool == 'mean' else cls_tokens
-
-        x = self.to_latent(x)
-
-        return self.mlp_head(x)
-
-# proposed VAT
-
-# https://openreview.net/forum?id=TalHOvvLZu
-# simple way to get SOTA on Libero dataset (beating fine-tuned pi-zero)
-
-class VAAT(Module):
-    def __init__(
-        self,
-        vit: ViT | dict,
-        ast: AST | dict,
-        *,
-        dim,
-        depth,
-        heads,
-        dim_head,
-        dim_action,
-        mlp_dim,
-        num_image_views = None,
-        num_audio_views = None,
-        num_tasks = None,
-        dim_extra_token = None,
-        num_register_tokens = 4,
-        action_chunk_len = 7,
-        time_seq_len = 1,
-        dropout = 0.,
-        add_self_attn = True,  # in the paper, they didn't have any ways for the action token to exchange information with the extra token, so we'll just add it as an option
-        self_attn_heads = 4,
-        self_attn_dim_head = 32,
-        ast_layer_indices: tuple[int, ...] | None = None,
-        vit_layer_indices: tuple[int, ...] | None = None
-    ):
-        super().__init__()
-
-        # vit
-
-        if isinstance(vit, dict):
-            vit = ViT(**vit)
-
-        self.vit = vit
-
-        vit_dim = vit.dim
-
-        assert vit.depth == depth or exists(vit_layer_indices), f'if the VAAT depth is not equal to the ViT depth, you must pass in the indices from the ViT to be layered to the VAAT in order from bottom to top'
-
-        vit_layer_indices = default(vit_layer_indices, tuple(range(depth)))
-
-        assert len(vit_layer_indices) == depth, f'number of vit layer indices {len(vit_layer_indices)} does not much the VAT depth {depth}'
-
-        self.register_buffer('vit_layer_indices', tensor(vit_layer_indices), persistent = False)
-
-        # ast
-
-        if isinstance(ast, dict):
-            ast = AST(**ast)
-
-        self.ast = ast
-
-        ast_dim = ast.dim
-
-        self.ast_accept_spec = ast.accept_spec
-
-        assert ast.depth == depth or exists(ast_layer_indices), f'if the VAAT depth is not equal to the AST depth, you must pass in the indices from the AST to be layered to the VAAT in order from bottom to top'
-
-        ast_layer_indices = default(ast_layer_indices, tuple(range(depth)))
-
-        assert len(ast_layer_indices) == depth, f'number of ast layer indices {len(ast_layer_indices)} does not much the VAAT depth {depth}'
-
-        self.register_buffer('ast_layer_indices', tensor(vit_layer_indices), persistent = False)
-
-        # handle maybe multiple frames
-
-        is_video = time_seq_len > 1
-
-        self.is_video = is_video
-        self.time_seq_len = time_seq_len
-        self.time_pos_emb = nn.Parameter(torch.randn(time_seq_len, vit_dim) * 1e-2) if is_video else None
-
-        # maybe view embeddings
-
-        self.image_view_emb = nn.Parameter(torch.randn(num_image_views, vit_dim) * 1e-2) if exists(num_image_views) and num_image_views > 1 else None
-
-        self.audio_view_emb = nn.Parameter(torch.randn(num_audio_views, ast_dim) * 1e-2) if exists(num_audio_views) and num_audio_views > 1 else None
-
-        # handle maybe task conditioning
-
-        self.has_tasks = exists(num_tasks)
-
-        if self.has_tasks:
-            self.task_emb = nn.Parameter(torch.randn(num_tasks, dim) * 1e-2)
-
-        # register tokens from Darcet et al.
-
-        self.register_tokens = nn.Parameter(torch.randn(num_register_tokens, dim) * 1e-2)
-
-        # to action tokens
-
-        self.action_pos_emb = nn.Parameter(torch.randn(action_chunk_len, dim) * 1e-2)
-
-        self.layers = ModuleList([])
-
-        for _ in range(depth):
-            maybe_film = FiLM(dim = dim) if self.has_tasks else None
-            maybe_self_attn = Attention(dim = dim, heads = self_attn_heads, dim_head = self_attn_dim_head, dropout = dropout) if add_self_attn else None
-
-            self.layers.append(ModuleList([
-                maybe_film,
-                maybe_self_attn,
-                Attention(dim = dim, dim_context = vit_dim, heads = heads, dim_head = dim_head, dropout = dropout, cross_attend = True),
-                Attention(dim = dim, dim_context = ast_dim, heads = heads, dim_head = dim_head, dropout = dropout, cross_attend = True),
-                FeedForward(dim = dim, hidden_dim = mlp_dim, dropout = dropout)
-            ]))
-
-        self.final_norm = nn.LayerNorm(dim)
-        self.to_pred_action = nn.Linear(dim, dim_action, bias = False)
-
-        # handle the extra token
-
-        self.accept_extra_token = exists(dim_extra_token)
-
-        if exists(dim_extra_token):
-            self.to_extra_token = nn.Linear(dim_extra_token, dim)
-
-    def forward(
-        self,
-        video_or_image,   # (b v? c t? h w)      - batch, views [wrist + third person or more], channels, maybe time, height, width
-        audio_or_spec,    # (b v? t) | (b v?f t) - batch, audio len | batch, spec freq, time
-        *,
-        extra = None,     # (b d)                - batch, dim extra     
-        tasks = None,     # (b)
-        actions = None,   # (b k d)              - batch, action chunk length, action dimension
-        return_hiddens = False,
-        freeze_vit = False,
-        freeze_ast = False
-    ):
-        batch = video_or_image.shape[0]
-        return_loss = exists(actions)
-
-        # handle some various input dimensions
-
-        if video_or_image.ndim == 4:
-            video_or_image = rearrange(video_or_image, 'b 1 c h w')
-
-        assert (
-            (video_or_image.ndim == 5 and not self.is_video) or
-            (video_or_image.ndim == 6 and self.is_video)
-        )
-
-        if video_or_image.ndim == 5:
-            video_or_image = rearrange(video_or_image, 'b v c h w -> b v c 1 h w')
-
-        assert video_or_image.shape[3] == self.time_seq_len
-
-        # audio shapes - adding view if impliciy to be 1
-
-        if audio_or_spec.ndim == 2 and not self.ast_accept_spec:
-            audio_or_spec = rearrange(audio_or_spec, 'b t -> b 1 t')
-
-        elif audio_or_spec.ndim == 3 and self.ast_accept_spec:
-            audio_or_spec = rearrange(audio_or_spec, 'b f t -> b 1 f t')
-
-        # to images
-
-        images = rearrange(video_or_image, 'b v c t h w -> b v t c h w')
-
-        images, image_packed_shape = pack([images], '* c h w')
-
-        # to audio
-
-        if self.ast_accept_spec:
-            audio_or_spec, audio_packed_shape = pack([audio_or_spec], '* f t')
-        else:
-            audio_or_spec, audio_packed_shape = pack([audio_or_spec], '* t')
-
-        # get representation trajectory from vit
-
-        vit_forward_context = torch.no_grad if freeze_vit else nullcontext
-
-        with vit_forward_context():
-            embed, hiddens = self.vit(images, return_hiddens = True)
-
-        hiddens = cat((hiddens, embed[None, ...]))
-
-        # extract the hiddens needed for the action cross attention
-
-        hiddens = hiddens[self.vit_layer_indices]
-
-        # unpack temporarily for embedding
-
-        hiddens, = unpack(hiddens, image_packed_shape, 'l * n d') # l for layers
-
-        # maybe add time embeddings
-
-        if self.is_video:
-            time_pos_emb = rearrange(self.time_pos_emb, 't d -> t 1 d')
-            hiddens = hiddens + time_pos_emb
-
-        # maybe view embeddings
-
-        if exists(self.image_view_emb):
-            assert self.image_view_emb.shape[0] == hiddens.shape[2]
-
-            image_view_emb = rearrange(self.image_view_emb, 'v d -> v 1 1 d')
-            hiddens = hiddens + image_view_emb
-
-        # get representation trajectory from ast
-
-        ast_forward_context = torch.no_grad if freeze_ast else nullcontext
-
-        with ast_forward_context():
-            audio_embed, audio_hiddens = self.ast(audio_or_spec, return_hiddens = True)
-
-        audio_hiddens = cat((audio_hiddens, audio_embed[None, ...]))
-
-        # extract the hiddens needed for the action cross attention
-
-        audio_hiddens = audio_hiddens[self.ast_layer_indices]
-
-        # unpack audio temporarily for embedding
-
-        audio_hiddens, = unpack(audio_hiddens, audio_packed_shape, 'l * n d') # l for layers
-
-        # maybe audio view embeddings
-
-        if exists(self.audio_view_emb):
-            assert self.audio_view_emb.shape[0] == audio_hiddens.shape[2]
-
-            audio_view_emb = rearrange(self.audio_view_emb, 'v d -> v 1 1 d')
-            audio_hiddens = audio_hiddens + audio_view_emb
-
-        # maybe tasks
-
-        if exists(tasks):
-            assert self.has_tasks, f'`num_tasks` must be set on `VAT` for task conditioning'
-
-            task_emb = self.task_emb[tasks]
-
-        # cross from actions to representation trajectory
-
-        image_context = rearrange(hiddens, 'l b v t n d -> l b (v t n) d')
-
-        audio_context = rearrange(audio_hiddens, 'l b v n d -> l b (v n) d')
-
-        # get main action tokens and maybe append extra
-
-        action_tokens = repeat(self.action_pos_emb, 'k d -> b k d', b = batch)
-
-        has_extra = exists(extra)
-
-        if has_extra:
-            assert self.accept_extra_token
-
-            extra_token = self.to_extra_token(extra)
-
-            action_tokens, packed_extra = pack([action_tokens, extra_token], 'b * d')
-
-        # register tokens
-
-        register_tokens = repeat(self.register_tokens, 'n d -> b n d', b = batch)
-
-        action_tokens, registers_packed_shape = pack((register_tokens, action_tokens), 'b * d')
-
-        # cross attention
-
-        hiddens = [action_tokens]
-
-        for (maybe_film, maybe_self_attn, image_cross_attn, audio_cross_attn, ff), image_layer_context, audio_layer_context in zip(self.layers, image_context, audio_context):
-
-            if exists(tasks):
-                action_tokens = maybe_film(action_tokens, task_emb)
-
-            action_tokens = image_cross_attn(action_tokens, image_layer_context) + action_tokens
-
-            action_tokens = audio_cross_attn(action_tokens, audio_layer_context) + action_tokens
-
-            if exists(maybe_self_attn):
-                action_tokens = maybe_self_attn(action_tokens) + action_tokens
-
-            action_tokens = ff(action_tokens) + action_tokens
-
-            hiddens.append(action_tokens)
-
-        # unpack registers
-
-        _, action_tokens = unpack(action_tokens, registers_packed_shape, 'b * d')
-
-        # maybe unpack extra
-
-        if has_extra:
-            action_tokens, _ = unpack(action_tokens, packed_extra, 'b * d')
-
-        # norm and prediction
-
-        action_tokens = self.final_norm(action_tokens)
-
-        pred_action = self.to_pred_action(action_tokens)
-
-        if not return_loss:
-            if not return_hiddens:
-                return pred_action
-
-            return pred_action, stack(hiddens)
-
-        assert pred_action.shape[1] == actions.shape[1]
-
-        # they found l1 loss suffices
-
-        return F.l1_loss(pred_action, actions)
-
-# quick test
-
-if __name__ == '__main__':
-
-    vit = ViT(
-        image_size = 256,
-        patch_size = 32,
-        num_classes = 1000,
-        dim = 384,
-        heads = 8,
-        depth = 4,
-        mlp_dim = 384 * 4
-    )
-
-    ast = AST(
-        dim = 384,
-        depth = 4,
-        heads = 8,
-        num_classes = 1000,
-        patch_size = 16,
-        mlp_dim = 384 * 4
-    )
-
-    vaat = VAAT(
-        vit,
-        ast,
-        dim = 512,
-        depth = 9,
-        heads = 8,
-        dim_head = 64,
-        mlp_dim = 2048,
-        dim_action = 20,
-        action_chunk_len = 7,
-        time_seq_len = 4,
-        num_image_views = 2,
-        num_audio_views = 2,
-        num_tasks = 4,
-        add_self_attn = True,
-        dim_extra_token = 33,               # extra token with some variable dimension
-        vit_layer_indices = (               # extending on the paper, allow for any order of hiddens, and also allow for depth index (which equates to the final embedding output from the vit)
-            0, 0, 1, 1, 2, 2, 3, 3, 4
-        ),
-        ast_layer_indices = (
-            1, 1, 1, 2, 2, 2, 3, 3, 3
-        )
-    )
-
-    images = torch.randn(2, 2, 3, 4, 256, 256) # (2 views with 4 frames)
-    audio = torch.randn(2, 2, 14_100 * 5)
-
-    tasks = torch.randint(0, 4, (2,))
-    extra = torch.randn(2, 33)                 # extra internal state
-
-    actions = torch.randn(2, 7, 20)         # actions for learning
-
-    loss = vaat(images, audio, actions = actions, tasks = tasks, extra = extra, freeze_vit = True)
-    loss.backward()
-
-    # after much training
-
-    pred_actions, hiddens = vaat(images, audio, tasks = tasks, extra = extra, return_hiddens = True)
-
-    assert pred_actions.shape == (2, 7, 20)

vit_pytorch/vat.py

@@ -1,536 +0,0 @@
-from __future__ import annotations
-from contextlib import nullcontext
-
-import torch
-import torch.nn.functional as F
-from torch import nn, cat, stack, tensor
-from torch.nn import Module, ModuleList
-
-from einops import rearrange, repeat, pack, unpack
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def exists(v):
-    return v is not None
-
-def default(v, d):
-    return v if exists(v) else d
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-# classes
-
-class FiLM(Module):
-    def __init__(
-        self,
-        dim,
-    ):
-        super().__init__()
-        proj = nn.Linear(dim, dim * 2)
-
-        self.to_gamma_beta = nn.Sequential(
-            proj,
-            Rearrange('b (two d) -> two b 1 d', two = 2)
-        )
-
-        nn.init.zeros_(proj.weight)
-        nn.init.zeros_(proj.bias)
-
-    def forward(self, tokens, cond):
-        gamma, beta = self.to_gamma_beta(cond)
-
-        return tokens * gamma + beta
-
-class FeedForward(Module):
-    def __init__(
-        self,
-        dim,
-        hidden_dim,
-        dropout = 0.
-    ):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Dropout(dropout),
-            nn.Linear(hidden_dim, dim),
-            nn.Dropout(dropout)
-        )
-
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(Module):
-    def __init__(
-        self,
-        dim,
-        dim_context = None,
-        heads = 8,
-        dim_head = 64,
-        dropout = 0.,
-        cross_attend = False
-    ):
-        super().__init__()
-        dim_context = default(dim_context, dim)
-        inner_dim = dim_head *  heads
-        project_out = not (heads == 1 and dim_head == dim)
-
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-
-        self.norm = nn.LayerNorm(dim)
-
-        self.cross_attend = cross_attend
-        self.context_norm = nn.LayerNorm(dim_context) if cross_attend else None
-
-        self.attend = nn.Softmax(dim = -1)
-        self.dropout = nn.Dropout(dropout)
-
-        self.to_q = nn.Linear(dim, inner_dim, bias = False)
-        self.to_kv = nn.Linear(dim_context, inner_dim * 2, bias = False)
-
-        self.to_out_gates = nn.Sequential(
-            nn.Linear(dim, heads),
-            Rearrange('b ... h -> b h ... 1'),
-            nn.Sigmoid()
-        )
-
-        self.to_out = nn.Sequential(
-            nn.Linear(inner_dim, dim),
-            nn.Dropout(dropout)
-        ) if project_out else nn.Identity()
-
-    def forward(self, x, context = None):
-
-        assert not (self.cross_attend ^ exists(context)), 'context must be passed in if cross attending, or vice versa'
-
-        x = self.norm(x)
-
-        # handle norming of context for cross attention
-
-        kv_input = x
-
-        if self.cross_attend:
-            context = self.context_norm(context)
-            kv_input = context
-
-        # project for queries, keys, values
-
-        qkv = (self.to_q(x), *self.to_kv(kv_input).chunk(2, dim = -1))
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-
-        attn = self.attend(dots)
-        attn = self.dropout(attn)
-
-        out = torch.matmul(attn, v)
-        out = out * self.to_out_gates(x) # https://arxiv.org/abs/2505.06708
-
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(Module):
-    def __init__(
-        self,
-        dim,
-        depth,
-        heads,
-        dim_head,
-        mlp_dim,
-        dropout = 0.
-    ):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim)
-        self.layers = ModuleList([])
-
-        for _ in range(depth):
-            self.layers.append(ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_dim, dropout = dropout)
-            ]))
-
-    def forward(
-        self,
-        x,
-        return_hiddens = False
-    ):
-
-        hiddens = []
-
-        for attn, ff in self.layers:
-            hiddens.append(x)
-
-            x = attn(x) + x
-            x = ff(x) + x
-
-        x = self.norm(x)
-
-        if not return_hiddens:
-            return x
-
-        return x, hiddens
-
-class ViT(Module):
-    def __init__(
-        self,
-        *,
-        image_size,
-        patch_size,
-        num_classes,
-        dim,
-        depth,
-        heads,
-        mlp_dim,
-        pool = 'cls',
-        channels = 3,
-        dim_head = 64,
-        dropout = 0.,
-        emb_dropout = 0.,
-        num_register_tokens = 0
-    ):
-        super().__init__()
-        self.dim = dim
-        self.depth = depth
-
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(patch_size)
-
-        assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
-
-        num_patches = (image_height // patch_height) * (image_width // patch_width)
-        patch_dim = channels * patch_height * patch_width
-        assert pool in {'cls', 'mean'}, 'pool type must be either cls (cls token) or mean (mean pooling)'
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.pos_embedding = nn.Parameter(torch.randn(num_patches, dim))
-        self.cls_token = nn.Parameter(torch.randn(dim))
-        self.dropout = nn.Dropout(emb_dropout)
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout)
-
-        self.pool = pool
-        self.to_latent = nn.Identity()
-
-        self.mlp_head = nn.Linear(dim, num_classes)
-
-        self.register_tokens = nn.Parameter(torch.randn(num_register_tokens, dim) * 1e-2)
-
-    def forward(self, img, return_hiddens = False):
-        x = self.to_patch_embedding(img)
-        b, n, _ = x.shape
-
-        x += self.pos_embedding[:n]
-
-        cls_tokens = repeat(self.cls_token, 'd -> b d', b = b)
-        register_tokens = repeat(self.register_tokens, 'n d -> b n d', b = b)
-
-        x, packed_shape = pack((register_tokens, cls_tokens, x), 'b * d')
-
-        x = self.dropout(x)
-
-        x, hiddens = self.transformer(x, return_hiddens = True)
-
-        # return the representation trajectory
-
-        if return_hiddens:
-            return x, stack(hiddens)
-
-        register_tokens, cls_tokens, x = unpack(x, packed_shape, 'b * d')
-
-        x = x.mean(dim = 1) if self.pool == 'mean' else cls_tokens
-
-        x = self.to_latent(x)
-        return self.mlp_head(x)
-
-# proposed VAT
-
-# https://openreview.net/forum?id=TalHOvvLZu
-# simple way to get SOTA on Libero dataset (beating fine-tuned pi-zero)
-
-class VAT(Module):
-    def __init__(
-        self,
-        vit: ViT | dict,
-        *,
-        dim,
-        depth,
-        heads,
-        dim_head,
-        dim_action,
-        mlp_dim,
-        num_views = None,
-        num_tasks = None,
-        dim_extra_token = None,
-        num_register_tokens = 4,
-        action_chunk_len = 7,
-        time_seq_len = 1,
-        dropout = 0.,
-        add_self_attn = True,  # in the paper, they didn't have any ways for the action token to exchange information with the extra token, so we'll just add it as an option
-        self_attn_heads = 4,
-        self_attn_dim_head = 32,
-        vit_layer_indices: tuple[int, ...] | None = None
-    ):
-        super().__init__()
-
-        if isinstance(vit, dict):
-            vit = ViT(**vit)
-
-        self.vit = vit
-
-        vit_dim = vit.dim
-
-        assert vit.depth == depth or exists(vit_layer_indices), f'if the VAT depth is not equal to the ViT depth, you must pass in the indices from the ViT to be layered to the VAT in order from bottom to top'
-
-        vit_layer_indices = default(vit_layer_indices, tuple(range(depth)))
-
-        assert len(vit_layer_indices) == depth, f'number of vit layer indices {len(vit_layer_indices)} does not much the VAT depth {depth}'
-
-        self.register_buffer('layer_indices', tensor(vit_layer_indices), persistent = False)
-
-        # handle maybe multiple frames
-
-        is_video = time_seq_len > 1
-
-        self.is_video = is_video
-        self.time_seq_len = time_seq_len
-        self.time_pos_emb = nn.Parameter(torch.randn(time_seq_len, vit_dim) * 1e-2) if is_video else None
-
-        # maybe view embeddings
-
-        self.view_emb = nn.Parameter(torch.randn(num_views, vit_dim) * 1e-2) if exists(num_views) and num_views > 1 else None
-
-        # handle maybe task conditioning
-
-        self.has_tasks = exists(num_tasks)
-
-        if self.has_tasks:
-            self.task_emb = nn.Parameter(torch.randn(num_tasks, dim) * 1e-2)
-
-        # register tokens from Darcet et al.
-
-        self.register_tokens = nn.Parameter(torch.randn(num_register_tokens, dim) * 1e-2)
-
-        # to action tokens
-
-        self.action_pos_emb = nn.Parameter(torch.randn(action_chunk_len, dim) * 1e-2)
-
-        self.layers = ModuleList([])
-
-        for _ in range(depth):
-            maybe_film = FiLM(dim = dim) if self.has_tasks else None
-            maybe_self_attn = Attention(dim = dim, heads = self_attn_heads, dim_head = self_attn_dim_head, dropout = dropout) if add_self_attn else None
-
-            self.layers.append(ModuleList([
-                maybe_film,
-                maybe_self_attn,
-                Attention(dim = dim, dim_context = vit_dim, heads = heads, dim_head = dim_head, dropout = dropout, cross_attend = True),
-                FeedForward(dim = dim, hidden_dim = mlp_dim, dropout = dropout)
-            ]))
-
-        self.final_norm = nn.LayerNorm(dim)
-        self.to_pred_action = nn.Linear(dim, dim_action, bias = False)
-
-        # handle the extra token
-
-        self.accept_extra_token = exists(dim_extra_token)
-
-        if exists(dim_extra_token):
-            self.to_extra_token = nn.Linear(dim_extra_token, dim)
-
-    def forward(
-        self,
-        video_or_image,   # (b v? c t? h w) - batch, views [wrist + third person or more], channels, maybe time, height, width
-        *,
-        extra = None,     # (b d)           - batch, dim extra     
-        tasks = None,     # (b)
-        actions = None,   # (b k d)         - batch, action chunk length, action dimension
-        return_hiddens = False,
-        freeze_vit = False
-    ):
-        batch = video_or_image.shape[0]
-        return_loss = exists(actions)
-
-        # handle some various input dimensions
-
-        if video_or_image.ndim == 4:
-            video_or_image = rearrange(video_or_image, 'b 1 c h w')
-
-        assert (
-            (video_or_image.ndim == 5 and not self.is_video) or
-            (video_or_image.ndim == 6 and self.is_video)
-        )
-
-        if video_or_image.ndim == 5:
-            video_or_image = rearrange(video_or_image, 'b v c h w -> b v c 1 h w')
-
-        assert video_or_image.shape[3] == self.time_seq_len
-
-        # to images
-
-        images = rearrange(video_or_image, 'b v c t h w -> b v t c h w')
-
-        images, packed_shape = pack([images], '* c h w')
-
-        # get representation trajectory from vit
-
-        vit_forward_context = torch.no_grad if freeze_vit else nullcontext
-
-        with vit_forward_context():
-            embed, hiddens = self.vit(images, return_hiddens = True)
-
-        hiddens = cat((hiddens, embed[None, ...]))
-
-        # extract the hiddens needed for the action cross attention
-
-        hiddens = hiddens[self.layer_indices]
-
-        # pack temporarily for embedding
-
-        hiddens, = unpack(hiddens, packed_shape, 'l * n d') # l for layers
-
-        # maybe add time embeddings
-
-        if self.is_video:
-            time_pos_emb = rearrange(self.time_pos_emb, 't d -> t 1 d')
-            hiddens = hiddens + time_pos_emb
-
-        # maybe view embeddings
-
-        if exists(self.view_emb):
-            assert self.view_emb.shape[0] == hiddens.shape[2]
-
-            view_emb = rearrange(self.view_emb, 'v d -> v 1 1 d')
-            hiddens = hiddens + view_emb
-
-        # maybe tasks
-
-        if exists(tasks):
-            assert self.has_tasks, f'`num_tasks` must be set on `VAT` for task conditioning'
-
-            task_emb = self.task_emb[tasks]
-
-        # cross from actions to representation trajectory
-
-        context = rearrange(hiddens, 'l b v t n d -> l b (v t n) d')
-
-        # get main action tokens and maybe append extra
-
-        action_tokens = repeat(self.action_pos_emb, 'k d -> b k d', b = batch)
-
-        has_extra = exists(extra)
-
-        if has_extra:
-            assert self.accept_extra_token
-
-            extra_token = self.to_extra_token(extra)
-
-            action_tokens, packed_extra = pack([action_tokens, extra_token], 'b * d')
-
-        # register tokens
-
-        register_tokens = repeat(self.register_tokens, 'n d -> b n d', b = batch)
-
-        action_tokens, registers_packed_shape = pack((register_tokens, action_tokens), 'b * d')
-
-        # cross attention
-
-        hiddens = [action_tokens]
-
-        for (maybe_film, maybe_self_attn, cross_attn, ff), layer_context in zip(self.layers, context):
-
-            if exists(tasks):
-                action_tokens = maybe_film(action_tokens, task_emb)
-
-            action_tokens = cross_attn(action_tokens, layer_context) + action_tokens
-
-            if exists(maybe_self_attn):
-                action_tokens = maybe_self_attn(action_tokens) + action_tokens
-
-            action_tokens = ff(action_tokens) + action_tokens
-
-            hiddens.append(action_tokens)
-
-        # unpack registers
-
-        _, action_tokens = unpack(action_tokens, registers_packed_shape, 'b * d')
-
-        # maybe unpack extra
-
-        if has_extra:
-            action_tokens, _ = unpack(action_tokens, packed_extra, 'b * d')
-
-        # norm and prediction
-
-        action_tokens = self.final_norm(action_tokens)
-
-        pred_action = self.to_pred_action(action_tokens)
-
-        if not return_loss:
-            if not return_hiddens:
-                return pred_action
-
-            return pred_action, stack(hiddens)
-
-        assert pred_action.shape[1] == actions.shape[1]
-
-        # they found l1 loss suffices
-
-        return F.l1_loss(pred_action, actions)
-
-# quick test
-
-if __name__ == '__main__':
-
-    vit = ViT(
-        image_size = 256,
-        patch_size = 32,
-        num_classes = 1000,
-        dim = 256,
-        heads = 8,
-        depth = 4,
-        mlp_dim = 1024
-    )
-
-    vat = VAT(
-        vit,
-        dim = 512,
-        depth = 9,
-        heads = 8,
-        dim_head = 64,
-        mlp_dim = 2048,
-        dim_action = 20,
-        action_chunk_len = 7,
-        time_seq_len = 4,
-        num_views = 2,
-        num_tasks = 4,
-        add_self_attn = True,
-        dim_extra_token = 33,               # extra token with some variable dimension
-        vit_layer_indices = (               # extending on the paper, allow for any order of hiddens, and also allow for depth index (which equates to the final embedding output from the vit)
-            0, 0, 1, 1, 2, 2, 3, 3, 4
-        )
-    )
-
-    images = torch.randn(2, 2, 3, 4, 256, 256) # (2 views with 4 frames)
-    tasks = torch.randint(0, 4, (2,))
-    extra = torch.randn(2, 33)                 # extra internal state
-
-    actions = torch.randn(2, 7, 20)         # actions for learning
-
-    loss = vat(images, actions = actions, tasks = tasks, extra = extra, freeze_vit = True)
-    loss.backward()
-
-    # after much training
-
-    pred_actions, hiddens = vat(images, tasks = tasks, extra = extra, return_hiddens = True)
-
-    assert pred_actions.shape == (2, 7, 20)

vit_pytorch/vat_siglip.py

@@ -1,487 +0,0 @@
-from __future__ import annotations
-from contextlib import nullcontext
-from pathlib import Path
-
-import torch
-import torch.nn.functional as F
-from torch import nn, cat, stack, tensor, einsum
-from torch.nn import Module, ModuleList
-
-from einops import rearrange, repeat, pack, unpack
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def exists(v):
-    return v is not None
-
-def default(v, d):
-    return v if exists(v) else d
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-# attention
-
-class Attention(Module):
-    def __init__(
-        self,
-        dim,
-        dim_context = None,
-        heads = 8,
-        dim_head = 64,
-        dropout = 0.,
-        norm_eps = 1e-6,
-        gate_attn = False
-    ):
-        super().__init__()
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-        inner_dim = dim_head * heads
-
-        self.norm = nn.LayerNorm(dim, eps = norm_eps)
-
-        self.is_cross_attn = exists(dim_context)
-        dim_context = default(dim_context, dim)
-        self.norm_context = nn.LayerNorm(dim_context, eps = norm_eps) if self.is_cross_attn else None
-
-        self.to_q = nn.Linear(dim, inner_dim)
-        self.to_kv = nn.Linear(dim_context, inner_dim * 2)
-
-        self.to_out_gates = nn.Sequential(
-            nn.Linear(dim, heads),
-            Rearrange('b ... h -> b h ... 1'),
-            nn.Sigmoid()
-        ) if gate_attn else None
-
-        self.to_out = nn.Sequential(
-            nn.Linear(inner_dim, dim),
-            nn.Dropout(dropout)
-        )
-
-    def forward(self, x, context = None):
-        x = self.norm(x)
-
-        if self.is_cross_attn:
-            assert exists(context)
-            context = self.norm_context(context)
-        else:
-            context = x
-
-        q = self.to_q(x)
-        k, v = self.to_kv(context).chunk(2, dim = -1)
-
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), (q, k, v))
-
-        sim = einsum('b h i d, b h j d -> b h i j', q, k) * self.scale
-        attn = sim.softmax(dim = -1)
-
-        out = einsum('b h i j, b h j d -> b h i d', attn, v)
-
-        if exists(self.to_out_gates):
-            out = out * self.to_out_gates(x) # https://arxiv.org/abs/2505.06708
-
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-def FeedForward(
-    dim,
-    dim_inner,
-    norm_eps = 1e-6
-):
-    return nn.Sequential(
-        nn.LayerNorm(dim, eps = norm_eps),
-        nn.Linear(dim, dim_inner),
-        nn.GELU(approximate = 'tanh'),
-        nn.Linear(dim_inner, dim)
-    )
-
-class SigLIP(Module):
-    def __init__(
-        self,
-        image_size = 224,
-        patch_size = 14,
-        dim = 1152,
-        depth = 27,
-        heads = 16,
-        mlp_dim = 4304,
-        norm_eps = 1e-6
-    ):
-        super().__init__()
-        self.dim = dim
-        self.depth = depth
-        num_patches = (image_size // patch_size) ** 2
-        dim_head = dim // heads
-
-        self.to_patch_embed = nn.Sequential(
-            Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_size, p2 = patch_size),
-            nn.Linear(patch_size * patch_size * 3, dim)
-        )
-
-        self.pos_embed = nn.Parameter(torch.randn(num_patches, dim))
-
-        self.layers = ModuleList([])
-        for _ in range(depth):
-            self.layers.append(ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, norm_eps = norm_eps),
-                FeedForward(dim = dim, dim_inner = mlp_dim, norm_eps = norm_eps)
-            ]))
-
-        self.norm = nn.LayerNorm(dim, eps = norm_eps)
-
-    def forward(self, x, return_hiddens = False):
-        x = self.to_patch_embed(x)
-        num_patches = x.shape[1]
-
-        x = x + self.pos_embed[:num_patches]
-
-        hiddens = []
-
-        for attn, ff in self.layers:
-            hiddens.append(x)
-
-            x = attn(x) + x
-            x = ff(x) + x
-
-        out = self.norm(x)
-
-        if not return_hiddens:
-            return out
-
-        return out, stack(hiddens)
-
-class FiLM(Module):
-    def __init__(self, dim):
-        super().__init__()
-        proj = nn.Linear(dim, dim * 2)
-
-        self.to_gamma_beta = nn.Sequential(
-            proj,
-            Rearrange('b (two d) -> two b 1 d', two = 2)
-        )
-
-        nn.init.zeros_(proj.weight)
-        nn.init.zeros_(proj.bias)
-
-    def forward(self, tokens, cond):
-        gamma, beta = self.to_gamma_beta(cond)
-        return tokens * gamma + beta
-
-class SigLIPVAT(Module):
-    def __init__(
-        self,
-        *,
-        dim = 512,
-        depth = 27,
-        heads = 8,
-        dim_head = 64,
-        dim_action = 32,
-        mlp_dim = 2048,
-        num_views = 1,
-        num_tasks = None,
-        dim_extra_token = None,
-        num_register_tokens = 4,
-        action_chunk_len = 50,
-        time_seq_len = 1,
-        dropout = 0.,
-        add_self_attn = True,
-        self_attn_heads = 4,
-        self_attn_dim_head = 32,
-        vit_layer_indices: tuple[int, ...] | None = None,
-        siglip_image_size = 224,
-        siglip_patch_size = 14,
-        siglip_dim = 1152,
-        siglip_depth = 27,
-        siglip_heads = 16,
-        siglip_mlp_dim = 4304,
-        siglip_norm_eps = 1e-6,
-    ):
-        super().__init__()
-
-        self.vit = SigLIP(
-            image_size = siglip_image_size,
-            patch_size = siglip_patch_size,
-            dim = siglip_dim,
-            depth = siglip_depth,
-            heads = siglip_heads,
-            mlp_dim = siglip_mlp_dim,
-            norm_eps = siglip_norm_eps
-        )
-
-        vit_dim = siglip_dim
-        self.vit_dim = vit_dim
-
-        vit_layer_indices = default(vit_layer_indices, tuple(range(depth)))
-        assert len(vit_layer_indices) == depth, f'number of vit layer indices {len(vit_layer_indices)} does not much the VAT depth {depth}'
-        self.register_buffer('layer_indices', tensor(vit_layer_indices), persistent = False)
-
-        # handle maybe multiple frames
-
-        is_video = time_seq_len > 1
-        self.is_video = is_video
-        self.time_seq_len = time_seq_len
-        self.time_pos_emb = nn.Parameter(torch.randn(time_seq_len, vit_dim) * 1e-2) if is_video else None
-
-        # maybe view embeddings
-
-        self.view_emb = nn.Parameter(torch.randn(num_views, vit_dim) * 1e-2) if exists(num_views) and num_views > 1 else None
-
-        # handle maybe task conditioning
-
-        self.has_tasks = exists(num_tasks)
-        if self.has_tasks:
-            self.task_emb = nn.Parameter(torch.randn(num_tasks, dim) * 1e-2)
-
-        # register tokens
-
-        self.register_tokens = nn.Parameter(torch.randn(num_register_tokens, dim) * 1e-2)
-
-        # to action tokens
-
-        self.action_pos_emb = nn.Parameter(torch.randn(action_chunk_len, dim) * 1e-2)
-
-        self.layers = ModuleList([])
-        for _ in range(depth):
-            maybe_film = FiLM(dim = dim) if self.has_tasks else None
-            maybe_self_attn = Attention(dim = dim, heads = self_attn_heads, dim_head = self_attn_dim_head, dropout = dropout) if add_self_attn else None
-
-            self.layers.append(ModuleList([
-                maybe_film,
-                maybe_self_attn,
-                Attention(dim = dim, dim_context = vit_dim, heads = heads, dim_head = dim_head, dropout = dropout, gate_attn = True),
-                FeedForward(dim = dim, dim_inner = mlp_dim)
-            ]))
-
-        self.final_norm = nn.LayerNorm(dim)
-        self.to_pred_action = nn.Linear(dim, dim_action, bias = False)
-
-        # handle the extra token
-
-        self.accept_extra_token = exists(dim_extra_token)
-        if exists(dim_extra_token):
-            self.to_extra_token = nn.Linear(dim_extra_token, dim)
-
-    def load_siglip(
-        self,
-        repo_id = 'google/siglip-so400m-patch14-224',
-        folder = 'checkpoints/siglip'
-    ):
-        folder = Path(folder)
-        if not folder.exists():
-            from huggingface_hub import snapshot_download
-            snapshot_download(
-                repo_id = repo_id,
-                local_dir = folder,
-                allow_patterns = ['config.json', 'model.safetensors']
-            )
-
-        from safetensors import safe_open
-        weights_path = folder / 'model.safetensors'
-
-        # Auto-detect prefix based on keys
-        with safe_open(weights_path, framework = 'pt') as f:
-            keys = f.keys()
-            
-            vi_p = ''
-            if any(k.startswith('paligemma_with_expert.paligemma.model.vision_tower.vision_model') for k in keys):
-                vi_p = 'paligemma_with_expert.paligemma.model.vision_tower.vision_model.'
-            elif any(k.startswith('vision_model') for k in keys):
-                vi_p = 'vision_model.'
-            
-            pz_state = self.vit.state_dict()
-
-            def copy_weight_bias(pz_prefix, vi_prefix):
-                pz_state[f'{pz_prefix}.weight'].copy_(f.get_tensor(f'{vi_prefix}.weight'))
-                pz_state[f'{pz_prefix}.bias'].copy_(f.get_tensor(f'{vi_prefix}.bias'))
-
-            # patch embedding
-            patch_weight = rearrange(f.get_tensor(f'{vi_p}embeddings.patch_embedding.weight'), 'd c h w -> d (h w c)')
-            pz_state['to_patch_embed.1.weight'].copy_(patch_weight)
-            pz_state['to_patch_embed.1.bias'].copy_(f.get_tensor(f'{vi_p}embeddings.patch_embedding.bias'))
-
-            # position embedding
-            pz_state['pos_embed'].copy_(f.get_tensor(f'{vi_p}embeddings.position_embedding.weight'))
-
-            # transformer layers
-            for i in range(self.vit.depth):
-                v_pi = f'{vi_p}encoder.layers.{i}'
-                v_pz = f'layers.{i}'
-
-                # attention
-                copy_weight_bias(f'{v_pz}.0.norm', f'{v_pi}.layer_norm1')
-                copy_weight_bias(f'{v_pz}.0.to_q', f'{v_pi}.self_attn.q_proj')
-
-                vk, vv = [f.get_tensor(f'{v_pi}.self_attn.{x}_proj.weight') for x in ('k', 'v')]
-                bk, bv = [f.get_tensor(f'{v_pi}.self_attn.{x}_proj.bias') for x in ('k', 'v')]
-
-                pz_state[f'{v_pz}.0.to_kv.weight'].copy_(cat((vk, vv), dim = 0))
-                pz_state[f'{v_pz}.0.to_kv.bias'].copy_(cat((bk, bv), dim = 0))
-
-                copy_weight_bias(f'{v_pz}.0.to_out.0', f'{v_pi}.self_attn.out_proj')
-
-                # feedforward
-                copy_weight_bias(f'{v_pz}.1.0', f'{v_pi}.layer_norm2')
-                copy_weight_bias(f'{v_pz}.1.1', f'{v_pi}.mlp.fc1')
-                copy_weight_bias(f'{v_pz}.1.3', f'{v_pi}.mlp.fc2')
-
-            # post-layernorm
-            copy_weight_bias('norm', f'{vi_p}post_layernorm')
-
-            self.vit.load_state_dict(pz_state)
-
-        print(f'Successfully loaded SigLIP weights from {repo_id}')
-
-    def forward(
-        self,
-        video_or_image,   # (b v? c t? h w)
-        *,
-        extra = None,
-        tasks = None,
-        actions = None,
-        return_hiddens = False,
-        freeze_vit = False
-    ):
-        batch = video_or_image.shape[0]
-        return_loss = exists(actions)
-
-        # handle some various input dimensions
-
-        if video_or_image.ndim == 4:
-            video_or_image = rearrange(video_or_image, 'b 1 c h w')
-
-        if video_or_image.ndim == 5:
-            video_or_image = rearrange(video_or_image, 'b v c h w -> b v c 1 h w')
-
-        assert video_or_image.shape[3] == self.time_seq_len
-
-        # to images
-
-        images = rearrange(video_or_image, 'b v c t h w -> b v t c h w')
-        images, packed_shape = pack([images], '* c h w')
-
-        # get representation trajectory from vit
-
-        vit_forward_context = torch.no_grad if freeze_vit else nullcontext
-
-        with vit_forward_context():
-            embed, hiddens = self.vit(images, return_hiddens = True)
-
-        hiddens = cat((hiddens, embed[None, ...]))
-
-        # extract the hiddens needed for the action cross attention
-
-        hiddens = hiddens[self.layer_indices]
-
-        # pack temporarily for embedding
-
-        hiddens, = unpack(hiddens, packed_shape, 'l * n d') # l for layers
-
-        # maybe add time embeddings
-
-        if self.is_video:
-            time_pos_emb = rearrange(self.time_pos_emb, 't d -> t 1 d')
-            hiddens = hiddens + time_pos_emb
-
-        # maybe view embeddings
-
-        if exists(self.view_emb):
-            view_emb = rearrange(self.view_emb, 'v d -> v 1 1 d')
-            hiddens = hiddens + view_emb
-
-        # maybe tasks
-
-        if exists(tasks):
-            task_emb = self.task_emb[tasks]
-
-        # cross from actions to representation trajectory
-
-        context = rearrange(hiddens, 'l b v t n d -> l b (v t n) d')
-
-        # get main action tokens and maybe append extra
-
-        action_tokens = repeat(self.action_pos_emb, 'k d -> b k d', b = batch)
-
-        has_extra = exists(extra)
-        if has_extra:
-            extra_token = self.to_extra_token(extra)
-            action_tokens, packed_extra = pack([action_tokens, extra_token], 'b * d')
-
-        # register tokens
-
-        register_tokens = repeat(self.register_tokens, 'n d -> b n d', b = batch)
-        action_tokens, registers_packed_shape = pack((register_tokens, action_tokens), 'b * d')
-
-        # cross attention
-
-        vat_hiddens = [action_tokens]
-
-        for (maybe_film, maybe_self_attn, cross_attn, ff), layer_context in zip(self.layers, context):
-
-            if exists(tasks):
-                action_tokens = maybe_film(action_tokens, task_emb)
-
-            action_tokens = cross_attn(action_tokens, layer_context) + action_tokens
-
-            if exists(maybe_self_attn):
-                action_tokens = maybe_self_attn(action_tokens) + action_tokens
-
-            action_tokens = ff(action_tokens) + action_tokens
-
-            vat_hiddens.append(action_tokens)
-
-        # unpack registers
-
-        _, action_tokens = unpack(action_tokens, registers_packed_shape, 'b * d')
-
-        # maybe unpack extra
-
-        if has_extra:
-            action_tokens, _ = unpack(action_tokens, packed_extra, 'b * d')
-
-        # norm and prediction
-
-        action_tokens = self.final_norm(action_tokens)
-        pred_action = self.to_pred_action(action_tokens)
-
-        if not return_loss:
-            if not return_hiddens:
-                return pred_action
-
-            return pred_action, stack(vat_hiddens)
-
-        assert pred_action.shape[1] == actions.shape[1]
-
-        return F.l1_loss(pred_action, actions)
-
-# quick test
-
-if __name__ == '__main__':
-    vat = SigLIPVAT(
-        num_tasks = 4,
-        dim_extra_token = 32,
-        time_seq_len = 2,
-        num_views = 2,
-        depth = 4,
-        vit_layer_indices = (               # extending on the paper, allow for any order of hiddens, and also allow for depth index (which equates to the final embedding output from the vit)
-            0, 1, 26, 27
-        )
-    )
-
-    vat.load_siglip() # load siglip weights from hf
-
-    # inputs
-
-    images = torch.randn(1, 2, 3, 2, 224, 224) # (b, v, c, t, h, w)
-    tasks = torch.randint(0, 4, (1,))
-    extra = torch.randn(1, 32)
-
-    actions = torch.randn(1, 50, 32) # actions for learning
-
-    loss = vat(images, actions = actions, tasks = tasks, extra = extra, freeze_vit = True)
-    loss.backward()
-
-    # after much training
-
-    pred_actions = vat(images, tasks = tasks, extra = extra)
-    
-    assert pred_actions.shape == (1, 50, 32)

vit_pytorch/vit.py

@@ -1,6 +1,5 @@
 import torch
 from torch import nn
-from torch.nn import Module, ModuleList
 
 from einops import rearrange, repeat
 from einops.layers.torch import Rearrange
@@ -12,22 +11,28 @@ def pair(t):
 
 # classes
 
-class FeedForward(Module):
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = nn.LayerNorm(dim)
+        self.fn = fn
+    def forward(self, x, **kwargs):
+        return self.fn(self.norm(x), **kwargs)
+
+class FeedForward(nn.Module):
     def __init__(self, dim, hidden_dim, dropout = 0.):
         super().__init__()
         self.net = nn.Sequential(
-            nn.LayerNorm(dim),
             nn.Linear(dim, hidden_dim),
             nn.GELU(),
             nn.Dropout(dropout),
             nn.Linear(hidden_dim, dim),
             nn.Dropout(dropout)
         )
-
     def forward(self, x):
         return self.net(x)
 
-class Attention(Module):
+class Attention(nn.Module):
     def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0.):
         super().__init__()
         inner_dim = dim_head *  heads
@@ -36,8 +41,6 @@ class Attention(Module):
         self.heads = heads
         self.scale = dim_head ** -0.5
 
-        self.norm = nn.LayerNorm(dim)
-
         self.attend = nn.Softmax(dim = -1)
         self.dropout = nn.Dropout(dropout)
 
@@ -49,8 +52,6 @@ class Attention(Module):
         ) if project_out else nn.Identity()
 
     def forward(self, x):
-        x = self.norm(x)
-
         qkv = self.to_qkv(x).chunk(3, dim = -1)
         q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
 
@@ -63,26 +64,22 @@ class Attention(Module):
         out = rearrange(out, 'b h n d -> b n (h d)')
         return self.to_out(out)
 
-class Transformer(Module):
+class Transformer(nn.Module):
     def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0.):
         super().__init__()
-        self.norm = nn.LayerNorm(dim)
-        self.layers = ModuleList([])
-
+        self.layers = nn.ModuleList([])
         for _ in range(depth):
-            self.layers.append(ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_dim, dropout = dropout)
+            self.layers.append(nn.ModuleList([
+                PreNorm(dim, Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout)),
+                PreNorm(dim, FeedForward(dim, mlp_dim, dropout = dropout))
             ]))
-
     def forward(self, x):
         for attn, ff in self.layers:
             x = attn(x) + x
             x = ff(x) + x
+        return x
 
-        return self.norm(x)
-
-class ViT(Module):
+class ViT(nn.Module):
     def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, pool = 'cls', channels = 3, dim_head = 64, dropout = 0., emb_dropout = 0.):
         super().__init__()
         image_height, image_width = pair(image_size)
@@ -92,20 +89,15 @@ class ViT(Module):
 
         num_patches = (image_height // patch_height) * (image_width // patch_width)
         patch_dim = channels * patch_height * patch_width
-
         assert pool in {'cls', 'mean'}, 'pool type must be either cls (cls token) or mean (mean pooling)'
-        num_cls_tokens = 1 if pool == 'cls' else 0
 
         self.to_patch_embedding = nn.Sequential(
             Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
             nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
         )
 
-        self.cls_token = nn.Parameter(torch.randn(num_cls_tokens, dim))
-        self.pos_embedding = nn.Parameter(torch.randn(num_patches + num_cls_tokens, dim))
-
+        self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))
+        self.cls_token = nn.Parameter(torch.randn(1, 1, dim))
         self.dropout = nn.Dropout(emb_dropout)
 
         self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout)
@@ -113,25 +105,22 @@ class ViT(Module):
         self.pool = pool
         self.to_latent = nn.Identity()
 
-        self.mlp_head = nn.Linear(dim, num_classes) if num_classes > 0 else None
+        self.mlp_head = nn.Sequential(
+            nn.LayerNorm(dim),
+            nn.Linear(dim, num_classes)
+        )
 
     def forward(self, img):
-        batch = img.shape[0]
         x = self.to_patch_embedding(img)
+        b, n, _ = x.shape
 
-        cls_tokens = repeat(self.cls_token, '... d -> b ... d', b = batch)
-        x = torch.cat((cls_tokens, x), dim = 1)
-
-        seq = x.shape[1]
-
-        x = x + self.pos_embedding[:seq]
+        cls_tokens = repeat(self.cls_token, '1 n d -> b n d', b = b)
+        x = torch.cat((cls_tokens, x), dim=1)
+        x += self.pos_embedding[:, :(n + 1)]
         x = self.dropout(x)
 
         x = self.transformer(x)
 
-        if self.mlp_head is None:
-            return x
-
         x = x.mean(dim = 1) if self.pool == 'mean' else x[:, 0]
 
         x = self.to_latent(x)

vit_pytorch/vit_1d.py

@@ -1,130 +0,0 @@
-import torch
-from torch import nn
-
-from einops import rearrange, repeat, pack, unpack
-from einops.layers.torch import Rearrange
-
-# classes
-
-class FeedForward(nn.Module):
-    def __init__(self, dim, hidden_dim, dropout = 0.):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Dropout(dropout),
-            nn.Linear(hidden_dim, dim),
-            nn.Dropout(dropout)
-        )
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(nn.Module):
-    def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0.):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        project_out = not (heads == 1 and dim_head == dim)
-
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-
-        self.norm = nn.LayerNorm(dim)
-        self.attend = nn.Softmax(dim = -1)
-        self.dropout = nn.Dropout(dropout)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-
-        self.to_out = nn.Sequential(
-            nn.Linear(inner_dim, dim),
-            nn.Dropout(dropout)
-        ) if project_out else nn.Identity()
-
-    def forward(self, x):
-        x = self.norm(x)
-        qkv = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-
-        attn = self.attend(dots)
-        attn = self.dropout(attn)
-
-        out = torch.matmul(attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(nn.Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0.):
-        super().__init__()
-        self.layers = nn.ModuleList([])
-        for _ in range(depth):
-            self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_dim, dropout = dropout)
-            ]))
-    def forward(self, x):
-        for attn, ff in self.layers:
-            x = attn(x) + x
-            x = ff(x) + x
-        return x
-
-class ViT(nn.Module):
-    def __init__(self, *, seq_len, patch_size, num_classes, dim, depth, heads, mlp_dim, channels = 3, dim_head = 64, dropout = 0., emb_dropout = 0.):
-        super().__init__()
-        assert (seq_len % patch_size) == 0
-
-        num_patches = seq_len // patch_size
-        patch_dim = channels * patch_size
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange('b c (n p) -> b n (p c)', p = patch_size),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))
-        self.cls_token = nn.Parameter(torch.randn(dim))
-        self.dropout = nn.Dropout(emb_dropout)
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout)
-
-        self.mlp_head = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, num_classes)
-        )
-
-    def forward(self, series):
-        x = self.to_patch_embedding(series)
-        b, n, _ = x.shape
-
-        cls_tokens = repeat(self.cls_token, 'd -> b d', b = b)
-
-        x, ps = pack([cls_tokens, x], 'b * d')
-
-        x += self.pos_embedding[:, :(n + 1)]
-        x = self.dropout(x)
-
-        x = self.transformer(x)
-
-        cls_tokens, _ = unpack(x, ps, 'b * d')
-
-        return self.mlp_head(cls_tokens)
-
-if __name__ == '__main__':
-
-    v = ViT(
-        seq_len = 256,
-        patch_size = 16,
-        num_classes = 1000,
-        dim = 1024,
-        depth = 6,
-        heads = 8,
-        mlp_dim = 2048,
-        dropout = 0.1,
-        emb_dropout = 0.1
-    )
-
-    time_series = torch.randn(4, 3, 256)
-    logits = v(time_series) # (4, 1000)

vit_pytorch/vit_3d.py

@@ -1,126 +0,0 @@
-import torch
-from torch import nn
-
-from einops import rearrange, repeat
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-# classes
-
-class FeedForward(nn.Module):
-    def __init__(self, dim, hidden_dim, dropout = 0.):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Dropout(dropout),
-            nn.Linear(hidden_dim, dim),
-            nn.Dropout(dropout)
-        )
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(nn.Module):
-    def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0.):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        project_out = not (heads == 1 and dim_head == dim)
-
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-
-        self.norm = nn.LayerNorm(dim)
-        self.attend = nn.Softmax(dim = -1)
-        self.dropout = nn.Dropout(dropout)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-
-        self.to_out = nn.Sequential(
-            nn.Linear(inner_dim, dim),
-            nn.Dropout(dropout)
-        ) if project_out else nn.Identity()
-
-    def forward(self, x):
-        x = self.norm(x)
-        qkv = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-
-        attn = self.attend(dots)
-        attn = self.dropout(attn)
-
-        out = torch.matmul(attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(nn.Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0.):
-        super().__init__()
-        self.layers = nn.ModuleList([])
-        for _ in range(depth):
-            self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_dim, dropout = dropout)
-            ]))
-    def forward(self, x):
-        for attn, ff in self.layers:
-            x = attn(x) + x
-            x = ff(x) + x
-        return x
-
-class ViT(nn.Module):
-    def __init__(self, *, image_size, image_patch_size, frames, frame_patch_size, num_classes, dim, depth, heads, mlp_dim, pool = 'cls', channels = 3, dim_head = 64, dropout = 0., emb_dropout = 0.):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(image_patch_size)
-
-        assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
-        assert frames % frame_patch_size == 0, 'Frames must be divisible by frame patch size'
-
-        num_patches = (image_height // patch_height) * (image_width // patch_width) * (frames // frame_patch_size)
-        patch_dim = channels * patch_height * patch_width * frame_patch_size
-
-        assert pool in {'cls', 'mean'}, 'pool type must be either cls (cls token) or mean (mean pooling)'
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange('b c (f pf) (h p1) (w p2) -> b (f h w) (pf p1 p2 c)', p1 = patch_height, p2 = patch_width, pf = frame_patch_size),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))
-        self.cls_token = nn.Parameter(torch.randn(1, 1, dim))
-        self.dropout = nn.Dropout(emb_dropout)
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout)
-
-        self.pool = pool
-        self.to_latent = nn.Identity()
-
-        self.mlp_head = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, num_classes)
-        )
-
-    def forward(self, video):
-        x = self.to_patch_embedding(video)
-        b, n, _ = x.shape
-
-        cls_tokens = repeat(self.cls_token, '1 1 d -> b 1 d', b = b)
-        x = torch.cat((cls_tokens, x), dim=1)
-        x += self.pos_embedding[:, :(n + 1)]
-        x = self.dropout(x)
-
-        x = self.transformer(x)
-
-        x = x.mean(dim = 1) if self.pool == 'mean' else x[:, 0]
-
-        x = self.to_latent(x)
-        return self.mlp_head(x)

vit_pytorch/vit_for_small_dataset.py

@@ -13,11 +13,18 @@ def pair(t):
 
 # classes
 
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = nn.LayerNorm(dim)
+        self.fn = fn
+    def forward(self, x, **kwargs):
+        return self.fn(self.norm(x), **kwargs)
+
 class FeedForward(nn.Module):
     def __init__(self, dim, hidden_dim, dropout = 0.):
         super().__init__()
         self.net = nn.Sequential(
-            nn.LayerNorm(dim),
             nn.Linear(dim, hidden_dim),
             nn.GELU(),
             nn.Dropout(dropout),
@@ -34,7 +41,6 @@ class LSA(nn.Module):
         self.heads = heads
         self.temperature = nn.Parameter(torch.log(torch.tensor(dim_head ** -0.5)))
 
-        self.norm = nn.LayerNorm(dim)
         self.attend = nn.Softmax(dim = -1)
         self.dropout = nn.Dropout(dropout)
 
@@ -46,7 +52,6 @@ class LSA(nn.Module):
         )
 
     def forward(self, x):
-        x = self.norm(x)
         qkv = self.to_qkv(x).chunk(3, dim = -1)
         q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
 
@@ -69,8 +74,8 @@ class Transformer(nn.Module):
         self.layers = nn.ModuleList([])
         for _ in range(depth):
             self.layers.append(nn.ModuleList([
-                LSA(dim, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_dim, dropout = dropout)
+                PreNorm(dim, LSA(dim, heads = heads, dim_head = dim_head, dropout = dropout)),
+                PreNorm(dim, FeedForward(dim, mlp_dim, dropout = dropout))
             ]))
     def forward(self, x):
         for attn, ff in self.layers:

vit_pytorch/vit_nd.py

@@ -1,191 +0,0 @@
-from __future__ import annotations
-
-import torch
-from torch import nn
-from torch.nn import Module
-
-from einops import rearrange, repeat
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def join(arr, delimiter = ' '):
-    return delimiter.join(arr)
-
-def ensure_tuple(t, length):
-    if isinstance(t, (tuple, list)):
-        assert len(t) == length, f'Expected tuple of length {length}, got {len(t)}'
-        return tuple(t)
-    return (t,) * length
-
-# classes
-
-class FeedForward(Module):
-    def __init__(self, dim, hidden_dim, dropout = 0.):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Dropout(dropout),
-            nn.Linear(hidden_dim, dim),
-            nn.Dropout(dropout)
-        )
-    
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(Module):
-    def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0.):
-        super().__init__()
-        inner_dim = dim_head * heads
-        project_out = not (heads == 1 and dim_head == dim)
-        
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-        
-        self.norm = nn.LayerNorm(dim)
-        self.attend = nn.Softmax(dim = -1)
-        self.dropout = nn.Dropout(dropout)
-        
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-        
-        self.to_out = nn.Sequential(
-            nn.Linear(inner_dim, dim),
-            nn.Dropout(dropout)
-        ) if project_out else nn.Identity()
-    
-    def forward(self, x):
-        x = self.norm(x)
-        qkv = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-        
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-        
-        attn = self.attend(dots)
-        attn = self.dropout(attn)
-        
-        out = torch.matmul(attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0.):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim)
-        self.layers = nn.ModuleList([])
-        for _ in range(depth):
-            self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_dim, dropout = dropout)
-            ]))
-    
-    def forward(self, x):
-        for attn, ff in self.layers:
-            x = attn(x) + x
-            x = ff(x) + x
-        return self.norm(x)
-
-class ViTND(Module):
-    def __init__(
-        self,
-        *,
-        ndim: int,
-        input_shape: int | tuple[int, ...],
-        patch_size: int | tuple[int, ...],
-        num_classes: int,
-        dim: int,
-        depth: int,
-        heads: int,
-        mlp_dim: int,
-        pool: str = 'cls',
-        channels: int = 3,
-        dim_head: int = 64,
-        dropout: float = 0.,
-        emb_dropout: float = 0.
-    ):
-        super().__init__()
-        
-        assert 1 <= ndim <= 7, 'ndim must be between 1 and 7'
-        assert pool in {'cls', 'mean'}, 'pool type must be either cls (cls token) or mean (mean pooling)'
-        
-        self.ndim = ndim
-        self.pool = pool
-        
-        input_shape = ensure_tuple(input_shape, ndim)
-        patch_size = ensure_tuple(patch_size, ndim)
-        
-        for i, (inp_dim, patch_dim) in enumerate(zip(input_shape, patch_size)):
-            assert inp_dim % patch_dim == 0, f'Input dimension {i} ({inp_dim}) must be divisible by patch size ({patch_dim})'
-        
-        num_patches_per_dim = [inp_dim // patch_dim for inp_dim, patch_dim in zip(input_shape, patch_size)]
-        num_patches = 1
-        for n in num_patches_per_dim:
-            num_patches *= n
-        
-        patch_dim = channels
-        for p in patch_size:
-            patch_dim *= p
-        
-        dim_names = 'fghijkl'[:ndim]
-        
-        input_dims = [f'({d} p{i})' for i, d in enumerate(dim_names)]
-        patch_dims = [f'p{i}' for i in range(ndim)]
-        
-        input_pattern = f'b c {join(input_dims)}'
-        output_pattern = f'b ({join(dim_names)}) ({join(patch_dims)} c)'
-        rearrange_str = f'{input_pattern} -> {output_pattern}'
-        
-        rearrange_kwargs = {f'p{i}': p for i, p in enumerate(patch_size)}
-        
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange(rearrange_str, **rearrange_kwargs),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-        
-        self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))
-        self.cls_token = nn.Parameter(torch.randn(1, 1, dim))
-        self.dropout = nn.Dropout(emb_dropout)
-        
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout)
-        
-        self.to_latent = nn.Identity()
-        self.mlp_head = nn.Linear(dim, num_classes)
-    
-    def forward(self, x):
-        x = self.to_patch_embedding(x)
-        b, n, _ = x.shape
-        
-        cls_tokens = repeat(self.cls_token, '1 1 d -> b 1 d', b = b)
-        x = torch.cat((cls_tokens, x), dim = 1)
-        x += self.pos_embedding[:, :(n + 1)]
-        x = self.dropout(x)
-        
-        x = self.transformer(x)
-        
-        x = x[:, 1:].mean(dim = 1) if self.pool == 'mean' else x[:, 0]
-        
-        x = self.to_latent(x)
-        return self.mlp_head(x)
-
-
-if __name__ == '__main__':
-    
-    model = ViTND(
-        ndim = 4,
-        input_shape = (8, 16, 32, 64),
-        patch_size = (2, 4, 4, 8),
-        num_classes = 1000,
-        dim = 512,
-        depth = 6,
-        heads = 8,
-        mlp_dim = 2048,
-        channels = 3,
-        dropout = 0.1,
-        emb_dropout = 0.1
-    )
-    
-    occupancy_time = torch.randn(2, 3, 8, 16, 32, 64)
-    
-    logits = model(occupancy_time)

vit_pytorch/vit_nd_pope.py

@@ -1,353 +0,0 @@
-from __future__ import annotations
-
-import torch
-import torch.nn.functional as F
-from torch import pi, nn, arange, cat, stack, Tensor
-from torch.nn import Module, ModuleList
-from torch.amp import autocast
-
-from einops import rearrange, repeat, reduce, pack, unpack
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def exists(val):
-    return val is not None
-
-def l2norm(t):
-    return F.normalize(t, dim = -1, p = 2)
-
-def join(arr, delimiter = ' '):
-    return delimiter.join(arr)
-
-def ensure_tuple(t, length):
-    if isinstance(t, (tuple, list)):
-        assert len(t) == length, f'Expected tuple of length {length}, got {len(t)}'
-        return tuple(t)
-
-    return (t,) * length
-
-# golden gate rotary - Jerry Xiong, PhD student at UIUC
-# https://jerryxio.ng/posts/nd-rope/
-
-# but using polar version instead
-# Gopalakrishnan et al. https://arxiv.org/abs/2509.10534
-
-def _phi(m: int) -> float:
-    x = 2.0
-    for _ in range(10):
-        x = (1 + x) ** (1.0 / (m + 1.0))
-    return x
-
-def make_directions(n: int, d: int) -> Tensor:
-    g = _phi(d)
-    alpha = (1.0 / g) ** arange(1, d + 1, dtype = torch.float64)
-    i = arange(1, n + 1, dtype = torch.float64).unsqueeze(1)
-    z = torch.fmod(i * alpha, 1.0)
-    directions = torch.erfinv(2.0 * z - 1.0)
-    directions = l2norm(directions)
-    return directions.float()
-
-class GoldenGatePoPENd(Module):
-    def __init__(
-        self,
-        dim_pos: int,
-        heads: int,
-        dim_head: int,
-        min_freq: float = 1.0,
-        max_freq: float = 10000.0,
-        p_zero_freqs: float = 0.0, # proportion of frequencies set to 0
-        init_learned_bias_uniform = False
-    ):
-        super().__init__()
-        n_freqs = dim_head
-        n_zero_freqs = round(p_zero_freqs * n_freqs)
-
-        omega = cat((
-            torch.zeros(n_zero_freqs),
-            min_freq * (max_freq / min_freq) ** torch.linspace(0, 1, n_freqs - n_zero_freqs),
-        ))
-
-        directions = rearrange(
-            make_directions(heads * n_freqs, dim_pos),
-            '(h f) p -> h f p',
-            h = heads
-        )
-
-        omega_expanded = rearrange(omega, 'f -> f 1')
-        self.register_buffer('freqs', directions * omega_expanded)  # shape: (h, f, p)
-
-        self.learned_bias = nn.Parameter(torch.zeros(heads, dim_head))
-
-        if init_learned_bias_uniform:
-            self.learned_bias.uniform_(-2. * pi, 0.)
-
-    @autocast('cuda', enabled = False)
-    def forward(self, pos):
-
-        freqs = rearrange(self.freqs, 'h f p -> 1 h 1 f p')
-        positions = rearrange(pos.float(), 'b n p -> b 1 n 1 p')
-
-        # compute theta for each (batch, head, seq, freq)
-
-        theta = reduce(freqs * positions, 'b h n f p -> b h n f', 'sum')
-
-        bias = self.learned_bias.clamp(-2. * pi, 0.)
-        bias = rearrange(bias, 'h d -> h 1 d')
-
-        return theta, bias
-
-@autocast('cuda', enabled = False)
-def apply_polar_pos_emb(t, freqs):
-    orig_dtype = t.dtype
-
-    t = t.float()
-    t = F.softplus(t)
-
-    out = cat((t * freqs.cos(), t * freqs.sin()), dim = -1)
-
-    return out.type(orig_dtype)
-
-# classes
-
-class FeedForward(Module):
-    def __init__(self, dim, hidden_dim, dropout = 0.):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Dropout(dropout),
-            nn.Linear(hidden_dim, dim),
-            nn.Dropout(dropout)
-        )
-    
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(Module):
-    def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0.):
-        super().__init__()
-        inner_dim = dim_head * heads
-        project_out = not (heads == 1 and dim_head == dim)
-        
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-        
-        self.norm = nn.LayerNorm(dim)
-        self.attend = nn.Softmax(dim = -1)
-        self.dropout = nn.Dropout(dropout)
-        
-        self.to_qk = nn.Linear(dim, inner_dim * 2, bias = False)
-        self.to_v = nn.Linear(dim, inner_dim, bias = False)
-
-        self.to_out = nn.Sequential(
-            nn.Linear(inner_dim, dim),
-            nn.Dropout(dropout)
-        ) if project_out else nn.Identity()
-    
-    def forward(self, x, polar_pos_emb = None):
-        x = self.norm(x)
-        qkv = (*self.to_qk(x).chunk(2, dim = -1), self.to_v(x))
-
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        if exists(polar_pos_emb):
-            freqs, bias = polar_pos_emb
-            q = apply_polar_pos_emb(q, freqs)
-            k = apply_polar_pos_emb(k, freqs + bias)
-        
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-        
-        attn = self.attend(dots)
-        attn = self.dropout(attn)
-        
-        out = torch.matmul(attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0., polar_emb = None):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim)
-
-        self.polar_emb = polar_emb
-
-        self.layers = ModuleList([])
-
-        for _ in range(depth):
-            self.layers.append(ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_dim, dropout = dropout)
-            ]))
-    
-    def forward(self, x, pos = None):
-
-        # pope embedding
-
-        polar_pos_emb = None
-        if exists(pos) and exists(self.polar_emb):
-            polar_pos_emb = self.polar_emb(pos)
-
-        # transformer layers
-
-        for attn, ff in self.layers:
-            x = attn(x, polar_pos_emb) + x
-            x = ff(x) + x
-
-        return self.norm(x)
-
-class ViTND(Module):
-    def __init__(
-        self,
-        *,
-        ndim: int,
-        input_shape: int | tuple[int, ...],
-        patch_size: int | tuple[int, ...],
-        num_classes: int,
-        dim: int,
-        depth: int,
-        heads: int,
-        mlp_dim: int,
-        channels: int = 3,
-        dim_head: int = 64,
-        dropout: float = 0.,
-        emb_dropout: float = 0.,
-        pope_min_freq: float = 1.0,
-        pope_max_freq: float = 10000.0,
-        pope_p_zero_freqs: float = 0.0,
-        pope_init_learned_bias_uniform = False
-    ):
-        super().__init__()
-        
-        assert 1 <= ndim <= 7, 'ndim must be between 1 and 7'
-        
-        self.ndim = ndim
-        
-        input_shape = ensure_tuple(input_shape, ndim)
-        patch_size = ensure_tuple(patch_size, ndim)
-        
-        for i, (inp_dim, patch_dim) in enumerate(zip(input_shape, patch_size)):
-            assert inp_dim % patch_dim == 0, f'Input dimension {i} ({inp_dim}) must be divisible by patch size ({patch_dim})'
-        
-        num_patches_per_dim = [inp_dim // patch_dim for inp_dim, patch_dim in zip(input_shape, patch_size)]
-        num_patches = 1
-        for n in num_patches_per_dim:
-            num_patches *= n
-        
-        patch_dim = channels
-        for p in patch_size:
-            patch_dim *= p
-        
-        dim_names = 'fghijkl'[:ndim]
-        
-        input_dims = [f'({d} p{i})' for i, d in enumerate(dim_names)]
-        patch_dims = [f'p{i}' for i in range(ndim)]
-        
-        input_pattern = f'b c {join(input_dims)}'
-        output_pattern = f'b {join(dim_names)} ({join(patch_dims)} c)'
-        rearrange_str = f'{input_pattern} -> {output_pattern}'
-        
-        rearrange_kwargs = {f'p{i}': p for i, p in enumerate(patch_size)}
-        
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange(rearrange_str, **rearrange_kwargs),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-        
-        self.dropout = nn.Dropout(emb_dropout)
-        
-        # golden gate pope
-
-        self.polar_emb = GoldenGatePoPENd(
-            dim_pos = ndim,
-            heads = heads,
-            dim_head = dim_head,
-            min_freq = pope_min_freq,
-            max_freq = pope_max_freq,
-            p_zero_freqs = pope_p_zero_freqs,
-            init_learned_bias_uniform = pope_init_learned_bias_uniform
-        )
-        
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout, polar_emb = self.polar_emb)
-        
-        self.to_latent = nn.Identity()
-        self.mlp_head = nn.Linear(dim, num_classes)
-    
-    def muon_parameters(self):
-        params = []
-
-        for m in self.modules():
-            if isinstance(m, Attention):
-                params.extend([
-                    m.to_v.weight,
-                    m.to_out[0].weight
-                ])
-            elif isinstance(m, FeedForward):
-                params.extend([
-                    m.net[1].weight,
-                    m.net[-2].weight
-                ])
-
-        return params
-
-    def forward(
-        self,
-        x,
-        return_embed = False
-    ):
-        x = self.to_patch_embedding(x) # (b, *spatial_dims, patch_dim)
-        
-        batch, *spatial_dims, _, device = *x.shape, x.device
-        
-        # Generate position coordinates
-
-        grids = [arange(d, device = device, dtype = torch.float32) for d in spatial_dims]
-        grid = torch.meshgrid(*grids, indexing = 'ij')
-        pos = stack(grid, dim = -1)  # (*spatial_dims, ndim)
-
-        # flatten spatial dimensions for attention with nd rotary
-        
-        pos = repeat(pos, '... p -> b (...) p', b = batch)
-        x, packed_shape = pack([x], 'b * d')
-
-        x = self.dropout(x)
-        
-        embed = self.transformer(x, pos)
-
-        # return the embed with reconstituted patch shape
-
-        if return_embed:
-            embed, = unpack(embed, packed_shape, 'b * d')
-            return embed
-
-        # pooling to logits
-
-        pooled = reduce(embed, 'b n d -> b d', 'mean')
-
-        pooled = self.to_latent(pooled)
-        return self.mlp_head(pooled)
-
-if __name__ == '__main__':
-  
-    model = ViTND(
-        ndim = 5,
-        input_shape = (4, 8, 16, 32, 64),
-        patch_size = (2, 2, 4, 4, 8),
-        num_classes = 1000,
-        dim = 512,
-        depth = 6,
-        heads = 8,
-        mlp_dim = 2048,
-        channels = 3,
-        dropout = 0.1,
-        emb_dropout = 0.1
-    )
-
-    data = torch.randn(3, 3, 4, 8, 16, 32, 64)
-
-    logits = model(data)
-
-    embed = model(data, return_embed = True)
-    assert embed.shape == (3, 2, 4, 4, 8, 8, 512)

vit_pytorch/vit_nd_rotary.py

@@ -1,325 +0,0 @@
-from __future__ import annotations
-
-import torch
-from torch import nn, arange, cat, stack, Tensor
-from torch.nn import Module, ModuleList
-import torch.nn.functional as F
-
-from einops import rearrange, repeat, reduce, pack, unpack
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def exists(val):
-    return val is not None
-
-def l2norm(t):
-    return F.normalize(t, dim = -1, p = 2)
-
-def join(arr, delimiter = ' '):
-    return delimiter.join(arr)
-
-def ensure_tuple(t, length):
-    if isinstance(t, (tuple, list)):
-        assert len(t) == length, f'Expected tuple of length {length}, got {len(t)}'
-        return tuple(t)
-    return (t,) * length
-
-# golden gate rotary - Jerry Xiong, PhD student at UIUC
-# https://jerryxio.ng/posts/nd-rope/
-
-def _phi(m: int) -> float:
-    x = 2.0
-    for _ in range(10):
-        x = (1 + x) ** (1.0 / (m + 1.0))
-    return x
-
-def make_directions(n: int, d: int) -> Tensor:
-    g = _phi(d)
-    alpha = (1.0 / g) ** arange(1, d + 1, dtype = torch.float64)
-    i = arange(1, n + 1, dtype = torch.float64).unsqueeze(1)
-    z = torch.fmod(i * alpha, 1.0)
-    directions = torch.erfinv(2.0 * z - 1.0)
-    directions = l2norm(directions)
-    return directions.float()
-
-class GoldenGateRoPENd(Module):
-    def __init__(
-        self,
-        dim_pos: int,
-        heads: int,
-        dim_head: int,
-        rope_min_freq: float = 1.0,
-        rope_max_freq: float = 10000.0,
-        rope_p_zero_freqs: float = 0.0, # proportion of frequencies set to 0
-    ):
-        super().__init__()
-        n_freqs = dim_head // 2
-        n_zero_freqs = round(rope_p_zero_freqs * n_freqs)
-
-        omega = cat((
-            torch.zeros(n_zero_freqs),
-            rope_min_freq * (rope_max_freq / rope_min_freq) ** torch.linspace(0, 1, n_freqs - n_zero_freqs),
-        ))
-
-        directions = rearrange(
-            make_directions(heads * n_freqs, dim_pos),
-            '(h f) p -> h f p',
-            h = heads
-        )
-
-        omega_expanded = rearrange(omega, 'f -> f 1')
-        self.register_buffer('freqs', directions * omega_expanded)  # shape: (h, f, p)
-
-    def forward(self, input: Tensor, pos: Tensor) -> Tensor:
-        # input shape: (b, h, n, d) where d = head_dim
-        # pos shape: (b, n, p) where p = pos_dim
-        # self.freqs shape: (h, f, p) where f = d // 2
-        
-        x, y = input.float().chunk(2, dim = -1)  # both (b, h, n, f)
-        
-        # Expand dimensions for broadcasting
-        freqs = rearrange(self.freqs, 'h f p -> 1 h 1 f p')
-        positions = rearrange(pos.float(), 'b n p -> b 1 n 1 p')
-        
-        # Compute theta for each (batch, head, seq, freq)
-        theta = reduce(freqs * positions, 'b h n f p -> b h n f', 'sum')
-        
-        cos_theta = torch.cos(theta)
-        sin_theta = torch.sin(theta)
-        
-        # Apply rotation
-        x_out = x * cos_theta - y * sin_theta
-        y_out = x * sin_theta + y * cos_theta
-        
-        output = cat((x_out, y_out), dim=-1)
-        return output.type_as(input)
-
-# classes
-
-class FeedForward(Module):
-    def __init__(self, dim, hidden_dim, dropout = 0.):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Dropout(dropout),
-            nn.Linear(hidden_dim, dim),
-            nn.Dropout(dropout)
-        )
-    
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(Module):
-    def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0., rotary_emb = None):
-        super().__init__()
-        inner_dim = dim_head * heads
-        project_out = not (heads == 1 and dim_head == dim)
-        
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-        self.rotary_emb = rotary_emb
-        
-        self.norm = nn.LayerNorm(dim)
-        self.attend = nn.Softmax(dim = -1)
-        self.dropout = nn.Dropout(dropout)
-        
-        self.to_qk = nn.Linear(dim, inner_dim * 2, bias = False)
-        self.to_v = nn.Linear(dim, inner_dim, bias = False)
-
-        self.to_out = nn.Sequential(
-            nn.Linear(inner_dim, dim),
-            nn.Dropout(dropout)
-        ) if project_out else nn.Identity()
-    
-    def forward(self, x, pos = None):
-        x = self.norm(x)
-        qkv = (*self.to_qk(x).chunk(2, dim = -1), self.to_v(x))
-
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-        
-        # Apply rotary embeddings if available
-        if exists(self.rotary_emb):
-            assert exists(pos)
-            q = self.rotary_emb(q, pos)
-            k = self.rotary_emb(k, pos)
-        
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-        
-        attn = self.attend(dots)
-        attn = self.dropout(attn)
-        
-        out = torch.matmul(attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0., rotary_emb = None):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim)
-        self.layers = ModuleList([])
-        for _ in range(depth):
-            self.layers.append(ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout, rotary_emb = rotary_emb),
-                FeedForward(dim, mlp_dim, dropout = dropout)
-            ]))
-    
-    def forward(self, x, pos = None):
-        for attn, ff in self.layers:
-            x = attn(x, pos) + x
-            x = ff(x) + x
-        return self.norm(x)
-
-class ViTND(Module):
-    def __init__(
-        self,
-        *,
-        ndim: int,
-        input_shape: int | tuple[int, ...],
-        patch_size: int | tuple[int, ...],
-        num_classes: int,
-        dim: int,
-        depth: int,
-        heads: int,
-        mlp_dim: int,
-        channels: int = 3,
-        dim_head: int = 64,
-        dropout: float = 0.,
-        emb_dropout: float = 0.,
-        rope_min_freq: float = 1.0,
-        rope_max_freq: float = 10000.0,
-        rope_p_zero_freqs: float = 0.0
-    ):
-        super().__init__()
-        
-        assert 1 <= ndim <= 7, 'ndim must be between 1 and 7'
-        
-        self.ndim = ndim
-        
-        input_shape = ensure_tuple(input_shape, ndim)
-        patch_size = ensure_tuple(patch_size, ndim)
-        
-        for i, (inp_dim, patch_dim) in enumerate(zip(input_shape, patch_size)):
-            assert inp_dim % patch_dim == 0, f'Input dimension {i} ({inp_dim}) must be divisible by patch size ({patch_dim})'
-        
-        num_patches_per_dim = [inp_dim // patch_dim for inp_dim, patch_dim in zip(input_shape, patch_size)]
-        num_patches = 1
-        for n in num_patches_per_dim:
-            num_patches *= n
-        
-        patch_dim = channels
-        for p in patch_size:
-            patch_dim *= p
-        
-        dim_names = 'fghijkl'[:ndim]
-        
-        input_dims = [f'({d} p{i})' for i, d in enumerate(dim_names)]
-        patch_dims = [f'p{i}' for i in range(ndim)]
-        
-        input_pattern = f'b c {join(input_dims)}'
-        output_pattern = f'b {join(dim_names)} ({join(patch_dims)} c)'
-        rearrange_str = f'{input_pattern} -> {output_pattern}'
-        
-        rearrange_kwargs = {f'p{i}': p for i, p in enumerate(patch_size)}
-        
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange(rearrange_str, **rearrange_kwargs),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-        
-        self.dropout = nn.Dropout(emb_dropout)
-        
-        # Create rotary embeddings
-        self.rotary_emb = GoldenGateRoPENd(
-            dim_pos = ndim,
-            heads = heads,
-            dim_head = dim_head,
-            rope_min_freq = rope_min_freq,
-            rope_max_freq = rope_max_freq,
-            rope_p_zero_freqs = rope_p_zero_freqs
-        )
-        
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout, rotary_emb = self.rotary_emb)
-        
-        self.to_latent = nn.Identity()
-        self.mlp_head = nn.Linear(dim, num_classes)
-    
-    def muon_parameters(self):
-        params = []
-
-        for m in self.modules():
-            if isinstance(m, Attention):
-                params.extend([
-                    m.to_v.weight,
-                    m.to_out[0].weight
-                ])
-            elif isinstance(m, FeedForward):
-                params.extend([
-                    m.net[1].weight,
-                    m.net[-2].weight
-                ])
-
-        return params
-
-    def forward(
-        self,
-        x,
-        return_embed = False
-    ):
-        x = self.to_patch_embedding(x) # (b, *spatial_dims, patch_dim)
-        
-        batch, *spatial_dims, _, device = *x.shape, x.device
-        
-        # Generate position coordinates
-
-        grids = [arange(d, device = device, dtype = torch.float32) for d in spatial_dims]
-        grid = torch.meshgrid(*grids, indexing = 'ij')
-        pos = stack(grid, dim = -1)  # (*spatial_dims, ndim)
-
-        # flatten spatial dimensions for attention with nd rotary
-        
-        pos = repeat(pos, '... p -> b (...) p', b = batch)
-        x, packed_shape = pack([x], 'b * d')
-
-        x = self.dropout(x)
-        
-        embed = self.transformer(x, pos)
-
-        # return the embed with reconstituted patch shape
-
-        if return_embed:
-            embed, = unpack(embed, packed_shape, 'b * d')
-            return embed
-
-        # pooling to logits
-
-        pooled = reduce(embed, 'b n d -> b d', 'mean')
-
-        pooled = self.to_latent(pooled)
-        return self.mlp_head(pooled)
-
-
-if __name__ == '__main__':
-  
-    model = ViTND(
-        ndim = 5,
-        input_shape = (4, 8, 16, 32, 64),
-        patch_size = (2, 2, 4, 4, 8),
-        num_classes = 1000,
-        dim = 512,
-        depth = 6,
-        heads = 8,
-        mlp_dim = 2048,
-        channels = 3,
-        dropout = 0.1,
-        emb_dropout = 0.1
-    )
-
-    data = torch.randn(2, 3, 4, 8, 16, 32, 64)
-
-    logits = model(data)
-
-    embed = model(data, return_embed = True) # (2, 2, 4, 4, 8, 8, 512)

vit_pytorch/vit_with_decorr.py

@@ -1,234 +0,0 @@
-# https://arxiv.org/abs/2510.14657
-# but instead of their decorr module updated with SGD, remove all projections and just return a decorrelation auxiliary loss
-
-import torch
-from torch import nn, stack, tensor
-import torch.nn.functional as F
-from torch.nn import Module, ModuleList
-
-from einops import rearrange, repeat, reduce, einsum, pack, unpack
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def exists(v):
-    return v is not None
-
-def default(v, d):
-    return v if exists(v) else d
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-# decorr loss
-
-class DecorrelationLoss(Module):
-    def __init__(
-        self,
-        sample_frac = 1.,
-        soft_validate_num_sampled = False
-    ):
-        super().__init__()
-        assert 0. <= sample_frac <= 1.
-        self.need_sample = sample_frac < 1.
-        self.sample_frac = sample_frac
-
-        self.soft_validate_num_sampled = soft_validate_num_sampled
-        self.register_buffer('zero', tensor(0.), persistent = False)
-
-    def forward(
-        self,
-        tokens
-    ):
-        batch, seq_len, dim, device = *tokens.shape[-3:], tokens.device
-
-        if self.need_sample:
-            num_sampled = int(seq_len * self.sample_frac)
-
-            assert self.soft_validate_num_sampled or num_sampled >= 2.
-
-            if num_sampled <= 1:
-                return self.zero
-
-            tokens, packed_shape = pack([tokens], '* n d e')
-
-            indices = torch.randn(tokens.shape[:2]).argsort(dim = -1)[..., :num_sampled, :]
-
-            batch_arange = torch.arange(tokens.shape[0], device = tokens.device)
-            batch_arange = rearrange(batch_arange, 'b -> b 1')
-
-            tokens = tokens[batch_arange, indices]
-            tokens, = unpack(tokens, packed_shape, '* n d e')
-
-        dist = einsum(tokens, tokens, '... n d, ... n e -> ... d e') / tokens.shape[-2]
-        eye = torch.eye(dim, device = device)
-
-        loss = dist.pow(2) * (1. - eye) / ((dim - 1) * dim)
-
-        loss = reduce(loss, '... b d e -> b', 'sum')
-        return loss.mean()
-
-# classes
-
-class FeedForward(Module):
-    def __init__(self, dim, hidden_dim, dropout = 0.):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim)
-
-        self.net = nn.Sequential(
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Dropout(dropout),
-            nn.Linear(hidden_dim, dim),
-            nn.Dropout(dropout)
-        )
-
-    def forward(self, x):
-        normed = self.norm(x)
-        return self.net(x), normed
-
-class Attention(Module):
-    def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0.):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        project_out = not (heads == 1 and dim_head == dim)
-
-        self.norm = nn.LayerNorm(dim)
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-
-        self.attend = nn.Softmax(dim = -1)
-        self.dropout = nn.Dropout(dropout)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-
-        self.to_out = nn.Sequential(
-            nn.Linear(inner_dim, dim),
-            nn.Dropout(dropout)
-        ) if project_out else nn.Identity()
-
-    def forward(self, x):
-        normed = self.norm(x)
-
-        qkv = self.to_qkv(normed).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-
-        attn = self.attend(dots)
-        attn = self.dropout(attn)
-
-        out = torch.matmul(attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-
-        return self.to_out(out), normed
-
-class Transformer(Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0.):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim)
-        self.layers = ModuleList([])
-
-        for _ in range(depth):
-            self.layers.append(ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_dim, dropout = dropout)
-            ]))
-
-    def forward(self, x):
-
-        normed_inputs = []
-
-        for attn, ff in self.layers:
-            attn_out, attn_normed_inp = attn(x)
-            x = attn_out + x
-
-            ff_out, ff_normed_inp = ff(x)
-            x = ff_out + x
-
-            normed_inputs.append(attn_normed_inp)
-            normed_inputs.append(ff_normed_inp)
-
-        return self.norm(x), stack(normed_inputs)
-
-class ViT(Module):
-    def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, pool = 'cls', channels = 3, dim_head = 64, dropout = 0., emb_dropout = 0., decorr_sample_frac = 1.):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(patch_size)
-
-        assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
-
-        num_patches = (image_height // patch_height) * (image_width // patch_width)
-        patch_dim = channels * patch_height * patch_width
-        assert pool in {'cls', 'mean'}, 'pool type must be either cls (cls token) or mean (mean pooling)'
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))
-        self.cls_token = nn.Parameter(torch.randn(1, 1, dim))
-        self.dropout = nn.Dropout(emb_dropout)
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout)
-
-        self.pool = pool
-        self.to_latent = nn.Identity()
-
-        self.mlp_head = nn.Linear(dim, num_classes)
-
-        # decorrelation loss related
-
-        self.has_decorr_loss = decorr_sample_frac > 0.
-
-        if self.has_decorr_loss:
-            self.decorr_loss = DecorrelationLoss(decorr_sample_frac)
-
-        self.register_buffer('zero', torch.tensor(0.), persistent = False)
-
-    def forward(
-        self,
-        img,
-        return_decorr_aux_loss = None
-    ):
-        return_decorr_aux_loss = default(return_decorr_aux_loss, self.training) and self.has_decorr_loss
-
-        x = self.to_patch_embedding(img)
-        b, n, _ = x.shape
-
-        cls_tokens = repeat(self.cls_token, '1 1 d -> b 1 d', b = b)
-        x = torch.cat((cls_tokens, x), dim=1)
-        x += self.pos_embedding[:, :(n + 1)]
-        x = self.dropout(x)
-
-        x, normed_layer_inputs = self.transformer(x)
-
-        # maybe return decor loss
-
-        decorr_aux_loss = self.zero
-
-        if return_decorr_aux_loss:
-            decorr_aux_loss = self.decorr_loss(normed_layer_inputs)
-
-        x = x.mean(dim = 1) if self.pool == 'mean' else x[:, 0]
-
-        x = self.to_latent(x)
-        return self.mlp_head(x), decorr_aux_loss
-
-# quick test
-
-if __name__ == '__main__':
-    decorr_loss = DecorrelationLoss(0.1)
-
-    hiddens = torch.randn(6, 2, 512, 256)
-
-    decorr_loss(hiddens)
-    decorr_loss(hiddens[0])
-
-    decorr_loss = DecorrelationLoss(0.0001, soft_validate_num_sampled = True)
-    out = decorr_loss(hiddens)
-    assert out.item() == 0

vit_pytorch/vit_with_keel_post_ln.py

@@ -1,217 +0,0 @@
-from __future__ import annotations
-
-import torch
-from torch import nn
-from torch.nn import Module, ModuleList
-
-from einops import rearrange, repeat
-from einops.layers.torch import Rearrange
-
-# functions
-
-def exists(v):
-    return v is not None
-
-def default(v, d):
-    return v if exists(v) else d
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-# classes
-
-class FeedForward(Module):
-    def __init__(self, dim, hidden_dim, dropout = 0.):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim, bias = False),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Dropout(dropout),
-            nn.Linear(hidden_dim, dim),
-            nn.Dropout(dropout)
-        )
-
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(Module):
-    def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0.):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        project_out = not (heads == 1 and dim_head == dim)
-
-        self.norm = nn.LayerNorm(dim, bias = False)
-
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-
-        self.attend = nn.Softmax(dim = -1)
-        self.dropout = nn.Dropout(dropout)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-
-        self.to_out = nn.Sequential(
-            nn.Linear(inner_dim, dim),
-            nn.Dropout(dropout)
-        ) if project_out else nn.Identity()
-
-    def forward(self, x):
-        x = self.norm(x)
-
-        qkv = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-
-        attn = self.attend(dots)
-        attn = self.dropout(attn)
-
-        out = torch.matmul(attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(Module):
-    def __init__(
-        self,
-        dim,
-        depth,
-        heads,
-        dim_head,
-        mlp_dim,
-        dropout = 0.,
-        keel_residual_scale = None
-    ):
-        super().__init__()
-        assert depth > 1
-
-        self.layers = ModuleList([])
-
-        for _ in range(depth):
-            self.layers.extend([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_dim, dropout = dropout)
-            ])
-
-        num_layers = depth * 2
-        self.keel_residual_scale = default(keel_residual_scale, num_layers)
-
-        self.post_norms = ModuleList([nn.LayerNorm(dim, bias = False) for _ in range(num_layers - 1)])
-
-    def forward(self, x):
-        residual_scale = self.keel_residual_scale
-
-        for layer_ind, layer in enumerate(self.layers):
-            first_layer = layer_ind == 0
-        
-            residual = x
-
-            out = layer(x)
-
-            if first_layer:
-                x = out + residual
-                continue
-
-            post_norm = self.post_norms[layer_ind - 1]
-
-            x = post_norm(out + residual * residual_scale)
-
-        return x
-
-class ViT(Module):
-    def __init__(
-        self,
-        *,
-        image_size,
-        patch_size,
-        num_classes,
-        dim,
-        depth,
-        heads,
-        mlp_dim,
-        pool = 'cls',
-        channels = 3,
-        dim_head = 64,
-        dropout = 0.,
-        emb_dropout = 0.,
-        keel_residual_scale = None
-    ):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(patch_size)
-
-        assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
-
-        num_patches = (image_height // patch_height) * (image_width // patch_width)
-        patch_dim = channels * patch_height * patch_width
-
-        assert pool in {'cls', 'mean'}, 'pool type must be either cls (cls token) or mean (mean pooling)'
-        num_cls_tokens = 1 if pool == 'cls' else 0
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim),
-        )
-
-        self.cls_token = nn.Parameter(torch.randn(num_cls_tokens, dim))
-        self.pos_embedding = nn.Parameter(torch.randn(num_patches + num_cls_tokens, dim))
-
-        self.dropout = nn.Dropout(emb_dropout)
-
-        self.transformer = Transformer(
-            dim,
-            depth,
-            heads,
-            dim_head,
-            mlp_dim,
-            dropout,
-            keel_residual_scale = keel_residual_scale
-        )
-
-        self.pool = pool
-        self.to_latent = nn.Identity()
-
-        self.mlp_head = nn.Linear(dim, num_classes) if num_classes > 0 else None
-
-    def forward(self, img):
-        batch = img.shape[0]
-        x = self.to_patch_embedding(img)
-
-        cls_tokens = repeat(self.cls_token, '... d -> b ... d', b = batch)
-        x = torch.cat((cls_tokens, x), dim = 1)
-
-        seq = x.shape[1]
-
-        x = x + self.pos_embedding[:seq]
-        x = self.dropout(x)
-
-        x = self.transformer(x)
-
-        if not exists(self.mlp_head):
-            return x
-
-        x = x.mean(dim = 1) if self.pool == 'mean' else x[:, 0]
-
-        x = self.to_latent(x)
-        return self.mlp_head(x)
-
-if __name__ == '__main__':
-    v = ViT(
-        image_size = 256,
-        patch_size = 32,
-        num_classes = 1000,
-        dim = 1024,
-        depth = 6,
-        heads = 16,
-        mlp_dim = 2048,
-        dropout = 0.1,
-        emb_dropout = 0.1
-    )
-
-    img = torch.randn(1, 3, 256, 256)
-
-    preds = v(img)
-
-    assert preds.shape == (1, 1000)

vit_pytorch/vit_with_patch_dropout.py

@@ -1,147 +0,0 @@
-import torch
-from torch import nn
-
-from einops import rearrange, repeat
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-# classes
-
-class PatchDropout(nn.Module):
-    def __init__(self, prob):
-        super().__init__()
-        assert 0 <= prob < 1.
-        self.prob = prob
-
-    def forward(self, x):
-        if not self.training or self.prob == 0.:
-            return x
-
-        b, n, _, device = *x.shape, x.device
-
-        batch_indices = torch.arange(b, device = device)
-        batch_indices = rearrange(batch_indices, '... -> ... 1')
-        num_patches_keep = max(1, int(n * (1 - self.prob)))
-        patch_indices_keep = torch.randn(b, n, device = device).topk(num_patches_keep, dim = -1).indices
-
-        return x[batch_indices, patch_indices_keep]
-
-class FeedForward(nn.Module):
-    def __init__(self, dim, hidden_dim, dropout = 0.):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Dropout(dropout),
-            nn.Linear(hidden_dim, dim),
-            nn.Dropout(dropout)
-        )
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(nn.Module):
-    def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0.):
-        super().__init__()
-        inner_dim = dim_head *  heads
-        project_out = not (heads == 1 and dim_head == dim)
-
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-
-        self.norm = nn.LayerNorm(dim)
-        self.attend = nn.Softmax(dim = -1)
-        self.dropout = nn.Dropout(dropout)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-
-        self.to_out = nn.Sequential(
-            nn.Linear(inner_dim, dim),
-            nn.Dropout(dropout)
-        ) if project_out else nn.Identity()
-
-    def forward(self, x):
-        x = self.norm(x)
-        qkv = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-
-        attn = self.attend(dots)
-        attn = self.dropout(attn)
-
-        out = torch.matmul(attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(nn.Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0.):
-        super().__init__()
-        self.layers = nn.ModuleList([])
-        for _ in range(depth):
-            self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_dim, dropout = dropout)
-            ]))
-    def forward(self, x):
-        for attn, ff in self.layers:
-            x = attn(x) + x
-            x = ff(x) + x
-        return x
-
-class ViT(nn.Module):
-    def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, pool = 'cls', channels = 3, dim_head = 64, dropout = 0., emb_dropout = 0., patch_dropout = 0.25):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(patch_size)
-
-        assert image_height % patch_height == 0 and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
-
-        num_patches = (image_height // patch_height) * (image_width // patch_width)
-        patch_dim = channels * patch_height * patch_width
-        assert pool in {'cls', 'mean'}, 'pool type must be either cls (cls token) or mean (mean pooling)'
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_height, p2 = patch_width),
-            nn.Linear(patch_dim, dim),
-        )
-
-        self.pos_embedding = nn.Parameter(torch.randn(num_patches, dim))
-        self.cls_token = nn.Parameter(torch.randn(1, 1, dim))
-
-        self.patch_dropout = PatchDropout(patch_dropout)
-        self.dropout = nn.Dropout(emb_dropout)
-
-        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout)
-
-        self.pool = pool
-        self.to_latent = nn.Identity()
-
-        self.mlp_head = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, num_classes)
-        )
-
-    def forward(self, img):
-        x = self.to_patch_embedding(img)
-        b, n, _ = x.shape
-
-        x += self.pos_embedding
-
-        x = self.patch_dropout(x)
-
-        cls_tokens = repeat(self.cls_token, '1 1 d -> b 1 d', b = b)
-
-        x = torch.cat((cls_tokens, x), dim=1)
-        x = self.dropout(x)
-
-        x = self.transformer(x)
-
-        x = x.mean(dim = 1) if self.pool == 'mean' else x[:, 0]
-
-        x = self.to_latent(x)
-        return self.mlp_head(x)

vit_pytorch/vit_with_patch_merger.py

@@ -32,11 +32,18 @@ class PatchMerger(nn.Module):
 
 # classes
 
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.norm = nn.LayerNorm(dim)
+        self.fn = fn
+    def forward(self, x, **kwargs):
+        return self.fn(self.norm(x), **kwargs)
+
 class FeedForward(nn.Module):
     def __init__(self, dim, hidden_dim, dropout = 0.):
         super().__init__()
         self.net = nn.Sequential(
-            nn.LayerNorm(dim),
             nn.Linear(dim, hidden_dim),
             nn.GELU(),
             nn.Dropout(dropout),
@@ -55,7 +62,6 @@ class Attention(nn.Module):
         self.heads = heads
         self.scale = dim_head ** -0.5
 
-        self.norm = nn.LayerNorm(dim)
         self.attend = nn.Softmax(dim = -1)
         self.dropout = nn.Dropout(dropout)
 
@@ -67,7 +73,6 @@ class Attention(nn.Module):
         ) if project_out else nn.Identity()
 
     def forward(self, x):
-        x = self.norm(x)
         qkv = self.to_qkv(x).chunk(3, dim = -1)
         q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
 
@@ -83,7 +88,6 @@ class Attention(nn.Module):
 class Transformer(nn.Module):
     def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0., patch_merge_layer = None, patch_merge_num_tokens = 8):
         super().__init__()
-        self.norm = nn.LayerNorm(dim)
         self.layers = nn.ModuleList([])
 
         self.patch_merge_layer_index = default(patch_merge_layer, depth // 2) - 1 # default to mid-way through transformer, as shown in paper
@@ -91,8 +95,8 @@ class Transformer(nn.Module):
 
         for _ in range(depth):
             self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout),
-                FeedForward(dim, mlp_dim, dropout = dropout)
+                PreNorm(dim, Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout)),
+                PreNorm(dim, FeedForward(dim, mlp_dim, dropout = dropout))
             ]))
     def forward(self, x):
         for index, (attn, ff) in enumerate(self.layers):
@@ -102,7 +106,7 @@ class Transformer(nn.Module):
             if index == self.patch_merge_layer_index:
                 x = self.patch_merger(x)
 
-        return self.norm(x)
+        return x
 
 class ViT(nn.Module):
     def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, patch_merge_layer = None, patch_merge_num_tokens = 8, channels = 3, dim_head = 64, dropout = 0., emb_dropout = 0.):
@@ -117,9 +121,7 @@ class ViT(nn.Module):
 
         self.to_patch_embedding = nn.Sequential(
             Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_height, p2 = patch_width),
-            nn.LayerNorm(patch_dim),
             nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim)
         )
 
         self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))
@@ -129,6 +131,7 @@ class ViT(nn.Module):
 
         self.mlp_head = nn.Sequential(
             Reduce('b n d -> b d', 'mean'),
+            nn.LayerNorm(dim),
             nn.Linear(dim, num_classes)
         )
 

vit_pytorch/vivit.py

@@ -1,305 +0,0 @@
-from collections import namedtuple
-
-import torch
-from torch import nn, cat
-import torch.nn.functional as F
-from torch.nn import Module, ModuleList
-from torch.nn.attention import SDPBackend, sdpa_kernel
-
-from einops import rearrange, repeat, reduce
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def exists(val):
-    return val is not None
-
-def divisible_by(num, den):
-    return (num % den) == 0
-
-def pair(t):
-    return t if isinstance(t, tuple) else (t, t)
-
-# classes
-
-class FeedForward(Module):
-    def __init__(self, dim, hidden_dim, dropout = 0.):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Dropout(dropout),
-            nn.Linear(hidden_dim, dim),
-            nn.Dropout(dropout)
-        )
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(Module):
-    def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0., use_flash_attn = True):
-        super().__init__()
-        self.use_flash_attn = use_flash_attn
-        self.dropout_p = dropout
-        inner_dim = dim_head *  heads
-        project_out = not (heads == 1 and dim_head == dim)
-
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-
-        self.norm = nn.LayerNorm(dim)
-        self.attend = nn.Softmax(dim = -1)
-        self.dropout = nn.Dropout(dropout)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-
-        self.to_out = nn.Sequential(
-            nn.Linear(inner_dim, dim),
-            nn.Dropout(dropout)
-        ) if project_out else nn.Identity()
-
-    def flash_attn(self, q, k, v, mask = None):
-
-        with sdpa_kernel([SDPBackend.MATH, SDPBackend.EFFICIENT_ATTENTION, SDPBackend.FLASH_ATTENTION, SDPBackend.CUDNN_ATTENTION]):
-
-            out = F.scaled_dot_product_attention(
-                q, k, v,
-                attn_mask = mask,
-                dropout_p = self.dropout_p,
-                is_causal = False,
-                scale = self.scale
-            )
-
-        return out
-
-    def forward(self, x, mask = None):
-        batch, seq, _ = x.shape
-
-        x = self.norm(x)
-        qkv = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = self.heads), qkv)
-
-        if exists(mask):
-            mask = rearrange(mask, 'b j -> b 1 1 j')
-
-        if self.use_flash_attn:
-            out =  self.flash_attn(q, k, v, mask = mask)
-
-        else:
-            dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
-
-            if exists(mask):
-                dots = dots.masked_fill(~mask, -torch.finfo(dots.dtype).max)
-
-            attn = self.attend(dots)
-            attn = self.dropout(attn)
-
-            out = torch.matmul(attn, v)
-
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class Transformer(Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0., use_flash_attn = True):
-        super().__init__()
-        self.use_flash_attn = use_flash_attn
-
-        self.norm = nn.LayerNorm(dim)
-        self.layers = ModuleList([])
-        for _ in range(depth):
-            self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout, use_flash_attn = use_flash_attn),
-                FeedForward(dim, mlp_dim, dropout = dropout)
-            ]))
-
-    def forward(self, x, mask = None):
-
-        for attn, ff in self.layers:
-            x = attn(x, mask = mask) + x
-            x = ff(x) + x
-
-        return self.norm(x)
-
-class FactorizedTransformer(Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0., use_flash_attn = True):
-        super().__init__()
-        self.use_flash_attn = use_flash_attn
-
-        self.norm = nn.LayerNorm(dim)
-        self.layers = nn.ModuleList([])
-
-        for _ in range(depth):
-            self.layers.append(nn.ModuleList([
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout, use_flash_attn = use_flash_attn),
-                Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout, use_flash_attn = use_flash_attn),
-                FeedForward(dim, mlp_dim, dropout = dropout)
-            ]))
-
-    def forward(self, x, mask = None):
-        batch, frames, seq, _ = x.shape
-
-        if exists(mask):
-            mask = repeat(mask, 'b ... -> (b space) ...', space = x.shape[2])
-
-        for spatial_attn, temporal_attn, ff in self.layers:
-            x = rearrange(x, 'b f n d -> (b f) n d')
-            x = spatial_attn(x) + x
-            x = rearrange(x, '(b f) n d -> (b n) f d', b = batch, f = frames)
-            x = temporal_attn(x, mask = mask) + x
-            x = ff(x) + x
-            x = rearrange(x, '(b n) f d -> b f n d', b = batch, n = seq)
-
-        return self.norm(x)
-
-class ViViT(Module):
-    def __init__(
-        self,
-        *,
-        image_size,
-        image_patch_size,
-        frames,
-        frame_patch_size,
-        num_classes,
-        dim,
-        spatial_depth,
-        temporal_depth,
-        heads,
-        mlp_dim,
-        pool = 'cls',
-        channels = 3,
-        dim_head = 64,
-        dropout = 0.,
-        emb_dropout = 0.,
-        variant = 'factorized_encoder',
-        use_flash_attn: bool = True,
-    ):
-        super().__init__()
-        image_height, image_width = pair(image_size)
-        patch_height, patch_width = pair(image_patch_size)
-
-        assert divisible_by(image_height, patch_height) and image_width % patch_width == 0, 'Image dimensions must be divisible by the patch size.'
-        assert divisible_by(frames, frame_patch_size), 'Frames must be divisible by frame patch size'
-        assert variant in ('factorized_encoder', 'factorized_self_attention'), f'variant = {variant} is not implemented'
-
-        num_image_patches = (image_height // patch_height) * (image_width // patch_width)
-        num_frame_patches = (frames // frame_patch_size)
-
-        patch_dim = channels * patch_height * patch_width * frame_patch_size
-
-        assert pool in {'cls', 'mean'}, 'pool type must be either cls (cls token) or mean (mean pooling)'
-
-        self.frame_patch_size = frame_patch_size
-
-        self.global_average_pool = pool == 'mean'
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange('b c (f pf) (h p1) (w p2) -> b f (h w) (pf p1 p2 c)', p1 = patch_height, p2 = patch_width, pf = frame_patch_size),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim)
-        )
-
-        self.pos_embedding = nn.Parameter(torch.randn(1, num_frame_patches, num_image_patches, dim))
-        self.dropout = nn.Dropout(emb_dropout)
-
-        self.spatial_cls_token = nn.Parameter(torch.randn(1, 1, dim)) if not self.global_average_pool else None
-
-        if variant == 'factorized_encoder':
-            self.temporal_cls_token = nn.Parameter(torch.randn(1, 1, dim)) if not self.global_average_pool else None
-            self.spatial_transformer = Transformer(dim, spatial_depth, heads, dim_head, mlp_dim, dropout, use_flash_attn)
-            self.temporal_transformer = Transformer(dim, temporal_depth, heads, dim_head, mlp_dim, dropout, use_flash_attn)
-        elif variant == 'factorized_self_attention':
-            assert spatial_depth == temporal_depth, 'Spatial and temporal depth must be the same for factorized self-attention'
-            self.factorized_transformer = FactorizedTransformer(dim, spatial_depth, heads, dim_head, mlp_dim, dropout, use_flash_attn)
-
-        self.pool = pool
-        self.to_latent = nn.Identity()
-
-        self.mlp_head = nn.Linear(dim, num_classes)
-        self.variant = variant
-
-    def forward(self, video, mask = None):
-        device = video.device
-
-        x = self.to_patch_embedding(video)
-        batch, frames, seq, _ = x.shape
-
-        x = x + self.pos_embedding[:, :frames, :seq]
-
-        if exists(self.spatial_cls_token):
-            spatial_cls_tokens = repeat(self.spatial_cls_token, '1 1 d -> b f 1 d', b = batch, f = frames)
-            x = cat((spatial_cls_tokens, x), dim = 2)
-
-        x = self.dropout(x)
-
-        # maybe temporal mask
-
-        temporal_mask = None
-
-        if exists(mask):
-            temporal_mask = reduce(mask, 'b (f patch) -> b f', 'all', patch = self.frame_patch_size)
-
-        # the two variants
-
-        if self.variant == 'factorized_encoder':
-            x = rearrange(x, 'b f n d -> (b f) n d')
-
-            # attend across space
-
-            x = self.spatial_transformer(x)
-            x = rearrange(x, '(b f) n d -> b f n d', b = batch)
-
-            # excise out the spatial cls tokens or average pool for temporal attention
-
-            x = x[:, :, 0] if not self.global_average_pool else reduce(x, 'b f n d -> b f d', 'mean')
-
-            # append temporal CLS tokens
-
-            if exists(self.temporal_cls_token):
-                temporal_cls_tokens = repeat(self.temporal_cls_token, '1 1 d-> b 1 d', b = batch)
-
-                x = cat((temporal_cls_tokens, x), dim = 1)
-
-                if exists(temporal_mask):
-                    temporal_mask = F.pad(temporal_mask, (1, 0), value = True)
-
-            # attend across time
-
-            x = self.temporal_transformer(x, mask = temporal_mask)
-
-            # excise out temporal cls token or average pool
-
-            x = x[:, 0] if not self.global_average_pool else reduce(x, 'b f d -> b d', 'mean')
-
-        elif self.variant == 'factorized_self_attention':
-
-            x = self.factorized_transformer(x, mask = temporal_mask)
-
-            x = x[:, 0, 0] if not self.global_average_pool else reduce(x, 'b f n d -> b d', 'mean')
-
-        x = self.to_latent(x)
-        return self.mlp_head(x)
-
-# main
-
-if __name__ == '__main__':
-
-    vivit = ViViT(
-        dim = 512,
-        spatial_depth = 2,
-        temporal_depth = 2,
-        heads = 4,
-        mlp_dim = 2048,
-        image_size = 256,
-        image_patch_size = 16,
-        frames = 8,
-        frame_patch_size = 2,
-        num_classes = 1000,
-        variant = 'factorized_encoder',
-    )
-
-    video = torch.randn(3, 3, 8, 256, 256)
-    mask = torch.randint(0, 2, (3, 8)).bool()
-
-    logits = vivit(video, mask = None)
-    assert logits.shape == (3, 1000)

vit_pytorch/xcit.py

@@ -1,283 +0,0 @@
-from random import randrange
-
-import torch
-from torch import nn, einsum
-from torch.nn import Module, ModuleList
-import torch.nn.functional as F
-
-from einops import rearrange, repeat, pack, unpack
-from einops.layers.torch import Rearrange
-
-# helpers
-
-def exists(val):
-    return val is not None
-
-def pack_one(t, pattern):
-    return pack([t], pattern)
-
-def unpack_one(t, ps, pattern):
-    return unpack(t, ps, pattern)[0]
-
-def l2norm(t):
-    return F.normalize(t, dim = -1, p = 2)
-
-def dropout_layers(layers, dropout):
-    if dropout == 0:
-        return layers
-
-    num_layers = len(layers)
-    to_drop = torch.zeros(num_layers).uniform_(0., 1.) < dropout
-
-    # make sure at least one layer makes it
-    if all(to_drop):
-        rand_index = randrange(num_layers)
-        to_drop[rand_index] = False
-
-    layers = [layer for (layer, drop) in zip(layers, to_drop) if not drop]
-    return layers
-
-# classes
-
-class LayerScale(Module):
-    def __init__(self, dim, fn, depth):
-        super().__init__()
-        if depth <= 18:
-            init_eps = 0.1
-        elif 18 > depth <= 24:
-            init_eps = 1e-5
-        else:
-            init_eps = 1e-6
-
-        self.fn = fn
-        self.scale = nn.Parameter(torch.full((dim,), init_eps))
-
-    def forward(self, x, **kwargs):
-        return self.fn(x, **kwargs) * self.scale
-
-class FeedForward(Module):
-    def __init__(self, dim, hidden_dim, dropout = 0.):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Dropout(dropout),
-            nn.Linear(hidden_dim, dim),
-            nn.Dropout(dropout)
-        )
-    def forward(self, x):
-        return self.net(x)
-
-class Attention(Module):
-    def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0.):
-        super().__init__()
-        inner_dim = dim_head * heads
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-
-        self.norm = nn.LayerNorm(dim)
-        self.to_q = nn.Linear(dim, inner_dim, bias = False)
-        self.to_kv = nn.Linear(dim, inner_dim * 2, bias = False)
-
-        self.attend = nn.Softmax(dim = -1)
-        self.dropout = nn.Dropout(dropout)
-
-        self.to_out = nn.Sequential(
-            nn.Linear(inner_dim, dim),
-            nn.Dropout(dropout)
-        )
-
-    def forward(self, x, context = None):
-        h = self.heads
-
-        x = self.norm(x)
-        context = x if not exists(context) else torch.cat((x, context), dim = 1)
-
-        qkv = (self.to_q(x), *self.to_kv(context).chunk(2, dim = -1))
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = h), qkv)
-
-        sim = einsum('b h i d, b h j d -> b h i j', q, k) * self.scale
-
-        attn = self.attend(sim)
-        attn = self.dropout(attn)
-
-        out = einsum('b h i j, b h j d -> b h i d', attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-class XCAttention(Module):
-    def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0.):
-        super().__init__()
-        inner_dim = dim_head * heads
-        self.heads = heads
-        self.norm = nn.LayerNorm(dim)
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-
-        self.temperature = nn.Parameter(torch.ones(heads, 1, 1))
-
-        self.attend = nn.Softmax(dim = -1)
-        self.dropout = nn.Dropout(dropout)
-
-        self.to_out = nn.Sequential(
-            nn.Linear(inner_dim, dim),
-            nn.Dropout(dropout)
-        )
-
-    def forward(self, x):
-        h = self.heads
-        x, ps = pack_one(x, 'b * d')
-
-        x = self.norm(x)
-        q, k, v = self.to_qkv(x).chunk(3, dim = -1)
-
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h d n', h = h), (q, k, v))
-
-        q, k = map(l2norm, (q, k))
-
-        sim = einsum('b h i n, b h j n -> b h i j', q, k) * self.temperature.exp()
-
-        attn = self.attend(sim)
-        attn = self.dropout(attn)
-
-        out = einsum('b h i j, b h j n -> b h i n', attn, v)
-        out = rearrange(out, 'b h d n -> b n (h d)')
-
-        out = unpack_one(out, ps, 'b * d')
-        return self.to_out(out)
-
-class LocalPatchInteraction(Module):
-    def __init__(self, dim, kernel_size = 3):
-        super().__init__()
-        assert (kernel_size % 2) == 1
-        padding = kernel_size // 2
-
-        self.net = nn.Sequential(
-            nn.LayerNorm(dim),
-            Rearrange('b h w c -> b c h w'),
-            nn.Conv2d(dim, dim, kernel_size, padding = padding, groups = dim),
-            nn.BatchNorm2d(dim),
-            nn.GELU(),
-            nn.Conv2d(dim, dim, kernel_size, padding = padding, groups = dim),
-            Rearrange('b c h w -> b h w c'),
-        )
-
-    def forward(self, x):
-        return self.net(x)
-
-class Transformer(Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0., layer_dropout = 0.):
-        super().__init__()
-        self.layers = ModuleList([])
-        self.layer_dropout = layer_dropout
-
-        for ind in range(depth):
-            layer = ind + 1
-            self.layers.append(ModuleList([
-                LayerScale(dim, Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout), depth = layer),
-                LayerScale(dim, FeedForward(dim, mlp_dim, dropout = dropout), depth = layer)
-            ]))
-
-    def forward(self, x, context = None):
-        layers = dropout_layers(self.layers, dropout = self.layer_dropout)
-
-        for attn, ff in layers:
-            x = attn(x, context = context) + x
-            x = ff(x) + x
-
-        return x
-
-class XCATransformer(Module):
-    def __init__(self, dim, depth, heads, dim_head, mlp_dim, local_patch_kernel_size = 3, dropout = 0., layer_dropout = 0.):
-        super().__init__()
-        self.layers = ModuleList([])
-        self.layer_dropout = layer_dropout
-
-        for ind in range(depth):
-            layer = ind + 1
-            self.layers.append(ModuleList([
-                LayerScale(dim, XCAttention(dim, heads = heads, dim_head = dim_head, dropout = dropout), depth = layer),
-                LayerScale(dim, LocalPatchInteraction(dim, local_patch_kernel_size), depth = layer),
-                LayerScale(dim, FeedForward(dim, mlp_dim, dropout = dropout), depth = layer)
-            ]))
-
-    def forward(self, x):
-        layers = dropout_layers(self.layers, dropout = self.layer_dropout)
-
-        for cross_covariance_attn, local_patch_interaction, ff in layers:
-            x = cross_covariance_attn(x) + x
-            x = local_patch_interaction(x) + x
-            x = ff(x) + x
-
-        return x
-
-class XCiT(Module):
-    def __init__(
-        self,
-        *,
-        image_size,
-        patch_size,
-        num_classes,
-        dim,
-        depth,
-        cls_depth,
-        heads,
-        mlp_dim,
-        dim_head = 64,
-        dropout = 0.,
-        emb_dropout = 0.,
-        local_patch_kernel_size = 3,
-        layer_dropout = 0.
-    ):
-        super().__init__()
-        assert image_size % patch_size == 0, 'Image dimensions must be divisible by the patch size.'
-
-        num_patches = (image_size // patch_size) ** 2
-        patch_dim = 3 * patch_size ** 2
-
-        self.to_patch_embedding = nn.Sequential(
-            Rearrange('b c (h p1) (w p2) -> b h w (p1 p2 c)', p1 = patch_size, p2 = patch_size),
-            nn.LayerNorm(patch_dim),
-            nn.Linear(patch_dim, dim),
-            nn.LayerNorm(dim)
-        )
-
-        self.pos_embedding = nn.Parameter(torch.randn(1, num_patches, dim))
-        self.cls_token = nn.Parameter(torch.randn(dim))
-
-        self.dropout = nn.Dropout(emb_dropout)
-
-        self.xcit_transformer = XCATransformer(dim, depth, heads, dim_head, mlp_dim, local_patch_kernel_size, dropout, layer_dropout)
-
-        self.final_norm = nn.LayerNorm(dim)
-
-        self.cls_transformer = Transformer(dim, cls_depth, heads, dim_head, mlp_dim, dropout, layer_dropout)
-
-        self.mlp_head = nn.Sequential(
-            nn.LayerNorm(dim),
-            nn.Linear(dim, num_classes)
-        )
-
-    def forward(self, img):
-        x = self.to_patch_embedding(img)
-
-        x, ps = pack_one(x, 'b * d')
-
-        b, n, _ = x.shape
-        x += self.pos_embedding[:, :n]
-
-        x = unpack_one(x, ps, 'b * d')
-
-        x = self.dropout(x)
-
-        x = self.xcit_transformer(x)
-
-        x = self.final_norm(x)
-
-        cls_tokens = repeat(self.cls_token, 'd -> b 1 d', b = b)
-
-        x = rearrange(x, 'b ... d -> b (...) d')
-        cls_tokens = self.cls_transformer(cls_tokens, context = x)
-
-        return self.mlp_head(cls_tokens[:, 0])