# Pop2Piano

## Tổng quan

Mô hình Pop2Piano được đề xuất trong [Pop2Piano : Pop Audio-based Piano Cover Generation](https://huggingface.co/papers/2211.00895) bởi Jongho Choi và Kyogu Lee.

Các bản cover piano của nhạc pop được yêu thích rộng rãi, nhưng việc tạo ra chúng từ âm nhạc không phải là một nhiệm vụ đơn giản. Điều này đòi hỏi chuyên môn cao trong việc chơi piano cũng như hiểu biết về các đặc điểm và giai điệu khác nhau của một bài hát. Với Pop2Piano, bạn có thể trực tiếp tạo ra một bản cover từ dạng sóng âm thanh của bài hát. Đây là mô hình đầu tiên trực tiếp tạo ra bản cover piano từ âm thanh pop mà không cần các module trích xuất giai điệu và hợp âm.

Pop2Piano là một mô hình Transformer encoder-decoder dựa trên [T5](https://huggingface.co/papers/1910.10683). Âm thanh đầu vào được chuyển đổi thành dạng waveform và được truyền vào encoder, nơi nó được biến đổi thành biểu diễn ẩn (latent representation). Decoder sử dụng các biểu diễn ẩn này để tạo ra các token id theo cách tự hồi quy (autoregressive). Mỗi token id tương ứng với một trong bốn loại token khác nhau: time, velocity, note và 'special'. Các token id sau đó được giải mã thành tệp MIDI tương đương.

Tóm tắt từ bài báo như sau:

*Bản cover piano của nhạc pop được nhiều người yêu thích. Tuy nhiên, bài toán tự động tạo bản cover piano cho nhạc pop vẫn chưa được nghiên cứu nhiều. Một phần nguyên nhân là do thiếu các cặp dữ liệu {Pop, Piano Cover} được đồng bộ hóa, khiến việc áp dụng các phương pháp dựa trên deep learning cần nhiều dữ liệu hiện đại trở nên khó khăn. Để tận dụng sức mạnh của tiếp cận dựa trên dữ liệu, chúng tôi tạo ra một lượng lớn dữ liệu {Pop, Piano Cover} được ghép cặp và đồng bộ hóa bằng một pipeline tự động. Trong bài báo này, chúng tôi giới thiệu Pop2Piano, một mạng Transformer tạo ra bản cover piano từ waveform của nhạc pop. Theo hiểu biết của chúng tôi, đây là mô hình đầu tiên tạo bản cover piano trực tiếp từ âm thanh pop mà không sử dụng các module trích xuất giai điệu và hợp âm. Chúng tôi cho thấy Pop2Piano, được huấn luyện với tập dữ liệu của chúng tôi, có khả năng tạo ra các bản cover piano hợp lý.*

Mô hình này được đóng góp bởi [Susnato Dhar](https://huggingface.co/susnato). Mã gốc có thể được tìm thấy [tại đây](https://github.com/sweetcocoa/pop2piano).

## Mẹo sử dụng

* Để sử dụng Pop2Piano, bạn cần cài đặt thư viện 🤗 Transformers, cũng như các module bên thứ ba sau:

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

Vui lòng lưu ý rằng bạn có thể cần khởi động lại môi trường chạy (runtime) sau khi cài đặt.

* Pop2Piano là một mô hình dựa trên Encoder-Decoder giống như T5.
* Pop2Piano có thể được sử dụng để tạo các tệp midi-audio cho một chuỗi âm thanh nhất định.
* Việc chọn các nhà soạn nhạc khác nhau trong `Pop2PianoForConditionalGeneration.generate()` có thể dẫn đến nhiều kết quả khác nhau.
* Việc đặt tần số lấy mẫu là 44,1 kHz khi tải tệp âm thanh có thể mang lại hiệu suất tốt.
* Mặc dù Pop2Piano chủ yếu được huấn luyện trên nhạc Pop Hàn Quốc, nó cũng hoạt động khá tốt trên các bài hát Pop hoặc Hip Hop phương Tây khác.

## Ví dụ

- Ví dụ sử dụng 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")
```

- Ví dụ sử dụng tệp âm thanh của bạn:

```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")
```

- Ví dụ về xử lý nhiều tệp âm thanh theo lô:

```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")
```

- Ví dụ về xử lý nhiều tệp âm thanh theo lô (Sử dụng `Pop2PianoFeatureExtractor` và `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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/configuration_pop2piano.py#L24)

**Tham số:**

is_encoder_decoder (`bool`, *tùy chọn*, mặc định là `True`) : Xác định xem mô hình có được sử dụng như một bộ mã hóa/giải mã hay không.

vocab_size (`int`, *tùy chọn*, mặc định là `2400`) : Kích thước từ vựng của mô hình. Xác định số lượng token khác nhau có thể được biểu diễn bởi `input_ids`.

composer_vocab_size (`int`, *tuỳ chọn*, mặc định là 21) : Chỉ định số lượng nhà soạn nhạc.

d_model (`int`, *tuỳ chọn*, mặc định là `512`) : Kích thước của các lớp encoder và lớp pooler.

d_kv (`int`, *tuỳ chọn*, mặc định là `64`) : Kích thước của các phép chiếu key, query, value cho mỗi đầu chú ý. `inner_dim` của lớp chiếu sẽ được định nghĩa là `num_heads * d_kv`.

d_ff (`int`, *tuỳ chọn*, mặc định là `2048`) : Kích thước của các biểu diễn MLP.

num_layers (`int`, *tuỳ chọn*, mặc định là `6`) : Số lượng lớp ẩn trong bộ giải mã Transformer.

num_decoder_layers (`int`, *tuỳ chọn*) : Số lượng lớp ẩn trong bộ giải mã Transformer. Sẽ sử dụng cùng giá trị với `num_layers` nếu không được đặt.

num_heads (`int`, *tuỳ chọn*, mặc định là `8`) : Số lượng đầu chú ý cho mỗi lớp chú ý trong bộ giải mã Transformer.

relative_attention_num_buckets (`int`, *tuỳ chọn*, mặc định là 32) : Số lượng bucket được sử dụng cho mỗi lớp attention.

relative_attention_max_distance (`int`, *tuỳ chọn*, mặc định là 128) : Khoảng cách tối đa của các chuỗi dài hơn cho việc tách bucket.

dropout_rate (`Union[float, int]`, *tùy chọn*, mặc định là `0.1`) : Tỷ lệ cho tất cả các lớp dropout.

layer_norm_epsilon (`float`, *tuỳ chọn*, mặc định là `1e-06`) : Epsilon được sử dụng bởi các lớp chuẩn hóa lớp (layer normalization).

initializer_factor (`float`, *tuỳ chọn*, mặc định là `1.0`) : Hệ số để khởi tạo tất cả các ma trận trọng số (nên giữ ở mức 1, được sử dụng bên trong cho việc kiểm tra khởi tạo).

feed_forward_proj (`string`, *tùy chọn*, mặc định là `"gated-gelu"`) : Loại lớp feed forward sẽ được sử dụng. Phải là một trong `"relu"` hoặc `"gated-gelu"`.

use_cache (`bool`, *tùy chọn*, mặc định là `True`) : Xác định xem mô hình có nên trả về các chú ý key/values cuối cùng hay không (không được sử dụng bởi tất cả các mô hình). Chỉ liên quan nếu `config.is_decoder=True` hoặc khi mô hình là mô hình sinh chỉ có decoder.

pad_token_id (`int`, *tùy chọn*, mặc định là `0`) : Id của token được sử dụng để đệm (padding) trong từ vựng.

eos_token_id (`Union[int, list[int]]`, *tùy chọn*, mặc định là `1`) : Id của token được sử dụng cho end-of-stream trong bảng từ vựng.

dense_act_fn (`string`, *tùy chọn*, mặc định là `"relu"`) : Loại Activation Function được sử dụng trong `Pop2PianoDenseActDense` và trong `Pop2PianoDenseGatedActDense`.

is_decoder (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem mô hình có được sử dụng như một bộ giải mã (decoder) hay không. Nếu `False`, mô hình sẽ được sử dụng như một bộ mã hóa (encoder).

tie_word_embeddings (`bool`, *tùy chọn*, mặc định là `True`) : Có nên gắn kết các nhúng trọng số theo ánh xạ `tied_weights_keys` của mô hình hay không.

Đây là lớp cấu hình để lưu trữ cấu hình của một Pop2PianoModel. Nó được sử dụng để khởi tạo một mô hình Pop2Piano theo các đối số được chỉ định, xác định kiến trúc của mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như cấu hình của [sweetcocoa/pop2piano](https://huggingface.co/sweetcocoa/pop2piano)

Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin.

## 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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/feature_extraction_pop2piano.py#L49)

**Tham số:**

sampling_rate (`int`, *tuỳ chọn*, mặc định là 22050) : Tần số lấy mẫu đích của tín hiệu âm thanh. Đây là tần số lấy mẫu mà chúng ta truyền vào mô hình.

padding_value (`int`, *optional*, mặc định là 0) : Giá trị đệm được sử dụng để đệm âm thanh. Nên tương ứng với các khoảng im lặng.

window_size (`int`, *optional*, mặc định là 4096) : Độ dài của cửa sổ tính bằng số mẫu mà phép biến đổi Fourier được áp dụng.

hop_length (`int`, *tuỳ chọn*, mặc định là 1024) : Kích thước bước giữa mỗi cửa sổ của dạng sóng, tính bằng số mẫu.

min_frequency (`float`, *optional*, mặc định là 10.0) : Tần số thấp nhất sẽ được sử dụng trong phổ log-mel.

feature_size (`int`, *tuỳ chọn*, mặc định là 512) : Kích thước chiều của các đặc trưng đã trích xuất.

num_bars (`int`, *tuỳ chọn*, mặc định là 2) : Xác định khoảng cách giữa mỗi chuỗi.

Tạo bộ trích xuất đặc trưng Pop2Piano.

Feature extractor này kế thừa từ [SequenceFeatureExtractor](/docs/transformers/main/vi/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), bao gồm hầu hết các phương thức chính. Người dùng nên tham khảo lớp cha này để biết thêm thông tin về các phương thức đó.

Lớp này trích xuất nhịp điệu và tiền xử lý âm thanh trước khi truyền vào mô hình. Đầu tiên, âm thanh được đưa vào thuật toán `RhythmExtractor2013` để trích xuất beat_times, vị trí các beat và ước lượng độ tin cậy của chúng cũng như tempo tính bằng bpm, sau đó beat_times được nội suy để lấy beatsteps. Tiếp theo, chúng ta tính toán extrapolated_beatsteps từ beatsteps để sử dụng trong tokenizer. Mặt khác, âm thanh được lấy mẫu lại theo self.sampling_rate và tiền xử lý, sau đó log mel spectogram được tính toán từ đó để sử dụng trong mô hình transformer của chúng ta.

#### __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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/feature_extraction_pop2piano.py#L341)

**Tham số:**

audio (`np.ndarray`, `List`) : Âm thanh hoặc lô âm thanh cần được xử lý. Mỗi âm thanh có thể là một mảng numpy, một danh sách các giá trị float, một danh sách các mảng numpy hoặc một danh sách các danh sách giá trị float.

sampling_rate (`int`) : Tần số lấy mẫu mà đầu vào `audio` được lấy mẫu. Rất khuyến nghị truyền `sampling_rate` trong lời gọi forward để ngăn các lỗi âm thầm.

steps_per_beat (`int`, *tuỳ chọn*, mặc định là 2) : Tham số này được sử dụng để nội suy `beat_times`.

resample (`bool`, *tùy chọn*, mặc định là `True`) : Xác định việc có lấy mẫu lại âm thanh thành `sampling_rate` hay không trước khi xử lý. Phải là True trong quá trình suy luận.

return_attention_mask (`bool` *optional*, mặc định là `False`) : Chỉ định xem attention_mask cho input_features, beatsteps và extrapolated_beatstep có được đưa ra làm đầu ra hay không. Được tự động đặt thành True cho các đầu vào dạng batch.

return_tensors (`str` hoặc [TensorType](/docs/transformers/main/vi/internal/file_utils#transformers.TensorType), *optional*) : Nếu được đặt, sẽ trả về các tensor thay vì danh sách các số nguyên python. Các giá trị chấp nhận được là: - `'pt'`: Trả về các đối tượng `torch.Tensor` của PyTorch. - `'np'`: Trả về các đối tượng `np.ndarray` của Numpy. Nếu không có gì được chỉ định, nó sẽ trả về danh sách các mảng `np.ndarray`.

Phương thức chính để tạo đặc trưng và chuẩn bị cho mô hình.

## Pop2PianoForConditionalGeneration[[transformers.Pop2PianoForConditionalGeneration]]

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/modeling_pop2piano.py#L763)

**Tham số:**

config ([Pop2PianoConfig](/docs/transformers/main/vi/model_doc/pop2piano#transformers.Pop2PianoConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình.

Mô hình Pop2Piano với đầu `language modeling` ở trên.

Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.)

Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung.

#### 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'>)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/modeling_pop2piano.py#L851)

**Tham số:**

input_ids (`torch.LongTensor` có shape `(batch_size, sequence_length)`) : Chỉ số của các token trong chuỗi đầu vào theo từ điển. Pop2Piano là một mô hình có nhúng vị trí tương đối nên bạn có thể đệm (pad) đầu vào ở cả bên phải và bên trái. Các chỉ số có thể được lấy bằng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [Input IDs là gì?](../glossary#input-ids) Để biết thêm về cách chuẩn bị `input_ids` cho huấn luyện trước, hãy xem [Pop2Piano Training](./Pop2Piano#training).

attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`:  - 1 cho các token **không bị che**, - 0 cho các token **bị che**.  [Mặt nạ chú ý là gì?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor` có shape `(batch_size, target_sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào của bộ giải mã trong từ vựng. Các chỉ số có thể được lấy bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [Các ID đầu vào của bộ giải mã là gì?](../glossary#decoder-input-ids) Pop2Piano sử dụng `pad_token_id` làm token bắt đầu cho việc tạo `decoder_input_ids`. Nếu `past_key_values` được sử dụng, tùy chọn chỉ cần nhập `decoder_input_ids` cuối cùng (xem `past_key_values`). Để biết thêm về cách chuẩn bị

decoder_attention_mask (`torch.BoolTensor` có shape `(batch_size, target_sequence_length)`, *tùy chọn*) : Hành vi mặc định: tạo một tensor bỏ qua các token pad trong `decoder_input_ids`. Causal mask cũng sẽ được sử dụng theo mặc định.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *tùy chọn*) : Tuple bao gồm (`last_hidden_state`, *tùy chọn*: `hidden_states`, *tùy chọn*: `attentions`) `last_hidden_state` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) là một chuỗi các hidden-states tại đầu ra của lớp cuối cùng của encoder. Được sử dụng trong cross-attention của decoder.

past_key_values (`~cache_utils.Cache`, *tùy chọn*) : Các hidden-states đã tính trước (key và values trong các khối self-attention và cross-attention) có thể được sử dụng để tăng tốc giải mã tuần tự. Điều này thường bao gồm `past_key_values` do mô hình trả về ở một giai đoạn giải mã trước đó, khi `use_cache=True` hoặc `config.use_cache=True`.  Chỉ cho phép [Cache](/docs/transformers/main/vi/internal/generation_utils#transformers.Cache) instance làm đầu vào, xem [hướng dẫn kv cache](https://huggingface.co/docs/transformers/en/kv_cache) của chúng tôi. Nếu không truyền `past_key_values`, [DynamicCache](/docs/transformers/main/vi/internal/generation_utils#transformers.DynamicCache) sẽ được khởi tạo theo mặc định.  Mô hình sẽ xuất ra cùng định dạng cache được đưa vào làm đầu vào.  Nếu sử dụng `past_key_values`, người dùng được kỳ vọng chỉ nhập các `input_ids` chưa được xử lý (những phần chưa có trạng thái key value quá khứ được cung cấp cho mô hình này) có shape `(batch_size, unprocessed_length)` thay vì tất cả `input_ids` có shape `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình.

input_features (`torch.Tensor` có shape `(batch_size, sequence_length, feature_dim)`, *tùy chọn*) : Các tensor tương ứng với các đặc trưng âm thanh đầu vào. Các đặc trưng âm thanh có thể được lấy bằng [Pop2PianoFeatureExtractor](/docs/transformers/main/vi/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor). Xem [Pop2PianoFeatureExtractor.__call__()](/docs/transformers/main/vi/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor.__call__) để biết chi tiết ([Pop2PianoProcessor](/docs/transformers/main/vi/model_doc/pop2piano#transformers.Pop2PianoProcessor) sử dụng [Pop2PianoFeatureExtractor](/docs/transformers/main/vi/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor) để xử lý âm thanh).

decoder_inputs_embeds (`torch.Tensor` có shape `(batch_size, target_sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `decoder_input_ids`, bạn có thể chọn truyền trực tiếp một biểu diễn nhúng. Nếu `past_key_values` được sử dụng, tùy chọn chỉ cần nhập `decoder_inputs_embeds` cuối cùng (xem `past_key_values`). Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `decoder_input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình. Nếu cả `decoder_input_ids` và `decoder_inputs_embeds` đều không được đặt, `decoder_inputs_embeds` sẽ nhận giá trị của `inputs_embeds`.

labels (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn để tính toán tổn thất phân loại/hồi quy chuỗi. Chỉ số phải nằm trong `[-100, 0, ..., config.vocab_size - 1]`. Tất cả các nhãn được đặt thành `-100` sẽ bị bỏ qua (che), tổn thất chỉ được tính cho các nhãn trong `[0, ..., config.vocab_size]`

use_cache (`bool`, *tùy chọn*) : Nếu được đặt thành `True`, các trạng thái khóa và giá trị `past_key_values` sẽ được trả về và có thể được sử dụng để tăng tốc quá trình giải mã (xem `past_key_values`).

**Trả về:** [Seq2SeqLMOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) hoặc `tuple(torch.Tensor)`

Một [Seq2SeqLMOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các thành phần khác nhau tùy thuộc vào cấu hình ([Pop2PianoConfig](/docs/transformers/main/vi/model_doc/pop2piano#transformers.Pop2PianoConfig)) và đầu vào.

Phương thức forward của [Pop2PianoForConditionalGeneration](/docs/transformers/main/vi/model_doc/pop2piano#transformers.Pop2PianoForConditionalGeneration) ghi đè lên phương thức đặc biệt `__call__`.

Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng.

- **loss** (`torch.Tensor` có shape `(1,)`, *tuỳ chọn*, được trả về khi `labels` được cung cấp) -- Loss của language modeling.
- **logits** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, config.vocab_size)`) -- Điểm dự đoán của đầu mô hình hóa ngôn ngữ (điểm cho mỗi token từ vựng trước SoftMax).
- **past_key_values** (`EncoderDecoderCache`, *tùy chọn*, được trả về khi `use_cache=True` được truyền vào hoặc khi `config.use_cache=True`) -- Đây là một instance của [EncoderDecoderCache](/docs/transformers/main/vi/internal/generation_utils#transformers.EncoderDecoderCache). Để biết thêm chi tiết, hãy xem [hướng dẫn về kv cache](https://huggingface.co/docs/transformers/en/kv_cache) của chúng tôi.

  Chứa các hidden-states đã được tính trước (key và values trong các khối self-attention và trong các khối cross-attention) có thể được sử dụng (xem đầu vào `past_key_values`) để tăng tốc độ giải mã tuần tự.
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của bộ giải mã tại đầu ra của mỗi lớp cùng với đầu ra của nhúng ban đầu.
- **decoder_attentions** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý của bộ giải mã, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention).
- **cross_attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý của lớp cross-attention của bộ giải mã, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý chéo.
- **encoder_last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) -- Chuỗi các trạng thái ẩn tại đầu ra của lớp cuối cùng của bộ mã hóa trong mô hình.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`.

  Trạng thái ẩn của bộ mã hóa tại đầu ra của mỗi lớp cùng với đầu ra của nhúng ban đầu.
- **encoder_attentions** (`tuple(torch.Tensor)`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`.

  Trọng số chú ý của bộ mã hóa, sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự thân.

Ví dụ:

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/modeling_pop2piano.py#L953)

**Tham số:**

input_features (`torch.Tensor` có shape `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Đây là phiên bản featurized của audio được tạo bởi `Pop2PianoFeatureExtractor`.

attention_mask : Đối với sinh theo lô, `input_features` được đệm (padding) để có cùng hình dạng trên tất cả các ví dụ. `attention_mask` giúp xác định vùng nào được đệm và vùng nào không. - 1 cho các token **không được đệm**, - 0 cho các token **được đệm**.

composer (`str`, *tùy chọn*, mặc định là `"composer1"`) : Giá trị này được truyền vào `Pop2PianoConcatEmbeddingToMel` để tạo ra các embedding khác nhau cho mỗi `"composer"`. Vui lòng đảm bảo rằng giá trị composer có mặt trong `composer_to_feature_token` của `generation_config`. Để xem ví dụ, hãy xem https://huggingface.co/sweetcocoa/pop2piano/blob/main/generation_config.json .

generation_config (`~generation.GenerationConfig`, *tùy chọn*) : Cấu hình sinh được sử dụng làm tham số hóa cơ sở cho lệnh gọi sinh. Các `**kwargs` được truyền vào generate khớp với các thuộc tính của `generation_config` sẽ ghi đè lên chúng. Nếu `generation_config` không được cung cấp, giá trị mặc định sẽ được sử dụng, với thứ tự ưu tiên nạp như sau: 1) từ tệp mô hình `generation_config.json`, nếu tệp này tồn tại; 2) từ cấu hình của mô hình. Vui lòng lưu ý rằng các tham số không được chỉ định sẽ kế thừa các giá trị mặc định của [GenerationConfig](/docs/transformers/main/vi/main_classes/text_generation#transformers.GenerationConfig), và tài liệu của chúng nên được kiểm tra để tham số hóa quá trình sinh.

kwargs : Tham số hóa ad hoc cho `generate_config` và/hoặc các kwargs cụ thể của model bổ sung sẽ được chuyển tiếp đến hàm `forward` của model. Nếu model là model encoder-decoder, các kwargs cụ thể của encoder không nên được thêm tiền tố, còn các kwargs cụ thể của decoder nên được thêm tiền tố *decoder_*.

**Trả về:** [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) hoặc `torch.LongTensor`

Một [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) (nếu `return_dict_in_generate=True` hoặc khi `config.return_dict_in_generate=True`) hoặc một `torch.Tensor`. Vì Pop2Piano là một mô hình encoder-decoder (`model.config.is_encoder_decoder=True`), các kiểu [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) có thể là:
- [GenerateEncoderDecoderOutput](/docs/transformers/main/vi/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput),
- [GenerateBeamEncoderDecoderOutput](/docs/transformers/main/vi/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput)

Tạo các id token cho đầu ra midi.

Hầu hết các tham số kiểm soát quá trình sinh được đặt trong `generation_config`, nếu không được truyền vào, giá trị này sẽ được đặt thành cấu hình sinh mặc định của mô hình. Bạn có thể ghi đè bất kỳ `generation_config` nào bằng cách truyền các tham số tương ứng vào generate(), ví dụ `.generate(inputs, num_beams=4, do_sample=True)`. Để xem tổng quan về các chiến lược sinh và ví dụ mã, hãy xem [hướng dẫn sau](./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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/tokenization_pop2piano.py#L62)

**Tham số:**

vocab (`str`) : Đường dẫn đến tệp từ vựng chứa bảng từ vựng.

default_velocity (`int`, *tuỳ chọn*, mặc định là 77) : Xác định tốc độ mặc định được sử dụng khi tạo các nốt midi.

num_bars (`int`, *tuỳ chọn*, mặc định là 2) : Xác định cutoff_time_idx cho từng token.

unk_token (`str` hoặc `tokenizers.AddedToken`, *tuỳ chọn*, mặc định là `"-1"`) : Token không xác định. Một token không có trong từ vựng sẽ không thể được chuyển đổi thành ID và sẽ được gán thành token này thay thế.

eos_token (`str` hoặc `tokenizers.AddedToken`, *tuỳ chọn*, mặc định là 1) : Token kết thúc chuỗi.

pad_token (`str` hoặc `tokenizers.AddedToken`, *tuỳ chọn*, mặc định là 0) : Một token đặc biệt được sử dụng để làm cho các mảng token có cùng kích thước nhằm mục đích tạo batch. Sau đó, nó sẽ bị bỏ qua bởi các cơ chế chú ý hoặc tính toán loss.

bos_token (`str` hoặc `tokenizers.AddedToken`, *tuỳ chọn*, mặc định là 2) : Token bắt đầu chuỗi được sử dụng trong quá trình tiền huấn luyện. Có thể được dùng làm token phân loại chuỗi.

Tạo một tokenizer Pop2Piano. Tokenizer này không yêu cầu huấn luyện.

Tokenizer này kế thừa từ [PreTrainedTokenizer](/docs/transformers/main/vi/main_classes/tokenizer#transformers.PythonBackend), lớp chứa hầu hết các phương thức chính. Người dùng nên tham khảo siêu lớp này để biết thêm thông tin về các phương thức đó.

#### __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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/tokenization_pop2piano.py#L473)

**Tham số:**

notes (`numpy.ndarray` có shape `[batch_size, max_sequence_length, 4]` hoặc `list` các đối tượng `pretty_midi.Note`) : Đại diện cho các nốt midi. Nếu `notes` là `numpy.ndarray`: - Mỗi chuỗi phải có 4 giá trị, lần lượt là `onset idx`, `offset idx`, `pitch` và `velocity`. Nếu `notes` là `list` chứa các đối tượng `pretty_midi.Note`: - Mỗi chuỗi phải có 4 thuộc tính, lần lượt là `start`, `end`, `pitch` và `velocity`.

padding (`bool`, `str` hoặc [PaddingStrategy](/docs/transformers/main/vi/internal/file_utils#transformers.utils.PaddingStrategy), *tuỳ chọn*, mặc định là `False`) : Kích hoạt và kiểm soát việc đệm. Chấp nhận các giá trị sau:  - `True` hoặc `'longest'`: Đệm đến độ dài của chuỗi dài nhất trong lô (hoặc không đệm nếu chỉ có một chuỗi duy nhất được cung cấp). - `'max_length'`: Đệm đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. - `False` hoặc `'do_not_pad'` (mặc định): Không đệm (tức là có thể xuất ra một lô với các chuỗi có độ dài khác nhau).

truncation (`bool`, `str` hoặc [TruncationStrategy](/docs/transformers/main/vi/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *optional*, mặc định là `False`) : Kích hoạt và kiểm soát việc cắt ngắn. Chấp nhận các giá trị sau:  - `True` hoặc `'longest_first'`: Cắt ngắn đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. Thao tác này sẽ cắt ngắn theo từng token, loại bỏ một token từ chuỗi dài nhất trong cặp nếu một cặp chuỗi (hoặc một batch các cặp) được cung cấp. - `'only_first'`: Cắt ngắn đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. Thao tác này chỉ cắt ngắn chuỗi đầu tiên của một cặp nếu một cặp chuỗi (hoặc một batch các cặp) được cung cấp. - `'only_second'`: Cắt ngắn đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. Thao tác này chỉ cắt ngắn chuỗi thứ hai của một cặp nếu một cặp chuỗi (hoặc một batch các cặp) được cung cấp. - `False` hoặc `'do_not_truncate'` (mặc định): Không cắt ngắn (tức là có thể xuất ra batch với độ dài chuỗi lớn hơn kích thước đầu vào tối đa được phép của mô hình).

max_length (`int`, *optional*) : Kiểm soát độ dài tối đa được sử dụng bởi một trong các tham số cắt/giữ chỗ. Nếu không được đặt hoặc được đặt thành `None`, giá trị này sẽ sử dụng độ dài tối đa định trước của mô hình nếu một trong các tham số cắt/giữ chỗ yêu cầu độ dài tối đa. Nếu mô hình không có độ dài đầu vào tối đa cụ thể (như XLNet), việc cắt/giữ chỗ đến độ dài tối đa sẽ bị vô hiệu hóa.

pad_to_multiple_of (`int`, *optional*) : Nếu được đặt, sẽ đệm chuỗi đến bội số của giá trị được cung cấp. Điều này đặc biệt hữu ích để cho phép sử dụng Tensor Cores trên phần cứng NVIDIA có khả năng tính toán `>= 7.5` (Volta).

return_attention_mask (`bool`, *tuỳ chọn*) : Có trả về attention mask hay không. Nếu để mặc định, sẽ trả về attention mask theo mặc định của tokenizer cụ thể, được định nghĩa bởi thuộc tính `return_outputs`.  [Attention mask là gì?](../glossary#attention-mask)

return_tensors (`str` hoặc [TensorType](/docs/transformers/main/vi/internal/file_utils#transformers.TensorType), *optional*) : Nếu được đặt, sẽ trả về các tensor thay vì danh sách các số nguyên python. Các giá trị chấp nhận được là:  - `'pt'`: Trả về các đối tượng `torch.Tensor` của PyTorch. - `'np'`: Trả về các đối tượng `np.ndarray` của Numpy.

verbose (`bool`, *tùy chọn*, mặc định là `True`) : Có in thêm thông tin và cảnh báo hay không.

**Trả về:**

`BatchEncoding` chứa token_ids.

Đây là phương thức `__call__` của `Pop2PianoTokenizer`. Nó chuyển đổi các nốt midi thành các id token do transformer tạo ra.

## Pop2PianoProcessor[[transformers.Pop2PianoProcessor]]

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/processing_pop2piano.py#L29)

**Tham số:**

feature_extractor (`Pop2PianoFeatureExtractor`) : Bộ trích xuất đặc trưng là một đầu vào bắt buộc.

tokenizer (`tokenizer_class`) : Tokenizer là đầu vào bắt buộc.

Tạo một Pop2PianoProcessor, đóng gói một bộ trích xuất đặc trưng và một tokenizer thành một bộ xử lý duy nhất.

[Pop2PianoProcessor](/docs/transformers/main/vi/model_doc/pop2piano#transformers.Pop2PianoProcessor) cung cấp đầy đủ các chức năng của [Pop2PianoFeatureExtractor](/docs/transformers/main/vi/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor) và `tokenizer_class`. Xem [~Pop2PianoFeatureExtractor](/docs/transformers/main/vi/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor) và `~tokenizer_class` để biết thêm thông tin.

#### __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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pop2piano/processing_pop2piano.py#L33)

**Tham số:**

audio (`Union[numpy.ndarray, list[float], list[numpy.ndarray]]`, *tuỳ chọn*) : Âm thanh hoặc lô âm thanh cần được chuẩn bị. Mỗi âm thanh có thể là mảng NumPy hoặc tensor PyTorch. Trong trường hợp là mảng NumPy/tensor PyTorch, mỗi âm thanh nên có hình dạng (C, T), trong đó C là số kênh và T là độ dài mẫu của âm thanh.

sampling_rate (`int` hoặc `list[int]`, *tùy chọn*) : Tần số lấy mẫu của âm thanh đầu vào, tính bằng Hz. Giá trị này phải khớp với tần số lấy mẫu được sử dụng bởi bộ trích xuất đặc trưng. Nếu không được cung cấp, tần số lấy mẫu mặc định từ cấu hình bộ xử lý sẽ được sử dụng.

steps_per_beat (`int`, *optional*, mặc định là `2`) : Số bước thời gian trên mỗi nhịp nhạc. Tham số này kiểm soát độ phân giải thời gian của biểu diễn âm nhạc. Giá trị cao hơn cung cấp độ hạt thời gian mịn hơn nhưng làm tăng độ dài chuỗi. Được sử dụng khi xử lý âm thanh để trích xuất các đặc trưng âm nhạc.

resample (`bool`, *tùy chọn*, mặc định là `True`) : Bộ lọc lấy mẫu lại (resampling filter) được sử dụng khi thay đổi kích thước ảnh. Giá trị này có thể là một trong các hằng số liệt kê (enum) của `PILImageResampling`. Chỉ có hiệu lực khi `do_resize` được đặt thành `True`.

notes (`list` hoặc `TensorType`, *optional*) : Các nốt nhạc MIDI đã được trích xuất trước. Khi được cung cấp, trình xử lý sẽ bỏ qua bước trích xuất đặc trưng âm thanh và xử lý trực tiếp các nốt nhạc thông qua tokenizer. Mỗi nốt nhạc nên được biểu diễn dưới dạng một list hoặc tensor chứa thông tin về cao độ, vận tốc và thời điểm.

padding (bool, str hoặc [PaddingStrategy](/docs/transformers/main/vi/internal/file_utils#transformers.utils.PaddingStrategy), *optional*, mặc định là `False`) : Kích hoạt và kiểm soát việc đệm. Chấp nhận các giá trị sau:  - `True` hoặc `'longest'`: Đệm đến độ dài của chuỗi dài nhất trong batch (hoặc không đệm nếu chỉ cung cấp một chuỗi duy nhất). - `'max_length'`: Đệm đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. - `False` hoặc `'do_not_pad'` (mặc định): Không đệm (tức là có thể xuất ra một batch với các chuỗi có độ dài khác nhau).

truncation (bool, str hoặc [TruncationStrategy](/docs/transformers/main/vi/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *optional*) : Kích hoạt và kiểm soát việc cắt ngắn. Chấp nhận các giá trị sau:  - `True` hoặc `'longest_first'`: Cắt ngắn đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. Thao tác này sẽ cắt ngắn theo từng token, loại bỏ một token từ chuỗi dài nhất trong cặp nếu một cặp chuỗi (hoặc một lô các cặp) được cung cấp. - `'only_first'`: Cắt ngắn đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. Thao tác này chỉ cắt ngắn chuỗi đầu tiên của một cặp nếu một cặp chuỗi (hoặc một lô các cặp) được cung cấp. - `'only_second'`: Cắt ngắn đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. Thao tác này chỉ cắt ngắn chuỗi thứ hai của một cặp nếu một cặp chuỗi (hoặc một lô các cặp) được cung cấp. - `False` hoặc `'do_not_truncate'` (mặc định): Không cắt ngắn (tức là có thể xuất ra lô có độ dài chuỗi lớn hơn kích thước đầu vào tối đa được phép của mô hình).

max_length (`int`, *optional*) : Kiểm soát độ dài tối đa được sử dụng bởi một trong các tham số cắt/giữ chỗ. Nếu không được đặt hoặc được đặt thành `None`, tham số này sẽ sử dụng độ dài tối đa định trước của mô hình nếu một trong các tham số cắt/giữ chỗ yêu cầu độ dài tối đa. Nếu mô hình không có độ dài đầu vào tối đa cụ thể (như XLNet), việc cắt/giữ chỗ đến độ dài tối đa sẽ bị vô hiệu hóa.

pad_to_multiple_of (`int`, *optional*) : Nếu được đặt, sẽ đệm chuỗi đến bội số của giá trị được cung cấp. Yêu cầu `padding` phải được kích hoạt. Điều này đặc biệt hữu ích để cho phép sử dụng Tensor Cores trên phần cứng NVIDIA có khả năng tính toán `>= 7.5` (Volta).

verbose (`bool`, *tùy chọn*, mặc định là `True`) : Có in thêm thông tin và cảnh báo hay không.

return_tensors (`str` hoặc [TensorType](/docs/transformers/main/vi/internal/file_utils#transformers.TensorType), *optional*) : Nếu được đặt, sẽ trả về các tensor của một framework cụ thể. Các giá trị chấp nhận được là:  - `'pt'`: Trả về các đối tượng `torch.Tensor` của PyTorch. - `'np'`: Trả về các đối tượng `np.ndarray` của NumPy.

**Trả về:**

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