Model upload, utils

.gitignore

@@ -0,0 +1,26 @@
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+env/
+venv/
+ENV/
+*.egg-info/
+*.egg
+*.log
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Pytest
+.cache
+.pytest_cache/
+
+# VS Code
+.vscode/
+.idea/
+
+# System files
+.DS_Store
+Thumbs.db

README.md

@@ -0,0 +1,55 @@
+Model Card for Mars ViT Base Model
+
+## Model Architecture
+- Architecture: Vision Transformer (ViT) Base
+- Input Channels: 1 (grayscale images)
+- Number of Classes: 0 (features extraction)
+
+## Training Method
+- Method: Masked Autoencoder (MAE)
+- Dataset: 2 million CTX images
+
+## Usage Examples
+### Using timm
+```python
+import timm
+import torch
+
+model = timm.create_model(
+    'vit_base_patch16_224',
+    in_chans=1,
+    num_classes=0,
+    global_pool='',
+    checkpoint_path="https://huggingface.co/jfang/mars-vit-base-ctx2m/resolve/main/checkpoint-1199.pth"
+)
+
+model.eval()
+x = torch.randn(1, 1, 224, 224)
+with torch.no_grad():
+    features = model.forward_features(x)  # shape [1, tokens, embed_dim]
+print(features.shape)
+
+cls_token = features[:, 0]
+patch_tokens = features[:, 1:]
+```
+
+Using transformers
+```python
+from transformers import AutoModel, AutoImageProcessor
+
+model = AutoModel.from_pretrained("jfang/mars-vit-base-ctx2m")
+image_processor = AutoImageProcessor.from_pretrained("jfang/mars-vit-base-ctx2m")
+
+# Example usage
+from PIL import Image
+image = Image.open("some_image.png").convert("L")  # 1-channel
+inputs = image_processor(image, return_tensors="pt")
+outputs = model(**inputs)
+```
+
+### Model Performance
+The model is optimized for feature extraction from CTX images. Detailed performance metrics on specific tasks or datasets are not provided in this card.
+
+### Limitations
+The model is trained specifically on CTX images and may not generalize well to other types of images without further fine-tuning.
+The model is designed for feature extraction and does not include a classification head.

checkpoint-1199.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f2f3d358fe5106cd9f7604b7b7368da15e14d8585e776d0fa59766a4ae556e48
+size 341667862

config.json

@@ -0,0 +1,22 @@
+{
+  "architectures": [
+    "ViTModel"
+  ],
+  "attention_probs_dropout_prob": 0.0,
+  "encoder_stride": 16,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.0,
+  "hidden_size": 768,
+  "image_size": 224,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "layer_norm_eps": 1e-12,
+  "model_type": "vit",
+  "num_attention_heads": 12,
+  "num_channels": 1,
+  "num_hidden_layers": 12,
+  "patch_size": 16,
+  "qkv_bias": true,
+  "torch_dtype": "float32",
+  "transformers_version": "4.47.1"
+}

mae/checkpoint-1199.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6022020e9ce04b222a644f49059cdd0518d96e261f2d3b4ae93a95d12c8977d9
+size 1333326408

mae/mae_visualize.ipynb

@@ -0,0 +1,209 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "15c2148f-c1b0-46e0-87f6-2db29e13d5b8",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "This is a visualization demo using our pre-trained MAE models. Adapted from [MAE Visualize](https://github.com/facebookresearch/mae/blob/main/demo/mae_visualize.ipynb). Modified to work with our MAE models."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "df2c7e91-3981-44ae-a00e-1b26efa7aa5c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-01-27T01:14:13.796746Z",
+     "iopub.status.busy": "2025-01-27T01:14:13.796412Z",
+     "iopub.status.idle": "2025-01-27T01:14:13.803827Z",
+     "shell.execute_reply": "2025-01-27T01:14:13.803400Z",
+     "shell.execute_reply.started": "2025-01-27T01:14:13.796730Z"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from PIL import Image\n",
+    "\n",
+    "# Define utils\n",
+    "# Remove RGB-specific normalization\n",
+    "imagenet_mean = np.array([0.5])  # Using only one channel\n",
+    "imagenet_std = np.array([0.5])   # Using only one channel\n",
+    "\n",
+    "def show_image(image, title=''):\n",
+    "    # image is [H, W, 1] or [H, W]\n",
+    "    if not isinstance(image, torch.Tensor):\n",
+    "        image = torch.tensor(image)\n",
+    "    plt.imshow(((image * imagenet_std + imagenet_mean) * 255).clip(0, 255).int(), cmap='gray')\n",
+    "    plt.title(title, fontsize=16)\n",
+    "    plt.axis('off')\n",
+    "    return\n",
+    "\n",
+    "def run_one_image(img, model):\n",
+    "    x = torch.tensor(img)\n",
+    "    \n",
+    "    # Add channel dimension if not present\n",
+    "    if len(x.shape) == 2:\n",
+    "        x = x.unsqueeze(-1)  # Add channel dimension\n",
+    "    \n",
+    "    # make it a batch-like\n",
+    "    x = x.unsqueeze(dim=0)\n",
+    "    x = torch.einsum('nhwc->nchw', x)\n",
+    "\n",
+    "    # run MAE\n",
+    "    loss, y, mask = model(x.float(), mask_ratio=0.75)\n",
+    "    y = model.unpatchify(y)\n",
+    "    y = torch.einsum('nchw->nhwc', y).detach().cpu()\n",
+    "\n",
+    "    # visualize the mask\n",
+    "    mask = mask.detach()\n",
+    "    mask = mask.unsqueeze(-1).repeat(1, 1, model.patch_embed.patch_size[0]**2 * 1)  # Changed *3 to *1 for single channel\n",
+    "    mask = model.unpatchify(mask)\n",
+    "    mask = torch.einsum('nchw->nhwc', mask).detach().cpu()\n",
+    "    \n",
+    "    x = torch.einsum('nchw->nhwc', x)\n",
+    "\n",
+    "    # Rest of the function remains the same\n",
+    "    im_masked = x * (1 - mask)\n",
+    "    im_paste = x * (1 - mask) + y * mask\n",
+    "    \n",
+    "    plt.rcParams['figure.figsize'] = [24, 24]\n",
+    "\n",
+    "    plt.subplot(1, 4, 1)\n",
+    "    show_image(x[0], \"original\")\n",
+    "\n",
+    "    plt.subplot(1, 4, 2)\n",
+    "    show_image(im_masked[0], \"masked\")\n",
+    "\n",
+    "    plt.subplot(1, 4, 3)\n",
+    "\n",
+    "    # Only keep reconstructed pixels in masked region\n",
+    "    y_masked = y * mask\n",
+    "    \n",
+    "    black_value = -(imagenet_mean / imagenet_std)\n",
+    "    # Convert to a float or a torch Tensor\n",
+    "    black_value = torch.tensor(black_value, dtype=y_masked.dtype, device=y_masked.device)\n",
+    "    y_masked[mask == 0] = black_value\n",
+    "    show_image(y_masked[0], \"reconstruction only\")\n",
+    "    \n",
+    "    # show_image(y[0], \"reconstruction\")\n",
+    "\n",
+    "    plt.subplot(1, 4, 4)\n",
+    "    show_image(im_paste[0], \"reconstruction + visible\")\n",
+    "\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a47df54a",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-01-27T01:14:14.045225Z",
+     "iopub.status.busy": "2025-01-27T01:14:14.044902Z",
+     "iopub.status.idle": "2025-01-27T01:14:14.064737Z",
+     "shell.execute_reply": "2025-01-27T01:14:14.064205Z",
+     "shell.execute_reply.started": "2025-01-27T01:14:14.045199Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from glob import glob\n",
+    "import random\n",
+    "\n",
+    "img_paths = glob('./samples/*.png')\n",
+    "\n",
+    "img_path = random.choice(img_paths)\n",
+    "img = Image.open(img_path)\n",
+    "img = img.resize((224, 224))\n",
+    "img = np.array(img) / 255.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b33ab531",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-01-27T01:14:14.279739Z",
+     "iopub.status.busy": "2025-01-27T01:14:14.279422Z",
+     "iopub.status.idle": "2025-01-27T01:14:14.904252Z",
+     "shell.execute_reply": "2025-01-27T01:14:14.903550Z",
+     "shell.execute_reply.started": "2025-01-27T01:14:14.279714Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import sys\n",
+    "import os\n",
+    "sys.path.append(os.getcwd())\n",
+    "import models_mae_1c\n",
+    "\n",
+    "def prepare_model(chkpt_dir, arch='mae_vit_base_patch16'):\n",
+    "    # build model\n",
+    "    model = getattr(models_mae_1c, arch)()\n",
+    "    # load model\n",
+    "    checkpoint = torch.load(chkpt_dir, map_location='cpu')\n",
+    "    msg = model.load_state_dict(checkpoint['model'], strict=False)\n",
+    "    print(msg)\n",
+    "    return model\n",
+    "\n",
+    "\n",
+    "model = prepare_model(\"./checkpoint-1199.pth\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "05a153d6",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-01-27T01:14:29.875184Z",
+     "iopub.status.busy": "2025-01-27T01:14:29.874954Z",
+     "iopub.status.idle": "2025-01-27T01:14:30.229847Z",
+     "shell.execute_reply": "2025-01-27T01:14:30.229301Z",
+     "shell.execute_reply.started": "2025-01-27T01:14:29.875168Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "img_path = random.choice(img_paths)\n",
+    "img = Image.open(img_path).convert(\"L\")\n",
+    "img = img.resize((224, 224))\n",
+    "img = np.array(img) / 255.\n",
+    "# show_image(img)\n",
+    "run_one_image(img, model)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "vfms",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

mae/models_mae_1c.py

@@ -0,0 +1,279 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+# --------------------------------------------------------
+# References:
+# timm: https://github.com/rwightman/pytorch-image-models/tree/master/timm
+# DeiT: https://github.com/facebookresearch/deit
+# --------------------------------------------------------
+
+from functools import partial
+
+import torch
+import torch.nn as nn
+import numpy as np
+
+from timm.models.vision_transformer import PatchEmbed, Block
+
+def get_2d_sincos_pos_embed(embed_dim, grid_size, cls_token=False):
+    """
+    grid_size: int of the grid height and width
+    return:
+    pos_embed: [grid_size*grid_size, embed_dim] or [1+grid_size*grid_size, embed_dim] (w/ or w/o cls_token)
+    """
+    grid_h = np.arange(grid_size, dtype=np.float32)
+    grid_w = np.arange(grid_size, dtype=np.float32)
+    grid = np.meshgrid(grid_w, grid_h)  # here w goes first
+    grid = np.stack(grid, axis=0)
+
+    grid = grid.reshape([2, 1, grid_size, grid_size])
+    pos_embed = get_2d_sincos_pos_embed_from_grid(embed_dim, grid)
+    if cls_token:
+        pos_embed = np.concatenate([np.zeros([1, embed_dim]), pos_embed], axis=0)
+    return pos_embed
+
+
+class MaskedAutoencoderViT(nn.Module):
+    """ Masked Autoencoder with VisionTransformer backbone
+    """
+    def __init__(self, img_size=224, patch_size=16, in_chans=1,
+                 embed_dim=1024, depth=24, num_heads=16,
+                 decoder_embed_dim=512, decoder_depth=8, decoder_num_heads=16,
+                 mlp_ratio=4., norm_layer=nn.LayerNorm, norm_pix_loss=False):
+        super().__init__()
+
+        # --------------------------------------------------------------------------
+        # MAE encoder specifics
+        self.patch_embed = PatchEmbed(img_size, patch_size, in_chans, embed_dim)
+        num_patches = self.patch_embed.num_patches
+
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
+        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim), requires_grad=False)  # fixed sin-cos embedding
+
+        self.blocks = nn.ModuleList([
+            # Block(embed_dim, num_heads, mlp_ratio, qkv_bias=True, qk_scale=None, norm_layer=norm_layer)
+            Block(embed_dim, num_heads, mlp_ratio, qkv_bias=True, norm_layer=norm_layer)
+            for i in range(depth)])
+        self.norm = norm_layer(embed_dim)
+        # --------------------------------------------------------------------------
+
+        # --------------------------------------------------------------------------
+        # MAE decoder specifics
+        self.decoder_embed = nn.Linear(embed_dim, decoder_embed_dim, bias=True)
+
+        self.mask_token = nn.Parameter(torch.zeros(1, 1, decoder_embed_dim))
+
+        self.decoder_pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, decoder_embed_dim), requires_grad=False)  # fixed sin-cos embedding
+
+        self.decoder_blocks = nn.ModuleList([
+            # Block(decoder_embed_dim, decoder_num_heads, mlp_ratio, qkv_bias=True, qk_scale=None, norm_layer=norm_layer)
+            Block(decoder_embed_dim, decoder_num_heads, mlp_ratio, qkv_bias=True,  norm_layer=norm_layer)
+            
+            for i in range(decoder_depth)])
+
+        self.decoder_norm = norm_layer(decoder_embed_dim)
+        self.decoder_pred = nn.Linear(decoder_embed_dim, patch_size**2 * in_chans, bias=True) # decoder to patch
+        # --------------------------------------------------------------------------
+
+        self.norm_pix_loss = norm_pix_loss
+
+        self.initialize_weights()
+
+    def initialize_weights(self):
+        # initialization
+        # initialize (and freeze) pos_embed by sin-cos embedding
+        pos_embed = get_2d_sincos_pos_embed(self.pos_embed.shape[-1], int(self.patch_embed.num_patches**.5), cls_token=True)
+        self.pos_embed.data.copy_(torch.from_numpy(pos_embed).float().unsqueeze(0))
+
+        decoder_pos_embed = get_2d_sincos_pos_embed(self.decoder_pos_embed.shape[-1], int(self.patch_embed.num_patches**.5), cls_token=True)
+        self.decoder_pos_embed.data.copy_(torch.from_numpy(decoder_pos_embed).float().unsqueeze(0))
+
+        # initialize patch_embed like nn.Linear (instead of nn.Conv2d)
+        w = self.patch_embed.proj.weight.data
+        torch.nn.init.xavier_uniform_(w.view([w.shape[0], -1]))
+
+        # timm's trunc_normal_(std=.02) is effectively normal_(std=0.02) as cutoff is too big (2.)
+        torch.nn.init.normal_(self.cls_token, std=.02)
+        torch.nn.init.normal_(self.mask_token, std=.02)
+
+        # initialize nn.Linear and nn.LayerNorm
+        self.apply(self._init_weights)
+
+    def _init_weights(self, m):
+        if isinstance(m, nn.Linear):
+            # we use xavier_uniform following official JAX ViT:
+            torch.nn.init.xavier_uniform_(m.weight)
+            if isinstance(m, nn.Linear) and m.bias is not None:
+                nn.init.constant_(m.bias, 0)
+        elif isinstance(m, nn.LayerNorm):
+            nn.init.constant_(m.bias, 0)
+            nn.init.constant_(m.weight, 1.0)
+
+    def patchify(self, imgs):
+        """
+        imgs: (N, 1, H, W)
+        x: (N, L, patch_size**2 * 1)
+        """
+        assert imgs.shape[1] == 1, f"Expected 1 channel, got {imgs.shape[1]}"
+        p = self.patch_embed.patch_size[0]
+        assert imgs.shape[2] == imgs.shape[3] and imgs.shape[2] % p == 0
+
+        h = w = imgs.shape[2] // p
+        x = imgs.reshape(shape=(imgs.shape[0], 1, h, p, w, p))
+        x = torch.einsum('nchpwq->nhwpqc', x)
+        x = x.reshape(shape=(imgs.shape[0], h * w, p**2 * 1))
+        return x
+
+    def unpatchify(self, x):
+        """
+        x: (N, L, patch_size**2 * 1)
+        imgs: (N, 1, H, W)
+        """
+        assert x.shape[2] == self.patch_embed.patch_size[0]**2, f"Incorrect patch dimension"
+        p = self.patch_embed.patch_size[0]
+        h = w = int(x.shape[1]**.5)
+        assert h * w == x.shape[1]
+        
+        x = x.reshape(shape=(x.shape[0], h, w, p, p, 1))
+        x = torch.einsum('nhwpqc->nchpwq', x)
+        imgs = x.reshape(shape=(x.shape[0], 1, h * p, h * p))
+        return imgs
+
+    def random_masking(self, x, mask_ratio):
+        """
+        Perform per-sample random masking by per-sample shuffling.
+        Per-sample shuffling is done by argsort random noise.
+        x: [N, L, D], sequence
+        """
+        N, L, D = x.shape  # batch, length, dim
+        len_keep = int(L * (1 - mask_ratio))
+        
+        noise = torch.rand(N, L, device=x.device)  # noise in [0, 1]
+        
+        # sort noise for each sample
+        ids_shuffle = torch.argsort(noise, dim=1)  # ascend: small is keep, large is remove
+        ids_restore = torch.argsort(ids_shuffle, dim=1)
+
+        # keep the first subset
+        ids_keep = ids_shuffle[:, :len_keep]
+        x_masked = torch.gather(x, dim=1, index=ids_keep.unsqueeze(-1).repeat(1, 1, D))
+
+        # generate the binary mask: 0 is keep, 1 is remove
+        mask = torch.ones([N, L], device=x.device)
+        mask[:, :len_keep] = 0
+        # unshuffle to get the binary mask
+        mask = torch.gather(mask, dim=1, index=ids_restore)
+
+        return x_masked, mask, ids_restore
+
+    def forward_encoder(self, x, mask_ratio):
+        # embed patches
+        x = self.patch_embed(x)
+
+        # add pos embed w/o cls token
+        x = x + self.pos_embed[:, 1:, :]
+
+        # masking: length -> length * mask_ratio
+        x, mask, ids_restore = self.random_masking(x, mask_ratio)
+
+        # append cls token
+        cls_token = self.cls_token + self.pos_embed[:, :1, :]
+        cls_tokens = cls_token.expand(x.shape[0], -1, -1)
+        x = torch.cat((cls_tokens, x), dim=1)
+
+        # apply Transformer blocks
+        for blk in self.blocks:
+            x = blk(x)
+        x = self.norm(x)
+
+        return x, mask, ids_restore
+
+    def forward_decoder(self, x, ids_restore):
+        # embed tokens
+        x = self.decoder_embed(x)
+
+        # append mask tokens to sequence
+        mask_tokens = self.mask_token.repeat(x.shape[0], ids_restore.shape[1] + 1 - x.shape[1], 1)
+        x_ = torch.cat([x[:, 1:, :], mask_tokens], dim=1)  # no cls token
+        x_ = torch.gather(x_, dim=1, index=ids_restore.unsqueeze(-1).repeat(1, 1, x.shape[2]))  # unshuffle
+        x = torch.cat([x[:, :1, :], x_], dim=1)  # append cls token
+
+        # add pos embed
+        x = x + self.decoder_pos_embed
+
+        # apply Transformer blocks
+        for blk in self.decoder_blocks:
+            x = blk(x)
+        x = self.decoder_norm(x)
+
+        # predictor projection
+        x = self.decoder_pred(x)
+
+        # remove cls token
+        x = x[:, 1:, :]
+
+        return x
+
+    def forward_loss(self, imgs, pred, mask):
+        """
+        imgs: [N, 3, H, W]
+        pred: [N, L, p*p*3]
+        mask: [N, L], 0 is keep, 1 is remove, 
+        """
+        target = self.patchify(imgs)
+        if self.norm_pix_loss:
+            mean = target.mean(dim=-1, keepdim=True)
+            var = target.var(dim=-1, keepdim=True)
+            target = (target - mean) / (var + 1.e-6)**.5
+
+        loss = (pred - target) ** 2
+        loss = loss.mean(dim=-1)  # [N, L], mean loss per patch
+
+        loss = (loss * mask).sum() / mask.sum()  # mean loss on removed patches
+        return loss
+
+    def forward(self, imgs, mask_ratio=0.75):
+        latent, mask, ids_restore = self.forward_encoder(imgs, mask_ratio)
+        pred = self.forward_decoder(latent, ids_restore)  # [N, L, p*p*3]
+        loss = self.forward_loss(imgs, pred, mask)
+        return loss, pred, mask
+
+
+def mae_vit_base_patch16_dec512d8b(**kwargs):
+    model = MaskedAutoencoderViT(
+        patch_size=16, embed_dim=768, depth=12, num_heads=12,
+        decoder_embed_dim=512, decoder_depth=8, decoder_num_heads=16,
+        mlp_ratio=4, norm_layer=partial(nn.LayerNorm, eps=1e-6), **kwargs)
+    return model
+
+
+def mae_vit_large_patch16_dec512d8b(**kwargs):
+    model = MaskedAutoencoderViT(
+        patch_size=16, embed_dim=1024, depth=24, num_heads=16,
+        decoder_embed_dim=512, decoder_depth=8, decoder_num_heads=16,
+        mlp_ratio=4, norm_layer=partial(nn.LayerNorm, eps=1e-6), **kwargs)
+    return model
+
+
+def mae_vit_huge_patch14_dec512d8b(**kwargs):
+    model = MaskedAutoencoderViT(
+        patch_size=14, embed_dim=1280, depth=32, num_heads=16,
+        decoder_embed_dim=512, decoder_depth=8, decoder_num_heads=16,
+        mlp_ratio=4, norm_layer=partial(nn.LayerNorm, eps=1e-6), **kwargs)
+    return model
+
+def mae_vit_small_patch16_dec512d8b(**kwargs):
+    model = MaskedAutoencoderViT(
+        patch_size=16, embed_dim=384, depth=12, num_heads=6,
+        decoder_embed_dim=512, decoder_depth=8, decoder_num_heads=16,
+        mlp_ratio=4, norm_layer=partial(nn.LayerNorm, eps=1e-6), **kwargs)
+    return model
+
+
+# set recommended archs
+mae_vit_base_patch16 = mae_vit_base_patch16_dec512d8b  # decoder: 512 dim, 8 blocks
+mae_vit_large_patch16 = mae_vit_large_patch16_dec512d8b  # decoder: 512 dim, 8 blocks
+mae_vit_huge_patch14 = mae_vit_huge_patch14_dec512d8b  # decoder: 512 dim, 8 blocks
+mae_vit_small_patch16 = mae_vit_small_patch16_dec512d8b

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04e7122c161a46314611a6ff20504ad1c7f84b05fe25bb2739e3c9f9ff83a093
+size 344006552