# Обработчик изображений

Обработчик изображений отвечает за загрузку изображений (при необходимости), подготовку входных признаков для моделей компьютерного зрения и постобработку их выходов. Сюда входят такие преобразования, как изменение размера, нормализация и преобразование в тензоры PyTorch и Numpy. Также может включать специфичную для модели постобработку, например, преобразование логитов в маски сегментации.

Обработчики изображений используют архитектуру на основе бэкендов. Иерархия классов:

- [BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor) — абстрактный базовый класс (только для обратной совместимости; не создавайте экземпляры напрямую)
  - [TorchvisionBackend](/docs/transformers/main/ru/main_classes/image_processor#transformers.TorchvisionBackend) — **заданный по умолчанию** [бэкенд на базе torchvision](https://pytorch.org/vision/stable/index.html). Ускоренный на GPU и значительно более быстрый, чем бэкенд PIL. Все модели предоставляют класс `<Model>ImageProcessor`, который наследуется от него.
  - [PilBackend](/docs/transformers/main/ru/main_classes/image_processor#transformers.PilBackend) — альтернативный бэкенд на основе PIL/NumPy. Переносимый, работает только на CPU. Доступен только для старых моделей через класс `<Model>ImageProcessorPil`; полезен, когда требуется точное числовое совпадение с исходной реализацией.

Оба бэкенда предоставляют одинаковый API. Используйте атрибут `backend`, чтобы определить, какой бэкенд использует загруженный процессор (например, `processor.backend == "torchvision"`).

Передайте `backend` в [AutoImageProcessor.from_pretrained()](/docs/transformers/main/ru/model_doc/auto#transformers.AutoImageProcessor.from_pretrained), чтобы выбрать бэкенд. Если `backend` не указан (значение по умолчанию), используется torchvision, если он установлен, иначе применяется PIL. Исключение составляют несколько моделей, использующих интерполяцию Lanczos (Chameleon, Flava, Idefics3, SmolVLM): для них значением по умолчанию является PIL, если версия torchvision < 0.27. Если для этих моделей принудительно задать `backend="torchvision"` при версии torchvision < 0.27, будет использована интерполяция BICUBIC, поскольку torchvision поддерживает Lanczos для тензоров только начиная с версии 0.27.

```python
from transformers import AutoImageProcessor

# Default: picks torchvision if available, otherwise pil
processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50")

# Explicitly request torchvision
processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50", backend="torchvision")

# Explicitly request PIL
processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50", backend="pil")
```

При использовании бэкенда torchvision можно задать аргумент `device`, чтобы указать устройство, на котором следует выполнять обработку. По умолчанию обработка выполняется на том же устройстве, что и входные данные, если они являются тензорами, иначе — на CPU.

```python
import torch
from torchvision.io import read_image
from transformers import DetrImageProcessor

device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"

images = read_image("image.jpg")
processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
images_processed = processor(images, return_tensors="pt", device=device)
```

Ниже приведены сравнения скорости между бэкендами torchvision и PIL для моделей `DETR` и `RT-DETR`, а также их влияние на общее время инференса:

  

  

  

  

Эти бенчмарки были запущены на [инстансе AWS EC2 g5.2xlarge](https://aws.amazon.com/ec2/instance-types/g5/) с использованием GPU NVIDIA A10G Tensor Core.

## ImageProcessingMixin[[transformers.ImageProcessingMixin]]

#### transformers.ImageProcessingMixin[[transformers.ImageProcessingMixin]]

```python
transformers.ImageProcessingMixin(**kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_base.py#L61)

Это миксин для процессора изображений, используемый для обеспечения функциональности сохранения и загрузки для последовательных и извлекаемых признаков изображений.

#### from_pretrained[[transformers.ImageProcessingMixin.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_base.py#L84)

**Параметры:**

pretrained_model_name_or_path (`str` или `os.PathLike`) : Может быть одним из следующих:  - строка, *model id* предобученного image_processor, размещенного в репозитории моделей на huggingface.co. - путь к *каталогу*, содержащему файл image processor, сохраненный с помощью метода [save_pretrained()](/docs/transformers/main/ru/internal/image_processing_utils#transformers.ImageProcessingMixin.save_pretrained), например, `./my_model_directory/`. - путь к сохраненному JSON-*файлу* image processor, например, `./my_model_directory/preprocessor_config.json`.

cache_dir (`str` или `os.PathLike`, *необязательный*) : Путь к каталогу, в котором должен кэшироваться загруженный процессор изображений предобученной модели, если стандартный кэш не используется.

force_download (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли принудительно (пере)скачивать файлы image processor и заменять кэшированные версии, если они существуют.

proxies (`dict[str, str]`, *необязательный*) : Словарь прокси-серверов, используемых по протоколу или конечной точке, например, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}.` Прокси применяются при каждом запросе.

token (`str` или `bool`, *необязательный*) : Токен, используемый в качестве HTTP bearer-авторизации для удалённых файлов. Если указано значение `True` или параметр не задан, будет использован токен, сгенерированный при выполнении `hf auth login` (хранится в `~/.huggingface`).

revision (`str`, *необязательный*, по умолчанию `"main"`) : Конкретная версия модели, которую следует использовать. Это может быть имя ветки, имя тега или идентификатор коммита, поскольку для хранения моделей и других артефактов на huggingface.co используется система на базе git, поэтому `revision` может быть любым идентификатором, разрешённым git.     Чтобы протестировать pull request, который вы создали на Hub, можно передать `revision="refs/pr/<pr_number>"`.

return_unused_kwargs (`bool`, *необязательный*, по умолчанию `False`) : Если `False`, функция возвращает только итоговый объект image processor. Если `True`, функция возвращает `Tuple(image_processor, unused_kwargs)`, где *unused_kwargs* — это словарь, состоящий из пар ключ/значение, ключи которых не являются атрибутами image processor, то есть та часть `kwargs`, которая не была использована для обновления `image_processor` и в остальном игнорируется.

subfolder (`str`, *необязательный*, по умолчанию `""`) : Если соответствующие файлы находятся в подпапке репозитория модели на huggingface.co, здесь можно указать имя папки.

kwargs (`dict[str, Any]`, *необязательный*) : Значения в kwargs для любых ключей, являющихся атрибутами image processor, будут использоваться для переопределения загруженных значений. Поведение в отношении пар ключ/значение, ключи которых *не* являются атрибутами image processor, контролируется параметром `return_unused_kwargs`.

**Возвращаемое значение:**

Обработчик изображений типа [ImageProcessingMixin](/docs/transformers/main/ru/internal/image_processing_utils#transformers.ImageProcessingMixin).

Создайте экземпляр типа [ImageProcessingMixin](/docs/transformers/main/ru/internal/image_processing_utils#transformers.ImageProcessingMixin) из image processor.

Примеры:

```python
# We can't instantiate directly the base class *ImageProcessingMixin* so let's show the examples on a
# derived class: *CLIPImageProcessor*
image_processor = CLIPImageProcessor.from_pretrained(
    "openai/clip-vit-base-patch32"
)  # Download image_processing_config from huggingface.co and cache.
image_processor = CLIPImageProcessor.from_pretrained(
    "./test/saved_model/"
)  # E.g. image processor (or model) was saved using *save_pretrained('./test/saved_model/')*
image_processor = CLIPImageProcessor.from_pretrained("./test/saved_model/preprocessor_config.json")
image_processor = CLIPImageProcessor.from_pretrained(
    "openai/clip-vit-base-patch32", do_normalize=False, foo=False
)
assert image_processor.do_normalize is False
image_processor, unused_kwargs = CLIPImageProcessor.from_pretrained(
    "openai/clip-vit-base-patch32", do_normalize=False, foo=False, return_unused_kwargs=True
)
assert image_processor.do_normalize is False
assert unused_kwargs == {"foo": False}
```

#### save_pretrained[[transformers.ImageProcessingMixin.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike, push_to_hub: bool = False, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_base.py#L190)

**Параметры:**

save_directory (`str` или `os.PathLike`) : Каталог, в котором будет сохранён JSON-файл процессора изображений (будет создан, если не существует).

push_to_hub (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли после сохранения модели загрузить её в Hugging Face model hub. Репозиторий, в который нужно загрузить модель, можно указать с помощью `repo_id` (по умолчанию используется имя `save_directory` в вашем пространстве имён).

kwargs (`dict[str, Any]`, *необязательный*) : Дополнительные именованные аргументы, передаваемые в метод [push_to_hub()](/docs/transformers/main/ru/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Сохраните объект image processor в каталог `save_directory`, чтобы его можно было загрузить с помощью метода класса [from_pretrained()](/docs/transformers/main/ru/internal/image_processing_utils#transformers.ImageProcessingMixin.from_pretrained).

## BatchFeature[[transformers.BatchFeature]]

#### transformers.BatchFeature[[transformers.BatchFeature]]

```python
transformers.BatchFeature(data: dict[str, typing.Any] | None = None, tensor_type: None | str | transformers.utils.generic.TensorType = None, skip_tensor_conversion: list[str] | set[str] | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/feature_extraction_utils.py#L58)

**Параметры:**

data (`dict`, *необязательный*) : Словарь списков/массивов/тензоров, возвращаемый методами __call__/pad ('input_values', 'attention_mask' и т. д.).

tensor_type (`Union[None, str, TensorType]`, *необязательный*) : Здесь можно указать tensor_type, чтобы при инициализации преобразовать списки целых чисел в тензоры PyTorch/Numpy.

skip_tensor_conversion (`list[str]` или `set[str]`, *необязательный*) : Список или множество ключей, которые не следует преобразовывать в тензоры, даже если указан `tensor_type`.

Содержит результат методов [pad()](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) и специфичных для экстрактора признаков `__call__`.

Этот класс наследуется от словаря Python и может использоваться как словарь.

#### convert_to_tensors[[transformers.BatchFeature.convert_to_tensors]]

```python
convert_to_tensors(tensor_type: str | transformers.utils.generic.TensorType | None = None, skip_tensor_conversion: list[str] | set[str] | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/feature_extraction_utils.py#L158)

**Параметры:**

tensor_type (`str` или [TensorType](/docs/transformers/main/ru/internal/file_utils#transformers.TensorType), *optional*) : Тип тензоров, который следует использовать. Если `str`, значение должно быть одним из значений перечисления [TensorType](/docs/transformers/main/ru/internal/file_utils#transformers.TensorType). Если `None`, изменения не выполняются.

skip_tensor_conversion (`list[str]` или `set[str]`, *необязательный*) : Список или множество ключей, которые не следует преобразовывать в тензоры, даже если указан `tensor_type`.

Преобразуйте внутреннее содержимое в тензоры.

Примечание: значения, не имеющие структуры массива (например, строки, словари, списки строк), автоматически пропускаются и не преобразуются в тензоры. Для неровных массивов (списков массивов разной длины) преобразование всё же выполняется, но в процессе могут возникать ошибки.

#### к[[transformers.BatchFeature.to]]

```python
to(*args, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/feature_extraction_utils.py#L215)

**Параметры:**

args (`Tuple`) : будет передан в функцию `to(...)` тензоров.

kwargs (`Dict`, *необязательный*) : Будет передан в функцию `to(...)` тензоров. Для включения асинхронной передачи данных установите флаг `non_blocking` в `kwargs` (по умолчанию `False`).

**Возвращает:** [BatchFeature](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.BatchFeature)

Тот же самый экземпляр после модификации.

Отправьте все значения на устройство, вызвав `v.to(*args, **kwargs)` (только PyTorch). Это должно поддерживать приведение к различным `dtypes` и отправку `BatchFeature` на другое `device`.

## BaseImageProcessor[[transformers.BaseImageProcessor]]

#### transformers.BaseImageProcessor[[transformers.BaseImageProcessor]]

```python
transformers.BaseImageProcessor(**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L60)

Базовый класс для процессоров изображений с архитектурой бэкенда на основе наследования.

Этот класс определяет конвейер предобработки: валидацию аргументов kwargs, подготовку входных данных и передачу управления методу `_preprocess` бэкенда. Подклассы бэкендов (`TorchvisionBackend`, `PilBackend`) наследуются от этого класса и реализуют фактические операции с изображениями (изменение размера, обрезка, масштабирование, нормализация и т. д.). Специфичные для модели процессоры изображений наследуются от соответствующего класса бэкенда.

Обзор архитектуры ---------------------

Иерархия классов:

BaseImageProcessor (этот класс) ├── TorchvisionBackend    (ускорение на GPU, torch.Tensor) │   └── ModelImageProcessor (например, LlavaNextImageProcessor) └── PilBackend            (переносимый CPU, np.ndarray) └── ModelImageProcessorPil (например, CLIPImageProcessorPil)

Поток предобработки:

__call__() → preprocess() → _preprocess_image_like_inputs() → _prepare_image_like_inputs() (вызывает process_image для каждого изображения) → _preprocess() (операции над батчем: resize, crop и т. д.)

- `process_image`: Реализуется бэкендами. Преобразует один необработанный вход (PIL, NumPy или Tensor) в рабочий формат бэкенда (torch.Tensor или np.ndarray), обрабатывает конвертацию в RGB и перестановку каналов.
- `_preprocess`: Реализуется бэкендами. Выполняет фактическую пакетную обработку (изменение размера, центрированный кроп, масштабирование, нормализация, паддинг) и возвращает `BatchFeature`.

Базовая реализация --------------------

Для процессоров, которым нужны только стандартные операции (resize, center crop, rescale, normalize), унаследуйте класс от бэкенда и определите атрибуты класса:

from transformers.image_processing_backends import PilBackend

class MyImageProcessorPil(PilBackend): resample = PILImageResampling.BILINEAR image_mean = IMAGENET_DEFAULT_MEAN image_std = IMAGENET_DEFAULT_STD size = {"height": 224, "width": 224} do_resize = True do_rescale = True do_normalize = True

Метод `_preprocess` бэкенда автоматически обрабатывает стандартный конвейер.

Пользовательская обработка -----------------

Для процессоров, требующих пользовательской логики (например, обработки по патчам, нескольких типов входных данных), переопределите `_preprocess` в процессоре, специфичном для вашей модели. Метод `_preprocess` принимает уже подготовленные изображения (преобразованные в формат бэкенда с порядком каналов первым) и выполняет фактическую обработку:

class MyImageProcessor(TorchvisionBackend): def _preprocess(self, images, do_resize, size, do_normalize, image_mean, image_std, **kwargs):
# Группировка изображений по форме для эффективных пакетных операций
grouped_images, grouped_images_index = group_images_by_shape(images) processed_groups = {} for shape, stacked_images in grouped_images.items(): if do_resize: stacked_images = self.resize(stacked_images, size=size) if do_normalize: stacked_images = self.normalize(stacked_images, mean=image_mean, std=image_std) processed_groups[shape] = stacked_images processed_images = reorder_images(processed_groups, grouped_images_index) return BatchFeature(data={"pixel_values": processed_images})

Для процессоров, обрабатывающих несколько типов входных данных (например, изображения + карты сегментации), переопределите `_preprocess_image_like_inputs`:

def _preprocess_image_like_inputs( self, images: ImageInput, segmentation_maps: ImageInput | None = None, **kwargs, ) -> BatchFeature: images = self._prepare_image_like_inputs(images, **kwargs) batch_feature = self._preprocess(images, **kwargs)

if segmentation_maps is not None: maps = self._prepare_image_like_inputs(segmentation_maps, **kwargs) batch_feature["labels"] = self._preprocess(maps, **kwargs).pixel_values

return batch_feature

Расширение поведения бэкенда --------------------------

Чтобы настроить операции для конкретного бэкенда, создайте подкласс бэкенда и переопределите его методы:

from transformers.image_processing_backends import TorchvisionBackend, PilBackend

class MyTorchvisionProcessor(TorchvisionBackend): def resize(self, image, size, **kwargs):
# Пользовательская логика изменения размера для torchvision
return super().resize(image, size, **kwargs)

class MyPilProcessor(PilBackend): def resize(self, image, size, **kwargs):
# Пользовательская логика изменения размера для PIL
return super().resize(image, size, **kwargs)

Пользовательские параметры -----------------

Чтобы добавить параметры, выходящие за рамки `ImagesKwargs`, создайте собственный класс kwargs и установите его в качестве `valid_kwargs`:

class MyImageProcessorKwargs(ImagesKwargs): custom_param: int | None = None

class MyImageProcessor(TorchvisionBackend): valid_kwargs = MyImageProcessorKwargs custom_param = 10  # default value

Ключевые замечания ---------

- Выбор бэкенда выполняется на уровне класса: наследуйте от `TorchvisionBackend` или `PilBackend`
- Бэкенды получают изображения в виде `torch.Tensor` (Torchvision) или `np.ndarray` (PIL), всегда с каналами впереди
- Все изображения имеют размерность каналов первой при обработке, независимо от бэкенда
- Аргументы, не переданные пользователем, по умолчанию принимают значения атрибутов класса
- Классы бэкендов инкапсулируют логику, специфичную для каждого бэкенда (resize, normalize и т. д.), и могут быть переопределены

#### center_crop[[transformers.BaseImageProcessor.center_crop]]

```python
center_crop(image: ndarray, size: dict, data_format: str | transformers.image_utils.ChannelDimension | None = None, input_data_format: str | transformers.image_utils.ChannelDimension | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L500)

**Параметры:**

image (`np.ndarray`) : Изображение для центрированного кадрирования.

size (`dict[str, int]`) : Размер выходного изображения.

data_format (`str` или `ChannelDimension`, *необязательный*) : Формат размерности каналов для выходного изображения. Если не задано, используется формат размерности каналов входного изображения. Может быть одним из: - `"channels_first"` или `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `"channels_last"` или `ChannelDimension.LAST`: изображение в формате (height, width, num_channels).

input_data_format (`ChannelDimension` или `str`, *необязательный*) : Формат размерности каналов для входного изображения. Если не задано, формат размерности каналов определяется по входному изображению. Может быть одним из: - `"channels_first"` или `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `"channels_last"` или `ChannelDimension.LAST`: изображение в формате (height, width, num_channels).

Центральное обрезание изображения до размера `(size["height"], size["width"])`. Если размер входного изображения меньше `crop_size` по любому из краёв, изображение дополняется нулями, а затем выполняется центральное обрезание.

#### normalize[[transformers.BaseImageProcessor.normalize]]

```python
normalize(image: ndarray, mean: float | collections.abc.Iterable[float], std: float | collections.abc.Iterable[float], data_format: str | transformers.image_utils.ChannelDimension | None = None, input_data_format: str | transformers.image_utils.ChannelDimension | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L463)

**Параметры:**

image (`np.ndarray`) : Изображение для нормализации.

mean (`float` или `Iterable[float]`) : Среднее значение изображения, используемое для нормализации.

std (`float` или `Iterable[float]`) : Стандартное отклонение изображения, используемое для нормализации.

data_format (`str` или `ChannelDimension`, *необязательный*) : Формат размерности каналов для выходного изображения. Если не задано, используется формат размерности каналов входного изображения. Может быть одним из: - `"channels_first"` или `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `"channels_last"` или `ChannelDimension.LAST`: изображение в формате (height, width, num_channels).

input_data_format (`ChannelDimension` или `str`, *необязательный*) : Формат размерности каналов для входного изображения. Если не задано, формат размерности каналов определяется по входному изображению. Может быть одним из: - `"channels_first"` или `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `"channels_last"` или `ChannelDimension.LAST`: изображение в формате (height, width, num_channels).

**Возвращает:** `np.ndarray`

Нормализованное изображение.

Нормализация изображения. image = (image - image_mean) / image_std.

#### preprocess[[transformers.BaseImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], *args, image_like_kwargs: dict[str, typing.Any] | None = None, **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L382)

**Параметры:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Изображение для предобработки. Ожидается одно изображение или пакет изображений со значениями пикселей в диапазоне от 0 до 255. Если передаются изображения со значениями пикселей в диапазоне от 0 до 1, установите `do_rescale=False`.

image_like_kwargs (`dict[str, Any]`, *необязательный*) : Флаг разработчика для дополнительных изображений и похожих на них входных данных, которые также будут предобработаны. Используйте этот параметр только в том случае, если передача входных данных через kwarg не работает. Например, `preprocess(images, masks=masks)` — предпочтительный вариант, но для некоторых моделей он приводит к проблемам с приоритетом аргументов. В таких случаях можно использовать `preprocess(images, image_like_inputs={"masks": masks})`.

do_convert_rgb (`bool`, *kwargs*, *необязательный*) : Преобразовать ли изображение в RGB.

do_resize (`bool`, *kwargs*, *необязательный*) : Указывает, нужно ли изменить размер изображения.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Описывает максимальные размеры входных данных для модели.

default_to_square (`bool`, *kwargs*, *необязательный*) : Указывает, следует ли по умолчанию использовать квадратное изображение при изменении размера, если size задан как int.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Размер выходного изображения после применения `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Фильтр ресемплинга, используемый при изменении размера изображения. Может быть одним из значений перечисления `PILImageResampling`. Действует только при установке `do_resize` в `True`.

do_rescale (`bool`, *kwargs*, *необязательный*) : Нужно ли масштабировать изображение.

rescale_factor (`float`, *kwargs*, *optional*) : Коэффициент масштабирования для изменения размера изображения, если `do_rescale` установлен в `True`.

do_normalize (`bool`, *kwargs*, *необязательный*) : Нужно ли нормализовать изображение.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Среднее значение изображения, используемое для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Стандартное отклонение изображения, используемое для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`.

do_pad (`bool`, *kwargs*, *необязательный*) : Указывает, нужно ли выравнивать изображение. Выравнивание выполняется либо до максимального размера в батче, либо до фиксированного квадратного размера для каждого изображения. Конкретная стратегия выравнивания зависит от модели.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Размер в формате `{"height": int, "width" int}`, до которого следует дополнить изображения. Должен быть больше любого размера изображения, переданного для предобработки. Если `pad_size` не указан, изображения будут дополнены до наибольшей высоты и ширины в батче. Применяется только при `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *optional*) : Центрировать ли изображение при обрезке.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *необязательный*) : Поддерживается только `ChannelDimension.FIRST`. Добавлено для совместимости с медленными процессорами.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Формат размерности каналов для входного изображения. Если не задано, формат размерности каналов определяется по входному изображению. Может быть одним из: - `"channels_first"` или `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `"channels_last"` или `ChannelDimension.LAST`: изображение в формате (height, width, num_channels). - `"none"` или `ChannelDimension.NONE`: изображение в формате (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Устройство для обработки видео. Если не задано, устройство определяется на основе входных видео.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Возвращает стопку тензоров, если установлено значение `'pt'`, иначе возвращает список тензоров.

disable_grouping (`bool`, *kwargs*, *optional*) : Указывает, следует ли отключить группировку изображений по размеру для их индивидуальной обработки, а не пачками. Если значение равно None, оно будет установлено в True, если изображения находятся на CPU, и в False в противном случае. Этот выбор основан на эмпирических наблюдениях, подробно описанных здесь: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *необязательный*) : Количество токенов изображения, используемых для каждого изображения во входных данных. Добавлено для обратной совместимости, но в будущих моделях это значение следует задавать как атрибут процессора.

**Возвращает:** `~image_processing_base.BatchFeature`

- **data** (`dict`) — Словарь списков/массивов/тензоров, возвращаемый методом __call__ ('pixel_values' и т. д.).
- **tensor_type** (`Union[None, str, TensorType]`, *необязательный*) -- Здесь можно указать tensor_type, чтобы при инициализации преобразовать списки целых чисел в тензоры PyTorch/Numpy.

Предобработка изображения или пакета изображений.

#### process_image[[transformers.BaseImageProcessor.process_image]]

```python
process_image(*args, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L219)

Обработка одного необработанного изображения в рабочий формат бэкенда.

Реализован в подклассах бэкендов (`TorchvisionBackend`, `PilBackend`). Преобразует исходные данные (изображение PIL, массив NumPy или тензор torch) во внутренний формат бэкенда (`torch.Tensor` для Torchvision, `np.ndarray` для PIL), выполняет преобразование в RGB и обеспечивает порядок каналов «каналы первыми».

#### rescale[[transformers.BaseImageProcessor.rescale]]

```python
rescale(image: ndarray, scale: float, data_format: str | transformers.image_utils.ChannelDimension | None = None, input_data_format: str | transformers.image_utils.ChannelDimension | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L430)

**Параметры:**

image (`np.ndarray`) : Изображение для масштабирования.

scale (`float`) : Коэффициент масштабирования для перемасштабирования значений пикселей.

data_format (`str` или `ChannelDimension`, *необязательный*) : Формат размерности каналов для выходного изображения. Если не задано, используется формат размерности каналов входного изображения. Может быть одним из: - `"channels_first"` или `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `"channels_last"` или `ChannelDimension.LAST`: изображение в формате (height, width, num_channels).

input_data_format (`ChannelDimension` или `str`, *необязательный*) : Формат размерности каналов для входного изображения. Если не задано, формат размерности каналов определяется по входному изображению. Может быть одним из: - `"channels_first"` или `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `"channels_last"` или `ChannelDimension.LAST`: изображение в формате (height, width, num_channels).

**Возвращает:** `np.ndarray`

Масштабированное изображение.

Масштабирование изображения с помощью коэффициента масштабирования. image = image * scale.

## TorchvisionBackend[[transformers.TorchvisionBackend]]

#### transformers.TorchvisionBackend[[transformers.TorchvisionBackend]]

```python
transformers.TorchvisionBackend(**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L86)

Бэкенд Torchvision для пакетной обработки изображений с ускорением на GPU.

#### center_crop[[transformers.TorchvisionBackend.center_crop]]

```python
center_crop(image: torch.Tensor, size: SizeDict, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L367)

Центральное обрезание изображения с помощью Torchvision.

#### convert_to_rgb[[transformers.TorchvisionBackend.convert_to_rgb]]

```python
convert_to_rgb(image: torch.Tensor, input_data_format: str | transformers.image_utils.ChannelDimension | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L156)

Преобразование изображения в формат RGB.

#### fetch_images[[transformers.TorchvisionBackend.fetch_images]]

```python
fetch_images(image_url_or_urls: str | list[str] | list[list[str]])
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L100)

Преобразовать один URL или список URL/путей в объекты `torch.Tensor`.

Уже валидные объекты изображений (тензоры, массивы numpy, изображения PIL) передаются без изменений, чтобы вызывающие стороны, предварительно загружающие изображения, не были затронуты.

#### normalize[[transformers.TorchvisionBackend.normalize]]

```python
normalize(image: torch.Tensor, mean: float | collections.abc.Iterable[float], std: float | collections.abc.Iterable[float], inplace: bool = False, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L313)

Нормализуйте изображение с помощью Torchvision.

#### pad[[transformers.TorchvisionBackend.pad]]

```python
pad(images: list, pad_size: SizeDict = None, fill_value: int | None = 0, padding_mode: str | None = 'constant', return_mask: bool = False, disable_grouping: bool | None = False, is_nested: bool | None = False, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L180)

Выполните выравнивание изображений с помощью Torchvision с использованием пакетных операций.

#### process_image[[transformers.TorchvisionBackend.process_image]]

```python
process_image(image: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], do_convert_rgb: bool | None = None, input_data_format: str | transformers.image_utils.ChannelDimension | None = None, device: typing.Optional[ForwardRef('torch.device')] = None, **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L116)

Обработка одного изображения для бэкенда torchvision.

#### rescale[[transformers.TorchvisionBackend.rescale]]

```python
rescale(image: torch.Tensor, scale: float, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L304)

Масштабирование изображения с помощью коэффициента масштаба в Torchvision.

#### rescale_and_normalize[[transformers.TorchvisionBackend.rescale_and_normalize]]

```python
rescale_and_normalize(images: torch.Tensor, do_rescale: bool, rescale_factor: float, do_normalize: bool, image_mean: float | list[float], image_std: float | list[float])
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L341)

Масштабирование и нормализация изображений с помощью Torchvision (объединённые для эффективности).

#### resize[[transformers.TorchvisionBackend.resize]]

```python
resize(image: torch.Tensor, size: SizeDict, resample: PILImageResampling | tvF.InterpolationMode | int | None = None, antialias: bool = True, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L230)

Изменение размера изображения с помощью Torchvision.

## PilBackend[[transformers.PilBackend]]

#### transformers.PilBackend[[transformers.PilBackend]]

```python
transformers.PilBackend(**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L444)

Бэкенд PIL/NumPy для переносимой обработки изображений только на CPU.

#### center_crop[[transformers.PilBackend.center_crop]]

```python
center_crop(image: ndarray, size: SizeDict, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L635)

Центральное обрезание изображения с помощью NumPy.

#### convert_to_rgb[[transformers.PilBackend.convert_to_rgb]]

```python
convert_to_rgb(image: ndarray, input_data_format: str | transformers.image_utils.ChannelDimension | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L495)

Преобразование изображения в формат RGB.

#### normalize[[transformers.PilBackend.normalize]]

```python
normalize(image: ndarray, mean: float | collections.abc.Iterable[float], std: float | collections.abc.Iterable[float], **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L619)

Нормализация изображения с помощью NumPy.

#### pad[[transformers.PilBackend.pad]]

```python
pad(images: list, pad_size: SizeDict = None, fill_value: int | None = 0, padding_mode: str | None = 'constant', return_mask: bool = False, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L503)

Заполните изображения нулями до указанного размера с помощью NumPy.

#### process_image[[transformers.PilBackend.process_image]]

```python
process_image(image: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], do_convert_rgb: bool | None = None, input_data_format: str | transformers.image_utils.ChannelDimension | None = None, **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L458)

Обработка одного изображения для бэкенда PIL.

#### rescale[[transformers.PilBackend.rescale]]

```python
rescale(image: ndarray, scale: float, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L605)

Масштабирование изображения с помощью коэффициента масштаба в NumPy.

#### resize[[transformers.PilBackend.resize]]

```python
resize(image: ndarray, size: SizeDict, resample: PILImageResampling | None = None, reducing_gap: int | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L554)

Изменение размера изображения с помощью PIL/NumPy.