# Pop2Piano

## 概要

Pop2Pianoモデルは、Jongho Choi氏とKyogu Lee氏による[Pop2Piano : Pop Audio-based Piano Cover Generation](https://huggingface.co/papers/2211.00895)で提案されました。

ポップミュージックのピアノカヴァーは広く楽しまれていますが、音楽からそれらを生成することは容易ではありません。ピアノ演奏の高い専門知識と、楽曲の異なる特徴やメロディの理解が求められます。Pop2Pianoを使用すると、楽曲のオーディオ波形から直接カヴァーを生成できます。これは、メロディやコードの抽出モジュールなしに、ポップミュージックのオーディオから直接ピアノカヴァーを生成する初のモデルです。

Pop2Piano は [T5](https://huggingface.co/papers/1910.10683) に基づくエンコーダー・デコーダー型 Transformer モデルです。入力オーディオは波形に変換されエンコーダーに渡され、エンコーダーはそれを潜在表現に変換します。デコーダーはこれらの潜在表現を用いて、自己回帰的にトークン ID を生成します。各トークン ID は、time、velocity、note、'special' の 4 つの異なるトークン型のいずれかに対応します。その後、トークン ID は等価な MIDI ファイルにデコードされます。

論文の抄録は以下の通りです。

*ポップミュージックのピアノカヴァーは多くの人々に楽しまれています。しかし、ポップミュージックのピアノカヴァーを自動生成するタスクについては、まだ研究が十分に行われていません。これは部分的に、同期された {Pop, Piano Cover} データペアの不足が原因であり、データ集約型の最新の深層学習ベースの手法を適用することが困難でした。データ駆動型アプローチの力を活用するために、自動パイプラインを使用して、大量のペアリングされ同期された {Pop, Piano Cover} データを作成しました。本論文では、ポップミュージックの波形からピアノカヴァーを生成する Transformer ネットワークである Pop2Piano を提案します。我々の知る限り、これはメロディとコードの抽出モジュールを使用せずに、ポップオーディオから直接ピアノカヴァーを生成する最初のモデルです。我々のデータセットで訓練された Pop2Piano が、妥当なピアノカヴァーを生成できることを示します。*

このモデルは [Susnato Dhar](https://huggingface.co/susnato) によって提供されました。元のコードは [こちら](https://github.com/sweetcocoa/pop2piano) で確認できます。

## 使用のコツ

* Pop2Pianoを使用するには、🤗 Transformersライブラリと、以下のサードパーティ製モジュールをインストールする必要があります。

```bash
pip install pretty-midi==0.2.9 essentia==2.1b6.dev1034 librosa scipy
```

インストール後、ランタイムの再起動が必要な場合があります。

* Pop2Pianoは、T5と同様にEncoder-Decoderベースのモデルです。
* Pop2Pianoは、与えられたオーディオシーケンスに対してmidiオーディオファイルを生成するために使用できます。
* `Pop2PianoForConditionalGeneration.generate()` で異なる作曲家を選択すると、多様な結果が得られます。
* オーディオファイルを読み込む際にサンプリングレートを44.1 kHzに設定すると、良好なパフォーマンスが得られます。
* Pop2Pianoは主に韓国ポップミュージックで訓練されましたが、他の西洋ポップやヒップホップの曲でもかなり良いパフォーマンスを発揮します。

## 例

- HuggingFace Dataset を使用した例:

```python
from datasets import load_dataset

from transformers import Pop2PianoForConditionalGeneration, Pop2PianoProcessor

model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano", device_map="auto")
processor = Pop2PianoProcessor.from_pretrained("sweetcocoa/pop2piano")
ds = load_dataset("sweetcocoa/pop2piano_ci", split="test")

inputs = processor(
    audio=ds["audio"][0]["array"], sampling_rate=ds["audio"][0]["sampling_rate"], return_tensors="pt"
)
model_output = model.generate(input_features=inputs["input_features"], composer="composer1")
tokenizer_output = processor.batch_decode(
    token_ids=model_output, feature_extractor_output=inputs
)["pretty_midi_objects"][0]
tokenizer_output.write("./Outputs/midi_output.mid")
```

- 独自のオーディオファイルを使用する例:

```python
import librosa

from transformers import Pop2PianoForConditionalGeneration, Pop2PianoProcessor

audio, sr = librosa.load("<your_audio_file_here>", sr=44100)  # feel free to change the sr to a suitable value.
model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano", device_map="auto")
processor = Pop2PianoProcessor.from_pretrained("sweetcocoa/pop2piano")

inputs = processor(audio=audio, sampling_rate=sr, return_tensors="pt").to(model.device)
model_output = model.generate(input_features=inputs["input_features"], composer="composer1")
tokenizer_output = processor.batch_decode(
    token_ids=model_output, feature_extractor_output=inputs
)["pretty_midi_objects"][0]
tokenizer_output.write("./Outputs/midi_output.mid")
```

- バッチで複数のオーディオファイルを処理する例:

```python
import librosa

from transformers import Pop2PianoForConditionalGeneration, Pop2PianoProcessor

# feel free to change the sr to a suitable value.
audio1, sr1 = librosa.load("<your_first_audio_file_here>", sr=44100)
audio2, sr2 = librosa.load("<your_second_audio_file_here>", sr=44100)
model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano", device_map="auto")
processor = Pop2PianoProcessor.from_pretrained("sweetcocoa/pop2piano")

inputs = processor(audio=[audio1, audio2], sampling_rate=[sr1, sr2], return_attention_mask=True, return_tensors="pt").to(model.device)
# Since we now generating in batch(2 audios) we must pass the attention_mask
model_output = model.generate(
    input_features=inputs["input_features"],
    attention_mask=inputs["attention_mask"],
    composer="composer1",
)
tokenizer_output = processor.batch_decode(
    token_ids=model_output, feature_extractor_output=inputs
)["pretty_midi_objects"]

# Since we now have 2 generated MIDI files
tokenizer_output[0].write("./Outputs/midi_output1.mid")
tokenizer_output[1].write("./Outputs/midi_output2.mid")
```

- `Pop2PianoFeatureExtractor`と`Pop2PianoTokenizer`を使用して、複数のオーディオファイルをバッチで処理する例:

```python
import librosa

from transformers import Pop2PianoFeatureExtractor, Pop2PianoForConditionalGeneration, Pop2PianoTokenizer

# feel free to change the sr to a suitable value.
audio1, sr1 = librosa.load("<your_first_audio_file_here>", sr=44100)
audio2, sr2 = librosa.load("<your_second_audio_file_here>", sr=44100)
model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano", device_map="auto")
feature_extractor = Pop2PianoFeatureExtractor.from_pretrained("sweetcocoa/pop2piano")
tokenizer = Pop2PianoTokenizer.from_pretrained("sweetcocoa/pop2piano")

inputs = feature_extractor(
    audio=[audio1, audio2],
    sampling_rate=[sr1, sr2],
    return_attention_mask=True,
    return_tensors="pt",
)
# Since we now generating in batch(2 audios) we must pass the attention_mask
model_output = model.generate(
    input_features=inputs["input_features"],
    attention_mask=inputs["attention_mask"],
    composer="composer1",
)
tokenizer_output = tokenizer.batch_decode(
    token_ids=model_output, feature_extractor_output=inputs
)["pretty_midi_objects"]

# Since we now have 2 generated MIDI files
tokenizer_output[0].write("./Outputs/midi_output1.mid")
tokenizer_output[1].write("./Outputs/midi_output2.mid")
```

## Pop2PianoConfig[[transformers.Pop2PianoConfig]]

#### transformers.Pop2PianoConfig[[transformers.Pop2PianoConfig]]

```python
transformers.Pop2PianoConfig(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, 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, is_encoder_decoder: bool = True, vocab_size: int = 2400, composer_vocab_size: int = 21, d_model: int = 512, d_kv: int = 64, d_ff: int = 2048, num_layers: int = 6, num_decoder_layers: int | None = None, num_heads: int = 8, relative_attention_num_buckets: int = 32, relative_attention_max_distance: int = 128, dropout_rate: float | int = 0.1, layer_norm_epsilon: float = 1e-06, initializer_factor: float = 1.0, feed_forward_proj: str = 'gated-gelu', use_cache: bool = True, pad_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, dense_act_fn: str = 'relu', is_decoder: bool = False, tie_word_embeddings: bool = True)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/configuration_pop2piano.py#L24)

**パラメータ:**

is_encoder_decoder (`bool`、*任意*、デフォルトは`True`) : モデルがエンコーダー/デコーダーとして使用されるかどうかを示します。

vocab_size (`int`、*任意*、デフォルトは`2400`) : モデルの語彙サイズ。`input_ids`で表現できるトークンの種類数を定義します。

composer_vocab_size (`int`, *optional*, デフォルトは 21) : コンポーザーの数を示します。

d_model (`int`、*任意*、デフォルトは`512`) : エンコーダ層とプーラー層のサイズ。

d_kv (`int`、*任意*、デフォルトは`64`) : アテンションヘッドごとのキー、クエリ、バリューの射影サイズ。射影層の`inner_dim`は`num_heads * d_kv`として定義されます。

d_ff (`int`、*任意*、デフォルトは`2048`) : MLP 表現の次元数。

num_layers (`int`、*任意*、デフォルトは`6`) : Transformer デコーダーの隠れ層の数。

num_decoder_layers (`int`, *optional*) : Transformerデコーダーの隠れ層の数。設定されていない場合は、`num_layers`と同じ値が使用されます。

num_heads (`int`、*任意*、デフォルトは `8`) : Transformer デコーダーの各アテンション層におけるアテンションヘッドの数。

relative_attention_num_buckets (`int`、*optional*、デフォルトは 32) : 各アテンション層で使用するバケット数。

relative_attention_max_distance (`int`、*optional*、デフォルトは 128) : バケット分離における、長いシーケンスの最大距離。

dropout_rate (`Union[float, int]`、*任意*、デフォルトは`0.1`) : すべての dropout 層の比率。

layer_norm_epsilon (`float`、*任意*、デフォルトは`1e-06`) : Layer Normalization 層で使用する epsilon です。

initializer_factor (`float`、*任意*、デフォルトは`1.0`) : すべての重み行列を初期化する係数です（1に保つ必要があります。初期化テスト用に内部で使用されます）。

feed_forward_proj (`string`、*任意*、デフォルトは`"gated-gelu"`) : 使用するフィードフォワード層の種類。`"relu"`または`"gated-gelu"`のいずれかである必要があります。

use_cache (`bool`、*任意*、デフォルトは `True`) : モデルが最後のキー/バリューアテンションを返すかどうか（すべてのモデルで利用されるわけではありません）。`config.is_decoder=True` の場合、またはモデルがデコーダー専用の生成モデルである場合にのみ関連します。

pad_token_id (`int`, *任意*, デフォルトは `0`) : 語彙内でパディングに使用されるトークン ID。

eos_token_id (`Union[int, list[int]]`、*任意*、デフォルトは `1`) : 語彙内でストリーム終了に使用されるトークン ID。

dense_act_fn (`string`、*任意*、デフォルトは`"relu"`) : `Pop2PianoDenseActDense`および`Pop2PianoDenseGatedActDense`で使用する活性化関数の種類。

is_decoder (`bool`, *任意*, デフォルトは `False`) : モデルがデコーダーとして使用されるかどうかを指定します。`False` の場合、モデルはエンコーダーとして使用されます。

tie_word_embeddings (`bool`、*任意*、デフォルトは`True`) : モデルの`tied_weights_keys`マッピングに従って重み埋め込みを共有するかどうか。

これはPop2PianoModelの設定を保存するための設定クラスです。指定された引数に基づいてPop2Pianoモデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[sweetcocoa/pop2piano](https://huggingface.co/sweetcocoa/pop2piano)と類似した設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

## Pop2PianoFeatureExtractor[[transformers.Pop2PianoFeatureExtractor]]

#### transformers.Pop2PianoFeatureExtractor[[transformers.Pop2PianoFeatureExtractor]]

```python
transformers.Pop2PianoFeatureExtractor(sampling_rate: int = 22050, padding_value: int = 0, window_size: int = 4096, hop_length: int = 1024, min_frequency: float = 10.0, feature_size: int = 512, num_bars: int = 2, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/feature_extraction_pop2piano.py#L49)

**パラメータ:**

sampling_rate (`int`、*optional*、デフォルトは 22050) : 音声シグナルのターゲットサンプリングレートです。モデルに渡すサンプリングレートです。

padding_value (`int`、*optional*、デフォルトは 0) : 音声のパディングに使用される値です。無音に対応する値である必要があります。

window_size (`int`, *optional*, デフォルトは 4096) : フーリエ変換を適用するウィンドウのサンプル数。

hop_length (`int`, *optional*, デフォルトは 1024) : ウェーブフォームの各ウィンドウ間のステップサイズ（サンプル数）。

min_frequency (`float`、*optional*、デフォルト値は 10.0) : log-mel スペクトラムで使用する最低周波数。

feature_size (`int`、*optional*、デフォルトは 512) : 抽出された特徴量の次元数。

num_bars (`int`、*optional*、デフォルトは 2) : 各シーケンス間の間隔を決定します。

Pop2Pianoのフィーチャーエクストラクターを構築します。

このフィーチャーエクストラクターは、主要なメソッドの大部分を含む [SequenceFeatureExtractor](/docs/transformers/main/ja/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) を継承しています。これらのメソッドに関する詳細については、このスーパークラスを参照してください。

このクラスはリズムを抽出し、モデルに渡す前にオーディオを前処理します。まず、オーディオは`RhythmExtractor2013`アルゴリズムに渡され、beat_times、ビート位置、それらの信頼度、およびbpm単位のテンポが推定されます。次に、beat_timesを補間してbeatstepsを取得します。その後、tokenizerで使用するためにextrapolated_beatstepsを計算します。一方、オーディオはself.sampling_rateにリサンプリングされ、前処理が行われた後、transformerモデルで使用するためにlog mel spectrogramが計算されます。

#### __call__[[transformers.Pop2PianoFeatureExtractor.__call__]]

```python
__call__(audio: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], sampling_rate: int | list[int], steps_per_beat: int = 2, resample: bool | None = True, return_attention_mask: bool | None = False, return_tensors: str | transformers.utils.generic.TensorType | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/feature_extraction_pop2piano.py#L341)

**パラメータ:**

audio (`np.ndarray`, `List`) : 処理対象のオーディオまたはオーディオのバッチです。各オーディオは、numpy配列、浮動小数点数のリスト、numpy配列のリスト、または浮動小数点数のリストのリストであることができます。

sampling_rate (`int`) : `audio`入力がサンプリングされた際のサンプリングレートです。サイレントエラーを防ぐため、フォワード呼び出し時に`sampling_rate`を渡すことを強く推奨します。

steps_per_beat (`int`、*optional*、デフォルトは 2) : `beat_times`の補間処理で使用されます。

resample (`bool`、*任意*、デフォルトは`True`) : 処理の前にオーディオを`sampling_rate`にリサンプリングするかどうかを決定します。推論時にはTrueである必要があります。

return_attention_mask (`bool` *optional*、デフォルトは`False`) : input_features、beatsteps、extrapolated_beatstepのattention_maskを出力として返すかどうかを示します。バッチ入力の場合、自動的にTrueに設定されます。

return_tensors (`str` または [TensorType](/docs/transformers/main/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定されている場合、Python の整数のリストではなくテンソルを返します。許可される値は以下の通りです: - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。 - `'np'`: Numpy の `np.ndarray` オブジェクトを返します。何も指定しない場合、`np.ndarray` 配列のリストを返します。

モデル用に特徴量を作成し、準備するための主要なメソッド。

## Pop2PianoForConditionalGeneration[[transformers.Pop2PianoForConditionalGeneration]]

#### transformers.Pop2PianoForConditionalGeneration[[transformers.Pop2PianoForConditionalGeneration]]

```python
transformers.Pop2PianoForConditionalGeneration(config: Pop2PianoConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/modeling_pop2piano.py#L763)

**パラメータ:**

config ([Pop2PianoConfig](/docs/transformers/main/ja/model_doc/pop2piano#transformers.Pop2PianoConfig)) : モデルのすべてのパラメータを含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

`language modeling`ヘッドを上部に備えたPop2Pianoモデル。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

#### forward[[transformers.Pop2PianoForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, input_features: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/modeling_pop2piano.py#L851)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`) : 語彙における入力シーケンスのトークンインデックスです。Pop2Piano は相対位置埋め込みを持つモデルであるため、入力の右側と左側の両方にパディングを適用できます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。[入力 ID とは何か？](../glossary#input-ids) 事前学習のために `input_ids` を準備する方法については、[Pop2Piano Training](./Pop2Piano#training) をご覧ください。

attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor`、形状 `(batch_size, target_sequence_length)`、*任意*) : 語彙におけるデコーダー入力シーケンスのトークンインデックスです。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。[デコーダー入力IDとは何ですか？](../glossary#decoder-input-ids) Pop2Piano は、`decoder_input_ids` の生成の開始トークンとして `pad_token_id` を使用します。`past_key_values` を使用する場合、オプションとして最後の `decoder_input_ids` だけを入力すれば十分です（`past_key_values` を参照）。準備方法の詳細については

decoder_attention_mask (`torch.BoolTensor`、shape `(batch_size, target_sequence_length)`、*任意*) : デフォルトの動作: `decoder_input_ids`内のpadトークンを無視するテンソルを生成します。デフォルトでは、causal maskも使用されます。

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *任意*) : (`last_hidden_state`, *任意*: `hidden_states`, *任意*: `attentions`) のタプルです。`last_hidden_state` は形状 `(batch_size, sequence_length, hidden_size)` を持ち、*任意* です。エンコーダーの最終層の出力における隠れ状態のシーケンスです。デコーダーのクロスアテンションで使用されます。

past_key_values (`~cache_utils.Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

inputs_embeds (`torch.Tensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

input_features (`torch.Tensor`、形状 `(batch_size, sequence_length, feature_dim)`、*任意*) : 入力音声特徴に対応するテンソルです。音声特徴は [Pop2PianoFeatureExtractor](/docs/transformers/main/ja/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor) を使用して取得できます。詳細は [Pop2PianoFeatureExtractor.__call__()](/docs/transformers/main/ja/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor.__call__) を参照してください（[Pop2PianoProcessor](/docs/transformers/main/ja/model_doc/pop2piano#transformers.Pop2PianoProcessor) は音声の処理に [Pop2PianoFeatureExtractor](/docs/transformers/main/ja/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor) を使用します）。

decoder_inputs_embeds (`torch.Tensor`、shape `(batch_size, target_sequence_length, hidden_size)`、*任意*) : `decoder_input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。`past_key_values` を使用する場合、`decoder_inputs_embeds` の最後の部分のみを入力すればよい場合があります（`past_key_values` を参照）。`decoder_input_ids` のインデックスを関連するベクトルに変換する方法を、モデル内部の埋め込みルックアップ行列よりも細かく制御したい場合に便利です。 `decoder_input_ids` と `decoder_inputs_embeds` の両方が設定されていない場合、`decoder_inputs_embeds` は `inputs_embeds` の値を採ります。

labels (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : シーケンス分類/回帰の損失を計算するためのラベル。インデックスは `[-100, 0, ..., config.vocab_size - 1]` の範囲である必要があります。ラベルが `-100` に設定されているものは無視（マスク）され、損失は `[0, ..., config.vocab_size]` の範囲のラベルに対してのみ計算されます。

use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。

**戻り値:** [Seq2SeqLMOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) または `tuple(torch.Tensor)`

設定（[Pop2PianoConfig](/docs/transformers/main/ja/model_doc/pop2piano#transformers.Pop2PianoConfig)）と入力に応じて、さまざまな要素で構成される、[Seq2PianoLMOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) または `torch.Tensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。

[Pop2PianoForConditionalGeneration](/docs/transformers/main/ja/model_doc/pop2piano#transformers.Pop2PianoForConditionalGeneration)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **loss** (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が指定された場合に返されます) -- 言語モデリングの損失。
- **logits** (`torch.Tensor`、形状 `(batch_size, sequence_length, config.vocab_size)`) -- 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。
- **past_key_values** (`EncoderDecoderCache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [EncoderDecoderCache](/docs/transformers/main/ja/internal/generation_utils#transformers.EncoderDecoderCache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。

  逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算済みの隠れ状態（自己アテンションブロックおよびクロスアテンションブロックのキーとバリュー）が含まれます。
- **decoder_hidden_states** (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用 1 つ + 各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力および初期埋め込み出力における、デコーダーの隠れ状態。
- **decoder_attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  自己アテンションヘッドにおける加重平均を計算するために使用される、アテンションのsoftmax後のデコーダーのアテンション重み。
- **cross_attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  クロスアテンション層のアテンション重みは、アテンションのsoftmax適用後に計算され、クロスアテンションヘッドにおける加重平均の計算に使用されます。
- **encoder_last_hidden_state** (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) -- モデルのエンコーダーの最終層の出力における隠れ状態のシーケンス。
- **encoder_hidden_states** (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用 1 つ + 各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力および初期埋め込み出力におけるエンコーダーの隠れ状態。
- **encoder_attentions** (`tuple(torch.Tensor)`、*任意*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- 各レイヤーごとに 1 つの `torch.Tensor` からなるタプルで、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。

  アテンションのsoftmaxを適用した後のエンコーダーのアテンション重み。自己アテンションヘッドにおける加重平均の計算に使用されます。

例:

```python
>>> from transformers import AutoProcessor, Pop2PianoForConditionalGeneration
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = AutoProcessor.from_pretrained("sweetcocoa/pop2piano")
>>> model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
...

>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids

>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
...
```

#### generate[[transformers.Pop2PianoForConditionalGeneration.generate]]

```python
generate(input_features, attention_mask = None, composer = 'composer1', generation_config = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/modeling_pop2piano.py#L953)

**パラメータ:**

input_features (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) : これは、`Pop2PianoFeatureExtractor` によって生成されたオーディオの特徴量化されたバージョンです。

attention_mask : バッチ生成の場合、`input_features` はすべての例で同じ形状になるようにパディングされます。`attention_mask` は、どの領域がパディングされ、どの領域がパディングされていないかを判断するのに役立ちます。- **パディングされていない**トークンは 1、- **パディングされた**トークンは 0。

composer (`str`、*任意*、デフォルトは`"composer1"`) : この値は`Pop2PianoConcatEmbeddingToMel`に渡され、各`"composer"`に対して異なる埋め込みを生成するために使用されます。`generation_config`内の`composer_to_feature_token`にcomposerの値が含まれていることを確認してください。例については、https://huggingface.co/sweetcocoa/pop2piano/blob/main/generation_config.json を参照してください。

generation_config (`~generation.GenerationConfig`, *任意*) : 生成呼び出しのベースパラメータ化として使用される生成設定です。 `**kwargs` で `generation_config` の属性に一致するものが generate に渡された場合、それらが上書きされます。 `generation_config` が指定されない場合、デフォルトが使用されます。その読み込み優先順位は以下の通りです: 1) `generation_config.json` モデルファイルが存在する場合、そこから読み込む; 2) モデル設定から読み込む。 未指定のパラメータは [GenerationConfig](/docs/transformers/main/ja/main_classes/text_generation#transformers.GenerationConfig) のデフォルト値を継承することに注意してください。生成をパラメータ化するには、そのドキュメントを確認してください。

kwargs : `generate_config` のアドホックなパラメータ化、および/またはモデルの `forward` 関数に転送される追加のモデル固有の kwargs。モデルがエンコーダー・デコーダーモデルの場合、エンコーダー固有の kwargs はプレフィックスを付与せず、デコーダー固有の kwargs には *decoder_* をプレフィックスとして付与する必要があります。

**戻り値:** [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) または `torch.LongTensor`

`return_dict_in_generate=True` の場合、または `config.return_dict_in_generate=True` の場合は [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput)、それ以外は `torch.Tensor` です。Pop2Piano はエンコーダー・デコーダーモデル（`model.config.is_encoder_decoder=True`）であるため、考えられる [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) の型は以下の通りです。
- [GenerateEncoderDecoderOutput](/docs/transformers/main/ja/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput)、
- [GenerateBeamEncoderDecoderOutput](/docs/transformers/main/ja/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput)

MIDI出力用のトークンIDを生成します。

生成を制御するほとんどのパラメータは`generation_config`で設定されます。この引数が渡されない場合、モデルのデフォルトの生成設定が使用されます。`generation_config`の任意の値は、generate()に該当するパラメータを渡すことで上書きできます。例えば、`.generate(inputs, num_beams=4, do_sample=True)`のように指定します。生成戦略の概要とコード例については、[こちらのガイド](./generation_strategies)を参照してください。

## Pop2PianoTokenizer[[transformers.Pop2PianoTokenizer]]

#### transformers.Pop2PianoTokenizer[[transformers.Pop2PianoTokenizer]]

```python
transformers.Pop2PianoTokenizer(vocab, default_velocity = 77, num_bars = 2, unk_token = '-1', eos_token = '1', pad_token = '0', bos_token = '2', **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/tokenization_pop2piano.py#L62)

**パラメータ:**

vocab (`str`) : 語彙を含む語彙ファイルへのパス。

default_velocity (`int`, *任意*, デフォルト値は 77) : midi Note を作成する際に使用されるデフォルトの velocity を決定します。

num_bars (`int`、*optional*、デフォルトは 2) : 各トークンにおける cutoff_time_idx を決定します。

unk_token (`str` または `tokenizers.AddedToken`、*任意*、デフォルトは `"-1"`) : 不明なトークンです。語彙に存在しないトークンは ID に変換できず、代わりにこのトークンが設定されます。

eos_token (`str` または `tokenizers.AddedToken`、*任意*、デフォルトは 1) : シーケンスの終了トークン。

pad_token (`str` または `tokenizers.AddedToken`、*optional*、デフォルトは 0) : バッチ処理のためにトークンの配列を同じサイズにするために使用される特殊トークン。その後、アテンション機構や損失計算によって無視されます。

bos_token (`str` または `tokenizers.AddedToken`、*optional*、デフォルトは 2) : 事前学習で使用されたシーケンスの開始トークン。シーケンス分類器のトークンとして使用できます。

Pop2Pianoのトークナイザーを構築します。このトークナイザーは学習を必要としません。

このトークナイザーは、[PreTrainedTokenizer](/docs/transformers/main/ja/main_classes/tokenizer#transformers.PythonBackend) を継承しており、主要なメソッドのほとんどが含まれています。これらのメソッドに関する詳細については、このスーパークラスを参照してください。

#### __call__[[transformers.Pop2PianoTokenizer.__call__]]

```python
__call__(notes: numpy.ndarray | list[pretty_midi.Note] | list[list[pretty_midi.Note]], padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, pad_to_multiple_of: int | None = None, return_attention_mask: bool | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, verbose: bool = True, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/tokenization_pop2piano.py#L473)

**パラメータ:**

notes (`numpy.ndarray` の形状が `[batch_size, max_sequence_length, 4]` または `pretty_midi.Note` オブジェクトの `list`) : MIDIノートを表します。 `notes` が `numpy.ndarray` の場合: - 各シーケンスには4つの値が必要です。それらは `onset idx`、`offset idx`、`pitch`、`velocity` です。 `notes` が `pretty_midi.Note` オブジェクトを含む `list` の場合: - 各シーケンスには4つの属性が必要です。それらは `start`、`end`、`pitch`、`velocity` です。

padding (`bool`、`str`または[PaddingStrategy](/docs/transformers/main/ja/internal/file_utils#transformers.utils.PaddingStrategy)、*optional*、デフォルトは`False`) : パディングの有効化と制御を行います。以下の値を受け取ります: - `True`または`'longest'`: バッチ内の最長のシーケンスの長さにパディングします（単一のシーケンスのみが提供された場合は、パディングを行いません）。 - `'max_length'`: 引数`max_length`で指定された最大長、またはその引数が提供されていない場合はモデルが受け入れ可能な最大入力長までパディングします。 - `False`または`'do_not_pad'`（デフォルト）: パディングを行いません（つまり、長さが異なるシーケンスのバッチを出力できます）。

truncation (`bool`、`str` または [TruncationStrategy](/docs/transformers/main/ja/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy)、*optional*、デフォルトは `False`) : トランケーションを有効化し、制御します。以下の値を受け取ります: - `True` または `'longest_first'`: 引数 `max_length` で指定された最大長、またはその引数が指定されていない場合はモデルが許容する最大入力長まで切り詰めます。ペアのシーケンス（またはペアのバッチ）が提供されている場合、ペアの中で最も長いシーケンスからトークン単位で1トークンずつ削除します。 - `'only_first'`: 引数 `max_length` で指定された最大長、またはその引数が指定されていない場合はモデルが許容する最大入力長まで切り詰めます。ペアのシーケンス（またはペアのバッチ）が提供されている場合、ペアの最初のシーケンスのみを切り詰めます。 - `'only_second'`: 引数 `max_length` で指定された最大長、またはその引数が指定されていない場合はモデルが許容する最大入力長まで切り詰めます。ペアのシーケンス（またはペアのバッチ）が提供されている場合、ペアの2番目のシーケンスのみを切り詰めます。 - `False` または `'do_not_truncate'`（デフォルト）: トランケーションを行いません（つまり、モデルが許容する最大入力サイズを超えるシーケンス長を持つバッチを出力する可能性があります）。

max_length (`int`, *optional*) : 切り詰め/パディングパラメータのいずれかによって使用される最大長を制御します。未設定のまま、または `None` に設定されている場合、切り詰め/パディングパラメータのいずれかが最大長を必要とする場合、事前に定義されたモデルの最大長が使用されます。モデルに特定の最大入力長がない場合（XLNet など）、最大長への切り詰め/パディングは無効になります。

pad_to_multiple_of (`int`, *optional*) : 設定すると、シーケンスを指定された値の倍数にパディングします。これは、計算能力が `>= 7.5` (Volta) の NVIDIA ハードウェア上で Tensor Cores を使用可能にするために特に有用です。

return_attention_mask (`bool`、*省略可*) : アテンションマスクを返すかどうか。デフォルトのままにすると、`return_outputs` 属性で定義される特定のトークナイザーのデフォルトに従って、アテンションマスクを返します。  [アテンションマスクとは?](../glossary#attention-mask)

return_tensors (`str` または [TensorType](/docs/transformers/main/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定されている場合、Python の整数のリストではなくテンソルを返します。指定可能な値は以下の通りです。 - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。 - `'np'`: Numpy の `np.ndarray` オブジェクトを返します。

verbose (`bool`、*任意*、デフォルトは `True`) : 詳細な情報や警告を表示するかどうか。

**戻り値:**

`BatchEncoding` には token_ids が含まれます。

これは`Pop2PianoTokenizer`の`__call__`メソッドです。MIDIノートを、transformerが生成するトークンIDに変換します。

## Pop2PianoProcessor[[transformers.Pop2PianoProcessor]]

#### transformers.Pop2PianoProcessor[[transformers.Pop2PianoProcessor]]

```python
transformers.Pop2PianoProcessor(feature_extractor, tokenizer)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/processing_pop2piano.py#L29)

**パラメータ:**

feature_extractor (`Pop2PianoFeatureExtractor`) : 特徴抽出器は必須の入力です。

tokenizer (`tokenizer_class`) : トークナイザーは必須の入力です。

Pop2PianoProcessor を構築します。これは、フィーチャーエクストラクターとトークナイザーを単一のプロセッサーにラップします。

[Pop2PianoProcessor](/docs/transformers/main/ja/model_doc/pop2piano#transformers.Pop2PianoProcessor) は、[Pop2PianoFeatureExtractor](/docs/transformers/main/ja/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor) と `tokenizer_class` のすべての機能を提供します。詳細については、[~Pop2PianoFeatureExtractor](/docs/transformers/main/ja/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor) および `~tokenizer_class` を参照してください。

#### __call__[[transformers.Pop2PianoProcessor.__call__]]

```python
__call__(audio: numpy.ndarray | list[float] | list[numpy.ndarray] = None, sampling_rate: int | list[int] | None = None, steps_per_beat: int = 2, resample: bool | None = True, notes: list | transformers.utils.generic.TensorType = None, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy = None, max_length: int | None = None, pad_to_multiple_of: int | None = None, verbose: bool = True, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/processing_pop2piano.py#L33)

**パラメータ:**

audio (`Union[numpy.ndarray, list[float], list[numpy.ndarray]]`, *任意*) : 準備対象のオーディオまたはオーディオのバッチです。各オーディオはNumPy配列またはPyTorchテンソルであることができます。NumPy配列/PyTorchテンソルの場合、各オーディオの形状は(C, T)である必要があります。ここで、Cはチャネル数、Tはオーディオのサンプル長です。

sampling_rate (`int`または`list[int]`、*任意*) : 入力オーディオのサンプリングレート（Hz）。これは、特徴抽出器で使用されるサンプリングレートと一致する必要があります。指定されない場合、プロセッサの構成からデフォルトのサンプリングレートが使用されます。

steps_per_beat (`int`, *optional*, デフォルトは `2`) : 1拍あたりのタイムステップ数です。このパラメータは、音楽表現の時間分解能を制御します。値を大きくすると時間的な粒度が細かくなりますが、シーケンス長が増加します。オーディオを処理して音楽的特徴を抽出する際に使用されます。

resample (`bool`、*任意*、デフォルトは`True`) : 画像のリサイズ時に使用するリサンプリングフィルタ。`PILImageResampling` の列挙型のいずれかになります。`do_resize` が`True` に設定されている場合のみ、効果が現れます。

notes (`list` または `TensorType`、*optional*) : MIDI 形式で事前抽出された音符です。指定された場合、プロセッサは音声特徴量の抽出をスキップし、トークナイザーを通じて音符を直接処理します。各音符は、ピッチ、ベロシティ、タイミング情報を含むリストまたはテンソルとして表される必要があります。

padding (bool, str or [PaddingStrategy](/docs/transformers/main/ja/internal/file_utils#transformers.utils.PaddingStrategy), *optional*, デフォルトは `False`) : パディングの有効化と制御を行います。以下の値を受け取ります:  - `True` または `'longest'`: バッチ内の最長のシーケンスの長さにパディングします（単一のシーケンスのみが提供された場合は、パディングを行いません）。 - `'max_length'`: 引数 `max_length` で指定された最大長、またはその引数が提供されていない場合はモデルが受け入れ可能な最大入力長までパディングします。 - `False` または `'do_not_pad'`（デフォルト）: パディングを行いません（つまり、長さが異なるシーケンスを含むバッチを出力できます）。

truncation (bool, str or [TruncationStrategy](/docs/transformers/main/ja/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *optional*) : トランケーションを有効化し、制御します。以下の値を受け取ります:  - `True` または `'longest_first'`: 引数 `max_length` で指定された最大長、またはその引数が指定されていない場合はモデルが許容する最大入力長まで切り詰めます。ペアのシーケンス（またはペアのバッチ）が提供されている場合、ペアの中で最も長いシーケンスからトークン単位で1トークンずつ削除して切り詰めます。 - `'only_first'`: 引数 `max_length` で指定された最大長、またはその引数が指定されていない場合はモデルが許容する最大入力長まで切り詰めます。ペアのシーケンス（またはペアのバッチ）が提供されている場合、ペアの最初のシーケンスのみを切り詰めます。 - `'only_second'`: 引数 `max_length` で指定された最大長、またはその引数が指定されていない場合はモデルが許容する最大入力長まで切り詰めます。ペアのシーケンス（またはペアのバッチ）が提供されている場合、ペアの2番目のシーケンスのみを切り詰めます。 - `False` または `'do_not_truncate'` (デフォルト): トランケーションを行いません（つまり、モデルの最大許容入力サイズを超えるシーケンス長を持つバッチを出力する可能性があります）。

max_length (`int`, *optional*) : 切り詰め/パディングパラメータのいずれかによって使用される最大長を制御します。 未設定のまま、または `None` に設定されている場合、切り詰め/パディングパラメータのいずれかが最大長を必要とする場合、事前に定義されたモデルの最大長が使用されます。 モデルに特定の最大入力長がない場合（XLNet など）、最大長への切り詰め/パディングは無効になります。

pad_to_multiple_of (`int`, *optional*) : 設定すると、シーケンスを指定された値の倍数にパディングします。`padding` が有効化されている必要があります。これは、計算能力 `>= 7.5` (Volta) を備えた NVIDIA ハードウェア上で Tensor Cores を使用できるようにするため、特に有用です。

verbose (`bool`、*任意*、デフォルトは `True`) : 詳細な情報や警告を表示するかどうか。

return_tensors (`str` または [TensorType](/docs/transformers/main/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定されている場合、特定のフレームワークのテンソルを返します。受け入れ可能な値は以下の通りです:  - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。 - `'np'`: NumPy の `np.ndarray` オブジェクトを返します。

**戻り値:**

`Union[~feature_extraction_utils.BatchFeature, ~tokenization_utils_base.BatchEncoding]`