Upload 13 files

Browse files

Files changed (13) hide show

.gitattributes +35 -35
README.md +98 -0
config.json +31 -0
configuration_intern_vit.py +117 -0
flash_attention.py +75 -0
model-00001-of-00003.safetensors +3 -0
model-00002-of-00003.safetensors +3 -0
model-00003-of-00003.safetensors +3 -0
model.safetensors.index.json +596 -0
modeling_intern_vit.py +415 -0
preprocessor_config.json +19 -0
triton_bert_padding.py +225 -0
triton_flash_attn.py +964 -0

.gitattributes CHANGED Viewed

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md ADDED Viewed

	@@ -0,0 +1,98 @@

+---
+license: mit
+datasets:
+- laion/laion2B-en
+- laion/laion-coco
+- laion/laion2B-multi
+- kakaobrain/coyo-700m
+- conceptual_captions
+- wanng/wukong100m
+pipeline_tag: image-feature-extraction
+---
+# Model Card for InternViT-6B-448px-V1-5
+<p align="center">
+  <img src="https://cdn-uploads.huggingface.co/production/uploads/64119264f0f81eb569e0d569/AUE-3OBtfr9vDA7Elgkhd.webp" alt="Image Description" width="300" height="300">
+</p>
+[\[🆕 Blog\]](https://internvl.github.io/blog/)  [\[📜 InternVL 1.0 Paper\]](https://arxiv.org/abs/2312.14238)  [\[📜 InternVL 1.5 Report\]](https://arxiv.org/abs/2404.16821)  [\[🗨️ Chat Demo\]](https://internvl.opengvlab.com/)
+[\[🤗 HF Demo\]](https://huggingface.co/spaces/OpenGVLab/InternVL)  [\[🚀 Quick Start\]](#model-usage)  [\[🌐 Community-hosted API\]](https://rapidapi.com/adushar1320/api/internvl-chat)  [\[📖 中文解读\]](https://zhuanlan.zhihu.com/p/675877376)
+We develop InternViT-6B-448px-V1-5 based on the pre-training of the strong foundation of [InternViT-6B-448px-V1-2](https://huggingface.co/OpenGVLab/InternViT-6B-448px-V1-2). In this update, the resolution of training images is expanded from 448&times;448 to dynamic 448&times;448, where the basic tile size is 448&times;448 and the number of tiles ranges from 1 to 12.
+Additionally, we enhance the data scale, quality, and diversity of the pre-training dataset, resulting in the powerful robustness, OCR capability, and high-resolution processing capability of our
+1.5 version model.
+## Model Details
+- **Model Type:** vision foundation model, feature backbone
+- **Model Stats:**
+  - Params (M): 5540 (the last 3 blocks are discarded)
+  - Image size: 448 x 448, training with 1 - 12 tiles
+- **Pretrain Dataset:** LAION-en, LAION-zh, COYO, GRIT, COCO, TextCaps, Objects365, OpenImages, All-Seeing, Wukong-OCR, LaionCOCO-OCR, and other OCR-related datasets.
+To enhance the OCR capability of the model, we have incorporated additional OCR data alongside the general caption datasets. Specifically, we utilized PaddleOCR to perform Chinese OCR on images from Wukong and English OCR on images from LAION-COCO.
+- **Note:** InternViT-6B originally had 48 blocks, and we found that using the output after the fourth-to-last block worked best for MLLM. For ease of use and to save GPU memory, we simply discarded the last 3 blocks. Now, the model has only 45 blocks and the number of parameters has been reduced from 5.9B to 5.5B. Therefore, if you want to build a MLLM based on this model, **please make use of the features from the last layer.**
+## Released Models
+### Vision Foundation model
+| Model                   | Date       | Download                                                               | Note                             |
+| ----------------------- | ---------- | ---------------------------------------------------------------------- | -------------------------------- |
+| InternViT-6B-448px-V1-5 | 2024.04.20 | 🤗 [HF link](https://huggingface.co/OpenGVLab/InternViT-6B-448px-V1-5) | support dynamic resolution, super strong OCR (🔥new) |
+| InternViT-6B-448px-V1-2 | 2024.02.11 | 🤗 [HF link](https://huggingface.co/OpenGVLab/InternViT-6B-448px-V1-2) | 448 resolution                   |
+| InternViT-6B-448px-V1-0 | 2024.01.30 | 🤗 [HF link](https://huggingface.co/OpenGVLab/InternViT-6B-448px-V1-0) | 448 resolution                   |
+| InternViT-6B-224px      | 2023.12.22 | 🤗 [HF link](https://huggingface.co/OpenGVLab/InternViT-6B-224px)      | vision foundation model          |
+| InternVL-14B-224px      | 2023.12.22 | 🤗 [HF link](https://huggingface.co/OpenGVLab/InternVL-14B-224px)      | vision-language foundation model |
+### Multimodal Large Language Model (MLLM)
+| Model                   | Date       | Download                                                                    | Note                               |
+| ----------------------- | ---------- | --------------------------------------------------------------------------- | ---------------------------------- |
+| InternVL-Chat-V1-5      | 2024.04.18 | 🤗 [HF link](https://huggingface.co/OpenGVLab/InternVL-Chat-V1-5)            | support 4K image; super strong OCR; Approaching the performance of GPT-4V and Gemini Pro on various benchmarks like MMMU, DocVQA, ChartQA, MathVista, etc. (🔥new)|
+| InternVL-Chat-V1-2-Plus | 2024.02.21 | 🤗 [HF link](https://huggingface.co/OpenGVLab/InternVL-Chat-V1-2-Plus)       | more SFT data and stronger  |
+| InternVL-Chat-V1-2      | 2024.02.11 | 🤗 [HF link](https://huggingface.co/OpenGVLab/InternVL-Chat-V1-2)            | scaling up LLM to 34B       |
+| InternVL-Chat-V1-1      | 2024.01.24 | 🤗 [HF link](https://huggingface.co/OpenGVLab/InternVL-Chat-V1-1)            | support Chinese and stronger OCR   |
+## Model Usage (Image Embeddings)
+```python
+import torch
+from PIL import Image
+from transformers import AutoModel, CLIPImageProcessor
+model = AutoModel.from_pretrained(
+    'OpenGVLab/InternViT-6B-448px-V1-5',
+    torch_dtype=torch.bfloat16,
+    low_cpu_mem_usage=True,
+    trust_remote_code=True).cuda().eval()
+image = Image.open('./examples/image1.jpg').convert('RGB')
+image_processor = CLIPImageProcessor.from_pretrained('OpenGVLab/InternViT-6B-448px-V1-5')
+pixel_values = image_processor(images=image, return_tensors='pt').pixel_values
+pixel_values = pixel_values.to(torch.bfloat16).cuda()
+outputs = model(pixel_values)
+```
+## Citation
+If you find this project useful in your research, please consider citing:
+```BibTeX
+@article{chen2023internvl,
+  title={InternVL: Scaling up Vision Foundation Models and Aligning for Generic Visual-Linguistic Tasks},
+  author={Chen, Zhe and Wu, Jiannan and Wang, Wenhai and Su, Weijie and Chen, Guo and Xing, Sen and Zhong, Muyan and Zhang, Qinglong and Zhu, Xizhou and Lu, Lewei and Li, Bin and Luo, Ping and Lu, Tong and Qiao, Yu and Dai, Jifeng},
+  journal={arXiv preprint arXiv:2312.14238},
+  year={2023}
+}
+@article{chen2024far,
+  title={How Far Are We to GPT-4V? Closing the Gap to Commercial Multimodal Models with Open-Source Suites},
+  author={Chen, Zhe and Wang, Weiyun and Tian, Hao and Ye, Shenglong and Gao, Zhangwei and Cui, Erfei and Tong, Wenwen and Hu, Kongzhi and Luo, Jiapeng and Ma, Zheng and others},
+  journal={arXiv preprint arXiv:2404.16821},
+  year={2024}
+}
+```
+## Acknowledgement
+InternVL is built with reference to the code of the following projects: [OpenAI CLIP](https://github.com/openai/CLIP), [Open CLIP](https://github.com/mlfoundations/open_clip), [CLIP Benchmark](https://github.com/LAION-AI/CLIP_benchmark), [EVA](https://github.com/baaivision/EVA/tree/master), [InternImage](https://github.com/OpenGVLab/InternImage), [ViT-Adapter](https://github.com/czczup/ViT-Adapter), [MMSegmentation](https://github.com/open-mmlab/mmsegmentation), [Transformers](https://github.com/huggingface/transformers), [DINOv2](https://github.com/facebookresearch/dinov2), [BLIP-2](https://github.com/salesforce/LAVIS/tree/main/projects/blip2), [Qwen-VL](https://github.com/QwenLM/Qwen-VL/tree/master/eval_mm), and [LLaVA-1.5](https://github.com/haotian-liu/LLaVA). Thanks for their awesome work!

config.json ADDED Viewed

	@@ -0,0 +1,31 @@

+{
+  "_name_or_path": "OpenGVLab/InternViT-6B-448px-V1-5",
+  "architectures": [
+    "InternVisionModel"
+  ],
+  "attention_dropout": 0.0,
+  "auto_map": {
+    "AutoConfig": "configuration_intern_vit.InternVisionConfig",
+    "AutoModel": "modeling_intern_vit.InternVisionModel"
+  },
+  "drop_path_rate": 0.0,
+  "dropout": 0.0,
+  "hidden_act": "gelu",
+  "hidden_size": 3200,
+  "image_size": 448,
+  "initializer_factor": 0.1,
+  "initializer_range": 1e-10,
+  "intermediate_size": 12800,
+  "layer_norm_eps": 1e-06,
+  "model_type": "intern_vit_6b",
+  "num_attention_heads": 25,
+  "num_channels": 3,
+  "num_hidden_layers": 45,
+  "patch_size": 14,
+  "qk_normalization": true,
+  "qkv_bias": false,
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.36.2",
+  "use_bfloat16": true,
+  "use_flash_attn": true
+}

configuration_intern_vit.py ADDED Viewed

	@@ -0,0 +1,117 @@

+# --------------------------------------------------------
+# InternVL
+# Copyright (c) 2023 OpenGVLab
+# Licensed under The MIT License [see LICENSE for details]
+# --------------------------------------------------------
+import os
+from typing import Union
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+logger = logging.get_logger(__name__)
+class InternVisionConfig(PretrainedConfig):
+    r"""
+    This is the configuration class to store the configuration of a [`InternVisionModel`]. It is used to
+    instantiate a vision encoder according to the specified arguments, defining the model architecture.
+    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+    documentation from [`PretrainedConfig`] for more information.
+    Args:
+        num_channels (`int`, *optional*, defaults to 3):
+            Number of color channels in the input images (e.g., 3 for RGB).
+        patch_size (`int`, *optional*, defaults to 14):
+            The size (resolution) of each patch.
+        image_size (`int`, *optional*, defaults to 224):
+            The size (resolution) of each image.
+        qkv_bias (`bool`, *optional*, defaults to `False`):
+            Whether to add a bias to the queries and values in the self-attention layers.
+        hidden_size (`int`, *optional*, defaults to 3200):
+            Dimensionality of the encoder layers and the pooler layer.
+        num_attention_heads (`int`, *optional*, defaults to 25):
+            Number of attention heads for each attention layer in the Transformer encoder.
+        intermediate_size (`int`, *optional*, defaults to 12800):
+            Dimensionality of the "intermediate" (i.e., feed-forward) layer in the Transformer encoder.
+        qk_normalization (`bool`, *optional*, defaults to `True`):
+            Whether to normalize the queries and keys in the self-attention layers.
+        num_hidden_layers (`int`, *optional*, defaults to 48):
+            Number of hidden layers in the Transformer encoder.
+        use_flash_attn (`bool`, *optional*, defaults to `True`):
+            Whether to use flash attention mechanism.
+        hidden_act (`str` or `function`, *optional*, defaults to `"gelu"`):
+            The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
+            `"relu"`, `"selu"` and `"gelu_new"` ``"gelu"` are supported.
+        layer_norm_eps (`float`, *optional*, defaults to 1e-6):
+            The epsilon used by the layer normalization layers.
+        dropout (`float`, *optional*, defaults to 0.0):
+            The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.
+        drop_path_rate (`float`, *optional*, defaults to 0.0):
+            Dropout rate for stochastic depth.
+        attention_dropout (`float`, *optional*, defaults to 0.0):
+            The dropout ratio for the attention probabilities.
+        initializer_range (`float`, *optional*, defaults to 0.02):
+            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+        initializer_factor (`float`, *optional*, defaults to 0.1):
+            A factor for layer scale.
+    """
+    model_type = 'intern_vit_6b'
+    def __init__(
+            self,
+            num_channels=3,
+            patch_size=14,
+            image_size=224,
+            qkv_bias=False,
+            hidden_size=3200,
+            num_attention_heads=25,
+            intermediate_size=12800,
+            qk_normalization=True,
+            num_hidden_layers=48,
+            use_flash_attn=True,
+            hidden_act='gelu',
+            layer_norm_eps=1e-6,
+            dropout=0.0,
+            drop_path_rate=0.0,
+            attention_dropout=0.0,
+            initializer_range=0.02,
+            initializer_factor=0.1,
+            **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.hidden_size = hidden_size
+        self.intermediate_size = intermediate_size
+        self.dropout = dropout
+        self.drop_path_rate = drop_path_rate
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.num_channels = num_channels
+        self.patch_size = patch_size
+        self.image_size = image_size
+        self.initializer_range = initializer_range
+        self.initializer_factor = initializer_factor
+        self.attention_dropout = attention_dropout
+        self.layer_norm_eps = layer_norm_eps
+        self.hidden_act = hidden_act
+        self.qkv_bias = qkv_bias
+        self.qk_normalization = qk_normalization
+        self.use_flash_attn = use_flash_attn
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs) -> 'PretrainedConfig':
+        config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs)
+        if 'vision_config' in config_dict:
+            config_dict = config_dict['vision_config']
+        if 'model_type' in config_dict and hasattr(cls, 'model_type') and config_dict['model_type'] != cls.model_type:
+            logger.warning(
+                f"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
+                f'{cls.model_type}. This is not supported for all configurations of models and can yield errors.'
+            )
+        return cls.from_dict(config_dict, **kwargs)

flash_attention.py ADDED Viewed

	@@ -0,0 +1,75 @@

+import torch
+import torch.nn as nn
+from einops import rearrange
+try:  # v1
+    from flash_attn.flash_attn_interface import \
+        flash_attn_unpadded_qkvpacked_func
+except:  # v2
+    from flash_attn.flash_attn_interface import flash_attn_varlen_qkvpacked_func as flash_attn_unpadded_qkvpacked_func
+from flash_attn.bert_padding import pad_input, unpad_input
+class FlashAttention(nn.Module):
+    """Implement the scaled dot product attention with softmax.
+    Arguments
+    ---------
+        softmax_scale: The temperature to use for the softmax attention.
+                      (default: 1/sqrt(d_keys) where d_keys is computed at
+                      runtime)
+        attention_dropout: The dropout rate to apply to the attention
+                           (default: 0.0)
+    """
+    def __init__(self, softmax_scale=None, attention_dropout=0.0, device=None, dtype=None):
+        super().__init__()
+        self.softmax_scale = softmax_scale
+        self.dropout_p = attention_dropout
+    def forward(self, qkv, key_padding_mask=None, causal=False, cu_seqlens=None,
+                max_s=None, need_weights=False):
+        """Implements the multihead softmax attention.
+        Arguments
+        ---------
+            qkv: The tensor containing the query, key, and value. (B, S, 3, H, D) if key_padding_mask is None
+                if unpadded: (nnz, 3, h, d)
+            key_padding_mask: a bool tensor of shape (B, S)
+        """
+        assert not need_weights
+        assert qkv.dtype in [torch.float16, torch.bfloat16]
+        assert qkv.is_cuda
+        if cu_seqlens is None:
+            batch_size = qkv.shape[0]
+            seqlen = qkv.shape[1]
+            if key_padding_mask is None:
+                qkv = rearrange(qkv, 'b s ... -> (b s) ...')
+                max_s = seqlen
+                cu_seqlens = torch.arange(0, (batch_size + 1) * seqlen, step=seqlen, dtype=torch.int32,
+                                          device=qkv.device)
+                output = flash_attn_unpadded_qkvpacked_func(
+                    qkv, cu_seqlens, max_s, self.dropout_p if self.training else 0.0,
+                    softmax_scale=self.softmax_scale, causal=causal
+                )
+                output = rearrange(output, '(b s) ... -> b s ...', b=batch_size)
+            else:
+                nheads = qkv.shape[-2]
+                x = rearrange(qkv, 'b s three h d -> b s (three h d)')
+                x_unpad, indices, cu_seqlens, max_s = unpad_input(x, key_padding_mask)
+                x_unpad = rearrange(x_unpad, 'nnz (three h d) -> nnz three h d', three=3, h=nheads)
+                output_unpad = flash_attn_unpadded_qkvpacked_func(
+                    x_unpad, cu_seqlens, max_s, self.dropout_p if self.training else 0.0,
+                    softmax_scale=self.softmax_scale, causal=causal
+                )
+                output = rearrange(pad_input(rearrange(output_unpad, 'nnz h d -> nnz (h d)'),
+                                             indices, batch_size, seqlen),
+                                   'b s (h d) -> b s h d', h=nheads)
+        else:
+            assert max_s is not None
+            output = flash_attn_unpadded_qkvpacked_func(
+                qkv, cu_seqlens, max_s, self.dropout_p if self.training else 0.0,
+                softmax_scale=self.softmax_scale, causal=causal
+            )
+        return output, None

model-00001-of-00003.safetensors ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:331fc0e79147081bb4260491b4db121aaf4252e0f29ed3509ae5df11bd8ae41e
+size 4988565944

model-00002-of-00003.safetensors ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:4785be9bec8771f0b25a2f33c52fe9e53623068eb0e7d72aa01e410c43a91cbc
+size 4937250176

model-00003-of-00003.safetensors ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:95fe64ed513580d1fbd4257823adfd5b7b1a283c70cdd2771453443dd1f0b6b6
+size 1147238088

model.safetensors.index.json ADDED Viewed

	@@ -0,0 +1,596 @@

+{
+  "metadata": {
+    "total_size": 11072992000
+  },
+  "weight_map": {
+    "embeddings.class_embedding": "model-00001-of-00003.safetensors",
+    "embeddings.patch_embedding.bias": "model-00001-of-00003.safetensors",
+    "embeddings.patch_embedding.weight": "model-00001-of-00003.safetensors",
+    "embeddings.position_embedding": "model-00001-of-00003.safetensors",
+    "encoder.layers.0.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.0.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.0.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.0.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.0.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.0.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.0.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.0.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.0.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.0.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.0.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.0.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.0.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.1.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.1.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.1.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.1.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.1.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.1.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.1.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.1.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.1.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.1.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.1.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.1.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.1.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.10.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.10.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.10.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.10.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.10.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.10.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.10.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.10.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.10.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.10.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.10.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.10.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.10.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.11.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.11.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.11.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.11.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.11.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.11.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.11.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.11.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.11.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.11.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.11.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.11.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.11.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.12.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.12.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.12.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.12.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.12.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.12.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.12.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.12.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.12.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.12.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.12.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.12.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.12.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.13.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.13.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.13.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.13.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.13.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.13.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.13.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.13.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.13.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.13.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.13.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.13.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.13.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.14.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.14.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.14.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.14.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.14.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.14.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.14.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.14.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.14.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.14.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.14.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.14.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.14.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.15.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.15.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.15.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.15.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.15.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.15.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.15.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.15.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.15.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.15.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.15.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.15.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.15.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.16.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.16.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.16.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.16.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.16.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.16.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.16.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.16.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.16.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.16.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.16.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.16.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.16.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.17.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.17.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.17.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.17.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.17.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.17.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.17.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.17.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.17.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.17.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.17.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.17.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.17.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.18.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.18.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.18.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.18.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.18.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.18.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.18.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.18.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.18.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.18.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.18.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.18.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.18.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.19.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.19.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.19.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.19.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.19.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.19.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.19.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.19.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.19.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.19.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.19.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.19.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.19.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.2.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.2.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.2.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.2.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.2.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.2.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.2.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.2.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.2.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.2.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.2.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.2.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.2.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.20.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.20.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.20.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.20.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.20.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.20.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.20.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.20.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.20.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.20.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.20.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.20.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.20.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.21.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.21.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.21.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.21.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.21.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.21.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.21.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.21.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.21.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.21.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.21.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.21.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.21.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.22.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.22.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.22.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.22.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.22.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.22.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.22.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.22.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.22.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.22.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.22.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.22.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.22.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.23.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.23.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.23.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.23.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.23.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.23.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.23.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.23.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.23.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.23.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.23.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.23.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.23.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.24.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.24.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.24.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.24.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.24.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.24.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.24.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.24.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.24.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.24.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.24.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.24.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.24.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.25.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.25.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.25.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.25.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.25.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.25.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.25.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.25.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.25.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.25.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.25.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.25.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.25.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.26.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.26.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.26.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.26.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.26.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.26.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.26.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.26.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.26.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.26.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.26.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.26.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.26.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.27.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.27.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.27.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.27.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.27.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.27.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.27.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.27.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.27.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.27.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.27.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.27.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.27.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.28.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.28.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.28.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.28.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.28.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.28.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.28.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.28.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.28.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.28.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.28.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.28.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.28.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.29.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.29.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.29.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.29.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.29.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.29.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.29.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.29.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.29.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.29.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.29.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.29.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.29.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.3.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.3.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.3.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.3.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.3.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.3.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.3.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.3.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.3.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.3.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.3.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.3.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.3.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.30.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.30.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.30.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.30.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.30.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.30.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.30.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.30.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.30.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.30.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.30.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.30.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.30.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.31.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.31.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.31.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.31.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.31.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.31.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.31.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.31.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.31.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.31.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.31.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.31.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.31.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.32.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.32.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.32.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.32.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.32.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.32.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.32.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.32.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.32.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.32.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.32.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.32.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.32.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.33.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.33.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.33.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.33.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.33.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.33.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.33.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.33.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.33.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.33.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.33.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.33.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.33.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.34.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.34.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.34.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.34.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.34.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.34.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.34.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.34.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.34.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.34.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.34.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.34.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.34.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.35.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.35.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.35.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.35.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.35.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.35.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.35.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.35.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.35.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.35.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.35.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.35.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.35.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.36.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.36.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.36.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.36.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.36.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.36.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.36.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.36.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.36.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.36.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.36.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.36.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.36.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.37.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.37.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.37.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.37.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.37.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.37.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.37.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.37.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.37.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.37.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.37.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.37.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.37.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.38.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.38.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.38.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.38.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.38.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.38.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.38.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.38.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.38.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.38.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.38.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.38.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.38.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.39.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.39.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.39.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.39.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.39.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.39.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.39.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.39.mlp.fc1.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.39.mlp.fc1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.39.mlp.fc2.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.39.mlp.fc2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.39.norm1.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.39.norm2.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.4.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.4.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.4.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.4.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.4.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.4.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.4.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.4.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.4.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.4.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.4.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.4.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.4.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.40.attn.k_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.40.attn.proj.bias": "model-00002-of-00003.safetensors",
+    "encoder.layers.40.attn.proj.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.40.attn.q_norm.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.40.attn.qkv.weight": "model-00002-of-00003.safetensors",
+    "encoder.layers.40.ls1": "model-00002-of-00003.safetensors",
+    "encoder.layers.40.ls2": "model-00002-of-00003.safetensors",
+    "encoder.layers.40.mlp.fc1.bias": "model-00003-of-00003.safetensors",
+    "encoder.layers.40.mlp.fc1.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.40.mlp.fc2.bias": "model-00003-of-00003.safetensors",
+    "encoder.layers.40.mlp.fc2.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.40.norm1.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.40.norm2.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.41.attn.k_norm.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.41.attn.proj.bias": "model-00003-of-00003.safetensors",
+    "encoder.layers.41.attn.proj.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.41.attn.q_norm.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.41.attn.qkv.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.41.ls1": "model-00003-of-00003.safetensors",
+    "encoder.layers.41.ls2": "model-00003-of-00003.safetensors",
+    "encoder.layers.41.mlp.fc1.bias": "model-00003-of-00003.safetensors",
+    "encoder.layers.41.mlp.fc1.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.41.mlp.fc2.bias": "model-00003-of-00003.safetensors",
+    "encoder.layers.41.mlp.fc2.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.41.norm1.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.41.norm2.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.42.attn.k_norm.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.42.attn.proj.bias": "model-00003-of-00003.safetensors",
+    "encoder.layers.42.attn.proj.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.42.attn.q_norm.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.42.attn.qkv.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.42.ls1": "model-00003-of-00003.safetensors",
+    "encoder.layers.42.ls2": "model-00003-of-00003.safetensors",
+    "encoder.layers.42.mlp.fc1.bias": "model-00003-of-00003.safetensors",
+    "encoder.layers.42.mlp.fc1.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.42.mlp.fc2.bias": "model-00003-of-00003.safetensors",
+    "encoder.layers.42.mlp.fc2.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.42.norm1.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.42.norm2.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.43.attn.k_norm.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.43.attn.proj.bias": "model-00003-of-00003.safetensors",
+    "encoder.layers.43.attn.proj.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.43.attn.q_norm.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.43.attn.qkv.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.43.ls1": "model-00003-of-00003.safetensors",
+    "encoder.layers.43.ls2": "model-00003-of-00003.safetensors",
+    "encoder.layers.43.mlp.fc1.bias": "model-00003-of-00003.safetensors",
+    "encoder.layers.43.mlp.fc1.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.43.mlp.fc2.bias": "model-00003-of-00003.safetensors",
+    "encoder.layers.43.mlp.fc2.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.43.norm1.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.43.norm2.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.44.attn.k_norm.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.44.attn.proj.bias": "model-00003-of-00003.safetensors",
+    "encoder.layers.44.attn.proj.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.44.attn.q_norm.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.44.attn.qkv.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.44.ls1": "model-00003-of-00003.safetensors",
+    "encoder.layers.44.ls2": "model-00003-of-00003.safetensors",
+    "encoder.layers.44.mlp.fc1.bias": "model-00003-of-00003.safetensors",
+    "encoder.layers.44.mlp.fc1.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.44.mlp.fc2.bias": "model-00003-of-00003.safetensors",
+    "encoder.layers.44.mlp.fc2.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.44.norm1.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.44.norm2.weight": "model-00003-of-00003.safetensors",
+    "encoder.layers.5.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.5.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.5.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.5.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.5.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.5.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.5.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.5.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.5.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.5.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.5.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.5.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.5.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.6.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.6.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.6.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.6.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.6.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.6.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.6.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.6.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.6.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.6.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.6.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.6.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.6.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.7.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.7.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.7.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.7.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.7.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.7.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.7.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.7.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.7.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.7.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.7.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.7.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.7.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.8.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.8.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.8.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.8.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.8.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.8.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.8.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.8.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.8.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.8.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.8.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.8.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.8.norm2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.9.attn.k_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.9.attn.proj.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.9.attn.proj.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.9.attn.q_norm.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.9.attn.qkv.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.9.ls1": "model-00001-of-00003.safetensors",
+    "encoder.layers.9.ls2": "model-00001-of-00003.safetensors",
+    "encoder.layers.9.mlp.fc1.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.9.mlp.fc1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.9.mlp.fc2.bias": "model-00001-of-00003.safetensors",
+    "encoder.layers.9.mlp.fc2.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.9.norm1.weight": "model-00001-of-00003.safetensors",
+    "encoder.layers.9.norm2.weight": "model-00001-of-00003.safetensors"
+  }
+}

modeling_intern_vit.py ADDED Viewed

	@@ -0,0 +1,415 @@

+# --------------------------------------------------------
+# InternVL
+# Copyright (c) 2023 OpenGVLab
+# Licensed under The MIT License [see LICENSE for details]
+# --------------------------------------------------------
+from typing import Optional, Tuple, Union
+import torch
+import torch.nn.functional as F
+import torch.utils.checkpoint
+from einops import rearrange
+from timm.models.layers import DropPath
+from torch import nn
+from transformers.activations import ACT2FN
+from transformers.modeling_outputs import BaseModelOutput, BaseModelOutputWithPooling
+from transformers.modeling_utils import PreTrainedModel
+from transformers.utils import logging
+from .configuration_intern_vit import InternVisionConfig
+try:
+    from .triton_flash_attn import attention
+    has_flash_attn = True
+except:
+    print("attention is not installed.")
+    has_flash_attn = False
+logger = logging.get_logger(__name__)
+class InternRMSNorm(nn.Module):
+    def __init__(self, hidden_size, eps=1e-6):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(hidden_size))
+        self.variance_epsilon = eps
+    def forward(self, hidden_states):
+        input_dtype = hidden_states.dtype
+        hidden_states = hidden_states.to(torch.float32)
+        variance = hidden_states.pow(2).mean(-1, keepdim=True)
+        hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+        return self.weight * hidden_states.to(input_dtype)
+try:
+    from apex.normalization import FusedRMSNorm
+    InternRMSNorm = FusedRMSNorm  # noqa
+    logger.info(
+        "Discovered apex.normalization.FusedRMSNorm - will use it instead of InternRMSNorm"
+    )
+except ImportError:
+    # using the normal InternRMSNorm
+    pass
+except Exception:
+    logger.warning(
+        "discovered apex but it failed to load, falling back to InternRMSNorm"
+    )
+    pass
+class InternVisionEmbeddings(nn.Module):
+    def __init__(self, config: InternVisionConfig):
+        super().__init__()
+        self.config = config
+        self.embed_dim = config.hidden_size
+        self.image_size = config.image_size
+        self.patch_size = config.patch_size
+        self.class_embedding = nn.Parameter(
+            torch.randn(1, 1, self.embed_dim),
+        )
+        self.patch_embedding = nn.Conv2d(
+            in_channels=3,
+            out_channels=self.embed_dim,
+            kernel_size=self.patch_size,
+            stride=self.patch_size,
+        )
+        self.num_patches = (self.image_size // self.patch_size) ** 2
+        self.num_positions = self.num_patches + 1
+        self.position_embedding = nn.Parameter(
+            torch.randn(1, self.num_positions, self.embed_dim)
+        )
+    def forward(self, pixel_values: torch.FloatTensor) -> torch.Tensor:
+        batch_size = pixel_values.shape[0]
+        target_dtype = self.patch_embedding.weight.dtype
+        patch_embeds = self.patch_embedding(
+            pixel_values
+        )  # shape = [*, width, grid, grid]
+        patch_embeds = patch_embeds.flatten(2).transpose(1, 2)
+        class_embeds = self.class_embedding.expand(batch_size, 1, -1).to(target_dtype)
+        embeddings = torch.cat([class_embeds, patch_embeds], dim=1)
+        embeddings = embeddings + self.position_embedding.to(target_dtype)
+        return embeddings
+class InternAttention(nn.Module):
+    """Multi-headed attention from 'Attention Is All You Need' paper"""
+    def __init__(self, config: InternVisionConfig):
+        super().__init__()
+        self.config = config
+        self.embed_dim = config.hidden_size
+        self.num_heads = config.num_attention_heads
+        self.use_flash_attn = config.use_flash_attn and has_flash_attn
+        if config.use_flash_attn and not has_flash_attn:
+            print(
+                "Warning: Flash Attention is not available, use_flash_attn is set to False."
+            )
+        self.head_dim = self.embed_dim // self.num_heads
+        if self.head_dim * self.num_heads != self.embed_dim:
+            raise ValueError(
+                f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim} and `num_heads`:"
+                f" {self.num_heads})."
+            )
+        self.scale = self.head_dim**-0.5
+        self.qkv = nn.Linear(self.embed_dim, 3 * self.embed_dim, bias=config.qkv_bias)
+        self.attn_drop = nn.Dropout(config.attention_dropout)
+        self.proj_drop = nn.Dropout(config.dropout)
+        self.qk_normalization = config.qk_normalization
+        if self.qk_normalization:
+            self.q_norm = InternRMSNorm(self.embed_dim, eps=config.layer_norm_eps)
+            self.k_norm = InternRMSNorm(self.embed_dim, eps=config.layer_norm_eps)
+        if self.use_flash_attn:
+            self.inner_attn = attention(attention_dropout=config.attention_dropout)
+        self.proj = nn.Linear(self.embed_dim, self.embed_dim)
+    def _naive_attn(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.unbind(0)  # make torchscript happy (cannot use tensor as tuple)
+        if self.qk_normalization:
+            B_, H_, N_, D_ = q.shape
+            q = (
+                self.q_norm(q.transpose(1, 2).flatten(-2, -1))
+                .view(B_, N_, H_, D_)
+                .transpose(1, 2)
+            )
+            k = (
+                self.k_norm(k.transpose(1, 2).flatten(-2, -1))
+                .view(B_, N_, H_, D_)
+                .transpose(1, 2)
+            )
+        attn = (q * self.scale) @ k.transpose(-2, -1)
+        attn = attn.softmax(dim=-1)
+        attn = self.attn_drop(attn)
+        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+    def _flash_attn(self, x, key_padding_mask=None, need_weights=False):
+        qkv = self.qkv(x)
+        qkv = rearrange(
+            qkv, "b s (three h d) -> b s three h d", three=3, h=self.num_heads
+        )
+        if self.qk_normalization:
+            q, k, v = qkv.unbind(2)
+            q = self.q_norm(q.flatten(-2, -1)).view(q.shape)
+            k = self.k_norm(k.flatten(-2, -1)).view(k.shape)
+            qkv = torch.stack([q, k, v], dim=2)
+        context, _ = self.inner_attn(
+            qkv,
+            key_padding_mask=key_padding_mask,
+            need_weights=need_weights,
+            causal=False,
+        )
+        outs = self.proj(rearrange(context, "b s h d -> b s (h d)"))
+        outs = self.proj_drop(outs)
+        return outs
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        x = (
+            self._naive_attn(hidden_states)
+            if not self.use_flash_attn
+            else self._flash_attn(hidden_states)
+        )
+        return x
+class InternMLP(nn.Module):
+    def __init__(self, config: InternVisionConfig):
+        super().__init__()
+        self.config = config
+        self.act = ACT2FN[config.hidden_act]
+        self.fc1 = nn.Linear(config.hidden_size, config.intermediate_size)
+        self.fc2 = nn.Linear(config.intermediate_size, config.hidden_size)
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.fc1(hidden_states)
+        hidden_states = self.act(hidden_states)
+        hidden_states = self.fc2(hidden_states)
+        return hidden_states
+class InternVisionEncoderLayer(nn.Module):
+    def __init__(self, config: InternVisionConfig, drop_path_rate: float):
+        super().__init__()
+        self.embed_dim = config.hidden_size
+        self.intermediate_size = config.intermediate_size
+        self.attn = InternAttention(config)
+        self.mlp = InternMLP(config)
+        self.norm1 = InternRMSNorm(self.embed_dim, eps=config.layer_norm_eps)
+        self.norm2 = InternRMSNorm(self.embed_dim, eps=config.layer_norm_eps)
+        self.ls1 = nn.Parameter(config.initializer_factor * torch.ones(self.embed_dim))
+        self.ls2 = nn.Parameter(config.initializer_factor * torch.ones(self.embed_dim))
+        self.drop_path1 = (
+            DropPath(drop_path_rate) if drop_path_rate > 0.0 else nn.Identity()
+        )
+        self.drop_path2 = (
+            DropPath(drop_path_rate) if drop_path_rate > 0.0 else nn.Identity()
+        )
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+    ) -> Tuple[
+        torch.FloatTensor,
+        Optional[torch.FloatTensor],
+        Optional[Tuple[torch.FloatTensor]],
+    ]:
+        """
+        Args:
+            hidden_states (`Tuple[torch.FloatTensor, Optional[torch.FloatTensor]]`): input to the layer of shape `(batch, seq_len, embed_dim)`
+        """
+        hidden_states = hidden_states + self.drop_path1(
+            self.attn(self.norm1(hidden_states)) * self.ls1
+        )
+        hidden_states = hidden_states + self.drop_path2(
+            self.mlp(self.norm2(hidden_states)) * self.ls2
+        )
+        return hidden_states
+class InternVisionEncoder(nn.Module):
+    """
+    Transformer encoder consisting of `config.num_hidden_layers` self attention layers. Each layer is a
+    [`InternEncoderLayer`].
+    Args:
+        config (`InternConfig`):
+            The corresponding vision configuration for the `InternEncoder`.
+    """
+    def __init__(self, config: InternVisionConfig):
+        super().__init__()
+        self.config = config
+        # stochastic depth decay rule
+        dpr = [
+            x.item()
+            for x in torch.linspace(0, config.drop_path_rate, config.num_hidden_layers)
+        ]
+        self.layers = nn.ModuleList(
+            [
+                InternVisionEncoderLayer(config, dpr[idx])
+                for idx in range(config.num_hidden_layers)
+            ]
+        )
+        self.gradient_checkpointing = True
+    def forward(
+        self,
+        inputs_embeds,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, BaseModelOutput]:
+        r"""
+        Args:
+            inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+                Embedded representation of the inputs. Should be float, not int tokens.
+            output_hidden_states (`bool`, *optional*):
+                Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
+                for more detail.
+            return_dict (`bool`, *optional*):
+                Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+        """
+        output_hidden_states = (
+            output_hidden_states
+            if output_hidden_states is not None
+            else self.config.output_hidden_states
+        )
+        return_dict = (
+            return_dict if return_dict is not None else self.config.use_return_dict
+        )
+        encoder_states = () if output_hidden_states else None
+        hidden_states = inputs_embeds
+        for idx, encoder_layer in enumerate(self.layers):
+            if output_hidden_states:
+                encoder_states = encoder_states + (hidden_states,)
+            if self.gradient_checkpointing and self.training:
+                layer_outputs = torch.utils.checkpoint.checkpoint(
+                    encoder_layer, hidden_states
+                )
+            else:
+                layer_outputs = encoder_layer(
+                    hidden_states,
+                )
+            hidden_states = layer_outputs
+        if output_hidden_states:
+            encoder_states = encoder_states + (hidden_states,)
+        if not return_dict:
+            return tuple(v for v in [hidden_states, encoder_states] if v is not None)
+        return BaseModelOutput(
+            last_hidden_state=hidden_states, hidden_states=encoder_states
+        )
+class InternVisionModel(PreTrainedModel):
+    main_input_name = "pixel_values"
+    config_class = InternVisionConfig
+    _no_split_modules = ["InternVisionEncoderLayer"]
+    def __init__(self, config: InternVisionConfig):
+        super().__init__(config)
+        self.config = config
+        self.embeddings = InternVisionEmbeddings(config)
+        self.encoder = InternVisionEncoder(config)
+    def resize_pos_embeddings(self, old_size, new_size, patch_size):
+        pos_emb = self.embeddings.position_embedding
+        _, num_positions, embed_dim = pos_emb.shape
+        cls_emb = pos_emb[:, :1, :]
+        pos_emb = (
+            pos_emb[:, 1:, :]
+            .reshape(1, old_size // patch_size, old_size // patch_size, -1)
+            .permute(0, 3, 1, 2)
+        )
+        pos_emb = F.interpolate(
+            pos_emb.float(),
+            size=new_size // patch_size,
+            mode="bicubic",
+            align_corners=False,
+        )
+        pos_emb = pos_emb.to(cls_emb.dtype).reshape(1, embed_dim, -1).permute(0, 2, 1)
+        pos_emb = torch.cat([cls_emb, pos_emb], dim=1)
+        self.embeddings.position_embedding = nn.Parameter(pos_emb)
+        logger.info(
+            "Resized position embeddings from {} to {}".format(old_size, new_size)
+        )
+    def get_input_embeddings(self):
+        return self.embeddings
+    def forward(
+        self,
+        pixel_values: Optional[torch.FloatTensor] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        pixel_embeds: Optional[torch.FloatTensor] = None,
+    ) -> Union[Tuple, BaseModelOutputWithPooling]:
+        output_hidden_states = (
+            output_hidden_states
+            if output_hidden_states is not None
+            else self.config.output_hidden_states
+        )
+        return_dict = (
+            return_dict if return_dict is not None else self.config.use_return_dict
+        )
+        if pixel_values is None and pixel_embeds is None:
+            raise ValueError("You have to specify pixel_values or pixel_embeds")
+        if pixel_embeds is not None:
+            hidden_states = pixel_embeds
+        else:
+            if len(pixel_values.shape) == 4:
+                hidden_states = self.embeddings(pixel_values)
+            else:
+                raise ValueError(f"wrong pixel_values size: {pixel_values.shape}")
+        encoder_outputs = self.encoder(
+            inputs_embeds=hidden_states,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        last_hidden_state = encoder_outputs.last_hidden_state
+        pooled_output = last_hidden_state[:, 0, :]
+        if not return_dict:
+            return (last_hidden_state, pooled_output) + encoder_outputs[1:]
+        return BaseModelOutputWithPooling(
+            last_hidden_state=last_hidden_state,
+            pooler_output=pooled_output,
+            hidden_states=encoder_outputs.hidden_states,
+            attentions=encoder_outputs.attentions,
+        )

preprocessor_config.json ADDED Viewed

	@@ -0,0 +1,19 @@

+{
+  "crop_size": 448,
+  "do_center_crop": true,
+  "do_normalize": true,
+  "do_resize": true,
+  "feature_extractor_type": "CLIPFeatureExtractor",
+  "image_mean": [
+    0.485,
+    0.456,
+    0.406
+  ],
+  "image_std": [
+    0.229,
+    0.224,
+    0.225
+  ],
+  "resample": 3,
+  "size": 448
+}

triton_bert_padding.py ADDED Viewed

	@@ -0,0 +1,225 @@

+# Adapted from https://github.com/mlcommons/training_results_v1.1/blob/main/NVIDIA/benchmarks/bert/implementations/pytorch/padding.py
+import torch
+import torch.nn.functional as F
+from einops import rearrange, repeat
+class IndexFirstAxis(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, input, indices):
+        ctx.save_for_backward(indices)
+        assert input.ndim >= 2
+        ctx.first_axis_dim, other_shape = input.shape[0], input.shape[1:]
+        second_dim = other_shape.numel()
+        # TD [2022-03-04] For some reason torch.gather is a bit faster than indexing.
+        # return input[indices]
+        return torch.gather(
+            rearrange(input, "b ... -> b (...)"),
+            0,
+            repeat(indices, "z -> z d", d=second_dim),
+        ).reshape(-1, *other_shape)
+    @staticmethod
+    def backward(ctx, grad_output):
+        (indices,) = ctx.saved_tensors
+        assert grad_output.ndim >= 2
+        other_shape = grad_output.shape[1:]
+        grad_output = rearrange(grad_output, "b ... -> b (...)")
+        grad_input = torch.zeros(
+            [ctx.first_axis_dim, grad_output.shape[1]],
+            device=grad_output.device,
+            dtype=grad_output.dtype,
+        )
+        # TD [2022-03-04] For some reason torch.scatter is a bit faster than indexing.
+        # grad_input[indices] = grad_output
+        grad_input.scatter_(
+            0, repeat(indices, "z -> z d", d=grad_output.shape[1]), grad_output
+        )
+        return grad_input.reshape(ctx.first_axis_dim, *other_shape), None
+index_first_axis = IndexFirstAxis.apply
+class IndexPutFirstAxis(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, values, indices, first_axis_dim):
+        ctx.save_for_backward(indices)
+        assert indices.ndim == 1
+        assert values.ndim >= 2
+        output = torch.zeros(
+            first_axis_dim, *values.shape[1:], device=values.device, dtype=values.dtype
+        )
+        # TD [2022-03-04] For some reason torch.scatter is a bit faster than indexing.
+        output[indices] = values
+        # output.scatter_(0, repeat(indices, 'z -> z d', d=values.shape[1]), values)
+        return output
+    @staticmethod
+    def backward(ctx, grad_output):
+        (indices,) = ctx.saved_tensors
+        # TD [2022-03-04] For some reason torch.gather is a bit faster than indexing.
+        grad_values = grad_output[indices]
+        # grad_values = torch.gather(grad_output, 0, repeat(indices, 'z -> z d', d=grad_output.shape[1]))
+        return grad_values, None, None
+index_put_first_axis = IndexPutFirstAxis.apply
+class IndexFirstAxisResidual(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, input, indices):
+        ctx.save_for_backward(indices)
+        assert input.ndim >= 2
+        ctx.first_axis_dim, other_shape = input.shape[0], input.shape[1:]
+        second_dim = other_shape.numel()
+        # TD [2022-03-04] For some reason torch.gather is a bit faster than indexing.
+        output = input[indices]
+        # We don't want to reshape input (b ... -> b (...)) since it could change the channel_last
+        # memory format to channel_first. In other words, input might not be contiguous.
+        # If we don't detach, Pytorch complains about output being a view and is being modified inplace
+        return output, input.detach()
+    @staticmethod
+    def backward(ctx, grad_output, grad_residual):
+        (indices,) = ctx.saved_tensors
+        assert grad_output.ndim >= 2
+        other_shape = grad_output.shape[1:]
+        assert grad_residual.shape[1:] == other_shape
+        grad_input = grad_residual
+        # grad_input[indices] += grad_output
+        indices = indices.reshape(indices.shape[0], *((1,) * (grad_output.ndim - 1)))
+        indices = indices.expand_as(grad_output)
+        grad_input.scatter_add_(0, indices, grad_output)
+        return grad_input.reshape(ctx.first_axis_dim, *other_shape), None
+index_first_axis_residual = IndexFirstAxisResidual.apply
+def unpad_input(hidden_states, attention_mask):
+    """
+    Arguments:
+        hidden_states: (batch, seqlen, ...)
+        attention_mask: (batch, seqlen), bool / int, 1 means valid and 0 means not valid.
+    Return:
+        hidden_states: (total_nnz, ...), where total_nnz = number of tokens in selected in attention_mask.
+        indices: (total_nnz), the indices of non-masked tokens from the flattened input sequence.
+        cu_seqlens: (batch + 1), the cumulative sequence lengths, used to index into hidden_states.
+        max_seqlen_in_batch: int
+    """
+    seqlens_in_batch = attention_mask.sum(dim=-1, dtype=torch.int32)
+    indices = torch.nonzero(attention_mask.flatten(), as_tuple=False).flatten()
+    max_seqlen_in_batch = seqlens_in_batch.max().item()
+    cu_seqlens = F.pad(
+        torch.cumsum(seqlens_in_batch, dim=0, dtype=torch.torch.int32), (1, 0)
+    )
+    # TD [2022-03-04] We don't want to index with a bool mask, because Pytorch will expand the
+    # bool mask, then call nonzero to get the indices, then index with those. The indices is @dim
+    # times larger than it needs to be, wasting memory. It's faster and more memory-efficient to
+    # index with integer indices. Moreover, torch's index is a bit slower than it needs to be,
+    # so we write custom forward and backward to make it a bit faster.
+    return (
+        index_first_axis(rearrange(hidden_states, "b s ... -> (b s) ..."), indices),
+        indices,
+        cu_seqlens,
+        max_seqlen_in_batch,
+    )
+def unpad_input_for_concatenated_sequences(hidden_states, attention_mask_in_length):
+    """
+    Supports concatenating short samples in one sequence. The attention_mask_in_length is utilized to mask other short samples. It helps efficient training of variant lengths-based samples (e.g., the supervised fine-tuning task in large language model).
+    The motivation for this function is explained [here](https://github.com/Dao-AILab/flash-attention/issues/432#issuecomment-1668822286).
+    For example, if batch = 3 and seqlen = 6, the attention_mask_in_length is:
+        ```
+        [
+          [2, 3, 0, 0, 0, 0],
+          [3, 2, 0, 0, 0, 0],
+          [6, 0, 0, 0, 0, 0]
+        ]
+        ```
+    , which refers to the 3D-attention mask:
+        ```
+        [
+          [
+            [1, 0, 0, 0, 0, 0],
+            [1, 1, 0, 0, 0, 0],
+            [0, 0, 1, 0, 0, 0],
+            [0, 0, 1, 1, 0, 0],
+            [0, 0, 1, 1, 1, 0],
+            [0, 0, 0, 0, 0, 1]
+          ],
+          [
+            [1, 0, 0, 0, 0, 0],
+            [1, 1, 0, 0, 0, 0],
+            [1, 1, 1, 0, 0, 0],
+            [0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 1, 1, 0],
+            [0, 0, 0, 0, 0, 1]
+          ],
+          [
+            [1, 0, 0, 0, 0, 0],
+            [1, 1, 0, 0, 0, 0],
+            [1, 1, 1, 0, 0, 0],
+            [1, 1, 1, 1, 0, 0],
+            [1, 1, 1, 1, 1, 0],
+            [1, 1, 1, 1, 1, 1]
+          ]
+        ]
+        ```.
+    Arguments:
+        hidden_states: (batch, seqlen, ...)
+        attention_mask_in_length: (batch, seqlen), int, a nonzero number (e.g., 1, 2, 3, etc.) means length of concatenated sequence in b-th batch, and 0 means none.
+    Return:
+        hidden_states: (total_nnz, ...), where total_nnz = number of tokens in selected in attention_mask.
+        indices: (total_nnz), the indices of non-masked tokens from the flattened input sequence.
+        cu_seqlens: (batch + 1), the cumulative sequence lengths, used to index into hidden_states.
+        max_seqlen_in_batch: int
+    """
+    length = attention_mask_in_length.sum(dim=-1)
+    seqlen = attention_mask_in_length.size(-1)
+    attention_mask_2d = torch.arange(
+        seqlen, device=length.device, dtype=length.dtype
+    ).expand(len(length), seqlen) < length.unsqueeze(1)
+    real_indices_idx = torch.nonzero(
+        attention_mask_in_length.flatten(), as_tuple=False
+    ).flatten()
+    seqlens_in_batch = attention_mask_in_length.flatten()[real_indices_idx]
+    indices = torch.nonzero(attention_mask_2d.flatten(), as_tuple=False).flatten()
+    max_seqlen_in_batch = seqlens_in_batch.max().item()
+    cu_seqlens = F.pad(
+        torch.cumsum(seqlens_in_batch, dim=0, dtype=torch.torch.int32), (1, 0)
+    )
+    # TD [2022-03-04] We don't want to index with a bool mask, because Pytorch will expand the
+    # bool mask, then call nonzero to get the indices, then index with those. The indices is @dim
+    # times larger than it needs to be, wasting memory. It's faster and more memory-efficient to
+    # index with integer indices. Moreover, torch's index is a bit slower than it needs to be,
+    # so we write custom forward and backward to make it a bit faster.
+    return (
+        index_first_axis(rearrange(hidden_states, "b s ... -> (b s) ..."), indices),
+        indices,
+        cu_seqlens,
+        max_seqlen_in_batch,
+    )
+def pad_input(hidden_states, indices, batch, seqlen):
+    """
+    Arguments:
+        hidden_states: (total_nnz, ...), where total_nnz = number of tokens in selected in attention_mask.
+        indices: (total_nnz), the indices that represent the non-masked tokens of the original padded input sequence.
+        batch: int, batch size for the padded sequence.
+        seqlen: int, maximum sequence length for the padded sequence.
+    Return:
+        hidden_states: (batch, seqlen, ...)
+    """
+    dim = hidden_states.shape[-1]
+    # output = torch.zeros((batch * seqlen), dim, device=hidden_states.device, dtype=hidden_states.dtype)
+    # output[indices] = hidden_states
+    output = index_put_first_axis(hidden_states, indices, batch * seqlen)
+    return rearrange(output, "(b s) ... -> b s ...", b=batch)

triton_flash_attn.py ADDED Viewed

	@@ -0,0 +1,964 @@

+"""
+Fused Attention
+===============
+This is a Triton implementation of the Flash Attention v2 algorithm from Tri Dao (https://tridao.me/publications/flash2/flash2.pdf)
+Credits: OpenAI kernel team
+Extra Credits:
+- Original flash attention paper (https://arxiv.org/abs/2205.14135)
+- Rabe and Staats (https://arxiv.org/pdf/2112.05682v2.pdf)
+"""
+import pytest
+import torch
+import triton
+import triton.language as tl
+# Pick the fp8 data type
+# AMD E4M3B8
+# Note: When picking this f8 data type, scaling is required when using f8
+# for the second gemm
+# TORCH_HAS_FP8E4B8 = hasattr(torch, 'float8_e4m3fnuz')
+# AMD E5M2B16
+TORCH_HAS_FP8E5B16 = hasattr(torch, "float8_e5m2fnuz")
+@triton.jit
+def _attn_fwd_inner(
+    acc,
+    l_i,
+    m_i,
+    q,
+    K_block_ptr,
+    V_block_ptr,
+    start_m,
+    BLOCK_M: tl.constexpr,
+    BLOCK_DMODEL: tl.constexpr,
+    BLOCK_N: tl.constexpr,
+    STAGE: tl.constexpr,
+    offs_m: tl.constexpr,
+    offs_n: tl.constexpr,
+    N_CTX,
+    pre_load_v: tl.constexpr,
+):
+    # range of values handled by this stage
+    if STAGE == 1:
+        lo, hi = 0, start_m * BLOCK_M
+    elif STAGE == 2:
+        lo, hi = start_m * BLOCK_M, (start_m + 1) * BLOCK_M
+        lo = tl.multiple_of(lo, BLOCK_M)
+        K_block_ptr = tl.advance(K_block_ptr, (0, lo))
+        V_block_ptr = tl.advance(V_block_ptr, (lo, 0))
+    # causal = False
+    else:
+        lo, hi = 0, N_CTX
+    # loop over k, v and update accumulator
+    for start_n in range(lo, hi, BLOCK_N):
+        start_n = tl.multiple_of(start_n, BLOCK_N)
+        # -- compute qk ----
+        k = tl.load(K_block_ptr)
+        if pre_load_v:
+            v = tl.load(V_block_ptr)
+        qk = tl.zeros([BLOCK_M, BLOCK_N], dtype=tl.float32)
+        if STAGE == 2:
+            mask = offs_m[:, None] >= (start_n + offs_n[None, :])
+            qk = tl.where(mask, qk, float("-inf"))
+        qk += tl.dot(q, k)
+        m_ij = tl.maximum(m_i, tl.max(qk, 1))
+        qk = qk - m_ij[:, None]
+        p = tl.math.exp2(qk)
+        # -- update output accumulator --
+        alpha = tl.math.exp2(m_i - m_ij)
+        acc = acc * alpha[:, None]
+        if not pre_load_v:
+            v = tl.load(V_block_ptr)
+        acc += tl.dot(p.to(v.dtype), v)
+        # -- update m_i and l_i
+        l_ij = tl.sum(p, 1)
+        l_i = l_i * alpha + l_ij
+        # update m_i and l_i
+        m_i = m_ij
+        V_block_ptr = tl.advance(V_block_ptr, (BLOCK_N, 0))
+        K_block_ptr = tl.advance(K_block_ptr, (0, BLOCK_N))
+    return acc, l_i, m_i
+# We don't run auto-tuning everytime to keep the tutorial fast. Uncommenting
+# the code below and commenting out the equivalent parameters is convenient for
+# re-tuning.
+@triton.autotune(
+    configs=[
+        triton.Config(
+            {
+                "BLOCK_M": 64,
+                "BLOCK_N": 16,
+                "waves_per_eu": 2,
+                "slice_k_tile": 0,
+                "pre_load_v": False,
+            },
+            num_stages=1,
+            num_warps=2,
+        ),
+        triton.Config(
+            {
+                "BLOCK_M": 64,
+                "BLOCK_N": 16,
+                "waves_per_eu": 2,
+                "slice_k_tile": 32,
+                "pre_load_v": False,
+            },
+            num_stages=1,
+            num_warps=2,
+        ),
+        triton.Config(
+            {
+                "BLOCK_M": 32,
+                "BLOCK_N": 32,
+                "waves_per_eu": 2,
+                "slice_k_tile": 0,
+                "pre_load_v": False,
+            },
+            num_stages=1,
+            num_warps=1,
+        ),
+        triton.Config(
+            {
+                "BLOCK_M": 32,
+                "BLOCK_N": 32,
+                "waves_per_eu": 2,
+                "slice_k_tile": 32,
+                "pre_load_v": False,
+            },
+            num_stages=1,
+            num_warps=1,
+        ),
+        triton.Config(
+            {
+                "BLOCK_M": 64,
+                "BLOCK_N": 32,
+                "waves_per_eu": 2,
+                "slice_k_tile": 0,
+                "pre_load_v": False,
+            },
+            num_stages=1,
+            num_warps=2,
+        ),
+        triton.Config(
+            {
+                "BLOCK_M": 32,
+                "BLOCK_N": 16,
+                "waves_per_eu": 3,
+                "slice_k_tile": 0,
+                "pre_load_v": True,
+            },
+            num_stages=1,
+            num_warps=1,
+        ),
+        triton.Config(
+            {
+                "BLOCK_M": 32,
+                "BLOCK_N": 16,
+                "waves_per_eu": 3,
+                "slice_k_tile": 0,
+                "pre_load_v": False,
+            },
+            num_stages=1,
+            num_warps=1,
+        ),
+    ],
+    key=["Z", "H", "N_CTX", "STAGE", "BLOCK_DMODEL"],
+)
+@triton.jit
+def _attn_fwd(
+    Q,
+    K,
+    V,
+    sm_scale,
+    M,
+    Out,
+    stride_qz,
+    stride_qh,
+    stride_qm,
+    stride_qk,
+    stride_kz,
+    stride_kh,
+    stride_kn,
+    stride_kk,
+    stride_vz,
+    stride_vh,
+    stride_vk,
+    stride_vn,
+    stride_oz,
+    stride_oh,
+    stride_om,
+    stride_on,
+    Z,
+    H,
+    N_CTX,
+    BLOCK_DMODEL: tl.constexpr,
+    STAGE: tl.constexpr,
+    BLOCK_M: tl.constexpr,
+    BLOCK_N: tl.constexpr,
+    pre_load_v: tl.constexpr,
+):
+    start_m = tl.program_id(0)
+    off_hz = tl.program_id(1)
+    qvk_offset = off_hz * stride_qh
+    # block pointers
+    Q_block_ptr = tl.make_block_ptr(
+        base=Q + qvk_offset,
+        shape=(N_CTX, BLOCK_DMODEL),
+        strides=(stride_qm, stride_qk),
+        offsets=(start_m * BLOCK_M, 0),
+        block_shape=(BLOCK_M, BLOCK_DMODEL),
+        order=(1, 0),
+    )
+    V_block_ptr = tl.make_block_ptr(
+        base=V + qvk_offset,
+        shape=(N_CTX, BLOCK_DMODEL),
+        strides=(stride_vk, stride_vn),
+        offsets=(0, 0),
+        block_shape=(BLOCK_N, BLOCK_DMODEL),
+        order=(1, 0),
+    )
+    K_block_ptr = tl.make_block_ptr(
+        base=K + qvk_offset,
+        shape=(BLOCK_DMODEL, N_CTX),
+        strides=(stride_kk, stride_kn),
+        offsets=(0, 0),
+        block_shape=(BLOCK_DMODEL, BLOCK_N),
+        order=(0, 1),
+    )
+    O_block_ptr = tl.make_block_ptr(
+        base=Out + qvk_offset,
+        shape=(N_CTX, BLOCK_DMODEL),
+        strides=(stride_om, stride_on),
+        offsets=(start_m * BLOCK_M, 0),
+        block_shape=(BLOCK_M, BLOCK_DMODEL),
+        order=(1, 0),
+    )
+    # initialize offsets
+    offs_m = start_m * BLOCK_M + tl.arange(0, BLOCK_M)
+    offs_n = tl.arange(0, BLOCK_N)
+    # initialize pointer to m and l
+    m_i = tl.zeros([BLOCK_M], dtype=tl.float32) - float("inf")
+    l_i = tl.zeros([BLOCK_M], dtype=tl.float32) + 1.0
+    acc = tl.zeros([BLOCK_M, BLOCK_DMODEL], dtype=tl.float32)
+    # scale sm_scale by log_2(e) and use
+    # 2^x instead of exp in the loop because CSE and LICM
+    # don't work as expected with `exp` in the loop
+    qk_scale = sm_scale * 1.44269504
+    # load q: it will stay in SRAM throughout on NV GPUs but in VGPRs on AMD GPUs
+    q = tl.load(Q_block_ptr)
+    q = (q * qk_scale).to(q.dtype)
+    # stage 1: off-band
+    # For causal = True, STAGE = 3 and _attn_fwd_inner gets 1 as its STAGE
+    # For causal = False, STAGE = 1, and _attn_fwd_inner gets 3 as its STAGE
+    if STAGE & 1:
+        acc, l_i, m_i = _attn_fwd_inner(
+            acc,
+            l_i,
+            m_i,
+            q,
+            K_block_ptr,
+            V_block_ptr,
+            start_m,
+            BLOCK_M,
+            BLOCK_DMODEL,
+            BLOCK_N,
+            4 - STAGE,
+            offs_m,
+            offs_n,
+            N_CTX,
+            pre_load_v,
+        )
+    # stage 2: on-band
+    if STAGE & 2:
+        # barrier makes it easier for compielr to schedule the
+        # two loops independently
+        tl.debug_barrier()
+        acc, l_i, m_i = _attn_fwd_inner(
+            acc,
+            l_i,
+            m_i,
+            q,
+            K_block_ptr,
+            V_block_ptr,
+            start_m,
+            BLOCK_M,
+            BLOCK_DMODEL,
+            BLOCK_N,
+            2,
+            offs_m,
+            offs_n,
+            N_CTX,
+            pre_load_v,
+        )
+    # epilogue
+    # write back m
+    acc = acc / l_i[:, None]
+    m_ptrs = M + off_hz * N_CTX + offs_m
+    tl.store(m_ptrs, m_i + tl.math.log2(l_i))
+    tl.store(O_block_ptr, acc.to(Out.type.element_ty))
+@triton.jit
+def _attn_bwd_preprocess(
+    O, DO, Delta, Z, H, N_CTX, BLOCK_M: tl.constexpr, D_HEAD: tl.constexpr
+):
+    off_m = tl.program_id(0) * BLOCK_M + tl.arange(0, BLOCK_M)
+    off_hz = tl.program_id(1)
+    off_n = tl.arange(0, D_HEAD)
+    o = tl.load(O + off_hz * D_HEAD * N_CTX + off_m[:, None] * D_HEAD + off_n[None, :])
+    do = tl.load(
+        DO + off_hz * D_HEAD * N_CTX + off_m[:, None] * D_HEAD + off_n[None, :]
+    ).to(tl.float32)
+    delta = tl.sum(o * do, axis=1)
+    tl.store(Delta + off_hz * N_CTX + off_m, delta)
+# The main inner-loop logic for computing dK and dV.
+@triton.jit
+def _attn_bwd_dkdv(
+    dk,
+    dv,
+    Q,
+    k,
+    v,
+    sm_scale,
+    DO,
+    M,
+    D,
+    # shared by Q/K/V/DO.
+    stride_tok,
+    stride_d,
+    H,
+    N_CTX,
+    BLOCK_M1: tl.constexpr,
+    BLOCK_N1: tl.constexpr,
+    BLOCK_DMODEL: tl.constexpr,
+    # Filled in by the wrapper.
+    start_n,
+    start_m,
+    num_steps,
+    MASK: tl.constexpr,
+):
+    offs_m = start_m + tl.arange(0, BLOCK_M1)
+    offs_n = start_n + tl.arange(0, BLOCK_N1)
+    offs_k = tl.arange(0, BLOCK_DMODEL)
+    QT_block_ptr = tl.make_block_ptr(
+        base=Q,
+        shape=(BLOCK_DMODEL, N_CTX),
+        strides=(stride_d, stride_tok),
+        offsets=(0, start_m),
+        block_shape=(BLOCK_DMODEL, BLOCK_M1),
+        order=(0, 1),
+    )
+    DO_block_ptr = tl.make_block_ptr(
+        base=DO,
+        shape=(N_CTX, BLOCK_DMODEL),
+        strides=(stride_tok, stride_d),
+        offsets=(start_m, 0),
+        block_shape=(BLOCK_M1, BLOCK_DMODEL),
+        order=(1, 0),
+    )
+    # BLOCK_N1 must be a multiple of BLOCK_M1, otherwise the code wouldn't work.
+    tl.static_assert(BLOCK_N1 % BLOCK_M1 == 0)
+    curr_m = start_m
+    step_m = BLOCK_M1
+    for blk_idx in range(num_steps):
+        qT = tl.load(QT_block_ptr)
+        # Load m before computing qk to reduce pipeline stall.
+        offs_m = curr_m + tl.arange(0, BLOCK_M1)
+        m = tl.load(M + offs_m)
+        qkT = tl.dot(k, qT)
+        pT = tl.math.exp2(qkT - m[None, :])
+        # Autoregressive masking.
+        if MASK:
+            mask = offs_m[None, :] >= offs_n[:, None]
+            pT = tl.where(mask, pT, 0.0)
+        do = tl.load(DO_block_ptr)
+        # Compute dV.
+        ppT = pT
+        ppT = ppT.to(tl.float16)
+        dv += tl.dot(ppT, do)
+        # D (= delta) is pre-divided by ds_scale.
+        Di = tl.load(D + offs_m)
+        # Compute dP and dS.
+        dpT = tl.dot(v, tl.trans(do))
+        dsT = pT * (dpT - Di[None, :])
+        dsT = dsT.to(tl.float16)
+        dk += tl.dot(dsT, tl.trans(qT))
+        # Increment pointers.
+        curr_m += step_m
+        QT_block_ptr = tl.advance(QT_block_ptr, (0, step_m))
+        DO_block_ptr = tl.advance(DO_block_ptr, (step_m, 0))
+    return dk, dv
+# the main inner-loop logic for computing dQ
+@triton.jit
+def _attn_bwd_dq(
+    dq,
+    q,
+    K,
+    V,
+    do,
+    m,
+    D,
+    # shared by Q/K/V/DO.
+    stride_tok,
+    stride_d,
+    H,
+    N_CTX,
+    BLOCK_M2: tl.constexpr,
+    BLOCK_N2: tl.constexpr,
+    BLOCK_DMODEL: tl.constexpr,
+    # Filled in by the wrapper.
+    start_m,
+    start_n,
+    num_steps,
+    MASK: tl.constexpr,
+):
+    offs_m = start_m + tl.arange(0, BLOCK_M2)
+    offs_n = start_n + tl.arange(0, BLOCK_N2)
+    offs_k = tl.arange(0, BLOCK_DMODEL)
+    KT_block_ptr = tl.make_block_ptr(
+        base=K,
+        shape=(BLOCK_DMODEL, N_CTX),
+        strides=(stride_d, stride_tok),
+        offsets=(0, start_n),
+        block_shape=(BLOCK_DMODEL, BLOCK_N2),
+        order=(0, 1),
+    )
+    VT_block_ptr = tl.make_block_ptr(
+        base=V,
+        shape=(BLOCK_DMODEL, N_CTX),
+        strides=(stride_d, stride_tok),
+        offsets=(0, start_n),
+        block_shape=(BLOCK_DMODEL, BLOCK_N2),
+        order=(0, 1),
+    )
+    # D (= delta) is pre-divided by ds_scale.
+    Di = tl.load(D + offs_m)
+    # BLOCK_M2 must be a multiple of BLOCK_N2, otherwise the code wouldn't work.
+    tl.static_assert(BLOCK_M2 % BLOCK_N2 == 0)
+    curr_n = start_n
+    step_n = BLOCK_N2
+    for blk_idx in range(num_steps):
+        kT = tl.load(KT_block_ptr)
+        qk = tl.dot(q, kT)
+        p = tl.math.exp2(qk - m)
+        # Autoregressive masking.
+        if MASK:
+            offs_n = curr_n + tl.arange(0, BLOCK_N2)
+            mask = offs_m[:, None] >= offs_n[None, :]
+            p = tl.where(mask, p, 0.0)
+        # Compute dP and dS.
+        vT = tl.load(VT_block_ptr)
+        dp = tl.dot(do, vT).to(tl.float32)
+        ds = p * (dp - Di[:, None])
+        ds = ds.to(tl.float16)
+        # Compute dQ.
+        # NOTE: We need to de-scale dq in the end, because kT was pre-scaled.
+        dq += tl.dot(ds, tl.trans(kT))
+        # Increment pointers.
+        curr_n += step_n
+        KT_block_ptr = tl.advance(KT_block_ptr, (0, step_n))
+        VT_block_ptr = tl.advance(VT_block_ptr, (0, step_n))
+    return dq
+@triton.autotune(
+    configs=[
+        triton.Config(
+            {
+                "BLOCK_M1": 32,
+                "BLOCK_N1": 64,
+                "BLOCK_M2": 64,
+                "BLOCK_N2": 32,
+                "BLK_SLICE_FACTOR": 1,
+            },
+            num_stages=1,
+            num_warps=4,
+        ),
+        triton.Config(
+            {
+                "BLOCK_M1": 32,
+                "BLOCK_N1": 64,
+                "BLOCK_M2": 64,
+                "BLOCK_N2": 32,
+                "BLK_SLICE_FACTOR": 2,
+            },
+            num_stages=1,
+            num_warps=4,
+        ),
+        triton.Config(
+            {
+                "BLOCK_M1": 64,
+                "BLOCK_N1": 128,
+                "BLOCK_M2": 128,
+                "BLOCK_N2": 64,
+                "BLK_SLICE_FACTOR": 1,
+            },
+            num_stages=1,
+            num_warps=4,
+        ),
+        triton.Config(
+            {
+                "BLOCK_M1": 64,
+                "BLOCK_N1": 128,
+                "BLOCK_M2": 128,
+                "BLOCK_N2": 64,
+                "BLK_SLICE_FACTOR": 2,
+            },
+            num_stages=1,
+            num_warps=4,
+        ),
+        triton.Config(
+            {
+                "BLOCK_M1": 64,
+                "BLOCK_N1": 64,
+                "BLOCK_M2": 64,
+                "BLOCK_N2": 64,
+                "BLK_SLICE_FACTOR": 1,
+            },
+            num_stages=1,
+            num_warps=4,
+        ),
+        triton.Config(
+            {
+                "BLOCK_M1": 64,
+                "BLOCK_N1": 64,
+                "BLOCK_M2": 64,
+                "BLOCK_N2": 64,
+                "BLK_SLICE_FACTOR": 2,
+            },
+            num_stages=1,
+            num_warps=4,
+        ),
+        triton.Config(
+            {
+                "BLOCK_M1": 32,
+                "BLOCK_N1": 128,
+                "BLOCK_M2": 128,
+                "BLOCK_N2": 32,
+                "BLK_SLICE_FACTOR": 1,
+            },
+            num_stages=1,
+            num_warps=4,
+        ),
+        triton.Config(
+            {
+                "BLOCK_M1": 32,
+                "BLOCK_N1": 128,
+                "BLOCK_M2": 128,
+                "BLOCK_N2": 32,
+                "BLK_SLICE_FACTOR": 2,
+            },
+            num_stages=1,
+            num_warps=4,
+        ),
+        triton.Config(
+            {
+                "BLOCK_M1": 32,
+                "BLOCK_N1": 128,
+                "BLOCK_M2": 128,
+                "BLOCK_N2": 32,
+                "BLK_SLICE_FACTOR": 2,
+            },
+            num_stages=1,
+            num_warps=8,
+        ),
+    ],
+    key=["H", "N_CTX", "BLOCK_DMODEL"],
+)
+@triton.jit
+def _attn_bwd(
+    Q,
+    K,
+    V,
+    sm_scale,
+    DO,
+    DQ,
+    DK,
+    DV,
+    M,
+    D,
+    # shared by Q/K/V/DO.
+    stride_z,
+    stride_h,
+    stride_tok,
+    stride_d,
+    # H = 16, N_CTX = 1024
+    H,
+    N_CTX,
+    BLOCK_DMODEL: tl.constexpr,
+    BLOCK_M1: tl.constexpr,
+    BLOCK_N1: tl.constexpr,
+    BLOCK_M2: tl.constexpr,
+    BLOCK_N2: tl.constexpr,
+    BLK_SLICE_FACTOR: tl.constexpr,
+):
+    LN2: tl.constexpr = 0.6931471824645996  # = ln(2)
+    bhid = tl.program_id(2)
+    off_chz = (bhid * N_CTX).to(tl.int64)
+    adj = (stride_h * (bhid % H) + stride_z * (bhid // H)).to(tl.int64)
+    pid = tl.program_id(0)
+    # offset pointers for batch/head
+    Q += adj
+    K += adj
+    V += adj
+    DO += adj
+    DQ += adj
+    DK += adj
+    DV += adj
+    M += off_chz
+    D += off_chz
+    offs_k = tl.arange(0, BLOCK_DMODEL)
+    start_n = pid * BLOCK_N1
+    # This assignment is important. It is what allows us to pick the diagonal
+    # blocks. Later, when we want to do the lower triangular, we update start_m
+    # after the first dkdv call.
+    start_m = start_n
+    MASK_BLOCK_M1: tl.constexpr = BLOCK_M1 // BLK_SLICE_FACTOR
+    offs_n = start_n + tl.arange(0, BLOCK_N1)
+    dv = tl.zeros([BLOCK_N1, BLOCK_DMODEL], dtype=tl.float32)
+    dk = tl.zeros([BLOCK_N1, BLOCK_DMODEL], dtype=tl.float32)
+    K_block_ptr = tl.make_block_ptr(
+        base=K,
+        shape=(N_CTX, BLOCK_DMODEL),
+        strides=(stride_tok, stride_d),
+        offsets=(start_n, 0),
+        block_shape=(BLOCK_N1, BLOCK_DMODEL),
+        order=(1, 0),
+    )
+    V_block_ptr = tl.make_block_ptr(
+        base=V,
+        shape=(N_CTX, BLOCK_DMODEL),
+        strides=(stride_tok, stride_d),
+        offsets=(start_n, 0),
+        block_shape=(BLOCK_N1, BLOCK_DMODEL),
+        order=(1, 0),
+    )
+    # load K and V: they stay in SRAM throughout the inner loop for dkdv.
+    k = tl.load(K_block_ptr)
+    v = tl.load(V_block_ptr)
+    num_steps = BLOCK_N1 // MASK_BLOCK_M1
+    dk, dv = _attn_bwd_dkdv(
+        dk,
+        dv,
+        Q,
+        k,
+        v,
+        sm_scale,
+        DO,
+        M,
+        D,
+        stride_tok,
+        stride_d,
+        H,
+        N_CTX,
+        MASK_BLOCK_M1,
+        BLOCK_N1,
+        BLOCK_DMODEL,
+        start_n,
+        start_m,
+        num_steps,
+        MASK=True,
+    )
+    start_m += num_steps * MASK_BLOCK_M1
+    num_steps = (N_CTX - start_m) // BLOCK_M1
+    # Compute dK and dV for non-masked blocks.
+    dk, dv = _attn_bwd_dkdv(
+        dk,
+        dv,
+        Q,
+        k,
+        v,
+        sm_scale,
+        DO,
+        M,
+        D,
+        stride_tok,
+        stride_d,
+        H,
+        N_CTX,
+        BLOCK_M1,
+        BLOCK_N1,
+        BLOCK_DMODEL,
+        start_n,
+        start_m,
+        num_steps,
+        MASK=False,
+    )
+    DV_block_ptrs = tl.make_block_ptr(
+        base=DV,
+        shape=(N_CTX, BLOCK_DMODEL),
+        strides=(stride_tok, stride_d),
+        offsets=(start_n, 0),
+        block_shape=(BLOCK_N1, BLOCK_DMODEL),
+        order=(1, 0),
+    )
+    tl.store(DV_block_ptrs, dv.to(tl.float16))
+    # Write back dK.
+    dk *= sm_scale
+    DK_block_ptrs = tl.make_block_ptr(
+        base=DK,
+        shape=(N_CTX, BLOCK_DMODEL),
+        strides=(stride_tok, stride_d),
+        offsets=(start_n, 0),
+        block_shape=(BLOCK_N1, BLOCK_DMODEL),
+        order=(1, 0),
+    )
+    tl.store(DK_block_ptrs, dk.to(tl.float16))
+    # THIS BLOCK DOES DQ:
+    start_m = pid * BLOCK_M2
+    end_n = start_m + BLOCK_M2
+    MASK_BLOCK_N2: tl.constexpr = BLOCK_N2 // BLK_SLICE_FACTOR
+    offs_m = start_m + tl.arange(0, BLOCK_M2)
+    Q_block_ptr = tl.make_block_ptr(
+        base=Q,
+        shape=(N_CTX, BLOCK_DMODEL),
+        strides=(stride_tok, stride_d),
+        offsets=(start_m, 0),
+        block_shape=(BLOCK_M2, BLOCK_DMODEL),
+        order=(1, 0),
+    )
+    DO_block_ptr = tl.make_block_ptr(
+        base=DO,
+        shape=(N_CTX, BLOCK_DMODEL),
+        strides=(stride_tok, stride_d),
+        offsets=(start_m, 0),
+        block_shape=(BLOCK_M2, BLOCK_DMODEL),
+        order=(1, 0),
+    )
+    q = tl.load(Q_block_ptr)
+    do = tl.load(DO_block_ptr)
+    dq = tl.zeros([BLOCK_M2, BLOCK_DMODEL], dtype=tl.float32)
+    m = tl.load(M + offs_m)
+    m = m[:, None]
+    # Compute dQ for masked (diagonal) blocks.
+    # NOTE: This code scans each row of QK^T backward (from right to left,
+    # but inside each call to _attn_bwd_dq, from left to right), but that's
+    # not due to anything important.  I just wanted to reuse the loop
+    # structure for dK & dV above as much as possible.
+    num_steps = BLOCK_M2 // MASK_BLOCK_N2
+    dq = _attn_bwd_dq(
+        dq,
+        q,
+        K,
+        V,
+        do,
+        m,
+        D,
+        stride_tok,
+        stride_d,
+        H,
+        N_CTX,
+        BLOCK_M2,
+        MASK_BLOCK_N2,
+        BLOCK_DMODEL,
+        start_m,
+        end_n - num_steps * MASK_BLOCK_N2,
+        num_steps,
+        MASK=True,
+    )
+    end_n -= num_steps * MASK_BLOCK_N2
+    # stage 2
+    num_steps = end_n // BLOCK_N2
+    dq = _attn_bwd_dq(
+        dq,
+        q,
+        K,
+        V,
+        do,
+        m,
+        D,
+        stride_tok,
+        stride_d,
+        H,
+        N_CTX,
+        BLOCK_M2,
+        BLOCK_N2,
+        BLOCK_DMODEL,
+        start_m,
+        end_n - num_steps * BLOCK_N2,
+        num_steps,
+        MASK=False,
+    )
+    # Write back dQ.
+    DQ_block_ptr = tl.make_block_ptr(
+        base=DQ,
+        shape=(N_CTX, BLOCK_DMODEL),
+        strides=(stride_tok, stride_d),
+        offsets=(start_m, 0),
+        block_shape=(BLOCK_M2, BLOCK_DMODEL),
+        order=(1, 0),
+    )
+    dq *= LN2
+    tl.store(DQ_block_ptr, dq.to(tl.float16))
+empty = torch.empty(128, device="cuda")
+class _attention(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, q, k, v, causal, sm_scale):
+        # shape constraints
+        Lq, Lk, Lv = q.shape[-1], k.shape[-1], v.shape[-1]
+        assert Lq == Lk and Lk == Lv
+        assert Lk in {16, 32, 64, 128}
+        o = torch.empty_like(q, dtype=v.dtype)
+        if torch.version.hip is None:
+            BLOCK_M = 128
+            BLOCK_N = 64 if Lk <= 64 else 32
+            num_stages = 4 if Lk <= 64 else 3
+            num_warps = 4 if Lk <= 64 else 8
+            # Tuning for H100
+            if torch.cuda.get_device_capability()[0] == 9:
+                num_warps = 8
+                num_stages = 7 if Lk >= 64 else 3
+        stage = 3 if causal else 1
+        def grid(META):
+            return (
+                triton.cdiv(q.shape[2], META["BLOCK_M"]),
+                q.shape[0] * q.shape[1],
+                1,
+            )
+        M = torch.empty(
+            (q.shape[0] * q.shape[1], q.shape[2]), device=q.device, dtype=torch.float32
+        )
+        _attn_fwd[grid](
+            q,
+            k,
+            v,
+            sm_scale,
+            M,
+            o,
+            q.stride(0),
+            q.stride(1),
+            q.stride(2),
+            q.stride(3),
+            k.stride(0),
+            k.stride(1),
+            k.stride(2),
+            k.stride(3),
+            v.stride(0),
+            v.stride(1),
+            v.stride(2),
+            v.stride(3),
+            o.stride(0),
+            o.stride(1),
+            o.stride(2),
+            o.stride(3),
+            q.shape[0],
+            q.shape[1],
+            N_CTX=q.shape[2],
+            BLOCK_DMODEL=Lk,
+            STAGE=stage,
+        )
+        # restore the grid for bwd kernel
+        best_config = _attn_fwd.get_best_config()
+        block_m = int(best_config.__str__().split(",")[0].split("BLOCK_M:")[1])
+        grid = (triton.cdiv(q.shape[2], block_m), q.shape[0] * q.shape[1], 1)
+        ctx.save_for_backward(q, k, v, o, M)
+        ctx.grid = grid
+        ctx.sm_scale = sm_scale
+        ctx.BLOCK_DMODEL = Lk
+        ctx.causal = causal
+        return o
+    @staticmethod
+    def backward(ctx, do):
+        if torch.version.hip is not None:
+            BLOCK = 64
+        else:
+            BLOCK = 128
+        q, k, v, o, M = ctx.saved_tensors
+        assert do.is_contiguous()
+        assert q.stride() == k.stride() == v.stride() == o.stride() == do.stride()
+        dq = torch.empty_like(q)
+        dk = torch.empty_like(k)
+        dv = torch.empty_like(v)
+        BATCH, N_HEAD, N_CTX = q.shape[:3]
+        PRE_BLOCK = 128
+        NUM_WARPS, NUM_STAGES = 4, 1
+        BLOCK_M1, BLOCK_N1, BLOCK_M2, BLOCK_N2 = 32, 64, 64, 32
+        BLK_SLICE_FACTOR = 2
+        RCP_LN2 = 1.4426950408889634  # = 1.0 / ln(2)
+        arg_k = k
+        arg_k = arg_k * (ctx.sm_scale * RCP_LN2)
+        assert N_CTX % PRE_BLOCK == 0
+        pre_grid = (N_CTX // PRE_BLOCK, BATCH * N_HEAD)
+        delta = torch.empty_like(M)
+        _attn_bwd_preprocess[pre_grid](
+            o,
+            do,
+            delta,
+            BATCH,
+            N_HEAD,
+            N_CTX,
+            BLOCK_M=PRE_BLOCK,
+            D_HEAD=ctx.BLOCK_DMODEL,
+        )
+        def grid(META):
+            return (triton.cdiv(N_CTX, META["BLOCK_N1"]), 1, BATCH * N_HEAD)
+        _attn_bwd[grid](
+            q,
+            arg_k,
+            v,
+            ctx.sm_scale,
+            do,
+            dq,
+            dk,
+            dv,
+            M,
+            delta,
+            q.stride(0),
+            q.stride(1),
+            q.stride(2),
+            q.stride(3),
+            N_HEAD,
+            N_CTX,
+            BLOCK_DMODEL=ctx.BLOCK_DMODEL,
+        )
+        return dq, dk, dv, None, None
+attention = _attention.apply