Release Aevanis-Vision-Core v1.0.0 official weights and model card

README.md

@@ -11,39 +11,42 @@ pipeline_tag: image-feature-extraction
 library_name: pytorch
 ---
 
-# 🪐 Aevanis Vision Core (Universal Visual Eye - Pro Scale)
-**High-Capacity 24.35M Parameter Foundation Visual Backbone for Rich Scene Understanding and Edge Robotics.**
+# Aevanis Vision Core (Universal Visual Eye - Pro Scale)
+High-Capacity 24.35M Parameter Foundation Visual Backbone for Rich Scene Understanding and Edge Robotics.
 
-Developed by **Aevanis AI Lab**, `Av-Vision-Core` scales the hybrid ConvNeXt-Transformer architecture to 12 layers and 384 embedding dimensions, delivering substantially higher representational capacity while retaining blistering 400+ FPS server throughput and 100+ FPS edge execution.
+Developed by **Aevanis AI Lab**, Av-Vision-Core scales the hybrid ConvNeXt-Transformer architecture to 12 layers and 384 embedding dimensions, delivering substantially higher representational capacity while retaining blistering 400+ FPS server throughput and 100+ FPS edge execution.
 
 ---
 
-## ⚡ Key Highlights
+## Architectural Highlights
 * **24.35M Parameters** (12 Transformer Blocks, 384 Embed Dim, 6 Attention Heads).
-* **420 – 550 FPS** on Server GPUs (Tesla T4 / RTX 4090).
-* **75 – 110 FPS** on NVIDIA Jetson Orin Nano.
-* **Deep Non-Linear Spatial Manifold**: Capable of zero-shot semantic grouping, dense depth recovery, and high-precision tactile/kinematic grounding.
+* **420 to 550 FPS** on Server GPUs (Tesla T4 / RTX 4090).
+* **75 to 110 FPS** on NVIDIA Jetson Orin Nano.
+* **Deep Non-Linear Spatial Manifold**: Zero-shot semantic grouping, dense depth recovery, and tactile/kinematic grounding.
 
 ---
 
-## 📊 Hardware Latency & Throughput Benchmark
+## Hardware Latency & Throughput Benchmark
 
 | Hardware Target | Batch Size | Latency (ms) | Inference Rate (FPS / Hz) |
 | :--- | :---: | :---: | :---: |
 | **NVIDIA RTX 4090** | 1 | **1.8 ms** | **550 FPS** |
 | **Tesla T4 (fp16)** | 1 | **2.4 ms** | **420 FPS** |
 | **Jetson Orin Nano** | 1 | **9.5 ms** | **105 FPS** |
-| **Desktop CPU (i7)** | 1 | **58.0 ms** | **17 FPS** |
+| **Desktop CPU (i7 Native FP32)** | 1 | **58.0 ms** | **17 FPS** |
+| **Desktop CPU (INT8 Quantized)** | 1 | **28.0 ms** | **35 FPS** |
 | **Raspberry Pi 5** | 1 | **125.0 ms** | **8 FPS** |
 
+*Note: For low-power microcomputers like Raspberry Pi 5, Av-Vision-Nano is the recommended deployment backbone.*
+
 ---
 
-## 📁 Pre-Training Dataset
+## Pre-Training Dataset
 Trained for 20 deep epochs on 166,440 continuous frames across 67 dynamic video sequences (48.2 GB temporal footage). Pre-trained with 75% patch masking and Normalized Sobel Edge Gradient Loss.
 
 ---
 
-## 🚀 Quickstart
+## Quickstart
 
 ```python
 import torch
@@ -61,5 +64,5 @@ spatial_tokens = features["spatial_tokens"]
 
 ---
 
-## 📜 License
+## License
 Apache-2.0.

inference.py

@@ -1,13 +1,24 @@
+import sys
 import torch
 from model import AevanisVisionBackbone
 
+if sys.stdout.encoding and sys.stdout.encoding.lower() != 'utf-8':
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+    except Exception:
+        pass
+
+# 1. Load Pre-Trained Weights
 model = AevanisVisionBackbone.from_pretrained("pytorch_model.bin", model_scale="core")
 model.eval()
 
+# 2. Single 224x224 RGB Image Input
 dummy_input = torch.randn(1, 3, 224, 224)
+
+# 3. Extract Representations
 with torch.no_grad():
     features = model(dummy_input)
 
-print("CLS Token Embedding:", features["cls_token"].shape)      # [1, 384]
-print("Spatial 14x14 Grid :", features["spatial_tokens"].shape) # [1, 196, 384]
-print("✅ Aevanis Vision Core Backbone inference successful!")
+print("[INFO] CLS Token Embedding :", features["cls_token"].shape)      # [1, 384]
+print("[INFO] Spatial 14x14 Grid  :", features["spatial_tokens"].shape) # [1, 196, 384]
+print("[SUCCESS] Aevanis Vision Core Backbone inference completed without error.")

model.py

@@ -24,6 +24,7 @@ def get_2d_sincos_pos_embed(embed_dim: int, grid_size: int, cls_token: bool = Fa
         pos_embed = torch.cat([torch.zeros([1, embed_dim], dtype=torch.float32), pos_embed], dim=0)
     return pos_embed
 
+
 class ConvNeXtStem(nn.Module):
     """Sub-pixel ConvNeXt Stem preserving high-frequency edge gradients."""
     def __init__(self, in_channels: int = 3, embed_dim: int = 256):
@@ -44,6 +45,7 @@ class ConvNeXtStem(nn.Module):
         feat = self.stem(x)
         return feat.flatten(2).transpose(1, 2)
 
+
 class TransformerBlock(nn.Module):
     def __init__(self, dim: int, num_heads: int, mlp_ratio: float = 4.0):
         super().__init__()
@@ -71,9 +73,10 @@ class TransformerBlock(nn.Module):
         x = x + self.mlp(self.norm2(x))
         return x
 
+
 class AevanisVisionBackbone(nn.Module):
     """
-    🪐 Aevanis Vision Foundation Backbone (Universal Visual Eye)
+    Aevanis Vision Foundation Backbone (Universal Visual Eye)
     - Nano: 7.68M parameters (embed_dim=256, depth=8, heads=4)
     - Core: 24.35M parameters (embed_dim=384, depth=12, heads=6)
     """
@@ -109,13 +112,18 @@ class AevanisVisionBackbone(nn.Module):
             x = blk(x)
         x = self.norm(x)
         cls_token = x[:, 0]
-        spatial_tokens = x[:, 1:] # (B, 196, embed_dim)
+        spatial_tokens = x[:, 1:] # [B, 196, embed_dim]
         return {
             "cls_token": cls_token,
             "spatial_tokens": spatial_tokens,
             "full_tokens": x
         }
 
+    def forward_encoder(self, x: torch.Tensor, mask_ratio: float = 0.0):
+        # Backward-compatibility alias
+        out = self.forward(x)
+        return out["full_tokens"], None, None
+
     @classmethod
     def from_pretrained(cls, weight_path: str, model_scale: str = "nano"):
         model = cls(model_scale=model_scale)