Upload SARMAE ViT-L transformers-format pretrain checkpoint

vit-large-patch16-pretrain/README.md

@@ -0,0 +1,128 @@
+---
+license: cc-by-nc-4.0
+language: en
+tags:
+  - vision
+  - image-feature-extraction
+  - sar
+  - remote-sensing
+  - synthetic-aperture-radar
+  - masked-autoencoder
+  - transformers
+library_name: transformers
+pipeline_tag: image-feature-extraction
+datasets:
+  - Wenquandan777/SAR-1M
+arxiv: 2512.16635
+base_model: Wenquandan777/SARMAE
+model-index:
+  - name: sarmae-vit-large-patch16-pretrain
+    results: []
+---
+
+# sarmae-vit-large-patch16-pretrain
+
+SARMAE (ViT-L, patch 16) encoder checkpoint converted to native Hugging Face Transformers format.
+
+SARMAE is a Noise-Aware Masked Autoencoder for self-supervised SAR representation learning, pretrained on [SAR-1M](https://huggingface.co/datasets/Wenquandan777/SAR-1M) with Speckle-Aware Representation Enhancement (SARE) and Semantic Anchor Representation Constraint (SARC).
+
+- **Paper:** [2512.16635](https://arxiv.org/abs/2512.16635)
+- **Legacy weights:** [Wenquandan777/SARMAE](https://huggingface.co/Wenquandan777/SARMAE)
+- **Stage:** `pretrain`
+- **Input:** 3 x 224 x 224 (single-channel SAR is repeated to 3 channels)
+- **Architecture:** 24 layers, hidden size 1024, 16 heads
+
+## Model specifications
+
+| Property | Value |
+|----------|-------|
+| Model type | `sarmae` |
+| Backbone | ViT-L |
+| Patch size | 16 |
+| Image size | 224 |
+| Hidden size | 1024 |
+| Layers | 24 |
+| Attention heads | 16 |
+| Global pooling | `True` |
+| Normalization mean | `[0.485, 0.456, 0.406]` |
+| Normalization std | `[0.229, 0.224, 0.225]` |
+
+## Intended use
+
+- SAR image feature extraction for downstream classification, detection, and segmentation
+- Initializing OpenMMLab backbones (`mmrotate`, `mmseg`) after weight porting
+- Research and non-commercial use under [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/)
+
+## Quick start
+
+Install dependencies:
+
+```bash
+pip install transformers timm torch torchvision safetensors
+```
+
+### Feature extraction with `transformers.pipeline`
+
+```python
+from transformers import pipeline
+
+pipe = pipeline(
+    task="image-feature-extraction",
+    model="BiliSakura/SARMAE-transformers", subfolder="vit-large-patch16-pretrain",
+    trust_remote_code=True,
+)
+features = pipe(sar_image, pool=True, return_tensors=True)
+print(features.shape)
+```
+
+### Direct model loading
+
+```python
+from transformers import AutoModel, AutoImageProcessor
+
+model = AutoModel.from_pretrained("BiliSakura/SARMAE-transformers", subfolder="vit-large-patch16-pretrain", trust_remote_code=True)
+processor = AutoImageProcessor.from_pretrained("BiliSakura/SARMAE-transformers", subfolder="vit-large-patch16-pretrain", trust_remote_code=True)
+
+inputs = processor(images=sar_image, return_tensors="pt")
+outputs = model(**inputs)
+pooled_features = outputs.pooler_output
+```
+
+### Local checkout
+
+```python
+pipe = pipeline(
+    task="image-feature-extraction",
+    model="./sarmae-vit-large-patch16-pretrain",
+    trust_remote_code=True,
+)
+```
+
+## Preprocessing
+
+- Resize to 224x224
+- Scale pixel values to `[0, 1]` (`rescale_factor=1/255`)
+- Repeat grayscale SAR to 3 channels when `repeat_grayscale_channels=true`
+- Normalize with ImageNet mean/std (same as SARMAE fine-tuning code)
+
+## Training data
+
+Pretrained on **SAR-1M**, a million-scale SAR dataset with paired optical anchors for a subset of samples.
+
+## Citation
+
+```bibtex
+@misc{liu2025sarmaemaskedautoencodersar,
+  title={SARMAE: Masked Autoencoder for SAR Representation Learning},
+  author={Danxu Liu and Di Wang and Hebaixu Wang and Haoyang Chen and Wentao Jiang and Yilin Cheng and Haonan Guo and Wei Cui and Jing Zhang},
+  year={2025},
+  eprint={2512.16635},
+  archivePrefix={arXiv},
+  primaryClass={cs.CV},
+  url={https://arxiv.org/abs/2512.16635},
+}
+```
+
+## License
+
+This model is released under [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/).

vit-large-patch16-pretrain/config.json

@@ -0,0 +1,50 @@
+{
+  "architectures": [
+    "SarmaeModel"
+  ],
+  "attention_probs_dropout_prob": 0.0,
+  "checkpoint_stage": "pretrain",
+  "dtype": "float32",
+  "global_pool": true,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.0,
+  "hidden_size": 1024,
+  "id2label": {},
+  "image_mean": [
+    0.485,
+    0.456,
+    0.406
+  ],
+  "image_size": 224,
+  "image_std": [
+    0.229,
+    0.224,
+    0.225
+  ],
+  "initializer_range": 0.02,
+  "intermediate_size": 4096,
+  "label2id": {},
+  "layer_norm_eps": 1e-06,
+  "mlp_ratio": 4.0,
+  "model_type": "sarmae",
+  "num_attention_heads": 16,
+  "num_channels": 3,
+  "num_hidden_layers": 24,
+  "patch_size": 16,
+  "qkv_bias": true,
+  "repeat_grayscale_channels": true,
+  "transformers_version": "5.0.0",
+  "auto_map": {
+    "AutoConfig": "modeling_sarmae.SarmaeConfig",
+    "AutoModel": "modeling_sarmae.SarmaeModel",
+    "AutoModelForImageClassification": "modeling_sarmae.SarmaeForImageClassification"
+  },
+  "custom_pipelines": {
+    "sarmae-feature-extraction": {
+      "impl": "pipeline_sarmae.SarmaeImageFeatureExtractionPipeline",
+      "pt": [
+        "AutoModel"
+      ]
+    }
+  }
+}

vit-large-patch16-pretrain/image_processing_sarmae.py

@@ -0,0 +1,164 @@
+# Copyright 2026 SARMAE Authors and The HuggingFace Inc. team.
+"""Image processor for SARMAE models (self-contained for trust_remote_code)."""
+
+from typing import Optional, Union
+
+import numpy as np
+
+from transformers.image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
+from transformers.image_transforms import resize, to_channel_dimension_format
+from transformers.image_utils import (
+    ChannelDimension,
+    ImageInput,
+    PILImageResampling,
+    infer_channel_dimension_format,
+    to_numpy_array,
+    valid_images,
+    validate_preprocess_arguments,
+)
+from transformers.utils import TensorType, filter_out_non_signature_kwargs, logging
+
+
+logger = logging.get_logger(__name__)
+
+
+def _repeat_grayscale_channels(image: np.ndarray, target_channels: int, input_data_format: ChannelDimension) -> np.ndarray:
+    if input_data_format == ChannelDimension.FIRST:
+        num_channels = image.shape[0]
+        if num_channels == target_channels:
+            return image
+        if num_channels == 1:
+            return np.repeat(image, target_channels, axis=0)
+        return image[:target_channels]
+    num_channels = image.shape[-1]
+    if num_channels == target_channels:
+        return image
+    if num_channels == 1:
+        return np.repeat(image, target_channels, axis=-1)
+    return image[..., :target_channels]
+
+
+def _prepare_image_batch(images: ImageInput) -> list:
+    if isinstance(images, np.ndarray):
+        images = [images]
+    elif not isinstance(images, (list, tuple)):
+        images = [images]
+
+    prepared = []
+    for image in images:
+        array = to_numpy_array(image)
+        if array.ndim == 2:
+            array = np.expand_dims(array, axis=-1)
+        prepared.append(array)
+    return prepared
+
+
+class SarmaeImageProcessor(BaseImageProcessor):
+    model_input_names = ["pixel_values"]
+
+    def __init__(
+        self,
+        do_resize: bool = True,
+        size: Optional[dict[str, int]] = None,
+        resample: PILImageResampling = PILImageResampling.BILINEAR,
+        do_rescale: bool = True,
+        rescale_factor: float = 1 / 255.0,
+        do_normalize: bool = True,
+        image_mean: Optional[Union[float, list[float]]] = None,
+        image_std: Optional[Union[float, list[float]]] = None,
+        do_convert_rgb: bool = False,
+        repeat_grayscale_channels: bool = True,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        size = size if size is not None else {"height": 224, "width": 224}
+        self.do_resize = do_resize
+        self.size = size
+        self.resample = resample
+        self.do_rescale = do_rescale
+        self.rescale_factor = rescale_factor
+        self.do_normalize = do_normalize
+        self.image_mean = image_mean
+        self.image_std = image_std
+        self.do_convert_rgb = do_convert_rgb
+        self.repeat_grayscale_channels = repeat_grayscale_channels
+
+    @filter_out_non_signature_kwargs()
+    def preprocess(
+        self,
+        images: ImageInput,
+        do_resize: Optional[bool] = None,
+        size: Optional[dict[str, int]] = None,
+        resample: Optional[PILImageResampling] = None,
+        do_rescale: Optional[bool] = None,
+        rescale_factor: Optional[float] = None,
+        do_normalize: Optional[bool] = None,
+        image_mean: Optional[Union[float, list[float]]] = None,
+        image_std: Optional[Union[float, list[float]]] = None,
+        return_tensors: Optional[Union[str, TensorType]] = None,
+        data_format: Union[str, ChannelDimension] = ChannelDimension.FIRST,
+        input_data_format: Optional[Union[str, ChannelDimension]] = None,
+        do_convert_rgb: Optional[bool] = None,
+        repeat_grayscale_channels: Optional[bool] = None,
+    ):
+        do_resize = do_resize if do_resize is not None else self.do_resize
+        size = get_size_dict(size if size is not None else self.size, default_to_square=True)
+        resample = resample if resample is not None else self.resample
+        do_rescale = do_rescale if do_rescale is not None else self.do_rescale
+        rescale_factor = rescale_factor if rescale_factor is not None else self.rescale_factor
+        do_normalize = do_normalize if do_normalize is not None else self.do_normalize
+        image_mean = image_mean if image_mean is not None else self.image_mean
+        image_std = image_std if image_std is not None else self.image_std
+        do_convert_rgb = do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb
+        repeat_grayscale_channels = (
+            repeat_grayscale_channels if repeat_grayscale_channels is not None else self.repeat_grayscale_channels
+        )
+
+        if do_normalize and (image_mean is None or image_std is None):
+            raise ValueError("Normalization requires `image_mean` and `image_std` with one value per channel.")
+
+        images = _prepare_image_batch(images)
+        if not valid_images(images):
+            raise ValueError("Invalid image type. Must be PIL, numpy, or torch tensor.")
+
+        validate_preprocess_arguments(
+            do_rescale=do_rescale,
+            rescale_factor=rescale_factor,
+            do_normalize=do_normalize,
+            image_mean=image_mean,
+            image_std=image_std,
+            do_resize=do_resize,
+            size=size,
+            resample=resample,
+        )
+
+        processed_images = []
+        for image in images:
+            image = to_numpy_array(image)
+            if do_convert_rgb:
+                image = self._convert_image_to_rgb(image)
+            if input_data_format is None:
+                try:
+                    input_data_format = infer_channel_dimension_format(image)
+                except ValueError:
+                    input_data_format = ChannelDimension.LAST
+            if repeat_grayscale_channels:
+                image = _repeat_grayscale_channels(image, target_channels=3, input_data_format=input_data_format)
+            if do_resize:
+                image = resize(
+                    image,
+                    size=(size["height"], size["width"]),
+                    resample=resample,
+                    input_data_format=input_data_format,
+                )
+            if do_rescale:
+                image = image * rescale_factor
+            if do_normalize:
+                image = self.normalize(image=image, mean=image_mean, std=image_std, input_data_format=input_data_format)
+            image = to_channel_dimension_format(image, data_format, input_channel_dim=input_data_format)
+            processed_images.append(image)
+
+        return BatchFeature(data={"pixel_values": processed_images}, tensor_type=return_tensors)
+
+
+__all__ = ["SarmaeImageProcessor"]

vit-large-patch16-pretrain/model.safetensors

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

vit-large-patch16-pretrain/modeling_sarmae.py

@@ -0,0 +1,200 @@
+# Copyright 2026 SARMAE Authors and The HuggingFace Inc. team.
+"""Self-contained SARMAE model and config for trust_remote_code loading."""
+
+from __future__ import annotations
+
+from functools import partial
+from typing import Optional
+
+import numpy as np
+import torch
+from timm.models.vision_transformer import Block, PatchEmbed
+from torch import nn
+
+from transformers.configuration_utils import PretrainedConfig as PreTrainedConfig
+from transformers.modeling_outputs import BaseModelOutputWithPooling, ImageClassifierOutput
+from transformers.modeling_utils import PreTrainedModel
+from transformers.processing_utils import Unpack
+from transformers.utils import TransformersKwargs, logging
+
+
+logger = logging.get_logger(__name__)
+
+IMAGENET_MEAN = [0.485, 0.456, 0.406]
+IMAGENET_STD = [0.229, 0.224, 0.225]
+
+
+def get_2d_sincos_pos_embed(embed_dim: int, grid_size: int, cls_token: bool = False) -> np.ndarray:
+    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)
+    grid = np.stack(grid, axis=0).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
+
+
+def get_2d_sincos_pos_embed_from_grid(embed_dim: int, grid: np.ndarray) -> np.ndarray:
+    emb_h = get_1d_sincos_pos_embed_from_grid(embed_dim // 2, grid[0])
+    emb_w = get_1d_sincos_pos_embed_from_grid(embed_dim // 2, grid[1])
+    return np.concatenate([emb_h, emb_w], axis=1)
+
+
+def get_1d_sincos_pos_embed_from_grid(embed_dim: int, pos: np.ndarray) -> np.ndarray:
+    omega = np.arange(embed_dim // 2, dtype=np.float32)
+    omega /= embed_dim / 2.0
+    omega = 1.0 / 10000**omega
+    pos = pos.reshape(-1)
+    out = np.einsum("m,d->md", pos, omega)
+    return np.concatenate([np.sin(out), np.cos(out)], axis=1)
+
+
+class SarmaeConfig(PreTrainedConfig):
+    model_type = "sarmae"
+
+    def __init__(
+        self,
+        hidden_size: int = 768,
+        num_hidden_layers: int = 12,
+        num_attention_heads: int = 12,
+        intermediate_size: int | None = None,
+        hidden_act: str = "gelu",
+        hidden_dropout_prob: float = 0.0,
+        attention_probs_dropout_prob: float = 0.0,
+        initializer_range: float = 0.02,
+        layer_norm_eps: float = 1e-6,
+        image_size: int = 224,
+        patch_size: int = 16,
+        num_channels: int = 3,
+        qkv_bias: bool = True,
+        mlp_ratio: float = 4.0,
+        global_pool: bool = True,
+        repeat_grayscale_channels: bool = True,
+        checkpoint_stage: str = "pretrain",
+        image_mean: list[float] | None = None,
+        image_std: list[float] | None = None,
+        num_labels: int = 0,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.hidden_size = hidden_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.hidden_act = hidden_act
+        self.hidden_dropout_prob = hidden_dropout_prob
+        self.attention_probs_dropout_prob = attention_probs_dropout_prob
+        self.initializer_range = initializer_range
+        self.layer_norm_eps = layer_norm_eps
+        self.image_size = image_size
+        self.patch_size = patch_size
+        self.num_channels = num_channels
+        self.qkv_bias = qkv_bias
+        self.mlp_ratio = mlp_ratio
+        self.global_pool = global_pool
+        self.repeat_grayscale_channels = repeat_grayscale_channels
+        self.checkpoint_stage = checkpoint_stage
+        self.num_labels = num_labels
+        self.intermediate_size = int(hidden_size * mlp_ratio) if intermediate_size is None else intermediate_size
+        self.image_mean = image_mean if image_mean is not None else IMAGENET_MEAN
+        self.image_std = image_std if image_std is not None else IMAGENET_STD
+
+
+class SarmaePreTrainedModel(PreTrainedModel):
+    config_class = SarmaeConfig
+    config: SarmaeConfig
+    base_model_prefix = "sarmae"
+    main_input_name = "pixel_values"
+    input_modalities = ("image",)
+    supports_gradient_checkpointing = True
+    _no_split_modules = ["Block"]
+
+
+class SarmaeModel(SarmaePreTrainedModel):
+    def __init__(self, config: SarmaeConfig, add_pooling_layer: bool = True):
+        super().__init__(config)
+        self.config = config
+        self.add_pooling_layer = add_pooling_layer
+
+        image_size = config.image_size if isinstance(config.image_size, int) else config.image_size[0]
+        norm_layer = partial(nn.LayerNorm, eps=config.layer_norm_eps)
+        self.patch_embed = PatchEmbed(image_size, config.patch_size, config.num_channels, config.hidden_size)
+        self.num_patches = self.patch_embed.num_patches
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, config.hidden_size))
+        self.pos_embed = nn.Parameter(torch.zeros(1, self.num_patches + 1, config.hidden_size))
+        pos_embed = get_2d_sincos_pos_embed(self.pos_embed.shape[-1], int(self.num_patches**0.5), cls_token=True)
+        self.pos_embed.data.copy_(torch.from_numpy(pos_embed).float().unsqueeze(0))
+        self.blocks = nn.ModuleList([
+            Block(config.hidden_size, config.num_attention_heads, config.mlp_ratio, qkv_bias=config.qkv_bias, norm_layer=norm_layer)
+            for _ in range(config.num_hidden_layers)
+        ])
+        self.global_pool = config.global_pool
+        if self.global_pool:
+            self.fc_norm = norm_layer(config.hidden_size)
+            self.norm = None
+        else:
+            self.fc_norm = None
+            self.norm = norm_layer(config.hidden_size)
+        self.post_init()
+
+    def forward(
+        self,
+        pixel_values: Optional[torch.Tensor] = None,
+        return_dict: Optional[bool] = None,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> BaseModelOutputWithPooling:
+        if pixel_values is None:
+            raise ValueError("You must specify `pixel_values`")
+        pixel_values = pixel_values.to(dtype=self.dtype)
+        if return_dict is None:
+            return_dict = self.config.use_return_dict
+
+        batch_size = pixel_values.shape[0]
+        patch_tokens = self.patch_embed(pixel_values)
+        cls_tokens = self.cls_token.expand(batch_size, -1, -1)
+        hidden_states = torch.cat((cls_tokens, patch_tokens), dim=1) + self.pos_embed
+        for block in self.blocks:
+            hidden_states = block(hidden_states)
+        if self.global_pool:
+            pooled_output = self.fc_norm(hidden_states[:, 1:, :].mean(dim=1))
+        else:
+            hidden_states = self.norm(hidden_states)
+            pooled_output = hidden_states[:, 0]
+        if not self.add_pooling_layer:
+            pooled_output = None
+        if not return_dict:
+            return (hidden_states, pooled_output)
+        return BaseModelOutputWithPooling(last_hidden_state=hidden_states, pooler_output=pooled_output)
+
+
+class SarmaeForImageClassification(SarmaePreTrainedModel):
+    def __init__(self, config: SarmaeConfig):
+        super().__init__(config)
+        self.sarmae = SarmaeModel(config, add_pooling_layer=True)
+        self.classifier = nn.Linear(config.hidden_size, config.num_labels) if config.num_labels > 0 else nn.Identity()
+        self.post_init()
+
+    def forward(
+        self,
+        pixel_values: Optional[torch.Tensor] = None,
+        labels: Optional[torch.Tensor] = None,
+        return_dict: Optional[bool] = None,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> ImageClassifierOutput:
+        outputs = self.sarmae(pixel_values=pixel_values, return_dict=True, **kwargs)
+        logits = self.classifier(outputs.pooler_output)
+        loss = None
+        if labels is not None:
+            loss = self.loss_function(labels, logits, self.config, **kwargs)
+        if not return_dict:
+            output = (logits,) + outputs[1:]
+            return ((loss,) + output) if loss is not None else output
+        return ImageClassifierOutput(loss=loss, logits=logits, hidden_states=outputs.hidden_states, attentions=outputs.attentions)
+
+
+__all__ = [
+    "SarmaeConfig",
+    "SarmaeForImageClassification",
+    "SarmaeModel",
+    "SarmaePreTrainedModel",
+]

vit-large-patch16-pretrain/pipeline_sarmae.py

@@ -0,0 +1,51 @@
+# Copyright 2026 SARMAE Authors and The HuggingFace Inc. team.
+"""SARMAE image feature extraction pipeline (self-contained for trust_remote_code)."""
+
+from typing import Any, Union
+
+from transformers.pipelines.base import GenericTensor, build_pipeline_init_args
+from transformers.pipelines.image_feature_extraction import ImageFeatureExtractionPipeline
+from transformers.utils import add_end_docstrings, is_vision_available
+
+
+if is_vision_available():
+    from transformers.image_utils import load_image
+
+
+@add_end_docstrings(
+    build_pipeline_init_args(has_image_processor=True),
+    """
+        pool (`bool`, *optional*, defaults to `False`):
+            Whether or not to return the pooled output. If `False`, the model will return the raw hidden states.
+    """,
+)
+class SarmaeImageFeatureExtractionPipeline(ImageFeatureExtractionPipeline):
+    def _sanitize_parameters(
+        self,
+        image_processor_kwargs=None,
+        return_tensors=None,
+        pool=None,
+        **kwargs,
+    ):
+        preprocess_params = {} if image_processor_kwargs is None else dict(image_processor_kwargs)
+        if "timeout" in kwargs:
+            preprocess_params["timeout"] = kwargs["timeout"]
+        postprocess_params = {}
+        if pool is not None:
+            postprocess_params["pool"] = pool
+        if return_tensors is not None:
+            postprocess_params["return_tensors"] = return_tensors
+        return preprocess_params, {}, postprocess_params
+
+    def preprocess(self, image, timeout=None, **image_processor_kwargs) -> dict[str, GenericTensor]:
+        if not isinstance(image, (list, tuple)) and not hasattr(image, "shape"):
+            image = load_image(image, timeout=timeout)
+        model_inputs = self.image_processor(image, return_tensors="pt", **image_processor_kwargs)
+        model_inputs = model_inputs.to(self.dtype)
+        return model_inputs
+
+    def __call__(self, *args: Union[str, Any, list[Any]], **kwargs: Any) -> list[Any]:
+        return super().__call__(*args, **kwargs)
+
+
+__all__ = ["SarmaeImageFeatureExtractionPipeline"]

vit-large-patch16-pretrain/preprocessor_config.json

@@ -0,0 +1,26 @@
+{
+  "image_processor_type": "SarmaeImageProcessor",
+  "size": {
+    "height": 224,
+    "width": 224
+  },
+  "do_resize": true,
+  "do_rescale": true,
+  "rescale_factor": 0.00392156862745098,
+  "do_normalize": true,
+  "do_convert_rgb": false,
+  "repeat_grayscale_channels": true,
+  "image_mean": [
+    0.485,
+    0.456,
+    0.406
+  ],
+  "image_std": [
+    0.229,
+    0.224,
+    0.225
+  ],
+  "auto_map": {
+    "AutoImageProcessor": "image_processing_sarmae.SarmaeImageProcessor"
+  }
+}