Transformers documentation

SigLIP2

Transformers

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

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Model ini dipublikasikan di HF papers pada 2025-02-20 dan disumbangkan ke Hugging Face Transformers pada 2025-02-21.

SigLIP2

Ikhtisar

SigLIP2 adalah keluarga encoder vision-language multibahasa yang dibangun di atas resep pelatihan SigLIP. Model ini mencakup pretraining berbasis decoder, self-distillation, dan prediksi ter-mask untuk meningkatkan tugas prediksi padat (segmentasi, estimasi kedalaman, dll.). Model ini tersedia dalam dua varian:

NaFlex mendukung resolusi yang berbeda dan mempertahankan rasio aspek asli gambar
FixRes mendukung resolusi tetap dan kompatibel mundur dengan SigLIP

Anda dapat menemukan semua checkpoint SigLIP2 asli di bawah koleksi SigLIP2.

Klik pada model SigLIP2 di bilah sisi kanan untuk melihat lebih banyak contoh cara menerapkan SigLIP2 ke berbagai tugas gambar dan teks.

Contoh di bawah ini mendemonstrasikan klasifikasi zero-shot dengan Pipeline atau kelas AutoModel.

Pipeline

AutoModel (FixRes)

AutoModel (NaFlex)

Quantization mengurangi beban memori model besar dengan merepresentasikan bobot dalam presisi yang lebih rendah. Lihat ringkasan Quantization untuk backend quantization lain yang tersedia.

Contoh di bawah menggunakan bitsandbytes untuk hanya mengkuantisasi bobot ke int4.

import requests
import torch
from PIL import Image

from transformers import AutoModel, AutoProcessor, BitsAndBytesConfig


bnb_config = BitsAndBytesConfig(load_in_4bit=True)
model = AutoModel.from_pretrained("google/siglip2-base-patch16-224", quantization_config=bnb_config, device_map="auto", attn_implementation="sdpa")
processor = AutoProcessor.from_pretrained("google/siglip2-base-patch16-224")

url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
image = Image.open(requests.get(url, stream=True).raw)
candidate_labels = ["a Pallas cat", "a lion", "a Siberian tiger"]

# follows the pipeline prompt template to get same results
texts = [f'This is a photo of {label}.' for label in candidate_labels]

# IMPORTANT: we pass `padding=max_length` and `max_length=64` since the model was trained with this
inputs = processor(text=texts, images=image, padding="max_length", max_length=64, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs)

logits_per_image = outputs.logits_per_image
probs = torch.sigmoid(logits_per_image)
print(f"{probs[0][0]:.1%} that image 0 is '{candidate_labels[0]}'")

Embedding teks dan pengambilan

SigLIP2 dapat digunakan untuk menghasilkan embedding teks untuk tugas pencarian atau tugas berbasis kemiripan (misalnya, pencarian produk atau caption).

Untuk hasil terbaik, prapemrosesan teks yang sama yang digunakan selama pelatihan harus diterapkan. Saat memuat checkpoint SigLIP2 melalui [AutoProcessor], prapemrosesan ini ditangani secara otomatis oleh processor.

Prapemrosesan teks bawaan (ditangani secara otomatis)

Untuk model SigLIP2, prosesor menerapkan nilai bawaan berikut untuk input teks:

Menyebutuhkan huruf kecil untuk semua teks input
Padding dan pemotongan tetap: padding="max_length", max_length=64, truncation=True

Nilai default ini memastikan embedding teks yang konsisten dan benar. Mengubahnya dapat menyebabkan penurunan kualitas pencarian.

Contoh: menghitung embedding teks

import torch

from transformers import AutoModel, AutoProcessor


model_id = "google/siglip2-so400m-patch14-384"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModel.from_pretrained(model_id, device_map="auto").eval()

texts = [
    "HOME084 Timbangan Badan Digital Kaca Transparan 28CM Body Scale Personal Scale",
    "26cm Timbangan Badan digital personal scale weight",
    "33cm Timbangan Badan digital personal scale weight",
]

# NOTE: lowercasing and padding/truncation to length 64 are applied automatically by the processor pipeline.
inputs = processor(text=texts, return_tensors="pt").to(model.device)

with torch.no_grad():
    text_features = model.get_text_features(**inputs)

# Normalize embeddings for cosine similarity
text_features = text_features / text_features.norm(p=2, dim=-1, keepdim=True)

Penggunaan hanya teks: Siglip2Tokenizer

Jika Anda mengkodekan teks tanpa processor (misalnya, melalui AutoTokenizer), gunakan Siglip2Tokenizer.

Siglip2Tokenizer menerapkan lowercasing pada level backend tokenizer (sesuai dengan normalisasi saat pelatihan SigLIP2), sambil mempertahankan tokenisasi yang sama dengan tokenizer asli.
Saat menggunakan tokenizer secara langsung, Anda harus secara eksplisit menerapkan pengaturan padding/truncation yang sama seperti yang digunakan selama pelatihan (misalnya max_length=64):

from transformers import Siglip2Tokenizer


model_id = "google/siglip2-so400m-patch14-384"
tokenizer = Siglip2Tokenizer.from_pretrained(model_id)

inputs = tokenizer(
    ["HELLO WORLD"],
    padding="max_length",
    truncation=True,
    max_length=64,
    return_tensors="pt",
)

Catatan

Pelatihan didukung untuk DDP dan FSDP pada setup multi-akselerator single-node. Namun, hal ini tidak menggunakan utilitas torch.distributed yang dapat membatasi skalabilitas ukuran batch.
Saat menggunakan GemmaTokenizerFast yang berdiri sendiri, pastikan untuk meneruskan padding="max_length" dan max_length=64 karena itulah cara model tersebut dilatih.
Model dilatih dengan teks lowercased, jadi pastikan label teks Anda dipreprocess dengan cara yang sama.
Untuk mendapatkan hasil yang sama seperti Pipeline, template prompt "This is a photo of {label}." harus diteruskan ke processor.
Varian NaFlex memproses berbagai jenis gambar pada resolusi yang sesuai (misalnya, menggunakan resolusi yang lebih besar untuk memproses gambar dokumen), sambil juga meminimalkan dampak distorsi rasio aspek untuk tugas inferensi tertentu seperti OCR.

NaFlex mengubah ukuran gambar input sehingga tinggi dan lebarnya menjadi kelipatan dari ukuran patch setelah pengubahan ukuran. Distorsi rasio aspek dijaga serendah mungkin dan menghasilkan panjang urutan yang paling banyak sama dengan panjang urutan target yang diinginkan (max_num_patches). Setelah pengubahan ukuran, gambar dipecah menjadi urutan patch dan ditambahkan mask yang berisi informasi padding.

Ubah parameter attn_implementation menjadi "sdpa" atau "flash_attention_2" untuk menggunakan perhatian yang lebih hemat memori.

# pip install -U flash-attn --no-build-isolation

from transformers import Siglip2Model

model = Siglip2Model.from_pretrained(
    "google/siglip2-so400m-patch14-384",
    attn_implementation="flash_attention_2",
    device_map="auto",
)

Siglip2Config

kelas transformers.Siglip2Config

< source >

Parameter

text_config (Union[dict, ~configuration_utils.PreTrainedConfig], opsional) — Objek config atau dictionary dari text backbone.
vision_config (Union[dict, ~configuration_utils.PreTrainedConfig], opsional) — Objek config atau dictionary dari vision backbone.
initializer_factor (float, opsional, default 1.0) — Faktor untuk menginisialisasi semua matriks bobot (sebaiknya dipertahankan pada 1, digunakan secara internal untuk pengujian inisialisasi).

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Siglip2Model. Kelas ini digunakan untuk membuat instans model Siglip2 sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari google/siglip2-base-patch16-naflex

Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.

Contoh:

>>> from transformers import Siglip2Config, Siglip2Model

>>> # Initializing a Siglip2Config with google/siglip2-base-patch16-224 style configuration
>>> configuration = Siglip2Config()

>>> # Initializing a Siglip2Model (with random weights) from the google/siglip2-base-patch16-224 style configuration
>>> model = Siglip2Model(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

>>> # We can also initialize a Siglip2Config from a Siglip2TextConfig and a Siglip2VisionConfig
>>> from transformers import Siglip2TextConfig, Siglip2VisionConfig

>>> # Initializing a Siglip2Text and Siglip2Vision configuration
>>> config_text = Siglip2TextConfig()
>>> config_vision = Siglip2VisionConfig()

>>> config = Siglip2Config(text_config=config_text, vision_config=config_vision)

Siglip2TextConfig

kelas transformers.Siglip2TextConfig

< source >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 32000hidden_size: int = 768intermediate_size: int = 3072num_hidden_layers: int = 12num_attention_heads: int = 12max_position_embeddings: int = 64hidden_act: str = 'gelu_pytorch_tanh'layer_norm_eps: float = 1e-06attention_dropout: float | int = 0.0pad_token_id: int | None = 1bos_token_id: int | None = 49406eos_token_id: int | list[int] | None = 49407projection_size: int | None = None )

Parameter

vocab_size (int, opsional, default 32000) — Ukuran kosakata model. Menentukan jumlah token berbeda yang dapat direpresentasikan oleh input_ids.
hidden_size (int, opsional, default 768) — Dimensi dari representasi tersembunyi.
intermediate_size (int, opsional, default 3072) — Dimensi representasi MLP.
num_hidden_layers (int, opsional, default 12) — Jumlah lapisan tersembunyi dalam decoder Transformer.
num_attention_heads (int, opsional, default 12) — Jumlah attention head untuk setiap lapisan attention di decoder Transformer.
max_position_embeddings (int, opsional, default 64) — Panjang maksimum sekuens yang mungkin digunakan dengan model ini.
hidden_act (str, opsional, defaultnya gelu_pytorch_tanh) — Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, "gelu", "relu", "silu", dan sebagainya.
layer_norm_eps (float, opsional, defaultnya 1e-06) — Epsilon yang digunakan oleh lapisan normalisasi lapisan.
attention_dropout (Union[float, int], opsional, default 0.0) — Rasio dropout untuk probabilitas perhatian.
pad_token_id (int, opsional, default 1) — ID token yang digunakan untuk padding dalam kosakata.
bos_token_id (int, opsional, default 49406) — ID token yang digunakan untuk awal aliran (beginning-of-stream) dalam kosakata.
eos_token_id (Union[int, list[int]], opsional, default 49407) — ID token yang digunakan untuk end-of-stream dalam kosakata.
projection_size (int, opsional) — Dimensi dari lapisan proyeksi teks dan visi.

Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.

Contoh:

>>> from transformers import Siglip2TextConfig, Siglip2TextModel

>>> # Initializing a Siglip2TextConfig with google/siglip2-base-patch16-224 style configuration
>>> configuration = Siglip2TextConfig()

>>> # Initializing a Siglip2TextModel (with random weights) from the google/siglip2-base-patch16-224 style configuration
>>> model = Siglip2TextModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

Siglip2VisionConfig

kelas transformers.Siglip2VisionConfig

< source >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 768intermediate_size: int = 3072num_hidden_layers: int = 12num_attention_heads: int = 12num_channels: int = 3patch_size: int | list[int] | tuple[int, int] = 16hidden_act: str = 'gelu_pytorch_tanh'layer_norm_eps: float = 1e-06attention_dropout: float | int = 0.0num_patches: int = 256 )

Parameter

hidden_size (int, opsional, default 768) — Dimensi dari representasi tersembunyi.
intermediate_size (int, opsional, default 3072) — Dimensi representasi MLP.
num_hidden_layers (int, opsional, default 12) — Jumlah lapisan tersembunyi dalam decoder Transformer.
num_attention_heads (int, opsional, default 12) — Jumlah attention head untuk setiap lapisan attention di decoder Transformer.
num_channels (int, opsional, defaultnya 3) — Jumlah saluran input.
patch_size (Union[int, list[int], tuple[int, int]], opsional, defaultnya 16) — Ukuran (resolusi) dari setiap patch.
hidden_act (str, opsional, defaultnya gelu_pytorch_tanh) — Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, "gelu", "relu", "silu", dan sebagainya.
layer_norm_eps (float, opsional, defaultnya 1e-06) — Epsilon yang digunakan oleh lapisan normalisasi lapisan.
attention_dropout (Union[float, int], opsional, default 0.0) — Rasio dropout untuk probabilitas perhatian.
num_patches (int, opsional, default 256) — Jumlah patch pada gambar dengan ukuran (patch_size, patch_size). Gambar di-resize untuk mengisi maksimal jumlah patch ini, sambil mempertahankan rasio aspek. Jika jumlah patch yang dihasilkan lebih rendah, gambar akan di-pad pada dimensi “patch”.

Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.

Contoh:

>>> from transformers import Siglip2VisionConfig, Siglip2VisionModel

>>> # Initializing a Siglip2VisionConfig with google/siglip2-base-patch16-naflex style configuration
>>> configuration = Siglip2VisionConfig()

>>> # Initializing a Siglip2VisionModel (with random weights) from the google/siglip2-base-patch16-naflex style configuration
>>> model = Siglip2VisionModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

Siglip2ImageProcessor

kelas transformers.Siglip2ImageProcessor

< source >

( **kwargs: *<class 'transformers.models.siglip2.image_processing_siglip2.Siglip2ImageProcessorKwargs'> )

Parameter

do_convert_rgb (bool, kwargs, opsional) — Apakah akan mengonversi gambar ke RGB.
do_resize (bool, kwargs, opsional, default True) — 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, defaultnya True) — Apakah akan menggunakan gambar persegi sebagai default saat melakukan resize, 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, defaultnya 2) — Filter resampling yang digunakan jika mengubah ukuran gambar. Ini bisa berupa salah satu enum PILImageResampling. Hanya berpengaruh jika do_resize diatur ke True.
do_rescale (bool, kwargs, opsional, default True) — Apakah akan melakukan penskalaan ulang pada gambar.
rescale_factor (float, kwargs, opsional, default 0.00392156862745098) — Faktor rescale untuk menskalakan ulang gambar jika do_rescale diatur ke True.
do_normalize (bool, kwargs, opsional, default True) — Apakah akan menormalisasi gambar.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opsional, defaultnya [0.5, 0.5, 0.5]) — 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, defaultnya [0.5, 0.5, 0.5]) — 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.
patch_size (int, kwargs, opsional, default self.patch_size) — Ukuran (resolusi) dari setiap patch yang akan digunakan untuk membagi gambar.
max_num_patches (int, kwargs, opsional, default self.max_num_patches) — Gambar akan di-resize agar memiliki jumlah patch paling banyak sebesar nilai ini, lalu di-pad pada dimensi “patch” agar persis sama dengan jumlah tersebut.

Membangun pemroses gambar Siglip2ImageProcessor.

praproses

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]**kwargs: *<class 'transformers.models.siglip2.image_processing_siglip2.Siglip2ImageProcessorKwargs'> ) → ~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.
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.
patch_size (int, kwargs, opsional, default self.patch_size) — Ukuran (resolusi) dari setiap patch yang akan digunakan untuk membagi gambar.
max_num_patches (int, kwargs, opsional, default self.max_num_patches) — Gambar akan di-resize agar memiliki jumlah patch paling banyak sebesar nilai ini, lalu di-pad pada dimensi “patch” agar persis sama dengan jumlah tersebut.

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.

Siglip2ImageProcessorPil

kelas transformers.Siglip2ImageProcessorPil

< source >

( **kwargs: *<class 'transformers.models.siglip2.image_processing_pil_siglip2.Siglip2ImageProcessorKwargs'> )

Parameter

do_convert_rgb (bool, kwargs, opsional) — Apakah akan mengonversi gambar ke RGB.
do_resize (bool, kwargs, opsional, default True) — 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, defaultnya True) — Apakah akan menggunakan gambar persegi sebagai default saat melakukan resize, 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, defaultnya 2) — Filter resampling yang digunakan jika mengubah ukuran gambar. Ini bisa berupa salah satu enum PILImageResampling. Hanya berpengaruh jika do_resize diatur ke True.
do_rescale (bool, kwargs, opsional, default True) — Apakah akan melakukan penskalaan ulang pada gambar.
rescale_factor (float, kwargs, opsional, default 0.00392156862745098) — Faktor rescale untuk menskalakan ulang gambar jika do_rescale diatur ke True.
do_normalize (bool, kwargs, opsional, default True) — Apakah akan menormalisasi gambar.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opsional, defaultnya [0.5, 0.5, 0.5]) — 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, defaultnya [0.5, 0.5, 0.5]) — 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.
patch_size (int, kwargs, opsional, default self.patch_size) — Ukuran (resolusi) dari setiap patch yang akan digunakan untuk membagi gambar.
max_num_patches (int, kwargs, opsional, default self.max_num_patches) — Gambar akan di-resize agar memiliki jumlah patch paling banyak sebesar nilai ini, lalu di-pad pada dimensi “patch” agar persis sama dengan jumlah tersebut.

Membangun pemroses gambar Siglip2ImageProcessor.

praproses

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]**kwargs: *<class 'transformers.models.siglip2.image_processing_pil_siglip2.Siglip2ImageProcessorKwargs'> ) → ~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.
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.
patch_size (int, kwargs, opsional, default self.patch_size) — Ukuran (resolusi) dari setiap patch yang akan digunakan untuk membagi gambar.
max_num_patches (int, kwargs, opsional, default self.max_num_patches) — Gambar akan di-resize agar memiliki jumlah patch paling banyak sebesar nilai ini, lalu di-pad pada dimensi “patch” agar persis sama dengan jumlah tersebut.

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.

Siglip2Processor

kelas transformers.Siglip2Processor

< source >

( image_processortokenizer )

Parameter

image_processor (Siglip2ImageProcessor) — Image processor adalah input yang wajib diisi.
tokenizer (Siglip2Tokenizer) — Tokenizer adalah input yang wajib.

Membangun Siglip2Processor yang membungkus image processor dan tokenizer menjadi satu processor.

Siglip2Processor menyediakan semua fungsionalitas dari Siglip2ImageProcessor dan Siglip2Tokenizer. Lihat ~Siglip2ImageProcessor dan ~Siglip2Tokenizer untuk informasi lebih lanjut.

call

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | list[list[str]] | None = Nonevideos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = Noneaudio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None**kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'> )

Parameter

images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], opsional) — 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.
text (Union[str, list[str], list[list[str]]], opsional) — Sequens atau batch dari sequens yang akan dienkod. Setiap sequens dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika Anda memasukkan input yang sudah dipretokenisasi, atur is_split_into_words=True untuk menghindari ambiguitas dengan input yang di-batch.
videos (Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]], opsional) — Video yang akan dipreprocess. Mengharapkan satu video atau batch video dengan nilai piksel berkisar dari 0 hingga 255. Jika mengirimkan video dengan nilai piksel antara 0 dan 1, atur do_rescale=False.
audio (Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]], opsional) — Audio atau batch audio yang akan disiapkan. Setiap audio dapat berupa array NumPy atau tensor PyTorch. Jika berupa array NumPy/tensor PyTorch, setiap audio harus memiliki bentuk (C, T), di mana C adalah jumlah channel, dan T adalah panjang sampel dari audio tersebut.
return_tensors (str atau TensorType, opsional) — Jika diset, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:
- 'pt': Mengembalikan objek PyTorch torch.Tensor.
- 'np': Mengembalikan objek NumPy np.ndarray.
**kwargs (ProcessingKwargs, opsional) — Opsi pemrosesan tambahan untuk setiap modalitas (teks, gambar, video, audio). Parameter spesifik model tercantum di atas; lihat kelas TypedDict untuk daftar lengkap argumen yang didukung.

Siglip2Model

kelas transformers.Siglip2Model

< source >

( config: Siglip2Config )

Parameter

config (Siglip2Config) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya saja. Lihat metode from_pretrained() untuk memuat bobot model.

Model Siglip2 polos yang menghasilkan hidden-states mentah tanpa head spesifik di atasnya.

Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)

Model ini juga merupakan subclass dari torch.nn.Module PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonepixel_attention_mask: typing.Optional[torch.Tensor] = Nonespatial_shapes: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonereturn_loss: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Siglip2Output or tuple(torch.Tensor)

Parameter

input_ids (torch.LongTensor dengan bentuk (batch_size, sequence_length), opsional) — Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default.
Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya.

Apa itu input ID?
pixel_values (torch.Tensor dengan bentuk (batch_size, num_channels, image_size, image_size), opsional) — Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan Siglip2ImageProcessor. Lihat Siglip2ImageProcessor.call() untuk detailnya (Siglip2Processor menggunakan Siglip2ImageProcessor untuk memproses gambar).
pixel_attention_mask (torch.Tensor dengan bentuk (batch_size, image_size, image_size), opsional) — Mask untuk menghindari pelaksanaan attention pada indeks piksel padding.
spatial_shapes (torch.LongTensor dengan bentuk (batch_size, 2)) — Tensor yang berisi dimensi spasial (tinggi, lebar) dari gambar input.
attention_mask (torch.Tensor dengan bentuk (batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari [0, 1]:
- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
Apa itu attention mask?
position_ids (torch.LongTensor dengan bentuk (batch_size, sequence_length), opsional) — Indeks posisi token dari setiap urutan input dalam position embeddings. Dipilih dalam rentang [0, config.n_positions - 1].
Apa itu ID posisi?
return_loss (bool, opsional) — Apakah akan mengembalikan kerugian kontras (contrastive loss).

Mengembalikan

Siglip2Output atau tuple(torch.Tensor)

Siglip2Output atau tuple dari torch.Tensor (jika return_dict=False dilewatkan atau ketika config.return_dict=False) yang terdiri dari berbagai elemen tergantung pada konfigurasi (Siglip2Config) dan input.

Metode forward dari Siglip2Model menimpa metode khusus __call__.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance Module setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

loss (torch.Tensor dengan bentuk (1,), opsional, dikembalikan ketika return_loss bernilai True) — Loss kontrastif untuk kemiripan gambar-teks.
logits_per_image (torch.Tensor dengan bentuk (image_batch_size, text_batch_size)) — Skor hasil perkalian titik (dot product) yang telah diskalakan antara image_embeds dan text_embeds. Ini mewakili skor kemiripan antara gambar dan teks.
logits_per_text (torch.Tensor dengan bentuk (text_batch_size, image_batch_size)) — Skor hasil perkalian titik berskala antara text_embeds dan image_embeds. Ini mewakili skor kemiripan teks-gambar.
text_embeds (torch.Tensor dengan bentuk (batch_size, output_dim) — Embedding teks yang diperoleh dengan menerapkan lapisan proyeksi ke output terpool dari Siglip2TextModel.
image_embeds (torch.Tensor dengan bentuk (batch_size, output_dim) — Embedding gambar yang diperoleh dengan menerapkan lapisan proyeksi ke output terpool dari Siglip2VisionModel.
text_model_output (~modeling_outputs.BaseModelOutputWithPooling, opsional) — Output dari Siglip2TextModel.
vision_model_output (~modeling_outputs.BaseModelOutputWithPooling, opsional) — Output dari Siglip2VisionModel.

Contoh:

>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoProcessor, AutoModel
>>> import torch

>>> model = AutoModel.from_pretrained("google/siglip2-base-patch16-224")
>>> processor = AutoProcessor.from_pretrained("google/siglip2-base-patch16-224")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> texts = ["a photo of 2 cats", "a photo of 2 dogs"]
>>> # important: we pass `padding=max_length` since the model was trained with this
>>> inputs = processor(text=texts, images=image, padding="max_length", return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> logits_per_image = outputs.logits_per_image
>>> probs = torch.sigmoid(logits_per_image) # these are the probabilities
>>> print(f"{probs[0][0]:.1%} that image 0 is '{texts[0]}'")
31.9% that image 0 is 'a photo of 2 cats'

get_text_features

< source >

( input_ids: Tensorattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Parameter

input_ids (torch.Tensor dengan bentuk (batch_size, sequence_length)) — Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya. Apa itu input ID?
Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya.

Apa itu input ID?
attention_mask (torch.Tensor dengan bentuk (batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari [0, 1]:
- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
Apa itu attention mask?
position_ids (torch.Tensor dengan bentuk (batch_size, sequence_length), opsional) — Indeks posisi token dari setiap urutan input dalam position embeddings. Dipilih dalam rentang [0, config.n_positions - 1].
Apa itu ID posisi?

Mengembalikan

BaseModelOutputWithPooling atau tuple(torch.Tensor)

BaseModelOutputWithPooling atau tuple dari torch.Tensor (jika return_dict=False dilewatkan atau ketika config.return_dict=False) yang terdiri dari berbagai elemen tergantung pada konfigurasi (Siglip2Config) dan input.

last_hidden_state (torch.Tensor dengan bentuk (batch_size, sequence_length, hidden_size)) — Urutan hidden-states pada keluaran lapisan terakhir model.
pooler_output (torch.Tensor dengan bentuk (batch_size, hidden_size)) — Hidden-state lapisan terakhir dari token pertama dalam urutan (token klasifikasi) setelah diproses lebih lanjut melalui lapisan yang digunakan untuk tugas pra-pelatihan tambahan. Misalnya, untuk keluarga model BERT, ini mengembalikan token klasifikasi setelah diproses melalui lapisan linear dan fungsi aktivasi tanh. Bobot lapisan linear dilatih dari tujuan prediksi kalimat berikutnya (klasifikasi) selama pra-pelatihan.
hidden_states (tuple(torch.Tensor), opsional, dikembalikan saat output_hidden_states=True dilewatkan atau saat config.output_hidden_states=True) — Tuple dari torch.Tensor (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk (batch_size, sequence_length, hidden_size).

Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (tuple(torch.Tensor), opsional, dikembalikan saat output_attentions=True dilewatkan atau saat config.output_attentions=True) — Tuple dari torch.Tensor (satu untuk setiap layer) dengan bentuk (batch_size, num_heads, sequence_length, sequence_length).

Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).

Contoh:

>>> from transformers import AutoTokenizer, AutoModel
>>> import torch

>>> model = AutoModel.from_pretrained("google/siglip2-base-patch16-224")
>>> tokenizer = AutoTokenizer.from_pretrained("google/siglip2-base-patch16-224")

>>> # important: make sure to set padding="max_length" as that's how the model was trained
>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding="max_length", return_tensors="pt")
>>> with torch.no_grad():
...     text_features = model.get_text_features(**inputs)

get_image_features

< source >

( pixel_values: typing.Optional[torch.Tensor] = Nonepixel_attention_mask: typing.Optional[torch.Tensor] = Nonespatial_shapes: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Parameter

pixel_values (torch.Tensor dengan bentuk (batch_size, num_channels, image_size, image_size), opsional) — Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan Siglip2ImageProcessor. Lihat Siglip2ImageProcessor.call() untuk detailnya (Siglip2Processor menggunakan Siglip2ImageProcessor untuk memproses gambar).
pixel_attention_mask (torch.Tensor dengan bentuk (batch_size, image_size, image_size), opsional) — Mask untuk menghindari pelaksanaan attention pada indeks piksel padding.
spatial_shapes (torch.LongTensor dengan bentuk (batch_size, 2)) — Tensor yang berisi dimensi spasial (tinggi, lebar) dari gambar input.

Mengembalikan

BaseModelOutputWithPooling atau tuple(torch.Tensor)

Sebuah BaseModelOutputWithPooling atau tuple dari torch.Tensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai elemen tergantung pada konfigurasi (Siglip2Config) dan input.

last_hidden_state (torch.Tensor dengan bentuk (batch_size, sequence_length, hidden_size)) — Urutan hidden-states pada keluaran lapisan terakhir model.
pooler_output (torch.Tensor dengan bentuk (batch_size, hidden_size)) — Hidden-state lapisan terakhir dari token pertama dalam urutan (token klasifikasi) setelah diproses lebih lanjut melalui lapisan yang digunakan untuk tugas pra-pelatihan tambahan. Misalnya, untuk keluarga model BERT, ini mengembalikan token klasifikasi setelah diproses melalui lapisan linear dan fungsi aktivasi tanh. Bobot lapisan linear dilatih dari tujuan prediksi kalimat berikutnya (klasifikasi) selama pra-pelatihan.
hidden_states (tuple(torch.Tensor), opsional, dikembalikan saat output_hidden_states=True dilewatkan atau saat config.output_hidden_states=True) — Tuple dari torch.Tensor (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk (batch_size, sequence_length, hidden_size).

Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (tuple(torch.Tensor), opsional, dikembalikan saat output_attentions=True dilewatkan atau saat config.output_attentions=True) — Tuple dari torch.Tensor (satu untuk setiap layer) dengan bentuk (batch_size, num_heads, sequence_length, sequence_length).

Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).

Contoh:

>>> import torch
>>> from transformers import AutoProcessor, AutoModel
>>> from transformers.image_utils import load_image

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = load_image(url)

>>> model = AutoModel.from_pretrained("google/siglip2-base-patch16-224")
>>> processor = AutoProcessor.from_pretrained("google/siglip2-base-patch16-224")

>>> inputs = processor(images=image, return_tensors="pt")

>>> with torch.no_grad():
...     image_features = model.get_image_features(**inputs)

Siglip2TextModel

kelas transformers.Siglip2TextModel

< source >

( config: Siglip2TextConfig )

Parameter

config (Siglip2TextConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.

Model teks dari Siglip2 tanpa head atau proyeksi di atasnya.

forward

< source >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Parameter

input_ids (torch.Tensor dengan bentuk (batch_size, sequence_length), opsional) — Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default.
Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya.

Apa itu input ID?
attention_mask (torch.Tensor dengan bentuk (batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari [0, 1]:
- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
Apa itu attention mask?
position_ids (torch.Tensor dengan bentuk (batch_size, sequence_length), opsional) — Indeks posisi token dari setiap urutan input dalam position embeddings. Dipilih dalam rentang [0, config.n_positions - 1].
Apa itu ID posisi?

Mengembalikan

BaseModelOutputWithPooling atau tuple(torch.Tensor)

Metode forward dari Siglip2TextModel menimpa metode khusus __call__.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance Module setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

last_hidden_state (torch.Tensor dengan bentuk (batch_size, sequence_length, hidden_size)) — Urutan hidden-states pada keluaran lapisan terakhir model.
pooler_output (torch.Tensor dengan bentuk (batch_size, hidden_size)) — Hidden-state lapisan terakhir dari token pertama dalam urutan (token klasifikasi) setelah diproses lebih lanjut melalui lapisan yang digunakan untuk tugas pra-pelatihan tambahan. Misalnya, untuk keluarga model BERT, ini mengembalikan token klasifikasi setelah diproses melalui lapisan linear dan fungsi aktivasi tanh. Bobot lapisan linear dilatih dari tujuan prediksi kalimat berikutnya (klasifikasi) selama pra-pelatihan.
hidden_states (tuple(torch.Tensor), opsional, dikembalikan saat output_hidden_states=True dilewatkan atau saat config.output_hidden_states=True) — Tuple dari torch.Tensor (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk (batch_size, sequence_length, hidden_size).

Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (tuple(torch.Tensor), opsional, dikembalikan saat output_attentions=True dilewatkan atau saat config.output_attentions=True) — Tuple dari torch.Tensor (satu untuk setiap layer) dengan bentuk (batch_size, num_heads, sequence_length, sequence_length).

Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).

Contoh:

>>> from transformers import AutoTokenizer, Siglip2TextModel

>>> model = Siglip2TextModel.from_pretrained("google/siglip2-base-patch16-224")
>>> tokenizer = AutoTokenizer.from_pretrained("google/siglip2-base-patch16-224")

>>> # important: make sure to set padding="max_length" as that's how the model was trained
>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding="max_length", return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled (EOS token) states

Siglip2VisionModel

kelas transformers.Siglip2VisionModel

< source >

( config: Siglip2VisionConfig )

Parameter

config (Siglip2VisionConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.

Model visi dari Siglip2 tanpa head atau proyeksi di atasnya.

forward

< source >

( pixel_values: Tensorpixel_attention_mask: Tensorspatial_shapes: LongTensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Parameter

pixel_values (torch.Tensor dengan bentuk (batch_size, num_channels, image_size, image_size)) — Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan Siglip2ImageProcessor. Lihat Siglip2ImageProcessor.call() untuk detailnya (Siglip2Processor menggunakan Siglip2ImageProcessor untuk memproses gambar).
pixel_attention_mask (torch.Tensor dengan bentuk (batch_size, image_size, image_size), opsional) — Mask untuk menghindari pelaksanaan attention pada indeks piksel padding.
spatial_shapes (torch.LongTensor dengan bentuk (batch_size, 2)) — Tensor yang berisi dimensi spasial (tinggi, lebar) dari gambar input.

Mengembalikan

BaseModelOutputWithPooling atau tuple(torch.Tensor)

BaseModelOutputWithPooling atau tuple dari torch.Tensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai elemen tergantung pada konfigurasi (Siglip2Config) dan input.

Metode forward dari Siglip2VisionModel menimpa metode khusus __call__.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance Module setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

last_hidden_state (torch.Tensor dengan bentuk (batch_size, sequence_length, hidden_size)) — Urutan hidden-states pada keluaran lapisan terakhir model.
pooler_output (torch.Tensor dengan bentuk (batch_size, hidden_size)) — Hidden-state lapisan terakhir dari token pertama dalam urutan (token klasifikasi) setelah diproses lebih lanjut melalui lapisan yang digunakan untuk tugas pra-pelatihan tambahan. Misalnya, untuk keluarga model BERT, ini mengembalikan token klasifikasi setelah diproses melalui lapisan linear dan fungsi aktivasi tanh. Bobot lapisan linear dilatih dari tujuan prediksi kalimat berikutnya (klasifikasi) selama pra-pelatihan.
hidden_states (tuple(torch.Tensor), opsional, dikembalikan saat output_hidden_states=True dilewatkan atau saat config.output_hidden_states=True) — Tuple dari torch.Tensor (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk (batch_size, sequence_length, hidden_size).

Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (tuple(torch.Tensor), opsional, dikembalikan saat output_attentions=True dilewatkan atau saat config.output_attentions=True) — Tuple dari torch.Tensor (satu untuk setiap layer) dengan bentuk (batch_size, num_heads, sequence_length, sequence_length).

Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).

Contoh:

>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from PIL import Image
>>> from transformers import AutoProcessor, Siglip2VisionModel

>>> model = Siglip2VisionModel.from_pretrained("google/siglip2-base-patch16-224")
>>> processor = AutoProcessor.from_pretrained("google/siglip2-base-patch16-224")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> inputs = processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled features

Siglip2ForImageClassification

kelas transformers.Siglip2ForImageClassification

< source >

( config: Siglip2Config )

Parameter

config (Siglip2Config) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya saja. Lihat metode from_pretrained() untuk memuat bobot model.

Vision encoder Siglip2 dengan kepala klasifikasi gambar di atasnya (lapisan linear di atas keadaan tersembunyi akhir yang dipool dari token patch), misalnya untuk ImageNet.

forward

< source >

( pixel_values: typing.Optional[torch.Tensor] = Nonepixel_attention_mask: typing.Optional[torch.Tensor] = Nonespatial_shapes: typing.Optional[torch.LongTensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ImageClassifierOutput or tuple(torch.Tensor)

Parameter

pixel_values (torch.Tensor dengan bentuk (batch_size, num_channels, image_size, image_size), opsional) — Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan Siglip2ImageProcessor. Lihat Siglip2ImageProcessor.call() untuk detailnya (Siglip2Processor menggunakan Siglip2ImageProcessor untuk memproses gambar).
pixel_attention_mask (torch.Tensor dengan bentuk (batch_size, image_size, image_size), opsional) — Mask untuk menghindari pelaksanaan attention pada indeks piksel padding.
spatial_shapes (torch.LongTensor dengan bentuk (batch_size, 2)) — Tensor yang berisi dimensi spasial (tinggi, lebar) dari gambar input.
labels (torch.LongTensor dengan bentuk (batch_size,), opsional) — Label untuk menghitung loss klasifikasi/regresi gambar. Indeks harus berada dalam [0, ..., config.num_labels - 1]. Jika config.num_labels == 1, loss regresi dihitung (Mean-Square loss). Jika config.num_labels > 1, loss klasifikasi dihitung (Cross-Entropy).

Mengembalikan

ImageClassifierOutput atau tuple(torch.Tensor)

Sebuah ImageClassifierOutput atau tuple dari torch.Tensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai elemen tergantung pada konfigurasi (Siglip2Config) dan input.

Metode forward dari Siglip2ForImageClassification menimpa metode khusus __call__.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance Module setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

loss (torch.Tensor dengan bentuk (1,), opsional, dikembalikan saat labels disediakan) — Loss klasifikasi (atau regresi jika config.num_labels==1).
logits (torch.Tensor dengan bentuk (batch_size, config.num_labels)) — Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax).
hidden_states (tuple(torch.Tensor), opsional, dikembalikan saat output_hidden_states=True dilewatkan atau saat config.output_hidden_states=True) — Tuple dari torch.Tensor (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap tahap) dengan bentuk (batch_size, sequence_length, hidden_size). Hidden-states (juga disebut feature maps) dari model pada output dari setiap tahap.
attentions (tuple(torch.Tensor), opsional, dikembalikan saat output_attentions=True dilewatkan atau saat config.output_attentions=True) — Tuple dari torch.Tensor (satu untuk setiap layer) dengan bentuk (batch_size, num_heads, patch_size, sequence_length).

Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).

Contoh:

>>> from transformers import AutoImageProcessor, Siglip2ForImageClassification
>>> import torch
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> torch.manual_seed(3)
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> # note: we are loading a `Siglip2Model` from the hub here,
>>> # so the head will be randomly initialized, hence the predictions will be random if seed is not set above.
>>> image_processor = AutoImageProcessor.from_pretrained("google/siglip2-base-patch16-224")
>>> model = Siglip2ForImageClassification.from_pretrained("google/siglip2-base-patch16-224")

>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> # model predicts one of the two classes
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: LABEL_1

Siglip2Tokenizer

kelas transformers.Siglip2Tokenizer

< source >

( vocab: str | dict[str, int] | None = Nonemerges: str | list[str] | None = Noneunk_token: str = '<unk>'bos_token: str = '<bos>'eos_token: str = '<eos>'pad_token: str = '<pad>'mask_token: str = '<mask>'**kwargs )

Tokenizer Gemma + default pelatihan SigLIP2: normalisasi huruf kecil.

call

< source >

Parameter

text (str, list[str], list[list[str]], opsional) — Sequens atau batch dari sequens yang akan dienkod. Setiap sequens dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika sequens diberikan sebagai daftar string (pretokenized), Anda harus mengatur is_split_into_words=True (untuk menghilangkan ambiguitas dengan batch dari sequens).
text_pair (str, list[str], list[list[str]], opsional) — Urutan atau batch dari urutan yang akan dienkod. Setiap urutan dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika urutan diberikan sebagai daftar string (pretokenized), Anda harus mengatur is_split_into_words=True (untuk menghilangkan ambiguitas dengan batch dari urutan).
text_target (str, list[str], list[list[str]], opsional) — Sequens atau batch sequens yang akan dikodekan sebagai teks target. Setiap sequens dapat berupa string atau daftar string (string pretokenized). Jika sequens diberikan sebagai daftar string (pretokenized), Anda harus mengatur is_split_into_words=True (untuk menghilangkan ambiguitas dengan batch sequens).
text_pair_target (str, list[str], list[list[str]], opsional) — Urutan atau batch urutan yang akan dikodekan sebagai teks target. Setiap urutan dapat berupa string atau daftar string (string pretokenized). Jika urutan diberikan sebagai daftar string (pretokenized), Anda harus mengatur is_split_into_words=True (untuk menghilangkan ambiguitas dengan batch urutan).
tokenizer_kwargs (dict[str, Any], opsional) — Kwargs tambahan untuk diteruskan ke tokenizer. Kwargs ini akan digabungkan dengan parameter eksplisit dan kwargs lainnya, dengan parameter eksplisit memiliki prioritas lebih tinggi.
add_special_tokens (bool, opsional, default True) — Apakah akan menambahkan token khusus saat meng-encode urutan. Ini akan menggunakan fungsi PretrainedTokenizerBase.build_inputs_with_special_tokens yang mendasarinya, yang mendefinisikan token mana yang ditambahkan secara otomatis ke input ids. Ini berguna jika Anda ingin menambahkan token bos atau eos secara otomatis.
padding (bool, str atau PaddingStrategy, opsional, defaultnya False) — Mengaktifkan dan mengontrol padding. Menerima nilai-nilai berikut:
- True atau 'longest': Pad hingga urutan terpanjang dalam batch (atau tanpa padding jika hanya satu urutan yang diberikan).
- 'max_length': Pad hingga panjang maksimum yang ditentukan dengan argumen max_length atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan.
- False atau 'do_not_pad' (default): Tidak ada padding (yaitu, dapat menghasilkan batch dengan urutan yang panjangnya berbeda).
truncation (bool, str atau TruncationStrategy, opsional, defaultnya False) — Mengaktifkan dan mengontrol pemotongan. Menerima nilai-nilai berikut:
- True atau 'longest_first': Memotong hingga panjang maksimum yang ditentukan dengan argumen max_length atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini akan memotong per token, dengan menghapus satu token dari urutan terpanjang dalam pasangan jika sepasang urutan (atau batch pasangan) diberikan.
- 'only_first': Potong hingga panjang maksimum yang ditentukan dengan argumen max_length atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan pertama dari sebuah pasangan jika sepasang urutan (atau batch dari pasangan) diberikan.
- 'only_second': Potong hingga panjang maksimum yang ditentukan dengan argumen max_length atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan kedua dari sebuah pasangan jika sepasang urutan (atau batch dari pasangan) diberikan.
- False atau 'do_not_truncate' (default): Tidak ada pemotongan (yaitu, dapat menghasilkan batch dengan panjang sekuens yang lebih besar dari ukuran input maksimum yang diizinkan model).
max_length (int, opsional) — Mengontrol panjang maksimum yang digunakan oleh salah satu parameter truncation/padding.
Jika tidak disetel atau disetel ke None, ini akan menggunakan panjang maksimum model yang telah didefinisikan sebelumnya jika panjang maksimum diperlukan oleh salah satu parameter truncation/padding. Jika model tidak memiliki panjang input maksimum yang spesifik (seperti XLNet), truncation/padding ke panjang maksimum akan dinonaktifkan.
stride (int, opsional, default 0) — Jika diatur ke sebuah angka bersama dengan max_length, token yang meluap yang dikembalikan saat return_overflowing_tokens=True akan berisi beberapa token dari akhir urutan terpotong yang dikembalikan untuk menyediakan beberapa tumpang tindih antara urutan terpotong dan urutan yang meluap. Nilai argumen ini menentukan jumlah token yang tumpang tindih.
is_split_into_words (bool, opsional, default False) — Apakah input sudah di-pre-tokenisasi (misalnya, dipecah menjadi kata). Jika disetel ke True, tokenizer mengasumsikan input sudah dipecah menjadi kata (misalnya, dengan memisahkannya berdasarkan spasi) yang akan ditokenisasi. Ini berguna untuk NER atau klasifikasi token.
pad_to_multiple_of (int, opsional) — Jika diset, akan melakukan padding pada urutan hingga menjadi kelipatan dari nilai yang diberikan. Memerlukan padding untuk diaktifkan. Ini sangat berguna untuk memungkinkan penggunaan Tensor Cores pada perangkat keras NVIDIA dengan kemampuan komputasi >= 7.5 (Volta).
padding_side (str, opsional) — Sisi tempat model harus menerapkan padding. Harus dipilih antara [‘right’, ‘left’]. Nilai default diambil dari atribut kelas dengan nama yang sama.
return_tensors (str atau TensorType, opsional) — Jika diset, akan mengembalikan tensor alih-alih daftar integer Python. Nilai yang dapat diterima adalah:
- 'pt': Mengembalikan objek PyTorch torch.Tensor.
- 'np': Mengembalikan objek Numpy np.ndarray.
return_token_type_ids (bool, opsional) — Apakah akan mengembalikan token type ID. Jika dibiarkan pada nilai default, akan mengembalikan token type ID sesuai dengan default tokenizer tertentu, yang ditentukan oleh return_outputs atribut.
Apa itu token type ID?
return_attention_mask (bool, opsional) — Apakah akan mengembalikan attention mask. Jika dibiarkan pada nilai default, akan mengembalikan attention mask sesuai dengan default tokenizer tertentu, yang didefinisikan oleh return_outputs atribut.
Apa itu attention mask?
return_overflowing_tokens (bool, opsional, default False) — Apakah akan mengembalikan urutan token yang meluap. Jika sepasang urutan id input (atau batch dari pasangan) diberikan dengan truncation_strategy = longest_first atau True, error akan dilemparkan alih-alih mengembalikan token yang meluap.
return_special_tokens_mask (bool, opsional, default False) — Apakah akan mengembalikan informasi mask token khusus.
return_offsets_mapping (bool, opsional, defaultnya False) — Apakah akan mengembalikan (char_start, char_end) untuk setiap token.
Ini hanya tersedia pada fast tokenizer yang mewarisi dari PreTrainedTokenizerFast, jika menggunakan tokenizer Python, metode ini akan memicu NotImplementedError.
return_length (bool, opsional, default False) — Apakah akan mengembalikan panjang dari input yang dikodekan.
verbose (bool, opsional, defaultnya True) — Apakah akan mencetak lebih banyak informasi dan peringatan.
**kwargs — diteruskan ke metode self.tokenize()

Mengembalikan

BatchEncoding

BatchEncoding dengan bidang berikut:

input_ids — Daftar id token yang akan diberikan ke model.

Apa itu input ID?
token_type_ids — Daftar token type id yang akan diberikan ke model (ketika return_token_type_ids=True atau jika “token_type_ids” ada di self.model_input_names).

Apa itu token type ID?
attention_mask — Daftar indeks yang menentukan token mana yang harus diperhatikan oleh model (ketika return_attention_mask=True atau jika “attention_mask” ada di self.model_input_names).

Apa itu attention mask?
overflowing_tokens — Daftar sekuens token yang meluap (ketika max_length ditentukan dan return_overflowing_tokens=True).
num_truncated_tokens — Jumlah token yang dipangkas (ketika max_length ditentukan dan return_overflowing_tokens=True).
special_tokens_mask — Daftar angka 0 dan 1, di mana 1 menandakan token khusus yang ditambahkan dan 0 menandakan token urutan reguler (ketika add_special_tokens=True dan return_special_tokens_mask=True).
length — Panjang dari input (ketika return_length=True)

Metode utama untuk melakukan tokenisasi dan persiapan satu atau beberapa urutan atau satu atau beberapa pasangan urutan untuk model.

Update on GitHub

←SigLIP SLANet→