Hugging Face's logo

Transformers documentation

Pemroses gambar

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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 — kelas dasar abstrak (hanya untuk kompatibilitas mundur; jangan instansiasi secara langsung)
    • TorchvisionBackend — backend default yang didukung torchvision. Dipercepat dengan GPU dan jauh lebih cepat daripada backend PIL. Semua model mengekspos kelas <Model>ImageProcessor yang mewarisi darinya.
    • 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").

Lewati backend ke AutoImageProcessor.from_pretrained() untuk memilih backend. Ketika backend diabaikan (default), torchvision dipilih jika terinstal, jika tidak PIL yang 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.

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.

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, menggunakan GPU NVIDIA A10G Tensor Core.

ImageProcessingMixin

kelas transformers.ImageProcessingMixin

< >

( **kwargs )

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

from_pretrained

< >

( pretrained_model_name_or_path: str | os.PathLikecache_dir: str | os.PathLike | None = Noneforce_download: bool = Falselocal_files_only: bool = Falsetoken: str | bool | None = Nonerevision: str = 'main'**kwargs )

Parameter

  • pretrained_model_name_or_path (str atau os.PathLike) — Ini bisa berupa:
    • sebuah string, model id dari image_processor pretrained yang dihosting di dalam repo model di huggingface.co.
    • path ke direktori yang berisi file image processor yang disimpan menggunakan metode save_pretrained(), misalnya ./my_model_directory/.
    • path ke file JSON image processor yang disimpan file, misalnya ./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 (mengunduh ulang) file image processor dan menimpa versi yang sudah di-cache jika ada.
  • proxies (dict[str, str], opsional) — Kamus server proxy untuk 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, default "main") — Versi model spesifik yang akan digunakan. Bisa berupa nama branch, nama tag, atau commit id, 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.

Instansiasi tipe ImageProcessingMixin dari image processor.

Contoh:

# 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

< >

( save_directory: str | os.PathLikepush_to_hub: bool = False**kwargs )

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 Anda akan didorong ke Hugging Face model hub setelah disimpan. Anda dapat menentukan repository yang ingin Anda tuju 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().

Simpan objek image processor ke direktori save_directory agar dapat dimuat ulang menggunakan metode kelas from_pretrained().

BatchFeature

kelas transformers.BatchFeature

< >

( data: dict[str, typing.Any] | None = Nonetensor_type: None | str | transformers.utils.generic.TensorType = Noneskip_tensor_conversion: list[str] | set[str] | None = None )

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 bilangan bulat menjadi Tensor PyTorch/Numpy saat inisialisasi.
  • skip_tensor_conversion (list[str] atau set[str], opsional) — Daftar atau set kunci yang TIDAK boleh dikonversi menjadi tensor, bahkan ketika tensor_type ditentukan.

Menyimpan output dari metode pad() dan __call__ spesifik feature extractor.

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

convert_to_tensors

< >

( tensor_type: str | transformers.utils.generic.TensorType | None = Noneskip_tensor_conversion: list[str] | set[str] | None = None )

Parameter

  • tensor_type (str atau TensorType, opsional) — Jenis tensor yang akan digunakan. Jika str, harus salah satu nilai dari enum TensorType. Jika None, tidak ada modifikasi yang dilakukan.
  • skip_tensor_conversion (list[str] atau set[str], opsional) — Daftar atau set kunci yang TIDAK boleh dikonversi menjadi tensor, bahkan ketika tensor_type ditentukan.

Konversi konten internal menjadi tensor.

Note: 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 menimbulkan error selama konversi.

ke

< >

( *args**kwargs ) → BatchFeature

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

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

kelas transformers.BaseImageProcessor

< >

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

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.). Prosesor gambar spesifik 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 per 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 backend menangani pipeline standar secara otomatis.

Pemrosesan Kustom

Untuk prosesor yang memerlukan logika khusus (misalnya, pemrosesan berbasis patch, beberapa jenis input), timpa _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 # nilai default

Catatan Penting

  • 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

< >

( image: ndarraysize: dictdata_format: str | transformers.image_utils.ChannelDimension | None = Noneinput_data_format: str | transformers.image_utils.ChannelDimension | None = None**kwargs )

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 output. Jika tidak disetel, format dimensi channel dari gambar input akan digunakan. 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).
  • 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).

Pusatkan pemotongan gambar ke (size["height"], size["width"]). Jika ukuran input lebih kecil dari crop_size di sepanjang salah satu tepi, gambar akan ditambahkan padding dengan 0 dan kemudian dipotong di tengah.

normalize

< >

( image: ndarraymean: float | collections.abc.Iterable[float]std: float | collections.abc.Iterable[float]data_format: str | transformers.image_utils.ChannelDimension | None = Noneinput_data_format: str | transformers.image_utils.ChannelDimension | None = None**kwargs ) → np.ndarray

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]) — Deviasi standar gambar yang digunakan untuk normalisasi.
  • data_format (str atau ChannelDimension, opsional) — Format dimensi channel untuk gambar output. Jika tidak disetel, format dimensi channel dari gambar input akan digunakan. 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).
  • 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.

praproses

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]*argsimage_like_kwargs: dict[str, typing.Any] | None = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> ) → ~image_processing_base.BatchFeature

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 mengirimkan 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 melewati input sebagai kwarg tidak berhasil. Misalnya, preprocess(images, masks=masks) adalah opsi yang lebih disukai, tetapi menyebabkan masalah prioritas argumen untuk beberapa model. Dalam kasus tersebut, preprocess(images, image_like_inputs={"masks": masks}) dapat digunakan sebagai gantinya.
  • do_convert_rgb (bool, kwargs, opsional) — Apakah akan mengonversi 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) — Menggambarkan dimensi input maksimum untuk model.
  • default_to_square (bool, kwargs, opsional) — Apakah akan menggunakan gambar persegi sebagai default 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 jika mengubah ukuran gambar. 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 rescale 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 ke ukuran terbesar dalam batch atau ke 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 disediakan untuk pra-pemrosesan. Jika pad_size tidak disediakan, 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 diset, 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 bertumpuk jika diset ke 'pt', selain itu mengembalikan daftar tensor.
  • disable_grouping (bool, kwargs, opsional) — Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan bukan dalam batch. Jika None, akan diatur 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 seharusnya diatur sebagai atribut prosesor pada model-model mendatang.

Mengembalikan

~image_processing_base.BatchFeature

  • data (dict) — Kamus berisi daftar/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

< >

( *args**kwargs )

Memproses 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 channel-first.

rescale

< >

( image: ndarrayscale: floatdata_format: str | transformers.image_utils.ChannelDimension | None = Noneinput_data_format: str | transformers.image_utils.ChannelDimension | None = None**kwargs ) → np.ndarray

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 output. Jika tidak disetel, format dimensi channel dari gambar input akan digunakan. 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).
  • 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

kelas transformers.TorchvisionBackend

< >

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

Backend Torchvision untuk pemrosesan gambar batch yang dipercepat GPU.

center_crop

< >

( image: torch.Tensorsize: SizeDict**kwargs )

Center crop sebuah gambar menggunakan Torchvision.

convert_to_rgb

< >

( image: torch.Tensorinput_data_format: str | transformers.image_utils.ChannelDimension | None = None )

Mengonversi gambar ke format RGB.

fetch_images

< >

( image_url_or_urls: str | list[str] | list[list[str]] )

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

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

normalize

< >

( image: torch.Tensormean: float | collections.abc.Iterable[float]std: float | collections.abc.Iterable[float]inplace: bool = False**kwargs )

Normalisasi gambar menggunakan Torchvision.

pad

< >

( images: listpad_size: SizeDict = Nonefill_value: int | None = 0padding_mode: str | None = 'constant'return_mask: bool = Falsedisable_grouping: bool | None = Falseis_nested: bool | None = False**kwargs )

Pad gambar menggunakan Torchvision dengan operasi batched.

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 = Noneinput_data_format: str | transformers.image_utils.ChannelDimension | None = Nonedevice: typing.Optional[ForwardRef('torch.device')] = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )

Memproses satu gambar untuk backend torchvision.

rescale

< >

( image: torch.Tensorscale: float**kwargs )

Skala ulang gambar dengan faktor skala menggunakan Torchvision.

rescale_and_normalize

< >

( images: torch.Tensordo_rescale: boolrescale_factor: floatdo_normalize: boolimage_mean: float | list[float]image_std: float | list[float] )

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

resize

< >

( image: torch.Tensorsize: SizeDictresample: PILImageResampling | tvF.InterpolationMode | int | None = Noneantialias: bool = True**kwargs )

Ukurkan ulang gambar menggunakan Torchvision.

PilBackend

kelas transformers.PilBackend

< >

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

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

center_crop

< >

( image: ndarraysize: SizeDict**kwargs )

Center crop sebuah gambar menggunakan NumPy.

convert_to_rgb

< >

( image: ndarrayinput_data_format: str | transformers.image_utils.ChannelDimension | None = None )

Mengonversi gambar ke format RGB.

normalize

< >

( image: ndarraymean: float | collections.abc.Iterable[float]std: float | collections.abc.Iterable[float]**kwargs )

Normalisasi gambar menggunakan NumPy.

pad

< >

( images: listpad_size: SizeDict = Nonefill_value: int | None = 0padding_mode: str | None = 'constant'return_mask: bool = False**kwargs )

Pad gambar ke ukuran yang ditentukan menggunakan NumPy.

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 = Noneinput_data_format: str | transformers.image_utils.ChannelDimension | None = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )

Proses satu gambar untuk backend PIL.

rescale

< >

( image: ndarrayscale: float**kwargs )

Skala ulang gambar dengan faktor skala menggunakan NumPy.

resize

< >

( image: ndarraysize: SizeDictresample: PILImageResampling | None = Nonereducing_gap: int | None = None**kwargs )

Ukurkan ulang gambar menggunakan PIL/NumPy.

Update on GitHub

←Ekstraktor fitur Pemroses video→