Transformers documentation

Pixio

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 disumbangkan ke Hugging Face Transformers pada 2025-12-17. Model ini akan diumumkan

Pixio

Pixio adalah model fondasi visi yang menggunakan ViT sebagai ekstraktor fitur untuk berbagai tugas turunan seperti estimasi kedalaman, segmentasi semantik, rekonstruksi 3D feed-forward, robotika, dan klasifikasi gambar. Model ini dibangun di atas kerangka pra-pelatihan Masked Autoencoder (MAE), dengan empat pembaruan minimal namun krusial: 1) decoder yang lebih dalam, 2) granularitas masking yang lebih besar, 3) lebih banyak token kelas, dan 4) data pelatihan kurasi skala web.

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

Contoh di bawah ini menunjukkan cara mendapatkan embedding gambar dengan kelas AutoModel.

import requests
from PIL import Image

from transformers import AutoImageProcessor, AutoModel


url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)

processor = AutoImageProcessor.from_pretrained("facebook/pixio-vith16")
model = AutoModel.from_pretrained("facebook/pixio-vith16", device_map="auto")

inputs = processor(images=image, return_tensors="pt").to(model.device)
outputs = model(**inputs)
features_norm = outputs.last_hidden_state # class tokens + patch tokens after last LayerNorm
features = outputs.hidden_states[-1] # class tokens + patch tokens before last LayerNorm

Catatan

Contoh di bawah ini menunjukkan cara membagi tensor output menjadi:

seperangkat embedding global untuk seluruh gambar, yang umumnya disebut sebagai token CLS, berguna untuk klasifikasi dan pengambilan. Anda dapat merata-ratakannya (disarankan) atau menggabungkannya sepanjang dimensi channel.
seperangkat embedding lokal, satu untuk setiap patch 16x16 dari gambar input, berguna untuk tugas-tugas padat, seperti estimasi kedalaman dan segmentasi semantik.

from transformers import AutoImageProcessor, AutoModel
from PIL import Image
import requests

url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
image = Image.open(requests.get(url, stream=True).raw)
print(image.height, image.width)  # [480, 640]

processor = AutoImageProcessor.from_pretrained('facebook/pixio-vith16')
model = AutoModel.from_pretrained('facebook/pixio-vith16', device_map="auto")
patch_size = model.config.patch_size

inputs = processor(images=image, return_tensors="pt").to(model.device)
print(inputs.pixel_values.shape)  # [1, 3, 256, 256]
batch_size, rgb, img_height, img_width = inputs.pixel_values.shape
num_patches_height, num_patches_width = img_height // patch_size, img_width // patch_size
num_patches_flat = num_patches_height * num_patches_width

outputs = model(**inputs)
last_hidden_states = outputs.last_hidden_state
print(last_hidden_states.shape)  # [1, 8 + 256, 1280]
assert last_hidden_states.shape == (batch_size, model.config.n_cls_tokens + num_patches_flat, model.config.hidden_size)

cls_tokens = last_hidden_states[:, :model.config.n_cls_tokens, :]
patch_features = last_hidden_states[:, model.config.n_cls_tokens:, :].unflatten(1, (num_patches_height, num_patches_width))

Gunakan torch.compile untuk mempercepat inferensi.

import torch
from transformers import AutoImageProcessor, AutoModel
from PIL import Image
import requests

url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
image = Image.open(requests.get(url, stream=True).raw)

processor = AutoImageProcessor.from_pretrained('facebook/pixio-vith16')
model = AutoModel.from_pretrained('facebook/pixio-vith16', device_map="auto")

compiled_model = torch.compile(model)

inputs = processor(images=image, return_tensors="pt").to(model.device)
outputs = compiled_model(**inputs)
last_hidden_states = outputs.last_hidden_state

PixioConfig

kelas transformers.PixioConfig

< 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 = 1280num_hidden_layers: int = 32num_attention_heads: int = 16mlp_ratio: int = 4hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.0attention_probs_dropout_prob: float | int = 0.0initializer_range: float = 0.02layer_norm_eps: float = 1e-06image_size: int | list[int] | tuple[int, int] = 256patch_size: int | list[int] | tuple[int, int] = 16num_channels: int = 3qkv_bias: bool = Truedrop_path_rate: float | int = 0.0_out_features: list[str] | None = None_out_indices: list[int] | None = Noneapply_layernorm: bool = Truereshape_hidden_states: bool = Truen_cls_tokens: int = 8 )

Parameter

hidden_size (int, opsional, default 1280) — Dimensi dari representasi tersembunyi.
num_hidden_layers (int, opsional, default 32) — Jumlah lapisan tersembunyi dalam decoder Transformer.
num_attention_heads (int, opsional, default 16) — Jumlah attention head untuk setiap lapisan attention di decoder Transformer.
mlp_ratio (int, opsional, default 4) — Rasio dimensi tersembunyi MLP terhadap dimensi embedding.
hidden_act (str, opsional, defaultnya gelu) — Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, "gelu", "relu", "silu", dan sebagainya.
hidden_dropout_prob (Union[float, int], opsional, default 0.0) — Probabilitas dropout untuk semua lapisan fully connected di embeddings, encoder, dan pooler.
attention_probs_dropout_prob (Union[float, int], opsional, default 0.0) — Rasio dropout untuk probabilitas perhatian.
initializer_range (float, opsional, defaultnya 0.02) — Standar deviasi dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.
layer_norm_eps (float, opsional, defaultnya 1e-06) — Epsilon yang digunakan oleh lapisan normalisasi lapisan.
image_size (Union[int, list[int], tuple[int, int]], opsional, defaultnya 256) — Ukuran (resolusi) dari setiap gambar.
patch_size (Union[int, list[int], tuple[int, int]], opsional, defaultnya 16) — Ukuran (resolusi) dari setiap patch.
num_channels (int, opsional, defaultnya 3) — Jumlah saluran input.
qkv_bias (bool, opsional, defaultnya True) — Apakah akan menambahkan bias ke queries, keys, dan values.
drop_path_rate (Union[float, int], opsional, defaultnya 0.0) — Tingkat drop path untuk fusi patch.
apply_layernorm (bool, opsional, default True) — Apakah layer normalization akan diterapkan pada feature maps jika model digunakan sebagai backbone.
reshape_hidden_states (bool, opsional, default True) — Apakah peta fitur akan di-reshape menjadi tensor 4D dengan bentuk (batch_size, hidden_size, height, width) jika model digunakan sebagai backbone. Jika False, peta fitur akan berupa tensor 3D dengan bentuk (batch_size, seq_len, hidden_size).
n_cls_tokens (int, opsional, default 8) — Jumlah token kelas dalam encoder Transformer.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari PixioModel. Kelas ini digunakan untuk membuat instans model Pixio sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari facebook/pixio-huge

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

Contoh:

>>> from transformers import PixioConfig, PixioModel

>>> # Initializing a Pixio pixio-huge style configuration
>>> configuration = PixioConfig()

>>> # Initializing a model (with random weights) from the pixio-huge style configuration
>>> model = PixioModel(configuration)

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

PixioModel

kelas transformers.PixioModel

< source >

( config: PixioConfig )

Parameter

config (PixioConfig) — 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 Pixio 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 >

( pixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = 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 BitImageProcessor. Lihat BitImageProcessor.call() untuk detailnya (processor_class menggunakan BitImageProcessor untuk memproses gambar).
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?

Mengembalikan

BaseModelOutputWithPooling atau tuple(torch.Tensor)

A 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 (PixioConfig) dan input.

Metode forward dari PixioModel 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:

PixioBackbone

kelas transformers.PixioBackbone

< source >

( config: PixioConfig )

Parameter

config (PixioConfig) — 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.

Backbone Pixio, untuk digunakan dengan framework seperti DETR dan MaskFormer.

forward

< source >

( pixel_values: Tensorattention_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BackboneOutput 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 BitImageProcessor. Lihat BitImageProcessor.call() untuk detailnya (processor_class menggunakan BitImageProcessor untuk memproses gambar).
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?

Mengembalikan

BackboneOutput atau tuple(torch.Tensor)

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

Metode forward dari PixioBackbone 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.

feature_maps (tuple(torch.Tensor) dengan bentuk (batch_size, num_channels, height, width)) — Feature maps dari setiap tahap.
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 embeddings + satu untuk output setiap layer) dengan bentuk (batch_size, sequence_length, hidden_size) atau (batch_size, num_channels, height, width), tergantung pada backbone.

Hidden-states model pada output setiap tahap ditambah output embedding awal.
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). Hanya berlaku jika backbone menggunakan attention.

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

Contoh:

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

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

>>> processor = AutoImageProcessor.from_pretrained("facebook/pixio-huge")
>>> model = AutoBackbone.from_pretrained(
...     "facebook/pixio-huge", out_features=["stage7", "stage15", "stage23", "stage31"]
... )

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

>>> outputs = model(**inputs)
>>> feature_maps = outputs.feature_maps
>>> list(feature_maps[-1].shape)
[1, 1280, 16, 16]

Update on GitHub

←MobileViTV2 PoolFormer→