Transformers documentation

ViTPose

Transformers

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

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Model ini dipublikasikan di HF papers pada 2022-04-26 dan disumbangkan ke Hugging Face Transformers pada 2025-01-08.

ViTPose

ViTPose adalah model berbasis vision transformer untuk estimasi titik kunci (pose). Model ini menggunakan backbone ViT sederhana dan non-hierarkis serta kepala decoder yang ringan. Arsitektur ini menyederhanakan desain model, memanfaatkan skalabilitas transformer, dan dapat diadaptasi ke berbagai strategi pelatihan.

ViTPose++ meningkatkan ViTPose dengan mengintegrasikan modul mixture-of-experts (MoE) ke dalam backbone dan menggunakan data pra-pelatihan yang lebih beragam.

Anda dapat menemukan semua checkpoint ViTPose dan ViTPose++ di bawah koleksi ViTPose.

Contoh di bawah ini mendemonstrasikan estimasi pose dengan kelas 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

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

Contoh di bawah menggunakan torchao untuk hanya mengkuantisasi bobot ke 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]

Catatan

Gunakan AutoProcessor untuk menyiapkan input bounding box dan gambar secara otomatis.
ViTPose adalah estimator pose top-down. Ia menggunakan detektor objek untuk mendeteksi individu terlebih dahulu sebelum melakukan prediksi titik kunci.

ViTPose++ memiliki 6 kepala ahli MoE yang berbeda (validasi COCO 0, AiC 1, MPII 2, AP-10K 3, APT-36K 4, COCO-WholeBody 5) yang mendukung 6 dataset berbeda. Sampaikan nilai spesifik yang sesuai dengan dataset ke dataset_index untuk menunjukkan ahli mana yang akan digunakan.

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 adalah opsi alternatif untuk memvisualisasikan pose yang diperkirakan.

# 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

Sumber daya

Lihat sumber daya di bawah ini untuk mempelajari lebih lanjut tentang penggunaan ViTPose.

Notebook ini mendemonstrasikan inferensi dan visualisasi.
Space ini mendemonstrasikan ViTPose pada gambar dan video.

VitPoseImageProcessor

kelas transformers.VitPoseImageProcessor

< source >

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

Parameter

do_convert_rgb (bool, kwargs, opsional) — Apakah akan mengonversi gambar ke RGB.
do_resize (bool, kwargs, opsional) — Apakah akan mengubah ukuran gambar.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, defaultnya {'height' -- 256, 'width': 192}): Menggambarkan dimensi input maksimum untuk model.
default_to_square (bool, kwargs, opsional, defaultnya True) — Apakah akan menggunakan gambar persegi sebagai default saat melakukan resize, jika size berupa int.
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran gambar keluaran setelah menerapkan center_crop.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filter resampling yang digunakan jika mengubah ukuran gambar. Ini dapat berupa salah satu enum PILImageResampling. Hanya berpengaruh jika do_resize diatur ke True.
do_rescale (bool, kwargs, opsional, default True) — Apakah akan melakukan penskalaan ulang pada gambar.
rescale_factor (float, kwargs, opsional, default 0.00392156862745098) — Faktor rescale untuk menskalakan ulang gambar jika do_rescale diatur ke True.
do_normalize (bool, kwargs, opsional, default True) — Apakah akan menormalisasi gambar.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opsional, defaultnya [0.485, 0.456, 0.406]) — Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika do_normalize diatur ke True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, opsional, defaultnya [0.229, 0.224, 0.225]) — Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika do_normalize diatur ke True.
do_pad (bool, kwargs, opsional) — Apakah akan melakukan padding pada gambar. Padding dilakukan ke ukuran terbesar dalam batch atau ke ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model.
pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran dalam {"height": int, "width" int} untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang disediakan untuk pra-pemrosesan. Jika pad_size tidak disediakan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketika do_pad=True.
do_center_crop (bool, kwargs, opsional) — Apakah akan melakukan center crop pada gambar.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — Hanya ChannelDimension.FIRST yang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat.
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — Format dimensi channel untuk gambar input. Jika tidak diset, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari:
- "channels_first" atau ChannelDimension.FIRST: gambar dalam format (num_channels, height, width).
- "channels_last" atau ChannelDimension.LAST: gambar dalam format (height, width, num_channels).
- "none" atau ChannelDimension.NONE: gambar dalam format (height, width).
device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input.
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Mengembalikan tensor bertumpuk jika diset ke 'pt', selain itu mengembalikan daftar tensor.
disable_grouping (bool, kwargs, opsional) — Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan bukan dalam batch. Jika None, akan diatur ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157
image_seq_length (int, kwargs, opsional) — Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini seharusnya diatur sebagai atribut prosesor pada model-model mendatang.
do_affine_transform (bool, kwargs, opsional) — Apakah akan menerapkan transformasi afine pada gambar input berdasarkan kotak pembatas.
normalize_factor (float, kwargs, opsional, default 200.0) — Faktor skala lebar dan tinggi yang digunakan untuk normalisasi saat menghitung center dan scale dari bounding box.

Membangun pemroses gambar VitPoseImageProcessor.

praproses

< 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

Parameter

images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Gambar yang akan dipreprocess. Mengharapkan satu gambar atau batch gambar dengan nilai piksel berkisar dari 0 hingga 255. Jika mengirimkan gambar dengan nilai piksel antara 0 dan 1, atur do_rescale=False.
boxes (list[list[list[float]]] atau np.ndarray) — Daftar atau array dari bounding box untuk setiap gambar. Setiap box harus berupa daftar 4 float yang merepresentasikan koordinat bounding box dalam format COCO (top_left_x, top_left_y, width, height).
do_convert_rgb (bool, kwargs, opsional) — Apakah akan mengonversi gambar ke RGB.
do_resize (bool, kwargs, opsional) — Apakah akan mengubah ukuran gambar.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Menggambarkan dimensi input maksimum untuk model.
default_to_square (bool, kwargs, opsional) — Apakah akan menggunakan gambar persegi sebagai default saat mengubah ukuran, jika size berupa int.
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran gambar keluaran setelah menerapkan center_crop.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filter resampling yang digunakan jika mengubah ukuran gambar. Ini dapat berupa salah satu enum PILImageResampling. Hanya berpengaruh jika do_resize diatur ke True.
do_rescale (bool, kwargs, opsional) — Apakah akan melakukan penskalaan ulang pada gambar.
rescale_factor (float, kwargs, opsional) — Faktor rescale untuk menskalakan ulang gambar jika do_rescale diatur ke True.
do_normalize (bool, kwargs, opsional) — Apakah akan menormalisasi gambar.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opsional) — Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika do_normalize diatur ke True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, opsional) — Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika do_normalize diatur ke True.
do_pad (bool, kwargs, opsional) — Apakah akan melakukan padding pada gambar. Padding dilakukan ke ukuran terbesar dalam batch atau ke ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model.
pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran dalam {"height": int, "width" int} untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang disediakan untuk pra-pemrosesan. Jika pad_size tidak disediakan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketika do_pad=True.
do_center_crop (bool, kwargs, opsional) — Apakah akan melakukan center crop pada gambar.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — Hanya ChannelDimension.FIRST yang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat.
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — Format dimensi channel untuk gambar input. Jika tidak diset, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari:
- "channels_first" atau ChannelDimension.FIRST: gambar dalam format (num_channels, height, width).
- "channels_last" atau ChannelDimension.LAST: gambar dalam format (height, width, num_channels).
- "none" atau ChannelDimension.NONE: gambar dalam format (height, width).
device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input.
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Mengembalikan tensor bertumpuk jika diset ke 'pt', selain itu mengembalikan daftar tensor.
disable_grouping (bool, kwargs, opsional) — Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan bukan dalam batch. Jika None, akan diatur ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157
image_seq_length (int, kwargs, opsional) — Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini seharusnya diatur sebagai atribut prosesor pada model-model mendatang.
do_affine_transform (bool, kwargs, opsional) — Apakah akan menerapkan transformasi afine pada gambar input berdasarkan kotak pembatas.
normalize_factor (float, kwargs, opsional, default 200.0) — Faktor skala lebar dan tinggi yang digunakan untuk normalisasi saat menghitung center dan scale dari bounding box.

Mengembalikan

~image_processing_base.BatchFeature

data (dict) — Kamus berisi daftar/array/tensor yang dikembalikan oleh metode call (‘pixel_values’, dll.).
tensor_type (Union[None, str, TensorType], opsional) — Anda dapat memberikan tensor_type di sini untuk mengonversi daftar bilangan bulat menjadi Tensor PyTorch/Numpy saat inisialisasi.

post_process_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]]

Parameter

outputs (VitPoseEstimatorOutput) — Output dari model VitPoseForPoseEstimation.
boxes (list[list[list[float]]] atau np.ndarray) — Daftar atau array dari bounding box untuk setiap gambar. Setiap box harus berupa daftar 4 float yang merepresentasikan koordinat bounding box dalam format COCO (top_left_x, top_left_y, width, height).
kernel_size (int, opsional, default 11) — Ukuran kernel Gaussian (K) untuk modulasi.
threshold (float, opsional, default None) — Ambang batas skor untuk mempertahankan prediksi deteksi objek.
target_sizes (torch.Tensor atau list[tuple[int, int]], opsional) — Tensor dengan bentuk (batch_size, 2) atau daftar tuple (tuple[int, int]) yang berisi ukuran target (height, width) dari setiap gambar dalam batch. Jika tidak diset, prediksi akan di-resize dengan nilai default.

Mengembalikan

list[list[Dict]]

Daftar dari beberapa kamus, di mana setiap kamus berisi titik-titik kunci (keypoints) dan kotak (boxes) untuk sebuah gambar dalam batch, sebagaimana diprediksi oleh model.

Ubah heatmap menjadi prediksi titik kunci, lalu ubah kembali ke gambar.

VitPoseImageProcessorPil

kelas transformers.VitPoseImageProcessorPil

< source >

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

Parameter

do_convert_rgb (bool, kwargs, opsional) — Apakah akan mengonversi gambar ke RGB.
do_resize (bool, kwargs, opsional) — Apakah akan mengubah ukuran gambar.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, defaultnya {'height' -- 256, 'width': 192}): Menggambarkan dimensi input maksimum untuk model.
default_to_square (bool, kwargs, opsional, defaultnya True) — Apakah akan menggunakan gambar persegi sebagai default saat melakukan resize, jika size berupa int.
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran gambar keluaran setelah menerapkan center_crop.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filter resampling yang digunakan jika mengubah ukuran gambar. Ini dapat berupa salah satu enum PILImageResampling. Hanya berpengaruh jika do_resize diatur ke True.
do_rescale (bool, kwargs, opsional, default True) — Apakah akan melakukan penskalaan ulang pada gambar.
rescale_factor (float, kwargs, opsional, default 0.00392156862745098) — Faktor rescale untuk menskalakan ulang gambar jika do_rescale diatur ke True.
do_normalize (bool, kwargs, opsional, default True) — Apakah akan menormalisasi gambar.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opsional, defaultnya [0.485, 0.456, 0.406]) — Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika do_normalize diatur ke True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, opsional, defaultnya [0.229, 0.224, 0.225]) — Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika do_normalize diatur ke True.
do_pad (bool, kwargs, opsional) — Apakah akan melakukan padding pada gambar. Padding dilakukan ke ukuran terbesar dalam batch atau ke ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model.
pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran dalam {"height": int, "width" int} untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang disediakan untuk pra-pemrosesan. Jika pad_size tidak disediakan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketika do_pad=True.
do_center_crop (bool, kwargs, opsional) — Apakah akan melakukan center crop pada gambar.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — Hanya ChannelDimension.FIRST yang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat.
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — Format dimensi channel untuk gambar input. Jika tidak diset, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari:
- "channels_first" atau ChannelDimension.FIRST: gambar dalam format (num_channels, height, width).
- "channels_last" atau ChannelDimension.LAST: gambar dalam format (height, width, num_channels).
- "none" atau ChannelDimension.NONE: gambar dalam format (height, width).
device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input.
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Mengembalikan tensor bertumpuk jika diset ke 'pt', selain itu mengembalikan daftar tensor.
disable_grouping (bool, kwargs, opsional) — Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan bukan dalam batch. Jika None, akan diatur ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157
image_seq_length (int, kwargs, opsional) — Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini seharusnya diatur sebagai atribut prosesor pada model-model mendatang.
do_affine_transform (bool, kwargs, opsional) — Apakah akan menerapkan transformasi afine pada gambar input berdasarkan kotak pembatas.
normalize_factor (float, kwargs, opsional, default 200.0) — Faktor skala lebar dan tinggi yang digunakan untuk normalisasi saat menghitung center dan scale dari bounding box.

Membangun pemroses gambar VitPoseImageProcessor.

praproses

< 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

Parameter

images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Gambar yang akan dipreprocess. Mengharapkan satu gambar atau batch gambar dengan nilai piksel berkisar dari 0 hingga 255. Jika mengirimkan gambar dengan nilai piksel antara 0 dan 1, atur do_rescale=False.
boxes (list[list[list[float]]] atau np.ndarray) — Daftar atau array dari bounding box untuk setiap gambar. Setiap box harus berupa daftar 4 float yang merepresentasikan koordinat bounding box dalam format COCO (top_left_x, top_left_y, width, height).
do_convert_rgb (bool, kwargs, opsional) — Apakah akan mengonversi gambar ke RGB.
do_resize (bool, kwargs, opsional) — Apakah akan mengubah ukuran gambar.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Menggambarkan dimensi input maksimum untuk model.
default_to_square (bool, kwargs, opsional) — Apakah akan menggunakan gambar persegi sebagai default saat mengubah ukuran, jika size berupa int.
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran gambar keluaran setelah menerapkan center_crop.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filter resampling yang digunakan jika mengubah ukuran gambar. Ini dapat berupa salah satu enum PILImageResampling. Hanya berpengaruh jika do_resize diatur ke True.
do_rescale (bool, kwargs, opsional) — Apakah akan melakukan penskalaan ulang pada gambar.
rescale_factor (float, kwargs, opsional) — Faktor rescale untuk menskalakan ulang gambar jika do_rescale diatur ke True.
do_normalize (bool, kwargs, opsional) — Apakah akan menormalisasi gambar.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opsional) — Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika do_normalize diatur ke True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, opsional) — Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika do_normalize diatur ke True.
do_pad (bool, kwargs, opsional) — Apakah akan melakukan padding pada gambar. Padding dilakukan ke ukuran terbesar dalam batch atau ke ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model.
pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran dalam {"height": int, "width" int} untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang disediakan untuk pra-pemrosesan. Jika pad_size tidak disediakan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketika do_pad=True.
do_center_crop (bool, kwargs, opsional) — Apakah akan melakukan center crop pada gambar.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — Hanya ChannelDimension.FIRST yang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat.
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — Format dimensi channel untuk gambar input. Jika tidak diset, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari:
- "channels_first" atau ChannelDimension.FIRST: gambar dalam format (num_channels, height, width).
- "channels_last" atau ChannelDimension.LAST: gambar dalam format (height, width, num_channels).
- "none" atau ChannelDimension.NONE: gambar dalam format (height, width).
device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input.
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Mengembalikan tensor bertumpuk jika diset ke 'pt', selain itu mengembalikan daftar tensor.
disable_grouping (bool, kwargs, opsional) — Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan bukan dalam batch. Jika None, akan diatur ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157
image_seq_length (int, kwargs, opsional) — Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini seharusnya diatur sebagai atribut prosesor pada model-model mendatang.
do_affine_transform (bool, kwargs, opsional) — Apakah akan menerapkan transformasi afine pada gambar input berdasarkan kotak pembatas.
normalize_factor (float, kwargs, opsional, default 200.0) — Faktor skala lebar dan tinggi yang digunakan untuk normalisasi saat menghitung center dan scale dari bounding box.

Mengembalikan

~image_processing_base.BatchFeature

data (dict) — Kamus berisi daftar/array/tensor yang dikembalikan oleh metode call (‘pixel_values’, dll.).
tensor_type (Union[None, str, TensorType], opsional) — Anda dapat memberikan tensor_type di sini untuk mengonversi daftar bilangan bulat menjadi Tensor PyTorch/Numpy saat inisialisasi.

post_process_pose_estimation

< source >

Parameter

outputs (VitPoseEstimatorOutput) — Output dari model VitPoseForPoseEstimation.
boxes (list[list[list[float]]] atau np.ndarray) — Daftar atau array dari bounding box untuk setiap gambar. Setiap box harus berupa daftar 4 float yang merepresentasikan koordinat bounding box dalam format COCO (top_left_x, top_left_y, width, height).
kernel_size (int, opsional, default 11) — Ukuran kernel Gaussian (K) untuk modulasi.
threshold (float, opsional, default None) — Ambang batas skor untuk mempertahankan prediksi deteksi objek.
target_sizes (torch.Tensor atau list[tuple[int, int]], opsional) — Tensor dengan bentuk (batch_size, 2) atau daftar tuple (tuple[int, int]) yang berisi ukuran target (height, width) dari setiap gambar dalam batch. Jika tidak disetel, prediksi akan di-resize dengan nilai default.

Mengembalikan

list[list[Dict]]

Daftar dari beberapa kamus, di mana setiap kamus berisi titik-titik kunci (keypoints) dan kotak (boxes) untuk sebuah gambar dalam batch, sebagaimana diprediksi oleh model.

Ubah heatmap menjadi prediksi titik kunci, lalu ubah kembali ke gambar.

VitPoseConfig

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

Parameter

backbone_config (Union[dict, ~configuration_utils.PreTrainedConfig], opsional) — Konfigurasi dari model backbone.
initializer_range (float, opsional, defaultnya 0.02) — Standar deviasi dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.
scale_factor (int, opsional, default 4) — Faktor untuk memperbesar (upscale) feature maps yang berasal dari backbone ViT.
use_simple_decoder (bool, opsional, default True) — Apakah akan menggunakan VitPoseSimpleDecoder untuk mendekode feature maps dari backbone menjadi heatmaps. Jika tidak, digunakan VitPoseClassicDecoder.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari VitposeModel. Kelas ini digunakan untuk menginstansiasi model Vitpose berdasarkan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Menginstansiasi konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari usyd-community/vitpose-base-simple

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

Contoh:

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

kelas transformers.VitPoseForPoseEstimation

< source >

( config: VitPoseConfig )

Parameter

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

Model VitPose dengan head estimasi pose di atasnya.

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

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

forward

< source >

( pixel_values: 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.FloatTensor)

Parameter

pixel_values (torch.Tensor dengan bentuk (batch_size, num_channels, image_size, image_size)) — Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan VitPoseImageProcessor. Lihat VitPoseImageProcessor.call() untuk detailnya (processor_class menggunakan VitPoseImageProcessor untuk memproses gambar).
dataset_index (torch.Tensor dengan bentuk (batch_size,)) — Indeks yang digunakan pada blok Mixture-of-Experts (MoE) di backbone. Ini sesuai dengan indeks dataset yang digunakan selama pelatihan, misalnya untuk indeks dataset tunggal, 0 merujuk pada dataset yang sesuai. Untuk beberapa dataset, indeks 0 merujuk pada dataset A (misalnya MPII) dan indeks 1 merujuk pada dataset B (misalnya CrowdPose).
Ini sesuai dengan indeks dataset yang digunakan selama pelatihan, misalnya. Untuk indeks dataset tunggal, 0 merujuk pada dataset yang sesuai. Untuk beberapa dataset, indeks 0 merujuk pada dataset A (misalnya MPII) dan indeks 1 merujuk pada dataset B (misalnya CrowdPose).
flip_pairs (torch.tensor, opsional) — Apakah akan membalikkan pasangan titik kunci (misalnya, telinga kiri — telinga kanan).
labels (torch.Tensor dengan bentuk (batch_size, sequence_length), opsional) — Label untuk menghitung kerugian pemodelan bahasa yang disamarkan (masked language modeling). Indeks harus berada dalam [0, ..., config.vocab_size] atau -100 (lihat docstring input_ids). Token dengan indeks yang disetel ke -100 diabaikan (disamarkan), kerugian hanya dihitung untuk token dengan label dalam [0, ..., config.vocab_size].

Mengembalikan

VitPoseEstimatorOutput atau tuple(torch.FloatTensor)

VitPoseEstimatorOutput atau tuple dari torch.FloatTensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai elemen tergantung pada konfigurasi (VitPoseConfig) dan input.

Metode forward dari VitPoseForPoseEstimation menimpa metode khusus __call__.

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

loss (torch.FloatTensor dengan bentuk (1,), opsional, dikembalikan ketika labels disediakan) — Loss tidak didukung saat ini. Lihat https://github.com/ViTAE-Transformer/ViTPose/tree/main/mmpose/models/losses untuk detail lebih lanjut.
heatmaps (torch.FloatTensor dengan bentuk (batch_size, num_keypoints, height, width)) — Heatmaps yang diprediksi oleh model.
hidden_states (tuple(torch.FloatTensor), opsional, dikembalikan saat output_hidden_states=True dilewatkan atau saat config.output_hidden_states=True) — Tuple dari torch.FloatTensor (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap tahap) dengan bentuk (batch_size, sequence_length, hidden_size). Hidden-states (juga disebut feature maps) dari model pada output dari setiap tahap.
attentions (tuple[torch.FloatTensor, ...], opsional, dikembalikan saat output_attentions=True dilewatkan atau saat config.output_attentions=True) — Tuple dari torch.FloatTensor (satu untuk setiap layer) dengan bentuk (batch_size, num_heads, sequence_length, sequence_length).

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

Contoh:

>>> from transformers import AutoImageProcessor, 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→