# Video processor

**Video Processor**は、動画モデルの入力特徴量の準備と、その出力の後処理を担当するユーティリティです。リサイズ、正規化、PyTorch への変換などの変換処理を提供します。変換処理に加えて、`VideoProcessor` クラスは、ローカルパスまたは URL からの動画デコード（[`torchcodec`](https://pypi.org/project/torchcodec/) が必要）と、モデル固有の戦略に基づくフレームサンプリングを処理します。

video processorは、画像プロセッサの機能を拡張し、Vision Large Language Models (VLMs) が画像とは異なる引数セットを使用して動画を処理できるようにします。これは生データである動画とモデルの間の橋渡し役として機能し、入力特徴量がVLM向けに最適化されることを保証します。

Video processorの設定は`video_preprocessor_config.json`に保存されます。古いチェックポイントでは、`preprocessor_config.json`に保存されている場合があります。再読み込み時のカスタムバックエンドの登録については、[保存と再読み込み](#save-and-reload)を参照してください。

## 使用例

[`llava-hf/llava-onevision-qwen2-0.5b-ov-hf`](https://huggingface.co/llava-hf/llava-onevision-qwen2-0.5b-ov-hf) モデルでビデオプロセッサを読み込む例を以下に示します。

```python
from transformers import AutoVideoProcessor

processor = AutoVideoProcessor.from_pretrained("llava-hf/llava-onevision-qwen2-0.5b-ov-hf")
```

前処理は、入力テンソルのデバイス上で実行されます。その他の入力の場合は、CPU上で実行されます。`device`を設定することで、前処理の前に別のデバイスへ動画を送信できます。これによりバックエンドは変更されません。アクセラレーターを使用している場合、torchvisionの前処理を`torch.compile`でコンパイルすることもできます。

```python
import torch
from transformers.video_utils import load_video
from transformers import AutoVideoProcessor

device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"

video = load_video("video.mp4")
processor = AutoVideoProcessor.from_pretrained("llava-hf/llava-onevision-qwen2-0.5b-ov-hf", device=device)
processor = torch.compile(processor)
processed_video = processor(video, return_tensors="pt")
```

## Video processor バックエンド

組み込みのビデオプロセッサは、バッチ化されたリサイズ、リスケール、正規化に[torchvision](https://pytorch.org/vision/stable/index.html)を使用します。これらを使用するには、PyTorchとtorchvisionをインストールしてください。画像プロセッサとは異なり、組み込みのビデオプロセッサにはPILバックエンドは提供されていません。

[AutoVideoProcessor](/docs/transformers/main/ja/model_doc/auto#transformers.AutoVideoProcessor)はデフォルトで`torchvision`バックエンドを選択します。明示的に指定することもでき、読み込まれたプロセッサの`backend`属性を確認できます。

```python
from transformers import AutoVideoProcessor

model_id = "llava-hf/llava-onevision-qwen2-0.5b-ov-hf"
video_processor = AutoVideoProcessor.from_pretrained(model_id, backend="torchvision")
print(video_processor.backend)
# torchvision
```

`backend` 引数は、動画デコーダーではなく、前処理の実装を選択します。デコードとフレームサンプリングについては、[サンプリングの動作](#sampling-behavior)を参照してください。

### カスタムバックエンド

[BaseVideoProcessor](/docs/transformers/main/ja/main_classes/video_processor#transformers.BaseVideoProcessor) は torchvision ベースの前処理を提供します。torchvision を使わない実装を行う場合は、[VideoProcessorMixin](/docs/transformers/main/ja/main_classes/video_processor#transformers.VideoProcessorMixin) をサブクラス化し、`preprocess` をオーバーライドして、モデルが期待する入力を格納した [BatchFeature](/docs/transformers/main/ja/main_classes/feature_extractor#transformers.BatchFeature) を返すようにします。

[AutoVideoProcessor.register()](/docs/transformers/main/ja/model_doc/auto#transformers.AutoVideoProcessor.register) でカスタムクラスを登録し、`video_processor_classes` を使用してバックエンド名をクラスにマッピングします。以下の例では、`NewCustomVideoProcessor` が LLaVA-OneVision チェックポイントに必要な前処理を定義済みであると仮定しています。

```python
from transformers import LlavaOnevisionConfig

AutoVideoProcessor.register(
    LlavaOnevisionConfig,
    video_processor_classes={"custom": NewCustomVideoProcessor},
    exist_ok=True,
)
custom_processor = AutoVideoProcessor.from_pretrained(model_id, backend="custom")
```

`LlavaOnevisionConfig` はすでに登録されているため、`exist_ok=True` を使用します。指定されたエントリはバックエンドのマッピングにマージされ、名前が一致するエントリは置き換えられ、`torchvision` のように指定されていないエントリは保持されます。

### 保存と再読み込み

[save_pretrained()](/docs/transformers/main/ja/main_classes/video_processor#transformers.VideoProcessorMixin.save_pretrained) は、[AutoVideoProcessor.register()](/docs/transformers/main/ja/model_doc/auto#transformers.AutoVideoProcessor.register) で追加されたバックエンドのマッピングではなく、前処理の設定を保存します。同じ Python プロセス内で、保存したプロセッサを `backend="custom"` を指定して再読み込みします:

```python
custom_processor.save_pretrained("./saved-video-processor")
custom_processor = AutoVideoProcessor.from_pretrained("./saved-video-processor", backend="custom")
```

カスタム登録は、現在の Python プロセスにのみ適用されます。新しいプロセスでは、カスタムクラスを定義またはインポートし、読み込み前に再度登録してください。

## サンプリングの動作

Video Processor は、対象のモデルに最も適した手法を用いて動画フレームをサンプリングすることもできます。サンプリングの動作は `do_sample_frames` 引数で制御され、`num_frames` や `fps`（動画のサンプリングレート）などのモデル固有のパラメータで設定できます。入力動画がローカルパスまたは URL（`str`）として与えられた場合、プロセッサは自動的にデコードします。サンプリングされたフレームのインデックス、元の解像度、再生時間、fps などのデコード済み動画のメタデータを取得するには、プロセッサに `return_metadata=True` を渡してください。

- `num_frames`を指定しても、出力がちょうどそのフレーム数になることは保証されません。モデルによって、サンプラーが最小または最大のフレーム数の制限を強制する場合があります。

- デフォルトのデコーダーは [`torchcodec`](https://pypi.org/project/torchcodec/) であり、インストールが必要です。

```python
import torch
from transformers import AutoVideoProcessor

device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"

processor = AutoVideoProcessor.from_pretrained("llava-hf/llava-onevision-qwen2-0.5b-ov-hf", device=device)
processed_video_inputs = processor(videos=["video_path.mp4"], return_metadata=True, do_sample_frames=True, return_tensors="pt")
video_metadata = processed_video_inputs["video_metadata"]

# See how many frames the original video had and what was the original FPS
print(video_metadata.total_num_frames, video_metadata.fps)
```

デコード済みの動画配列を渡す場合でも、モデル固有のフレームサンプリングを有効にしたい場合は、video_metadata を提供することを強く推奨します。これにより、サンプラーは元の動画の再生時間と FPS を把握できます。メタデータは `VideoMetadata` オブジェクトとして渡すことも、プレーンな dict として渡すこともできます。

```python
import torch
from transformers import AutoVideoProcessor
from transformers.video_utils import VideoMetadata

device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"

processor = AutoVideoProcessor.from_pretrained("llava-hf/llava-onevision-qwen2-0.5b-ov-hf", device=device)
decoded_video = torch.randint(0, 255, size=(100, 3, 1280, 1280)) # short video of 100 frames
video_metadata = VideoMetadata(
    total_num_frames=100,
    fps=24,
    duration=4.1, # in seconds
)
processed_video_inputs = processor(videos=[decoded_video], video_metadata=video_metadata, do_sample_frames=True, num_frames=10, return_tensors="pt")
print(processed_video_inputs.pixel_values_videos.shape)
[10, 3, 384, 384]
```

## VideoProcessorMixin[[transformers.VideoProcessorMixin]]

#### transformers.VideoProcessorMixin[[transformers.VideoProcessorMixin]]

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

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/video_processing_utils.py#L76)

#### fetch_videos[[transformers.VideoProcessorMixin.fetch_videos]]

```python
fetch_videos(video_url_or_urls: str | list[str] | list[list[str]], sample_indices_fn = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/video_processing_utils.py#L559)

単一のURLまたはURLのリストを、対応する`np.array`オブジェクトに変換します。

単一のurlが渡された場合、戻り値は単一のオブジェクトになります。リストが渡された場合、オブジェクトのリストが返されます。

#### from_dict[[transformers.VideoProcessorMixin.from_dict]]

```python
from_dict(video_processor_dict: dict, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/video_processing_utils.py#L431)

**パラメータ:**

video_processor_dict (`dict[str, Any]`) : video processor オブジェクトをインスタンス化するために使用される辞書。この辞書は、`~video_processing_utils.VideoProcessorBase.to_dict` メソッドを活用して事前学習済みチェックポイントから取得できます。

kwargs (`dict[str, Any]`) : video processor オブジェクトの初期化に使用する追加のパラメータ。

**戻り値:** `~video_processing_utils.VideoProcessorBase`

これらのパラメータからインスタンス化されたビデオプロセッサオブジェクト。

Pythonのパラメータ辞書から`~video_processing_utils.VideoProcessorBase`の型をインスタンス化します。

#### from_json_file[[transformers.VideoProcessorMixin.from_json_file]]

```python
from_json_file(json_file: str | os.PathLike)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/video_processing_utils.py#L514)

**パラメータ:**

json_file (`str` または `os.PathLike`) : パラメータを含む JSON ファイルへのパス。

**戻り値:** `~video_processing_utils.VideoProcessorBase` 型のビデオプロセッサ

その JSON ファイルからインスタンス化された video_processor オブジェクト。

パラメータの JSON ファイルへのパスから、`~video_processing_utils.VideoProcessorBase` 型のビデオプロセッサをインスタンス化します。

#### from_pretrained[[transformers.VideoProcessorMixin.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/video_processing_utils.py#L142)

**パラメータ:**

pretrained_model_name_or_path (`str` または `os.PathLike`) : 以下のいずれかです。 - huggingface.co のモデルリポジトリにホストされている事前学習済み動画の *model id* を示す文字列。 - `~video_processing_utils.VideoProcessorBase.save_pretrained` メソッドを使用して保存された動画プロセッサファイルを含む *ディレクトリ* へのパス。例: `./my_model_directory/`。 - 保存された動画プロセッサの JSON *ファイル* へのパス。例: `./my_model_directory/video_preprocessor_config.json`。

cache_dir (`str` または `os.PathLike`、*任意*) : 標準のキャッシュを使用しない場合、ダウンロードした事前学習済みモデルの video processor をキャッシュするディレクトリのパス。

force_download (`bool`、*任意*、デフォルトは`False`) : 存在する場合はキャッシュされたバージョンを上書きし、動画プロセッサのファイルを（再）ダウンロードすることを強制するかどうか。

proxies (`dict[str, str]`, *省略可*) : プロトコルまたはエンドポイントごとに使用するプロキシサーバーの辞書。例: `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}.` 各リクエストでこれらのプロキシが使用されます。

token (`str` または `bool`、*省略可*) : リモートファイルの HTTP ベアラ認証に使用するトークン。`True` の場合、または指定されていない場合は、`hf auth login` を実行した際に生成されたトークン（`~/.huggingface` に保存）が使用されます。

revision (`str`、*任意*、デフォルトは`"main"`) : 使用する特定のモデルバージョンです。huggingface.co ではモデルやその他の成果物を保存するために git ベースのシステムを使用しているため、ブランチ名、タグ名、コミット ID など、git で許可されている任意の識別子を`revision`に指定できます。     Hub で作成したプルリクエストをテストするには、`revision="refs/pr/<pr_number>"`を渡すことができます。

return_unused_kwargs (`bool`、*任意*、デフォルトは`False`) : `False`の場合、この関数は最終的なvideo processorオブジェクトのみを返します。`True`の場合、この関数は`Tuple(video_processor, unused_kwargs)`を返します。ここで、*unused_kwargs*は、キーがvideo processorの属性でないキー/値のペアで構成される辞書です。つまり、`kwargs`のうち`video_processor`の更新に使われず、それ以外では無視される部分です。

subfolder (`str`、*任意*、デフォルトは`""`) : 関連するファイルが huggingface.co 上のモデルリポジトリ内のサブフォルダに配置されている場合、ここにフォルダ名を指定できます。

kwargs (`dict[str, Any]`、*省略可*) : kwargs 内の、キーが video processor の属性である値は、読み込まれた値の上書きに使用されます。キーが video processor の属性で*ない*キー/値ペアの挙動は、`return_unused_kwargs` キーワード引数によって制御されます。

**戻り値:**

型が`~video_processing_utils.ImagVideoProcessorBase`のビデオプロセッサ。

`~video_processing_utils.VideoProcessorBase` の型を、video processor からインスタンス化します。

例:

```python
# We can't instantiate directly the base class *VideoProcessorBase* so let's show the examples on a
# derived class: *LlavaOnevisionVideoProcessor*
video_processor = LlavaOnevisionVideoProcessor.from_pretrained(
    "llava-hf/llava-onevision-qwen2-0.5b-ov-hf"
)  # Download video_processing_config from huggingface.co and cache.
video_processor = LlavaOnevisionVideoProcessor.from_pretrained(
    "./test/saved_model/"
)  # E.g. video processor (or model) was saved using *save_pretrained('./test/saved_model/')*
video_processor = LlavaOnevisionVideoProcessor.from_pretrained("./test/saved_model/video_preprocessor_config.json")
video_processor = LlavaOnevisionVideoProcessor.from_pretrained(
    "llava-hf/llava-onevision-qwen2-0.5b-ov-hf", do_normalize=False, foo=False
)
assert video_processor.do_normalize is False
video_processor, unused_kwargs = LlavaOnevisionVideoProcessor.from_pretrained(
    "llava-hf/llava-onevision-qwen2-0.5b-ov-hf", do_normalize=False, foo=False, return_unused_kwargs=True
)
assert video_processor.do_normalize is False
assert unused_kwargs == {"foo": False}
```

#### get_video_processor_dict[[transformers.VideoProcessorMixin.get_video_processor_dict]]

```python
get_video_processor_dict(pretrained_model_name_or_path: str | os.PathLike, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/video_processing_utils.py#L296)

**パラメータ:**

pretrained_model_name_or_path (`str` または `os.PathLike`) : パラメータの辞書を取得したい事前学習済みチェックポイントの識別子。

subfolder (`str`、*任意*、デフォルトは`""`) : 関連するファイルが huggingface.co 上のモデルリポジトリ内のサブフォルダに配置されている場合、ここにフォルダ名を指定できます。

**戻り値:** `tuple[Dict, Dict]`

動画プロセッサオブジェクトをインスタンス化するために使用される辞書です。

`pretrained_model_name_or_path` から、`from_dict` を使用して `~video_processing_utils.VideoProcessorBase` 型のビデオプロセッサをインスタンス化するために使用されるパラメータの辞書に解決します。

#### preprocess[[transformers.VideoProcessorMixin.preprocess]]

```python
preprocess(videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]]], **kwargs: *<class 'transformers.processing_utils.VideosKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/video_processing_utils.py#L98)

**パラメータ:**

videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`) : 前処理対象の動画。ピクセル値が 0 から 255 の範囲にある、単一の動画またはバッチの動画を想定しています。ピクセル値が 0 から 1 の範囲にある動画を渡す場合は、`do_rescale=False` を設定してください。

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 が int の場合、リサイズ時に正方形の画像をデフォルトとするかどうか。

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : 画像をリサイズする場合に使用するリサンプリングフィルタ。`PILImageResampling` の列挙型のいずれかです。`do_resize` が `True` に設定されている場合のみ有効です。

do_rescale (`bool`, *kwargs*, *任意*) : 画像をリスケールするかどうか。

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_center_crop (`bool`, *kwargs*, *optional*) : 画像を中央クロップするかどうか。

do_pad (`bool`, *kwargs*, *任意*) : 画像にパディングを適用するかどうか。パディングは、バッチ内の最大サイズに合わせるか、画像ごとに固定の正方形サイズに合わせるかのいずれかで行われます。正確なパディング戦略はモデルによって異なります。

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop` を適用した後の出力画像のサイズ。

data_format (`Union[str, ~image_utils.ChannelDimension]`、*kwargs*、*optional*) : 対応するのは `ChannelDimension.FIRST` のみです。slow processors との互換性のために追加されました。

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*, *optional*) : 処理前に動画からフレームをサンプリングするか、動画全体を処理するかを指定します。

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` の場合、1 秒あたりにサンプリングするターゲットフレーム数。

num_frames (`Annotated[int | None, None]`, *kwargs*) : `do_sample_frames=True` の場合、サンプリングするフレームの最大数。

return_metadata (`bool`, *kwargs*, *任意*) : ビデオメタデータを返すかどうかを指定します。ビデオメタデータは、ビデオの再生時間、fps、デコードバックエンドなどの情報を含むオブジェクトです。

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'`に設定されている場合はスタックされたテンソルを返し、それ以外の場合はテンソルのリストを返します。

**戻り値:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- __call__ メソッドによって返されるリスト/配列/テンソルの辞書（'pixel_values' など）。
- **tensor_type** (`Union[None, str, TensorType]`、*省略可*) -- 初期化時に PyTorch/Numpy の Tensor 内の整数リストを変換するために、ここで tensor_type を指定できます。

#### register_for_auto_class[[transformers.VideoProcessorMixin.register_for_auto_class]]

```python
register_for_auto_class(auto_class = 'AutoVideoProcessor')
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/video_processing_utils.py#L533)

**パラメータ:**

auto_class (`str` または `type`、*任意*、デフォルトは `"AutoVideoProcessor "`) : この新しい video processor を登録するための auto クラス。

このクラスを指定された auto クラスに登録します。ライブラリ内のものはすでに`AutoVideoProcessor `にマッピングされているため、このメソッドはカスタムな video processor の場合にのみ使用してください。

このAPIは実験的なものであり、次のリリースでわずかな破壊的変更が発生する可能性があります。

#### save_pretrained[[transformers.VideoProcessorMixin.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike, push_to_hub: bool = False, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/video_processing_utils.py#L248)

**パラメータ:**

save_directory (`str` または `os.PathLike`) : 動画プロセッサの JSON ファイルを保存するディレクトリ（存在しない場合は作成されます）。

push_to_hub (`bool`、*任意*、デフォルトは`False`) : モデルを保存した後、Hugging Face モデルハブにプッシュするかどうかを指定します。プッシュ先のリポジトリは`repo_id`で指定できます（指定しない場合、`save_directory`の名前があなたのネームスペース内でデフォルトとして使用されます）。

kwargs (`dict[str, Any]`、*省略可*) : [push_to_hub()](/docs/transformers/main/ja/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub) メソッドに渡される追加のキーワード引数。

`save_directory` にビデオプロセッサオブジェクトを保存し、`~video_processing_utils.VideoProcessorBase.from_pretrained` クラスメソッドによって再読み込みできるようにします。

#### to_dict[[transformers.VideoProcessorMixin.to_dict]]

```python
to_dict()
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/video_processing_utils.py#L472)

**戻り値:** `dict[str, Any]`

この video processor インスタンスを構成するすべての属性の辞書。

このインスタンスをPythonの辞書にシリアライズします。

## BaseVideoProcessor[[transformers.BaseVideoProcessor]]

#### transformers.BaseVideoProcessor[[transformers.BaseVideoProcessor]]

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

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/video_processing_utils.py#L587)

#### convert_to_rgb[[transformers.BaseVideoProcessor.convert_to_rgb]]

```python
convert_to_rgb(video: torch.Tensor)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/video_processing_utils.py#L588)

**パラメータ:**

video (`"torch.Tensor"`) : 変換対象の動画。

**戻り値:** `torch.Tensor`

変換された動画。

動画をRGB形式に変換します。

#### sample_frames[[transformers.BaseVideoProcessor.sample_frames]]

```python
sample_frames(metadata: VideoMetadata, num_frames: int | None = None, fps: int | float | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/video_processing_utils.py#L605)

**パラメータ:**

metadata (`VideoMetadata`) : 動画のメタデータ。総再生時間、fps、総フレーム数に関する情報を含みます。

num_frames (`int`, *任意*) : サンプルするフレームの最大数。デフォルトは `self.num_frames` です。

fps (`int` または `float`、*任意*) : 1 秒あたりにサンプリングするターゲットフレーム数。デフォルトは `self.fps` です。

**戻り値:** `np.ndarray`

動画フレームをサンプリングするためのインデックス。

0から総フレーム数までの範囲で、指定されたフレーム数を均等にサンプリングするデフォルトのサンプリング関数です。`fps`がメタデータとともに渡された場合、`fps`フレーム/秒で均等にサンプリングされます。引数`num_frames`と`fps`は排他的です。