


"""simple docstring"""





import sys
from typing import Dict

from transformers import EvalPrediction, HfArgumentParser, TrainingArguments, is_torch_available
from transformers.utils import logging


__UpperCAmelCase    				=       logging.get_logger(__name__)


if is_torch_available():
   import torch
   from torch import nn
   from torch.utils.data import Dataset

   from transformers import Trainer

   class  lowercase_  ( snake_case_						):







         def __init__(      self :							Dict		,  _lowercase :							str = 1_0_1    ):
           lowerCAmelCase__    :    str								=					length







         def __len__(      self :							str    ):
           return self.length







         def __getitem__(      self :							Any		,  _lowercase :							str    ):
           return i

   class  lowercase_  :







         def __call__(      self :							List[str]		,  _lowercase :							Union[str, Any]    ):
           return {"input_ids": torch.tensor(_lowercase    ), "labels": torch.tensor(_lowercase    )}

   class  lowercase_  ( nn.Module						):







         def __init__(      self :							List[Any]    ):
           super().__init__()
           # Add some (unused) params otherwise DDP will complain.
           lowerCAmelCase__    :    Optional[Any]								=					nn.Linear(1_2_0		,  8_0    )







         def 				_lowerCAmelCase       (      self :							List[Any]		,  _lowercase :							int		,  _lowercase :							Dict=None    ):
           if labels is not None:
             return torch.tensor(0.0		,  device=input_ids.device    ), input_ids
           else:
             return input_ids





def     lowercase__	(  )					->     str:
  lowerCAmelCase__    :    Optional[int]								=					HfArgumentParser((TrainingArguments,)				)
  sys.argv += ["--output_dir", "./examples"]
  lowerCAmelCase__    :    Optional[int]								=					parser.parse_args_into_dataclasses()[0]

  logger.warning(
      F"Process rank: {training_args.local_rank}, device: {training_args.device}, "
      F"tpu_num_cores: {training_args.tpu_num_cores}"				,	)

  # Essentially, what we want to verify in the distributed case is
  # that we get all samples back, in the right order.
  # (this is crucial for prediction for instance)
  for dataset_length in [1_0_0_1, 2_5_6, 1_5]:
    lowerCAmelCase__    :    List[str]								=					DummyDataset(__lowerCamelCase				)

    def compute_metrics(lowerCamelCase     :  EvalPrediction				) -> Dict:
      lowerCAmelCase__    :    Dict								=					list(range(len(__lowerCamelCase				)				)				)
      lowerCAmelCase__    :    int								=					p.predictions.tolist() == sequential and p.label_ids.tolist() == sequential
      return {"success": success}

    lowerCAmelCase__    :    Dict								=					Trainer(
        model=DummyModel()				,	args=__lowerCamelCase				,	data_collator=DummyDataCollator()				,	eval_dataset=__lowerCamelCase				,	compute_metrics=__lowerCamelCase				,	)
    lowerCAmelCase__    :    str								=					trainer.evaluate()
    logger.info(__lowerCamelCase				)
    if metrics["eval_success"] is not True:
      logger.error(__lowerCamelCase				)
      exit(1				)

    lowerCAmelCase__    :    int								=					trainer.predict(__lowerCamelCase				)
    logger.info(p.metrics				)
    if p.metrics["test_success"] is not True:
      logger.error(p.metrics				)
      exit(1				)

    lowerCAmelCase__    :    Dict								=					2

    lowerCAmelCase__    :    str								=					trainer.evaluate()
    logger.info(__lowerCamelCase				)
    if metrics["eval_success"] is not True:
      logger.error(__lowerCamelCase				)
      exit(1				)

    lowerCAmelCase__    :    Dict								=					trainer.predict(__lowerCamelCase				)
    logger.info(p.metrics				)
    if p.metrics["test_success"] is not True:
      logger.error(p.metrics				)
      exit(1				)

    lowerCAmelCase__    :    int								=					None

  logger.info("🔥 All distributed tests successful"				)





def     lowercase__	(  lowerCamelCase     :  Any				)					->     Any:
  # For xla_spawn (TPUs)
  main()


if __name__ == "__main__":
   main()




"""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    )
