Transformers documentation

ViTPose

Transformers

Начало работы

Transformers Установка Быстрый старт

Базовые классы

Модели

Предобработчики

Вывод

API конвейера

Generate API

Оптимизация

Чат с моделями

Развёртывание

Обучение

Начало работы

Настройка

Параметрически эффективная дообучение

Производительность

Распределённое обучение

Аппаратное обеспечение

Квантование

Интеграции с экосистемой

Ресурсы

API

Основные классы

Модели

Текстовые модели

Модели компьютерного зрения

Аудиомодели

Видеомодели

Мультимодальные модели

Модели обучения с подкреплением

Модели временных рядов

Внутренние вспомогательные функции

Справочник

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

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Эта модель была опубликована в HF papers 26.04.2022 и добавлена в Hugging Face Transformers 08.01.2025.

ViTPose

ViTPose — это модель на основе vision transformer для оценки ключевых точек (позы). Она использует простой, не иерархический бэкбон ViT и лёгкий декодер. Такая архитектура упрощает проектирование модели, позволяет использовать масштабируемость трансформеров и адаптируется к различным стратегиям обучения.

ViTPose++ улучшает ViTPose за счёт добавления модуля mixture-of-experts (MoE) в backbone и использования более разнообразных данных для предобучения.

Все чекпоинты ViTPose и ViTPose++ можно найти в коллекции ViTPose.

Приведённый ниже пример демонстрирует оценку позы с использованием класса VitPoseForPoseEstimation.

import requests
import supervision as sv
import torch
from PIL import Image

from transformers import AutoProcessor, RTDetrForObjectDetection, VitPoseForPoseEstimation


url = "https://www.fcbarcelona.com/fcbarcelona/photo/2021/01/31/3c55a19f-dfc1-4451-885e-afd14e890a11/mini_2021-01-31-BARCELONA-ATHLETIC-BILBAOI-30.JPG"
image = Image.open(requests.get(url, stream=True).raw)

# Detect humans in the image
person_image_processor = AutoProcessor.from_pretrained("PekingU/rtdetr_r50vd_coco_o365")
person_model = RTDetrForObjectDetection.from_pretrained("PekingU/rtdetr_r50vd_coco_o365", device_map="auto")

inputs = person_image_processor(images=image, return_tensors="pt").to(person_model.device)

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

results = person_image_processor.post_process_object_detection(
    outputs, target_sizes=torch.tensor([(image.height, image.width)]), threshold=0.3
)
result = results[0]

# Human label refers 0 index in COCO dataset
person_boxes = result["boxes"][result["labels"] == 0]
person_boxes = person_boxes.cpu().numpy()

# Convert boxes from VOC (x1, y1, x2, y2) to COCO (x1, y1, w, h) format
person_boxes[:, 2] = person_boxes[:, 2] - person_boxes[:, 0]
person_boxes[:, 3] = person_boxes[:, 3] - person_boxes[:, 1]

# Detect keypoints for each person found
image_processor = AutoProcessor.from_pretrained("usyd-community/vitpose-base-simple")
model = VitPoseForPoseEstimation.from_pretrained("usyd-community/vitpose-base-simple", device_map="auto")

inputs = image_processor(image, boxes=[person_boxes], return_tensors="pt").to(model.device)

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

pose_results = image_processor.post_process_pose_estimation(outputs, boxes=[person_boxes])
image_pose_result = pose_results[0]

xy = torch.stack([pose_result['keypoints'] for pose_result in image_pose_result]).cpu().numpy()
scores = torch.stack([pose_result['scores'] for pose_result in image_pose_result]).cpu().numpy()

key_points = sv.KeyPoints(
    xy=xy, confidence=scores
)

edge_annotator = sv.EdgeAnnotator(
    color=sv.Color.GREEN,
    thickness=1
)
vertex_annotator = sv.VertexAnnotator(
    color=sv.Color.RED,
    radius=2
)
annotated_frame = edge_annotator.annotate(
    scene=image.copy(),
    key_points=key_points
)
annotated_frame = vertex_annotator.annotate(
    scene=annotated_frame,
    key_points=key_points
)
annotated_frame

Квантование снижает нагрузку на память при работе с большими моделями, представляя веса в пониженной точности. Подробнее о доступных бэкендах квантования см. в обзоре Квантование.

Приведённый ниже пример использует torchao для квантования только весов до int4.

# pip install torchao
import requests
import torch
from PIL import Image

from transformers import AutoProcessor, RTDetrForObjectDetection, TorchAoConfig, VitPoseForPoseEstimation


url = "https://www.fcbarcelona.com/fcbarcelona/photo/2021/01/31/3c55a19f-dfc1-4451-885e-afd14e890a11/mini_2021-01-31-BARCELONA-ATHLETIC-BILBAOI-30.JPG"
image = Image.open(requests.get(url, stream=True).raw)

person_image_processor = AutoProcessor.from_pretrained("PekingU/rtdetr_r50vd_coco_o365")
person_model = RTDetrForObjectDetection.from_pretrained("PekingU/rtdetr_r50vd_coco_o365", device_map="auto")

inputs = person_image_processor(images=image, return_tensors="pt").to(model.device)

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

results = person_image_processor.post_process_object_detection(
    outputs, target_sizes=torch.tensor([(image.height, image.width)]), threshold=0.3
)
result = results[0]

person_boxes = result["boxes"][result["labels"] == 0]
person_boxes = person_boxes.cpu().numpy()

person_boxes[:, 2] = person_boxes[:, 2] - person_boxes[:, 0]
person_boxes[:, 3] = person_boxes[:, 3] - person_boxes[:, 1]

quantization_config = TorchAoConfig("int4_weight_only", group_size=128)

image_processor = AutoProcessor.from_pretrained("usyd-community/vitpose-plus-huge")
model = VitPoseForPoseEstimation.from_pretrained("usyd-community/vitpose-plus-huge", device_map="auto", quantization_config=quantization_config)

inputs = image_processor(image, boxes=[person_boxes], return_tensors="pt").to(model.device)

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

pose_results = image_processor.post_process_pose_estimation(outputs, boxes=[person_boxes])
image_pose_result = pose_results[0]

Примечания

Используйте AutoProcessor для автоматической подготовки входных данных с ограничивающими рамками и изображений.
ViTPose — это топ-даун-оценщик позы. Сначала он использует детектор объектов для обнаружения людей, а затем предсказывает ключевые точки.

ViTPose++ имеет 6 различных экспертных головок MoE (COCO validation 0, AiC 1, MPII 2, AP-10K 3, APT-36K 4, COCO-WholeBody 5), что позволяет работать с 6 различными наборами данных. Передайте в dataset_index конкретное значение, соответствующее набору данных, чтобы указать, какой эксперт использовать.

from transformers import AutoProcessor, VitPoseForPoseEstimation

image_processor = AutoProcessor.from_pretrained("usyd-community/vitpose-plus-base")
model = VitPoseForPoseEstimation.from_pretrained("usyd-community/vitpose-plus-base", device_map="auto")

inputs = image_processor(image, boxes=[person_boxes], return_tensors="pt").to(model.device)
dataset_index = torch.tensor([0], device=device) # must be a tensor of shape (batch_size,)

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

OpenCV — альтернативный вариант для визуализации оценённой позы.

# pip install opencv-python
import math
import cv2

def draw_points(image, keypoints, scores, pose_keypoint_color, keypoint_score_threshold, radius, show_keypoint_weight):
    if pose_keypoint_color is not None:
        assert len(pose_keypoint_color) == len(keypoints)
    for kid, (kpt, kpt_score) in enumerate(zip(keypoints, scores)):
        x_coord, y_coord = int(kpt[0]), int(kpt[1])
        if kpt_score > keypoint_score_threshold:
            color = tuple(int(c) for c in pose_keypoint_color[kid])
            if show_keypoint_weight:
                cv2.circle(image, (int(x_coord), int(y_coord)), radius, color, -1)
                transparency = max(0, min(1, kpt_score))
                cv2.addWeighted(image, transparency, image, 1 - transparency, 0, dst=image)
            else:
                cv2.circle(image, (int(x_coord), int(y_coord)), radius, color, -1)

def draw_links(image, keypoints, scores, keypoint_edges, link_colors, keypoint_score_threshold, thickness, show_keypoint_weight, stick_width = 2):
    height, width, _ = image.shape
    if keypoint_edges is not None and link_colors is not None:
        assert len(link_colors) == len(keypoint_edges)
        for sk_id, sk in enumerate(keypoint_edges):
            x1, y1, score1 = (int(keypoints[sk[0], 0]), int(keypoints[sk[0], 1]), scores[sk[0]])
            x2, y2, score2 = (int(keypoints[sk[1], 0]), int(keypoints[sk[1], 1]), scores[sk[1]])
            if (
                x1 > 0
                and x1 < width
                and y1 > 0
                and y1 < height
                and x2 > 0
                and x2 < width
                and y2 > 0
                and y2 < height
                and score1 > keypoint_score_threshold
                and score2 > keypoint_score_threshold
            ):
                color = tuple(int(c) for c in link_colors[sk_id])
                if show_keypoint_weight:
                    X = (x1, x2)
                    Y = (y1, y2)
                    mean_x = np.mean(X)
                    mean_y = np.mean(Y)
                    length = ((Y[0] - Y[1]) ** 2 + (X[0] - X[1]) ** 2) ** 0.5
                    angle = math.degrees(math.atan2(Y[0] - Y[1], X[0] - X[1]))
                    polygon = cv2.ellipse2Poly(
                        (int(mean_x), int(mean_y)), (int(length / 2), int(stick_width)), int(angle), 0, 360, 1
                    )
                    cv2.fillConvexPoly(image, polygon, color)
                    transparency = max(0, min(1, 0.5 * (keypoints[sk[0], 2] + keypoints[sk[1], 2])))
                    cv2.addWeighted(image, transparency, image, 1 - transparency, 0, dst=image)
                else:
                    cv2.line(image, (x1, y1), (x2, y2), color, thickness=thickness)

# Note: keypoint_edges and color palette are dataset-specific
keypoint_edges = model.config.edges

palette = np.array(
    [
        [255, 128, 0],
        [255, 153, 51],
        [255, 178, 102],
        [230, 230, 0],
        [255, 153, 255],
        [153, 204, 255],
        [255, 102, 255],
        [255, 51, 255],
        [102, 178, 255],
        [51, 153, 255],
        [255, 153, 153],
        [255, 102, 102],
        [255, 51, 51],
        [153, 255, 153],
        [102, 255, 102],
        [51, 255, 51],
        [0, 255, 0],
        [0, 0, 255],
        [255, 0, 0],
        [255, 255, 255],
    ]
)

link_colors = palette[[0, 0, 0, 0, 7, 7, 7, 9, 9, 9, 9, 9, 16, 16, 16, 16, 16, 16, 16]]
keypoint_colors = palette[[16, 16, 16, 16, 16, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0]]

numpy_image = np.array(image)

for pose_result in image_pose_result:
    scores = np.array(pose_result["scores"])
    keypoints = np.array(pose_result["keypoints"])

    # draw each point on image
    draw_points(numpy_image, keypoints, scores, keypoint_colors, keypoint_score_threshold=0.3, radius=4, show_keypoint_weight=False)

    # draw links
    draw_links(numpy_image, keypoints, scores, keypoint_edges, link_colors, keypoint_score_threshold=0.3, thickness=1, show_keypoint_weight=False)

pose_image = Image.fromarray(numpy_image)
pose_image

Ресурсы

См. ресурсы ниже, чтобы узнать больше об использовании ViTPose.

В этом ноутбуке показаны выполнение инференса и визуализация.
Этот Space демонстрирует ViTPose на изображениях и видео.

VitPoseImageProcessor

класс transformers.VitPoseImageProcessor

< source >

( **kwargs: *<class 'transformers.models.vitpose.image_processing_vitpose.VitPoseImageProcessorKwargs'> )

Параметры

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, по умолчанию {'height' -- 256, 'width': 192}): Определяет максимальные размеры входных данных для модели.
default_to_square (bool, kwargs, optional, по умолчанию True) — Определяет, следует ли по умолчанию использовать квадратное изображение при изменении размера, если size задано как int.
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, по умолчанию 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) — Определяет, нужно ли выравнивать изображение. Выравнивание выполняется либо до максимального размера в батче, либо до фиксированного квадратного размера для каждого изображения. Точная стратегия выравнивания зависит от модели.
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_affine_transform (bool, kwargs, optional) — Указывает, следует ли применять аффинное преобразование к входным изображениям на основе ограничивающих прямоугольников.
normalize_factor (float, kwargs, optional, по умолчанию 200.0) — Коэффициент масштабирования ширины и высоты, используемый для нормализации при вычислении центра и масштаба из ограничивающих прямоугольников.

Создаёт процессор изображений VitPoseImageProcessor.

preprocess

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]boxes: list[list[list[float]]] | numpy.ndarray**kwargs: *<class 'transformers.models.vitpose.image_processing_vitpose.VitPoseImageProcessorKwargs'> ) → ~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.
boxes (list[list[list[float]]] or np.ndarray) — Список или массив ограничивающих прямоугольников для каждого изображения. Каждый прямоугольник должен быть списком из 4 чисел с плавающей точкой, представляющих координаты ограничивающего прямоугольника в формате COCO (top_left_x, top_left_y, width, height).
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_affine_transform (bool, kwargs, optional) — Указывает, следует ли применять аффинное преобразование к входным изображениям на основе ограничивающих прямоугольников.
normalize_factor (float, kwargs, optional, по умолчанию 200.0) — Коэффициент масштабирования ширины и высоты, используемый для нормализации при вычислении центра и масштаба из ограничивающих прямоугольников.

Возвращает

~image_processing_base.BatchFeature

data (dict) — Словарь списков/массивов/тензоров, возвращаемый методом call (‘pixel_values’ и т. д.).
tensor_type (Union[None, str, TensorType], необязательный) — Здесь можно указать tensor_type, чтобы при инициализации преобразовать списки целых чисел в тензоры PyTorch/Numpy.

post_process_pose_estimation

< source >

( outputs: VitPoseEstimatorOutputboxes: list[list[list[float]]] | numpy.ndarraykernel_size: int = 11threshold: float | None = Nonetarget_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None ) → list[list[Dict]]

Параметры

outputs (VitPoseEstimatorOutput) — выходы модели VitPoseForPoseEstimation.
boxes (list[list[list[float]]] or np.ndarray) — Список или массив ограничивающих прямоугольников для каждого изображения. Каждый прямоугольник должен быть списком из 4 чисел с плавающей точкой, представляющих координаты ограничивающего прямоугольника в формате COCO (top_left_x, top_left_y, width, height).
kernel_size (int, необязательный, по умолчанию 11) — Размер гауссова ядра (K) для модуляции.
threshold (float, необязательный, по умолчанию None) — Порог оценки для сохранения предсказаний обнаружения объектов.
target_sizes (torch.Tensor or list[tuple[int, int]], необязательный) — Тензор формы (batch_size, 2) или список кортежей (tuple[int, int]), содержащий целевой размер (height, width) каждого изображения в батче. Если не задано, предсказания будут масштабированы с использованием значения по умолчанию.

Возвращает

list[list[Dict]]

Список словарей, где каждый словарь содержит ключевые точки и рамки для изображения в батче, как их предсказала модель.

Преобразуйте тепловые карты в предсказания ключевых точек и верните их обратно в изображение.

VitPoseImageProcessorPil

класс transformers.VitPoseImageProcessorPil

< source >

( **kwargs: *<class 'transformers.models.vitpose.image_processing_pil_vitpose.VitPoseImageProcessorKwargs'> )

Параметры

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, по умолчанию {'height' -- 256, 'width': 192}): Определяет максимальные размеры входных данных для модели.
default_to_square (bool, kwargs, optional, по умолчанию True) — Определяет, следует ли по умолчанию использовать квадратное изображение при изменении размера, если size задано как int.
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, по умолчанию 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) — Определяет, нужно ли выравнивать изображение. Выравнивание выполняется либо до максимального размера в батче, либо до фиксированного квадратного размера для каждого изображения. Точная стратегия выравнивания зависит от модели.
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_affine_transform (bool, kwargs, optional) — Указывает, следует ли применять аффинное преобразование к входным изображениям на основе ограничивающих прямоугольников.
normalize_factor (float, kwargs, optional, по умолчанию 200.0) — Коэффициент масштабирования ширины и высоты, используемый для нормализации при вычислении центра и масштаба из ограничивающих прямоугольников.

Создаёт процессор изображений VitPoseImageProcessor.

preprocess

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]boxes: list[list[list[float]]] | numpy.ndarray**kwargs: *<class 'transformers.models.vitpose.image_processing_pil_vitpose.VitPoseImageProcessorKwargs'> ) → ~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.
boxes (list[list[list[float]]] or np.ndarray) — Список или массив ограничивающих прямоугольников для каждого изображения. Каждый прямоугольник должен быть списком из 4 чисел с плавающей точкой, представляющих координаты ограничивающего прямоугольника в формате COCO (top_left_x, top_left_y, width, height).
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_affine_transform (bool, kwargs, optional) — Указывает, следует ли применять аффинное преобразование к входным изображениям на основе ограничивающих прямоугольников.
normalize_factor (float, kwargs, optional, по умолчанию 200.0) — Коэффициент масштабирования ширины и высоты, используемый для нормализации при вычислении центра и масштаба из ограничивающих прямоугольников.

Возвращает

~image_processing_base.BatchFeature

data (dict) — Словарь списков/массивов/тензоров, возвращаемый методом call (‘pixel_values’ и т. д.).
tensor_type (Union[None, str, TensorType], необязательный) — Здесь можно указать tensor_type, чтобы при инициализации преобразовать списки целых чисел в тензоры PyTorch/Numpy.

post_process_pose_estimation

< source >

Параметры

outputs (VitPoseEstimatorOutput) — выходы модели VitPoseForPoseEstimation.
boxes (list[list[list[float]]] or np.ndarray) — Список или массив ограничивающих прямоугольников для каждого изображения. Каждый прямоугольник должен быть списком из 4 чисел с плавающей точкой, представляющих координаты ограничивающего прямоугольника в формате COCO (top_left_x, top_left_y, width, height).
kernel_size (int, необязательный, по умолчанию 11) — Размер гауссова ядра (K) для модуляции.
threshold (float, необязательный, по умолчанию None) — Порог оценки для сохранения предсказаний обнаружения объектов.
target_sizes (torch.Tensor or list[tuple[int, int]], необязательный) — Тензор формы (batch_size, 2) или список кортежей (tuple[int, int]), содержащий целевой размер (height, width) каждого изображения в батче. Если не задано, предсказания будут масштабированы с использованием значения по умолчанию.

Возвращает

list[list[Dict]]

Преобразуйте тепловые карты в предсказания ключевых точек и верните их обратно в изображение.

VitPoseConfig

класс transformers.VitPoseConfig

< 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 = Nonebackbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneinitializer_range: float = 0.02scale_factor: int = 4use_simple_decoder: bool = True )

Параметры

backbone_config (Union[dict, ~configuration_utils.PreTrainedConfig], необязательный) — Конфигурация модели-бэкбона.
initializer_range (float, необязательный, по умолчанию 0.02) — Стандартное отклонение truncated_normal_initializer, используемое для инициализации всех матриц весов.
scale_factor (int, необязательный, по умолчанию 4) — Коэффициент увеличения масштаба карт признаков, получаемых из каркаса ViT.
use_simple_decoder (bool, необязательный, по умолчанию True) — Определяет, следует ли использовать VitPoseSimpleDecoder для декодирования карт признаков из backbone в тепловые карты. В противном случае используется VitPoseClassicDecoder.

Это класс конфигурации для хранения конфигурации модели VitposeModel. Он используется для создания модели Vitpose в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации usyd-community/vitpose-base-simple

Объекты конфигурации наследуются от PreTrainedConfig и могут использоваться для управления выводами модели. Подробнее читайте в документации PreTrainedConfig.

Пример:

>>> from transformers import VitPoseConfig, VitPoseForPoseEstimation

>>> # Initializing a VitPose configuration
>>> configuration = VitPoseConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = VitPoseForPoseEstimation(configuration)

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

VitPoseForPoseEstimation

класс transformers.VitPoseForPoseEstimation

< source >

( config: VitPoseConfig )

Параметры

config (VitPoseConfig) — Класс конфигурации модели, содержащий все параметры модели. Инициализация с помощью файла конфигурации не загружает веса, связанные с моделью, а только конфигурацию. Используйте метод from_pretrained() для загрузки весов модели.

Модель VitPose с головкой для оценки позы.

Эта модель наследуется от PreTrainedModel. См. документацию родительского класса для общих методов, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка голов и т. д.)

Эта модель также является подклассом torch.nn.Module в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

forward

< source >

( pixel_values: Tensordataset_index: typing.Optional[torch.Tensor] = Noneflip_pairs: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → VitPoseEstimatorOutput or tuple(torch.Tensor)

Параметры

pixel_values (torch.Tensor формы (batch_size, num_channels, image_size, image_size)) — Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью VitPoseImageProcessor. Подробности см. в VitPoseImageProcessor.call() (processor_class использует VitPoseImageProcessor для обработки изображений).
dataset_index (torch.Tensor с формой (batch_size,)) — Индекс, используемый в блоках Mixture-of-Experts (MoE) базовой модели. Это соответствует индексу набора данных, используемому во время обучения. Например, для одного набора данных индекс 0 указывает на соответствующий набор данных. Для нескольких наборов данных индекс 0 указывает на набор данных A (например, MPII), а индекс 1 — на набор данных B (например, CrowdPose).
Это соответствует индексу набора данных, используемому во время обучения. Например, для одного набора данных индекс 0 указывает на соответствующий набор данных. Для нескольких наборов данных индекс 0 указывает на набор данных A (например, MPII), а индекс 1 — на набор данных B (например, CrowdPose).
flip_pairs (torch.tensor, необязательный) — Указывает, нужно ли зеркально отражать пары ключевых точек (например, левое ухо — правое ухо).
labels (torch.Tensor формы (batch_size, sequence_length), необязательный) — Метки для вычисления потерь маскированного языкового моделирования. Индексы должны находиться в диапазоне [0, ..., config.vocab_size] или быть равны -100 (см. docstring input_ids). Токены с индексами, установленными в -100, игнорируются (маскируются); потери вычисляются только для токенов с метками в диапазоне [0, ..., config.vocab_size].

Возвращает

VitPoseEstimatorOutput или tuple(torch.Tensor)

VitPoseEstimatorOutput или кортеж из torch.Tensor (если передано return_dict=False или если config.return_dict=False), содержащий различные элементы в зависимости от конфигурации (VitPoseConfig) и входных данных.

Метод forward класса VitPoseForPoseEstimation переопределяет специальный метод __call__.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр Module, а не эту функцию, поскольку первый вариант обеспечивает выполнение шагов предварительной и последующей обработки, тогда как второй молча их игнорирует.

loss (torch.Tensor формы (1,), необязательный, возвращается, если задан labels) — В данный момент loss не поддерживается. Подробности см. по адресу https://github.com/ViTAE-Transformer/ViTPose/tree/main/mmpose/models/losses.
карты активаций (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, VitPoseForPoseEstimation
>>> import torch
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> processor = AutoImageProcessor.from_pretrained("usyd-community/vitpose-base-simple")
>>> model = VitPoseForPoseEstimation.from_pretrained("usyd-community/vitpose-base-simple")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))
>>> boxes = [[[412.8, 157.61, 53.05, 138.01], [384.43, 172.21, 15.12, 35.74]]]
>>> inputs = processor(image, boxes=boxes, return_tensors="pt")

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

Update on GitHub

←ViTMSN YOLOS→