
     `i.                        d Z ddlmZ ddlmZ ddlmZmZ ddlm	Z	m
Z
  ej        e          ZdZ G d	 d
e          Z ee                    dd          d           G d de                      Z ee                    dd          d           G d de                      Z ee                    dd          d           G d de                      Z G d de          Zg dZdS )zBARK model configuration    )Optional   )PretrainedConfig)add_start_docstringslogging   )CONFIG_MAPPING
AutoConfiga
  
    This is the configuration class to store the configuration of a [`{model}`]. It is used to instantiate the model
    according to the specified arguments, defining the model architecture. Instantiating a configuration with the
    defaults will yield a similar configuration to that of the Bark [suno/bark](https://huggingface.co/suno/bark)
    architecture.

    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
    documentation from [`PretrainedConfig`] for more information.

    Args:
        block_size (`int`, *optional*, defaults to 1024):
            The maximum sequence length that this model might ever be used with. Typically set this to something large
            just in case (e.g., 512 or 1024 or 2048).
        input_vocab_size (`int`, *optional*, defaults to 10_048):
            Vocabulary size of a Bark sub-model. Defines the number of different tokens that can be represented by the
            `inputs_ids` passed when calling [`{model}`]. Defaults to 10_048 but should be carefully thought with
            regards to the chosen sub-model.
        output_vocab_size (`int`, *optional*, defaults to 10_048):
            Output vocabulary size of a Bark sub-model. Defines the number of different tokens that can be represented
            by the: `output_ids` when passing forward a [`{model}`]. Defaults to 10_048 but should be carefully thought
            with regards to the chosen sub-model.
        num_layers (`int`, *optional*, defaults to 12):
            Number of hidden layers in the given sub-model.
        num_heads (`int`, *optional*, defaults to 12):
            Number of attention heads for each attention layer in the Transformer architecture.
        hidden_size (`int`, *optional*, defaults to 768):
            Dimensionality of the "intermediate" (often named feed-forward) layer in the architecture.
        dropout (`float`, *optional*, defaults to 0.0):
            The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.
        bias (`bool`, *optional*, defaults to `True`):
            Whether or not to use bias in the linear layers and layer norm layers.
        initializer_range (`float`, *optional*, defaults to 0.02):
            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
        use_cache (`bool`, *optional*, defaults to `True`):
            Whether or not the model should return the last key/values attentions (not used by all models).
c                   H     e Zd ZdgZdddddZ	 	 	 	 	 	 	 	 	 	 d fd	Z xZS )BarkSubModelConfigpast_key_values	num_heads
num_layersinput_vocab_size
block_size)num_attention_headsnum_hidden_layers
vocab_sizewindow_size   @'                T{Gz?c                     || _         || _        || _        || _        || _        || _        || _        || _        |
| _        |	| _	         t                      j        di | d S )N )r   r   output_vocab_sizer   r   hidden_sizedropoutbias	use_cacheinitializer_rangesuper__init__)selfr   r   r   r   r   r   r    r!   r#   r"   kwargs	__class__s               /home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/transformers/models/bark/configuration_bark.pyr%   zBarkSubModelConfig.__init__K   sr     % 0!2$"&	"!2""6"""""    )
r   r   r   r   r   r   r   Tr   T)__name__
__module____qualname__keys_to_ignore_at_inferenceattribute_mapr%   __classcell__r(   s   @r)   r   r   A   s        #4"5  +)(#	 M  # # # # # # # # # #r*   r   BarkSemanticConfigBarkSemanticModel)configmodela  
    Example:

    ```python
    >>> 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
    ```c                       e Zd ZdZdZdS )r2   semanticsemantic_configNr+   r,   r-   
model_typebase_config_keyr   r*   r)   r2   r2   g   s        & J'OOOr*   BarkCoarseConfigBarkCoarseModela  
    Example:

    ```python
    >>> 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.config
    ```c                       e Zd ZdZdZdS )r<   coarse_acousticscoarse_acoustics_configNr9   r   r*   r)   r<   r<   ~   s        & $J/OOOr*   BarkFineConfigBarkFineModela   
        n_codes_total (`int`, *optional*, defaults to 8):
            The total number of audio codebooks predicted. Used in the fine acoustics sub-model.
        n_codes_given (`int`, *optional*, defaults to 1):
            The number of audio codebooks predicted in the coarse acoustics sub-model. Used in the acoustics
            sub-models.
    Example:

    ```python
    >>> 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.config
    ```c                   (     e Zd ZdZdZd fd	Z xZS )rA   fine_acousticsfine_acoustics_configT      c                 Z    || _         || _         t                      j        dd|i| d S )Ntie_word_embeddingsr   )n_codes_totaln_codes_givenr$   r%   )r&   rI   rJ   rK   r'   r(   s        r)   r%   zBarkFineConfig.__init__   s<    **KK-@KFKKKKKr*   )TrF   rG   )r+   r,   r-   r:   r;   r%   r0   r1   s   @r)   rA   rA      sS        0 "J-OL L L L L L L L L Lr*   c            
            e Zd ZdZdZeeeedZ		 	 	 	 	 dde
e         de
e         de
e         d	e
e         f fd
Zedededed	efd            Z xZS )
BarkConfiga  
    This is the configuration class to store the configuration of a [`BarkModel`]. It is used to instantiate a Bark
    model according to the specified sub-models configurations, defining the model architecture.

    Instantiating a configuration with the defaults will yield a similar configuration to that of the Bark
    [suno/bark](https://huggingface.co/suno/bark) architecture.

    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
    documentation from [`PretrainedConfig`] for more information.

    Args:
    semantic_config ([`BarkSemanticConfig`], *optional*):
        Configuration of the underlying semantic sub-model.
    coarse_acoustics_config ([`BarkCoarseConfig`], *optional*):
        Configuration of the underlying coarse acoustics sub-model.
    fine_acoustics_config ([`BarkFineConfig`], *optional*):
        Configuration of the underlying fine acoustics sub-model.
    codec_config ([`AutoConfig`], *optional*):
        Configuration of the underlying codec sub-model.

    Example:

    ```python
    >>> 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.from_sub_model_configs(
    ...     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.config
    ```
    barkr8   r@   rE   codec_configNr   r8   r@   rE   rP   c                    |i }t                               d           |i }t                               d           |i }t                               d           |i }t                               d           t          di || _        t	          di || _        t          di || _        |                    dd          }t          |         di || _
        || _         t                      j        di | d S )NzMsemantic_config is None. initializing the semantic model with default values.zScoarse_acoustics_config is None. initializing the coarse model with default values.zOfine_acoustics_config is None. initializing the fine model with default values.zGcodec_config is None. initializing the codec model with default values.r:   encodecr   )loggerinfor2   r8   r<   r@   rA   rE   getr	   rP   r#   r$   r%   )	r&   r8   r@   rE   rP   r#   r'   codec_model_typer(   s	           r)   r%   zBarkConfig.__init__   s     " OKKghhh"*&(#KKmnnn ($&!KKijjjLKKabbb1DDODD'7'R'R:Q'R'R$%3%L%L6K%L%L"'++L)DD*+;<LL|LL!2""6"""""r*   c                      | d|                                 |                                 |                                 |                                 d|S )z
        Instantiate a [`BarkConfig`] (or a derived class) from bark sub-models configuration.

        Returns:
            [`BarkConfig`]: An instance of a configuration object
        rO   r   )to_dict)clsr8   r@   rE   rP   r'   s         r)   from_sub_model_configsz!BarkConfig.from_sub_model_configs  sh     s 
+3355$;$C$C$E$E"7"?"?"A"A%--//	
 

 
 
 	
r*   )NNNNr   )r+   r,   r-   __doc__r:   r2   r<   rA   r
   sub_configsr   dictr%   classmethodr   rZ   r0   r1   s   @r)   rM   rM      s        2 2h J-#3!/"	 K +/2604'+!# !#!$!# "*$!#  (~	!#
 tn!# !# !# !# !# !#F 
+
 "2
  .	

 '
 
 
 [
 
 
 
 
r*   rM   )r<   rM   rA   r2   N)r[   typingr   configuration_utilsr   utilsr   r   autor	   r
   
get_loggerr+   rS   #BARK_SUBMODELCONFIG_START_DOCSTRINGr   formatr2   r<   rA   rM   __all__r   r*   r)   <module>rg      s#           3 3 3 3 3 3 2 2 2 2 2 2 2 2 - - - - - - - - 
	H	%	%#' #L## ## ## ## ##) ## ## ##L '..6JRe.ff $( ( ( ( (+ ( (% $(
 '..6HPa.bb $0 0 0 0 0) 0 0% $0
 '..6Fo.^^ .L L L L L' L L/ .Lu
 u
 u
 u
 u
! u
 u
 u
p U
T
Tr*   