# Pemroses gambar

Sebuah image processor bertanggung jawab untuk memuat gambar (secara opsional), menyiapkan fitur input untuk model visi, dan memproses ulang outputnya. Ini mencakup transformasi seperti pengubahan ukuran, normalisasi, dan konversi ke tensor PyTorch dan Numpy. Hal ini juga dapat mencakup pascapemrosesan yang spesifik untuk model, seperti mengonversi logits menjadi mask segmentasi.

Pemroses gambar menggunakan arsitektur berbasis backend. Hirarki kelasnya adalah:

- [BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor) — kelas dasar abstrak (hanya untuk kompatibilitas mundur; jangan instansiasi secara langsung)
  - [TorchvisionBackend](/docs/transformers/main/id/main_classes/image_processor#transformers.TorchvisionBackend) — backend **default** yang didukung [torchvision](https://pytorch.org/vision/stable/index.html). Dipercepat dengan GPU dan jauh lebih cepat daripada backend PIL. Semua model mengekspos kelas `<Model>ImageProcessor` yang mewarisi darinya.
  - [PilBackend](/docs/transformers/main/id/main_classes/image_processor#transformers.PilBackend) — backend alternatif PIL/NumPy. Portabel, hanya CPU. Hanya tersedia untuk model lama melalui kelas `<Model>ImageProcessorPil`; berguna ketika kesetaraan numerik yang tepat dengan implementasi asli diperlukan.

Kedua backend tersebut mengekspos API yang sama. Gunakan atribut `backend` untuk memeriksa backend mana yang digunakan oleh processor yang dimuat (misalnya `processor.backend == "torchvision"`).

Lewatkan `backend` ke [AutoImageProcessor.from_pretrained()](/docs/transformers/main/id/model_doc/auto#transformers.AutoImageProcessor.from_pretrained) untuk memilih backend. Ketika `backend` diabaikan (default), torchvision akan dipilih jika terpasang, jika tidak, PIL akan digunakan. Beberapa model yang menggunakan interpolasi Lanczos (Chameleon, Flava, Idefics3, SmolVLM) adalah pengecualian, dan mereka default ke PIL ketika torchvision < 0.27. Memaksa `backend="torchvision"` untuk model-model ini pada torchvision < 0.27 akan kembali ke interpolasi BICUBIC, karena torchvision mendukung Lanczos untuk tensor hanya mulai dari 0.27 ke atas.

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

Saat menggunakan backend torchvision, Anda dapat mengatur argumen `device` untuk menentukan perangkat tempat pemrosesan dilakukan. Secara default, pemrosesan dilakukan pada perangkat yang sama dengan input jika input berupa tensor, atau pada CPU jika tidak.

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

Berikut adalah beberapa perbandingan kecepatan antara backend torchvision dan PIL untuk model `DETR` dan `RT-DETR`, serta dampaknya terhadap waktu inferensi keseluruhan:

  

  

  

  

Benchmark ini dijalankan pada [instans AWS EC2 g5.2xlarge](https://aws.amazon.com/ec2/instance-types/g5/), menggunakan GPU NVIDIA A10G Tensor Core.

## ImageProcessingMixin[[transformers.ImageProcessingMixin]]

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_base.py#L61)

Ini adalah mixin pemroses gambar yang digunakan untuk menyediakan fungsionalitas penyimpanan/pemuatan untuk ekstraktor fitur sekuensial dan gambar.

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_base.py#L84)

**Parameter:**

pretrained_model_name_or_path (`str` or `os.PathLike`) : This can be either:  - a string, the *model id* of a pretrained image_processor hosted inside a model repo on huggingface.co. - a path to a *directory* containing a image processor file saved using the [save_pretrained()](/docs/transformers/main/id/internal/image_processing_utils#transformers.ImageProcessingMixin.save_pretrained) method, e.g., `./my_model_directory/`. - a path to a saved image processor JSON *file*, e.g., `./my_model_directory/preprocessor_config.json`.

cache_dir (`str` atau `os.PathLike`, *opsional*) : Path ke direktori tempat image processor model pretrained yang diunduh harus di-cache jika cache standar tidak digunakan.

force_download (`bool`, *opsional*, default `False`) : Apakah akan memaksa untuk (mengunduh ulang) file image processor dan menimpa versi yang sudah di-cache jika ada.

proxies (`dict[str, str]`, *opsional*) : Kamus server proxy yang digunakan berdasarkan protokol atau endpoint, misalnya `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}.` Proxy digunakan pada setiap permintaan.

token (`str` atau `bool`, *opsional*) : Token yang digunakan sebagai otorisasi bearer HTTP untuk file jarak jauh. Jika `True`, atau tidak ditentukan, akan menggunakan token yang dihasilkan saat menjalankan `hf auth login` (disimpan di `~/.huggingface`).

revision (`str`, *opsional*, defaultnya `"main"`) : Versi model spesifik yang akan digunakan. Bisa berupa nama branch, nama tag, atau id commit, karena kami menggunakan sistem berbasis git untuk menyimpan model dan artefak lainnya di huggingface.co, sehingga `revision` dapat berupa identifikasi apa pun yang diizinkan oleh git.     Untuk menguji pull request yang Anda buat di Hub, Anda dapat meneruskan `revision="refs/pr/<pr_number>"`.

return_unused_kwargs (`bool`, *opsional*, default `False`) : Jika `False`, fungsi ini hanya mengembalikan objek image processor akhir. Jika `True`, fungsi ini mengembalikan `Tuple(image_processor, unused_kwargs)` di mana *unused_kwargs* adalah kamus yang terdiri dari pasangan kunci/nilai yang kuncinya bukan atribut image processor: yaitu, bagian dari `kwargs` yang tidak digunakan untuk memperbarui `image_processor` dan diabaikan.

subfolder (`str`, *opsional*, default `""`) : Jika file yang relevan berada di dalam subfolder dari repo model di huggingface.co, Anda dapat menentukan nama folder di sini.

kwargs (`dict[str, Any]`, *opsional*) : Nilai dalam kwargs untuk kunci apa pun yang merupakan atribut image processor akan digunakan untuk menimpa nilai yang dimuat. Perilaku terkait pasangan kunci/nilai yang kuncinya *bukan* atribut image processor dikendalikan oleh parameter kata kunci `return_unused_kwargs`.

**Mengembalikan:**

Pemroses gambar bertipe [ImageProcessingMixin](/docs/transformers/main/id/internal/image_processing_utils#transformers.ImageProcessingMixin).

Instansiasi tipe [ImageProcessingMixin](/docs/transformers/main/id/internal/image_processing_utils#transformers.ImageProcessingMixin) dari image processor.

Contoh:

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_base.py#L190)

**Parameter:**

save_directory (`str` atau `os.PathLike`) : Direktori tempat file JSON image processor akan disimpan (akan dibuat jika belum ada).

push_to_hub (`bool`, *opsional*, default `False`) : Apakah model akan didorong ke Hugging Face model hub setelah disimpan. Anda dapat menentukan repositori tujuan dengan `repo_id` (defaultnya adalah nama `save_directory` di namespace Anda).

kwargs (`dict[str, Any]`, *opsional*) : Argumen kata kunci tambahan yang diteruskan ke metode [push_to_hub()](/docs/transformers/main/id/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Simpan objek image processor ke direktori `save_directory` agar dapat dimuat ulang menggunakan metode kelas [from_pretrained()](/docs/transformers/main/id/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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/feature_extraction_utils.py#L58)

**Parameter:**

data (`dict`, *opsional*) : Kamus berisi daftar/array/tensor yang dikembalikan oleh metode __call__/pad ('input_values', 'attention_mask', dll.).

tensor_type (`Union[None, str, TensorType]`, *opsional*) : Anda dapat memberikan tensor_type di sini untuk mengonversi daftar integer menjadi Tensor PyTorch/Numpy saat inisialisasi.

skip_tensor_conversion (`list[str]` atau `set[str]`, *opsional*) : Daftar atau himpunan kunci yang TIDAK boleh dikonversi menjadi tensor, bahkan ketika `tensor_type` ditentukan.

Menyimpan output dari metode [pad()](/docs/transformers/main/id/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) dan `__call__` spesifik feature extractor.

Kelas ini diturunkan dari kamus python dan dapat digunakan sebagai kamus.

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/feature_extraction_utils.py#L158)

**Parameter:**

tensor_type (`str` atau [TensorType](/docs/transformers/main/id/internal/file_utils#transformers.TensorType), *opsional*) : Jenis tensor yang akan digunakan. Jika `str`, harus salah satu nilai dari enum [TensorType](/docs/transformers/main/id/internal/file_utils#transformers.TensorType). Jika `None`, tidak ada modifikasi yang dilakukan.

skip_tensor_conversion (`list[str]` atau `set[str]`, *opsional*) : Daftar atau himpunan kunci yang TIDAK boleh dikonversi menjadi tensor, bahkan ketika `tensor_type` ditentukan.

Konversi konten internal menjadi tensor.

Catatan: Nilai yang tidak memiliki struktur seperti array (misalnya, string, dict, daftar string) akan dilewati secara otomatis dan tidak akan dikonversi menjadi tensor. Array yang tidak beraturan (daftar array dengan panjang berbeda) tetap akan dicoba, meskipun mungkin akan memicu error selama konversi.

#### ke[[transformers.BatchFeature.to]]

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/feature_extraction_utils.py#L215)

**Parameter:**

args (`Tuple`) : Akan diteruskan ke fungsi `to(...)` dari tensor.

kwargs (`Dict`, *opsional*) : Akan diteruskan ke fungsi `to(...)` dari tensor. Untuk mengaktifkan transfer data asinkron, setel flag `non_blocking` di `kwargs` (defaultnya `False`).

**Mengembalikan:** [BatchFeature](/docs/transformers/main/id/main_classes/feature_extractor#transformers.BatchFeature)

Instans yang sama setelah dimodifikasi.

Kirim semua nilai ke perangkat dengan memanggil `v.to(*args, **kwargs)` (hanya PyTorch). Ini harus mendukung casting ke `dtypes` yang berbeda dan mengirim `BatchFeature` ke `device` yang berbeda.

## BaseImageProcessor[[transformers.BaseImageProcessor]]

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L60)

Kelas dasar untuk pemroses gambar dengan arsitektur backend berbasis pewarisan.

Kelas ini mendefinisikan pipeline pra-pemrosesan: validasi kwargs, persiapan input, dan pendelegasian ke metode `_preprocess` backend. Subkelas backend (`TorchvisionBackend`, `PilBackend`) mewarisi dari kelas ini dan mengimplementasikan operasi gambar yang sebenarnya (resize, crop, rescale, normalize, dll.). Image processor yang spesifik untuk model kemudian mewarisi dari kelas backend yang sesuai.

Ikhtisar Arsitektur ---------------------

Hierarki kelasnya adalah:

BaseImageProcessor (kelas ini) ├── TorchvisionBackend    (dipercepat GPU, torch.Tensor) │   └── ModelImageProcessor (mis. LlavaNextImageProcessor) └── PilBackend            (CPU portabel, np.ndarray) └── ModelImageProcessorPil (mis. CLIPImageProcessorPil)

Alur pra-pemrosesan adalah:

__call__() → preprocess() → _preprocess_image_like_inputs() → _prepare_image_like_inputs() (memanggil process_image untuk setiap gambar) → _preprocess() (operasi batch: resize, crop, dll.)

- `process_image`: Diimplementasikan oleh backend. Mengonversi satu input mentah (PIL, NumPy, atau Tensor) ke format kerja backend (torch.Tensor atau np.ndarray), menangani konversi RGB dan pengurutan ulang channel.
- `_preprocess`: Diimplementasikan oleh backend. Melakukan pemrosesan batch yang sebenarnya (resize, center crop, rescale, normalize, pad) dan mengembalikan `BatchFeature`.

Implementasi Dasar --------------------

Untuk prosesor yang hanya memerlukan operasi standar (resize, center crop, rescale, normalize), warisi dari backend dan definisikan atribut kelas:

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

Metode `_preprocess` di backend menangani pipeline standar secara otomatis.

Pemrosesan Kustom -----------------

Untuk prosesor yang memerlukan logika khusus (misalnya, pemrosesan berbasis patch, beberapa jenis input), override `_preprocess` di prosesor spesifik model Anda. Metode `_preprocess` menerima gambar yang sudah disiapkan (dikonversi ke format backend dengan urutan channel-first) dan melakukan pemrosesan sebenarnya:

class MyImageProcessor(TorchvisionBackend): def _preprocess(self, images, do_resize, size, do_normalize, image_mean, image_std, **kwargs):
# Kelompokkan gambar berdasarkan bentuk untuk operasi batch yang efisien
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})

Untuk prosesor yang menangani beberapa jenis input (misalnya, gambar + peta segmentasi), timpa `_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

Memperluas Perilaku Backend --------------------------

Untuk menyesuaikan operasi untuk backend tertentu, turunkan kelas dari backend tersebut dan timpa metodenya:

from transformers.image_processing_backends import TorchvisionBackend, PilBackend

class MyTorchvisionProcessor(TorchvisionBackend): def resize(self, image, size, **kwargs):
# Logika resize kustom untuk torchvision
return super().resize(image, size, **kwargs)

class MyPilProcessor(PilBackend): def resize(self, image, size, **kwargs):
# Logika resize kustom untuk PIL
return super().resize(image, size, **kwargs)

Parameter Kustom -----------------

Untuk menambahkan parameter di luar `ImagesKwargs`, buat kelas kwargs kustom dan atur sebagai `valid_kwargs`:

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

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

Catatan Utama ---------

- Pemilihan backend dilakukan pada level kelas: warisi dari `TorchvisionBackend` atau `PilBackend`
- Backends menerima gambar sebagai `torch.Tensor` (Torchvision) atau `np.ndarray` (PIL), selalu dengan urutan channel di depan
- Semua gambar memiliki dimensi channel di depan selama pemrosesan, terlepas dari backend
- Argumen yang tidak disediakan oleh pengguna secara default menggunakan nilai atribut kelas
- Kelas backend mengenkapsulasi logika yang spesifik untuk backend (resize, normalize, dll.) dan dapat ditimpa

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L500)

**Parameter:**

image (`np.ndarray`) : Gambar yang akan dipotong di tengah.

size (`dict[str, int]`) : Ukuran gambar keluaran.

data_format (`str` atau `ChannelDimension`, *opsional*) : Format dimensi channel untuk gambar keluaran. Jika tidak disetel, format dimensi channel dari gambar masukan akan digunakan. Dapat berupa salah satu dari: - `"channels_first"` atau `ChannelDimension.FIRST`: gambar dalam format (num_channels, height, width). - `"channels_last"` atau `ChannelDimension.LAST`: gambar dalam format (height, width, num_channels).

input_data_format (`ChannelDimension` atau `str`, *opsional*) : Format dimensi channel untuk gambar input. Jika tidak disetel, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari: - `"channels_first"` atau `ChannelDimension.FIRST`: gambar dalam format (num_channels, height, width). - `"channels_last"` atau `ChannelDimension.LAST`: gambar dalam format (height, width, num_channels).

Potong tengah (center crop) sebuah gambar menjadi `(size["height"], size["width"])`. Jika ukuran input lebih kecil dari `crop_size` pada salah satu tepinya, gambar akan di-pad dengan 0 dan kemudian dipotong di tengah.

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L463)

**Parameter:**

image (`np.ndarray`) : Gambar yang akan dinormalisasi.

mean (`float` atau `Iterable[float]`) : Rata-rata gambar yang digunakan untuk normalisasi.

std (`float` atau `Iterable[float]`) : Standar deviasi gambar yang akan digunakan untuk normalisasi.

data_format (`str` atau `ChannelDimension`, *opsional*) : Format dimensi channel untuk gambar keluaran. Jika tidak disetel, format dimensi channel dari gambar masukan akan digunakan. Dapat berupa salah satu dari: - `"channels_first"` atau `ChannelDimension.FIRST`: gambar dalam format (num_channels, height, width). - `"channels_last"` atau `ChannelDimension.LAST`: gambar dalam format (height, width, num_channels).

input_data_format (`ChannelDimension` atau `str`, *opsional*) : Format dimensi channel untuk gambar input. Jika tidak disetel, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari: - `"channels_first"` atau `ChannelDimension.FIRST`: gambar dalam format (num_channels, height, width). - `"channels_last"` atau `ChannelDimension.LAST`: gambar dalam format (height, width, num_channels).

**Mengembalikan:** `np.ndarray`

Gambar yang dinormalisasi.

Normalisasi sebuah gambar. 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'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L382)

**Parameter:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Gambar yang akan dipreprocess. Mengharapkan satu gambar atau batch gambar dengan nilai piksel berkisar dari 0 hingga 255. Jika memasukkan gambar dengan nilai piksel antara 0 dan 1, atur `do_rescale=False`.

image_like_kwargs (`dict[str, Any]`, *opsional*) : Flag pengembang untuk input tambahan yang mirip gambar yang juga akan dipreprocess. Gunakan ini hanya jika meneruskan input sebagai kwarg tidak berhasil. Misalnya, `preprocess(images, masks=masks)` adalah pilihan yang disarankan, tetapi dapat menyebabkan masalah prioritas argumen pada beberapa model. Dalam kasus tersebut, `preprocess(images, image_like_inputs={"masks": masks})` dapat digunakan sebagai gantinya.

do_convert_rgb (`bool`, *kwargs*, *opsional*) : Apakah akan mengkonversi gambar ke RGB.

do_resize (`bool`, *kwargs*, *opsional*) : Apakah akan mengubah ukuran gambar.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Menjelaskan dimensi input maksimum ke model.

default_to_square (`bool`, *kwargs*, *opsional*) : Apakah secara default menggunakan gambar persegi saat mengubah ukuran, jika size berupa int.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran gambar keluaran setelah menerapkan `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filter resampling yang digunakan saat mengubah ukuran gambar. Nilai ini dapat berupa salah satu enum `PILImageResampling`. Hanya berpengaruh jika `do_resize` diatur ke `True`.

do_rescale (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan penskalaan ulang pada gambar.

rescale_factor (`float`, *kwargs*, *opsional*) : Faktor penskalaan ulang untuk menskalakan ulang gambar jika `do_rescale` diatur ke `True`.

do_normalize (`bool`, *kwargs*, *opsional*) : Apakah akan menormalisasi gambar.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*) : Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*) : Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`.

do_pad (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan padding pada gambar. Padding dilakukan hingga ukuran terbesar dalam batch atau hingga ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran dalam `{"height": int, "width" int}` untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang diberikan untuk pra-pemrosesan. Jika `pad_size` tidak diberikan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketika `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan center crop pada gambar.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Hanya `ChannelDimension.FIRST` yang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Format dimensi channel untuk gambar input. Jika tidak disetel, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari: - `"channels_first"` atau `ChannelDimension.FIRST`: gambar dalam format (num_channels, height, width). - `"channels_last"` atau `ChannelDimension.LAST`: gambar dalam format (height, width, num_channels). - `"none"` atau `ChannelDimension.NONE`: gambar dalam format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Mengembalikan tensor yang ditumpuk jika disetel ke `'pt'`, selain itu mengembalikan daftar tensor.

disable_grouping (`bool`, *kwargs*, *opsional*) : Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan tidak dalam batch. Jika None, akan diset ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opsional*) : Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini sebaiknya diatur sebagai atribut prosesor pada model-model mendatang.

**Mengembalikan:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Dictionary berisi list/array/tensor yang dikembalikan oleh metode __call__ ('pixel_values', dll.).
- **tensor_type** (`Union[None, str, TensorType]`, *opsional*) -- Anda dapat memberikan tensor_type di sini untuk mengonversi daftar bilangan bulat menjadi Tensor PyTorch/Numpy saat inisialisasi.

Praproses sebuah gambar atau kumpulan gambar.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L219)

Proses satu gambar mentah ke dalam format kerja backend.

Diimplementasikan oleh subkelas backend (`TorchvisionBackend`, `PilBackend`). Mengonversi input mentah (PIL Image, array NumPy, atau torch Tensor) ke format internal backend (`torch.Tensor` untuk Torchvision, `np.ndarray` untuk PIL), menangani konversi RGB, dan memastikan urutan channels-first.

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L430)

**Parameter:**

image (`np.ndarray`) : Gambar yang akan diskalakan ulang.

scale (`float`) : Faktor penskalaan untuk menskalakan ulang nilai piksel.

data_format (`str` atau `ChannelDimension`, *opsional*) : Format dimensi channel untuk gambar keluaran. Jika tidak disetel, format dimensi channel dari gambar masukan akan digunakan. Dapat berupa salah satu dari: - `"channels_first"` atau `ChannelDimension.FIRST`: gambar dalam format (num_channels, height, width). - `"channels_last"` atau `ChannelDimension.LAST`: gambar dalam format (height, width, num_channels).

input_data_format (`ChannelDimension` atau `str`, *opsional*) : Format dimensi channel untuk gambar input. Jika tidak disetel, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari: - `"channels_first"` atau `ChannelDimension.FIRST`: gambar dalam format (num_channels, height, width). - `"channels_last"` atau `ChannelDimension.LAST`: gambar dalam format (height, width, num_channels).

**Mengembalikan:** `np.ndarray`

Gambar yang telah diskalakan ulang.

Skala ulang gambar dengan faktor skala. image = image * scale.

## TorchvisionBackend[[transformers.TorchvisionBackend]]

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L86)

Backend Torchvision untuk pemrosesan gambar batch yang dipercepat GPU.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L367)

Center crop sebuah gambar menggunakan 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L156)

Mengonversi gambar ke format RGB.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L100)

Konversi satu atau daftar URL / path menjadi objek `torch.Tensor`.

Objek gambar yang sudah valid (tensor, array numpy, PIL Images) diteruskan tanpa perubahan, sehingga pemanggil yang memuat gambar sebelumnya tidak terpengaruh.

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L313)

Normalisasi gambar menggunakan 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L180)

Pad gambar menggunakan Torchvision dengan operasi batched.

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L116)

Memproses satu gambar untuk backend torchvision.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L304)

Skala ulang gambar dengan faktor skala menggunakan 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])
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L341)

Skala ulang dan normalisasi gambar menggunakan Torchvision (digabungkan untuk efisiensi).

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L230)

Ukurkan ulang gambar menggunakan Torchvision.

## PilBackend[[transformers.PilBackend]]

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L444)

Backend PIL/NumPy untuk pemrosesan gambar CPU-only yang portabel.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L635)

Center crop sebuah gambar menggunakan 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L495)

Mengonversi gambar ke format RGB.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L619)

Normalisasi gambar menggunakan 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)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L503)

Pad gambar ke ukuran yang ditentukan menggunakan 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'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L458)

Proses satu gambar untuk backend PIL.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L605)

Skala ulang gambar dengan faktor skala menggunakan NumPy.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_backends.py#L554)

Ukurkan ulang gambar menggunakan PIL/NumPy.