Transformers documentation
Sapiens2
Эта модель была опубликована в HF papers 23.04.2026 и добавлена в Hugging Face Transformers 03.06.2026.
Sapiens2
Обзор
Модель Sapiens2 была предложена в работе Sapiens2 Rawal Khirodkar, He Wen, Julieta Martinez, Yuan Dong, Zhaoen Su, Shunsuke Saito. Sapiens2 — это семейство высокодетализированных vision transformers, предварительно обученных на ~1 миллиарде отобранных изображений людей, предназначенное для задач компьютерного зрения, ориентированных на человека, включая оценку позы, сегментацию частей тела, оценку поверхностных нормалей и оценку pointmap.
Все исходные контрольные точки Sapiens2 можно найти в коллекции Sapiens2.
Аннотация из статьи следующая:
Мы представляем Sapiens2 — семейство трансформеров высокого разрешения для задач компьютерного зрения, ориентированных на человека, с акцентом на обобщаемость, универсальность и высокое качество результатов. Мы обучаем модель на ~1 млрд отобранных изображений высокого качества с улучшенными аннотациями задач и сочетаем восстановление изображений с маскированием с само-дистиллированными контрастными целями, чтобы обучать как низкоуровневые, так и семантические признаки. Наши модели масштабируются от 0,4 до 5 млрд параметров и обучаются в нативном разрешении 1K, а иерархические варианты 4K обеспечивают расширенное пространственное рассуждение. Sapiens2 демонстрирует существенное улучшение по сравнению с предыдущей версией: +4 mAP в оценке позы, +24,3 mIoU в сегментации частей тела и снижение ошибки на 45,6% в оценке нормалей, а также расширяется на новые задачи, такие как оценка pointmap и альбедо. Код доступен публично.
Советы:
- Sapiens2 использует Rotary Position Embeddings (RoPE) и поддерживает произвольные разрешения входных данных. По умолчанию процессор изображений изменяет размер изображений до 1024×768 (высота×ширина).
- Модель использует Grouped Query Attention (GQA) для средних слоёв и полное multi-head внимание для первых и последних 8 слоёв.
- Регистрационные токены (по умолчанию — 8) снижают артефакты с высокой нормой в патч-токенах, что приводит к более чистым картам внимания и лучшей производительности на задачах плотного предсказания.
Эта модель была предоставлена пользователем guarin. Исходный код можно найти здесь.
Примеры использования
Пример ниже показывает, как получить токен CLS (эмбеддинг всего изображения) с помощью 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 предоставляет токены патчей, уже преобразованные в пространственные размеры, и токены CLS непосредственно в объекте результата.
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]Пример ниже показывает, как оценить нормали поверхности с помощью Sapiens2ForNormalEstimation.
Выводимые нормали являются необработанными (ненормированными); используйте post_process_normal_estimation, чтобы изменить их размер и нормировать по 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]Пример ниже показывает, как оценить 3D-координаты для каждого пикселя с помощью Sapiens2ForPointmapEstimation.
Используйте post_process_pointmap_estimation, чтобы удалить отступы, добавленные на этапе предобработки, изменить размер до исходного размера изображения и применить предсказанный масштаб фокусного расстояния.
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]Пример ниже показывает, как выполнить оценку позы с помощью Sapiens2ForPoseEstimation.
Модель предсказывает тепловые карты для каждой ключевой точки; для их декодирования обратно в координаты ключевых точек в пространстве изображения используйте post_process_pose_estimation. Для этого требуется 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)Аугментация горизонтальным отражением (аугментация на этапе тестирования) повышает точность предсказания ключевых точек за счёт усреднения предсказаний для исходного и зеркально отражённого изображения. Передайте flip_pairs — тензор пар [left_keypoint, right_keypoint] — во второй проход. Модель возвращает тепловые карты в исходной ориентации перед их возвратом, поэтому вы можете напрямую усреднить оба результата.
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"]Пример ниже показывает, как вычислить контролируемый (supervised) средний квадратичный (MSE) критерий потерь с помощью Sapiens2ForPoseEstimation, передав labels и необязательный label_weights. Это полезно для дообучения с использованием 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())Пример ниже показывает, как выполнить сегментацию частей тела с помощью 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]Пример ниже показывает, как выполнить маттинг изображения с помощью Sapiens2ForImageMatting.
Выводы уже активированы сигмоидой и находятся в диапазоне [0, 1]; используйте post_process_image_matting, чтобы изменить размер и разделить
результат на alphas, foregrounds и необязательное изображение composite. Композитное изображение показывает
передний план, наложенный на фон по формуле: 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
класс 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 )
Параметры
- patch_size (
Union[int, list[int], tuple[int, int]], необязательный, по умолчанию16) — Размер (разрешение) каждого патча. - hidden_size (
int, необязательный, по умолчанию1024) — Размерность скрытых представлений. - intermediate_size (
int, необязательный, по умолчанию4096) — Размерность представлений MLP. - num_hidden_layers (
int, необязательный, по умолчанию24) — Количество скрытых слоев в декодере Transformer. - num_attention_heads (
int, необязательный, по умолчанию16) — Количество головок внимания в каждом слое внимания декодера Transformer. - hidden_act (
str, необязательный, по умолчаниюsilu) — Нелинейная функция активации (функция или строка) в декодере. Например,"gelu","relu","silu"и т. д. - attention_dropout (
Union[float, int], необязательный, по умолчанию0.0) — Коэффициент dropout для вероятностей внимания. - initializer_range (
float, необязательный, по умолчанию0.02) — Стандартное отклонение truncated_normal_initializer, используемое для инициализации всех матриц весов. - rope_theta (
float, необязательный, по умолчанию 100.0) — Базовый период вложений RoPE. - image_size (
Union[int, list[int], tuple[int, int]], необязательный, по умолчанию224) — Размер (разрешение) каждого изображения. - num_channels (
int, необязательный, по умолчанию3) — Количество входных каналов. - query_bias (
bool, необязательный, по умолчаниюTrue) — Указывает, следует ли добавлять смещение (bias) к проекции запроса. - key_bias (
bool, необязательный, по умолчаниюFalse) — Указывает, нужно ли добавлять смещение (bias) к проекции ключей. - value_bias (
bool, необязательный, по умолчаниюTrue) — Указывает, следует ли добавлять смещение (bias) к проекции значения. - proj_bias (
bool, необязательный, по умолчаниюTrue) — Указывает, следует ли добавлять смещение (bias) к выходной проекции. - mlp_bias (
bool, необязательный, по умолчаниюTrue) — Использовать ли смещение (bias) в слоях up_proj, down_proj и gate_proj внутри MLP-слоёв. - layerscale_value (
float, необязательный, по умолчанию 1.0) — Начальное значение для layer scale. - drop_path_rate (
Union[float, int], необязательный, по умолчанию0.0) — Коэффициент drop path для слияния патчей. - use_gated_mlp (
bool, необязательный, по умолчаниюFalse) — Использовать ли свёрточную нейронную сеть SwiGLU. - num_register_tokens (
int, необязательный, по умолчанию 0) — Количество регистрационных токенов. - pos_embed_shift (
float, необязательный) — Величина случайного смещения координат позиционных эмбеддингов в диапазоне [-shift, shift], применяется только в режиме обучения, если значение не равноNone. - pos_embed_jitter (
float, необязательный) — Величина случайного смещения координат позиционных эмбеддингов в логарифмически равномерном диапазоне [1/jitter, jitter], применяется только в режиме обучения, если значение не равноNone. - pos_embed_rescale (
float, необязательный, по умолчанию 2.0) — Коэффициент случайного масштабирования координат позиционных эмбеддингов в логарифмически равномерном диапазоне [1/rescale, rescale], применяется только в режиме обучения, если не равноNone. - reshape_hidden_states (
bool, необязательный, по умолчаниюTrue) — Определяет, нужно ли преобразовывать скрытые состояния в пространственные размеры при использовании в качестве базовой модели. - use_mask_token (
bool, необязательный, по умолчаниюFalse) — Использовать ли токен маски в эмбеддингах (необходимо для предобучения с маскированием изображений). - rms_norm_eps (
float, необязательный, по умолчанию 1e-6) — Значение epsilon для слоёв нормализации RMS. - normalize_backbone_outputs (
bool, необязательный, по умолчаниюTrue) — Определяет, следует ли применять RMSNorm к выходнымfeature_mapsиcls_tokensбэкбона перед их возвратом из прямого прохода. Действует только при использовании модели в качестве бэкбона. - use_qk_norm (
bool, необязательный, по умолчаниюTrue) — Применять ли RMSNorm к запросам и ключам перед RoPE в слоях внимания. - num_key_value_heads_per_layer (
list[int], необязательный) — Количество ключевых/значимых головок для каждого слоя трансформера. Если значение для слоя равноnum_attention_heads, используется полное многоголовное внимание; меньшее значение обеспечивает групповое запросно-ответное внимание (grouped-query attention). По умолчанию для первыхnum_first_full_attention_layersи последнихnum_last_full_attention_layersслоёв значение равноnum_attention_heads, а для всех остальных слоёв —num_key_value_attention_heads. - num_key_value_attention_heads (
int, необязательный, по умолчанию8) — Число ключевых/значимых головок для слоев, использующих групповое внимание (grouped-query attention), еслиnum_key_value_heads_per_layerне задано. Игнорируется, еслиnum_key_value_heads_per_layerзадано. - num_first_full_attention_layers (
int, необязательный, по умолчанию 8) — Количество начальных трансформерных слоев, использующих полное многоголовное внимание. Используется только тогда, когдаnum_key_value_heads_per_layerравноNone. - num_last_full_attention_layers (
int, необязательный, по умолчанию 8) — Количество последних трансформерных слоев, использующих полное многоголовное внимание. Используется только тогда, когдаnum_key_value_heads_per_layerравноNone. - semantic_loss_ignore_index (
int, необязательный, по умолчанию 255) — Индекс метки, который игнорируется при вычислении функции потерь для сегментации. - flip_pairs (
list[list[int]], необязательный) — Пары индексов ключевых точек, которые зеркально отражаются по горизонтали (например, левое ухо ↔ правое ухо). Каждая пара — это список из двух элементов[left_index, right_index]. Используется для горизонтального отражения на этапе тестирования в задаче оценки позы: передайте эти пары во второй вызов forward, чтобы модель отражала тепловые карты обратно перед их возвратом. - head_config (
Sapiens2HeadConfig, необязательный) — Конфигурация для декодирующей головы. См. Sapiens2HeadConfig для доступных опций.
Это класс конфигурации для хранения настроек модели Sapiens2Model. Он используется для создания экземпляра модели Sapiens2 в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации facebook/sapiens2-pretrain-0.4b
Объекты конфигурации наследуются от PreTrainedConfig и могут использоваться для управления выводами модели. Подробнее читайте в документации PreTrainedConfig.
Sapiens2HeadConfig
класс 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 )
Параметры
- upsample_out_channels (
list[int], необязательный) — Количество выходных каналов для каждого блока апсемплинга. Первый блок принимает на входhidden_sizeканалов; последующие блоки используют предыдущий выход. - upsample_kernel_sizes (
list[int], необязательный) — Размер ядра для каждого блока апсемплинга. Автоматически заполняется значением[4, ...], еслиupsample_out_channelsзадано, а это значение равноNone. Длина должна совпадать с длинойupsample_out_channels. - upsample_kernel_size (
int, по умолчанию 4) — Размер ядра по умолчанию для блоков upsample, еслиupsample_kernel_sizesне задан. - use_pixel_shuffle (
bool, необязательный) — Указывает, использует ли головная часть для увеличения разрешения операцию pixel-shuffle вместо транспонированных свёрток. ЕслиNone(по умолчанию), головная часть использует транспонированные свёртки. - conv_out_channels (
list[int], необязательный) — Количество выходных каналов для уточняющих свёрточных слоёв, следующих за блоками апсемплинга. - conv_kernel_sizes (
list[int], необязательный) — Размер ядра для каждого слоя уточняющей свёртки. Автоматически заполняется значением[1, ...], еслиconv_out_channelsзадано, а это значение равноNone. Длина должна совпадать с длинойconv_out_channels. - conv_kernel_size (
int, по умолчанию 1) — Размер ядра по умолчанию для свёрточных слоёв, еслиconv_kernel_sizesне задан. - scale_conv_out_channels (
list[int], необязательный) — Количество выходных каналов для сверточных слоев с шагом 2, используемых для предсказания масштаба фокусного расстояния. ЕслиNone(по умолчанию), ветка масштаба не создается. - scale_conv_kernel_sizes (
list[int], необязательный) — Размер ядра для каждого слоя масштабного свёртывания. Автоматически заполняется значением[1, ...], еслиscale_conv_out_channelsзадано, а это значение равноNone. Длина должна совпадать с длинойscale_conv_out_channels. - scale_conv_kernel_size (
int, по умолчанию 1) — Размер ядра по умолчанию для слоёв scale conv, еслиscale_conv_kernel_sizesне задан. - scale_final_input_size (
int, необязательный) — Размер сглаженных признаков, передаваемый в масштабный MLP. ЕслиNone(по умолчанию), значение автоматически вычисляется изimage_sizeиpatch_sizeв родительском Sapiens2Config. - scale_final_hidden_sizes (
list[int], необязательный) — Размеры скрытых слоёв для MLP, который отображает сглаженные признаки масштаба на скалярный выход масштаба. ЕслиNone(по умолчанию), ветка масштаба не создаётся.
Это класс конфигурации для хранения настроек модели Sapiens2Model. Он используется для создания экземпляра модели Sapiens2 в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации facebook/sapiens2-seg-0.4b
Объекты конфигурации наследуются от PreTrainedConfig и могут использоваться для управления выводами модели. Подробнее читайте в документации PreTrainedConfig.
Sapiens2ImageProcessor
класс transformers.Sapiens2ImageProcessor
< source >( **kwargs: *<class 'transformers.models.sapiens2.image_processing_sapiens2.Sapiens2ImageProcessorKwargs'> )
Параметры
- do_convert_rgb (
bool, kwargs, optional) — Следует ли преобразовать изображение в RGB. - do_resize (
bool, kwargs, optional, по умолчаниюTrue) — Указывает, нужно ли изменять размер изображения. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, по умолчанию{'height' -- 1024, 'width': 768}): Определяет максимальные размеры входных данных для модели. - default_to_square (
bool, kwargs, optional, по умолчаниюTrue) — Определяет, следует ли по умолчанию использовать квадратное изображение при изменении размера, если size задано как int. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, по умолчанию{'height' -- 224, 'width': 224}): Размер выходного изображения после примененияcenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, по умолчанию2) — Фильтр ресемплинга, используемый при изменении размера изображения. Может быть одним из значений перечисленияPILImageResampling. Влияет только в том случае, еслиdo_resizeустановлено вTrue. - do_rescale (
bool, kwargs, optional, по умолчаниюTrue) — Указывает, следует ли выполнять рескейлинг изображения. - rescale_factor (
float, kwargs, optional, по умолчанию0.00392156862745098) — Коэффициент масштабирования, применяемый к изображению, еслиdo_rescaleустановлен вTrue. - do_normalize (
bool, kwargs, optional, по умолчаниюTrue) — Указывает, следует ли нормализовать изображение. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, optional, по умолчанию[0.485, 0.456, 0.406]) — Среднее значение изображения, используемое для нормализации. Влияет только в том случае, еслиdo_normalizeустановлено вTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, optional, по умолчанию[0.229, 0.224, 0.225]) — Стандартное отклонение изображения, используемое для нормализации. Влияет только в том случае, еслиdo_normalizeустановлено вTrue. - do_pad (
bool, kwargs, optional, по умолчаниюFalse) — Указывает, нужно ли дополнять изображение. Дополнение выполняется либо до максимального размера в батче, либо до фиксированного квадратного размера для каждого изображения. Конкретная стратегия дополнения зависит от модели. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Размер в формате{"height": int, "width" int}, до которого следует дополнить изображения. Должен быть больше любого размера изображения, предоставленного для предобработки. Еслиpad_sizeне указан, изображения будут дополнены до наибольшей высоты и ширины в батче. Применяется только приdo_pad=True. - do_center_crop (
bool, kwargs, optional, по умолчаниюFalse) — Выполнять ли центрированный обрез изображения. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, optional) — Поддерживается толькоChannelDimension.FIRST. Добавлено для совместимости с медленными процессорами. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, необязательный) — Формат размерности каналов для входного изображения. Если не задан, формат размерности каналов выводится из входного изображения. Может быть одним из:"channels_first"илиChannelDimension.FIRST: изображение в формате (num_channels, height, width)."channels_last"илиChannelDimension.LAST: изображение в формате (высота, ширина, число каналов)."none"илиChannelDimension.NONE: изображение в формате (height, width).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — Устройство, на котором будут обрабатываться видео. Если не задано, устройство определяется на основе входных видео. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Возвращает стопку тензоров, если установлено значение'pt', иначе возвращает список тензоров. - disable_grouping (
bool, kwargs, optional) — Определяет, следует ли отключить группировку изображений по размеру для их индивидуальной обработки, а не пачками. Если значение равно None, оно будет установлено в True, если изображения находятся на CPU, и в False в противном случае. Этот выбор основан на эмпирических наблюдениях, описанных здесь: https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, optional) — Количество токенов изображения, используемых для каждого изображения во входных данных. Добавлено для обратной совместимости, но в будущих моделях это значение следует задавать как атрибут процессора. - do_reduce_labels (
bool, kwargs, optional, по умолчаниюself.do_reduce_labels) — Указывает, следует ли уменьшить все значения меток в сегментационных картах на 1. Обычно используется для наборов данных, где 0 обозначает фон, а сам фон не входит в число всех классов набора (например, ADE20k). Метка фона будет заменена на 255. - keypoint_heatmap_downscale_factor (
int, kwargs, optional, по умолчанию 4) — Коэффициент масштабирования целевого размера тепловых карт относительно размера входных данных модели. - keypoint_heatmap_sigma (
float, kwargs, optional, по умолчанию 6.0) — Стандартное отклонение (сигма) для двумерных гауссовых распределений, используемых для генерации тепловых карт.
Создаёт процессор изображений Sapiens2ImageProcessor.
preprocess
< 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
Параметры
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Изображение для предобработки. Ожидается одно изображение или батч изображений со значениями пикселей в диапазоне от 0 до 255. Если передаются изображения со значениями пикселей в диапазоне от 0 до 1, установитеdo_rescale=False. - segmentation_maps (
ImageInput, необязательный) — Сегментационные карты, которые необходимо предобработать. - boxes (
list[list[list[float]]]илиnp.ndarray, необязательный) — Список или массив ограничивающих прямоугольников для каждого изображения. Каждый прямоугольник должен быть списком из 4 чисел с плавающей точкой, представляющих координаты ограничивающего прямоугольника в формате COCO (top_left_x, top_left_y, width, height). Если параметр указан, каждый вырез с человеком подвергается аффинному преобразованию до размера входных данных модели, вместо масштабирования всего изображения. - keypoints (
list[list[list[list[float]]]], необязательный) — Список ключевых точек для каждого человека на каждом изображении. Ожидаемый формат —[x, y, visibility]в стиле COCO. Значенияxиyдолжны быть абсолютными координатами пикселей изображения. Формат:[images -> persons -> keypoints -> [x, y, visibility]]. Используется для генерации ground-truth тепловых карт и весов видимости для дообучения оценки позы. - do_convert_rgb (
bool, kwargs, optional) — Следует ли преобразовать изображение в RGB. - do_resize (
bool, kwargs, optional) — Указывает, нужно ли изменить размер изображения. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Описывает максимальные размеры входных данных для модели. - default_to_square (
bool, kwargs, optional) — Определяет, следует ли по умолчанию использовать квадратное изображение при изменении размера, если size является целым числом. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Размер выходного изображения после примененияcenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Фильтр ресемплинга, используемый при изменении размера изображения. Может быть одним из значений перечисленияPILImageResampling. Влияет только в том случае, еслиdo_resizeустановлено вTrue. - do_rescale (
bool, kwargs, optional) — Нужно ли перемасштабировать изображение. - rescale_factor (
float, kwargs, optional) — Коэффициент масштабирования, применяемый к изображению, еслиdo_rescaleустановлен вTrue. - do_normalize (
bool, kwargs, optional) — Нужно ли нормализовать изображение. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, optional) — Среднее значение изображения, используемое для нормализации. Влияет только в том случае, еслиdo_normalizeустановлено вTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, optional) — Стандартное отклонение изображения, используемое для нормализации. Влияет только в том случае, еслиdo_normalizeустановлено вTrue. - do_pad (
bool, kwargs, optional) — Определяет, нужно ли выравнивать изображение. Выравнивание выполняется либо до максимального размера в батче, либо до фиксированного квадратного размера для каждого изображения. Точная стратегия выравнивания зависит от модели. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Размер в формате{"height": int, "width" int}, до которого следует дополнить изображения. Должен быть больше любого размера изображения, предоставленного для предобработки. Еслиpad_sizeне указан, изображения будут дополнены до наибольшей высоты и ширины в батче. Применяется только приdo_pad=True. - do_center_crop (
bool, kwargs, optional) — Выполнять ли центрированную обрезку изображения. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, optional) — Поддерживается толькоChannelDimension.FIRST. Добавлено для совместимости с медленными процессорами. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, необязательный) — Формат размерности каналов для входного изображения. Если не задан, формат размерности каналов выводится из входного изображения. Может быть одним из:"channels_first"илиChannelDimension.FIRST: изображение в формате (num_channels, height, width)."channels_last"илиChannelDimension.LAST: изображение в формате (высота, ширина, число каналов)."none"илиChannelDimension.NONE: изображение в формате (height, width).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — Устройство, на котором будут обрабатываться видео. Если не задано, устройство определяется на основе входных видео. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Возвращает стопку тензоров, если установлено значение'pt', иначе возвращает список тензоров. - disable_grouping (
bool, kwargs, optional) — Определяет, следует ли отключить группировку изображений по размеру для их индивидуальной обработки, а не пачками. Если значение равно None, оно будет установлено в True, если изображения находятся на CPU, и в False в противном случае. Этот выбор основан на эмпирических наблюдениях, описанных здесь: https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, optional) — Количество токенов изображения, используемых для каждого изображения во входных данных. Добавлено для обратной совместимости, но в будущих моделях это значение следует задавать как атрибут процессора. - do_reduce_labels (
bool, kwargs, optional, по умолчаниюself.do_reduce_labels) — Указывает, следует ли уменьшить все значения меток в сегментационных картах на 1. Обычно используется для наборов данных, где 0 обозначает фон, а сам фон не входит в число всех классов набора (например, ADE20k). Метка фона будет заменена на 255. - keypoint_heatmap_downscale_factor (
int, kwargs, optional, по умолчанию 4) — Коэффициент масштабирования целевого размера тепловых карт относительно размера входных данных модели. - keypoint_heatmap_sigma (
float, kwargs, optional, по умолчанию 6.0) — Стандартное отклонение (сигма) для двумерных гауссовых распределений, используемых для генерации тепловых карт.
Возвращает
~image_processing_base.BatchFeature
- data (
dict) — Словарь списков/массивов/тензоров, возвращаемый методом call (‘pixel_values’ и т. д.). - tensor_type (
Union[None, str, TensorType], необязательный) — Здесь можно указать tensor_type, чтобы при инициализации преобразовать списки целых чисел в тензоры PyTorch/Numpy.
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
Параметры
- outputs (
Sapiens2ImageMattingOutput) — Сырые выходные данные модели. - target_sizes (
torch.Tensorилиlist[tuple[int, int]]длиныbatch_size, необязательный) — Запрашиваемые итоговые(height, width)для каждого предсказания. Изображения масштабируются с помощью билинейной интерполяции. Если параметр не задан, предсказания возвращаются в разрешении выходных данных модели. - backgrounds (
ImageInput, необязательный) — Фоновое изображение (или несколько) для наложения. Может быть одним изображением (применяется ко всем элементам батча) или списком изображений, по одному на каждый элемент батча. Принимает изображения PIL, массивы numpy или тензоры torch любого типа данных; целочисленные типы (например, uint8) автоматически масштабируются в диапазон[0, 1]. Если параметр задан, в каждый словарь результата добавляется ключ"composite"с результирующим изображением в виде тензора uint8 в диапазоне[0, 255].
Возвращает
list[dict] длины batch_size. Каждый dict содержит
"alpha"(torch.Tensorформы(1, height, width)): значения alpha в диапазоне[0, 1]."foreground"(torch.Tensorформы(3, height, width)): предумноженный RGB в диапазоне[0, 1]."composite"(torch.Tensorформы(3, height, width)илиNone): передний план, наложенный наbackgroundsв виде тензора uint8 в диапазоне[0, 255];None, еслиbackgroundsне задан.
Преобразует выход Sapiens2ForImageMatting в альфа-маски и карты переднего плана.
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 )
Параметры
- outputs (
Sapiens2NormalEstimatorOutput) — Сырые выходные данные модели. - source_sizes (
torch.Tensorилиlist[tuple[int, int]]длиныbatch_size, необязательный) — Исходные(height, width)каждого изображения до предобработки. Если указано, отступы, добавленные при предобработке, удаляются, а предсказания масштабируются обратно до исходного размера изображения (еслиtarget_sizesне переопределяет итоговый размер). - target_sizes (
torch.Tensorилиlist[tuple[int, int]]длиныbatch_size, необязательный) — Запроженный итоговый размер(height, width)для каждого предсказания. Если указан, используется как целевой размер для масштабирования вместоsource_sizes. Масштабирование выполняется с помощью двухлинейной интерполяции после L2-нормализации. - do_remove_padding (
bool, необязательный) — Указывает, следует ли удалить нулевую отступную область, добавленную на этапе предобработки, перед изменением размера. По умолчанию установлено значениеTrue, если задан параметрsource_sizes, иначе —False.
Преобразует выход Sapiens2ForNormalEstimation в карты нормалей поверхности, нормированные по 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 )
Параметры
- outputs (
Sapiens2PointmapEstimatorOutput) — Сырые выходные данные модели. - source_sizes (
torch.Tensorилиlist[tuple[int, int]]длиныbatch_size, необязательный) — Исходные(height, width)каждого изображения до предобработки. Если указано, отступы, добавленные при предобработке, удаляются, а предсказания масштабируются обратно до исходного размера изображения (еслиtarget_sizesне переопределяет итоговый размер). - target_sizes (
torch.Tensorилиlist[tuple[int, int]]длиныbatch_size, необязательный) — Запрошенный итоговый размер(height, width)для каждого предсказания. Переопределяетsource_sizesв качестве целевого размера для масштабирования. - do_remove_padding (
bool, необязательный) — Указывает, следует ли удалить нулевую отступную область, добавленную на этапе предобработки, перед изменением размера. По умолчанию установлено значениеTrue, если задан параметрsource_sizes, иначе —False.
Преобразует выход Sapiens2ForPointmapEstimation в тензоры pointmap в пространстве изображения.
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]]
Параметры
- outputs (
Sapiens2PoseEstimatorOutput) — Сырые выходные данные модели.outputs.heatmapsдолжна иметь форму(N_total, num_keypoints, heatmap_height, heatmap_width), гдеN_total = sum(len(b) for b in boxes). - boxes (
list[list[list[float]]]илиnp.ndarray) — Список или массив ограничивающих прямоугольников для каждого изображения в абсолютных пиксельных координатах. Каждый прямоугольник должен быть списком из 4 чисел с плавающей точкой, представляющих координаты ограничивающего прямоугольника в формате COCO (top_left_x, top_left_y, width, height). Должно соответствовать аргументуboxes, переданному вpreprocess. - outputs_flipped (
Sapiens2PoseEstimatorOutput, необязательный) — Результаты выполнения модели на горизонтально инвертированных входных данных. Если параметр указан, тепловые карты усредняются сoutputsперед извлечением ключевых точек для повышения точности:avg_heatmaps = (outputs.heatmaps + outputs_flipped.heatmaps) / 2. - kernel_size (
int, необязательный, по умолчанию 11) — Размер ядра для гауссова размытия, используемого в уточнении UDP Dark Pose. - threshold (
float, необязательный) — Порог оценки. Ключевые точки с оценкой, меньшей или равной этому значению, отфильтровываются из результирующих словарей. - source_sizes (
torch.Tensorилиlist[tuple[int, int]]длиныbatch_size, необязательный) — Исходные(height, width)каждого изображения в пикселях. Обязателен, если указаноtarget_sizes, так как задаёт исходное координатное пространство для масштабирования ключевых точек и ограничивающих прямоугольников. - target_sizes (
torch.Tensorилиlist[tuple[int, int]]длиныbatch_size, необязательный) — Требуемое выходное координатное пространство(height, width)для каждого изображения. Если указано вместе сsource_sizes, координаты ключевых точек и ограничивающие рамки масштабируются из исходного пространства в целевое.
Возвращает
list[list[dict]]
Внешний список итерируется по изображениям, внутренний — по лицам. Каждый словарь содержит:
keypoints(torch.Tensorформы(num_keypoints, 2)): абсолютные координаты x/y в пространстве исходного изображения или в целевом пространстве, если заданtarget_sizes.scores(torch.Tensorформы(num_keypoints,)): уверенность для каждой ключевой точки.labels(torch.LongTensorформы(num_keypoints,)): индексы ключевых точек.bbox(torch.Tensorформы(4,)): ограничивающая рамка в абсолютном формате (x_min, y_min, x_max, y_max), в том же пространстве координат, что иkeypoints.
Преобразует выход Sapiens2ForPoseEstimation в предсказания ключевых точек в пространстве изображения.
post_process_semantic_segmentation
< source >( outputstarget_sizes: list[tuple] | None = Nonereturn_segmentation_scores: bool = False ) → list[torch.Tensor] or list[SemanticSegmentationPostProcessorOutput]
Параметры
- outputs (Sapiens2ForSemanticSegmentation) — Сырые выходные данные модели.
- target_sizes (
list[Tuple]длиныbatch_size, необязательный) — Список кортежей, соответствующих требуемому итоговому размеру (высота, ширина) каждого предсказания. Если не задано, предсказания не будут изменены в размере. - return_segmentation_scores (
bool, необязательный, по умолчаниюFalse) — Определяет, следует ли возвращать оценки сегментации вместе с картой сегментации. ЕслиTrue, каждый элемент возвращаемого списка представляет собойSemanticSegmentationPostProcessorOutputс полямиsegmentation(идентификаторы классов, форма(height, width)) иsegmentation_scores(форма(num_classes, height, width)).
Возвращает
list[torch.Tensor] или list[SemanticSegmentationPostProcessorOutput]
Если return_segmentation_scores=False (по умолчанию), возвращается список длины batch_size, где каждый элемент — это карта сегментации формы (height, width) с идентификаторами классов. Если return_segmentation_scores=True, возвращается список объектов SemanticSegmentationPostProcessorOutput с полями segmentation (идентификаторы классов, форма (height, width)) и segmentation_scores (форма (num_classes, height, width)). В обоих случаях (height, width) соответствует целевому размеру (если указан target_sizes).
Преобразует выход Sapiens2ForSemanticSegmentation в карты семантической сегментации.
Sapiens2Model
класс transformers.Sapiens2Model
< source >( config: Sapiens2Config )
Параметры
- config (Sapiens2Config) — Класс конфигурации модели, содержащий все параметры модели. Инициализация по файлу конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод from_pretrained() для загрузки весов модели.
Модель Sapiens2 без дополнительных слоёв, выводящая необработанные скрытые состояния.
Эта модель наследуется от PreTrainedModel. См. документацию родительского класса для общих методов, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка голов и т. д.)
Эта модель также является подклассом torch.nn.Module в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.
forward
< source >( pixel_values: Tensorbool_masked_pos: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Параметры
- pixel_values (
torch.Tensorформы(batch_size, num_channels, image_size, image_size)) — Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью Sapiens2ImageProcessor. Подробности см. в Sapiens2ImageProcessor.call() (processor_classиспользует Sapiens2ImageProcessor для обработки изображений). - bool_masked_pos (
torch.BoolTensorформы(batch_size, sequence_length), необязательный) — Булевы маскированные позиции. Указывает, какие патчи маскированы (1), а какие нет (0). Актуально только для предобучения.
Возвращает
BaseModelOutputWithPooling или tuple(torch.Tensor)
Объект BaseModelOutputWithPooling или кортеж
torch.Tensor (если передано return_dict=False или если config.return_dict=False), содержащий различные
элементы в зависимости от конфигурации (Sapiens2Config) и входных данных.
Метод Sapiens2Model forward переопределяет специальный метод __call__.
Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр
Module, а не эту функцию, поскольку первый вариант обеспечивает выполнение шагов предварительной и последующей обработки, тогда как второй молча их игнорирует.
last_hidden_state (
torch.Tensorформы(batch_size, sequence_length, hidden_size)) — Последовательность скрытых состояний на выходе последнего слоя модели.pooler_output (
torch.Tensorформы(batch_size, hidden_size)) — Скрытое состояние последнего слоя для первого токена последовательности (токен классификации) после дополнительной обработки слоями, используемыми для вспомогательной задачи предварительного обучения. Например, для моделей семейства BERT это возвращает токен классификации после обработки линейным слоем и функцией активации tanh. Веса линейного слоя обучаются по задаче предсказания следующего предложения (классификации) во время предварительного обучения.hidden_states (
tuple(torch.Tensor), optional, возвращается, если переданоoutput_hidden_states=Trueили еслиconfig.output_hidden_states=True) — кортеж изtorch.Tensor(один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы(batch_size, sequence_length, hidden_size).Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
attentions (
tuple(torch.Tensor), необязательный, возвращается при передачеoutput_attentions=Trueили приconfig.output_attentions=True) — Кортежtorch.Tensor(по одному на каждый слой) формы(batch_size, num_heads, sequence_length, sequence_length).Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
Пример:
>>> 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
класс transformers.Sapiens2Backbone
< source >( config: Sapiens2Config )
Параметры
- config (Sapiens2Config) — Класс конфигурации модели, содержащий все параметры модели. Инициализация по файлу конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод from_pretrained() для загрузки весов модели.
Backbone Sapiens2.
Эта модель наследуется от PreTrainedModel. См. документацию родительского класса для общих методов, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка голов и т. д.)
Эта модель также является подклассом torch.nn.Module в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.
forward
< source >( pixel_values: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2BackboneOutput or tuple(torch.Tensor)
Параметры
- pixel_values (
torch.Tensorформы(batch_size, num_channels, image_size, image_size)) — Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью Sapiens2ImageProcessor. Подробности см. в Sapiens2ImageProcessor.call() (processor_classиспользует Sapiens2ImageProcessor для обработки изображений).
Возвращает
Sapiens2BackboneOutput или tuple(torch.Tensor)
Sapiens2BackboneOutput или кортеж из
torch.Tensor (если передано return_dict=False или если config.return_dict=False), содержащий различные
элементы в зависимости от конфигурации (Sapiens2Config) и входных данных.
Метод forward класса Sapiens2Backbone переопределяет специальный метод __call__.
Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр
Module, а не эту функцию, поскольку первый вариант обеспечивает выполнение шагов предварительной и последующей обработки, тогда как второй молча их игнорирует.
feature_maps (
tuple(torch.Tensor)формы(batch_size, num_channels, height, width)) — Карты признаков на каждом этапе.hidden_states (
tuple(torch.Tensor), необязательный, возвращается при передачеoutput_hidden_states=Trueили приconfig.output_hidden_states=True) — Кортеж изtorch.Tensor(один для вывода эмбеддингов + один для вывода каждого слоя) с формой(batch_size, sequence_length, hidden_size)или(batch_size, num_channels, height, width)в зависимости от базовой модели.Скрытые состояния модели на выходе каждого этапа, а также выходные значения начального слоя встраивания.
attentions (
tuple(torch.Tensor), необязательный, возвращается при передачеoutput_attentions=Trueили приconfig.output_attentions=True) — Кортежtorch.Tensor(по одному на каждый слой) формы(batch_size, num_heads, sequence_length, sequence_length). Применимо только в том случае, если базовая модель использует механизм внимания.Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
cls_tokens (
tuple(torch.Tensor), необязательный) — CLS-токен из каждого выбранного этапа извлечения признаков, каждый имеет форму(batch_size, hidden_size). Присутствует только приconfig.return_class_token=True.
Пример:
>>> 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
класс transformers.Sapiens2ForImageMatting
< source >( config: Sapiens2Config )
Параметры
- config (Sapiens2Config) — Класс конфигурации модели, содержащий все параметры модели. Инициализация по файлу конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод from_pretrained() для загрузки весов модели.
Модель Sapiens2 с головкой маттинга наверху (декодер на основе PixelShuffle, который предсказывает преумноженный RGB-фон и альфа-маску).
Эта модель наследуется от PreTrainedModel. См. документацию родительского класса для общих методов, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка голов и т. д.)
Эта модель также является подклассом torch.nn.Module в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.
forward
< source >( pixel_values: Tensorlabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2ImageMattingOutput or tuple(torch.Tensor)
Параметры
- pixel_values (
torch.Tensorформы(batch_size, num_channels, image_size, image_size)) — Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью Sapiens2ImageProcessor. Подробности см. в Sapiens2ImageProcessor.call() (processor_classиспользует Sapiens2ImageProcessor для обработки изображений). - labels (
torch.Tensorформы(batch_size, 4, height, width), необязательный) — Целевые значения маттинга для вычисления функции потерь.
Возвращает
Sapiens2ImageMattingOutput или tuple(torch.Tensor)
Sapiens2ImageMattingOutput или кортеж из
torch.Tensor (если передано return_dict=False или если config.return_dict=False), содержащий различные
элементы в зависимости от конфигурации (Sapiens2Config) и входных данных.
Метод forward класса Sapiens2ForImageMatting переопределяет специальный метод __call__.
Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр
Module, а не эту функцию, поскольку первый вариант обеспечивает выполнение шагов предварительной и последующей обработки, тогда как второй молча их игнорирует.
loss (
torch.Tensorформы(1,), необязательный, возвращается, если заданlabels) — Потери.alphas (
torch.Tensorформы(batch_size, 1, height, width)) — Оцененные значения альфа.hidden_states (
tuple(torch.Tensor), optional, возвращается, если переданоoutput_hidden_states=Trueили еслиconfig.output_hidden_states=True) — Кортеж изtorch.Tensor(один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого этапа) формы(batch_size, sequence_length, hidden_size). Скрытые состояния (также называемые картами признаков) модели на выходе каждого этапа.attentions (
tuple[torch.Tensor], необязательный, возвращается при передачеoutput_attentions=Trueили когдаconfig.output_attentions=True) — Кортежtorch.Tensor(по одному на каждый слой) формы(batch_size, num_heads, sequence_length, sequence_length).Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
foregrounds (
torch.Tensorформы(batch_size, 3, height, width)) — Предсказания RGB-фона с предварительным умножением в диапазоне[0, 1](с сигмоидной активацией).
Пример:
>>> 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
класс transformers.Sapiens2ForNormalEstimation
< source >( config: Sapiens2Config )
Параметры
- config (Sapiens2Config) — Класс конфигурации модели, содержащий все параметры модели. Инициализация по файлу конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод from_pretrained() для загрузки весов модели.
Модель Sapiens2 с головкой для оценки нормалей поверх (декодер на основе PixelShuffle, предсказывающий карты нормалей поверхности).
Эта модель наследуется от PreTrainedModel. См. документацию родительского класса для общих методов, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка голов и т. д.)
Эта модель также является подклассом torch.nn.Module в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.
forward
< source >( pixel_values: Tensorlabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2NormalEstimatorOutput or tuple(torch.Tensor)
Параметры
- pixel_values (
torch.Tensorформы(batch_size, num_channels, image_size, image_size)) — Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью Sapiens2ImageProcessor. Подробности см. в Sapiens2ImageProcessor.call() (processor_classиспользует Sapiens2ImageProcessor для обработки изображений). - labels (
torch.Tensorформы(batch_size, num_labels, height, width), необязательный) — Истинные карты нормалей поверхности для вычисления функции потерь.
Возвращает
Sapiens2NormalEstimatorOutput или tuple(torch.Tensor)
Sapiens2NormalEstimatorOutput или кортеж из
torch.Tensor (если передано return_dict=False или если config.return_dict=False), содержащий различные
элементы в зависимости от конфигурации (Sapiens2Config) и входных данных.
Метод forward класса Sapiens2ForNormalEstimation переопределяет специальный метод __call__.
Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр
Module, а не эту функцию, поскольку первый вариант обеспечивает выполнение шагов предварительной и последующей обработки, тогда как второй молча их игнорирует.
- loss (
torch.Tensorформы(1,), необязательный, возвращается, если заданlabels) — Потеря оценки нормалей. - normals (
torch.Tensorформы(batch_size, num_labels, height, width)) — Сырые предсказания карты нормалей, выведенные моделью (без нормализации). - hidden_states (
tuple(torch.Tensor), необязательный, возвращается при передачеoutput_hidden_states=Trueили когдаconfig.output_hidden_states=True) — Кортеж изtorch.Tensor(один для вывода эмбеддингов + один для вывода каждого этапа) с формой(batch_size, sequence_length, hidden_size). Скрытые состояния модели на выходе каждого слоя, а также начальные выводы эмбеддингов. - attentions (
tuple(torch.Tensor), optional, возвращается, если переданоoutput_attentions=Trueили еслиconfig.output_attentions=True) — Кортежtorch.Tensor(по одному на каждый слой) формы(batch_size, num_heads, sequence_length, sequence_length). Веса внимания после softmax-функции внимания.
Пример:
>>> 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
класс transformers.Sapiens2ForPointmapEstimation
< source >( config: Sapiens2Config )
Параметры
- config (Sapiens2Config) — Класс конфигурации модели, содержащий все параметры модели. Инициализация по файлу конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод from_pretrained() для загрузки весов модели.
Модель Sapiens2 с головкой pointmap (декодер на основе PixelShuffle, предсказывающий 3D-координаты XYZ для каждого пикселя, плюс необязательная ветка масштаба для нормализации фокусного расстояния).
Эта модель наследуется от PreTrainedModel. См. документацию родительского класса для общих методов, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка голов и т. д.)
Эта модель также является подклассом torch.nn.Module в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.
forward
< source >( pixel_values: Tensorlabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2PointmapEstimatorOutput or tuple(torch.Tensor)
Параметры
- pixel_values (
torch.Tensorформы(batch_size, num_channels, image_size, image_size)) — Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью Sapiens2ImageProcessor. Подробности см. в Sapiens2ImageProcessor.call() (processor_classиспользует Sapiens2ImageProcessor для обработки изображений). - labels (
torch.Tensorформы(batch_size, 3, height, width), необязательный) — Истинная карта точек для вычисления функции потерь.
Возвращает
Sapiens2PointmapEstimatorOutput или tuple(torch.Tensor)
Sapiens2PointmapEstimatorOutput или кортеж из
torch.Tensor (если передано return_dict=False или если config.return_dict=False), содержащий различные
элементы в зависимости от конфигурации (Sapiens2Config) и входных данных.
Метод forward класса Sapiens2ForPointmapEstimation переопределяет специальный метод __call__.
Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр
Module, а не эту функцию, поскольку первый вариант обеспечивает выполнение шагов предварительной и последующей обработки, тогда как второй молча их игнорирует.
- loss (
torch.Tensorформы(1,), необязательный, возвращается, если заданlabels) — Потеря оценки Pointmap. - pointmaps (
torch.Tensorформы(batch_size, 3, height, width)) — Предсказания 3D-координат XYZ для каждого пикселя в каноническом пространстве камеры. - scales (
torch.Tensorформы(batch_size, 1), необязательный) — Соотношение канональной фокусной длины к фактической фокусной длине.None, если ветвь масштабирования не настроена. - hidden_states (
tuple(torch.Tensor), необязательный, возвращается при передачеoutput_hidden_states=Trueили когдаconfig.output_hidden_states=True) — Кортеж изtorch.Tensor(один для вывода эмбеддингов + один для вывода каждого этапа) с формой(batch_size, sequence_length, hidden_size). Скрытые состояния модели на выходе каждого слоя, а также начальные выводы эмбеддингов. - attentions (
tuple(torch.Tensor), optional, возвращается, если переданоoutput_attentions=Trueили еслиconfig.output_attentions=True) — Кортежtorch.Tensor(по одному на каждый слой) формы(batch_size, num_heads, sequence_length, sequence_length). Веса внимания после softmax-функции внимания.
Пример:
>>> 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
класс transformers.Sapiens2ForPoseEstimation
< source >( config: Sapiens2Config )
Параметры
- config (Sapiens2Config) — Класс конфигурации модели, содержащий все параметры модели. Инициализация по файлу конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод from_pretrained() для загрузки весов модели.
Модель Sapiens2 с головкой для оценки позы (набор предикторов тепловых карт, размещенных поверх выходных скрытых состояний).
Эта модель наследуется от PreTrainedModel. См. документацию родительского класса для общих методов, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка голов и т. д.)
Эта модель также является подклассом torch.nn.Module в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.
forward
< source >( pixel_values: Tensorflip_pairs: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Nonelabel_weights: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sapiens2PoseEstimatorOutput or tuple(torch.Tensor)
Параметры
- pixel_values (
torch.Tensorформы(batch_size, num_channels, image_size, image_size)) — Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью Sapiens2ImageProcessor. Подробности см. в Sapiens2ImageProcessor.call() (processor_classиспользует Sapiens2ImageProcessor для обработки изображений). - flip_pairs (
torch.Tensorформы(num_pairs, 2), необязательный) — Пары ключевых точек, которые являются зеркальными отражениями (например, левое ухо — правое ухо), используются для аугментации с горизонтальным переворотом на этапе тестирования. Если параметр указан, модель предполагает, чтоpixel_valuesсодержит изображения, перевёрнутые по горизонтали, и вызываетflip_backдля выходных тепловых карт, чтобы восстановить исходную ориентацию. - labels (
torch.Tensorформы(batch_size, num_keypoints, height, width), необязательный) — Эталонные данные тепловых карт для вычисления функции потерь. - label_weights (
torch.Tensorформы(batch_size, num_labels, 1, 1)или(batch_size, num_labels, height, width), необязательный) — Веса видимости для каждой ключевой точки. Должны быть приводимы к формеlabels.
Возвращает
Sapiens2PoseEstimatorOutput или tuple(torch.Tensor)
Sapiens2PoseEstimatorOutput или кортеж из
torch.Tensor (если передано return_dict=False или если config.return_dict=False), содержащий различные
элементы в зависимости от конфигурации (Sapiens2Config) и входных данных.
Метод forward класса Sapiens2ForPoseEstimation переопределяет специальный метод __call__.
Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр
Module, а не эту функцию, поскольку первый вариант обеспечивает выполнение шагов предварительной и последующей обработки, тогда как второй молча их игнорирует.
loss (
torch.Tensorформы(1,), необязательный, возвращается, если заданlabels) — Потери оценки позы.карты активаций (
torch.Tensorформы(batch_size, num_keypoints, height, width)) — Карты активаций, предсказанные моделью.hidden_states (
tuple(torch.Tensor), optional, возвращается, если переданоoutput_hidden_states=Trueили еслиconfig.output_hidden_states=True) — Кортеж изtorch.Tensor(один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого этапа) формы(batch_size, sequence_length, hidden_size). Скрытые состояния (также называемые картами признаков) модели на выходе каждого этапа.attentions (
tuple[torch.Tensor, ...], необязательный, возвращается при передачеoutput_attentions=Trueили когдаconfig.output_attentions=True) — Кортежtorch.Tensor(по одному на каждый слой) формы(batch_size, num_heads, sequence_length, sequence_length).Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
Пример:
>>> 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
класс transformers.Sapiens2ForSemanticSegmentation
< source >( config: Sapiens2Config )
Параметры
- config (Sapiens2Config) — Класс конфигурации модели, содержащий все параметры модели. Инициализация по файлу конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод from_pretrained() для загрузки весов модели.
Модель Sapiens2 с головой семантической сегментации, например, для ADE20K, CityScapes.
Эта модель наследуется от PreTrainedModel. См. документацию родительского класса для общих методов, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка голов и т. д.)
Эта модель также является подклассом torch.nn.Module в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.
forward
< source >( pixel_values: Tensorlabels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SemanticSegmenterOutput or tuple(torch.Tensor)
Параметры
- pixel_values (
torch.Tensorформы(batch_size, num_channels, image_size, image_size)) — Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью Sapiens2ImageProcessor. Подробности см. в Sapiens2ImageProcessor.call() (processor_classиспользует Sapiens2ImageProcessor для обработки изображений). - labels (
torch.LongTensorформы(batch_size, height, width), необязательный) — Карты семантической сегментации для вычисления функции потерь. Индексы должны находиться в диапазоне[0, ..., config.num_labels - 1]. Еслиconfig.num_labels > 1, вычисляется функция потерь для классификации (Cross-Entropy).
Возвращает
SemanticSegmenterOutput или tuple(torch.Tensor)
Объект SemanticSegmenterOutput или кортеж из
torch.Tensor (если передано return_dict=False или если config.return_dict=False), содержащий различные
элементы в зависимости от конфигурации (Sapiens2Config) и входных данных.
Метод forward класса Sapiens2ForSemanticSegmentation переопределяет специальный метод __call__.
Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр
Module, а не эту функцию, поскольку первый вариант обеспечивает выполнение шагов предварительной и последующей обработки, тогда как второй молча их игнорирует.
loss (
torch.Tensorформы(1,), необязательный, возвращается, если заданlabels) — Потери классификации (или регрессии, если config.num_labels==1).logits (
torch.Tensorформы(batch_size, config.num_labels, logits_height, logits_width)) — Оценки классификации для каждого пикселя.Возвращаемые logits не обязательно имеют тот же размер, что и переданные на вход
pixel_values. Это сделано, чтобы избежать двойной интерполяции и потери качества, когда пользователю необходимо изменить размер logits до исходного размера изображения на этапе постобработки. Всегда проверяйте форму logits и изменяйте размер по мере необходимости.hidden_states (
tuple(torch.Tensor), необязательный, возвращается при передачеoutput_hidden_states=Trueили когдаconfig.output_hidden_states=True) — Кортеж изtorch.Tensor(один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы(batch_size, patch_size, hidden_size).Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
attentions (
tuple(torch.Tensor), необязательный, возвращается при передачеoutput_attentions=Trueили приconfig.output_attentions=True) — Кортежtorch.Tensor(по одному на каждый слой) формы(batch_size, num_heads, patch_size, sequence_length).Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
Пример:
>>> 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])