Transformers documentation
Bark
Este modelo fue aportado a Hugging Face Transformers el 2023-07-17.
Bark
Resumen
Bark es un modelo de texto a voz basado en transformers propuesto por Suno AI en suno-ai/bark.
Bark está compuesto por 4 modelos principales:
- BarkSemanticModel (también conocido como el modelo de ‘texto’): un modelo transformer causal auto-regresivo que toma como entrada texto tokenizado y predice tokens semánticos de texto que capturan el significado del texto.
- BarkCoarseModel (también conocido como el modelo de ‘acústica gruesa’): un transformer autoregresivo causal que toma como entrada los resultados del modelo BarkSemanticModel. Su objetivo es predecir los dos primeros libros de códigos de audio necesarios para EnCodec.
- BarkFineModel (el modelo de «acústica fina»), esta vez un transformador autoencoder no causal, que predice iterativamente los últimos codebooks basándose en la suma de los embeddings de los codebooks anteriores.
- Tras haber predicho todos los canales del libro de códigos desde el EncodecModel, Bark lo utiliza para decodificar el array de audio de salida.
Cabe señalar que cada uno de los tres primeros módulos puede admitir embeddings de hablante condicional para condicionar el sonido de salida según una voz específica predefinida.
Este modelo fue aportado por Yoach Lacombe (ylacombe) y Sanchit Gandhi (sanchit-gandhi). El código original se puede encontrar aquí.
Optimización de Bark
Bark se puede optimizar con solo unas pocas líneas de código adicionales, lo que reduce significativamente su huella de memoria y acelera la inferencia.
Uso de precisión a mitad
Puede acelerar la inferencia y reducir la huella de memoria en un 50 % simplemente cargando el modelo en media precisión.
from transformers import BarkModel
model = BarkModel.from_pretrained("suno/bark-small", device_map="auto")Uso de CPU offload
Como se mencionó anteriormente, Bark está compuesto por 4 submodelos, que se invocan de forma secuencial durante la generación de audio. En otras palabras, mientras un submodelo está en uso, los demás submodelos permanecen inactivos.
Si estás usando una GPU CUDA o una XPU de Intel, una solución sencilla para beneficiarte de una reducción del 80 % en la huella de memoria es descargar los submodelos del dispositivo a la CPU cuando están inactivos. Esta operación se denomina CPU offloading. Puedes usarla con una sola línea de código, como se muestra a continuación:
model.enable_cpu_offload()
Tenga en cuenta que 🤗 Accelerate debe estar instalado antes de usar esta función. Así es como se instala.
Uso de Flash Attention 2
Flash Attention 2 es una versión aún más rápida y optimizada de la optimización anterior.
Instalación
Primero, compruebe si su hardware es compatible con Flash Attention 2. La lista más reciente de hardware compatible se encuentra en la documentación oficial. A continuación, instale la última versión de Flash Attention 2:
pip install -U flash-attn --no-build-isolation
Uso
Para cargar un modelo usando Flash Attention 2, podemos pasar la bandera attn_implementation="flash_attention_2" a from_pretrained(). También cargaremos el modelo en media precisión (p. ej. torch.float16), ya que esto produce una degradación casi nula en la calidad del audio pero un uso de memoria significativamente menor y una inferencia más rápida:
model = BarkModel.from_pretrained("suno/bark-small", attn_implementation="flash_attention_2", device_map="auto")Comparación de rendimiento
El siguiente diagrama muestra la latencia de la implementación nativa de atención (sin optimización) frente a Flash Attention 2. En todos los casos, generamos 400 tokens semánticos en una GPU A100 de 40 GB con PyTorch 2.1:
Para poner esto en perspectiva, en una NVIDIA A100 y al generar 400 tokens semánticos con un tamaño de lote de 16, se puede obtener un throughput 17 veces mayor y aun así ser 2 segundos más rápido que generar las oraciones una por una con la implementación nativa del modelo. En otras palabras, todas las muestras se generarán 17 veces más rápido.
Combinar técnicas de optimización
Puede combinar técnicas de optimización y usar CPU offload, precisión a mitad y Flash Attention 2 todas a la vez.
from transformers import BarkModel
# load in fp16 and use Flash Attention 2
model = BarkModel.from_pretrained("suno/bark-small", attn_implementation="flash_attention_2", device_map="auto")
# enable CPU offload
model.enable_cpu_offload()Obtenga más información sobre técnicas de optimización de inferencia aquí.
Consejos de uso
Suno ofrece una biblioteca de presets de voz en varios idiomas aquí. Estos presets también se suben al hub aquí o aquí.
from transformers import AutoProcessor, BarkModel
processor = AutoProcessor.from_pretrained("suno/bark")
model = BarkModel.from_pretrained("suno/bark", device_map="auto")
voice_preset = "v2/en_speaker_6"
inputs = processor("Hello, my dog is cute", voice_preset=voice_preset)
audio_array = model.generate(**inputs)
audio_array = audio_array.cpu().numpy().squeeze()Bark puede generar voz multilingüe altamente realista, así como otros audios, incluyendo música, ruido de fondo y efectos de sonido simples.
# Multilingual speech - simplified Chinese
inputs = processor("惊人的！我会说中文")
# Multilingual speech - French - let's use a voice_preset as well
inputs = processor("Incroyable! Je peux générer du son.", voice_preset="fr_speaker_5")
# Bark can also generate music. You can help it out by adding music notes around your lyrics.
inputs = processor("♪ Hello, my dog is cute ♪")
audio_array = model.generate(**inputs)
audio_array = audio_array.cpu().numpy().squeeze()El modelo también puede producir comunicaciones no verbales como reír, suspirar y llorar.
# Adding non-speech cues to the input text
inputs = processor("Hello uh [clears throat], my dog is cute [laughter]")
audio_array = model.generate(**inputs)
audio_array = audio_array.cpu().numpy().squeeze()Para guardar el audio, simplemente toma la tasa de muestreo de la configuración del modelo y usa alguna utilidad de scipy:
from scipy.io.wavfile import write as write_wav
# save audio to disk, but first take the sample rate from the model config
sample_rate = model.generation_config.sample_rate
write_wav("bark_generation.wav", sample_rate, audio_array)BarkConfig
clase transformers.BarkConfig
< 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 = 0is_encoder_decoder: bool = Falseid2label: 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 = Nonesemantic_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonecoarse_acoustics_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonefine_acoustics_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonecodec_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneinitializer_range: float = 0.02 )
Parámetros
- semantic_config (BarkSemanticConfig, opcional) — Configuración del submodelo semántico subyacente.
- coarse_acoustics_config (BarkCoarseConfig, opcional) — Configuración del submodelo de acústica gruesa subyacente.
- fine_acoustics_config (BarkFineConfig, opcional) — Configuración del submodelo de acústica fina subyacente.
- codec_config (AutoConfig, opcional) — Configuración del submodelo de codec subyacente.
- initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
Esta es la clase de configuración para almacenar la configuración de un BarkModel. Se utiliza para instanciar un modelo Bark 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 suno/bark
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.
Ejemplo:
>>> from transformers import (
... BarkSemanticConfig,
... BarkCoarseConfig,
... BarkFineConfig,
... BarkModel,
... BarkConfig,
... AutoConfig,
... )
>>> # Initializing Bark sub-modules configurations.
>>> semantic_config = BarkSemanticConfig()
>>> coarse_acoustics_config = BarkCoarseConfig()
>>> fine_acoustics_config = BarkFineConfig()
>>> codec_config = AutoConfig.from_pretrained("facebook/encodec_24khz")
>>> # Initializing a Bark module style configuration
>>> configuration = BarkConfig(
... semantic_config, coarse_acoustics_config, fine_acoustics_config, codec_config
... )
>>> # Initializing a model (with random weights)
>>> model = BarkModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configBarkProcessor
clase transformers.BarkProcessor
< source >( tokenizerspeaker_embeddings = None )
Parámetros
- tokenizer (
BertTokenizer) — El tokenizador es una entrada obligatoria. - speaker_embeddings (
dict[dict[str]], opcional) — Diccionario anidado opcional de embeddings de hablantes. El primer nivel contiene los nombres de los presets de voz (p. ej."en_speaker_4"). El segundo nivel contiene los embeddings de"semantic_prompt","coarse_prompt"y"fine_prompt". Los valores corresponden a la ruta delnp.ndarraycorrespondiente. Consulte aquí para obtener una lista devoice_preset_names.
Construye un BarkProcessor que envuelve un tokenizer en un único procesador.
BarkProcessor ofrece todas las funcionalidades de BertTokenizer. Consulte ~BertTokenizer para obtener más información.
__call__
< source >( text = Nonevoice_preset = Nonereturn_tensors = 'pt'max_length = 256add_special_tokens = Falsereturn_attention_mask = Truereturn_token_type_ids = False**kwargs ) → BatchEncoding
Parámetros
- text (`
) -- The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings (pretokenized string). If you pass a pretokenized input, setis_split_into_words=True` to avoid ambiguity with batched inputs. - voice_preset (
str,dict[np.ndarray]) — El preset de voz, es decir, los embeddings del hablante. Puede ser un nombre de voice_preset válido, por ejemplo"en_speaker_1", o directamente un diccionario de embeddingsnp.ndarraypara cada submodelo deBark. O bien, puede ser un nombre de archivo válido de un preset de voz local.npzque contenga las claves"semantic_prompt","coarse_prompt"y"fine_prompt". - return_tensors (`
, defaults topt`) — 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.
- max_length (
int, por defecto es256) — 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á. - add_special_tokens (
bool, por defectoFalse) — Indica si se deben o no añadir tokens especiales al codificar las secuencias. Esto utilizará la función subyacentePretrainedTokenizerBase.build_inputs_with_special_tokens, que define qué tokens se añaden automáticamente a los ids de entrada. Esto es útil si deseas añadir automáticamente tokensbosoeos. - return_attention_mask (
bool, por defectoTrue) — Si se devuelve 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_token_type_ids (
bool, por defecto esFalse) — Si se devuelve los IDs de tipo de token. Si se deja en el valor predeterminado, se devolverán los IDs de tipo de token según el valor predeterminado del tokenizador específico, definido por el atributoreturn_outputs.
Devuelve
Un objeto BatchEncoding que contiene la salida del tokenizer.
Si se proporciona un preset de voz, el objeto devuelto incluirá una clave "history_prompt"
que contiene un BatchFeature, es decir, el preset de voz con el tipo de tensores correcto.
from_pretrained
< source >( pretrained_processor_name_or_pathspeaker_embeddings_dict_path = 'speaker_embeddings_path.json'**kwargs )
Parámetros
- pretrained_model_name_or_path (
stroos.PathLike) — Puede ser:- una cadena, el model id de un BarkProcessor preentrenado alojado en un repositorio de modelos en huggingface.co.
- una ruta a un directorio que contiene un procesador guardado usando el método save_pretrained(), por ejemplo,
./my_model_directory/.
- speaker_embeddings_dict_path (
str, opcional, por defecto"speaker_embeddings_path.json") — El nombre del archivo.jsonque contiene el diccionario speaker_embeddings, ubicado enpretrained_model_name_or_path. Si esNone, no se carga speaker_embeddings. - **kwargs —
Argumentos de palabra clave adicionales que se pasan a
~tokenization_utils_base.PreTrainedTokenizer.from_pretrained.
Instanciar un procesador de Bark asociado a un modelo preentrenado.
save_pretrained
< source >( save_directoryspeaker_embeddings_dict_path = 'speaker_embeddings_path.json'speaker_embeddings_directory = 'speaker_embeddings'push_to_hub: bool = False**kwargs )
Parámetros
- save_directory (
stroos.PathLike) — Directorio donde se guardarán los archivos del tokenizador y las incrustaciones de hablante (el directorio se creará si no existe). - speaker_embeddings_dict_path (
str, opcional, por defecto"speaker_embeddings_path.json") — El nombre del archivo.jsonque contendrá el diccionario de rutas anidadas de speaker_embeddings, si existe, y que se ubicará enpretrained_model_name_or_path/speaker_embeddings_directory. - speaker_embeddings_directory (
str, opcional, por defecto"speaker_embeddings/") — El nombre de la carpeta en la que se guardarán los arrays de speaker_embeddings. - push_to_hub (
bool, opcional, valor predeterminadoFalse) — Indica si se debe subir el modelo al hub de modelos de Hugging Face después de guardarlo. Puedes especificar el repositorio al que deseas subirlo conrepo_id(por defecto, usará el nombre desave_directoryen tu espacio de nombres). - kwargs — Argumentos de palabra clave adicionales que se pasan al método push_to_hub().
Guarda los atributos de este procesador (tokenizador…) en el directorio especificado para que pueda recargarse utilizando el método from_pretrained().
BarkModel
clase transformers.BarkModel
< source >( config: BarkConfig )
Parámetros
- config (BarkConfig) — 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.
El modelo completo de Bark, un modelo de texto a voz compuesto por 4 submodelos:
- BarkSemanticModel (también conocido como el modelo de ‘texto’): un modelo transformer causal auto-regresivo que toma como entrada texto tokenizado y predice tokens semánticos de texto que capturan el significado del texto.
- BarkCoarseModel (también conocido como el modelo de ‘acústica gruesa’), también un transformer autoregresivo causal,
que toma como entrada los resultados del modelo anterior. Su objetivo es regresar los dos primeros libros de códigos de audio necesarios
para
encodec. - BarkFineModel (el modelo de ‘acústica fina’), esta vez un transformador autoencoder no causal, que predice iterativamente los últimos codebooks basándose en la suma de los embeddings de los codebooks anteriores.
- tras haber predicho todos los canales del libro de códigos desde el EncodecModel, Bark lo utiliza para decodificar el array de audio de salida.
Cabe señalar que cada uno de los tres primeros módulos puede admitir embeddings de hablante condicional para condicionar el sonido de salida según una voz predefinida específica.
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.
generate
< source >( input_ids: typing.Optional[torch.Tensor] = Nonehistory_prompt: dict[str, torch.Tensor] | None = Nonereturn_output_lengths: bool | None = None**kwargs ) → By default
Parámetros
- input_ids (
Optional[torch.Tensor]de forma (batch_size, seq_len), opcional) — ids de entrada. Se truncarán hasta 256 tokens. Ten en cuenta que los audios de salida tendrán la misma longitud que la generación más larga del lote. - history_prompt (
Optional[dict[str,torch.Tensor]], opcional) — Prompt de orador deBarkopcional. Tenga en cuenta que, por ahora, este modelo solo admite un prompt de orador por lote. - kwargs (opcional) — Diccionario restante de argumentos de palabra clave. Los argumentos de palabra clave son de dos tipos:
- Sin un prefijo, se introducirán como
**kwargspara el métodogeneratede cada submodelo. - Con un prefijo semantic_, coarse_, fine_, se utilizarán como entrada para el método
generatede la semántica, la gruesa y la fina, respectivamente. Tienen prioridad sobre las palabras clave sin prefijo.
Esto significa que, por ejemplo, puede especificar una estrategia de generación para todos los submodelos excepto uno.
- Sin un prefijo, se introducirán como
- return_output_lengths (
bool, opcional) — Indica si se deben devolver las longitudes de la forma de onda. Útil al procesar por lotes.
Devuelve
Por defecto
- audio_waveform (
torch.Tensorde forma (batch_size, seq_len)): Forma de onda de audio generada. Cuandoreturn_output_lengths=True: Devuelve una tupla compuesta por: - audio_waveform (
torch.Tensorde forma (batch_size, seq_len)): Forma de onda de audio generada. - output_lengths (
torch.Tensorde forma (batch_size)): La longitud de cada forma de onda en el lote
Genera audio a partir de un prompt de entrada y un prompt de orador de Bark adicional y opcional.
Ejemplo:
>>> from transformers import AutoProcessor, BarkModel
>>> processor = AutoProcessor.from_pretrained("suno/bark-small")
>>> model = BarkModel.from_pretrained("suno/bark-small")
>>> # To add a voice preset, you can pass `voice_preset` to `BarkProcessor.__call__(...)`
>>> voice_preset = "v2/en_speaker_6"
>>> inputs = processor("Hello, my dog is cute, I need him in my life", voice_preset=voice_preset)
>>> audio_array = model.generate(**inputs, semantic_max_new_tokens=100)
>>> audio_array = audio_array.cpu().numpy().squeeze()enable_cpu_offload
< source >( accelerator_id: int | None = 0**kwargs )
Descarga todos los submodelos a la CPU usando accelerate, reduciendo el uso de memoria con un bajo impacto en el rendimiento. Este método mueve un submodelo completo a la aceleradora a la vez cuando se utiliza, y el submodelo permanece en la aceleradora hasta que se ejecuta el siguiente submodelo.
BarkSemanticModel
clase transformers.BarkSemanticModel
< source >( config: BarkSubModelConfig )
Parámetros
- config (
BarkSubModelConfig) — 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 semántico (o de texto) de Bark. Comparte la misma arquitectura que el modelo grueso. Es un modelo autoregresivo similar a GPT-2 con una cabeza de modelado de lenguaje 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.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → CausalLMOutputWithPast or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- 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). - 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.
- position_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en[0, ..., config.vocab_size]o ser -100 (ver la docstring deinput_ids). Los tokens con índices establecidos en-100se ignoran (enmascarados); la pérdida solo se calcula para los tokens con etiquetas en[0, ..., config.vocab_size]. - 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. - 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). - output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.
Devuelve
CausalLMOutputWithPast o tuple(torch.Tensor)
Un CausalLMOutputWithPast 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 (BarkConfig) y las entradas.
El método forward de BarkCausalModel 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 (para la predicción del siguiente token).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 (
Cache, opcional, se devuelve cuando se pasause_cache=Trueo cuandoconfig.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que pueden utilizarse (véase la entrada
past_key_values) para acelerar la decodificación secuencial.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 modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
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 tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
BarkCoarseModel
clase transformers.BarkCoarseModel
< source >( config: BarkSubModelConfig )
Parámetros
- config (
BarkSubModelConfig) — 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 de acústica gruesa de Bark. Comparte la misma arquitectura que el modelo semántico (o de texto). Es un modelo autoregresivo similar a GPT-2 con una cabeza de modelado de lenguaje 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.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → CausalLMOutputWithPast or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- 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). - 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.
- position_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en[0, ..., config.vocab_size]o ser -100 (ver la docstring deinput_ids). Los tokens con índices establecidos en-100se ignoran (enmascarados); la pérdida solo se calcula para los tokens con etiquetas en[0, ..., config.vocab_size]. - 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. - 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). - output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.
Devuelve
CausalLMOutputWithPast o tuple(torch.Tensor)
Un CausalLMOutputWithPast 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 (BarkConfig) y las entradas.
El método forward de BarkCausalModel 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 (para la predicción del siguiente token).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 (
Cache, opcional, se devuelve cuando se pasause_cache=Trueo cuandoconfig.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que pueden utilizarse (véase la entrada
past_key_values) para acelerar la decodificación secuencial.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 modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
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 tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
BarkFineModel
clase transformers.BarkFineModel
< source >( config: BarkFineConfig )
Parámetros
- config (BarkFineConfig) — 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 de acústicas finas de Bark. Es un modelo no causal similar a GPT con config.n_codes_total capas de embedding y cabezas de modelado de lenguaje, una para cada codebook.
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 >( codebook_idx: intinput_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → MaskedLMOutput or tuple(torch.Tensor)
Parámetros
- codebook_idx (
int) — Índice del codebook que se predecirá. - input_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- 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.
- position_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — AÚN NO IMPLEMENTADO. - 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. - output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.
Devuelve
MaskedLMOutput o tuple(torch.Tensor)
Un MaskedLMOutput 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 (BarkConfig) y las entradas.
El método forward de BarkFineModel reemplaza 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 enmascarado (MLM).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).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 modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
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 tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
BarkCausalModel
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → CausalLMOutputWithPast or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- 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). - 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.
- position_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en[0, ..., config.vocab_size]o ser -100 (ver la docstring deinput_ids). Los tokens con índices establecidos en-100se ignoran (enmascarados); la pérdida solo se calcula para los tokens con etiquetas en[0, ..., config.vocab_size]. - 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. - 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). - output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.
Devuelve
CausalLMOutputWithPast o tuple(torch.Tensor)
Un CausalLMOutputWithPast 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 (BarkConfig) y las entradas.
El método forward de BarkCausalModel 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 (para la predicción del siguiente token).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 (
Cache, opcional, se devuelve cuando se pasause_cache=Trueo cuandoconfig.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que pueden utilizarse (véase la entrada
past_key_values) para acelerar la decodificación secuencial.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 modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
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 tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
BarkCoarseConfig
clase transformers.BarkCoarseConfig
< 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 = 0is_encoder_decoder: bool = Falseid2label: 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 = Noneblock_size: int = 1024input_vocab_size: int = 10048output_vocab_size: int = 10048num_layers: int = 12num_heads: int = 12hidden_size: int = 768dropout: float | int = 0.0bias: bool = Trueinitializer_range: float = 0.02use_cache: bool = True )
Parámetros
- block_size (
int, opcional, valor predeterminado 1024) — La longitud máxima de secuencia con la que podría usarse este modelo. Normalmente, se establece en un valor grande por si acaso (p. ej., 512 o 1024 o 2048). - input_vocab_size (
int, opcional, valor predeterminado 10_048) — Tamaño del vocabulario de un submodelo de Bark. Define el número de tokens diferentes que pueden representarse mediante losinputs_idsque se pasan al llamar a{model}. El valor predeterminado es 10_048, pero debe elegirse con cuidado en función del submodelo seleccionado. - output_vocab_size (
int, opcional, valor predeterminado 10_048) — Tamaño del vocabulario de salida de un submodelo de Bark. Define el número de tokens diferentes que pueden ser representados por:output_idsal pasar un{model}hacia adelante. El valor predeterminado es 10_048, pero debe pensarse cuidadosamente en relación con el submodelo elegido. - num_layers (
int, opcional, valor predeterminado12) — Número de capas ocultas en el decodificador del Transformer. - num_heads (
int, opcional, valor predeterminado12) — Número de cabezas de atención para cada capa de atención en el decodificador del Transformer. - hidden_size (
int, opcional, valor predeterminado768) — Dimensión de las representaciones ocultas. - dropout (
Union[float, int], opcional, valor predeterminado0.0) — La proporción para todas las capas de dropout. - bias (
bool, opcional, valor predeterminadoTrue) — Si se usa o no sesgo en las capas lineales y en las capas de normalización de capa - initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - 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.
Esta es la clase de configuración para almacenar la configuración de un BarkModel. Se utiliza para instanciar un modelo Bark 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 suno/bark
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.
Ejemplo:
>>> from transformers import BarkCoarseConfig, BarkCoarseModel
>>> # Initializing a Bark sub-module style configuration
>>> configuration = BarkCoarseConfig()
>>> # Initializing a model (with random weights) from the suno/bark style configuration
>>> model = BarkCoarseModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configBarkFineConfig
clase transformers.BarkFineConfig
< 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 = 0is_encoder_decoder: bool = Falseid2label: 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 = Noneblock_size: int = 1024input_vocab_size: int = 10048output_vocab_size: int = 10048num_layers: int = 12num_heads: int = 12hidden_size: int = 768dropout: float | int = 0.0bias: bool = Trueinitializer_range: float = 0.02use_cache: bool = Truetie_word_embeddings: bool = Truen_codes_total: int = 8n_codes_given: int = 1 )
Parámetros
- block_size (
int, opcional, valor predeterminado 1024) — La longitud máxima de secuencia con la que podría usarse este modelo. Normalmente, se establece en un valor grande por si acaso (p. ej., 512 o 1024 o 2048). - input_vocab_size (
int, opcional, valor predeterminado 10_048) — Tamaño del vocabulario de un submodelo de Bark. Define el número de tokens diferentes que pueden representarse mediante losinputs_idsque se pasan al llamar a{model}. El valor predeterminado es 10_048, pero debe elegirse con cuidado en función del submodelo seleccionado. - output_vocab_size (
int, opcional, valor predeterminado 10_048) — Tamaño del vocabulario de salida de un submodelo de Bark. Define el número de tokens diferentes que pueden ser representados por:output_idsal pasar un{model}hacia adelante. El valor predeterminado es 10_048, pero debe pensarse cuidadosamente en relación con el submodelo elegido. - num_layers (
int, opcional, valor predeterminado12) — Número de capas ocultas en el decodificador del Transformer. - num_heads (
int, opcional, valor predeterminado12) — Número de cabezas de atención para cada capa de atención en el decodificador del Transformer. - hidden_size (
int, opcional, valor predeterminado768) — Dimensión de las representaciones ocultas. - dropout (
Union[float, int], opcional, valor predeterminado0.0) — La proporción para todas las capas de dropout. - bias (
bool, opcional, valor predeterminadoTrue) — Si se usa o no sesgo en las capas lineales y en las capas de normalización de capa - initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - 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. - tie_word_embeddings (
bool, opcional, valor predeterminadoTrue) — Si se deben vincular las matrices de pesos de embeddings según el mapeotied_weights_keysdel modelo. - n_codes_total (
int, opcional, valor predeterminado 8) — El número total de libros de códigos de audio predichos. Se utiliza en el submodelo de acústica fina. - n_codes_given (
int, opcional, valor predeterminado 1) — El número de libros de códigos de audio predichos en el submodelo de acústica gruesa. Se utiliza en los submodelos de acústica.
Esta es la clase de configuración para almacenar la configuración de un BarkModel. Se utiliza para instanciar un modelo Bark 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 suno/bark
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.
Ejemplo:
>>> from transformers import BarkFineConfig, BarkFineModel
>>> # Initializing a Bark sub-module style configuration
>>> configuration = BarkFineConfig()
>>> # Initializing a model (with random weights) from the suno/bark style configuration
>>> model = BarkFineModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configBarkSemanticConfig
clase transformers.BarkSemanticConfig
< 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 = 0is_encoder_decoder: bool = Falseid2label: 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 = Noneblock_size: int = 1024input_vocab_size: int = 10048output_vocab_size: int = 10048num_layers: int = 12num_heads: int = 12hidden_size: int = 768dropout: float | int = 0.0bias: bool = Trueinitializer_range: float = 0.02use_cache: bool = True )
Parámetros
- block_size (
int, opcional, valor predeterminado 1024) — La longitud máxima de secuencia con la que podría usarse este modelo. Normalmente, se establece en un valor grande por si acaso (p. ej., 512 o 1024 o 2048). - input_vocab_size (
int, opcional, valor predeterminado 10_048) — Tamaño del vocabulario de un submodelo de Bark. Define el número de tokens diferentes que pueden representarse mediante losinputs_idsque se pasan al llamar a{model}. El valor predeterminado es 10_048, pero debe elegirse con cuidado en función del submodelo seleccionado. - output_vocab_size (
int, opcional, valor predeterminado 10_048) — Tamaño del vocabulario de salida de un submodelo de Bark. Define el número de tokens diferentes que pueden ser representados por:output_idsal pasar un{model}hacia adelante. El valor predeterminado es 10_048, pero debe pensarse cuidadosamente en relación con el submodelo elegido. - num_layers (
int, opcional, valor predeterminado12) — Número de capas ocultas en el decodificador del Transformer. - num_heads (
int, opcional, valor predeterminado12) — Número de cabezas de atención para cada capa de atención en el decodificador del Transformer. - hidden_size (
int, opcional, valor predeterminado768) — Dimensión de las representaciones ocultas. - dropout (
Union[float, int], opcional, valor predeterminado0.0) — La proporción para todas las capas de dropout. - bias (
bool, opcional, valor predeterminadoTrue) — Si se usa o no sesgo en las capas lineales y en las capas de normalización de capa - initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - 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.
Esta es la clase de configuración para almacenar la configuración de un BarkModel. Se utiliza para instanciar un modelo Bark 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 suno/bark
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.
Ejemplo:
>>> from transformers import BarkSemanticConfig, BarkSemanticModel
>>> # Initializing a Bark sub-module style configuration
>>> configuration = BarkSemanticConfig()
>>> # Initializing a model (with random weights) from the suno/bark style configuration
>>> model = BarkSemanticModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config