# Pop2Piano

## Visão geral

O modelo Pop2Piano foi proposto em [Pop2Piano : Pop Audio-based Piano Cover Generation](https://huggingface.co/papers/2211.00895) por Jongho Choi e Kyogu Lee.

Coberturas de piano de música pop são amplamente apreciadas, mas gerá-las a partir de música não é uma tarefa trivial. É necessário grande domínio na execução do piano, bem como conhecimento das diferentes características e melodias de uma música. Com o Pop2Piano, é possível gerar diretamente uma cobertura a partir da forma de onda de áudio de uma música. É o primeiro modelo a gerar diretamente uma cobertura de piano a partir de áudio pop, sem módulos de extração de melodia e acordes.

Pop2Piano é um modelo Transformer encoder-decoder baseado em [T5](https://huggingface.co/papers/1910.10683). O áudio de entrada é transformado em sua forma de onda e enviado ao encoder, que o converte em uma representação latente. O decoder usa essas representações latentes para gerar ids de tokens de forma autoregressiva. Cada id de token corresponde a um de quatro tipos diferentes de tokens: tempo, velocidade, nota e 'especial'. Os ids de tokens são então decodificados para o arquivo MIDI equivalente.

O resumo do artigo é o seguinte:

*Coberturas de piano de música pop são apreciadas por muitas pessoas. No entanto, a tarefa de gerar automaticamente coberturas de piano de música pop ainda é pouco estudada. Isso se deve em parte à falta de pares de dados {Pop, Piano Cover} sincronizados, o que dificultou a aplicação dos métodos mais recentes baseados em aprendizado profundo e intensivos em dados. Para aproveitar o poder da abordagem orientada por dados, criamos uma grande quantidade de dados pareados e sincronizados {Pop, Piano Cover} usando um pipeline automatizado. Neste artigo, apresentamos o Pop2Piano, uma rede Transformer que gera coberturas de piano a partir de formas de onda de música pop. Pelo nosso conhecimento, este é o primeiro modelo a gerar uma cobertura de piano diretamente de áudio pop sem usar módulos de extração de melodia e acordes. Mostramos que o Pop2Piano, treinado com nosso conjunto de dados, é capaz de produzir coberturas de piano plausíveis.*

Este modelo foi contribuído por [Susnato Dhar](https://huggingface.co/susnato). O código original pode ser encontrado [aqui](https://github.com/sweetcocoa/pop2piano).

## Dicas de uso

* Para usar o Pop2Piano, você precisará instalar a biblioteca 🤗 Transformers, bem como os seguintes módulos de terceiros:

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

Observe que você pode precisar reiniciar o runtime após a instalação.

* Pop2Piano é um modelo baseado em Encoder-Decoder, como o T5.
* O Pop2Piano pode ser usado para gerar arquivos midi-audio para uma sequência de áudio fornecida.
* Escolher diferentes compositores em `Pop2PianoForConditionalGeneration.generate()` pode levar a uma variedade de resultados diferentes.
* Definir a taxa de amostragem em 44,1 kHz ao carregar o arquivo de áudio pode resultar em bom desempenho.
* Embora o Pop2Piano tenha sido treinado principalmente em música Pop coreana, ele também se sai bem em outras músicas Pop ou Hip Hop ocidentais.

## Exemplos

- Exemplo usando o Dataset do HuggingFace:

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

- Exemplo usando seu próprio arquivo de áudio:

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

- Exemplo de processamento de vários arquivos de áudio em lote:

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

- Exemplo de processamento de vários arquivos de áudio em lote (usando `Pop2PianoFeatureExtractor` e `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)
```

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

**Parâmetros:**

is_encoder_decoder (`bool`, *opcional*, padrão `True`) : Indica se o modelo é usado como codificador/decodificador ou não.

vocab_size (`int`, *opcional*, padrão `2400`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`.

composer_vocab_size (`int`, *opcional*, padrão 21) : Indica o número de compositores.

d_model (`int`, *opcional*, padrão `512`) : Tamanho das camadas do codificador e da camada pooler.

d_kv (`int`, *opcional*, padrão `64`) : Tamanho das projeções de chave, consulta e valor por cabeça de atenção. O `inner_dim` da camada de projeção será definido como `num_heads * d_kv`.

d_ff (`int`, *opcional*, padrão `2048`) : Dimensão das representações do MLP.

num_layers (`int`, *opcional*, padrão `6`) : Número de camadas ocultas no decodificador do Transformer.

num_decoder_layers (`int`, *opcional*) : Número de camadas ocultas no decodificador do Transformer. Usará o mesmo valor de `num_layers` se não for definido.

num_heads (`int`, *opcional*, padrão `8`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

relative_attention_num_buckets (`int`, *opcional*, padrão 32) : O número de buckets a serem usados em cada camada de atenção.

relative_attention_max_distance (`int`, *opcional*, padrão 128) : A distância máxima das sequências mais longas para a separação em buckets.

dropout_rate (`Union[float, int]`, *opcional*, padrão `0.1`) : A proporção para todas as camadas de dropout.

layer_norm_epsilon (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização de camada.

initializer_factor (`float`, *opcional*, padrão `1.0`) : Um fator para inicializar todas as matrizes de pesos (deve ser mantido em 1, usado internamente para testes de inicialização).

feed_forward_proj (`string`, *opcional*, padrão `"gated-gelu"`) : Tipo de camada feed forward a ser usada. Deve ser um dos valores `"relu"` ou `"gated-gelu"`.

use_cache (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador.

pad_token_id (`int`, *opcional*, padrão `0`) : ID do token usado para preenchimento no vocabulário.

eos_token_id (`Union[int, list[int]]`, *opcional*, padrão `1`) : ID do token usado para o fim do fluxo no vocabulário.

dense_act_fn (`string`, *opcional*, padrão `"relu"`) : Tipo de Função de Ativação a ser usada em `Pop2PianoDenseActDense` e em `Pop2PianoDenseGatedActDense`.

is_decoder (`bool`, *opcional*, padrão `False`) : Indica se o modelo é usado como decodificador ou não. Se `False`, o modelo é usado como codificador.

tie_word_embeddings (`bool`, *opcional*, padrão `True`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo.

Esta é a classe de configuração para armazenar a configuração de um Pop2PianoModel. Ela é usada para instanciar um modelo Pop2Piano de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [sweetcocoa/pop2piano](https://huggingface.co/sweetcocoa/pop2piano)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

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

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

**Parâmetros:**

sampling_rate (`int`, *opcional*, padrão 22050) : Taxa de amostragem alvo do sinal de áudio. É a taxa de amostragem que enviamos para o modelo.

padding_value (`int`, *opcional*, padrão 0) : Valor de preenchimento usado para preencher o áudio. Deve corresponder a silêncios.

window_size (`int`, *opcional*, padrão 4096) : Comprimento da janela em amostras ao qual a transformada de Fourier é aplicada.

hop_length (`int`, *opcional*, padrão 1024) : Tamanho do passo entre cada janela da forma de onda, em amostras.

min_frequency (`float`, *opcional*, padrão 10.0) : Frequência mais baixa que será usada no espectrograma log-mel.

feature_size (`int`, *opcional*, padrão 512) : A dimensão dos recursos das características extraídas.

num_bars (`int`, *opcional*, padrão 2) : Determina o intervalo entre cada sequência.

Constrói um extrator de recursos Pop2Piano.

Este extrator de características herda de [SequenceFeatureExtractor](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), que contém a maioria dos métodos principais. Os usuários devem consultar esta superclasse para obter mais informações sobre esses métodos.

Esta classe extrai o ritmo e pré-processa o áudio antes de ele ser passado para o modelo. Primeiro, o áudio é enviado para o algoritmo `RhythmExtractor2013`, que extrai os beat_times, as posições dos beats e estima sua confiança, bem como o tempo em bpm. Em seguida, beat_times é interpolado para obter beatsteps. Depois, calculamos extrapolated_beatsteps a partir dele para ser usado no tokenizer. Por outro lado, o áudio é reamostrado para self.sampling_rate e pré-processado, e então o log mel spectogram é calculado a partir dele para ser usado em nosso modelo transformer.

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

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

**Parâmetros:**

audio (`np.ndarray`, `List`) : O áudio ou lote de áudios a ser processado. Cada áudio pode ser um array numpy, uma lista de valores float, uma lista de arrays numpy ou uma lista de listas de valores float.

sampling_rate (`int`) : A taxa de amostragem na qual a entrada `audio` foi amostrada. É fortemente recomendado passar `sampling_rate` na chamada de forward para evitar erros silenciosos.

steps_per_beat (`int`, *opcional*, padrão 2) : Isso é usado na interpolação de `beat_times`.

resample (`bool`, *opcional*, padrão `True`) : Determina se o áudio deve ser reamostrado para `sampling_rate` antes do processamento. Deve ser True durante a inferência.

return_attention_mask (`bool` *opcional*, padrão `False`) : Indica se a attention_mask para input_features, beatsteps e extrapolated_beatstep será fornecida como saída ou não. Definido automaticamente como True para entradas em lote.

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores em vez de lista de inteiros do Python. Valores aceitáveis são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do Numpy. Se nada for especificado, retornará lista de arrays `np.ndarray`.

Método principal para criar os recursos e preparar os dados para o modelo.

## Pop2PianoForConditionalGeneration[[transformers.Pop2PianoForConditionalGeneration]]

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

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

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

**Parâmetros:**

config ([Pop2PianoConfig](/docs/transformers/main/pt/model_doc/pop2piano#transformers.Pop2PianoConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Modelo Pop2Piano com uma cabeça de `language modeling` no topo.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de entrada no vocabulário. O Pop2Piano é um modelo com embeddings de posição relativa, portanto, você deve poder preencher as entradas tanto à direita quanto à esquerda. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) Para saber mais sobre como preparar `input_ids` para pré-treinamento, veja [Pop2Piano Training](./Pop2Piano#training).

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada do decodificador no vocabulário. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada do decodificador?](../glossary#decoder-input-ids) O Pop2Piano usa o `pad_token_id` como o token inicial para a geração de `decoder_input_ids`. Se `past_key_values` for usado, opcionalmente apenas os últimos `decoder_input_ids` precisam ser inseridos (veja `past_key_values`). Para saber mais sobre como preparar

decoder_attention_mask (`torch.BoolTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamento padrão: gerar um tensor que ignora tokens de preenchimento em `decoder_input_ids`. A máscara causal também será usada por padrão.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *opcional*) : A tupla consiste em (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder.

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando [Pop2PianoFeatureExtractor](/docs/transformers/main/pt/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor). Veja [Pop2PianoFeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor.__call__) para detalhes ([Pop2PianoProcessor](/docs/transformers/main/pt/model_doc/pop2piano#transformers.Pop2PianoProcessor) usa [Pop2PianoFeatureExtractor](/docs/transformers/main/pt/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor) para processar áudios).

decoder_inputs_embeds (`torch.Tensor` de forma `(batch_size, target_sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `decoder_input_ids`, você pode escolher passar diretamente uma representação incorporada. Se `past_key_values` for usado, opcionalmente apenas o último `decoder_inputs_embeds` precisa ser inserido (veja `past_key_values`). Isso é útil se você quiser ter mais controle sobre como converter os índices de `decoder_input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. Se `decoder_input_ids` e `decoder_inputs_embeds` estiverem ambos não definidos, `decoder_inputs_embeds` assume o valor de `inputs_embeds`.

labels (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em `[-100, 0, ..., config.vocab_size - 1]`. Todos os rótulos definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os rótulos em `[0, ..., config.vocab_size]`

use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`).

**Retorna:** [Seq2SeqLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou `tuple(torch.Tensor)`

Um [Seq2SeqLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([Pop2PianoConfig](/docs/transformers/main/pt/model_doc/pop2piano#transformers.Pop2PianoConfig)) e das entradas.

O método forward de [Pop2PianoForConditionalGeneration](/docs/transformers/main/pt/model_doc/pop2piano#transformers.Pop2PianoForConditionalGeneration) sobrescreve o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem.
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).
- **past_key_values** (`EncoderDecoderCache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- É uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial.
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do decodificador na saída de cada camada, além das saídas do embedding inicial.
- **decoder_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) com forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **cross_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.
- **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de estados ocultos na saída da última camada do encoder do modelo.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do codificador na saída de cada camada, além das saídas do embedding inicial.
- **encoder_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo:

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

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

**Parâmetros:**

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Esta é a versão com recursos do áudio gerada por `Pop2PianoFeatureExtractor`.

attention_mask : Para geração em lote, `input_features` são preenchidos para ter a mesma forma em todos os exemplos. `attention_mask` ajuda a determinar quais áreas foram preenchidas e quais não foram. - 1 para tokens que **não foram preenchidos**, - 0 para tokens que **foram preenchidos**.

composer (`str`, *opcional*, padrão `"composer1"`) : Este valor é passado para `Pop2PianoConcatEmbeddingToMel` para gerar embeddings diferentes para cada `"composer"`. Certifique-se de que o valor do compositor esteja presente em `composer_to_feature_token` em `generation_config`. Para um exemplo, consulte https://huggingface.co/sweetcocoa/pop2piano/blob/main/generation_config.json .

generation_config (`~generation.GenerationConfig`, *opcional*) : A configuração de geração a ser usada como parametrização base para a chamada de geração. Os `**kwargs` passados para generate que correspondam aos atributos de `generation_config` os sobrescreverão. Se `generation_config` não for fornecido, o padrão será usado, que tem a seguinte prioridade de carregamento: 1) do arquivo de modelo `generation_config.json`, se existir; 2) da configuração do modelo. Observe que os parâmetros não especificados herdarão os valores padrão de [GenerationConfig](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationConfig), cuja documentação deve ser consultada para parametrizar a geração.

kwargs : Parametrização ad hoc de `generate_config` e/ou kwargs específicos do modelo adicionais que serão encaminhados para a função `forward` do modelo. Se o modelo for um modelo encoder-decoder, os kwargs específicos do encoder não devem ter prefixo e os kwargs específicos do decoder devem ter o prefixo *decoder_*.

**Retorna:** [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) ou `torch.LongTensor`

Um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) (se `return_dict_in_generate=True` ou quando `config.return_dict_in_generate=True`) ou um `torch.Tensor`. Como o Pop2Piano é um modelo encoder-decoder (`model.config.is_encoder_decoder=True`), os tipos possíveis de [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) são:
- [GenerateEncoderDecoderOutput](/docs/transformers/main/pt/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput),
- [GenerateBeamEncoderDecoderOutput](/docs/transformers/main/pt/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput)

Gera ids de tokens para saídas midi.

A maioria dos parâmetros de controle de geração é definida em `generation_config`, que, se não for passada, será definida como a configuração de geração padrão do modelo. Você pode sobrescrever qualquer `generation_config` passando os parâmetros correspondentes para generate(), por exemplo, `.generate(inputs, num_beams=4, do_sample=True)`. Para uma visão geral das estratégias de geração e exemplos de código, confira o [guia a seguir](./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)
```

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

**Parâmetros:**

vocab (`str`) : Caminho para o arquivo de vocabulário que contém o vocabulário.

default_velocity (`int`, *opcional*, padrão 77) : Determina a velocidade padrão a ser usada ao criar notas midi.

num_bars (`int`, *opcional*, padrão 2) : Determina cutoff_time_idx para cada token.

unk_token (`str` ou `tokenizers.AddedToken`, *opcional*, padrão `"-1"`) : O token desconhecido. Um token que não está no vocabulário não pode ser convertido em um ID e é definido como este token em vez disso.

eos_token (`str` ou `tokenizers.AddedToken`, *opcional*, padrão 1) : O token de fim de sequência.

pad_token (`str` ou `tokenizers.AddedToken`, *opcional*, padrão 0) : Um token especial usado para tornar os arrays de tokens do mesmo tamanho para fins de loteamento. Em seguida, será ignorado pelos mecanismos de atenção ou pelo cálculo da perda.

bos_token (`str` ou `tokenizers.AddedToken`, *opcional*, padrão 2) : O token de início de sequência usado durante o pré-treinamento. Pode ser usado como token de classificador de sequência.

Constrói um tokenizador Pop2Piano. Este tokenizador não requer treinamento.

Este tokenizer herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend), que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos.

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

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

**Parâmetros:**

notes (`numpy.ndarray` de forma `[batch_size, max_sequence_length, 4]` ou `list` de objetos `pretty_midi.Note`) : Isso representa as notas midi. Se `notes` for um `numpy.ndarray`: - Cada sequência deve ter 4 valores, que são `onset idx`, `offset idx`, `pitch` e `velocity`. Se `notes` for uma `list` contendo objetos `pretty_midi.Note`: - Cada sequência deve ter 4 atributos, que são `start`, `end`, `pitch` e `velocity`.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `False`) : Ativa e controla o padding. Aceita os seguintes valores:  - `True` ou `'longest'`: Preenche até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Preenche até o comprimento máximo especificado com o argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_pad'` (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).

truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/main/pt/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, padrão `False`) : Ativa e controla a truncagem. Aceita os seguintes valores:  - `True` ou `'longest_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca token por token, removendo um token da sequência mais longa do par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a primeira sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_second'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a segunda sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `False` ou `'do_not_truncate'` (padrão): Sem truncagem (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada admissível do modelo).

max_length (`int`, *opcional*) : Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento. Se não for definido ou for definido como `None`, isso usará o comprimento máximo predefinido do modelo, caso um comprimento máximo seja exigido por um dos parâmetros de truncamento/preenchimento. Se o modelo não tiver um comprimento máximo específico de entrada (como o XLNet), o truncamento/preenchimento para um comprimento máximo será desativado.

pad_to_multiple_of (`int`, *opcional*) : Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Isso é especialmente útil para habilitar o uso de Tensor Cores em hardware NVIDIA com capacidade de computação `>= 7.5` (Volta).

return_attention_mask (`bool`, *opcional*) : Indica se a máscara de atenção deve ser retornada. Se mantido o valor padrão, a máscara de atenção será retornada de acordo com o padrão do tokenizer específico, definido pelo atributo `return_outputs`.  [O que são máscaras de atenção?](../glossary#attention-mask)

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores em vez de lista de inteiros do Python. Os valores aceitos são:  - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do Numpy.

verbose (`bool`, *opcional*, padrão `True`) : Se deve ou não exibir mais informações e avisos.

**Retorna:**

`BatchEncoding` contendo os token_ids.

Este é o método `__call__` para `Pop2PianoTokenizer`. Ele converte as notas midi nos ids de tokens gerados pelo transformer.

## Pop2PianoProcessor[[transformers.Pop2PianoProcessor]]

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

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

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

**Parâmetros:**

feature_extractor (`Pop2PianoFeatureExtractor`) : O extrator de recursos é uma entrada obrigatória.

tokenizer (`tokenizer_class`) : O tokenizer é uma entrada obrigatória.

Constrói um Pop2PianoProcessor que encapsula um extrator de recursos e um tokenizer em um único processador.

[Pop2PianoProcessor](/docs/transformers/main/pt/model_doc/pop2piano#transformers.Pop2PianoProcessor) oferece todas as funcionalidades de [Pop2PianoFeatureExtractor](/docs/transformers/main/pt/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor) e `tokenizer_class`. Consulte [~Pop2PianoFeatureExtractor](/docs/transformers/main/pt/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor) e `~tokenizer_class` para mais informações.

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

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

**Parâmetros:**

audio (`Union[numpy.ndarray, list[float], list[numpy.ndarray]]`, *opcional*) : O áudio ou lote de áudios a ser preparado. Cada áudio pode ser um array NumPy ou um tensor PyTorch. No caso de um array NumPy/tensor PyTorch, cada áudio deve ter a forma (C, T), onde C é o número de canais e T é o comprimento de amostras do áudio.

sampling_rate (`int` ou `list[int]`, *opcional*) : A taxa de amostragem do áudio de entrada em Hz. Isso deve corresponder à taxa de amostragem usada pelo extrator de recursos. Se não for fornecida, a taxa de amostragem padrão da configuração do processador será usada.

steps_per_beat (`int`, *opcional*, padrão `2`) : O número de passos de tempo por batida musical. Este parâmetro controla a resolução temporal da representação musical. Um valor maior fornece uma granularidade temporal mais fina, mas aumenta o comprimento da sequência. Usado ao processar áudio para extrair características musicais.

resample (`bool`, *opcional*, padrão `True`) : Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`.

notes (`list` ou `TensorType`, *opcional*) : Notas musicais pré-extraídas em formato MIDI. Quando fornecidas, o processador ignora a extração de recursos de áudio e processa diretamente as notas por meio do tokenizer. Cada nota deve ser representada como uma lista ou tensor contendo informações de altura, velocidade e tempo.

padding (bool, str ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `False`) : Ativa e controla o padding. Aceita os seguintes valores:  - `True` ou `'longest'`: Preenche até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Preenche até o comprimento máximo especificado com o argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_pad'` (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).

truncation (bool, str ou [TruncationStrategy](/docs/transformers/main/pt/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*) : Ativa e controla a truncagem. Aceita os seguintes valores:  - `True` ou `'longest_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável pelo modelo, caso esse argumento não seja fornecido. Isso trunca token por token, removendo um token da sequência mais longa do par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável pelo modelo, caso esse argumento não seja fornecido. Isso trunca apenas a primeira sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_second'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável pelo modelo, caso esse argumento não seja fornecido. Isso trunca apenas a segunda sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `False` ou `'do_not_truncate'` (padrão): Sem truncagem (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada admissível pelo modelo).

max_length (`int`, *opcional*) : Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento. Se não for definido ou for definido como `None`, será usado o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento até um comprimento máximo será desativado.

pad_to_multiple_of (`int`, *opcional*) : Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Exige que `padding` esteja ativado. Isso é especialmente útil para permitir o uso de Tensor Cores em hardware NVIDIA com capacidade de computação `>= 7.5` (Volta).

verbose (`bool`, *opcional*, padrão `True`) : Se deve ou não exibir mais informações e avisos.

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores de um framework específico. Os valores aceitos são:  - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy.

**Retorna:**

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