Transformers documentation
Sapiens2
Model ini dipublikasikan di HF papers pada 2026-04-23 dan disumbangkan ke Hugging Face Transformers pada 2026-06-03.
Sapiens2
Ikhtisar
Model Sapiens2 diusulkan dalam Sapiens2 oleh Rawal Khirodkar, He Wen, Julieta Martinez, Yuan Dong, Zhaoen Su, Shunsuke Saito. Sapiens2 adalah keluarga vision transformer resolusi tinggi yang dilatih sebelumnya pada sekitar 1 miliar gambar manusia yang dikurasi, dirancang untuk tugas computer vision yang berpusat pada manusia, termasuk estimasi pose, segmentasi bagian tubuh, estimasi normal permukaan, dan estimasi pointmap.
Anda dapat menemukan semua checkpoint asli Sapiens2 di bawah koleksi Sapiens2.
Abstrak dari makalah tersebut adalah sebagai berikut:
Kami memperkenalkan Sapiens2, sebuah keluarga transformer resolusi tinggi untuk visi berpusat pada manusia yang berfokus pada generalisasi, versatilitas, dan keluaran berfidelitas tinggi. Kami melakukan pra-pelatihan pada sekitar 1 miliar gambar manusia berkualitas tinggi yang dikurasi dengan anotasi tugas yang ditingkatkan, serta menggabungkan rekonstruksi gambar tersembunyi dengan tujuan kontras yang disuling sendiri untuk mempelajari fitur tingkat rendah dan semantik. Model kami berskala dari 0,4 miliar hingga 5 miliar parameter dan dilatih pada resolusi asli 1K, dengan varian 4K hierarkis untuk penalaran spasial yang diperluas. Sapiens2 mencapai peningkatan substansial dibandingkan pendahulunya: +4 mAP dalam estimasi pose, +24,3 mIoU dalam segmentasi bagian tubuh, dan pengurangan error 45,6% dalam estimasi normal, sambil diperluas ke tugas baru seperti estimasi pointmap dan albedo. Kode tersedia secara publik.
Tips:
- Sapiens2 menggunakan Rotary Position Embeddings (RoPE) dan mendukung resolusi input apa pun. Prosesor gambar bawaan mengubah ukuran gambar menjadi 1024×768 (tinggi×lebar).
- Model ini menggunakan Grouped Query Attention (GQA) untuk lapisan tengah dan full multi-head attention untuk 8 lapisan pertama dan terakhir.
- Token yang didaftarkan (8 secara default) mengurangi artefak bernorm tinggi pada token patch, menghasilkan peta perhatian yang lebih bersih dan kinerja yang lebih baik pada tugas prediksi padat.
Model ini disumbangkan oleh guarin. Kode aslinya dapat ditemukan di sini.
Contoh penggunaan
Contoh di bawah ini menunjukkan cara mendapatkan token CLS (embedding seluruh gambar) dengan Sapiens2Model.
import torch
from transformers import AutoImageProcessor, AutoModel
from transformers.image_utils import load_image
image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-pretrain-0.4b")
model = AutoModel.from_pretrained("facebook/sapiens2-pretrain-0.4b", device_map="auto")
inputs = image_processor(images=image, return_tensors="pt").to(model.device)
with torch.inference_mode():
outputs = model(**inputs)
# outputs.pooler_output is the CLS token (whole-image embedding)
cls_token = outputs.pooler_output
print("CLS token shape:", cls_token.shape) # [1, 1024]Sapiens2Backbone mengekspos token patch yang sudah di-*reshape* ke dimensi spasial dan token CLS langsung pada objek output.
import torch
from transformers import AutoBackbone, AutoImageProcessor
from transformers.image_utils import load_image
image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-pretrain-0.4b")
model = AutoBackbone.from_pretrained("facebook/sapiens2-pretrain-0.4b", device_map="auto")
inputs = image_processor(images=image, return_tensors="pt").to(model.device)
with torch.inference_mode():
outputs = model(**inputs, return_class_token=True)
# Patch tokens shaped (batch, height, width, channels)
patch_features = outputs.feature_maps[0]
cls_token = outputs.cls_tokens[0]
print("CLS token shape:", cls_token.shape) # [1, 1024]
print("Patch features shape:", patch_features.shape) # [1, 64, 48, 1024]Contoh di bawah menunjukkan cara memperkirakan normal permukaan dengan Sapiens2ForNormalEstimation.
Normal yang dihasilkan bersifat mentah (belum dinormalisasi); gunakan post_process_normal_estimation untuk mengubah ukuran dan menormalisasi L2.
import torch
from transformers import AutoImageProcessor, AutoModelForNormalEstimation
from transformers.image_utils import load_image
image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-normal-0.4b")
model = AutoModelForNormalEstimation.from_pretrained("facebook/sapiens2-normal-0.4b", device_map="auto")
inputs = image_processor(image, return_tensors="pt").to(model.device)
with torch.inference_mode():
outputs = model(**inputs)
# outputs.normals shape: (batch_size, 3, height, width) — raw, unnormalized XYZ normals
print("Normals shape:", outputs.normals.shape) # [1, 3, 1024, 768]
# Remove preprocessing padding, resize to original size, and L2-normalize to unit vectors in [-1, 1]
original_size = (image.height, image.width)
result = image_processor.post_process_normal_estimation(
outputs, source_sizes=[original_size], target_sizes=[original_size]
)
normals = result[0]["normals"]
print("Normals shape:", normals.shape) # [3, original_height, original_width]
### Example code for visualization
# Convert L2-normalized normals in [-1, 1] to RGB in [0, 255]
normals_rgb = ((normals + 1.0) / 2.0 * 255.0).clamp(0, 255).to(torch.uint8)
# Apply background removal using the segmentation model output.
# `segmentation` is the output of `post_process_semantic_segmentation` — a (H, W) tensor
# of per-pixel class IDs, where class 0 is background.
background_mask = segmentation == 0
normals_rgb[:, background_mask] = 0
print("Normals RGB shape:", normals_rgb.shape) # [3, original_height, original_width]Contoh di bawah ini menunjukkan cara memperkirakan koordinat 3D per piksel dengan Sapiens2ForPointmapEstimation.
Gunakan post_process_pointmap_estimation untuk menghapus padding pra-pemrosesan, mengubah ukuran ke ukuran gambar asli, dan menerapkan skala panjang fokus yang diprediksi.
import torch
from transformers import AutoImageProcessor, AutoModelForPointmapEstimation
from transformers.image_utils import load_image
image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-pointmap-0.4b")
model = AutoModelForPointmapEstimation.from_pretrained("facebook/sapiens2-pointmap-0.4b", device_map="auto")
inputs = image_processor(image, return_tensors="pt").to(model.device)
with torch.inference_mode():
outputs = model(**inputs)
# outputs.pointmaps shape: (batch_size, 3, height, width) — raw XYZ in canonical camera space
print("Pointmaps shape:", outputs.pointmaps.shape) # [1, 3, 1024, 768]
# Remove preprocessing padding, resize to original size, and apply focal-length scale
original_size = (image.height, image.width)
result = image_processor.post_process_pointmap_estimation(
outputs, source_sizes=[original_size], target_sizes=[original_size]
)
pointmap = result[0]["pointmap"]
print("Pointmap shape:", pointmap.shape) # [3, original_height, original_width]
### Example code for visualization
# Visualize the pointmap as an RGB image using inverse-depth and the turbo colormap.
import matplotlib.pyplot as plt
# `segmentation` is the output of `post_process_semantic_segmentation` — a (H, W) tensor
# of per-pixel class IDs, where class 0 is background.
foreground_mask = segmentation != 0
depth = pointmap[2] # Z channel: depth in camera space, shape (H, W)
pointmap_rgb = torch.zeros(3, *depth.shape, dtype=torch.uint8)
foreground_depth = depth[foreground_mask]
if foreground_depth.numel() > 0:
depth_low, depth_high = torch.quantile(foreground_depth, torch.tensor([0.01, 0.99]))
inverse_depth = 1.0 / foreground_depth.clamp(min=1e-6)
inverse_depth_low = 1.0 / depth_high.clamp(min=1e-6)
inverse_depth_high = 1.0 / depth_low.clamp(min=1e-6)
inverse_depth_normalized = ((inverse_depth - inverse_depth_low) / (inverse_depth_high - inverse_depth_low + 1e-8)).clamp(0, 1)
turbo = plt.get_cmap("turbo")
foreground_colors = torch.from_numpy(turbo(inverse_depth_normalized.cpu().numpy())[..., :3] * 255).to(torch.uint8) # (N, 3)
pointmap_rgb[:, foreground_mask] = foreground_colors.T
print("Pointmap RGB shape:", pointmap_rgb.shape) # [3, original_height, original_width]Contoh di bawah ini menunjukkan cara menjalankan estimasi pose dengan Sapiens2ForPoseEstimation.
Model memprediksi heatmap per-keypoint; gunakan post_process_pose_estimation untuk mengodekan kembali menjadi koordinat keypoint dalam ruang gambar. Diperlukan opencv-python (pip install opencv-python).
import torch
from transformers import AutoImageProcessor, AutoModelForPoseEstimation
from transformers.image_utils import load_image
image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-pose-0.4b")
model = AutoModelForPoseEstimation.from_pretrained("facebook/sapiens2-pose-0.4b", device_map="auto")
# Provide bounding boxes in COCO format (x, y, width, height) for each person
boxes = [[[270.8, 0.6, 294.1, 379.5]]]
inputs = image_processor(image, boxes=boxes, return_tensors="pt").to(model.device)
with torch.inference_mode():
outputs = model(**inputs)
# outputs.heatmaps shape: (num_persons, num_keypoints, heatmap_height, heatmap_width)
print("Heatmaps shape:", outputs.heatmaps.shape) # [1, 308, 256, 192]
# Decode heatmaps to image-space keypoint coordinates
results = image_processor.post_process_pose_estimation(outputs, boxes=boxes)[0]
keypoints = results[0]["keypoints"] # (num_keypoints, 2) — x/y in image coordinates
scores = results[0]["scores"] # (num_keypoints,) — per-keypoint confidence
print("Keypoints shape:", keypoints.shape)Augmentasi flip horizontal (augmentasi saat pengujian) meningkatkan akurasi titik kunci dengan merata-ratakan prediksi dari gambar asli dan gambar yang dicerminkan. Sampaikan flip_pairs — sebuah tensor berisi pasangan [left_keypoint, right_keypoint] — ke langkah forward kedua. Model akan membalik heatmap kembali ke orientasi asli sebelum mengembalikannya, sehingga Anda dapat langsung merata-ratakan kedua output tersebut.
import torch
from transformers import AutoImageProcessor, AutoModelForPoseEstimation
from transformers.image_utils import load_image
image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-pose-0.4b")
model = AutoModelForPoseEstimation.from_pretrained("facebook/sapiens2-pose-0.4b", device_map="auto")
boxes = [[[270.8, 0.6, 294.1, 379.5]]]
inputs = image_processor(image, boxes=boxes, return_tensors="pt").to(model.device)
pixel_values = inputs["pixel_values"]
flip_pairs = torch.tensor(model.config.flip_pairs, device=model.device)
with torch.inference_mode():
outputs = model(pixel_values)
outputs_flipped = model(pixel_values.flip(-1), flip_pairs=flip_pairs)
results = image_processor.post_process_pose_estimation(outputs, outputs_flipped=outputs_flipped, boxes=boxes)[0]
keypoints = results[0]["keypoints"]
scores = results[0]["scores"]Contoh di bawah ini menunjukkan cara menghitung kerugian Masked Mean Squared Error (MSE) yang diawasi dengan Sapiens2ForPoseEstimation dengan meneruskan labels dan label_weights opsional. Hal ini berguna untuk fine-tuning menggunakan API Trainer.
import torch
from transformers import AutoImageProcessor, AutoModelForPoseEstimation
from transformers.image_utils import load_image
image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-pose-0.4b")
model = AutoModelForPoseEstimation.from_pretrained("facebook/sapiens2-pose-0.4b", device_map="auto")
# Provide bounding boxes in COCO format (x, y, width, height) for each person
boxes = [[[270.8, 0.6, 294.1, 379.5]]]
inputs = image_processor(image, boxes=boxes, return_tensors="pt").to(model.device)
# Create dummy labels (heatmaps) and visibility weights to simulate ground truth
# 1.0 for visible keypoints, 0.0 for occluded/invisible keypoints
batch_size, num_keypoints = 1, 308
heatmap_height, heatmap_width = 1024, 768
labels = torch.randn(batch_size, num_keypoints, heatmap_height, heatmap_width, device=model.device)
label_weights = torch.ones(batch_size, num_keypoints, 1, 1, device=model.device)
# Forward pass with loss calculation
outputs = model(**inputs, labels=labels, label_weights=label_weights)
print("Loss:", outputs.loss.item())Contoh di bawah ini menunjukkan cara melakukan segmentasi bagian tubuh dengan Sapiens2ForSemanticSegmentation.
import torch
from transformers import AutoImageProcessor, AutoModelForSemanticSegmentation
from transformers.image_utils import load_image
image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-seg-0.4b")
model = AutoModelForSemanticSegmentation.from_pretrained("facebook/sapiens2-seg-0.4b", device_map="auto")
inputs = image_processor(image, return_tensors="pt").to(model.device)
with torch.inference_mode():
outputs = model(**inputs)
# outputs.logits shape: (batch_size, num_labels, height, width)
print("Logits shape:", outputs.logits.shape) # [1, 29, 1024, 768]
# Get per-pixel class predictions, optionally resized to the original image size
original_size = (image.height, image.width)
segmentation = image_processor.post_process_semantic_segmentation(
outputs, target_sizes=[original_size]
)[0]
print("Segmentation map shape:", segmentation.shape) # [original_height, original_width]Contoh di bawah ini menunjukkan cara menjalankan image matting dengan Sapiens2ForImageMatting.
Output telah diaktifkan sigmoid dan sudah berada dalam rentang [0, 1]; gunakan post_process_image_matting untuk mengubah ukuran dan memisahkan
menjadi alphas, foregrounds, dan gambar composite opsional. Gambar composite menampilkan
foreground yang ditumpangkan di atas background dengan rumus: composite = foreground * (1 - alpha) * background.
import torch
from transformers import AutoImageProcessor, AutoModelForImageMatting
from transformers.image_utils import load_image
image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-matting-1b")
model = AutoModelForImageMatting.from_pretrained("facebook/sapiens2-matting-1b", device_map="auto")
inputs = image_processor(image, return_tensors="pt").to(model.device)
with torch.inference_mode():
outputs = model(**inputs)
# outputs.foregrounds: (1, 3, H, W), outputs.alphas: (1, 1, H, W) — both in [0, 1]
original_size = (image.height, image.width)
# Pass an optional background to composite the foreground over it.
# A (3, 1, 1) tensor broadcasts as a uniform color; PIL images and numpy arrays are also accepted.
background = torch.tensor([0, 177, 64], dtype=torch.uint8).view(3, 1, 1) # chroma green in RGB
result = image_processor.post_process_image_matting(
outputs, target_sizes=[original_size], backgrounds=background
)[0]
print("Alpha shape:", result["alpha"].shape) # [1, original_height, original_width]
print("Foreground shape:", result["foreground"].shape) # [3, original_height, original_width]
print("Composite shape:", result["composite"].shape) # [3, original_height, original_width] — uint8 [0, 255]Sapiens2Config
kelas transformers.Sapiens2Config
< 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 = Nonepatch_size: int | list[int] | tuple[int, int] = 16hidden_size: int = 1024intermediate_size: int = 4096num_hidden_layers: int = 24num_attention_heads: int = 16hidden_act: str = 'silu'attention_dropout: float | int = 0.0initializer_range: float = 0.02rope_theta: float = 100.0image_size: int | list[int] | tuple[int, int] = 224num_channels: int = 3query_bias: bool = Truekey_bias: bool = Truevalue_bias: bool = Trueproj_bias: bool = Truemlp_bias: bool = Truelayerscale_value: float = 1.0drop_path_rate: float | int = 0.0use_gated_mlp: bool = Truenum_register_tokens: int = 8pos_embed_shift: float | None = Nonepos_embed_jitter: float | None = Nonepos_embed_rescale: float | None = 2.0_out_features: list[str] | None = None_out_indices: list[int] | None = Nonereshape_hidden_states: bool = Trueuse_mask_token: bool = Falserms_norm_eps: float = 1e-06normalize_backbone_outputs: bool = Trueuse_qk_norm: bool = Truenum_key_value_heads_per_layer: list[int] | None = Nonenum_key_value_attention_heads: int = 8num_first_full_attention_layers: int = 8num_last_full_attention_layers: int = 8semantic_loss_ignore_index: int = 255flip_pairs: list[list[int]] | None = Nonehead_config: transformers.models.sapiens2.configuration_sapiens2.Sapiens2HeadConfig | dict | None = None )
Parameter
- patch_size (
Union[int, list[int], tuple[int, int]], opsional, defaultnya16) — Ukuran (resolusi) dari setiap patch. - hidden_size (
int, opsional, default1024) — Dimensi dari representasi tersembunyi. - intermediate_size (
int, opsional, default4096) — Dimensi representasi MLP. - num_hidden_layers (
int, opsional, default24) — Jumlah lapisan tersembunyi dalam decoder Transformer. - num_attention_heads (
int, opsional, default16) — Jumlah attention head untuk setiap lapisan attention di decoder Transformer. - hidden_act (
str, opsional, defaultnyasilu) — Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya,"gelu","relu","silu", dan sebagainya. - attention_dropout (
Union[float, int], opsional, default0.0) — Rasio dropout untuk probabilitas perhatian. - initializer_range (
float, opsional, defaultnya0.02) — Standar deviasi dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot. - rope_theta (
float, opsional, default 100.0) — Periode dasar dari embedding RoPE. - image_size (
Union[int, list[int], tuple[int, int]], opsional, defaultnya224) — Ukuran (resolusi) dari setiap gambar. - num_channels (
int, opsional, defaultnya3) — Jumlah saluran input. - query_bias (
bool, opsional, defaultTrue) — Apakah akan menambahkan bias ke proyeksi query. - key_bias (
bool, opsional, defaultFalse) — Apakah akan menambahkan bias ke proyeksi kunci. - value_bias (
bool, opsional, defaultnyaTrue) — Apakah akan menambahkan bias ke proyeksi nilai. - proj_bias (
bool, opsional, defaultTrue) — Apakah akan menambahkan bias ke proyeksi output. - mlp_bias (
bool, opsional, defaultTrue) — Apakah akan menggunakan bias pada lapisan up_proj, down_proj, dan gate_proj di dalam lapisan MLP. - layerscale_value (
float, opsional, default 1.0) — Nilai awal yang digunakan untuk layer scale. - drop_path_rate (
Union[float, int], opsional, defaultnya0.0) — Tingkat drop path untuk fusi patch. - use_gated_mlp (
bool, opsional, defaultnyaFalse) — Apakah akan menggunakan jaringan saraf feedforward SwiGLU. - num_register_tokens (
int, opsional, default 0) — Jumlah register token. - pos_embed_shift (
float, opsional) — Jumlah pergeseran acak pada koordinat position embedding dalam rentang [-shift, shift], yang hanya diterapkan dalam mode pelatihan jika bukanNone. - pos_embed_jitter (
float, opsional) — Jumlah untuk mengacak koordinat position embedding secara acak dalam nilai log-uniform di [1/jitter, jitter], hanya diterapkan dalam mode pelatihan jika bukanNone. - pos_embed_rescale (
float, opsional, default 2.0) — Jumlah untuk melakukan rescale acak pada koordinat position embedding dalam nilai log-uniform di [1/rescale, rescale], hanya diterapkan dalam mode pelatihan jika bukanNone. - reshape_hidden_states (
bool, opsional, defaultTrue) — Apakah akan mengubah bentuk hidden states ke dimensi spasial saat digunakan sebagai backbone. - use_mask_token (
bool, opsional, defaultFalse) — Apakah akan menggunakan token mask pada embeddings (diperlukan untuk pretraining masked image modeling). - rms_norm_eps (
float, opsional, default 1e-6) — Epsilon untuk lapisan normalisasi RMS. - normalize_backbone_outputs (
bool, opsional, defaultTrue) — Apakah akan menerapkan RMSNorm pada outputfeature_mapsdancls_tokensdari backbone sebelum dikembalikan dari forward pass. Hanya berlaku ketika model digunakan sebagai backbone. - use_qk_norm (
bool, opsional, defaultTrue) — Apakah akan menerapkan RMSNorm pada query dan key sebelum RoPE di lapisan attention. - num_key_value_heads_per_layer (
list[int], opsional) — Jumlah kepala key/value untuk setiap lapisan transformer. Menetapkan nilai lapisan sama dengannum_attention_headsmenghasilkan multi-head attention penuh; nilai yang lebih kecil menghasilkan grouped-query attention. Nilainya secara default adalahnum_attention_headsuntuknum_first_full_attention_layerslapisan pertama dannum_last_full_attention_layerslapisan terakhir, sertanum_key_value_attention_headsuntuk semua lapisan lainnya. - num_key_value_attention_heads (
int, opsional, default8) — Jumlah key/value heads untuk lapisan yang menggunakan grouped-query attention ketikanum_key_value_heads_per_layertidak diatur. Diabaikan ketikanum_key_value_heads_per_layerdiatur. - num_first_full_attention_layers (
int, opsional, default 8) — Jumlah lapisan transformer awal yang menggunakan multi-head attention penuh. Hanya digunakan ketikanum_key_value_heads_per_layeradalahNone. - num_last_full_attention_layers (
int, opsional, default 8) — Jumlah lapisan transformer di bagian akhir yang menggunakan multi-head attention penuh. Hanya digunakan ketikanum_key_value_heads_per_layeradalahNone. - semantic_loss_ignore_index (
int, opsional, default 255) — Indeks label yang diabaikan saat menghitung loss segmentasi. - flip_pairs (
list[list[int]], opsional) — Pasangan indeks keypoint yang dicerminkan secara horizontal (misalnya, telinga kiri ↔ telinga kanan). Setiap pasangan adalah daftar dua elemen[left_index, right_index]. Digunakan untuk augmentasi flip horizontal pada saat pengujian dalam estimasi pose: berikan pasangan ini ke panggilan forward kedua agar model membalik heatmap kembali sebelum mengembalikannya. - head_config (
Sapiens2HeadConfig, opsional) — Konfigurasi untuk decode head. Lihat Sapiens2HeadConfig untuk opsi yang tersedia.
Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Sapiens2Model. Kelas ini digunakan untuk membuat instans model Sapiens2 berdasarkan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari facebook/sapiens2-pretrain-0.4b
Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.
Sapiens2HeadConfig
kelas transformers.Sapiens2HeadConfig
< 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 = Noneupsample_out_channels: list[int] | None = Noneupsample_kernel_sizes: list[int] | None = Noneupsample_kernel_size: int = 4use_pixel_shuffle: bool | None = Noneconv_out_channels: list[int] | None = Noneconv_kernel_sizes: list[int] | None = Noneconv_kernel_size: int = 1scale_conv_out_channels: list[int] | None = Nonescale_conv_kernel_sizes: list[int] | None = Nonescale_conv_kernel_size: int = 1scale_final_input_size: int | None = Nonescale_final_hidden_sizes: list[int] | None = None )
Parameter
- upsample_out_channels (
list[int], opsional) — Jumlah channel output untuk setiap blok upsample. Blok pertama menerimahidden_sizechannel sebagai input; blok berikutnya menggunakan output sebelumnya. - upsample_kernel_sizes (
list[int], opsional) — Ukuran kernel untuk setiap blok upsample. Diisi otomatis dengan[4, ...]ketikaupsample_out_channelsdisetel tetapi iniNone. Harus memiliki panjang yang sama denganupsample_out_channels. - upsample_kernel_size (
int, default 4) — Ukuran kernel default untuk blok upsample ketikaupsample_kernel_sizestidak diatur. - use_pixel_shuffle (
bool, opsional) — Apakah kepala upsample menggunakan upsample pixel-shuffle alih-alih konvolusi transposed. KetikaNone(default), kepala menggunakan konvolusi transposed. - conv_out_channels (
list[int], opsional) — Jumlah channel output untuk lapisan conv penyempurnaan yang mengikuti blok upsample. - conv_kernel_sizes (
list[int], opsional) — Ukuran kernel untuk setiap lapisan conv refinement. Diisi otomatis dengan[1, ...]ketikaconv_out_channelsdisetel tetapi iniNone. Harus memiliki panjang yang sama denganconv_out_channels. - conv_kernel_size (
int, defaultnya 1) — Ukuran kernel default untuk lapisan conv ketikaconv_kernel_sizestidak diatur. - scale_conv_out_channels (
list[int], opsional) — Jumlah channel output untuk lapisan conv stride-2 yang digunakan untuk memprediksi skala panjang fokus. KetikaNone(default), cabang skala tidak dibangun. - scale_conv_kernel_sizes (
list[int], opsional) — Ukuran kernel untuk setiap lapisan conv skala. Diisi otomatis dengan[1, ...]ketikascale_conv_out_channelsdisetel tetapi iniNone. Harus memiliki panjang yang sama denganscale_conv_out_channels. - scale_conv_kernel_size (
int, default 1) — Ukuran kernel default untuk lapisan scale conv ketikascale_conv_kernel_sizestidak diatur. - scale_final_input_size (
int, opsional) — Ukuran fitur datar yang diteruskan ke scale MLP. JikaNone(default), nilainya disimpulkan secara otomatis dariimage_sizedanpatch_sizedi Sapiens2Config induk. - scale_final_hidden_sizes (
list[int], opsional) — Ukuran lapisan tersembunyi untuk MLP yang memetakan fitur skala yang diratakan ke output skala skalar. KetikaNone(default), cabang skala tidak dibangun.
Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Sapiens2Model. Kelas ini digunakan untuk membuat instans model Sapiens2 berdasarkan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari facebook/sapiens2-seg-0.4b
Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.
Sapiens2ImageProcessor
kelas transformers.Sapiens2ImageProcessor
< source >( **kwargs: *<class 'transformers.models.sapiens2.image_processing_sapiens2.Sapiens2ImageProcessorKwargs'> )
Parameter
- do_convert_rgb (
bool, kwargs, opsional) — Apakah akan mengonversi gambar ke RGB. - do_resize (
bool, kwargs, opsional, defaultTrue) — Apakah akan mengubah ukuran gambar. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, defaultnya{'height' -- 1024, 'width': 768}): Menggambarkan dimensi input maksimum untuk model. - default_to_square (
bool, kwargs, opsional, defaultnyaTrue) — 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, defaultnya{'height' -- 224, 'width': 224}): Ukuran gambar keluaran setelah menerapkancenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, defaultnya2) — Filter resampling yang digunakan jika mengubah ukuran gambar. Ini bisa berupa salah satu enumPILImageResampling. Hanya berpengaruh jikado_resizediatur keTrue. - do_rescale (
bool, kwargs, opsional, defaultTrue) — Apakah akan melakukan penskalaan ulang pada gambar. - rescale_factor (
float, kwargs, opsional, default0.00392156862745098) — Faktor rescale untuk menskalakan ulang gambar jikado_rescalediatur keTrue. - do_normalize (
bool, kwargs, opsional, defaultTrue) — Apakah akan menormalisasi gambar. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, opsional, defaultnya[0.485, 0.456, 0.406]) — Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jikado_normalizediatur keTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opsional, defaultnya[0.229, 0.224, 0.225]) — Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jikado_normalizediatur keTrue. - do_pad (
bool, kwargs, opsional, defaultFalse) — 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. Jikapad_sizetidak disediakan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketikado_pad=True. - do_center_crop (
bool, kwargs, opsional, defaultFalse) — Apakah akan melakukan center crop pada gambar. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — HanyaChannelDimension.FIRSTyang 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"atauChannelDimension.FIRST: gambar dalam format (num_channels, height, width)."channels_last"atauChannelDimension.LAST: gambar dalam format (height, width, num_channels)."none"atauChannelDimension.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. - do_reduce_labels (
bool, kwargs, opsional, defaultnyaself.do_reduce_labels) — Apakah akan mengurangi semua nilai label pada peta segmentasi sebesar 1. Biasanya digunakan untuk dataset di mana 0 digunakan untuk latar belakang, dan latar belakang itu sendiri tidak termasuk dalam semua kelas dataset (mis. ADE20k). Label latar belakang akan diganti dengan 255. - keypoint_heatmap_downscale_factor (
int, kwargs, opsional, default 4) — Faktor downscale untuk ukuran heatmap target relatif terhadap ukuran input model. - keypoint_heatmap_sigma (
float, kwargs, opsional, default 6.0) — Standar deviasi (sigma) untuk distribusi Gaussian 2D yang digunakan untuk menghasilkan heatmap.
Membangun pemroses gambar Sapiens2ImageProcessor.
praproses
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Noneboxes: list[list[list[float]]] | None = Nonekeypoints: list[list[list[list[float]]]] | None = None**kwargs: *<class 'transformers.models.sapiens2.image_processing_sapiens2.Sapiens2ImageProcessorKwargs'> ) → ~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, aturdo_rescale=False. - segmentation_maps (
ImageInput, opsional) — Peta segmentasi yang akan dipreproses. - boxes (
list[list[list[float]]]ataunp.ndarray, opsional) — Daftar atau array kotak pembatas (bounding box) untuk setiap gambar. Setiap kotak harus berupa daftar 4 float yang merepresentasikan koordinat kotak pembatas dalam format COCO (top_left_x, top_left_y, width, height). Jika disediakan, setiap potongan orang (person crop) akan diwarping secara afine ke ukuran input model, alih-alih mengubah ukuran (resizing) seluruh gambar. - keypoints (
list[list[list[list[float]]]], opsional) — Daftar keypoints untuk setiap orang di setiap gambar. Format yang diharapkan adalah gaya COCO[x, y, visibility]. Nilaixdanydiharapkan berupa koordinat piksel absolut gambar. Formatnya adalah[images -> persons -> keypoints -> [x, y, visibility]]. Digunakan untuk menghasilkan peta panas ground-truth dan bobot visibilitas untuk fine-tuning estimasi pose. - 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 menerapkancenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filter resampling yang digunakan jika mengubah ukuran gambar. Ini dapat berupa salah satu enumPILImageResampling. Hanya berpengaruh jikado_resizediatur keTrue. - do_rescale (
bool, kwargs, opsional) — Apakah akan melakukan penskalaan ulang pada gambar. - rescale_factor (
float, kwargs, opsional) — Faktor rescale untuk menskalakan ulang gambar jikado_rescalediatur keTrue. - 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 jikado_normalizediatur keTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opsional) — Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jikado_normalizediatur keTrue. - 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. Jikapad_sizetidak disediakan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketikado_pad=True. - do_center_crop (
bool, kwargs, opsional) — Apakah akan melakukan center crop pada gambar. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — HanyaChannelDimension.FIRSTyang 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"atauChannelDimension.FIRST: gambar dalam format (num_channels, height, width)."channels_last"atauChannelDimension.LAST: gambar dalam format (height, width, num_channels)."none"atauChannelDimension.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. - do_reduce_labels (
bool, kwargs, opsional, defaultnyaself.do_reduce_labels) — Apakah akan mengurangi semua nilai label pada peta segmentasi sebesar 1. Biasanya digunakan untuk dataset di mana 0 digunakan untuk latar belakang, dan latar belakang itu sendiri tidak termasuk dalam semua kelas dataset (mis. ADE20k). Label latar belakang akan diganti dengan 255. - keypoint_heatmap_downscale_factor (
int, kwargs, opsional, default 4) — Faktor downscale untuk ukuran heatmap target relatif terhadap ukuran input model. - keypoint_heatmap_sigma (
float, kwargs, opsional, default 6.0) — Standar deviasi (sigma) untuk distribusi Gaussian 2D yang digunakan untuk menghasilkan heatmap.
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.
post_process_image_matting
< source >( outputstarget_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = Nonebackgrounds: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None ) → list[dict] of length batch_size. Each dict has
Parameter
- outputs (
Sapiens2ImageMattingOutput) — Output mentah dari model. - target_sizes (
torch.Tensorataulist[tuple[int, int]]dengan panjangbatch_size, opsional) — Ukuran akhir(height, width)yang diminta untuk setiap prediksi. Di-resize menggunakan interpolasi bilinear. Jika tidak diset, prediksi dikembalikan pada resolusi output model. - backgrounds (
ImageInput, opsional) — Gambar latar belakang untuk dikompositkan. Bisa berupa satu gambar (diterapkan ke setiap item dalam batch) atau daftar gambar, satu per item batch. Menerima gambar PIL, array numpy, atau tensor torch dengan dtype apa pun; tipe integer (misalnya uint8) akan diskalakan ke[0, 1]secara otomatis. Jika disediakan, setiap dict hasil akan mendapatkan kunci"composite"dengan gambar hasil komposit sebagai tensor uint8 dalam[0, 255].
Mengembalikan
list[dict] dengan panjang batch_size. Setiap dict memiliki
"alpha"(torch.Tensordengan bentuk(1, height, width)): nilai alpha dalam[0, 1]."foreground"(torch.Tensordengan bentuk(3, height, width)): RGB yang sudah dikalikan sebelumnya dalam[0, 1]."composite"(torch.Tensordengan bentuk(3, height, width)atauNone): latar depan yang dikompositkan di atasbackgroundssebagai tensor uint8 dalam[0, 255];Noneketikabackgroundstidak disediakan.
Mengonversi output dari Sapiens2ForImageMatting menjadi alpha mattes dan peta foreground.
post_process_normal_estimation
< source >( outputssource_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = Nonetarget_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = Nonedo_remove_padding: bool | None = None )
Parameter
- outputs (
Sapiens2NormalEstimatorOutput) — Output mentah dari model. - source_sizes (
torch.Tensorataulist[tuple[int, int]]dengan panjangbatch_size, opsional) —(height, width)asli dari setiap gambar sebelum prapemrosesan. Jika diberikan, padding yang ditambahkan selama prapemrosesan akan dihapus dan prediksi akan di-resize kembali ke ukuran gambar asli (kecualitarget_sizesmenimpa ukuran akhir). - target_sizes (
torch.Tensorataulist[tuple[int, int]]dengan panjangbatch_size, opsional) — Ukuran akhir(height, width)yang diminta untuk setiap prediksi. Jika diberikan, digunakan sebagai target resize alih-alihsource_sizes. Di-resize dengan interpolasi bilinear setelah normalisasi L2. - do_remove_padding (
bool, opsional) — Apakah akan memangkas zero-padding yang ditambahkan selama prapemrosesan sebelum mengubah ukuran. Nilai defaultnya adalahTruejikasource_sizesdiberikan,Falsejika tidak.
Mengonversi output dari Sapiens2ForNormalEstimation menjadi peta normal permukaan yang dinormalisasi L2.
post_process_pointmap_estimation
< source >( outputssource_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = Nonetarget_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = Nonedo_remove_padding: bool | None = None )
Parameter
- outputs (
Sapiens2PointmapEstimatorOutput) — Output mentah dari model. - source_sizes (
torch.Tensorataulist[tuple[int, int]]dengan panjangbatch_size, opsional) —(height, width)asli dari setiap gambar sebelum prapemrosesan. Jika diberikan, padding yang ditambahkan selama prapemrosesan akan dihapus dan prediksi akan di-resize kembali ke ukuran gambar asli (kecualitarget_sizesmenimpa ukuran akhir). - target_sizes (
torch.Tensorataulist[tuple[int, int]]dengan panjangbatch_size, opsional) —(height, width)akhir yang diminta untuk setiap prediksi. Mengesampingkansource_sizessebagai target resize. - do_remove_padding (
bool, opsional) — Apakah akan memangkas zero-padding yang ditambahkan selama prapemrosesan sebelum mengubah ukuran. Nilai defaultnya adalahTruejikasource_sizesdiberikan,Falsejika tidak.
Mengonversi output dari Sapiens2ForPointmapEstimation menjadi tensor pointmap dalam ruang gambar.
post_process_pose_estimation
< source >( outputsboxes: listoutputs_flipped = Nonekernel_size: int = 11threshold: float | None = Nonesource_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = Nonetarget_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None ) → list[list[dict]]
Parameter
- outputs (
Sapiens2PoseEstimatorOutput) — Output mentah dari model.outputs.heatmapsharus memiliki bentuk(N_total, num_keypoints, heatmap_height, heatmap_width)di manaN_total = sum(len(b) for b in boxes). - boxes (
list[list[list[float]]]ataunp.ndarray) — Daftar atau array kotak pembatas (bounding box) untuk setiap gambar dalam koordinat piksel absolut. Setiap kotak harus berupa daftar 4 float yang merepresentasikan koordinat kotak pembatas dalam format COCO (top_left_x, top_left_y, width, height). Harus sesuai dengan argumenboxesyang diteruskan kepreprocess. - outputs_flipped (
Sapiens2PoseEstimatorOutput, opsional) — Hasil keluaran dari menjalankan model pada input yang dibalik secara horizontal. Jika disediakan, heatmap di-rata-ratakan denganoutputssebelum ekstraksi keypoint untuk meningkatkan akurasi:avg_heatmaps = (outputs.heatmaps + outputs_flipped.heatmaps) / 2. - kernel_size (
int, opsional, default 11) — Ukuran kernel untuk Gaussian blur yang digunakan dalam penyempurnaan UDP Dark Pose. - threshold (
float, opsional) — Ambang batas skor. Keypoint dengan skor di bawah atau sama dengan nilai ini akan disingkirkan dari kamus hasil. - source_sizes (
torch.Tensorataulist[tuple[int, int]]dengan panjangbatch_size, opsional) —(height, width)asli dari setiap gambar dalam piksel. Wajib diisi ketikatarget_sizesdiberikan, sebagai ruang koordinat sumber untuk penskalaan titik kunci dan kotak batas. - target_sizes (
torch.Tensorataulist[tuple[int, int]]dengan panjangbatch_size, opsional) — Ruang koordinat(height, width)keluaran yang diinginkan untuk setiap gambar. Ketika diberikan bersamasource_sizes, koordinat keypoint dan bounding box akan diskalakan dari ruang sumber ke ruang target.
Mengembalikan
list[list[dict]]
Daftar luar adalah untuk gambar, daftar dalam adalah untuk orang. Setiap dict berisi:
keypoints(torch.FloatTensordengan bentuk(num_keypoints, 2)): koordinat x/y absolut dalam ruang gambar sumber, atau dalam ruang target jikatarget_sizesdisediakan.scores(torch.FloatTensordengan bentuk(num_keypoints,)): tingkat kepercayaan per-keypoint.labels(torch.LongTensordengan bentuk(num_keypoints,)): indeks keypoint.bbox(torch.FloatTensordengan bentuk(4,)): kotak pembatas dalam format absolut (x_min, y_min, x_max, y_max), pada ruang koordinat yang sama dengankeypoints.
Mengonversi output dari Sapiens2ForPoseEstimation menjadi prediksi keypoint dalam ruang gambar.
post_process_semantic_segmentation
< source >( outputstarget_sizes: list[tuple] | None = Nonereturn_segmentation_scores: bool = False ) → list[torch.Tensor] or list[SemanticSegmentationPostProcessorOutput]
Parameter
- outputs (Sapiens2ForSemanticSegmentation) — Output mentah dari model.
- target_sizes (
list[Tuple]dengan panjangbatch_size, opsional) — Daftar tuple yang sesuai dengan ukuran akhir (tinggi, lebar) yang diminta untuk setiap prediksi. Jika tidak disetel, prediksi tidak akan di-resize. - return_segmentation_scores (
bool, opsional, defaultFalse) — Apakah akan mengembalikan skor segmentasi bersama peta segmentasi. KetikaTrue, setiap elemen dari daftar yang dikembalikan adalahSemanticSegmentationPostProcessorOutputdengan fieldsegmentation(ID kelas, bentuk(height, width)) dansegmentation_scores(bentuk(num_classes, height, width)).
Mengembalikan
list[torch.Tensor] atau list[SemanticSegmentationPostProcessorOutput]
Ketika
return_segmentation_scores=False (default), sebuah daftar dengan panjang batch_size di mana setiap item adalah
peta segmentasi dengan bentuk (height, width) berisi ID kelas. Ketika return_segmentation_scores=True,
sebuah daftar SemanticSegmentationPostProcessorOutput dengan field segmentation (ID kelas, bentuk
(height, width)) dan segmentation_scores (bentuk (num_classes, height, width)). Dalam kedua kasus,
(height, width) sesuai dengan ukuran target (jika target_sizes ditentukan).
Mengonversi output dari Sapiens2ForSemanticSegmentation menjadi peta segmentasi semantik.
Sapiens2Model
kelas transformers.Sapiens2Model
< source >( config: Sapiens2Config )
Parameter
- config (Sapiens2Config) — 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 Sapiens2 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: Tensorbool_masked_pos: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.FloatTensor)
Parameter
- pixel_values (
torch.Tensordengan bentuk(batch_size, num_channels, image_size, image_size)) — Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan Sapiens2ImageProcessor. Lihat Sapiens2ImageProcessor.call() untuk detailnya (processor_classmenggunakan Sapiens2ImageProcessor untuk memproses gambar). - bool_masked_pos (
torch.BoolTensordengan bentuk(batch_size, sequence_length), opsional) — Posisi yang dimask secara boolean. Menunjukkan patch mana yang dimask (1) dan mana yang tidak (0). Hanya relevan untuk pre-training.
Mengembalikan
BaseModelOutputWithPooling atau tuple(torch.FloatTensor)
A BaseModelOutputWithPooling atau tuple dari
torch.FloatTensor (jika return_dict=False dilewatkan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (Sapiens2Config) dan input.
Metode forward dari Sapiens2Model menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya 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.FloatTensordengan bentuk(batch_size, sequence_length, hidden_size)) — Urutan hidden-states pada keluaran lapisan terakhir model.pooler_output (
torch.FloatTensordengan bentuk(batch_size, hidden_size)) — State tersembunyi dari lapisan terakhir untuk 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.FloatTensor), opsional, dikembalikan saatoutput_hidden_states=Truedilewatkan atau saatconfig.output_hidden_states=True) — Tuple daritorch.FloatTensor(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.FloatTensor), opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.FloatTensor(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 AutoImageProcessor, AutoModel
>>> from transformers.image_utils import load_image
>>> import torch
>>> image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-pretrain-0.4b")
>>> model = AutoModel.from_pretrained("facebook/sapiens2-pretrain-0.4b")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> with torch.inference_mode():
... outputs = model(**inputs)
>>> cls_token = outputs.pooler_output
>>> cls_token.shape
torch.Size([1, 1024])Sapiens2Backbone
kelas transformers.Sapiens2Backbone
< source >( config: Sapiens2Config )
Parameter
- config (Sapiens2Config) — 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 Sapiens2.
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: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2BackboneOutput or tuple(torch.FloatTensor)
Parameter
- pixel_values (
torch.Tensordengan bentuk(batch_size, num_channels, image_size, image_size)) — Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan Sapiens2ImageProcessor. Lihat Sapiens2ImageProcessor.call() untuk detailnya (processor_classmenggunakan Sapiens2ImageProcessor untuk memproses gambar).
Mengembalikan
Sapiens2BackboneOutput atau tuple(torch.FloatTensor)
Sapiens2BackboneOutput atau tuple dari
torch.FloatTensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (Sapiens2Config) dan input.
Metode forward dari Sapiens2Backbone menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya 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.FloatTensor)dengan bentuk(batch_size, num_channels, height, width)) — Feature maps dari setiap tahap.hidden_states (
tuple(torch.FloatTensor), opsional, dikembalikan saatoutput_hidden_states=Truedilewatkan atau saatconfig.output_hidden_states=True) — Tuple daritorch.FloatTensor(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.FloatTensor), opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.FloatTensor(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).
cls_tokens (
tuple(torch.FloatTensor), opsional) — token CLS dari setiap tahap fitur yang dipilih, masing-masing dengan bentuk(batch_size, hidden_size). Hanya ada ketikaconfig.return_class_token=True.
Contoh:
>>> from transformers import AutoBackbone, AutoImageProcessor
>>> from transformers.image_utils import load_image
>>> import torch
>>> image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-pretrain-0.4b")
>>> model = AutoBackbone.from_pretrained("facebook/sapiens2-pretrain-0.4b")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> with torch.inference_mode():
... outputs = model(**inputs, return_class_token=True)
>>> outputs.feature_maps[0].shape
torch.Size([1, 1024, 64, 48])
>>> outputs.cls_tokens[0].shape
torch.Size([1, 1024])Sapiens2ForImageMatting
kelas transformers.Sapiens2ForImageMatting
< source >( config: Sapiens2Config )
Parameter
- config (Sapiens2Config) — 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 Sapiens2 dengan kepala matting di atasnya (dekoder berbasis PixelShuffle yang memprediksi latar depan RGB pre-multiplied dan matte alpha).
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: FloatTensorlabels: typing.Optional[torch.FloatTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2ImageMattingOutput or tuple(torch.FloatTensor)
Parameter
- pixel_values (
torch.FloatTensordengan bentuk(batch_size, num_channels, image_size, image_size)) — Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan Sapiens2ImageProcessor. Lihat Sapiens2ImageProcessor.call() untuk detailnya (processor_classmenggunakan Sapiens2ImageProcessor untuk memproses gambar). - labels (
torch.FloatTensordengan bentuk(batch_size, 4, height, width), opsional) — Target matting ground-truth untuk menghitung loss.
Mengembalikan
Sapiens2ImageMattingOutput atau tuple(torch.FloatTensor)
Sapiens2ImageMattingOutput atau tuple dari
torch.FloatTensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (Sapiens2Config) dan input.
Metode forward dari Sapiens2ForImageMatting menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.
loss (
torch.FloatTensordengan bentuk(1,), opsional, dikembalikan saatlabelsdisediakan) — Loss.alphas (
torch.FloatTensordengan bentuk(batch_size, 1, height, width)) — Nilai alpha yang diperkirakan.hidden_states (
tuple(torch.FloatTensor), opsional, dikembalikan saatoutput_hidden_states=Truedilewatkan atau saatconfig.output_hidden_states=True) — Tuple daritorch.FloatTensor(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.FloatTensor], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.FloatTensor(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).
foregrounds (
torch.FloatTensordengan bentuk(batch_size, 3, height, width)) — Prediksi foreground RGB yang sudah dikalikan sebelumnya (pre-multiplied) dalam rentang[0, 1](diaktifkan dengan sigmoid).
Contoh:
>>> from transformers import AutoImageProcessor, AutoModel
>>> from transformers.image_utils import load_image
>>> import torch
>>> image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-matting-1b")
>>> model = AutoModel.from_pretrained("facebook/sapiens2-matting-1b")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.inference_mode():
... outputs = model(**inputs)
>>> outputs.alphas.shape
torch.Size([1, 1, 1024, 768])
>>> outputs.foregrounds.shape
torch.Size([1, 3, 1024, 768])Sapiens2ForNormalEstimation
kelas transformers.Sapiens2ForNormalEstimation
< source >( config: Sapiens2Config )
Parameter
- config (Sapiens2Config) — 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 Sapiens2 dengan kepala estimasi normal di atasnya (dekoder berbasis PixelShuffle yang memetakan peta normal permukaan).
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: FloatTensorlabels: typing.Optional[torch.FloatTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2NormalEstimatorOutput or tuple(torch.FloatTensor)
Parameter
- pixel_values (
torch.FloatTensordengan bentuk(batch_size, num_channels, image_size, image_size)) — Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan Sapiens2ImageProcessor. Lihat Sapiens2ImageProcessor.call() untuk detailnya (processor_classmenggunakan Sapiens2ImageProcessor untuk memproses gambar). - labels (
torch.FloatTensordengan bentuk(batch_size, num_labels, height, width), opsional) — Peta normal permukaan ground-truth untuk menghitung loss.
Mengembalikan
Sapiens2NormalEstimatorOutput atau tuple(torch.FloatTensor)
Sapiens2NormalEstimatorOutput atau tuple dari
torch.FloatTensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (Sapiens2Config) dan input.
Metode forward dari Sapiens2ForNormalEstimation menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.
- loss (
torch.FloatTensordengan bentuk(1,), opsional, dikembalikan ketikalabelsdisediakan) — Loss estimasi normal. - normals (
torch.FloatTensordengan bentuk(batch_size, num_labels, height, width)) — Prediksi peta normal mentah yang dihasilkan oleh model (belum dinormalisasi). - hidden_states (
tuple(torch.FloatTensor), opsional, dikembalikan ketikaoutput_hidden_states=Truedilewatkan atau ketikaconfig.output_hidden_states=True) — Tuple daritorch.FloatTensor(satu untuk output embeddings + satu untuk output setiap tahap) dengan bentuk(batch_size, sequence_length, hidden_size). Hidden-states dari model pada output setiap layer ditambah output embedding awal. - attentions (
tuple(torch.FloatTensor), opsional, dikembalikan ketikaoutput_attentions=Truedilewatkan atau ketikaconfig.output_attentions=True) — Tuple daritorch.FloatTensor(satu per lapisan) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length). Bobot perhatian setelah softmax perhatian.
Contoh:
>>> from transformers import AutoImageProcessor, AutoModel
>>> from transformers.image_utils import load_image
>>> import torch
>>> image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-normal-0.4b")
>>> model = AutoModel.from_pretrained("facebook/sapiens2-normal-0.4b")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.inference_mode():
... outputs = model(**inputs)
>>> outputs.normals.shape
torch.Size([1, 3, 1024, 768])Sapiens2ForPointmapEstimation
kelas transformers.Sapiens2ForPointmapEstimation
< source >( config: Sapiens2Config )
Parameter
- config (Sapiens2Config) — 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 Sapiens2 dengan kepala pointmap di atasnya (dekoder berbasis PixelShuffle yang memprediksi koordinat 3D XYZ per piksel, ditambah cabang skala opsional untuk normalisasi panjang fokus).
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: FloatTensorlabels: typing.Optional[torch.FloatTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2PointmapEstimatorOutput or tuple(torch.FloatTensor)
Parameter
- pixel_values (
torch.FloatTensordengan bentuk(batch_size, num_channels, image_size, image_size)) — Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan Sapiens2ImageProcessor. Lihat Sapiens2ImageProcessor.call() untuk detailnya (processor_classmenggunakan Sapiens2ImageProcessor untuk memproses gambar). - labels (
torch.FloatTensordengan bentuk(batch_size, 3, height, width), opsional) — Pointmap ground-truth untuk menghitung loss.
Mengembalikan
Sapiens2PointmapEstimatorOutput atau tuple(torch.FloatTensor)
Sapiens2PointmapEstimatorOutput atau tuple dari
torch.FloatTensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (Sapiens2Config) dan input.
Metode forward dari Sapiens2ForPointmapEstimation menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.
- loss (
torch.FloatTensordengan bentuk(1,), opsional, dikembalikan ketikalabelsdisediakan) — Loss estimasi pointmap. - pointmaps (
torch.FloatTensordengan bentuk(batch_size, 3, height, width)) — Prediksi koordinat 3D XYZ per piksel dalam ruang kamera kanonik. - scales (
torch.FloatTensordengan bentuk(batch_size, 1), opsional) — Rasio panjang fokus kanonik / panjang fokus aktual.Nonejika cabang skala tidak dikonfigurasi. - hidden_states (
tuple(torch.FloatTensor), opsional, dikembalikan ketikaoutput_hidden_states=Truedilewatkan atau ketikaconfig.output_hidden_states=True) — Tuple daritorch.FloatTensor(satu untuk output embeddings + satu untuk output setiap tahap) dengan bentuk(batch_size, sequence_length, hidden_size). Hidden-states dari model pada output setiap layer ditambah output embedding awal. - attentions (
tuple(torch.FloatTensor), opsional, dikembalikan ketikaoutput_attentions=Truedilewatkan atau ketikaconfig.output_attentions=True) — Tuple daritorch.FloatTensor(satu per lapisan) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length). Bobot perhatian setelah softmax perhatian.
Contoh:
>>> from transformers import AutoImageProcessor, AutoModel
>>> from transformers.image_utils import load_image
>>> import torch
>>> image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-pointmap-0.4b")
>>> model = AutoModel.from_pretrained("facebook/sapiens2-pointmap-0.4b")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.inference_mode():
... outputs = model(**inputs)
>>> outputs.pointmaps.shape
torch.Size([1, 3, 1024, 768])Sapiens2ForPoseEstimation
kelas transformers.Sapiens2ForPoseEstimation
< source >( config: Sapiens2Config )
Parameter
- config (Sapiens2Config) — 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 Sapiens2 dengan kepala estimasi pose di atasnya (sebuah set prediktor heatmap di atas keluaran hidden states).
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: FloatTensorflip_pairs: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.FloatTensor] = Nonelabel_weights: typing.Optional[torch.FloatTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2PoseEstimatorOutput or tuple(torch.FloatTensor)
Parameter
- pixel_values (
torch.FloatTensordengan bentuk(batch_size, num_channels, image_size, image_size)) — Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan Sapiens2ImageProcessor. Lihat Sapiens2ImageProcessor.call() untuk detailnya (processor_classmenggunakan Sapiens2ImageProcessor untuk memproses gambar). - flip_pairs (
torch.Tensordengan bentuk(num_pairs, 2), opsional) — Pasangan titik kunci yang saling cermin (misalnya, telinga kiri — telinga kanan), digunakan untuk augmentasi flip saat pengujian. Jika disediakan, model mengasumsikanpixel_valuesberisi gambar yang dibalik secara horizontal dan memanggilflip_backpada peta panas keluaran untuk memulihkan orientasi aslinya. - labels (
torch.FloatTensordengan bentuk(batch_size, num_keypoints, height, width), opsional) — Ground truth heatmap untuk menghitung loss. - label_weights (
torch.FloatTensordengan bentuk(batch_size, num_labels, 1, 1)atau(batch_size, num_labels, height, width), opsional) — Bobot visibilitas untuk setiap keypoint. Harus dapat di-broadcast ke bentuklabels.
Mengembalikan
Sapiens2PoseEstimatorOutput atau tuple(torch.FloatTensor)
Sapiens2PoseEstimatorOutput atau tuple dari
torch.FloatTensor (jika return_dict=False dilewatkan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (Sapiens2Config) dan input.
Metode forward dari Sapiens2ForPoseEstimation menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.
loss (
torch.FloatTensordengan bentuk(1,), opsional, dikembalikan saatlabelsdisediakan) — Loss estimasi pose.heatmaps (
torch.FloatTensordengan bentuk(batch_size, num_keypoints, height, width)) — Heatmaps yang diprediksi oleh model.hidden_states (
tuple(torch.FloatTensor), opsional, dikembalikan saatoutput_hidden_states=Truedilewatkan atau saatconfig.output_hidden_states=True) — Tuple daritorch.FloatTensor(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.FloatTensor, ...], opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.FloatTensor(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 AutoImageProcessor, AutoModel
>>> from transformers.image_utils import load_image
>>> import torch
>>> image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-pose-0.4b")
>>> model = AutoModel.from_pretrained("facebook/sapiens2-pose-0.4b")
>>> boxes = [[[270.8, 0.6, 294.1, 379.5]]]
>>> inputs = image_processor(image, boxes=boxes, return_tensors="pt")
>>> with torch.inference_mode():
... outputs = model(**inputs)
>>> outputs.heatmaps.shape
torch.Size([1, 308, 256, 192])Sapiens2ForSemanticSegmentation
kelas transformers.Sapiens2ForSemanticSegmentation
< source >( config: Sapiens2Config )
Parameter
- config (Sapiens2Config) — 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 Sapiens2 dengan kepala segmentasi semantik di atasnya, misalnya untuk ADE20K, CityScapes.
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: FloatTensorlabels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SemanticSegmenterOutput or tuple(torch.FloatTensor)
Parameter
- pixel_values (
torch.FloatTensordengan bentuk(batch_size, num_channels, image_size, image_size)) — Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan Sapiens2ImageProcessor. Lihat Sapiens2ImageProcessor.call() untuk detailnya (processor_classmenggunakan Sapiens2ImageProcessor untuk memproses gambar). - labels (
torch.LongTensordengan bentuk(batch_size, height, width), opsional) — Peta segmentasi semantik ground truth untuk menghitung loss. Indeks harus berada dalam[0, ..., config.num_labels - 1]. Jikaconfig.num_labels > 1, loss klasifikasi dihitung (Cross-Entropy).
Mengembalikan
SemanticSegmenterOutput atau tuple(torch.FloatTensor)
A SemanticSegmenterOutput atau tuple dari
torch.FloatTensor (jika return_dict=False dilewatkan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (Sapiens2Config) dan input.
Metode forward dari Sapiens2ForSemanticSegmentation menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.
loss (
torch.FloatTensordengan bentuk(1,), opsional, dikembalikan saatlabelsdisediakan) — Loss klasifikasi (atau regresi jika config.num_labels==1).logits (
torch.FloatTensordengan bentuk(batch_size, config.num_labels, logits_height, logits_width)) — Skor klasifikasi untuk setiap piksel.Logits yang dikembalikan tidak selalu memiliki ukuran yang sama dengan
pixel_valuesyang diberikan sebagai input. Hal ini dilakukan untuk menghindari dua kali interpolasi dan kehilangan kualitas ketika pengguna perlu mengubah ukuran logits menjadi ukuran gambar asli sebagai pascapemrosesan. Anda harus selalu memeriksa bentuk logits Anda dan mengubah ukurannya sesuai kebutuhan.hidden_states (
tuple(torch.FloatTensor), opsional, dikembalikan saatoutput_hidden_states=Truedilewatkan atau saatconfig.output_hidden_states=True) — Tuple daritorch.FloatTensor(satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk(batch_size, patch_size, hidden_size).Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (
tuple(torch.FloatTensor), opsional, dikembalikan saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.FloatTensor(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, AutoModel
>>> from transformers.image_utils import load_image
>>> import torch
>>> image = load_image("http://images.cocodataset.org/val2017/000000004016.jpg")
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/sapiens2-seg-0.4b")
>>> model = AutoModel.from_pretrained("facebook/sapiens2-seg-0.4b")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.inference_mode():
... outputs = model(**inputs)
>>> outputs.logits.shape
torch.Size([1, 29, 1024, 768])