# V-JEPA 2

[V-JEPA 2](https://huggingface.co/papers/2506.09985)([블로그 포스트](https://ai.meta.com/blog/v-jepa-2-world-model-benchmarks/))는 FAIR, Meta에서 개발한 비디오 인코더를 학습하기 위한 자기 지도 학습 방식입니다. 인터넷 규모의 비디오 데이터를 활용하여 V-JEPA 2는 동작 이해 및 인간 행동 예측 작업에서 최첨단 성능을 달성합니다. V-JEPA 2-AC는 V-JEPA 2에서 후학습된 잠재적 행동 조건부 월드 모델로, 소량의 로봇 궤적 상호작용 데이터를 사용하여 환경별 데이터 수집이나 작업별 학습, 보정 없이 로봇 조작 작업을 해결합니다.

    

모든 원본 V-JEPA2 체크포인트는 [V-JEPA 2](https://huggingface.co/collections/facebook/v-jepa-2-6841bad8413014e185b497a6) 컬렉션에서 찾을 수 있습니다.

이 모델은 [koustuvs](https://huggingface.co/koustuvs), [yonigozlan](https://huggingface.co/yonigozlan), [qubvel](https://huggingface.co/qubvel-hf)에 의해 기여되었습니다. 원본 코드는 [여기](https://github.com/facebookresearch/vjepa2)에서 찾을 수 있습니다.

## 사용 예시

아래 스니펫은 `AutoModel` 클래스를 사용하여 V-JEPA 2 모델을 특징 추출용으로 로드하는 방법을 보여줍니다.

```python
import numpy as np
from torchcodec.decoders import VideoDecoder

processor = AutoVideoProcessor.from_pretrained("facebook/vjepa2-vitl-fpc64-256")
model = AutoModel.from_pretrained(
    "facebook/vjepa2-vitl-fpc64-256",
    device_map="auto",
    attn_implementation="sdpa"
)

video_url = "https://huggingface.co/datasets/nateraw/kinetics-mini/resolve/main/val/archery/-Qz25rXdMjE_000014_000024.mp4"

vr = VideoDecoder(video_url)
frame_idx = np.arange(0, 64) # choosing some frames. here, you can define more complex sampling strategy
video = vr.get_frames_at(indices=frame_idx).data  # T x C x H x W
video = processor(video, return_tensors="pt").to(model.device)
outputs = model(**video)

# V-JEPA 2 encoder outputs, same as calling `model.get_vision_features()`
encoder_outputs = outputs.last_hidden_state

# V-JEPA 2 predictor outputs
predictor_outputs = outputs.predictor_output.last_hidden_state
```

V-JEPA 2는 비디오 분류를 위해 finetune할 수도 있습니다. 다음 스니펫에서는 Something-Something-V2 비디오 분류 모델로 finetune된 모델을 사용하는 방법을 보여줍니다.

```python
import numpy as np
import torch
from torchcodec.decoders import VideoDecoder

from transformers import AutoModelForVideoClassification, AutoVideoProcessor

# Load model and video preprocessor
hf_repo = "facebook/vjepa2-vitl-fpc16-256-ssv2"

model = AutoModelForVideoClassification.from_pretrained(hf_repo, device_map="auto")
processor = AutoVideoProcessor.from_pretrained(hf_repo)

# To load a video, sample the number of frames according to the model.
video_url = "https://huggingface.co/datasets/nateraw/kinetics-mini/resolve/main/val/bowling/-WH-lxmGJVY_000005_000015.mp4"
vr = VideoDecoder(video_url)
frame_idx = np.arange(0, model.config.frames_per_clip, 8) # you can define more complex sampling strategy
video = vr.get_frames_at(indices=frame_idx).data  # frames x channels x height x width

# Preprocess and run inference
inputs = processor(video, return_tensors="pt").to(model.device)
with torch.no_grad():
    outputs = model(**inputs)
logits = outputs.logits

print("Top 5 predicted class names:")
top5_indices = logits.topk(5).indices[0]
top5_probs = torch.softmax(logits, dim=-1).topk(5).values[0]
for idx, prob in zip(top5_indices, top5_probs):
    text_label = model.config.id2label[idx.item()]
    print(f" - {text_label}: {prob:.2f}")
```

## VJEPA2Config[[transformers.VJEPA2Config]]

#### transformers.VJEPA2Config[[transformers.VJEPA2Config]]

```python
transformers.VJEPA2Config(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, patch_size: int | list[int] | tuple[int, int] = 16, crop_size: int = 256, frames_per_clip: int = 64, tubelet_size: int = 2, hidden_size: int = 1024, in_chans: int = 3, num_attention_heads: int = 16, num_hidden_layers: int = 24, drop_path_rate: float | int = 0.0, mlp_ratio: int | float = 4.0, layer_norm_eps: float = 1e-06, qkv_bias: bool = True, attention_probs_dropout_prob: float | int = 0.0, hidden_act: str = 'gelu', initializer_range: float = 0.02, attention_dropout: float | int = 0.0, num_pooler_layers: int = 3, pred_hidden_size: int = 384, pred_num_attention_heads: int = 12, pred_num_hidden_layers: int = 12, pred_num_mask_tokens: int = 10, pred_zero_init_mask_tokens: bool = True, pred_mlp_ratio: int | float = 4.0)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vjepa2/configuration_vjepa2.py#L24)

**매개변수:**

patch_size (`Union[int, list[int], tuple[int, int]]`, *선택*, 기본값 `16`) : 각 패치의 크기(해상도).

crop_size (`int`, *선택 사항*, 기본값 256) : 모델의 입력 해상도

frames_per_clip (`int`, *선택 사항*, 기본값 64) : 모델이 사전 학습에 사용된 프레임 수입니다. 추론에는 영향을 미치지 않습니다.

tubelet_size (`int`, *선택 사항*, 기본값 2) : 단일 rastor에 사용되는 시간 프레임의 수입니다. 자세한 내용은 논문을 참고하세요.

hidden_size (`int`, *선택 사항*, 기본값 `1024`) : 숨겨진 표현의 차원.

in_chans (`int`, *선택 사항*, 기본값 `3`) : 입력 채널의 수입니다.

num_attention_heads (`int`, *선택 사항*, 기본값 `16`) : Transformer decoder의 각 attention layer에 사용할 attention head의 수입니다.

num_hidden_layers (`int`, *선택 사항*, 기본값 `24`) : Transformer decoder의 숨겨진 레이어 수.

drop_path_rate (`Union[float, int]`, *선택 사항*, 기본값 `0.0`) : 패치 퓨전용 드롭 패스 비율입니다.

mlp_ratio (`Union[int, float]`, *선택 사항*, 기본값 `4.0`) : MLP 숨겨진 차원과 임베딩 차원의 비율입니다.

layer_norm_eps (`float`, *선택 사항*, 기본값 `1e-06`) : 레이어 정규화 레이어에서 사용되는 epsilon 값입니다.

qkv_bias (`bool`, *선택 사항*, 기본값 `True`) : 쿼리, 키, 값에 bias를 추가할지 여부.

attention_probs_dropout_prob (`Union[float, int]`, *선택 사항*, 기본값 `0.0`) : attention 확률에 적용할 dropout 비율입니다.

hidden_act (`str`, *선택 사항*, 기본값 `gelu`) : 디코더에서 사용되는 비선형 활성화 함수(함수 또는 문자열). 예를 들어, `"gelu"`, `"relu"`, `"silu"` 등이 있습니다.

initializer_range (`float`, *선택 사항*, 기본값 `0.02`) : 모든 가중치 행렬을 초기화하는 truncated_normal_initializer의 표준 편차입니다.

attention_dropout (`Union[float, int]`, *선택 사항*, 기본값 `0.0`) : attention 확률에 적용할 dropout 비율입니다.

num_pooler_layers (`int`, *선택 사항*, 기본값 3) : pooler의 self-attention 레이어 수입니다.

pred_hidden_size (`int`, *선택 사항*, 기본값 384) : 예측기 레이어의 차원

pred_num_attention_heads (`int`, *선택 사항*, 기본값 12) : Predictor의 각 attention layer에 사용할 attention head의 수

pred_num_hidden_layers (`int`, *선택 사항*, 기본값 12) : Predictor의 숨겨진 레이어 수

pred_num_mask_tokens (`int`, *선택 사항*, 기본값 10) : Predictor에서 사용할 mask 토큰의 수를 정의합니다

pred_zero_init_mask_tokens (`bool`, *선택 사항*, 기본값 `True`) : predictor의 mask 토큰을 0으로 초기화합니다.

pred_mlp_ratio (`float`, *선택 사항*, 기본값 4.0) : Predictor에서 사용되는 MLP의 숨겨진 크기(hidden size)가 `pred_hidden_size`에 대한 비율입니다.

이것은 VJEPA2Model의 구성을 저장하기 위한 구성 클래스입니다. 지정된 인자에 따라 Vjepa2 모델을 인스턴스화하여 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 구성을 인스턴스화하면 [facebook/vjepa2-vitl-fpc64-256](https://huggingface.co/facebook/vjepa2-vitl-fpc64-256)의 구성과 유사한 구성이 생성됩니다.

Configuration 객체는 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/main_classes/configuration#transformers.PreTrainedConfig)를 상속하며, 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/main_classes/configuration#transformers.PreTrainedConfig)의 문서를 참고하세요.

예:

```python
>>> from transformers import VJEPA2Config, VJEPA2Model

>>> # Initializing a VJEPA2 vjepa2-vitl-fpc64-256 style configuration
>>> configuration = VJEPA2Config()

>>> # Initializing a model (with random weights) from the vjepa2-vitl-fpc64-256  style configuration
>>> model = VJEPA2Model(configuration)

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

## VJEPA2Model[[transformers.VJEPA2Model]]

#### transformers.VJEPA2Model[[transformers.VJEPA2Model]]

```python
transformers.VJEPA2Model(config: VJEPA2Config)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vjepa2/modeling_vjepa2.py#L888)

**매개변수:**

config ([VJEPA2Config](/docs/transformers/v5.23.0/ko/model_doc/vjepa2#transformers.VJEPA2Config)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

특정 헤드가 위에 없는 상태에서 원시 hidden-states를 출력하는 기본 Vjepa2 Model입니다.

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

#### forward[[transformers.VJEPA2Model.forward]]

```python
forward(pixel_values_videos: Tensor, context_mask: list[torch.Tensor] | None = None, target_mask: list[torch.Tensor] | None = None, skip_predictor: bool = False, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vjepa2/modeling_vjepa2.py#L902)

**매개변수:**

pixel_values_videos (`torch.Tensor`, shape `(batch_size, num_frames, num_channels, frame_size, frame_size)`) : 입력 비디오에 해당하는 텐서입니다. 비디오의 픽셀 값은 [VJEPA2VideoProcessor](/docs/transformers/v5.23.0/ko/model_doc/vjepa2#transformers.VJEPA2VideoProcessor)를 사용하여 얻을 수 있습니다. 자세한 내용은 [VJEPA2VideoProcessor.__call__()](/docs/transformers/v5.23.0/ko/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__)를 참조하세요 (`processor_class`는 비디오 처리에 [VJEPA2VideoProcessor](/docs/transformers/v5.23.0/ko/model_doc/vjepa2#transformers.VJEPA2VideoProcessor)를 사용합니다).

context_mask (`torch.Tensor`, shape `[batch_size, patch_size, 1]`, *선택 사항*) : 예측기에 노출될 인코더 출력 패치를 나타내는 마스크 위치 ID입니다. 기본적으로 이 마스크는 예측기가 전체 컨텍스트를 사용할 수 있음을 나타내는 torch.arange(N).unsqueeze(0).repeat(B,1)로 생성됩니다.

target_mask (`torch.Tensor`, shape `[batch_size, patch_size, 1]`, *선택 사항*) : 예측기(predictor)의 예측 대상으로 사용될 인코더 출력 패치를 나타내는 마스크 위치 ID입니다. 기본적으로 이 마스크는 torch.arange(N).unsqueeze(0).repeat(B,1)로 생성되며, 예측기가 모든 인코더 패치를 예측해야 함을 나타냅니다.

skip_predictor (`bool`, *선택 사항*, 기본값 `False`) : 예측자(forward)를 건너뛰는 플래그로, 인코더 출력만 필요한 경우 유용합니다

**반환값:** `VJEPA2WithMaskedInputModelOutput` 또는 `tuple(torch.Tensor)`

`VJEPA2WithMaskedInputModelOutput` 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우)로, [VJEPA2Config](/docs/transformers/v5.23.0/ko/model_doc/vjepa2#transformers.VJEPA2Config) 및 입력에 따라 다양한 요소를 포함합니다.

[VJEPA2Model](/docs/transformers/v5.23.0/ko/model_doc/vjepa2#transformers.VJEPA2Model)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`) -- 모델의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다.
- **masked_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*, `context_mask`가 제공되고 VJEPA2Encoder 출력에 적용될 때 반환됨) -- 모델의 masked hidden state입니다.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **attentions** (`tuple[torch.Tensor, ...]`, *선택*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor` 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.
- **predictor_output** (`VJEPA2WithMaskedInputPredictorOutput`, *선택 사항*) -- Predictor 모듈의 출력입니다.

## VJEPA2ForVideoClassification[[transformers.VJEPA2ForVideoClassification]]

#### transformers.VJEPA2ForVideoClassification[[transformers.VJEPA2ForVideoClassification]]

```python
transformers.VJEPA2ForVideoClassification(config: VJEPA2Config)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vjepa2/modeling_vjepa2.py#L976)

**매개변수:**

config ([VJEPA2Config](/docs/transformers/v5.23.0/ko/model_doc/vjepa2#transformers.VJEPA2Config)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

V-JEPA 2 모델은 attentive pooler 위에 선형 레이어를 배치한 비디오 분류 헤드를 갖춘 transformer입니다.

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

#### forward[[transformers.VJEPA2ForVideoClassification.forward]]

```python
forward(pixel_values_videos: Tensor, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vjepa2/modeling_vjepa2.py#L990)

**매개변수:**

pixel_values_videos (`torch.Tensor`, shape `(batch_size, num_frames, num_channels, frame_size, frame_size)`) : 입력 비디오에 해당하는 텐서입니다. 비디오의 픽셀 값은 [VJEPA2VideoProcessor](/docs/transformers/v5.23.0/ko/model_doc/vjepa2#transformers.VJEPA2VideoProcessor)를 사용하여 얻을 수 있습니다. 자세한 내용은 [VJEPA2VideoProcessor.__call__()](/docs/transformers/v5.23.0/ko/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__)를 참조하세요 (`processor_class`는 비디오 처리에 [VJEPA2VideoProcessor](/docs/transformers/v5.23.0/ko/model_doc/vjepa2#transformers.VJEPA2VideoProcessor)를 사용합니다).

labels (`torch.LongTensor`, shape `(batch_size,)`, *선택 사항*) : 이미지 분류/회귀 손실을 계산하는 데 사용되는 라벨. 인덱스는 `[0, ..., config.num_labels - 1]` 범위에 있어야 합니다. `config.num_labels == 1`인 경우 회귀 손실(평균 제곱 손실)이 계산되고, `config.num_labels > 1`인 경우 분류 손실(크로스 엔트로피)이 계산됩니다.

**반환값:** [ImageClassifierOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) 또는 `tuple(torch.Tensor)`

구성([VJEPA2Config](/docs/transformers/v5.23.0/ko/model_doc/vjepa2#transformers.VJEPA2Config))과 입력에 따라 다양한 요소를 포함하는 [ImageClassifierOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우).

[VJEPA2ForVideoClassification](/docs/transformers/v5.23.0/ko/model_doc/vjepa2#transformers.VJEPA2ForVideoClassification)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **loss** (`torch.Tensor`, shape `(1,)`, *선택*, `labels`이 제공될 때 반환됨) -- 분류(또는 config.num_labels==1인 경우 회귀) 손실.
- **logits** (`torch.Tensor`, shape `(batch_size, config.num_labels)`) -- SoftMax 적용 전 분류(또는 config.num_labels==1인 경우 회귀) 점수.
- **hidden_states** (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- `torch.Tensor`의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력용 1개 + 각 단계 출력용 1개)로, shape이 `(batch_size, sequence_length, hidden_size)`입니다. 각 단계 출력 시점의 모델 hidden-states(또는 feature maps)입니다.
- **attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어당 하나씩, shape가 `(batch_size, num_heads, patch_size, sequence_length)`인 `torch.Tensor`의 튜플.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.

예:

```python
>>> import torch
>>> import numpy as np
>>> from transformers import AutoVideoProcessor, VJEPA2ForVideoClassification

>>> device = "cuda"

>>> video_processor = AutoVideoProcessor.from_pretrained("facebook/vjepa2-vitl-fpc16-256-ssv2")
>>> model = VJEPA2ForVideoClassification.from_pretrained("facebook/vjepa2-vitl-fpc16-256-ssv2").to(device)

>>> video = np.ones((64, 256, 256, 3))  # 64 frames, 256x256 RGB
>>> inputs = video_processor(video, return_tensors="pt").to(device)

>>> # For inference
>>> with torch.no_grad():
...     outputs = model(**inputs)
>>> logits = outputs.logits

>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])

>>> # For training
>>> labels = torch.ones(1, dtype=torch.long, device=device)
>>> loss = model(**inputs, labels=labels).loss

```

## VJEPA2VideoProcessor[[transformers.VJEPA2VideoProcessor]]

#### transformers.VJEPA2VideoProcessor[[transformers.VJEPA2VideoProcessor]]

```python
transformers.VJEPA2VideoProcessor(**kwargs: *<class 'transformers.processing_utils.VideosKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vjepa2/video_processing_vjepa2.py#L23)

**매개변수:**

do_convert_rgb (`bool`, *kwargs*, *선택*) : 이미지를 RGB로 변환할지 여부.

do_resize (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : 이미지를 리사이즈할지 여부.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, 기본값 `{'shortest_edge' : 292}`): 모델에 입력되는 최대 차원을 설명합니다.

default_to_square (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : size가 int인 경우 리사이즈 시 정사각형 이미지로 설정할지 여부.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, 기본값 `2`) : 이미지를 리사이즈할 때 사용할 리샘플링 필터입니다. 이는 `PILImageResampling` enum 중 하나일 수 있습니다. `do_resize`가 `True`로 설정된 경우에만 효과가 있습니다.

do_rescale (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : 이미지를 다시 스케일링할지 여부.

rescale_factor (`float`, *kwargs*, *선택 사항*, 기본값 `0.00392156862745098`) : `do_rescale`이 `True`로 설정된 경우 이미지를 재조정하는 데 사용되는 재조정 계수입니다.

do_normalize (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : 이미지를 정규화할지 여부.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *선택 사항*, 기본값은 `[0.485, 0.456, 0.406]`) : 정규화에 사용할 이미지 평균입니다. `do_normalize`가 `True`로 설정된 경우에만 효과가 있습니다.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *선택 사항*, 기본값은 `[0.229, 0.224, 0.225]`) : 정규화에 사용할 이미지 표준 편차입니다. `do_normalize`가 `True`로 설정된 경우에만 효과가 있습니다.

do_center_crop (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : 이미지를 중앙 크롭할지 여부.

do_pad (`bool`, *kwargs*, *선택*) : 이미지를 패딩할지 여부입니다. 패딩은 배치 내 가장 큰 크기로 수행하거나, 이미지마다 고정된 정사각형 크기로 수행합니다. 정확한 패딩 전략은 모델에 따라 달라집니다.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, 기본값 `256`) : `center_crop`를 적용한 후의 출력 이미지 크기입니다.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *선택*) : `ChannelDimension.FIRST`만 지원됩니다. 느린 프로세서와의 호환성을 위해 추가되었습니다.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *선택*) : 입력 이미지의 채널 차원 형식입니다. 설정하지 않으면 입력 이미지에서 채널 차원 형식을 추론합니다. 다음 중 하나일 수 있습니다: - `"channels_first"` 또는 `ChannelDimension.FIRST`: (num_channels, height, width) 형식의 이미지. - `"channels_last"` 또는 `ChannelDimension.LAST`: (height, width, num_channels) 형식의 이미지. - `"none"` 또는 `ChannelDimension.NONE`: (height, width) 형식의 이미지.

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : 비디오를 처리할 장치입니다. 설정되지 않은 경우, 입력 비디오에서 장치를 추론합니다.

do_sample_frames (`bool`, *kwargs*, *선택*) : 처리 전에 비디오에서 프레임을 샘플링할지, 아니면 비디오 전체를 처리할지 여부.

video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : 총 길이, fps, 총 프레임 수에 대한 정보를 포함하는 비디오의 메타데이터입니다. 비디오에서 프레임을 샘플링하거나 타임스탬프를 계산하는 데 사용됩니다. 비디오를 수동으로 디코딩하여 처리하려는 경우를 제외하고는 메타데이터를 전달하지 마세요

fps (`Annotated[int | float | None, None]`, *kwargs*) : `do_sample_frames=True`일 때 초당 샘플링할 대상 프레임 수.

num_frames (`Annotated[int | None, None]`, *kwargs*) : `do_sample_frames=True`일 때 샘플링할 최대 프레임 수.

return_metadata (`bool`, *kwargs*, *선택 사항*, 기본값 `False`) : 비디오 메타데이터를 반환할지 여부입니다. 비디오 메타데이터는 비디오 길이, fps, 디코딩 백엔드 등에 대한 정보를 포함하는 객체입니다.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : 설정된 경우, 특정 프레임워크의 텐서를 반환합니다. 허용되는 값은 다음과 같습니다: - `'pt'`: PyTorch `torch.Tensor` 객체를 반환합니다. - `'np'`: NumPy `np.ndarray` 객체를 반환합니다.

- ****kwargs** ([VideosKwargs](/docs/transformers/v5.23.0/ko/main_classes/processors#transformers.VideosKwargs), *optional*) : 각 모달리티(텍스트, 이미지, 비디오, 오디오)에 대한 추가 처리 옵션입니다. 모델별 매개변수는 위에 나열되어 있으며, 지원되는 인수의 전체 목록은 TypedDict 클래스를 참조하세요.

VJEPA2VideoProcessor 비디오 프로세서를 생성합니다.

