





import copy
import os
from typing import Dict, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...utils import add_start_docstrings, logging
from ..auto import AutoConfig


_A				:							Union[str, Any]							= logging.get_logger(__name__)


_A				:							Optional[int]							= {
    """suno/bark-small""": """https://huggingface.co/suno/bark-small/resolve/main/config.json""",
    """suno/bark""": """https://huggingface.co/suno/bark/resolve/main/config.json""",
}

_A				:							Optional[Any]							= """
    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).
"""



class 				__snake_case  (     __SCREAMING_SNAKE_CASE						):


    '''simple docstring'''







    lowerCamelCase__						:		List[Any]							=  """bark_module"""
    lowerCamelCase__						:		List[str]							=  ["""past_key_values"""]

    lowerCamelCase__						:		Any							=  {
        """num_attention_heads""": """num_heads""",
        """num_hidden_layers""": """num_layers""",
        """vocab_size""": """input_vocab_size""",
        """window_size""": """block_size""",
    }



    def __init__(					self      ,							A_=10_24      ,							A_=1_00_48      ,							A_=1_00_48      ,							A_=12      ,							A_=12      ,							A_=7_68      ,							A_=0.0      ,							A_=True      ,							A_=0.02      ,							A_=True      ,							**A_      ,							):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__       							= block_size
        SCREAMING_SNAKE_CASE__       							= input_vocab_size
        SCREAMING_SNAKE_CASE__       							= output_vocab_size
        SCREAMING_SNAKE_CASE__       							= num_layers
        SCREAMING_SNAKE_CASE__       							= num_heads
        SCREAMING_SNAKE_CASE__       							= hidden_size
        SCREAMING_SNAKE_CASE__       							= dropout
        SCREAMING_SNAKE_CASE__       							= bias
        SCREAMING_SNAKE_CASE__       							= use_cache
        SCREAMING_SNAKE_CASE__       							= initializer_range

        super().__init__(**A_    )




    @classmethod
    def    lowercase_				(					cls      ,							A_      ,							A_ = None      ,							A_ = False      ,							A_ = False      ,							A_ = None      ,							A_ = "main"      ,							**A_      ,							):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__       							= cache_dir
        SCREAMING_SNAKE_CASE__       							= force_download
        SCREAMING_SNAKE_CASE__       							= local_files_only
        SCREAMING_SNAKE_CASE__       							= revision

        cls._set_token_in_kwargs(A_      ,							A_    )

        SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__       							= cls.get_config_dict(A_      ,							**A_    )

        # get the config dict if we are loading from Bark
        if config_dict.get('''model_type'''    ) == "bark":
            SCREAMING_SNAKE_CASE__       							= config_dict[f'''{cls.model_type}_config''']

        if "model_type" in config_dict and hasattr(cls      ,							'''model_type'''    ) and config_dict["model_type"] != cls.model_type:
            logger.warning(
                f'''You are using a model of type {config_dict["model_type"]} to instantiate a model of type '''
                f'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.'''    )

        return cls.from_dict(A_      ,							**A_    )





@add_start_docstrings(
    BARK_SUBMODELCONFIG_START_DOCSTRING.format(config="""BarkSemanticConfig""" ,    model="""BarkSemanticModel"""						) ,    """
    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
    ```""" ,    )
class 				__snake_case  (     __SCREAMING_SNAKE_CASE						):


    '''simple docstring'''







    lowerCamelCase__						:		str							=  """semantic"""





@add_start_docstrings(
    BARK_SUBMODELCONFIG_START_DOCSTRING.format(config="""BarkCoarseConfig""" ,    model="""BarkCoarseModel"""						) ,    """
    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
    ```""" ,    )
class 				__snake_case  (     __SCREAMING_SNAKE_CASE						):


    '''simple docstring'''







    lowerCamelCase__						:		Any							=  """coarse_acoustics"""





@add_start_docstrings(
    BARK_SUBMODELCONFIG_START_DOCSTRING.format(config="""BarkFineConfig""" ,    model="""BarkFineModel"""						) ,    """
        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
    ```""" ,    )
class 				__snake_case  (     __SCREAMING_SNAKE_CASE						):


    '''simple docstring'''







    lowerCamelCase__						:		List[str]							=  """fine_acoustics"""



    def __init__(					self      ,							A_=True      ,							A_=8      ,							A_=1      ,							**A_    ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__       							= n_codes_total
        SCREAMING_SNAKE_CASE__       							= n_codes_given

        super().__init__(tie_word_embeddings=A_      ,							**A_    )





class 				__snake_case  (     __SCREAMING_SNAKE_CASE						):


    '''simple docstring'''







    lowerCamelCase__						:		Optional[Any]							=  """bark"""
    lowerCamelCase__						:		Optional[Any]							=  True



    def __init__(					self      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_=0.02      ,							**A_      ,							):





        '''simple docstring'''

        if semantic_config is None:
            SCREAMING_SNAKE_CASE__       							= {}
            logger.info('''semantic_config is None. initializing the semantic model with default values.'''    )

        if coarse_acoustics_config is None:
            SCREAMING_SNAKE_CASE__       							= {}
            logger.info('''coarse_acoustics_config is None. initializing the coarse model with default values.'''    )

        if fine_acoustics_config is None:
            SCREAMING_SNAKE_CASE__       							= {}
            logger.info('''fine_acoustics_config is None. initializing the fine model with default values.'''    )

        if codec_config is None:
            SCREAMING_SNAKE_CASE__       							= {}
            logger.info('''codec_config is None. initializing the codec model with default values.'''    )

        SCREAMING_SNAKE_CASE__       							= BarkSemanticConfig(**A_    )
        SCREAMING_SNAKE_CASE__       							= BarkCoarseConfig(**A_    )
        SCREAMING_SNAKE_CASE__       							= BarkFineConfig(**A_    )
        SCREAMING_SNAKE_CASE__       							= AutoConfig.for_model(**A_    )

        SCREAMING_SNAKE_CASE__       							= initializer_range

        super().__init__(**A_    )



    @classmethod
    def    lowercase_				(					cls      ,							A_      ,							A_      ,							A_      ,							A_      ,							**A_      ,							):





        '''simple docstring'''

        return cls(
            semantic_config=semantic_config.to_dict()      ,							coarse_acoustics_config=coarse_acoustics_config.to_dict()      ,							fine_acoustics_config=fine_acoustics_config.to_dict()      ,							codec_config=codec_config.to_dict()      ,							**A_      ,							)




    def    lowercase_				(					self    ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__       							= copy.deepcopy(self.__dict__    )

        SCREAMING_SNAKE_CASE__       							= self.semantic_config.to_dict()
        SCREAMING_SNAKE_CASE__       							= self.coarse_acoustics_config.to_dict()
        SCREAMING_SNAKE_CASE__       							= self.fine_acoustics_config.to_dict()
        SCREAMING_SNAKE_CASE__       							= self.codec_config.to_dict()

        SCREAMING_SNAKE_CASE__       							= self.__class__.model_type
        return output







import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


_A				:							Any							= logging.get_logger(__name__)

_A				:							Any							= {
    """facebook/hubert-base-ls960""": """https://huggingface.co/facebook/hubert-base-ls960/resolve/main/config.json""",
    # See all Hubert models at https://huggingface.co/models?filter=hubert
}



class 				__snake_case  (     __SCREAMING_SNAKE_CASE						):


    '''simple docstring'''







    lowerCamelCase__						:		int							=  """hubert"""



    def __init__(					self      ,							A_=32      ,							A_=7_68      ,							A_=12      ,							A_=12      ,							A_=30_72      ,							A_="gelu"      ,							A_=0.1      ,							A_=0.1      ,							A_=0.1      ,							A_=True      ,							A_=0.0      ,							A_=0.1      ,							A_=0.1      ,							A_=0.02      ,							A_=1E-5      ,							A_="group"      ,							A_="gelu"      ,							A_=(5_12, 5_12, 5_12, 5_12, 5_12, 5_12, 5_12)      ,							A_=(5, 2, 2, 2, 2, 2, 2)      ,							A_=(10, 3, 3, 3, 3, 2, 2)      ,							A_=False      ,							A_=1_28      ,							A_=16      ,							A_=False      ,							A_=True      ,							A_=0.05      ,							A_=10      ,							A_=2      ,							A_=0.0      ,							A_=10      ,							A_=0      ,							A_="sum"      ,							A_=False      ,							A_=False      ,							A_=2_56      ,							A_=0      ,							A_=1      ,							A_=2      ,							**A_      ,							):





        '''simple docstring'''

        super().__init__(**A_      ,							pad_token_id=A_      ,							bos_token_id=A_      ,							eos_token_id=A_    )
        SCREAMING_SNAKE_CASE__       							= hidden_size
        SCREAMING_SNAKE_CASE__       							= feat_extract_norm
        SCREAMING_SNAKE_CASE__       							= feat_extract_activation
        SCREAMING_SNAKE_CASE__       							= list(A_    )
        SCREAMING_SNAKE_CASE__       							= list(A_    )
        SCREAMING_SNAKE_CASE__       							= list(A_    )
        SCREAMING_SNAKE_CASE__       							= conv_bias
        SCREAMING_SNAKE_CASE__       							= num_conv_pos_embeddings
        SCREAMING_SNAKE_CASE__       							= num_conv_pos_embedding_groups
        SCREAMING_SNAKE_CASE__       							= len(self.conv_dim    )
        SCREAMING_SNAKE_CASE__       							= num_hidden_layers
        SCREAMING_SNAKE_CASE__       							= intermediate_size
        SCREAMING_SNAKE_CASE__       							= hidden_act
        SCREAMING_SNAKE_CASE__       							= num_attention_heads
        SCREAMING_SNAKE_CASE__       							= hidden_dropout
        SCREAMING_SNAKE_CASE__       							= attention_dropout
        SCREAMING_SNAKE_CASE__       							= activation_dropout
        SCREAMING_SNAKE_CASE__       							= feat_proj_layer_norm
        SCREAMING_SNAKE_CASE__       							= feat_proj_dropout
        SCREAMING_SNAKE_CASE__       							= final_dropout
        SCREAMING_SNAKE_CASE__       							= layerdrop
        SCREAMING_SNAKE_CASE__       							= layer_norm_eps
        SCREAMING_SNAKE_CASE__       							= initializer_range
        SCREAMING_SNAKE_CASE__       							= vocab_size
        SCREAMING_SNAKE_CASE__       							= do_stable_layer_norm
        SCREAMING_SNAKE_CASE__       							= use_weighted_layer_sum
        SCREAMING_SNAKE_CASE__       							= classifier_proj_size

        if (
            (len(self.conv_stride    ) != self.num_feat_extract_layers)
            or (len(self.conv_kernel    ) != self.num_feat_extract_layers)
            or (len(self.conv_dim    ) != self.num_feat_extract_layers)
        ):
            raise ValueError(
                '''Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =='''
                ''' `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ='''
                f''' {len(self.conv_dim    )}`, `len(config.conv_stride) = {len(self.conv_stride    )}`,'''
                f''' `len(config.conv_kernel) = {len(self.conv_kernel    )}`.'''    )

        # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
        SCREAMING_SNAKE_CASE__       							= apply_spec_augment
        SCREAMING_SNAKE_CASE__       							= mask_time_prob
        SCREAMING_SNAKE_CASE__       							= mask_time_length
        SCREAMING_SNAKE_CASE__       							= mask_time_min_masks
        SCREAMING_SNAKE_CASE__       							= mask_feature_prob
        SCREAMING_SNAKE_CASE__       							= mask_feature_length
        SCREAMING_SNAKE_CASE__       							= mask_feature_min_masks

        # ctc loss
        SCREAMING_SNAKE_CASE__       							= ctc_loss_reduction
        SCREAMING_SNAKE_CASE__       							= ctc_zero_infinity




    @property
    def    lowercase_				(					self    ):





        '''simple docstring'''

        return functools.reduce(operator.mul      ,							self.conv_stride      ,							1    )
