Upload folder using huggingface_hub

README.md

@@ -0,0 +1,234 @@
+---
+license: apache-2.0
+base_model: facebook/sam2.1-hiera-tiny
+tags:
+  - robotics
+  - edge-deployment
+  - anima
+  - forge
+  - int8
+  - quantized
+  - sam2
+  - segmentation
+  - image-segmentation
+  - video-segmentation
+  - ros2
+  - jetson
+  - real-time
+  - vision
+library_name: transformers
+pipeline_tag: image-segmentation
+model-index:
+  - name: sam2.1-hiera-tiny-int8
+    results:
+      - task:
+          type: image-segmentation
+        metrics:
+          - name: Model Size (MB)
+            type: model_size
+            value: 152
+          - name: Compression Ratio
+            type: compression
+            value: 2.0
+          - name: Original Size (MB)
+            type: original_size
+            value: 298
+---
+
+# SAM 2.1 Hiera-Tiny — INT8 Quantized
+
+> Meta's Segment Anything Model 2.1 (Hiera-Tiny backbone) quantized to INT8 for real-time robotic segmentation. **2.0x smaller** — from 298 MB to 152 MB — the smallest SAM2 variant for maximum speed on edge hardware.
+
+This model is part of the **[RobotFlowLabs](https://huggingface.co/robotflowlabs)** model library, built for the **ANIMA** agentic robotics platform — a modular ROS2-native AI system that brings foundation model intelligence to real robots operating in the real world.
+
+## Why This Model Exists
+
+When every millisecond counts — grasping a moving object, dodging an obstacle, responding to a human — you need the fastest possible segmentation. SAM2 Hiera-Tiny is the lightest SAM2 backbone, and at 152 MB after INT8 quantization, it fits comfortably alongside multiple other perception models on devices like Jetson Nano or Orin NX.
+
+## Model Details
+
+| Property | Value |
+|----------|-------|
+| **Architecture** | Hiera-Tiny vision backbone + SAM2 decoder |
+| **Input Resolution** | 1024 × 1024 |
+| **Capabilities** | Image segmentation, video object tracking |
+| **Backbone Stages** | 4 stages: [1, 2, 7, 2] blocks (12 total) |
+| **Embed Dims** | [96, 192, 384, 768] per stage |
+| **Attention Heads** | [1, 2, 4, 8] per stage |
+| **Global Attention** | Blocks 5, 7, 9 |
+| **Mask Decoder** | 256-dim hidden, 8 attention heads, 3 multi-mask outputs |
+| **Memory Attention** | 4 layers, 2048-dim FFN, RoPE positional encoding |
+| **Memory Bank** | 7 frames temporal context |
+| **Original Model** | [`facebook/sam2.1-hiera-tiny`](https://huggingface.co/facebook/sam2.1-hiera-tiny) |
+| **License** | Apache-2.0 |
+
+## Compression Results
+
+Quantized on an NVIDIA L4 24GB GPU using INT8 dynamic quantization with SafeTensors export.
+
+| Metric | Original | INT8 Quantized | Change |
+|--------|----------|----------------|--------|
+| **Total Size** | 298 MB | 152 MB | **2.0x smaller** |
+| **INT8 Weights** | — | 32 MB | Quantized linear layers |
+| **SafeTensors** | — | 120 MB | Full model weights |
+| **Quantization** | FP32 | INT8 Dynamic | Per-tensor symmetric |
+| **Format** | PyTorch | SafeTensors + INT8 .pt | Dual format |
+
+> **Why SafeTensors instead of ONNX?** SAM2 uses custom CUDA operations (roi_align, deformable attention) that aren't supported by the ONNX standard. SafeTensors provides fast, safe loading directly into PyTorch with zero-copy memory mapping.
+
+## Included Files
+
+```
+sam2.1-hiera-tiny-int8/
+├── model_int8.pt              # 32 MB — INT8 quantized state dict
+├── model.safetensors          # 120 MB — Full model in SafeTensors format
+├── config.json                # Model configuration
+├── preprocessor_config.json   # Image preprocessing config
+└── README.md                  # This file
+```
+
+## Quick Start
+
+### PyTorch (SafeTensors)
+
+```python
+from transformers import Sam2Model, Sam2Processor
+import torch
+
+# Load with SafeTensors (automatic)
+model = Sam2Model.from_pretrained("robotflowlabs/sam2.1-hiera-tiny-int8")
+processor = Sam2Processor.from_pretrained("facebook/sam2.1-hiera-tiny")
+
+model.to("cuda").eval()
+
+# Segment with point prompt
+inputs = processor(
+    images=image,
+    input_points=[[[500, 375]]],  # (x, y) point prompt
+    return_tensors="pt"
+).to("cuda")
+
+with torch.no_grad():
+    outputs = model(**inputs)
+
+masks = processor.post_process_masks(
+    outputs.pred_masks,
+    inputs["original_sizes"],
+    inputs["reshaped_input_sizes"]
+)
+```
+
+### INT8 Weights (Maximum Compression)
+
+```python
+import torch
+from transformers import Sam2Model
+
+# Load architecture, then apply INT8 weights
+model = Sam2Model.from_pretrained("facebook/sam2.1-hiera-tiny")
+int8_state = torch.load("model_int8.pt", map_location="cuda", weights_only=True)
+model.load_state_dict(int8_state, strict=False)
+```
+
+### With FORGE (ANIMA Integration)
+
+```python
+from forge.vision import VisionEncoderRegistry
+
+# FORGE handles optimal loading and batching
+segmenter = VisionEncoderRegistry.load("sam2.1-hiera-tiny-int8")
+masks = segmenter.segment(image, points=[[500, 375]])
+```
+
+## Use Cases in ANIMA
+
+SAM2-Tiny is optimized for **latency-critical deployments**:
+
+- **Real-Time Grasping** — Fastest segmentation for time-critical manipulation
+- **Mobile Robots** — Lightweight enough for Jetson Nano-class devices
+- **Multi-Model Stacking** — Leaves maximum VRAM for other perception models
+- **Video Tracking** — Track objects across frames with 7-frame temporal memory
+- **High-Frequency Control** — Segmentation at camera framerate for reactive behavior
+
+## SAM2 Model Family
+
+We provide all three SAM2.1 variants, optimized for different deployment scenarios:
+
+| Model | Size | Speed | Best For |
+|-------|------|-------|----------|
+| [sam2.1-hiera-large-int8](https://huggingface.co/robotflowlabs/sam2.1-hiera-large-int8) | 1.0 GB | Highest quality | Research, high-accuracy tasks |
+| [sam2.1-hiera-small-int8](https://huggingface.co/robotflowlabs/sam2.1-hiera-small-int8) | 186 MB | Balanced | Production robotics |
+| **[sam2.1-hiera-tiny-int8](https://huggingface.co/robotflowlabs/sam2.1-hiera-tiny-int8)** | **152 MB** | **Fastest** | **Real-time edge, Jetson Nano** |
+
+## Intended Use
+
+### Designed For
+- Lowest-latency segmentation in robotic control loops
+- Edge devices with limited VRAM (Jetson Nano, Orin NX)
+- Multi-model inference stacks where VRAM is shared
+- Real-time video object tracking
+
+### Limitations
+- Smaller backbone means lower accuracy on complex scenes vs Large/Small variants
+- INT8 quantization may slightly reduce mask boundary precision
+- Requires a prompt (point, box, or mask) — not a panoptic segmenter
+- Inherits biases from SA-V dataset
+
+### Out of Scope
+- Medical image segmentation without domain-specific validation
+- Autonomous driving perception
+- Surveillance or tracking of individuals
+
+## Technical Details
+
+### Compression Pipeline
+
+```
+Original SAM2.1 Hiera-Tiny (FP32, 298 MB)
+    │
+    ├─→ torchao INT8 dynamic quantization (GPU-native)
+    │   └─→ model_int8.pt (32 MB)
+    │
+    └─→ SafeTensors export (roi_align not ONNX-compatible)
+        └─→ model.safetensors (120 MB)
+```
+
+- **Quantization**: INT8 dynamic activation + INT8 weight via `torchao` on NVIDIA L4 GPU
+- **Export**: SafeTensors format — zero-copy memory mapping, fast loading
+- **Why not ONNX**: SAM2's roi_align and deformable attention are custom CUDA ops
+- **Hardware**: NVIDIA L4 24GB, CUDA 13.0, PyTorch 2.10, Python 3.14
+
+## Attribution
+
+- **Original Model**: [`facebook/sam2.1-hiera-tiny`](https://huggingface.co/facebook/sam2.1-hiera-tiny) by Meta AI (FAIR)
+- **License**: [Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0) — free for commercial and research use
+- **Paper**: [SAM 2: Segment Anything in Images and Videos](https://arxiv.org/abs/2408.00714) — Ravi et al., 2024
+- **Dataset**: SA-V — 50.9K videos, 642.6K masklets
+- **Compressed by**: [RobotFlowLabs](https://huggingface.co/robotflowlabs) using [FORGE](https://github.com/robotflowlabs/forge)
+
+## Citation
+
+```bibtex
+@article{ravi2024sam2,
+  title={SAM 2: Segment Anything in Images and Videos},
+  author={Ravi, Nikhila and Gabeur, Valentin and Hu, Yuan-Ting and Hu, Ronghang and Ryali, Chaitanya and Ma, Tengyu and Khedr, Haitham and R{\"a}dle, Roman and Rolber, Chloe and Gustafson, Laura and others},
+  journal={arXiv preprint arXiv:2408.00714},
+  year={2024}
+}
+```
+
+```bibtex
+@misc{robotflowlabs2026anima,
+  title={ANIMA: Agentic Networked Intelligence for Modular Autonomy},
+  author={RobotFlowLabs},
+  year={2026},
+  url={https://huggingface.co/robotflowlabs}
+}
+```
+
+---
+
+<p align="center">
+  <b>Built with FORGE by <a href="https://huggingface.co/robotflowlabs">RobotFlowLabs</a></b><br>
+  Optimizing foundation models for real robots.
+</p>

config.json

@@ -0,0 +1,233 @@
+{
+  "architectures": [
+    "Sam2VideoModel"
+  ],
+  "enable_occlusion_spatial_embedding": true,
+  "enable_temporal_pos_encoding_for_object_pointers": true,
+  "image_size": 1024,
+  "initializer_range": 0.02,
+  "mask_decoder_config": {
+    "attention_downsample_rate": 2,
+    "dynamic_multimask_stability_delta": 0.05,
+    "dynamic_multimask_stability_thresh": 0.98,
+    "dynamic_multimask_via_stability": true,
+    "hidden_act": "gelu",
+    "hidden_size": 256,
+    "iou_head_depth": 3,
+    "iou_head_hidden_dim": 256,
+    "mlp_dim": 2048,
+    "model_type": "",
+    "num_attention_heads": 8,
+    "num_hidden_layers": 2,
+    "num_multimask_outputs": 3
+  },
+  "mask_downsampler_embed_dim": 256,
+  "mask_downsampler_hidden_act": "gelu",
+  "mask_downsampler_kernel_size": 3,
+  "mask_downsampler_padding": 1,
+  "mask_downsampler_stride": 2,
+  "mask_downsampler_total_stride": 16,
+  "max_object_pointers_in_encoder": 16,
+  "memory_attention_downsample_rate": 1,
+  "memory_attention_dropout": 0.1,
+  "memory_attention_feed_forward_hidden_act": "relu",
+  "memory_attention_feed_forward_hidden_size": 2048,
+  "memory_attention_hidden_size": 256,
+  "memory_attention_num_attention_heads": 1,
+  "memory_attention_num_layers": 4,
+  "memory_attention_rope_dropout": 0.1,
+  "memory_attention_rope_feat_sizes": [
+    64,
+    64
+  ],
+  "memory_attention_rope_theta": 10000,
+  "memory_encoder_hidden_size": 256,
+  "memory_encoder_output_channels": 64,
+  "memory_fuser_embed_dim": 256,
+  "memory_fuser_hidden_act": "gelu",
+  "memory_fuser_intermediate_dim": 1024,
+  "memory_fuser_kernel_size": 7,
+  "memory_fuser_layer_scale_init_value": 1e-06,
+  "memory_fuser_num_layers": 2,
+  "memory_fuser_padding": 3,
+  "model_type": "sam2_video",
+  "multimask_max_pt_num": 1,
+  "multimask_min_pt_num": 0,
+  "multimask_output_for_tracking": true,
+  "multimask_output_in_sam": true,
+  "num_maskmem": 7,
+  "prompt_encoder_config": {
+    "hidden_act": "gelu",
+    "hidden_size": 256,
+    "image_size": 1024,
+    "layer_norm_eps": 1e-06,
+    "mask_input_channels": 16,
+    "model_type": "",
+    "num_point_embeddings": 4,
+    "patch_size": 16,
+    "scale": 1
+  },
+  "sigmoid_bias_for_mem_enc": -10.0,
+  "sigmoid_scale_for_mem_enc": 20.0,
+  "torch_dtype": "float32",
+  "transformers_version": "4.56.0.dev0",
+  "vision_config": {
+    "backbone_channel_list": [
+      768,
+      384,
+      192,
+      96
+    ],
+    "backbone_config": {
+      "_name_or_path": "",
+      "add_cross_attention": false,
+      "architectures": null,
+      "bad_words_ids": null,
+      "begin_suppress_tokens": null,
+      "blocks_per_stage": [
+        1,
+        2,
+        7,
+        2
+      ],
+      "bos_token_id": null,
+      "chunk_size_feed_forward": 0,
+      "cross_attention_hidden_size": null,
+      "decoder_start_token_id": null,
+      "diversity_penalty": 0.0,
+      "do_sample": false,
+      "early_stopping": false,
+      "embed_dim_per_stage": [
+        96,
+        192,
+        384,
+        768
+      ],
+      "encoder_no_repeat_ngram_size": 0,
+      "eos_token_id": null,
+      "exponential_decay_length_penalty": null,
+      "finetuning_task": null,
+      "forced_bos_token_id": null,
+      "forced_eos_token_id": null,
+      "global_attention_blocks": [
+        5,
+        7,
+        9
+      ],
+      "hidden_act": "gelu",
+      "hidden_size": 96,
+      "id2label": {
+        "0": "LABEL_0",
+        "1": "LABEL_1"
+      },
+      "image_size": [
+        1024,
+        1024
+      ],
+      "initializer_range": 0.02,
+      "is_decoder": false,
+      "is_encoder_decoder": false,
+      "label2id": {
+        "LABEL_0": 0,
+        "LABEL_1": 1
+      },
+      "layer_norm_eps": 1e-06,
+      "length_penalty": 1.0,
+      "max_length": 20,
+      "min_length": 0,
+      "mlp_ratio": 4.0,
+      "model_type": "sam2_hiera_det_model",
+      "no_repeat_ngram_size": 0,
+      "num_attention_heads": 1,
+      "num_attention_heads_per_stage": [
+        1,
+        2,
+        4,
+        8
+      ],
+      "num_beam_groups": 1,
+      "num_beams": 1,
+      "num_channels": 3,
+      "num_query_pool_stages": 3,
+      "num_return_sequences": 1,
+      "output_attentions": false,
+      "output_hidden_states": false,
+      "output_scores": false,
+      "pad_token_id": null,
+      "patch_kernel_size": [
+        7,
+        7
+      ],
+      "patch_padding": [
+        3,
+        3
+      ],
+      "patch_stride": [
+        4,
+        4
+      ],
+      "prefix": null,
+      "problem_type": null,
+      "pruned_heads": {},
+      "query_stride": [
+        2,
+        2
+      ],
+      "remove_invalid_values": false,
+      "repetition_penalty": 1.0,
+      "return_dict": true,
+      "return_dict_in_generate": false,
+      "sep_token_id": null,
+      "suppress_tokens": null,
+      "task_specific_params": null,
+      "temperature": 1.0,
+      "tf_legacy_loss": false,
+      "tie_encoder_decoder": false,
+      "tie_word_embeddings": true,
+      "tokenizer_class": null,
+      "top_k": 50,
+      "top_p": 1.0,
+      "torch_dtype": null,
+      "torchscript": false,
+      "typical_p": 1.0,
+      "use_bfloat16": false,
+      "window_positional_embedding_background_size": [
+        7,
+        7
+      ],
+      "window_size_per_stage": [
+        8,
+        4,
+        14,
+        7
+      ]
+    },
+    "backbone_feature_sizes": [
+      [
+        256,
+        256
+      ],
+      [
+        128,
+        128
+      ],
+      [
+        64,
+        64
+      ]
+    ],
+    "fpn_hidden_size": 256,
+    "fpn_kernel_size": 1,
+    "fpn_padding": 0,
+    "fpn_stride": 1,
+    "fpn_top_down_levels": [
+      2,
+      3
+    ],
+    "hidden_act": "gelu",
+    "initializer_range": 0.02,
+    "layer_norm_eps": 1e-06,
+    "model_type": "sam2_vision_model",
+    "num_feature_levels": 3
+  }
+}

model.safetensors

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

model_int8.pt

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

preprocessor_config.json

@@ -0,0 +1,36 @@
+{
+  "crop_size": null,
+  "data_format": "channels_first",
+  "default_to_square": true,
+  "device": null,
+  "disable_grouping": null,
+  "do_center_crop": null,
+  "do_convert_rgb": true,
+  "do_normalize": true,
+  "do_rescale": true,
+  "do_resize": true,
+  "image_mean": [
+    0.485,
+    0.456,
+    0.406
+  ],
+  "image_processor_type": "Sam2ImageProcessorFast",
+  "image_std": [
+    0.229,
+    0.224,
+    0.225
+  ],
+  "input_data_format": null,
+  "mask_size": {
+    "height": 256,
+    "width": 256
+  },
+  "processor_class": "Sam2VideoProcessor",
+  "resample": 2,
+  "rescale_factor": 0.00392156862745098,
+  "return_tensors": null,
+  "size": {
+    "height": 1024,
+    "width": 1024
+  }
+}