

"""simple docstring"""






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


_lowerCAmelCase						=		logging.get_logger(__name__)

_lowerCAmelCase						=		{
    """speechbrain/m-ctc-t-large""": """https://huggingface.co/speechbrain/m-ctc-t-large/resolve/main/config.json""",
    # See all M-CTC-T models at https://huggingface.co/models?filter=mctct
}







class 	__UpperCamelCase    (    a__						):
  _UpperCAmelCase          =		"mctct"

  def __init__(		self    ,_A=8065    ,_A=1536    ,_A=36    ,_A=6144    ,_A=4    ,_A=384    ,_A=920    ,_A=1E-5    ,_A=0.3    ,_A="relu"    ,_A=0.0_2    ,_A=0.3    ,_A=0.3    ,_A=1    ,_A=0    ,_A=2    ,_A=1    ,_A=0.3    ,_A=1    ,_A=(7,)    ,_A=(3,)    ,_A=80    ,_A=1    ,_A=None    ,_A="sum"    ,_A=False    ,**_A    ,):
      '''simple docstring'''

      super().__init__(**_A    ,pad_token_id=_A    ,bos_token_id=_A    ,eos_token_id=_A      )
      _lowerCAmelCase       :   List[Any]  =    vocab_size
      _lowerCAmelCase       :   Optional[Any]  =    hidden_size
      _lowerCAmelCase       :   List[str]  =    num_hidden_layers
      _lowerCAmelCase       :   Union[str, Any]  =    intermediate_size
      _lowerCAmelCase       :   List[str]  =    num_attention_heads
      _lowerCAmelCase       :   Optional[Any]  =    attention_head_dim
      _lowerCAmelCase       :   Optional[int]  =    max_position_embeddings
      _lowerCAmelCase       :   List[str]  =    layer_norm_eps
      _lowerCAmelCase       :   Dict  =    layerdrop
      _lowerCAmelCase       :   Optional[Any]  =    hidden_act
      _lowerCAmelCase       :   Tuple  =    initializer_range
      _lowerCAmelCase       :   Optional[int]  =    hidden_dropout_prob
      _lowerCAmelCase       :   Dict  =    attention_probs_dropout_prob
      _lowerCAmelCase       :   Union[str, Any]  =    pad_token_id
      _lowerCAmelCase       :   Any  =    bos_token_id
      _lowerCAmelCase       :   Union[str, Any]  =    eos_token_id
      _lowerCAmelCase       :   str  =    conv_glu_dim
      _lowerCAmelCase       :   int  =    conv_dropout
      _lowerCAmelCase       :   str  =    num_conv_layers
      _lowerCAmelCase       :   Union[str, Any]  =    input_feat_per_channel
      _lowerCAmelCase       :   Any  =    input_channels
      _lowerCAmelCase       :   Optional[int]  =    conv_channels
      _lowerCAmelCase       :   str  =    ctc_loss_reduction
      _lowerCAmelCase       :   str  =    ctc_zero_infinity

      # prevents config testing fail with exporting to json
      _lowerCAmelCase       :   Any  =    list(_A      )
      _lowerCAmelCase       :   List[Any]  =    list(_A      )

      if len(self.conv_kernel      ) != self.num_conv_layers:
          raise ValueError(
              'Configuration for convolutional module is incorrect. '
              'It is required that `len(config.conv_kernel)` == `config.num_conv_layers` '
              F"""but is `len(config.conv_kernel) = {len(self.conv_kernel      )}`, """
              F"""`config.num_conv_layers = {self.num_conv_layers}`."""      )








"""simple docstring"""






import inspect
import os
import unittest

import torch

import accelerate
from accelerate import Accelerator
from accelerate.test_utils import execute_subprocess_async, require_multi_gpu
from accelerate.utils import patch_environment







class 	__UpperCamelCase    (    unittest.TestCase						):

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Dict  =    inspect.getfile(accelerate.test_utils      )
      _lowerCAmelCase       :   Union[str, Any]  =    os.path.sep.join(mod_file.split(os.path.sep      )[:-1] + ['scripts', 'test_script.py']      )
      _lowerCAmelCase       :   int  =    os.path.sep.join(
          mod_file.split(os.path.sep      )[:-1] + ['scripts', 'test_distributed_data_loop.py']      )
      _lowerCAmelCase       :   Optional[Any]  =    os.path.sep.join(mod_file.split(os.path.sep      )[:-1] + ['scripts', 'test_ops.py']      )

  @require_multi_gpu
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      print(F"""Found {torch.cuda.device_count()} devices."""      )
      _lowerCAmelCase       :   int  =    ['torchrun', F"""--nproc_per_node={torch.cuda.device_count()}""", self.test_file_path]
      with patch_environment(omp_num_threads=1      ):
          execute_subprocess_async(_A    ,env=os.environ.copy()      )

  @require_multi_gpu
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      print(F"""Found {torch.cuda.device_count()} devices."""      )
      _lowerCAmelCase       :   str  =    ['torchrun', F"""--nproc_per_node={torch.cuda.device_count()}""", self.operation_file_path]
      print(F"""Command: {cmd}"""      )
      with patch_environment(omp_num_threads=1      ):
          execute_subprocess_async(_A    ,env=os.environ.copy()      )

  @require_multi_gpu
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   List[Any]  =    ['torchrun', F"""--nproc_per_node={torch.cuda.device_count()}""", inspect.getfile(self.__class__      )]
      with patch_environment(omp_num_threads=1      ):
          execute_subprocess_async(_A    ,env=os.environ.copy()      )







  @require_multi_gpu
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      print(F"""Found {torch.cuda.device_count()} devices, using 2 devices only"""      )
      _lowerCAmelCase       :   Tuple  =    ['torchrun', F"""--nproc_per_node={torch.cuda.device_count()}""", self.data_loop_file_path]
      with patch_environment(omp_num_threads=1    ,cuda_visible_devices='0,1'      ):
          execute_subprocess_async(_A    ,env=os.environ.copy()      )


if __name__ == "__main__":
 _lowerCAmelCase						=		Accelerator()
 _lowerCAmelCase						=		(accelerator.state.process_index + 2, 1_0)
 _lowerCAmelCase						=		torch.randint(0, 1_0, shape).to(accelerator.device)

 _lowerCAmelCase						=		""""""

 _lowerCAmelCase						=		accelerator.pad_across_processes(tensor)
 if tensora.shape[0] != accelerator.state.num_processes + 1:
  error_msg += F"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
 if not torch.equal(tensora[: accelerator.state.process_index + 2], tensor):
  error_msg += "Tensors have different values."
 if not torch.all(tensora[accelerator.state.process_index + 2 :] == 0):
  error_msg += "Padding was not done with the right value (0)."

 _lowerCAmelCase						=		accelerator.pad_across_processes(tensor, pad_first=True)
 if tensora.shape[0] != accelerator.state.num_processes + 1:
  error_msg += F"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
 _lowerCAmelCase						=		accelerator.state.num_processes - accelerator.state.process_index - 1
 if not torch.equal(tensora[index:], tensor):
  error_msg += "Tensors have different values."
 if not torch.all(tensora[:index] == 0):
  error_msg += "Padding was not done with the right value (0)."

 # Raise error at the end to make sure we don't stop at the first failure.
 if len(error_msg) > 0:
  raise ValueError(error_msg)





