


'''simple docstring'''







import importlib.util
import json
import os
import warnings
from dataclasses import dataclass, field

import torch

from ..training_args import TrainingArguments
from ..utils import cached_property, is_sagemaker_dp_enabled, logging


_SCREAMING_SNAKE_CASE							: Tuple										=			logging.get_logger(__name__)



def     _UpperCamelCase				(			):






				"""simple docstring"""



				__magic_name__					:       Any    							=							os.getenv("SM_HP_MP_PARAMETERS"  , "{}"		)
				try:
								# Parse it and check the field "partitions" is included, it is required for model parallel.
								__magic_name__					:       List[str]    							=							json.loads(_UpperCamelCase		)
								if "partitions" not in smp_options:
												return False
				except json.JSONDecodeError:
								return False

				# Get the sagemaker specific framework parameters from mpi_options variable.
				__magic_name__					:       List[str]    							=							os.getenv("SM_FRAMEWORK_PARAMS"  , "{}"		)
				try:
								# Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
								__magic_name__					:       int    							=							json.loads(_UpperCamelCase		)
								if not mpi_options.get("sagemaker_mpi_enabled"  , _UpperCamelCase		):
												return False
				except json.JSONDecodeError:
								return False
				# Lastly, check if the `smdistributed` module is present.
				return importlib.util.find_spec("smdistributed"		) is not None


if is_sagemaker_model_parallel_available():
		import smdistributed.modelparallel.torch as smp

		smp.init()






@dataclass
class 		_snake_case     (					__lowerCAmelCase		):






						'''simple docstring'''







						__snake_case				=   field(
						    default=""	,	metadata={"help": "Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer"}	,	)







						def lowerCAmelCase__			(	self:						Optional[int]  )				->						str:
										super().__post_init__()
										warnings.warn(
										    "`SageMakerTrainingArguments` is deprecated and will be removed in v5 of Transformers. You can use "
										    "`TrainingArguments` instead."   ,				_SCREAMING_SNAKE_CASE   ,				)







						@cached_property
						def lowerCAmelCase__			(	self:						Union[str, Any]  )				->						"torch.device":
										logger.info("PyTorch: setting up devices"  )
										if torch.distributed.is_available() and torch.distributed.is_initialized() and self.local_rank == -1:
														logger.warning(
														    "torch.distributed process group is initialized, but local_rank == -1. "
														    "In order to use Torch DDP, launch your script with `python -m torch.distributed.launch"  )
										if self.no_cuda:
														__magic_name__					:       Any    							=							torch.device("cpu"  )
														__magic_name__					:       Tuple    							=							0
										elif is_sagemaker_model_parallel_available():
														__magic_name__					:       int    							=							smp.local_rank()
														__magic_name__					:       Optional[Any]    							=							torch.device("cuda"   ,				_SCREAMING_SNAKE_CASE  )
														__magic_name__					:       Union[str, Any]    							=							1
										elif is_sagemaker_dp_enabled():
														import smdistributed.dataparallel.torch.torch_smddp  # noqa: F401

														torch.distributed.init_process_group(backend="smddp"   ,				timeout=self.ddp_timeout_delta  )
														__magic_name__					:       Optional[int]    							=							int(os.getenv("SMDATAPARALLEL_LOCAL_RANK"  )  )
														__magic_name__					:       List[str]    							=							torch.device("cuda"   ,				self.local_rank  )
														__magic_name__					:       Optional[int]    							=							1
										elif self.local_rank == -1:
														# if n_gpu is > 1 we'll use nn.DataParallel.
														# If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
														# Explicitly set CUDA to the first (index 0) CUDA device, otherwise `set_device` will
														# trigger an error that a device index is missing. Index 0 takes into account the
														# GPUs available in the environment, so `CUDA_VISIBLE_DEVICES=1,2` with `cuda:0`
														# will use the first GPU in that env, i.e. GPU#1
														__magic_name__					:       Union[str, Any]    							=							torch.device("cuda:0" if torch.cuda.is_available() else "cpu"  )
														# Sometimes the line in the postinit has not been run before we end up here, so just checking we're not at
														# the default value.
														__magic_name__					:       int    							=							torch.cuda.device_count()
										else:
														# Here, we'll use torch.distributed.
														# Initializes the distributed backend which will take care of synchronizing nodes/GPUs
														if not torch.distributed.is_initialized():
																		torch.distributed.init_process_group(backend="nccl"   ,				timeout=self.ddp_timeout_delta  )
														__magic_name__					:       Dict    							=							torch.device("cuda"   ,				self.local_rank  )
														__magic_name__					:       Dict    							=							1

										if device.type == "cuda":
														torch.cuda.set_device(_SCREAMING_SNAKE_CASE  )

										return device







						@property
						def lowerCAmelCase__			(	self:						Optional[int]  )				->						Any:
										if is_sagemaker_model_parallel_available():
														return smp.dp_size()

										return super().world_size







						@property
						def lowerCAmelCase__			(	self:						Union[str, Any]  )				->						List[str]:
										return not is_sagemaker_model_parallel_available()







						@property
						def lowerCAmelCase__			(	self:						Any  )				->						Dict:
										return False





'''simple docstring'''





import functools
import operator

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


UpperCamelCase_		:     Optional[Any]          =		logging.get_logger(__name__)

UpperCamelCase_		:     Any          =		{
    '''microsoft/unispeech-sat-base-100h-libri-ft''': (
        '''https://huggingface.co/microsoft/unispeech-sat-base-100h-libri-ft/resolve/main/config.json'''
    ),
    # See all UniSpeechSat models at https://huggingface.co/models?filter=unispeech_sat
}

class   _a							(		__lowerCAmelCase				):
     SCREAMING_SNAKE_CASE_				:       str       							=		"""unispeech-sat"""






     def __init__(					self   ,_SCREAMING_SNAKE_CASE=32   ,_SCREAMING_SNAKE_CASE=768   ,_SCREAMING_SNAKE_CASE=12   ,_SCREAMING_SNAKE_CASE=12   ,_SCREAMING_SNAKE_CASE=3_072   ,_SCREAMING_SNAKE_CASE="gelu"   ,_SCREAMING_SNAKE_CASE=0.1   ,_SCREAMING_SNAKE_CASE=0.1   ,_SCREAMING_SNAKE_CASE=0.1   ,_SCREAMING_SNAKE_CASE=0.0   ,_SCREAMING_SNAKE_CASE=0.0   ,_SCREAMING_SNAKE_CASE=0.1   ,_SCREAMING_SNAKE_CASE=0.1   ,_SCREAMING_SNAKE_CASE=0.0_2   ,_SCREAMING_SNAKE_CASE=1e-5   ,_SCREAMING_SNAKE_CASE="group"   ,_SCREAMING_SNAKE_CASE="gelu"   ,_SCREAMING_SNAKE_CASE=(512, 512, 512, 512, 512, 512, 512)   ,_SCREAMING_SNAKE_CASE=(5, 2, 2, 2, 2, 2, 2)   ,_SCREAMING_SNAKE_CASE=(10, 3, 3, 3, 3, 2, 2)   ,_SCREAMING_SNAKE_CASE=False   ,_SCREAMING_SNAKE_CASE=128   ,_SCREAMING_SNAKE_CASE=16   ,_SCREAMING_SNAKE_CASE=False   ,_SCREAMING_SNAKE_CASE=True   ,_SCREAMING_SNAKE_CASE=0.0_5   ,_SCREAMING_SNAKE_CASE=10   ,_SCREAMING_SNAKE_CASE=2   ,_SCREAMING_SNAKE_CASE=0.0   ,_SCREAMING_SNAKE_CASE=10   ,_SCREAMING_SNAKE_CASE=0   ,_SCREAMING_SNAKE_CASE=320   ,_SCREAMING_SNAKE_CASE=2   ,_SCREAMING_SNAKE_CASE=0.1   ,_SCREAMING_SNAKE_CASE=100   ,_SCREAMING_SNAKE_CASE=256   ,_SCREAMING_SNAKE_CASE=256   ,_SCREAMING_SNAKE_CASE=0.1   ,_SCREAMING_SNAKE_CASE="mean"   ,_SCREAMING_SNAKE_CASE=False   ,_SCREAMING_SNAKE_CASE=False   ,_SCREAMING_SNAKE_CASE=256   ,_SCREAMING_SNAKE_CASE=(512, 512, 512, 512, 1_500)   ,_SCREAMING_SNAKE_CASE=(5, 3, 3, 1, 1)   ,_SCREAMING_SNAKE_CASE=(1, 2, 3, 1, 1)   ,_SCREAMING_SNAKE_CASE=512   ,_SCREAMING_SNAKE_CASE=0   ,_SCREAMING_SNAKE_CASE=1   ,_SCREAMING_SNAKE_CASE=2   ,_SCREAMING_SNAKE_CASE=504   ,**_SCREAMING_SNAKE_CASE   ,)				->     Any:
          super().__init__(**_SCREAMING_SNAKE_CASE   ,pad_token_id=_SCREAMING_SNAKE_CASE   ,bos_token_id=_SCREAMING_SNAKE_CASE   ,eos_token_id=_SCREAMING_SNAKE_CASE       )
          _snake_case				= hidden_size
          _snake_case				= feat_extract_norm
          _snake_case				= feat_extract_activation
          _snake_case				= list(_SCREAMING_SNAKE_CASE       )
          _snake_case				= list(_SCREAMING_SNAKE_CASE       )
          _snake_case				= list(_SCREAMING_SNAKE_CASE       )
          _snake_case				= conv_bias
          _snake_case				= num_conv_pos_embeddings
          _snake_case				= num_conv_pos_embedding_groups
          _snake_case				= len(self.conv_dim       )
          _snake_case				= num_hidden_layers
          _snake_case				= intermediate_size
          _snake_case				= hidden_act
          _snake_case				= num_attention_heads
          _snake_case				= hidden_dropout
          _snake_case				= attention_dropout
          _snake_case				= activation_dropout
          _snake_case				= feat_proj_dropout
          _snake_case				= final_dropout
          _snake_case				= layerdrop
          _snake_case				= layer_norm_eps
          _snake_case				= initializer_range
          _snake_case				= vocab_size
          _snake_case				= num_clusters
          _snake_case				= do_stable_layer_norm
          _snake_case				= use_weighted_layer_sum

          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
          _snake_case				= apply_spec_augment
          _snake_case				= mask_time_prob
          _snake_case				= mask_time_length
          _snake_case				= mask_time_min_masks
          _snake_case				= mask_feature_prob
          _snake_case				= mask_feature_length
          _snake_case				= mask_feature_min_masks

          # parameters for pretraining with codevector quantized representations
          _snake_case				= num_codevectors_per_group
          _snake_case				= num_codevector_groups
          _snake_case				= contrastive_logits_temperature
          _snake_case				= feat_quantizer_dropout
          _snake_case				= num_negatives
          _snake_case				= codevector_dim
          _snake_case				= proj_codevector_dim
          _snake_case				= diversity_loss_weight

          # ctc loss
          _snake_case				= ctc_loss_reduction
          _snake_case				= ctc_zero_infinity

          # SequenceClassification-specific parameter. Feel free to ignore for other classes.
          _snake_case				= classifier_proj_size

          # XVector-specific parameters. Feel free to ignore for other classes.
          _snake_case				= list(_SCREAMING_SNAKE_CASE       )
          _snake_case				= list(_SCREAMING_SNAKE_CASE       )
          _snake_case				= list(_SCREAMING_SNAKE_CASE       )
          _snake_case				= xvector_output_dim






     @property
     def 							_lowercase      (					self       )				->     List[str]:
          return functools.reduce(operator.mul   ,self.conv_stride   ,1       )


