Transformers documentation
Pop2Piano
Este modelo se publicó en HF papers el 2022-11-02 y se contribuyó a Hugging Face Transformers el 2023-08-21.
Pop2Piano
Resumen
El modelo Pop2Piano fue propuesto en Pop2Piano : Pop Audio-based Piano Cover Generation por Jongho Choi y Kyogu Lee.
Los arreglos de piano de música pop son muy populares, pero generarlos a partir de música no es una tarea trivial. Requiere un gran dominio del piano, así como un conocimiento de las distintas características y melodías de una canción. Con Pop2Piano puedes generar directamente un arreglo a partir de la forma de onda de audio de una canción. Es el primer modelo que genera directamente un arreglo de piano a partir de audio pop, sin módulos de extracción de melodía y acordes.
Pop2Piano es un modelo Transformer de codificador-decodificador basado en T5. El audio de entrada se transforma en su forma de onda y se pasa al codificador, que lo convierte en una representación latente. El decodificador utiliza estas representaciones latentes para generar ids de tokens de manera autoregresiva. Cada id de token corresponde a uno de cuatro tipos de tokens diferentes: tiempo, velocidad, nota y ‘especial’. Los ids de tokens se decodifican luego en su archivo MIDI equivalente.
El resumen del artículo es el siguiente:
Las versiones de piano de música pop son disfrutadas por muchas personas. Sin embargo, la tarea de generar automáticamente versiones de piano de música pop sigue estando poco estudiada. Esto se debe en parte a la falta de pares de datos sincronizados {Pop, Piano Cover}, lo que dificultó aplicar los últimos métodos basados en aprendizaje profundo intensivo en datos. Para aprovechar el poder del enfoque basado en datos, creamos una gran cantidad de datos emparejados y sincronizados {Pop, Piano Cover} utilizando un pipeline automatizado. En este artículo, presentamos Pop2Piano, una red Transformer que genera versiones de piano a partir de las formas de onda de la música pop. Según nuestro conocimiento, este es el primer modelo que genera una versión de piano directamente desde audio pop sin utilizar módulos de extracción de melodía y acordes. Mostramos que Pop2Piano, entrenado con nuestro conjunto de datos, es capaz de producir versiones de piano plausibles.
Este modelo fue aportado por Susnato Dhar. El código original se puede encontrar aquí.
Consejos de uso
- Para usar Pop2Piano, deberá instalar la biblioteca 🤗 Transformers, así como los siguientes módulos de terceros:
pip install pretty-midi==0.2.9 essentia==2.1b6.dev1034 librosa scipy
Tenga en cuenta que es posible que deba reiniciar su entorno de ejecución después de la instalación.
- Pop2Piano es un modelo basado en Encoder-Decoder, similar a T5.
- Pop2Piano se puede utilizar para generar archivos midi-audio para una secuencia de audio dada.
- Elegir diferentes compositores en
Pop2PianoForConditionalGeneration.generate()puede llevar a una variedad de resultados diferentes. - Establecer la tasa de muestreo en 44,1 kHz al cargar el archivo de audio puede ofrecer un buen rendimiento.
- Aunque Pop2Piano se entrenó principalmente con música pop coreana, también funciona bastante bien con otras canciones de pop o hip hop occidental.
Ejemplos
- Ejemplo usando un Dataset de HuggingFace:
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")- Ejemplo usando su propio archivo de audio:
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")- Ejemplo de procesamiento de varios archivos de audio en lote:
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")- Ejemplo de procesamiento de varios archivos de audio en lote (usando
Pop2PianoFeatureExtractoryPop2PianoTokenizer):
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
clase transformers.Pop2PianoConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Truevocab_size: int = 2400composer_vocab_size: int = 21d_model: int = 512d_kv: int = 64d_ff: int = 2048num_layers: int = 6num_decoder_layers: int | None = Nonenum_heads: int = 8relative_attention_num_buckets: int = 32relative_attention_max_distance: int = 128dropout_rate: float | int = 0.1layer_norm_epsilon: float = 1e-06initializer_factor: float = 1.0feed_forward_proj: str = 'gated-gelu'use_cache: bool = Truepad_token_id: int | None = 0eos_token_id: int | list[int] | None = 1dense_act_fn: str = 'relu'is_decoder: bool = Falsetie_word_embeddings: bool = True )
Parámetros
- is_encoder_decoder (
bool, opcional, valor predeterminadoTrue) — Indica si el modelo se utiliza como codificador/decodificador o no. - vocab_size (
int, opcional, valor predeterminado2400) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse medianteinput_ids. - composer_vocab_size (
int, opcional, valor predeterminado 21) — Indica el número de compositores. - d_model (
int, opcional, valor predeterminado512) — Tamaño de las capas del codificador y de la capa pooler. - d_kv (
int, opcional, valor predeterminado64) — Tamaño de las proyecciones de clave, consulta y valor por cabeza de atención. Lainner_dimde la capa de proyección se definirá comonum_heads * d_kv. - d_ff (
int, opcional, valor predeterminado2048) — Dimensión de las representaciones del MLP. - num_layers (
int, opcional, valor predeterminado6) — Número de capas ocultas en el decodificador del Transformer. - num_decoder_layers (
int, opcional) — Número de capas ocultas en el decodificador del Transformer. Si no se establece, se usará el mismo valor quenum_layers. - num_heads (
int, opcional, valor predeterminado8) — Número de cabezas de atención para cada capa de atención en el decodificador del Transformer. - relative_attention_num_buckets (
int, opcional, valor predeterminado 32) — El número de cubos a utilizar en cada capa de atención. - relative_attention_max_distance (
int, opcional, valor predeterminado 128) — La distancia máxima de las secuencias más largas para la separación en cubos. - dropout_rate (
Union[float, int], opcional, valor predeterminado0.1) — La proporción para todas las capas de dropout. - layer_norm_epsilon (
float, opcional, valor predeterminado1e-06) — El epsilon utilizado por las capas de normalización de capa. - initializer_factor (
float, opcional, valor predeterminado1.0) — Un factor para inicializar todas las matrices de pesos (debe mantenerse en 1, se usa internamente para pruebas de inicialización). - feed_forward_proj (
string, opcional, valor predeterminado"gated-gelu") — Tipo de capa de avance hacia adelante que se utilizará. Debe ser"relu"o"gated-gelu". - use_cache (
bool, opcional, valor predeterminadoTrue) — Indica si el modelo debe devolver las últimas claves/valores de atención (no utilizado por todos los modelos). Solo es relevante siconfig.is_decoder=Trueo cuando el modelo es un modelo generativo solo de decodificador. - pad_token_id (
int, opcional, valor predeterminado0) — Id del token utilizado para el relleno en el vocabulario. - eos_token_id (
Union[int, list[int]], opcional, valor predeterminado1) — Identificador de token utilizado para el fin de secuencia en el vocabulario. - dense_act_fn (
string, opcional, valor predeterminado"relu") — Tipo de función de activación que se utilizará enPop2PianoDenseActDensey enPop2PianoDenseGatedActDense. - is_decoder (
bool, opcional, valor predeterminadoFalse) — Indica si el modelo se utiliza como decodificador o no. Si esFalse, el modelo se utiliza como codificador. - tie_word_embeddings (
bool, opcional, valor predeterminadoTrue) — Si se deben vincular las matrices de pesos de embeddings según el mapeotied_weights_keysdel modelo.
Esta es la clase de configuración para almacenar la configuración de un Pop2PianoModel. Se utiliza para instanciar un modelo Pop2Piano según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de sweetcocoa/pop2piano
Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.
Pop2PianoFeatureExtractor
clase transformers.Pop2PianoFeatureExtractor
< source >( sampling_rate: int = 22050padding_value: int = 0window_size: int = 4096hop_length: int = 1024min_frequency: float = 10.0feature_size: int = 512num_bars: int = 2**kwargs )
Parámetros
- sampling_rate (
int, opcional, valor predeterminado 22050) — Frecuencia de muestreo objetivo de la señal de audio. Es la frecuencia de muestreo que se envía al modelo. - padding_value (
int, opcional, valor predeterminado 0) — Valor de relleno utilizado para rellenar el audio. Debe corresponder a silencios. - window_size (
int, opcional, valor predeterminado 4096) — Longitud de la ventana en muestras a la que se aplica la transformada de Fourier. - hop_length (
int, opcional, valor predeterminado 1024) — Tamaño del paso entre cada ventana de la forma de onda, en muestras. - min_frequency (
float, opcional, valor predeterminado 10.0) — Frecuencia mínima que se utilizará en el espectrograma log-mel. - feature_size (
int, opcional, valor predeterminado 512) — La dimensión de las características de las características extraídas. - num_bars (
int, opcional, valor predeterminado 2) — Determina el intervalo entre cada secuencia.
Construye un extractor de características Pop2Piano.
Este extractor de características hereda de SequenceFeatureExtractor, que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos.
Esta clase extrae el ritmo y preprocesa el audio antes de pasarlo al modelo. Primero, el audio se pasa al algoritmo RhythmExtractor2013, que extrae los beat_times, las posiciones de los beats y estima su confianza, así como el tempo en bpm. A continuación, beat_times se interpola para obtener beatsteps. Más tarde, calculamos extrapolated_beatsteps a partir de ello para usarlos en el tokenizer. Por otro lado, el audio se re-muestrea a self.sampling_rate y se preprocesa, y luego se calcula el espectrograma log mel a partir de él para usarlo en nuestro modelo transformer.
__call__
< source >( audio: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]sampling_rate: int | list[int]steps_per_beat: int = 2resample: bool | None = Truereturn_attention_mask: bool | None = Falsereturn_tensors: str | transformers.utils.generic.TensorType | None = None**kwargs )
Parámetros
- audio (
np.ndarray,List) — El audio o lote de audios a procesar. Cada audio puede ser un array de numpy, una lista de valores flotantes, una lista de arrays de numpy o una lista de listas de valores flotantes. - sampling_rate (
int) — La tasa de muestreo a la que se muestreó la entradaaudio. Se recomienda encarecidamente pasarsampling_rateen la llamada forward para evitar errores silenciosos. - steps_per_beat (
int, opcional, valor predeterminado 2) — Se utiliza para interpolarbeat_times. - resample (
bool, opcional, valor predeterminadoTrue) — Determina si se debe re-muestrear el audio asampling_rateantes de procesarlo. Debe ser True durante la inferencia. - return_attention_mask (
boolopcional, por defectoFalse) — Indica si se devolverá como salida la attention_mask para input_features, beatsteps y extrapolated_beatstep. Se establece automáticamente en True para entradas por lotes. - return_tensors (
stro TensorType, opcional) — Si se establece, devolverá tensores en lugar de una lista de enteros de Python. Los valores aceptables son:'pt': Devuelve objetostorch.Tensorde PyTorch.'np': Devuelve objetos Numpynp.ndarray. Si no se especifica nada, devolverá una lista de matricesnp.ndarray.
Método principal para extraer características y preparar los datos para el modelo.
Pop2PianoForConditionalGeneration
clase transformers.Pop2PianoForConditionalGeneration
< source >( config: Pop2PianoConfig )
Parámetros
- config (Pop2PianoConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
Modelo Pop2Piano con una cabeza de language modeling en la parte superior.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.BoolTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneinput_features: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqLMOutput or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length)) — Índices de los tokens de la secuencia de entrada en el vocabulario. Pop2Piano es un modelo con incrustaciones de posición relativa, por lo que debería ser posible rellenar las entradas tanto a la derecha como a la izquierda. Los índices se pueden obtener utilizando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles. ¿Qué son los IDs de entrada? Para saber más sobre cómo prepararinput_idspara el preentrenamiento, eche un vistazo a Pop2Piano Training. - attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- decoder_input_ids (
torch.LongTensorde forma(batch_size, target_sequence_length), opcional) — Índices de los tokens de la secuencia de entrada del decodificador en el vocabulario. Los índices se pueden obtener utilizando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles. ¿Qué son los IDs de entrada del decodificador? Pop2Piano utilizapad_token_idcomo token inicial para la generación dedecoder_input_ids. Si se utilizapast_key_values, opcionalmente solo se deben introducir los últimosdecoder_input_ids(consultepast_key_values). Para saber más sobre cómo preparar - decoder_attention_mask (
torch.BoolTensorde forma(batch_size, target_sequence_length), opcional) — Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno endecoder_input_ids. También se usará una máscara causal de forma predeterminada. - encoder_outputs (
tuple[tuple[torch.Tensor]], opcional) — La tupla consiste en (last_hidden_state, opcional:hidden_states, opcional:attentions)last_hidden_statede forma(batch_size, sequence_length, hidden_size), opcional) es una secuencia de hidden-states en la salida de la última capa del codificador. Se utiliza en la atención cruzada del decodificador. - past_key_values (
~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en lapast_key_valuesdevuelta por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.use_cache=True.Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan
past_key_values, DynamicCache se inicializará de forma predeterminada.El modelo generará el mismo formato de caché que se proporciona como entrada.
Si se utilizan
past_key_values, se espera que el usuario introduzca únicamente losinput_idsno procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma(batch_size, unprocessed_length)en lugar de todos losinput_idscon forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - input_features (
torch.Tensorde forma(batch_size, sequence_length, feature_dim), opcional) — Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener utilizando Pop2PianoFeatureExtractor. Consulte Pop2PianoFeatureExtractor.call() para más detalles (Pop2PianoProcessor utiliza Pop2PianoFeatureExtractor para procesar los audios). - decoder_inputs_embeds (
torch.Tensorde forma(batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasardecoder_input_idspuede optar por pasar directamente una representación incrustada. Sipast_key_valuesse usa, opcionalmente solo la últimadecoder_inputs_embedsdebe ser introducida (verpast_key_values). Esto es útil si se desea tener más control sobre cómo convertirdecoder_input_idsíndices en vectores asociados que la matriz de búsqueda de incrustaciones interna del modelo.Si
decoder_input_idsydecoder_inputs_embedsno están configurados,decoder_inputs_embedstoma el valor deinputs_embeds. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para calcular la pérdida de clasificación/regresión de secuencia. Los índices deben estar en[-100, 0, ..., config.vocab_size - 1]. Todas las etiquetas establecidas en-100se ignoran (se enmascaran); la pérdida solo se calcula para etiquetas en[0, ..., config.vocab_size] - use_cache (
bool, opcional) — Si se establece enTrue, se devuelven los estados de clave-valor depast_key_valuesy pueden usarse para acelerar la decodificación (verpast_key_values).
Devuelve
Seq2SeqLMOutput o tuple(torch.Tensor)
Un Seq2SeqLMOutput o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (Pop2PianoConfig) y las entradas.
El método forward de Pop2PianoForConditionalGeneration sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de modelado de lenguaje.logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).past_key_values (
EncoderDecoderCache, opcional, se devuelve cuando se pasause_cache=Trueo cuandoconfig.use_cache=True) — Es una instancia de EncoderDecoderCache. Para más detalles, consulte nuestra guía de caché kv.Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que pueden utilizarse (véase la entrada
past_key_values) para acelerar la decodificación secuencial.decoder_hidden_states (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del decodificador en la salida de cada capa más las salidas de la incrustación inicial.
decoder_attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
cross_attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
encoder_last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.encoder_hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del codificador en la salida de cada capa más las salidas de la incrustación inicial.
encoder_attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplo:
>>> 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
< source >( input_featuresattention_mask = Nonecomposer = 'composer1'generation_config = None**kwargs ) → ModelOutput or torch.LongTensor
Parámetros
- input_features (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Esta es la versión con características del audio generada porPop2PianoFeatureExtractor. - attention_mask —
Para la generación por lotes
input_featuresse rellenan para tener la misma forma en todos los ejemplos.attention_maskayuda a determinar qué áreas se rellenaron y cuáles no.- 1 para los tokens que no están rellenos,
- 0 para los tokens que están rellenados.
- composer (
str, opcional, valor predeterminado"composer1") — Este valor se pasa aPop2PianoConcatEmbeddingToMelpara generar diferentes embeddings para cada"composer". Asegúrese de que el valor de composer esté presente encomposer_to_feature_tokenengeneration_config. Para un ejemplo, consulte https://huggingface.co/sweetcocoa/pop2piano/blob/main/generation_config.json . - generation_config (
~generation.GenerationConfig, opcional) — La configuración de generación que se utilizará como parametrización base para la llamada de generación. Los**kwargspasados a generate que coincidan con los atributos degeneration_configlos sobrescribirán. Si no se proporcionageneration_config, se utilizará la predeterminada, que tiene la siguiente prioridad de carga: 1) desde el archivo de modelogeneration_config.json, si existe; 2) desde la configuración del modelo. Tenga en cuenta que los parámetros no especificados heredarán los valores predeterminados de GenerationConfig, cuya documentación debe consultarse para parametrizar la generación. - kwargs —
Parametrización ad hoc de
generate_configy/o kwargs adicionales específicos del modelo que se reenviarán a la funciónforwarddel modelo. Si el modelo es un modelo encoder-decoder, los kwargs específicos del encoder no deben tener prefijo y los kwargs específicos del decoder deben tener el prefijo decoder_.
Devuelve
ModelOutput o torch.LongTensor
Un ModelOutput (si return_dict_in_generate=True
o cuando config.return_dict_in_generate=True) o un torch.Tensor.
Dado que Pop2Piano es un modelo encoder-decoder (model.config.is_encoder_decoder=True), los tipos
de ModelOutput posibles son:
Genera ids de tokens para las salidas midi.
La mayoría de los parámetros de control de generación se configuran en
generation_config, que, si no se pasa, se establecerá en la configuración de generación predeterminada del modelo. Puede invalidar cualquiergeneration_configpasando los parámetros correspondientes a generate(), por ejemplo,.generate(inputs, num_beams=4, do_sample=True). Para una visión general de las estrategias de generación y ejemplos de código, consulte la siguiente guía.
Pop2PianoTokenizer
clase transformers.Pop2PianoTokenizer
< source >( vocabdefault_velocity = 77num_bars = 2unk_token = '-1'eos_token = '1'pad_token = '0'bos_token = '2'**kwargs )
Parámetros
- vocab (
str) — Ruta al archivo de vocabulario que contiene el vocabulario. - default_velocity (
int, opcional, valor predeterminado 77) — Determina la velocidad predeterminada que se utilizará al crear notas midi. - num_bars (
int, opcional, valor predeterminado 2) — Determina cutoff_time_idx para cada token. - unk_token (
strotokenizers.AddedToken, opcional, valor predeterminado"-1") — El token desconocido. Un token que no está en el vocabulario no se puede convertir en un ID y se establece como este token en su lugar. - eos_token (
strotokenizers.AddedToken, opcional, valor predeterminado 1) — El token de fin de secuencia. - pad_token (
strotokenizers.AddedToken, opcional, valor predeterminado 0) — Un token especial utilizado para que los arreglos de tokens tengan el mismo tamaño con fines de lote. Luego será ignorado por los mecanismos de atención o el cálculo de la pérdida. - bos_token (
strotokenizers.AddedToken, opcional, valor predeterminado 2) — El token de inicio de secuencia que se utilizó durante el preentrenamiento. Puede usarse como token de clasificador de secuencias.
Construye un tokenizador Pop2Piano. Este tokenizador no requiere entrenamiento.
Este tokenizador hereda de PreTrainedTokenizer, que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos.
__call__
< source >( notes: numpy.ndarray | list[pretty_midi.Note] | list[list[pretty_midi.Note]]padding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonepad_to_multiple_of: int | None = Nonereturn_attention_mask: bool | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Noneverbose: bool = True**kwargs )
Parámetros
- notes (
numpy.ndarrayde forma[batch_size, max_sequence_length, 4]olistdepretty_midi.Noteobjetos) — Esto representa las notas MIDI.Si
noteses unnumpy.ndarray:- Cada secuencia debe tener 4 valores:
onset idx,offset idx,pitchyvelocity. Sinoteses unalistque contiene objetospretty_midi.Note: - Cada secuencia debe tener 4 atributos:
start,end,pitchyvelocity.
- Cada secuencia debe tener 4 valores:
- padding (
bool,stro PaddingStrategy, opcional, el valor predeterminado esFalse) — Activa y controla el padding. Acepta los siguientes valores:Trueo'longest': Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia).'max_length': Rellena hasta una longitud máxima especificada con el argumentomax_lengtho hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento.Falseo'do_not_pad'(predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de diferentes longitudes).
- truncation (
bool,stro TruncationStrategy, opcional, por defectoFalse) — Activa y controla la truncación. Acepta los siguientes valores:Trueo'longest_first': Trunca hasta una longitud máxima especificada con el argumentomax_lengtho hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto truncará token a token, eliminando un token de la secuencia más larga de la pareja si se proporciona una pareja de secuencias (o un lote de parejas).'only_first': Trunca a una longitud máxima especificada con el argumentomax_lengtho a la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la primera secuencia de un par si se proporciona un par de secuencias (o un lote de pares).'only_second': Trunca a una longitud máxima especificada con el argumentomax_lengtho a la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la segunda secuencia de un par si se proporciona un par de secuencias (o un lote de pares).Falseo'do_not_truncate'(predeterminado): sin truncamiento (es decir, se puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible por el modelo).
- max_length (
int, opcional) — Controla la longitud máxima que utilizará uno de los parámetros de truncamiento/relleno. Si se deja sin establecer o se establece enNone, se utilizará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno requiere una longitud máxima. Si el modelo no tiene una longitud de entrada máxima específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará. - pad_to_multiple_of (
int, opcional) — Si se establece, se rellenará la secuencia hasta un múltiplo del valor proporcionado. Esto es especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo>= 7.5(Volta). - return_attention_mask (
bool, opcional) — Si se debe devolver la máscara de atención. Si se deja en el valor predeterminado, se devolverá la máscara de atención según el valor predeterminado del tokenizador específico, definido por elreturn_outputsatributo. - return_tensors (
stro TensorType, opcional) — Si se establece, devolverá tensores en lugar de una lista de enteros de Python. Los valores aceptables son:'pt': Devuelve objetostorch.Tensorde PyTorch.'np': Devuelve objetos Numpynp.ndarray.
- verbose (
bool, opcional, valor predeterminadoTrue) — Si se imprime más información y advertencias.
Este es el método __call__ para Pop2PianoTokenizer. Convierte las notas midi en los ids de tokens generados por el transformer.
Pop2PianoProcessor
clase transformers.Pop2PianoProcessor
< source >( feature_extractortokenizer )
Construye un Pop2PianoProcessor que envuelve un extractor de características y un tokenizador en un único procesador.
Pop2PianoProcessor ofrece todas las funcionalidades de Pop2PianoFeatureExtractor y tokenizer_class. Consulte ~Pop2PianoFeatureExtractor y ~tokenizer_class para obtener más información.
__call__
< source >( audio: numpy.ndarray | list[float] | list[numpy.ndarray] = Nonesampling_rate: int | list[int] | None = Nonesteps_per_beat: int = 2resample: bool | None = Truenotes: list | transformers.utils.generic.TensorType = Nonepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy = Nonemax_length: int | None = Nonepad_to_multiple_of: int | None = Noneverbose: bool = True**kwargs )
Parámetros
- audio (
Union[numpy.ndarray, list[float], list[numpy.ndarray]], opcional) — El audio o lote de audios que se va a preparar. Cada audio puede ser un array de NumPy o un tensor de PyTorch. En el caso de un array de NumPy/tensor de PyTorch, cada audio debe tener la forma (C, T), donde C es el número de canales y T es la longitud de la muestra del audio. - sampling_rate (
intolist[int], opcional) — La tasa de muestreo del audio de entrada en Hz. Debe coincidir con la tasa de muestreo utilizada por el extractor de características. Si no se proporciona, se utilizará la tasa de muestreo predeterminada de la configuración del procesador. - steps_per_beat (
int, opcional, valor predeterminado2) — El número de pasos de tiempo por compás musical. Este parámetro controla la resolución temporal de la representación musical. Un valor más alto proporciona una granularidad temporal más fina, pero aumenta la longitud de la secuencia. Se utiliza al procesar audio para extraer características musicales. - resample (
bool, opcional, valor predeterminadoTrue) — Filtro de remuestreo a utilizar si se cambia el tamaño de la imagen. Puede ser uno de los valores de la enumeraciónPILImageResampling. Solo tiene efecto sido_resizeestá establecido enTrue. - notes (
listoTensorType, opcional) — Notas musicales preextraídas en formato MIDI. Cuando se proporciona, el procesador omite la extracción de características de audio y procesa directamente las notas a través del tokenizador. Cada nota debe representarse como una lista o tensor que contenga información de tono, velocidad y temporización. - padding (bool, str o PaddingStrategy, opcional, por defecto
False) — Activa y controla el padding. Acepta los siguientes valores:Trueo'longest': Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia).'max_length': Rellena hasta una longitud máxima especificada con el argumentomax_lengtho hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento.Falseo'do_not_pad'(predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de diferentes longitudes).
- truncation (bool, str o TruncationStrategy, opcional) —
Activa y controla la truncación. Acepta los siguientes valores:
Trueo'longest_first': Trunca hasta una longitud máxima especificada con el argumentomax_lengtho hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto truncará token a token, eliminando un token de la secuencia más larga de la pareja si se proporciona una pareja de secuencias (o un lote de parejas).'only_first': Trunca a una longitud máxima especificada con el argumentomax_lengtho a la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la primera secuencia de un par si se proporciona un par de secuencias (o un lote de pares).'only_second': Trunca a una longitud máxima especificada con el argumentomax_lengtho a la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la segunda secuencia de un par si se proporciona un par de secuencias (o un lote de pares).Falseo'do_not_truncate'(predeterminado): sin truncamiento (es decir, se puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible por el modelo).
- max_length (
int, opcional) — Controla la longitud máxima que se utilizará mediante uno de los parámetros de truncamiento/relleno.Si se deja sin definir o se establece en
None, se utilizará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno lo requiere. Si el modelo no tiene una longitud máxima de entrada específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará. - pad_to_multiple_of (
int, opcional) — Si se establece, se rellenará la secuencia hasta un múltiplo del valor proporcionado. Requiere quepaddingesté activado. Esto es especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo>= 7.5(Volta). - verbose (
bool, opcional, valor predeterminadoTrue) — Si se imprime más información y advertencias. - return_tensors (
stro TensorType, opcional) — Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:'pt': Devuelve objetostorch.Tensorde PyTorch.'np': Devuelve objetosnp.ndarrayde NumPy.