


"""simple docstring"""





import os
import tempfile
import unittest
from typing import List

from transformers.models.esm.tokenization_esm import VOCAB_FILES_NAMES, EsmTokenizer
from transformers.testing_utils import require_tokenizers
from transformers.tokenization_utils import PreTrainedTokenizer
from transformers.tokenization_utils_base import PreTrainedTokenizerBase

@require_tokenizers
class  lowercase_  ( unittest.TestCase						):
      __magic_name__     :							str          =				EsmTokenizer







      def 				_lowerCAmelCase       (      self :							List[str]    ):
        super().setUp()
        lowerCAmelCase__    :    Any								=					tempfile.mkdtemp()
        # fmt: off
        lowerCAmelCase__    :    List[str]								=					["<cls>", "<pad>", "<eos>", "<unk>", "L", "A", "G", "V", "S", "E", "R", "T", "I", "D", "P", "K", "Q", "N", "F", "Y", "M", "H", "W", "C", "X", "B", "U", "Z", "O", ".", "-", "<null_1>", "<mask>"]  # noqa: E501
        # fmt: on
        lowerCAmelCase__    :    int								=					os.path.join(self.tmpdirname		,  VOCAB_FILES_NAMES["vocab_file"]    )
        with open(self.vocab_file		,  "w"		,  encoding="utf-8"    ) as vocab_writer:
          vocab_writer.write("".join([x + "\n" for x in vocab_tokens]    )    )







      def 				_lowerCAmelCase       (      self :							Optional[Any]		,  **_lowercase :							Union[str, Any]    ):
        return [self.get_tokenizer(**_lowercase    )]







      def 				_lowerCAmelCase       (      self :							Optional[int]		,  **_lowercase :							List[str]    ):
        return self.tokenizer_class.from_pretrained(self.tmpdirname		,  **_lowercase    )







      def 				_lowerCAmelCase       (      self :							List[str]    ):
        lowerCAmelCase__    :    Dict								=					self.tokenizer_class(self.vocab_file    )

        lowerCAmelCase__    :    Union[str, Any]								=					tokenizer.tokenize("LAGVS"    )
        self.assertListEqual(_lowercase		,  ["L", "A", "G", "V", "S"]    )
        self.assertListEqual(tokenizer.convert_tokens_to_ids(_lowercase    )		,  [4, 5, 6, 7, 8]    )







      def 				_lowerCAmelCase       (      self :							Optional[int]    ):
        lowerCAmelCase__    :    Any								=					self.tokenizer_class(self.vocab_file    )

        lowerCAmelCase__    :    Tuple								=					"LAGVS"
        self.assertListEqual(tokenizer.encode(_lowercase    )		,  [0, 4, 5, 6, 7, 8, 2]    )







      def 				_lowerCAmelCase       (      self :							Tuple    ):
        lowerCAmelCase__    :    List[Any]								=					self.tokenizer_class(self.vocab_file    )

        lowerCAmelCase__    :    Optional[Any]								=					["LAGVS", "WCB"]
        lowerCAmelCase__    :    Optional[Any]								=					tokenizer(_lowercase		,  padding=_lowercase    )["input_ids"]

        self.assertListEqual(_lowercase		,  [[0, 4, 5, 6, 7, 8, 2], [0, 2_2, 2_3, 2_5, 2]]    )







      def 				_lowerCAmelCase       (      self :							Union[str, Any]    ):
        lowerCAmelCase__    :    Dict								=					self.tokenizer_class(self.vocab_file    )

        lowerCAmelCase__    :    Tuple								=					["LAGVS", "WCB"]
        lowerCAmelCase__    :    Union[str, Any]								=					tokenizer(_lowercase		,  padding=_lowercase    )["input_ids"]

        self.assertListEqual(_lowercase		,  [[0, 4, 5, 6, 7, 8, 2], [0, 2_2, 2_3, 2_5, 2, 1, 1]]    )







      def 				_lowerCAmelCase       (      self :							List[str]    ):
        lowerCAmelCase__    :    List[str]								=					self.get_tokenizers(fast=_lowercase    )
        for tokenizer in tokenizers:
          with self.subTest(f"{tokenizer.__class__.__name__}"    ):
            lowerCAmelCase__    :    Optional[int]								=					"<unk>"
            lowerCAmelCase__    :    int								=					"<mask>"

            lowerCAmelCase__    :    Optional[Any]								=					tokenizer.tokenize(_lowercase    )
            lowerCAmelCase__    :    int								=					tokenizer.tokenize(_lowercase    )

            self.assertEqual(len(_lowercase    )		,  1    )
            self.assertEqual(len(_lowercase    )		,  1    )
            self.assertEqual(token_a[0]		,  _lowercase    )
            self.assertEqual(token_a[0]		,  _lowercase    )




"""simple docstring"""





import functools
import operator

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


__UpperCAmelCase    				=      logging.get_logger(__name__)

__UpperCAmelCase    				=      {
    "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  lowercase_  ( a_						):
      __magic_name__     :							List[Any]          =				"""hubert"""







      def __init__(      self :							List[Any]		,  _lowercase :							Optional[int]=3_2		,  _lowercase :							Tuple=7_6_8		,  _lowercase :							List[Any]=1_2		,  _lowercase :							Dict=1_2		,  _lowercase :							Tuple=3_0_7_2		,  _lowercase :							str="gelu"		,  _lowercase :							Optional[int]=0.1		,  _lowercase :							int=0.1		,  _lowercase :							Tuple=0.1		,  _lowercase :							str=True		,  _lowercase :							Optional[Any]=0.0		,  _lowercase :							List[Any]=0.1		,  _lowercase :							Union[str, Any]=0.1		,  _lowercase :							Union[str, Any]=0.02		,  _lowercase :							List[Any]=1e-5		,  _lowercase :							List[Any]="group"		,  _lowercase :							Tuple="gelu"		,  _lowercase :							List[str]=(5_1_2, 5_1_2, 5_1_2, 5_1_2, 5_1_2, 5_1_2, 5_1_2)		,  _lowercase :							List[Any]=(5, 2, 2, 2, 2, 2, 2)		,  _lowercase :							Tuple=(1_0, 3, 3, 3, 3, 2, 2)		,  _lowercase :							Any=False		,  _lowercase :							str=1_2_8		,  _lowercase :							int=1_6		,  _lowercase :							str=False		,  _lowercase :							Union[str, Any]=True		,  _lowercase :							Optional[Any]=0.05		,  _lowercase :							List[Any]=1_0		,  _lowercase :							Dict=2		,  _lowercase :							Optional[int]=0.0		,  _lowercase :							List[str]=1_0		,  _lowercase :							List[str]=0		,  _lowercase :							Optional[Any]="sum"		,  _lowercase :							int=False		,  _lowercase :							Any=False		,  _lowercase :							Optional[Any]=2_5_6		,  _lowercase :							int=0		,  _lowercase :							Optional[int]=1		,  _lowercase :							List[Any]=2		,  **_lowercase :							Tuple		,  ):
        super().__init__(**_lowercase		,  pad_token_id=_lowercase		,  bos_token_id=_lowercase		,  eos_token_id=_lowercase    )
        lowerCAmelCase__    :    Optional[Any]								=					hidden_size
        lowerCAmelCase__    :    int								=					feat_extract_norm
        lowerCAmelCase__    :    Optional[Any]								=					feat_extract_activation
        lowerCAmelCase__    :    Optional[Any]								=					list(_lowercase    )
        lowerCAmelCase__    :    Union[str, Any]								=					list(_lowercase    )
        lowerCAmelCase__    :    Tuple								=					list(_lowercase    )
        lowerCAmelCase__    :    str								=					conv_bias
        lowerCAmelCase__    :    Optional[Any]								=					num_conv_pos_embeddings
        lowerCAmelCase__    :    List[str]								=					num_conv_pos_embedding_groups
        lowerCAmelCase__    :    List[Any]								=					len(self.conv_dim    )
        lowerCAmelCase__    :    Union[str, Any]								=					num_hidden_layers
        lowerCAmelCase__    :    str								=					intermediate_size
        lowerCAmelCase__    :    List[Any]								=					hidden_act
        lowerCAmelCase__    :    Optional[int]								=					num_attention_heads
        lowerCAmelCase__    :    Optional[int]								=					hidden_dropout
        lowerCAmelCase__    :    Dict								=					attention_dropout
        lowerCAmelCase__    :    Dict								=					activation_dropout
        lowerCAmelCase__    :    Optional[Any]								=					feat_proj_layer_norm
        lowerCAmelCase__    :    Union[str, Any]								=					feat_proj_dropout
        lowerCAmelCase__    :    Optional[Any]								=					final_dropout
        lowerCAmelCase__    :    Dict								=					layerdrop
        lowerCAmelCase__    :    Optional[int]								=					layer_norm_eps
        lowerCAmelCase__    :    str								=					initializer_range
        lowerCAmelCase__    :    int								=					vocab_size
        lowerCAmelCase__    :    int								=					do_stable_layer_norm
        lowerCAmelCase__    :    Union[str, Any]								=					use_weighted_layer_sum
        lowerCAmelCase__    :    Tuple								=					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
        lowerCAmelCase__    :    int								=					apply_spec_augment
        lowerCAmelCase__    :    Tuple								=					mask_time_prob
        lowerCAmelCase__    :    int								=					mask_time_length
        lowerCAmelCase__    :    Dict								=					mask_time_min_masks
        lowerCAmelCase__    :    Union[str, Any]								=					mask_feature_prob
        lowerCAmelCase__    :    Dict								=					mask_feature_length
        lowerCAmelCase__    :    Tuple								=					mask_feature_min_masks

        # ctc loss
        lowerCAmelCase__    :    Tuple								=					ctc_loss_reduction
        lowerCAmelCase__    :    List[str]								=					ctc_zero_infinity







      @property
      def 				_lowerCAmelCase       (      self :							Dict    ):
        return functools.reduce(operator.mul		,  self.conv_stride		,  1    )
