Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* 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
+assets/example_selection_maps/bottom_up_selection_prob.png filter=lfs diff=lfs merge=lfs -text
+assets/example_selection_maps/top_down_selection_prob_1.png filter=lfs diff=lfs merge=lfs -text
+assets/example_selection_maps/top_down_selection_prob_2.png filter=lfs diff=lfs merge=lfs -text
+assets/test_images/dock.jpg filter=lfs diff=lfs merge=lfs -text

LICENSE.md

@@ -0,0 +1,36 @@
+NVIDIA License
+
+1. Definitions
+
+“Licensor” means any person or entity that distributes its Work.
+“Work” means (a) the original work of authorship made available under this license, which may include software, documentation, or other files, and (b) any additions to or derivative works  thereof  that are made available under this license.
+The terms “reproduce,” “reproduction,” “derivative works,” and “distribution” have the meaning as provided under U.S. copyright law; provided, however, that for the purposes of this license, derivative works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work.
+Works are “made available” under this license by including in or with the Work either (a) a copyright notice referencing the applicability of this license to the Work, or (b) a copy of this license.
+
+2. License Grant
+
+2.1 Copyright Grant. Subject to the terms and conditions of this license, each Licensor grants to you a perpetual, worldwide, non-exclusive, royalty-free, copyright license to use, reproduce, prepare derivative works of, publicly display, publicly perform, sublicense and distribute its Work and any resulting derivative works in any form.
+
+3. Limitations
+
+3.1 Redistribution. You may reproduce or distribute the Work only if (a) you do so under this license, (b) you include a complete copy of this license with your distribution, and (c) you retain without modification any copyright, patent, trademark, or attribution notices that are present in the Work.
+
+3.2 Derivative Works. You may specify that additional or different terms apply to the use, reproduction, and distribution of your derivative works of the Work (“Your Terms”) only if (a) Your Terms provide that the use limitation in Section 3.3 applies to your derivative works, and (b) you identify the specific derivative works that are subject to Your Terms. Notwithstanding Your Terms, this license (including the redistribution requirements in Section 3.1) will continue to apply to the Work itself.
+
+3.3 Use Limitation. The Work and any derivative works thereof only may be used or intended for use non-commercially. Notwithstanding the foregoing, NVIDIA Corporation and its affiliates may use the Work and any derivative works commercially. As used herein, “non-commercially” means for non-commercial research activities or non-commercial research publications only.
+
+3.4 Patent Claims. If you bring or threaten to bring a patent claim against any Licensor (including any claim, cross-claim or counterclaim in a lawsuit) to enforce any patents that you allege are infringed by any Work, then your rights under this license from such Licensor (including the grant in Section 2.1) will terminate immediately.
+
+3.5 Trademarks. This license does not grant any rights to use any Licensor’s or its affiliates’ names, logos, or trademarks, except as necessary to reproduce the notices described in this license.
+
+3.6 Termination. If you violate any term of this license, then your rights under this license (including the grant in Section 2.1) will terminate immediately.
+
+4. Disclaimer of Warranty.
+
+THE WORK IS PROVIDED “AS IS” WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WARRANTIES OR CONDITIONS OF 
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE OR NON-INFRINGEMENT. YOU BEAR THE RISK OF UNDERTAKING ANY ACTIVITIES UNDER THIS LICENSE. 
+
+5. Limitation of Liability.
+
+EXCEPT AS PROHIBITED BY APPLICABLE LAW, IN NO EVENT AND UNDER NO LEGAL THEORY, WHETHER IN TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE SHALL ANY LICENSOR BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATED TO THIS LICENSE, THE USE OR INABILITY TO USE THE WORK (INCLUDING BUT NOT LIMITED TO LOSS OF GOODWILL, BUSINESS INTERRUPTION, LOST PROFITS OR DATA, COMPUTER FAILURE OR MALFUNCTION, OR ANY OTHER DAMAGES OR LOSSES), EVEN IF THE LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+

README.md

@@ -0,0 +1,380 @@
+---
+language:
+- en
+base_model:
+- google/siglip2-so400m-patch14-384
+pipeline_tag: image-feature-extraction
+---
+
+## Description: <br>
+
+PS3-1.5K-SigLIP2 is a vision encoder that extracts visual features from images of up to 1.5K resolution.
+
+This model is for research and development only.
+
+### License/Terms of Use: <br> 
+
+[NVIDIA license](https://huggingface.co/nvidia/PS3-1.5K-SigLIP2/blob/main/LICENSE.md). Additional Information: [Apache License 2.0](https://choosealicense.com/licenses/apache-2.0/) for [siglip2-so400m-patch14-384](https://huggingface.co/google/siglip2-so400m-patch14-384). The reference to the NVIDIA License means the attached custom NSCLv1 license, under which users may use for purposes of conducting non-commercial research activities and non-commercial research publications.
+
+### Deployment Geography:
+
+Global
+
+### Use Case: <br>
+
+The model is used for extracting visual features from high-resolution images.
+
+### Release Date:  <br>
+
+Huggingface [07/26/2025] via [https://huggingface.co/nvidia/PS3-1.5K-SigLIP2] <br> 
+
+## Reference(s):
+
+The model is from the paper [Scaling Vision Pre-Training to 4K Resolution](https://arxiv.org/abs/2503.19903). Useful links:
+
+[![website](https://img.shields.io/badge/website-76b900?style=for-the-badge&logo=safari&labelColor=555555)](https://nvlabs.github.io/PS3/)
+[![Arxiv](https://img.shields.io/badge/Arxiv-b31b1b?style=for-the-badge&logo=arxiv&labelColor=555555)](https://arxiv.org/abs/2503.19903)
+[![VILA-HD Demo](https://img.shields.io/badge/-VILA--HD_Demo-brightgreen?style=for-the-badge&logo=huggingface&labelColor=555555&color=ff6e00)](https://huggingface.co/spaces/bfshi/VILA-HD-demo)
+[![PS3 Models](https://img.shields.io/badge/PS3%20Models%20-ffd21e?style=for-the-badge&logo=huggingface&labelColor=555555)](https://huggingface.co/collections/nvidia/ps3-scaling-vision-pre-training-to-4k-resolution-682d0535b61c07afd45242e9)
+[![VILA-HD Models](https://img.shields.io/badge/VILA--HD%20Models%20-ffd21e?style=for-the-badge&logo=huggingface&labelColor=555555)](https://huggingface.co/collections/nvidia/ps3-scaling-vision-pre-training-to-4k-resolution-682d0535b61c07afd45242e9)
+[![PS3 Code](https://img.shields.io/badge/PS3%20Code%20-181717?style=for-the-badge&logo=github&labelColor=555555)](https://github.com/NVlabs/PS3)
+
+
+## Model Architecture:
+**Architecture Type:** Neural Network
+
+**Network Architecture:** Vision Transformer designed for high-resolution images 
+
+This model was developed based on [SigLIP2](https://huggingface.co/google/siglip2-so400m-patch14-384). Please see training designs in the paper.
+ 
+
+## Input: <br>
+**Input Type(s):** Image <br>
+**Input Format:** Red, Green, Blue (RGB) <br>
+**Input Parameters:** Two-Dimensional (2D) <br>
+**Other Properties Related to Input:** Image resolutions up to 1512*1512. <br>
+
+## Output: <br>
+**Output Type(s):** Embeddings <br>
+**Output Format:** Tensor <br>
+**Output Parameters:** One-Dimensional (1D) <br>
+**Other Properties Related to Output:** Downstream model required to leverage image features <br>
+
+Our AI models are designed and/or optimized to run on NVIDIA GPU-accelerated systems. By leveraging NVIDIA’s hardware (e.g. GPU cores) and software frameworks (e.g., CUDA libraries), the model achieves faster training and inference times compared to CPU-only solutions. <br> 
+
+## Software Integration:
+**Runtime Engine(s):** 
+Not Applicable (N/A) <br> 
+
+**Supported Hardware Microarchitecture Compatibility:** <br>
+NVIDIA Ampere <br>
+NVIDIA Blackwell <br>
+NVIDIA Jetson  <br>
+NVIDIA Hopper <br>
+
+**Preferred/Supported Operating System(s):**
+Linux <br>
+Linux 4 Tegra <br>
+QNX  <br>
+Windows <br>
+
+## Model Version(s): 
+
+v1.0 - Initial release
+
+## Pre-Trained Models
+
+### PS3 models
+
+| Vision Model    | Max Resolution | Pre-Trained Weights                                                     |
+|-----------------|----------------|-------------------------------------------------------------------------|
+| PS3-1.5K-SigLIP | 1512 * 1512    | [nvidia/PS3-1.5K-SigLIP](https://huggingface.co/nvidia/PS3-1.5K-SigLIP) |
+| PS3-4K-SigLIP   | 3780 * 3780    | [nvidia/PS3-4K-SigLIP](https://huggingface.co/nvidia/PS3-4K-SigLIP)     |
+| PS3-1.5K-C-RADIOv2 | 1536 * 1536    | [nvidia/PS3-1.5K-C-RADIOv2](https://huggingface.co/nvidia/PS3-1.5K-C-RADIOv2) |
+| PS3-4K-C-RADIOv2   | 3840 * 3840    | [nvidia/PS3-4K-C-RADIOv2](https://huggingface.co/nvidia/PS3-4K-C-RADIOv2)     |
+| PS3-1.5K-SigLIP2 | 1512 * 1512    | [nvidia/PS3-1.5K-SigLIP2](https://huggingface.co/nvidia/PS3-1.5K-SigLIP2) |
+| PS3-4K-SigLIP2   | 3780 * 3780    | [nvidia/PS3-4K-SigLIP2](https://huggingface.co/nvidia/PS3-4K-SigLIP2)     |
+| PS3_Lang-1.5K-SigLIP2 | 1512 * 1512    | [nvidia/PS3_Lang-1.5K-SigLIP2](https://huggingface.co/nvidia/PS3_Lang-1.5K-SigLIP2) |
+| PS3_Lang-4K-SigLIP2   | 3780 * 3780    | [nvidia/PS3_Lang-4K-SigLIP2](https://huggingface.co/nvidia/PS3_Lang-4K-SigLIP2)     |
+
+## Training Datasets: <br>   
+
+75M images <br>
+
+1 dataset that's built based on:
+- SA-1B (https://ai.meta.com/datasets/segment-anything/)
+- IDL (https://huggingface.co/datasets/pixparse/idl-wds)
+   
+Training: 100% <br> 
+
+## Training Dataset:
+
+**Link:**
+We used the following dataset during developing PS3:
+- SA-1B (https://ai.meta.com/datasets/segment-anything/)
+- IDL (https://huggingface.co/datasets/pixparse/idl-wds)
+
+**Data Collection Method by dataset:**  <br>
+Automated
+
+**Labeling Method by dataset:**  <br>
+Automated
+
+**Properties (Quantity, Dataset Descriptions, Sensor(s)):**  <br>
+75M images with resolution up to 4Kx4K.
+
+## Testing & Evaluation Datasets: 
+* None <br>
+
+
+## Performance
+
+### Performance of PS3 models 
+
+See Table 1 in the paper for full results.
+
+## Inference:
+**Acceleration Engine:** Not Applicable (N/A) <br>
+**Test Hardware:** <br>
+The model is tested on NVIDIA A100 GPU.
+
+## Installation
+
+Install through pip to use PS3 out of the box.
+```bash
+pip install ps3-torch
+```
+
+If you would like to make changes to the PS3 code, go to [PS3 repository](https://github.com/NVlabs/PS3), clone the repo, and install in editable mode.
+```bash
+cd PS3
+pip install -e .
+```
+
+## Inference - Quick Start
+
+Here we show example usage including
+- loading the model
+- selectively encoding high-res image based on image saliency (bottom-up selection) and visualizing the selection probabilities
+- selectively encoding high-res image based on text prompts (top-down selection) and visualizing the selection probabilities
+- formatting the encoded features into (masked) feature maps
+
+### 1. Load Model and Image
+```python
+from PIL import Image
+from ps3 import PS3VisionModel, PS3ImageProcessor
+
+# Load the PS3 model and processor.
+vision_model = PS3VisionModel.from_pretrained("nvidia/PS3-4K-SigLIP2")
+processor = PS3ImageProcessor.from_pretrained("nvidia/PS3-4K-SigLIP2")
+vision_model.cuda().eval()
+
+# You can replace it with your own image.
+image = Image.open("assets/test_images/dock.jpg")
+
+# Preprocess the image.
+x = processor(image)["pixel_values"][0].unsqueeze(0).cuda()
+```
+
+### 2. Encode High-Res Image with Bottom-Up Selection
+
+PS3 can select important high-res patches based on visual saliency and encode those patches.
+
+**You can encode the whole high-res image using PS3.**
+```python
+outs = vision_model(x, num_look_close="all")
+features = outs.last_hidden_state
+print(features.shape)  # (1, 88209, 1152)
+```
+Note the PS3-4K model processes the image at multiple scales: 378 (low-res), 756, 1512, and 3780, and it has a patch size of 14.
+
+Then the number of tokens at each scale is (378/14)^2 = 729, (756/14)^2 = 2916, (1512/14)^2 = 11664, and (3780/14)^2 = 72900.
+
+The output hidden state concatenates all the tokens along sequence dimension.
+That gives us 729 + 2916 + 11664 + 72900 = 88209 tokens in total.
+
+**You can encode parts of the high-res image by setting `num_look_close`, i.e., how many times to run the high-res selection and encoding.**
+```python
+outs = vision_model(x, num_look_close=2)
+features = outs.last_hidden_state
+print(features.shape)  # (1, 5849, 1152)
+```
+In this example, it only runs the high-res selection and encoding twice.
+
+Note that PS3 processes at most 2560 high-res patches at a time. Then running high-res selection and encoding twice gives us 2560 * 2 = 5120 high-res tokens. There is also 729 low-res tokens. That gives us 729 + 5120 = 5849 tokens in total.
+
+**You can also decide how many high-res tokens to process by setting `num_token_look_close`.**
+```python
+outs = vision_model(x, num_token_look_close=3000)
+features = outs.last_hidden_state
+print(features.shape)  # (1, 3729, 1152)
+```
+In this example, it only processes 3000 high-res tokens. Note that PS3 only processes 2560 high-res patches at a time. This means it needs to run the high-res selection and encoding twice, with the first time processing 2560 high-res tokens and the second time processing 440 tokens. In the end it outputs 3729 tokens (3000 high-res + 729 low-res).
+
+**Visualize the bottom-up patch selection probabilities.**
+```python
+############## Helper functions for visiualization ##############
+
+# install cv2, matplotlib, scipy for visualization purpose
+os.system("pip install opencv-python matplotlib scipy")
+from torchvision import transforms
+import numpy as np
+import os
+import cv2
+import matplotlib.pyplot as plt
+from scipy.ndimage import gaussian_filter
+
+def create_heatmap_overlay(image, heatmap, alpha=0.4, colormap=plt.cm.jet, sigma=10.0):
+    if len(image.shape) == 2:
+        image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
+
+    smoothed_heatmap = gaussian_filter(heatmap.astype(np.float32), sigma=sigma)
+    smoothed_heatmap = (smoothed_heatmap - smoothed_heatmap.min()) / \
+                      (smoothed_heatmap.max() - smoothed_heatmap.min())
+    colored_heatmap = (colormap(smoothed_heatmap) * 255).astype(np.uint8)
+    
+    if colored_heatmap.shape[-1] == 4:
+        colored_heatmap = colored_heatmap[:, :, :3]
+    
+    overlay = cv2.addWeighted(image, 1 - alpha, colored_heatmap, alpha, 0)
+    return Image.fromarray(overlay)
+
+def save_visualization(selection_probs, image, output_dir):
+    os.makedirs(output_dir, exist_ok=True)
+    resize_transform = transforms.Resize(image.size[::-1])
+    for i, prob in enumerate(selection_probs):
+        prob = (prob - prob.min()) / (prob.max() - prob.min() + 1e-6)
+        prob = resize_transform(prob)
+        prob = prob.squeeze(0).detach().cpu().numpy()
+        # overlay the selection probability map on the original image
+        overlay = create_heatmap_overlay(np.array(image), prob)
+        overlay.save(os.path.join(output_dir, f"selection_prob_scale_{i}.png"))
+    image.save(os.path.join(output_dir, f"image.png"))
+
+#################### End of helper functions ####################
+
+selection_probs = outs.selection_probs
+print([p.shape for p in selection_probs])  # [(1, 54, 54), (1, 108, 108), (1, 270, 270)]
+save_visualization(selection_probs, image, "save_path/bottom_up_selection_probs")
+```
+`selection_probs` contains the selection probability map for each scale. In this case, the feature map of each scale has shapes of 54x54, 108x108, and 270x270. The selection probability reflects how salient/important each patch is and patches with higher probability are selected first. You can visit the demo for more visualization.
+
+![Bottom-Up Selection Probabilities](assets/example_selection_maps/bottom_up_selection_prob.png)
+
+
+### 3. Encode High-Res Image with Top-Down Selection
+
+PS3 can also select important high-res patches based on any text prompt.
+
+First of all, load the text model and encode the text prompt.
+```python
+from ps3 import PS3Tokenizer, PS3TextModel
+
+tokenizer = PS3Tokenizer.from_pretrained("nvidia/PS3-4K-SigLIP2")
+text_model = PS3TextModel.from_pretrained("nvidia/PS3-4K-SigLIP2")
+text_model.cuda().eval()
+
+text = ["A tall spire with a cross at the top of the building."]
+text = tokenizer(text).cuda()
+prompt = text_model(text).prompt
+```
+
+Then PS3 can select important high-res patches based on the text prompt and encode those patches.
+```python
+outs = vision_model(x, num_look_close=2, prompt=prompt)
+features = outs.last_hidden_state
+print(features.shape)  # (1, 5849, 1152)
+```
+
+You can visualize the top-down selection probabilities. Usually the regions related to the text prompt have higher selection probabilities.
+```python
+selection_probs = outs.selection_probs
+save_visualization(selection_probs, image, "save_path/top_down_selection_probs_1")
+```
+
+![Top-Down Selection Probabilities](assets/example_selection_maps/top_down_selection_prob_1.png)
+
+You can change to another text prompt and see different selection probabilities.
+```python
+text = ["A green rope on the green and red boat."]
+text = tokenizer(text).cuda()
+prompt = text_model(text).prompt
+outs = vision_model(x, num_look_close=2, prompt=prompt)
+selection_probs = outs.selection_probs
+save_visualization(selection_probs, image, "save_path/top_down_selection_probs_2")
+```
+
+![Top-Down Selection Probabilities](assets/example_selection_maps/top_down_selection_prob_2.png)
+
+### 4. Format the Encoded Features into (Masked) Feature Maps
+
+The features returned above are the concatenation of all the low-res and high-res features.
+
+You can format the features into masked feature maps for each scale.
+```python
+feature_maps = vision_model.vision_model.format_features_into_feature_maps(outs.last_hidden_state, outs.selection_maps)
+print([x.shape for x in feature_maps])  # [(1, 1152, 27, 27), (1, 1152, 54, 54), (1, 1152, 108, 108), (1, 1152, 270, 270)]
+```
+This will create a masked feature map `feature_maps` which is a list of feature maps (B * C * H * W) for each scale and each feature map contains the actual feature for the selected patches at that scaleand zero vector for the unselected patches.
+
+
+## Inference instructions
+
+[Quick Start](#quick-start) gives some examples of how to use PS3 to encode an image. Below are more detailed explanations of the arguments of model inference.
+
+```python
+class PS3VisionModel(PS3PreTrainedModel):
+    ...
+    def forward(
+        self,
+        pixel_values, 
+        num_look_close, 
+        num_token_look_close=None, 
+        prompt=None, 
+        gt_selection_maps=None, 
+        smooth_selection_prob=False,
+        only_select_first_n_scale=None,
+        is_global_text=None, 
+        pool_gt_token_only=False, 
+    ):
+    ...
+```
+`pixel_values`: the input images with shape (B, C, H, W).
+
+`num_look_close`: how many times to run high-res selection and encoding. PS3 selects and processes 2560 patches each time. If set to `all` then it selects all the high-res patches. If set to `0` then PS3 only returns the low-res features. If set to a larger number than what it needs to encode all the high-res patches, then PS3 will clamp it to the max number needed.
+
+`num_token_look_close`: (optinoal) how many high-res patches to select and process. Similar to `num_look_close` but `num_token_look_close` directly specifies the number of high-res tokens instead of number of running high-res encoding.
+
+`prompt`: (optional) the prompt embedding used to select high-res patches. The prompt embedding can be embedding of some text, or some embedding output by an LLM (see the paper). The shape of prompt embedding is (B, C) where B is the batch size (same in `pixel_values`) and C is the embedding dimension (same as PS3 token embedding dimension). If `prompt=None`, then PS3 will select high-res patches based on visual saliency (bottom-up selection).
+
+`gt_selection_maps`: (optional) the ground truth selection maps for the image. It should be a tensor of 0/1 values with shape (B, h, w). Regions with value 1 means they should be selected. When selecting high-res patches, PS3 will interpolate the `gt_selection_maps` to the same size as the feature map at each scale, prioritize selecting the tokens where the value is 1, and if there's still budget for selecting more tokens, it will select the rest based on the original selection probability.
+
+`smooth_selection_prob`: (optional) smooth the selection probability map such that the selected patches won't be distributed too scarcely each time it runs high-res selection. It slightly improves the performance occasinoally when selecting all the patches but usually hurts when selecting parts of the patches.
+
+`only_select_first_n_scale`: (optional) only select the first n high-res scales. For example, for PS3-4K model, if `only_select_first_n_scale=2`, then it only selects and processes scales of 756 and 1512, and ignores the scale of 3780.
+
+`is_global_text`: (optional) only return the pooled low-res feautres. *It will only be used during pre-training.*
+
+`pool_gt_token_only`: (optional) only pool the tokens inside the gt selection regions. *It will only be used during pre-training.*
+
+
+### Ethical Considerations:
+NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications.  When downloaded or used in accordance with our terms of service, developers should work with their internal model team to ensure this model meets requirements for the relevant industry and use case and addresses unforeseen product misuse. Please report security vulnerabilities or NVIDIA AI Concerns [here](https://www.nvidia.com/en-us/support/submit-security-vulnerability/).
+
+
+## More Details
+Please refer to the [PS3 codebase](https://github.com/NVlabs/PS3) for more details.
+
+
+## Citation
+
+If you find this work useful in your research, please consider citing:
+
+```bibtex
+@article{shi2025scaling,
+  title={Scaling Vision Pre-Training to 4K Resolution},
+  author={Shi, Baifeng and Li, Boyi and Cai, Han and Lu, Yao and Liu, Sifei and Pavone, Marco and Kautz, Jan and Han, Song and Darrell, Trevor and Molchanov, Pavlo and others},
+  journal={arXiv preprint arXiv:2503.19903},
+  year={2025}
+}
+```

config.json

@@ -0,0 +1,67 @@
+{
+  "architectures": [
+    "PS3Model"
+  ],
+  "model_type": "ps3",
+  "vision_config": {
+    "architectures": [
+      "PS3VisionModel"
+    ],
+    "model_type": "ps3_vision_model",
+    "model_name": "vit_so400m_patch14_siglip_378",
+    "hidden_size": 1152,
+    "pool": "map",
+    "ps3_scales": [
+      378,
+      756,
+      1512
+    ],
+    "select_based_on_layer": [
+      0,
+      9,
+      18,
+      26
+    ],
+    "min_select_num": 1,
+    "max_select_num": 2560,
+    "seperate_pos_emb": true,
+    "highres_selection_feature": true,
+    "radio": false,
+    "radio_adapter_mlp_version": null,
+    "radio_adapter_mlp_input_dim": null,
+    "radio_adapter_mlp_hidden_dim": null,
+    "radio_adapter_mlp_output_dim": null,
+    "radio_adapter_mlp_num_inner": null,
+    "img_size": null,
+    "drop": 0.0,
+    "class_token": null,
+    "final_norm": false
+  },
+  "text_config": {
+    "context_length": 64,
+    "vocab_size": 256000,
+    "hf_tokenizer_name": "timm/ViT-SO400M-14-SigLIP2-378",
+    "tokenizer_kwargs": {
+      "clean": "canonicalize"
+    },
+    "width": 1152,
+    "heads": 16,
+    "layers": 27,
+    "mlp_ratio": 3.7362,
+    "no_causal_mask": true,
+    "proj_bias": true,
+    "pool_type": "last",
+    "norm_kwargs": {
+      "eps": 1e-06
+    },
+    "act_kwargs": {
+      "approximate": "tanh"
+    },
+    "architectures": [
+      "PS3TextModel"
+    ],
+    "model_type": "ps3_text_model",
+    "output_dim": 1152,
+    "prompt_proj_dim": 1152
+  }
+}

model.safetensors

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

preprocessor_config.json

@@ -0,0 +1,18 @@
+{
+  "image_size": [
+    1512,
+    1512
+  ],
+  "mean": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "std": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "interpolation": "bicubic",
+  "resize_mode": "squash"
+}

tokenizer_config.json

@@ -0,0 +1,5 @@
+{
+  "tokenizer_name": "timm/ViT-SO400M-14-SigLIP2-378",
+  "context_length": 64,
+  "clean": "canonicalize"
+}