AnyUp-transformers / anyup /image_processing_anyup.py
BiliSakura's picture
Upload AnyUp Transformers checkpoints (anyup + anyup-multi-backbone)
da91acc verified
Raw History Blame Contribute Delete
5.65 kB
# Copyright 2026 The AnyUp authors and The HuggingFace Inc. team.
"""Image processor for AnyUp (ImageNet-normalized RGB guide, no default resize)."""
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 to_channel_dimension_format
from transformers.image_utils import (
IMAGENET_DEFAULT_MEAN,
IMAGENET_DEFAULT_STD,
ChannelDimension,
ImageInput,
PILImageResampling,
infer_channel_dimension_format,
make_flat_list_of_images,
to_numpy_array,
valid_images,
)
from transformers.utils import TensorType, filter_out_non_signature_kwargs, logging
logger = logging.get_logger(__name__)
def _maybe_rescale(image: np.ndarray, do_rescale: bool, rescale_factor: float) -> np.ndarray:
if not do_rescale:
return image.astype(np.float32, copy=False)
if np.nanmax(image) > 1.5:
return image.astype(np.float32) * rescale_factor
return image.astype(np.float32)
class AnyUpImageProcessor(BaseImageProcessor):
"""
Processor for AnyUp's high-resolution RGB guide.
Images are rescaled to ``[0, 1]`` and ImageNet-normalized. Resize is **off** by default so the
guide keeps its native ``(H, W)``; AnyUp is resolution-agnostic. Low-resolution features are
passed through as ``features`` and are not transformed.
"""
model_input_names = ["pixel_values", "features"]
def __init__(
self,
do_resize: bool = False,
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 = 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 = IMAGENET_DEFAULT_MEAN if image_mean is None else image_mean
self.image_std = IMAGENET_DEFAULT_STD if image_std is None else image_std
self.do_convert_rgb = do_convert_rgb
@filter_out_non_signature_kwargs()
def preprocess(
self,
images: ImageInput,
features=None,
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,
do_convert_rgb: Optional[bool] = None,
return_tensors: Optional[Union[str, TensorType]] = None,
data_format: Union[str, ChannelDimension] = ChannelDimension.FIRST,
input_data_format: Optional[Union[str, ChannelDimension]] = None,
) -> BatchFeature:
do_resize = self.do_resize if do_resize is None else do_resize
size = get_size_dict(self.size if size is None else size, default_to_square=True)
resample = self.resample if resample is None else resample
do_rescale = self.do_rescale if do_rescale is None else do_rescale
rescale_factor = self.rescale_factor if rescale_factor is None else rescale_factor
do_normalize = self.do_normalize if do_normalize is None else do_normalize
image_mean = self.image_mean if image_mean is None else image_mean
image_std = self.image_std if image_std is None else image_std
do_convert_rgb = self.do_convert_rgb if do_convert_rgb is None else do_convert_rgb
image_list = make_flat_list_of_images(images)
if not valid_images(image_list):
raise ValueError("Invalid image type. Must be PIL, numpy, or torch tensor.")
processed_images = []
for image in image_list:
image = to_numpy_array(image)
if do_convert_rgb and image.ndim == 2:
image = np.stack([image, image, image], axis=-1)
if input_data_format is None:
try:
channel_format = infer_channel_dimension_format(image)
except ValueError:
channel_format = ChannelDimension.LAST
else:
channel_format = input_data_format
if do_resize:
image = self.resize(
image,
size={"height": size["height"], "width": size["width"]},
resample=resample,
input_data_format=channel_format,
)
image = _maybe_rescale(image, do_rescale, rescale_factor)
if do_normalize:
image = self.normalize(
image=image, mean=image_mean, std=image_std, input_data_format=channel_format
)
image = to_channel_dimension_format(image, data_format, input_channel_dim=channel_format)
processed_images.append(image)
data = {"pixel_values": processed_images}
if features is not None:
data["features"] = features
return BatchFeature(data=data, tensor_type=return_tensors)
__all__ = ["AnyUpImageProcessor"]