# 画像プロセッサ

イメージプロセッサは、画像の読み込み（オプション）、ビジョンモデルへの入力特徴量の準備、および出力のポストプロセッシングを担当します。これには、リサイズ、正規化、PyTorch および Numpy テンソルへの変換などの変換が含まれます。また、logits をセグメンテーションマスクに変換するなどの、モデル固有のポストプロセッシングも含まれる場合があります。

Image processorはバックエンドベースのアーキテクチャを採用しています。クラス階層は以下の通りです。

- [BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor) — 抽象基底クラス（後方互換性のためだけに存在します。直接インスタンス化しないでください）
  - [TorchvisionBackend](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.TorchvisionBackend) — **デフォルト**の [torchvision ベース](https://pytorch.org/vision/stable/index.html)のバックエンドです。GPU によるアクセラレーションに対応しており、PIL バックエンドよりも大幅に高速です。すべてのモデルは、これを継承する `<Model>ImageProcessor` クラスを公開しています。
  - [PilBackend](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.PilBackend) — PIL/NumPy による代替バックエンド。ポータブルで、CPU のみ対応。旧モデルでは `<Model>ImageProcessorPil` クラスを通じてのみ利用可能であり、元の実装と厳密な数値的一致が必要な場合に有用です。

両方のバックエンドは同じAPIを公開しています。読み込まれたプロセッサがどのバックエンドを使用しているかを調べるには、`backend`属性を使用します（例: `processor.backend == "torchvision"`）。

`backend` を [AutoImageProcessor.from_pretrained()](/docs/transformers/v5.23.0/ja/model_doc/auto#transformers.AutoImageProcessor.from_pretrained) に渡してバックエンドを選択します。`backend` を省略した場合(デフォルト)、torchvision がインストールされていれば torchvision が選択され、そうでなければ PIL が使用されます。Lanczos 補間を使用する一部のモデル(Chameleon、Flava、Idefics3、SmolVLM)は例外であり、torchvision < 0.27 の場合はデフォルトで PIL が使用されます。これらのモデルに対して torchvision < 0.27 で `backend="torchvision"` を強制すると、torchvision がテンソルに対する Lanczos 補間をサポートするのは 0.27 以降であるため、BICUBIC 補間にフォールバックします。

```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)
```

`DETR`モデルと`RT-DETR`モデルにおけるtorchvisionバックエンドとPILバックエンドの速度比較、およびそれらが全体推論時間に与える影響を以下に示します。

  

  

  

  

これらのベンチマークは、NVIDIA A10G Tensor Core GPU を利用した [AWS EC2 g5.2xlarge インスタンス](https://aws.amazon.com/ec2/instance-types/g5/) で実行されました。

## ImageProcessingMixin[[transformers.ImageProcessingMixin]]

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

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

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/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/v5.23.0/src/transformers/image_processing_base.py#L84)

**パラメータ:**

pretrained_model_name_or_path (`str` または `os.PathLike`) : 以下のいずれかです: - huggingface.co のモデルリポジトリにホストされている事前学習済み *model id* の文字列。 - [save_pretrained()](/docs/transformers/v5.23.0/ja/internal/image_processing_utils#transformers.ImageProcessingMixin.save_pretrained) メソッドを使用して保存された image processor ファイルを含む *ディレクトリ* へのパス。例: `./my_model_directory/`。 - 保存された image processor の JSON *ファイル* へのパス。例: `./my_model_directory/preprocessor_config.json`。

cache_dir (`str` または `os.PathLike`、*任意*) : 標準のキャッシュを使用しない場合、ダウンロードした事前学習済みモデルの画像プロセッサをキャッシュするディレクトリのパス。

force_download (`bool`、*任意*、デフォルトは`False`) : 存在する場合はキャッシュされたバージョンを上書きして、イメージプロセッサのファイルを（再）ダウンロードを強制するかどうか。

proxies (`dict[str, str]`, *省略可*) : プロトコルまたはエンドポイントごとに使用するプロキシサーバーの辞書。例: `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}.` 各リクエストでこれらのプロキシが使用されます。

token (`str` または `bool`、*省略可*) : リモートファイルの HTTP ベアラ認証に使用するトークン。`True` の場合、または指定されていない場合は、`hf auth login` を実行した際に生成されたトークン（`~/.huggingface` に保存）が使用されます。

revision (`str`、*任意*、デフォルトは`"main"`) : 使用する特定のモデルバージョンです。huggingface.co ではモデルやその他の成果物を保存するために git ベースのシステムを使用しているため、ブランチ名、タグ名、コミット ID など、git で許可されている任意の識別子を`revision`に指定できます。     Hub で作成したプルリクエストをテストするには、`revision="refs/pr/<pr_number>"`を渡すことができます。

return_unused_kwargs (`bool`、*任意*、デフォルトは`False`) : `False`の場合、この関数は最終的なimage processorオブジェクトのみを返します。`True`の場合、この関数は`Tuple(image_processor, unused_kwargs)`を返します。ここで、*unused_kwargs*は、キーがimage processorの属性でないキー/値のペアで構成される辞書です。つまり、`image_processor`の更新に使用されず、それ以外は無視される`kwargs`の部分です。

subfolder (`str`、*任意*、デフォルトは`""`) : 関連するファイルが huggingface.co 上のモデルリポジトリ内のサブフォルダに配置されている場合、ここにフォルダ名を指定できます。

kwargs (`dict[str, Any]`, *省略可*) : kwargs 内の、キーが image processor の属性である値は、読み込まれた値の上書きに使用されます。キーが image processor の属性で*ない*キー/値ペアの動作は、`return_unused_kwargs` キーワード引数によって制御されます。

**戻り値:**

型が[ImageProcessingMixin](/docs/transformers/v5.23.0/ja/internal/image_processing_utils#transformers.ImageProcessingMixin)の画像プロセッサ。

画像プロセッサから[ImageProcessingMixin](/docs/transformers/v5.23.0/ja/internal/image_processing_utils#transformers.ImageProcessingMixin)の型をインスタンス化します。

例:

```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/v5.23.0/src/transformers/image_processing_base.py#L190)

**パラメータ:**

save_directory (`str` または `os.PathLike`) : 画像プロセッサの JSON ファイルを保存するディレクトリ（存在しない場合は作成されます）。

push_to_hub (`bool`、*任意*、デフォルトは`False`) : モデルを保存した後、Hugging Face モデルハブにプッシュするかどうかを指定します。プッシュ先のリポジトリは`repo_id`で指定できます（指定しない場合、`save_directory`の名前があなたのネームスペース内でデフォルトとして使用されます）。

kwargs (`dict[str, Any]`、*省略可*) : [push_to_hub()](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub) メソッドに渡される追加のキーワード引数。

画像プロセッサオブジェクトをディレクトリ `save_directory` に保存し、[from_pretrained()](/docs/transformers/v5.23.0/ja/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/v5.23.0/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 の Tensor 内の整数リストを変換できます。

skip_tensor_conversion (`list[str]` または `set[str]`、*任意*) : `tensor_type` が指定されている場合でも、テンソルに変換すべきでないキーのリストまたはセット。

[pad()](/docs/transformers/v5.23.0/ja/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/v5.23.0/src/transformers/feature_extraction_utils.py#L158)

**パラメータ:**

tensor_type (`str` または [TensorType](/docs/transformers/v5.23.0/ja/internal/file_utils#transformers.TensorType)、*optional*) : 使用するテンソルの型です。`str` の場合、列挙型 [TensorType](/docs/transformers/v5.23.0/ja/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/v5.23.0/src/transformers/feature_extraction_utils.py#L215)

**パラメータ:**

args (`Tuple`) : テンソルの `to(...)` 関数に渡されます。

kwargs (`Dict`、*任意*) : テンソルの `to(...)` 関数に渡されます。非同期データ転送を有効にするには、`kwargs` に `non_blocking` フラグを設定します（デフォルトは `False`）。

**戻り値:** [BatchFeature](/docs/transformers/v5.23.0/ja/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/v5.23.0/src/transformers/image_processing_utils.py#L60)

継承ベースのバックエンドアーキテクチャを備えた画像プロセッサの基底クラス。

このクラスは前処理パイプラインを定義します: kwargs の検証、入力の準備、バックエンドの `_preprocess` メソッドへのディスパッチ。バックエンドのサブクラス (`TorchvisionBackend`、`PilBackend`) はこのクラスを継承し、実際の画像操作 (リサイズ、クロップ、リスケール、正規化など) を実装します。モデル固有の画像プロセッサは、適切なバックエンドクラスを継承します。

アーキテクチャの概要 ---------------------

クラス階層は以下の通りです:

BaseImageProcessor (this class) ├── 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()（バッチ操作：リサイズ、クロップなど）

- `process_image`: バックエンドによって実装されます。単一の生入力（PIL、NumPy、または Tensor）をバックエンドの作業形式（torch.Tensor または np.ndarray）に変換し、RGB 変換とチャネルの並べ替えを処理します。
- `_preprocess`: バックエンドによって実装されます。実際のバッチ処理（リサイズ、センタークロップ、リスケール、正規化、パディング）を実行し、`BatchFeature`を返します。

基本的な実装 --------------------

標準的な操作（リサイズ、中央クロップ、リスケール、正規化）のみを必要とするプロセッサでは、バックエンドを継承し、クラス属性を定義します。

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)として受け取り、常にチャネル優先の形式で扱います
- …
- ユーザーが指定しない引数は、クラス属性の値がデフォルトとして使用されます
- Backend クラスは、バックエンド固有のロジック（リサイズ、正規化など）をカプセル化しており、オーバーライドできます

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

```python
center_crop(image: ndarray, size: dict[str, int], 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/v5.23.0/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`より小さい場合、画像は0でパディングされた後に中央クロップされます。

#### 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/v5.23.0/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/v5.23.0/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*, *optional*) : 画像を RGB に変換するかどうか。

do_resize (`bool`, *kwargs*, *optional*) : 画像をリサイズするかどうか。

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : モデルへの最大入力次元を記述します。

default_to_square (`bool`, *kwargs*, *optional*) : 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*, *optional*) : 画像を正規化するかどうかを指定します。

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*、*optional*) : 対応するのは `ChannelDimension.FIRST` のみです。slow processors との互換性のために追加されました。

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *任意*) : 入力画像のチャネル次元の形式です。設定されていない場合、入力画像からチャネル次元の形式が推論されます。以下のいずれかになります: - `"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 の場合、画像が CPU にある場合は True、それ以外の場合は 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]`、*省略可*) -- 初期化時に PyTorch/Numpy の Tensor 内の整数リストを変換するために、ここで tensor_type を指定できます。

画像または画像のバッチを前処理します。

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

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

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_utils.py#L219)

単一の生画像をバックエンドの作業形式に変換します。

バックエンドのサブクラス（`TorchvisionBackend`、`PilBackend`）によって実装されます。生の入力（PIL Image、NumPy 配列、または torch Tensor）をバックエンドの内部形式（Torchvision の場合は `torch.Tensor`、PIL の場合は `np.ndarray`）に変換し、RGB 変換を処理して、チャネル優先の順序を保証します。

#### リスケール[[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/v5.23.0/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/v5.23.0/src/transformers/image_processing_backends.py#L86)

GPU による高速化バッチ画像処理用の Torchvision バックエンド。

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

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

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L371)

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/v5.23.0/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/v5.23.0/src/transformers/image_processing_backends.py#L100)

単一のURL/パスまたはそのリストを`torch.Tensor`オブジェクトに変換します。

すでに有効な画像オブジェクト（テンソル、NumPy配列、PIL Image）は変更なしでそのまま渡されるため、事前に画像を読み込んでいる呼び出し元への影響はありません。

#### 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/v5.23.0/src/transformers/image_processing_backends.py#L317)

Torchvisionを使用して画像を正規化します。

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

```python
pad(images: list['torch.Tensor'], 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/v5.23.0/src/transformers/image_processing_backends.py#L184)

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/v5.23.0/src/transformers/image_processing_backends.py#L116)

torchvision バックエンドで単一の画像を処理します。

#### リスケール[[transformers.TorchvisionBackend.rescale]]

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

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L308)

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/v5.23.0/src/transformers/image_processing_backends.py#L345)

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/v5.23.0/src/transformers/image_processing_backends.py#L234)

Torchvision を使用して画像をリサイズします。

## PilBackend[[transformers.PilBackend]]

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

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

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L448)

ポータブルなCPU専用の画像処理のためのPIL/NumPyバックエンド。

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

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

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L639)

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/v5.23.0/src/transformers/image_processing_backends.py#L499)

画像を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/v5.23.0/src/transformers/image_processing_backends.py#L623)

NumPy を使用して画像を正規化します。

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

```python
pad(images: list[numpy.ndarray], 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/v5.23.0/src/transformers/image_processing_backends.py#L507)

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/v5.23.0/src/transformers/image_processing_backends.py#L462)

PILバックエンドで単一の画像を処理します。

#### リスケール[[transformers.PilBackend.rescale]]

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

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_backends.py#L609)

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/v5.23.0/src/transformers/image_processing_backends.py#L558)

PIL/NumPyを使用して画像をリサイズします。

