Transformers documentation
Bark
Ce modèle a été contribué à Hugging Face Transformers le 2023-07-17.
Bark
Aperçu
Bark est un modèle de synthèse vocale basé sur des transformers, proposé par Suno AI dans suno-ai/bark.
Bark est composé de 4 modèles principaux :
- BarkSemanticModel (également appelé modèle « texte ») : un modèle transformer causal auto-régressif qui prend en entrée du texte tokenisé et prédit des jetons de texte sémantiques qui capturent le sens du texte.
- BarkCoarseModel (également appelé modèle « acoustique grossière ») : un transformer autorégressif causal qui prend en entrée les résultats du modèle BarkSemanticModel. Il vise à prédire les deux premiers codebooks audio nécessaires pour EnCodec.
- BarkFineModel (le modèle « fine acoustics »), cette fois-ci un transformateur auto-encodeur non causal, qui prédit itérativement les derniers codebooks à partir de la somme des embeddings des codebooks précédents.
- Après avoir prédit tous les canaux du codebook à partir du EncodecModel, Bark l’utilise pour décoder le tableau de sortie audio.
Il convient de noter que chacun des trois premiers modules peut prendre en charge des embeddings de locuteur conditionnels afin de conditionner le son de sortie en fonction d'une voix prédéfinie spécifique.
Ce modèle a été contribué par Yoach Lacombe (ylacombe) et Sanchit Gandhi (sanchit-gandhi). Le code d'origine peut être trouvé ici.
Optimiser Bark
Bark peut être optimisé avec seulement quelques lignes de code supplémentaires, ce qui réduit considérablement son empreinte mémoire et accélère l'inférence.
Utilisation de la demi-précision
Vous pouvez accélérer l'inférence et réduire l'empreinte mémoire de 50 % simplement en chargeant le modèle en demi-précision.
from transformers import BarkModel
model = BarkModel.from_pretrained("suno/bark-small", device_map="auto")Utilisation du déchargement sur CPU
Comme mentionné ci-dessus, Bark est composé de 4 sous-modèles, qui sont appelés séquentiellement lors de la génération audio. Autrement dit, pendant qu'un sous-modèle est utilisé, les autres sous-modèles sont inactifs.
Si vous utilisez un GPU CUDA ou un XPU Intel, une solution simple pour bénéficier d’une réduction de 80 % de l’empreinte mémoire consiste à décharger les sous-modèles de l’appareil vers le CPU lorsqu’ils sont inactifs. Cette opération est appelée déchargement CPU. Vous pouvez l’utiliser avec une seule ligne de code comme suit :
model.enable_cpu_offload()
Notez que 🤗 Accelerate doit être installé avant d'utiliser cette fonctionnalité. Voici comment l'installer.
Utilisation de Flash Attention 2
Flash Attention 2 est une version encore plus rapide et optimisée de l'optimisation précédente.
Installation
Vérifiez d'abord si votre matériel est compatible avec Flash Attention 2. La liste la plus récente des matériels compatibles se trouve dans la documentation officielle. Ensuite, installez la dernière version de Flash Attention 2 :
pip install -U flash-attn --no-build-isolation
Utilisation
Pour charger un modèle en utilisant Flash Attention 2, nous pouvons passer le drapeau attn_implementation="flash_attention_2" à from_pretrained(). Nous chargerons également le modèle en demi-précision (par exemple torch.float16), car cela entraîne une dégradation quasi nulle de la qualité audio, mais une consommation mémoire nettement plus faible et une inférence plus rapide :
model = BarkModel.from_pretrained("suno/bark-small", attn_implementation="flash_attention_2", device_map="auto")Comparaison des performances
Le diagramme suivant montre la latence de l’implémentation native de l’attention (sans optimisation) par rapport à Flash Attention 2. Dans tous les cas, nous générons 400 jetons sémantiques sur un GPU A100 de 40 Go avec PyTorch 2.1 :
Pour situer les choses, sur une NVIDIA A100 et en générant 400 jetons sémantiques avec une taille de lot de 16, vous pouvez obtenir un débit 17 fois supérieur et être encore 2 secondes plus rapide que la génération de phrases une par une avec l’implémentation native du modèle. Autrement dit, tous les échantillons seront générés 17 fois plus vite.
Combinaison des techniques d’optimisation
Vous pouvez combiner les techniques d’optimisation et utiliser le déchargement sur CPU, la demi-précision et Flash Attention 2 simultanément.
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()En savoir plus sur les techniques d’optimisation de l’inférence ici.
Conseils d'utilisation
Suno propose une bibliothèque de préréglages vocaux dans plusieurs langues ici. Ces préréglages sont également téléversés sur le hub ici ou ici.
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 peut générer une parole multilingue très réaliste ainsi que d'autres types d'audio, y compris de la musique, des bruits de fond et des effets sonores 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()Le modèle peut également produire des communications non verbales comme des rires, des soupirs et des pleurs.
# 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()Pour enregistrer l'audio, il suffit de récupérer le taux d'échantillonnage depuis la configuration du modèle et d'utiliser quelques utilitaires 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
classe 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 )
Paramètres
- semantic_config (BarkSemanticConfig, facultatif) — Configuration du sous-modèle sémantique sous-jacent.
- coarse_acoustics_config (BarkCoarseConfig, facultatif) — Configuration du sous-modèle acoustique grossier sous-jacent.
- fine_acoustics_config (BarkFineConfig, facultatif) — Configuration du sous-modèle d’acoustique fine sous-jacent.
- codec_config (AutoConfig, facultatif) — Configuration du sous-modèle de codec sous-jacent.
- initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
Ceci est la classe de configuration destinée à stocker la configuration d'un BarkModel. Elle est utilisée pour instancier un modèle Bark en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de suno/bark
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
Exemple :
>>> 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
classe transformers.BarkProcessor
< source >( tokenizerspeaker_embeddings = None )
Paramètres
- tokenizer (
BertTokenizer) — Le tokenizer est une entrée obligatoire. - speaker_embeddings (
dict[dict[str]], facultatif) — Dictionnaire imbriqué facultatif des embeddings de locuteur. Le premier niveau contient les noms de préréglages vocaux (par ex."en_speaker_4"). Le second niveau contient les embeddings"semantic_prompt","coarse_prompt"et"fine_prompt". Les valeurs correspondent au chemin de l'np.ndarraycorrespondant. Voir ici pour une liste desvoice_preset_names.
Construit un BarkProcessor qui encapsule un tokenizer dans un processeur unique.
BarkProcessor propose toutes les fonctionnalités de BertTokenizer. Consultez la documentation de ~BertTokenizer pour plus d’informations.
__call__
< source >( text = Nonevoice_preset = Nonereturn_tensors = 'pt'max_length = 256add_special_tokens = Falsereturn_attention_mask = Truereturn_token_type_ids = False**kwargs ) → BatchEncoding
Paramètres
- 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]) — Le préréglage vocal, c’est-à-dire les embeddings du locuteur. Il peut s’agir soit d’un nom de voice_preset valide, par exemple"en_speaker_1", soit directement d’un dictionnaire d’embeddingsnp.ndarraypour chaque sous-modèle deBark. Ou bien il peut s’agir d’un nom de fichier valide d’un préréglage vocal local unique au format.npzcontenant les clés"semantic_prompt","coarse_prompt"et"fine_prompt". - return_tensors (`
, defaults topt`) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptables sont :'pt': Renvoie des objetstorch.Tensorde PyTorch.'np': Renvoie des objets NumPynp.ndarray.
- max_length (
int, défaut :256) — Contrôle la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage.Si non défini ou défini sur
None, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/le remplissage à une longueur maximale sera désactivé. - add_special_tokens (
bool, par défautFalse) — Indique s'il faut ajouter des jetons spéciaux lors de l'encodage des séquences. Cela utilise la fonction sous-jacentePretrainedTokenizerBase.build_inputs_with_special_tokens, qui définit les jetons ajoutés automatiquement aux identifiants d'entrée. Cela est utile si vous souhaitez ajouter automatiquement des jetonsbosoueos. - return_attention_mask (
bool, par défautTrue) — Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du tokenizer spécifique, définie par l'attributreturn_outputs. - return_token_type_ids (
bool, par défautFalse) — Indique s'il faut renvoyer les identifiants de type de jeton. Si la valeur par défaut est conservée, les identifiants de type de jeton sont renvoyés selon la valeur par défaut du tokeniseur spécifique, définie par l'attributreturn_outputs.
Retourne
Un objet BatchEncoding contenant la sortie du tokenizer.
Si un préréglage vocal est fourni, l'objet retourné inclura une clé "history_prompt"
contenant un BatchFeature, c'est-à-dire le préréglage vocal avec le bon type de tenseurs.
from_pretrained
< source >( pretrained_processor_name_or_pathspeaker_embeddings_dict_path = 'speaker_embeddings_path.json'**kwargs )
Paramètres
- pretrained_model_name_or_path (
strouos.PathLike) — Cela peut être soit :- une chaîne de caractères, l'identifiant du modèle d'un BarkProcessor pré-entraîné hébergé dans un dépôt de modèles sur huggingface.co.
- un chemin vers un dossier contenant un processeur enregistré à l’aide de la méthode save_pretrained(), par exemple
./my_model_directory/.
- speaker_embeddings_dict_path (
str, facultatif, par défaut"speaker_embeddings_path.json") — Le nom du fichier.jsoncontenant le dictionnaire speaker_embeddings situé danspretrained_model_name_or_path. SiNone, aucun speaker_embeddings n’est chargé. - **kwargs —
Arguments supplémentaires passés à
~tokenization_utils_base.PreTrainedTokenizer.from_pretrained.
Instanciez un processeur Bark associé à un modèle pré-entraîné.
save_pretrained
< source >( save_directoryspeaker_embeddings_dict_path = 'speaker_embeddings_path.json'speaker_embeddings_directory = 'speaker_embeddings'push_to_hub: bool = False**kwargs )
Paramètres
- save_directory (
strouos.PathLike) — Répertoire où les fichiers du tokenizer et les embeddings des locuteurs seront enregistrés (le répertoire sera créé s'il n'existe pas). - speaker_embeddings_dict_path (
str, facultatif, par défaut"speaker_embeddings_path.json") — Le nom du fichier.jsonqui contiendra le dictionnaire de chemins imbriqués des speaker_embeddings, s’il existe, et qui sera situé danspretrained_model_name_or_path/speaker_embeddings_directory. - speaker_embeddings_directory (
str, facultatif, par défaut"speaker_embeddings/") — Le nom du dossier dans lequel les tableaux speaker_embeddings seront enregistrés. - push_to_hub (
bool, facultatif, par défautFalse) — Indique s'il faut ou non pousser votre modèle sur le hub de modèles Hugging Face après l'avoir enregistré. Vous pouvez spécifier le dépôt auquel vous souhaitez pousser avecrepo_id(par défaut, il s'agit du nom desave_directorydans votre espace de noms). - kwargs — Arguments supplémentaires passés à la méthode push_to_hub().
Enregistre les attributs de ce processeur (tokeniseur…) dans le répertoire spécifié afin qu’il puisse être rechargé à l’aide de la méthode from_pretrained().
BarkModel
classe transformers.BarkModel
< source >( config: BarkConfig )
Paramètres
- config (BarkConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle Bark complet, un modèle de synthèse vocale composé de 4 sous-modèles :
- BarkSemanticModel (également appelé modèle « texte ») : un modèle transformer causal auto-régressif qui prend en entrée du texte tokenisé et prédit des jetons de texte sémantiques qui capturent le sens du texte.
- BarkCoarseModel (également appelé modèle « coarse acoustics »), lui aussi un transformer autorégressif causal,
qui prend en entrée les résultats du modèle précédent. Il vise à régresser les deux premiers codebooks audio nécessaires
à
encodec. - BarkFineModel (le modèle « fine acoustics »), cette fois-ci un transformateur auto-encodeur non causal, qui prédit itérativement les derniers codebooks à partir de la somme des embeddings des codebooks précédents.
- après avoir prédit tous les canaux du codebook à partir du EncodecModel, Bark l’utilise pour décoder le tableau de sortie audio.
Il convient de noter que chacun des trois premiers modules peut prendre en charge des embeddings de locuteur conditionnels afin de conditionner le son de sortie en fonction d'une voix prédéfinie spécifique.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
generate
< source >( input_ids: typing.Optional[torch.Tensor] = Nonehistory_prompt: dict[str, torch.Tensor] | None = Nonereturn_output_lengths: bool | None = None**kwargs ) → By default
Paramètres
- input_ids (
Optional[torch.Tensor]de forme (batch_size, seq_len), facultatif) — Identifiants d’entrée. Seront tronqués à 256 jetons. Notez que les audios de sortie seront aussi longs que la génération la plus longue du lot. - history_prompt (
Optional[dict[str,torch.Tensor]], facultatif) — Prompt de locuteurBarkfacultatif. Notez que, pour l'instant, ce modèle n'accepte qu'un seul prompt de locuteur par lot. - kwargs (facultatif) — Dictionnaire restant des arguments par mot-clé. Les arguments par mot-clé sont de deux types :
- Sans préfixe, elles seront transmises en tant que
**kwargspour la méthodegeneratede chaque sous-modèle. - Avec un préfixe semantic_, coarse_, fine_, ils seront respectivement les entrées de la méthode
generatede la sémantique, du grossier et du fin. Ils ont la priorité sur les mots-clés sans préfixe.
Cela signifie que vous pouvez, par exemple, spécifier une stratégie de génération pour tous les sous-modèles sauf un.
- Sans préfixe, elles seront transmises en tant que
- return_output_lengths (
bool, facultatif) — Indique s'il faut ou non retourner les longueurs des formes d'onde. Utile lors du traitement par lots.
Retourne
Par défaut
- audio_waveform (
torch.Tensorde forme (batch_size, seq_len)) : Forme d’onde audio générée. Lorsquereturn_output_lengths=True: Retourne un tuple composé de : - audio_waveform (
torch.Tensorde forme (batch_size, seq_len)) : Forme d'onde audio générée. - output_lengths (
torch.Tensorde forme (batch_size)) : la longueur de chaque forme d'onde du lot
Génère de l’audio à partir d’un prompt d’entrée et d’un prompt de locuteur Bark supplémentaire facultatif.
Exemple :
>>> 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 )
Décharge tous les sous-modèles sur le CPU à l'aide de accelerate, réduisant ainsi l'utilisation de la mémoire avec un impact minimal sur les performances. Cette méthode déplace un sous-modèle entier à la fois vers l'accélérateur lorsqu'il est utilisé, et le sous-modèle reste sur l'accélérateur jusqu'à l'exécution du sous-modèle suivant.
BarkSemanticModel
classe transformers.BarkSemanticModel
< source >( config: BarkSubModelConfig )
Paramètres
- config (
BarkSubModelConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Modèle sémantique (ou texte) de Bark. Il partage la même architecture que le modèle grossier. C'est un modèle autorégressif de type GPT-2 avec une tête de modélisation de langage au sommet.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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)
Paramètres
- input_ids (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- position_ids (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.n_positions - 1]. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans[0, ..., config.vocab_size]ou -100 (voir la docstring deinput_ids). Les jetons dont l'indice est défini sur-100sont ignorés (masqués), la perte n'est calculée que pour les jetons dont l'étiquette est dans[0, ..., config.vocab_size]. - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values). - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous les tenseurs retournés pour plus de détails. - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
CausalLMOutputWithPast ou tuple(torch.Tensor)
Un CausalLMOutputWithPast ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (BarkConfig) et des entrées.
La méthode forward du BarkCausalModel redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).logits (
torch.Tensorde forme(batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).past_key_values (
Cache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés (voir l'entrée
past_key_values) pour accélérer le décodage séquentiel.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
BarkCoarseModel
classe transformers.BarkCoarseModel
< source >( config: BarkSubModelConfig )
Paramètres
- config (
BarkSubModelConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Modèle d'acoustique grossière de Bark. Il partage la même architecture que le modèle sémantique (ou texte). Il s'agit d'un modèle autorégressif de type GPT-2 avec une tête de modélisation de langage au sommet.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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)
Paramètres
- input_ids (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- position_ids (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.n_positions - 1]. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans[0, ..., config.vocab_size]ou -100 (voir la docstring deinput_ids). Les jetons dont l'indice est défini sur-100sont ignorés (masqués), la perte n'est calculée que pour les jetons dont l'étiquette est dans[0, ..., config.vocab_size]. - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values). - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous les tenseurs retournés pour plus de détails. - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
CausalLMOutputWithPast ou tuple(torch.Tensor)
Un CausalLMOutputWithPast ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (BarkConfig) et des entrées.
La méthode forward du BarkCausalModel redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).logits (
torch.Tensorde forme(batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).past_key_values (
Cache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés (voir l'entrée
past_key_values) pour accélérer le décodage séquentiel.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
BarkFineModel
classe transformers.BarkFineModel
< source >( config: BarkFineConfig )
Paramètres
- config (BarkFineConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Modèle d'acoustique fine de Bark. Il s'agit d'un modèle non causal de type GPT doté de config.n_codes_total couches d'incorporation et de têtes de modélisation du langage, une pour chaque codebook.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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)
Paramètres
- codebook_idx (
int) — Index du codebook qui sera prédit. - input_ids (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- position_ids (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.n_positions - 1]. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — PAS ENCORE IMPLÉMENTÉ. - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous les tenseurs retournés pour plus de détails. - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
MaskedLMOutput ou tuple(torch.Tensor)
Un MaskedLMOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (BarkConfig) et des entrées.
La méthode forward du modèle BarkFineModel redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation de langage masquée (MLM).logits (
torch.Tensorde forme(batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
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)
Paramètres
- input_ids (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- position_ids (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.n_positions - 1]. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans[0, ..., config.vocab_size]ou -100 (voir la docstring deinput_ids). Les jetons dont l'indice est défini sur-100sont ignorés (masqués), la perte n'est calculée que pour les jetons dont l'étiquette est dans[0, ..., config.vocab_size]. - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values). - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous les tenseurs retournés pour plus de détails. - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
CausalLMOutputWithPast ou tuple(torch.Tensor)
Un CausalLMOutputWithPast ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (BarkConfig) et des entrées.
La méthode forward du BarkCausalModel redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).logits (
torch.Tensorde forme(batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).past_key_values (
Cache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés (voir l'entrée
past_key_values) pour accélérer le décodage séquentiel.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
BarkCoarseConfig
classe 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 )
Paramètres
- block_size (
int, facultatif, par défaut 1024) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. Il est généralement recommandé de définir cette valeur sur un nombre élevé par précaution (par exemple, 512, 1024 ou 2048). - input_vocab_size (
int, facultatif, valeur par défaut 10_048) — Taille du vocabulaire d’un sous-modèle Bark. Définit le nombre de jetons différents qui peuvent être représentés par lesinputs_idspassés lors de l’appel de{model}. La valeur par défaut est 10_048, mais elle doit être choisie avec soin en fonction du sous-modèle sélectionné. - output_vocab_size (
int, facultatif, valeur par défaut 10_048) — Taille du vocabulaire de sortie d'un sous-modèle Bark. Définit le nombre de jetons différents qui peuvent être représentés par :output_idslors du passage en avant d'un{model}. La valeur par défaut est 10_048, mais elle doit être choisie avec soin en fonction du sous-modèle sélectionné. - num_layers (
int, facultatif, par défaut12) — Nombre de couches cachées dans le décodeur Transformer. - num_heads (
int, facultatif, valeur par défaut12) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - hidden_size (
int, facultatif, par défaut768) — Dimension des représentations cachées. - dropout (
Union[float, int], facultatif, par défaut0.0) — Le taux appliqué à toutes les couches de dropout. - bias (
bool, facultatif, par défautTrue) — Indique s'il faut utiliser un biais dans les couches linéaires et les couches de normalisation par couche - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - use_cache (
bool, facultatif, valeur par défautTrue) — Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). N’est pertinent que siconfig.is_decoder=Trueou si le modèle est un modèle génératif uniquement décodeur.
Ceci est la classe de configuration destinée à stocker la configuration d'un BarkModel. Elle est utilisée pour instancier un modèle Bark en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de suno/bark
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
Exemple :
>>> 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
classe 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 )
Paramètres
- block_size (
int, facultatif, par défaut 1024) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. Il est généralement recommandé de définir cette valeur sur un nombre élevé par précaution (par exemple, 512, 1024 ou 2048). - input_vocab_size (
int, facultatif, valeur par défaut 10_048) — Taille du vocabulaire d’un sous-modèle Bark. Définit le nombre de jetons différents qui peuvent être représentés par lesinputs_idspassés lors de l’appel de{model}. La valeur par défaut est 10_048, mais elle doit être choisie avec soin en fonction du sous-modèle sélectionné. - output_vocab_size (
int, facultatif, valeur par défaut 10_048) — Taille du vocabulaire de sortie d'un sous-modèle Bark. Définit le nombre de jetons différents qui peuvent être représentés par :output_idslors du passage en avant d'un{model}. La valeur par défaut est 10_048, mais elle doit être choisie avec soin en fonction du sous-modèle sélectionné. - num_layers (
int, facultatif, par défaut12) — Nombre de couches cachées dans le décodeur Transformer. - num_heads (
int, facultatif, valeur par défaut12) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - hidden_size (
int, facultatif, par défaut768) — Dimension des représentations cachées. - dropout (
Union[float, int], facultatif, par défaut0.0) — Le taux appliqué à toutes les couches de dropout. - bias (
bool, facultatif, par défautTrue) — Indique s'il faut utiliser un biais dans les couches linéaires et les couches de normalisation par couche - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - use_cache (
bool, facultatif, valeur par défautTrue) — Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). N’est pertinent que siconfig.is_decoder=Trueou si le modèle est un modèle génératif uniquement décodeur. - tie_word_embeddings (
bool, facultatif, par défautTrue) — Indique s'il faut lier les embeddings de poids selon la correspondancetied_weights_keysdu modèle. - n_codes_total (
int, facultatif, valeur par défaut 8) — Nombre total de codebooks audio prédits. Utilisé dans le sous-modèle d'acoustique fine. - n_codes_given (
int, facultatif, valeur par défaut 1) — Le nombre de codebooks audio prédits dans le sous-modèle d’acoustique grossière. Utilisé dans les sous-modèles d’acoustique.
Ceci est la classe de configuration destinée à stocker la configuration d'un BarkModel. Elle est utilisée pour instancier un modèle Bark en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de suno/bark
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
Exemple :
>>> 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
classe 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 )
Paramètres
- block_size (
int, facultatif, par défaut 1024) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. Il est généralement recommandé de définir cette valeur sur un nombre élevé par précaution (par exemple, 512, 1024 ou 2048). - input_vocab_size (
int, facultatif, valeur par défaut 10_048) — Taille du vocabulaire d’un sous-modèle Bark. Définit le nombre de jetons différents qui peuvent être représentés par lesinputs_idspassés lors de l’appel de{model}. La valeur par défaut est 10_048, mais elle doit être choisie avec soin en fonction du sous-modèle sélectionné. - output_vocab_size (
int, facultatif, valeur par défaut 10_048) — Taille du vocabulaire de sortie d'un sous-modèle Bark. Définit le nombre de jetons différents qui peuvent être représentés par :output_idslors du passage en avant d'un{model}. La valeur par défaut est 10_048, mais elle doit être choisie avec soin en fonction du sous-modèle sélectionné. - num_layers (
int, facultatif, par défaut12) — Nombre de couches cachées dans le décodeur Transformer. - num_heads (
int, facultatif, valeur par défaut12) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - hidden_size (
int, facultatif, par défaut768) — Dimension des représentations cachées. - dropout (
Union[float, int], facultatif, par défaut0.0) — Le taux appliqué à toutes les couches de dropout. - bias (
bool, facultatif, par défautTrue) — Indique s'il faut utiliser un biais dans les couches linéaires et les couches de normalisation par couche - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - use_cache (
bool, facultatif, valeur par défautTrue) — Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). N’est pertinent que siconfig.is_decoder=Trueou si le modèle est un modèle génératif uniquement décodeur.
Ceci est la classe de configuration destinée à stocker la configuration d'un BarkModel. Elle est utilisée pour instancier un modèle Bark en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de suno/bark
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
Exemple :
>>> 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