





import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp

def   a_    ( ):
   __lowerCAmelCase								=	ArgumentParser(
       description=(
           'PyTorch TPU distributed training launch helper utility that will spawn up multiple distributed processes'
       )	)

   # Optional arguments for the launch helper
   parser.add_argument('--num_cores',	type=__a,	default=1,	help='Number of TPU cores to use (1 or 8).'	)

   # positional
   parser.add_argument(
       'training_script',	type=__a,	help=(
           'The full path to the single TPU training '
           'program/script to be launched in parallel, '
           'followed by all the arguments for the '
           'training script'
       ),	)

   # rest from the training program
   parser.add_argument('training_script_args',	nargs=__a	)

   return parser.parse_args()

def   a_    ( ):
   __lowerCAmelCase								=	parse_args()

   # Import training_script as a module.
   __lowerCAmelCase								=	Path(args.training_script	)
   sys.path.append(str(script_fpath.parent.resolve()	)	)
   __lowerCAmelCase								=	script_fpath.stem
   __lowerCAmelCase								=	importlib.import_module(__a	)

   # Patch sys.argv
   __lowerCAmelCase								=	[args.training_script] + args.training_script_args + ['--tpu_num_cores', str(args.num_cores	)]

   xmp.spawn(mod._mp_fn,	args=(),	nprocs=args.num_cores	)


if __name__ == "__main__":
     main()



'''simple docstring'''







import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin







class UpperCAmelCase__	( lowercase__	):





  """simple docstring"""

  __UpperCAmelCase				:				Union[str, Any]   =					None
  __UpperCAmelCase				:				List[Any]   =					None


  @property
  def   __lowercase		(		self      :     Dict       ):


     '''simple docstring'''






     return self.feat_extract_tester.prepare_feat_extract_dict()


  def   __lowercase		(		self      :     str       ):


     '''simple docstring'''






     _a				:	Dict			=   self.feature_extraction_class(**self.feat_extract_dict       )
     self.assertTrue(hasattr(_a							,'feature_size'       )       )
     self.assertTrue(hasattr(_a							,'sampling_rate'       )       )
     self.assertTrue(hasattr(_a							,'padding_value'       )       )


  def   __lowercase		(		self      :     int       ):


     '''simple docstring'''






     _a				:	Any			=   self.feat_extract_tester.prepare_inputs_for_common()
     _a				:	str			=   self.feature_extraction_class(**self.feat_extract_dict       )
     _a				:	int			=   feat_extract.model_input_names[0]

     _a				:	List[Any]			=   BatchFeature({input_name: speech_inputs}       )

     self.assertTrue(all(len(_a       ) == len(_a       ) for x, y in zip(_a							,processed_features[input_name]       )       )       )

     _a				:	Any			=   self.feat_extract_tester.prepare_inputs_for_common(equal_length=_a       )
     _a				:	Union[str, Any]			=   BatchFeature({input_name: speech_inputs}							,tensor_type='np'       )

     _a				:	Union[str, Any]			=   processed_features[input_name]

     if len(batch_features_input.shape       ) < 3:
        _a				:	Optional[int]			=   batch_features_input[:, :, None]

     self.assertTrue(
         batch_features_input.shape
         == (self.feat_extract_tester.batch_size, len(speech_inputs[0]       ), self.feat_extract_tester.feature_size)       )


  @require_torch
  def   __lowercase		(		self      :     Any       ):


     '''simple docstring'''






     _a				:	List[Any]			=   self.feat_extract_tester.prepare_inputs_for_common(equal_length=_a       )
     _a				:	Dict			=   self.feature_extraction_class(**self.feat_extract_dict       )
     _a				:	int			=   feat_extract.model_input_names[0]

     _a				:	str			=   BatchFeature({input_name: speech_inputs}							,tensor_type='pt'       )

     _a				:	str			=   processed_features[input_name]

     if len(batch_features_input.shape       ) < 3:
        _a				:	str			=   batch_features_input[:, :, None]

     self.assertTrue(
         batch_features_input.shape
         == (self.feat_extract_tester.batch_size, len(speech_inputs[0]       ), self.feat_extract_tester.feature_size)       )


  @require_tf
  def   __lowercase		(		self      :     int       ):


     '''simple docstring'''






     _a				:	int			=   self.feat_extract_tester.prepare_inputs_for_common(equal_length=_a       )
     _a				:	Dict			=   self.feature_extraction_class(**self.feat_extract_dict       )
     _a				:	Tuple			=   feat_extract.model_input_names[0]

     _a				:	int			=   BatchFeature({input_name: speech_inputs}							,tensor_type='tf'       )

     _a				:	Optional[int]			=   processed_features[input_name]

     if len(batch_features_input.shape       ) < 3:
        _a				:	Optional[Any]			=   batch_features_input[:, :, None]

     self.assertTrue(
         batch_features_input.shape
         == (self.feat_extract_tester.batch_size, len(speech_inputs[0]       ), self.feat_extract_tester.feature_size)       )


  def   __lowercase		(		self      :     Dict							,_a      :     Any=False       ):


     '''simple docstring'''






     def _inputs_have_equal_length(_a      :     Tuple       ):
        _a				:	Tuple			=   len(input[0]       )
        for input_slice in input[1:]:
           if len(_a       ) != length:
              return False
        return True

     def _inputs_are_equal(_a      :     Optional[Any]							,_a      :     Union[str, Any]       ):
        if len(_a       ) != len(_a       ):
           return False

        for input_slice_a, input_slice_a in zip(_a							,_a       ):
           if not np.allclose(np.asarray(_a       )							,np.asarray(_a       )							,atol=1E-3       ):
              return False
        return True

     _a				:	int			=   self.feature_extraction_class(**self.feat_extract_dict       )
     _a				:	Tuple			=   self.feat_extract_tester.prepare_inputs_for_common(numpify=_a       )
     _a				:	Union[str, Any]			=   feat_extract.model_input_names[0]

     _a				:	Tuple			=   BatchFeature({input_name: speech_inputs}       )

     _a				:	str			=   self.feat_extract_tester.seq_length_diff
     _a				:	Dict			=   self.feat_extract_tester.max_seq_length + pad_diff
     _a				:	Dict			=   self.feat_extract_tester.min_seq_length
     _a				:	Optional[Any]			=   self.feat_extract_tester.batch_size
     _a				:	Tuple			=   self.feat_extract_tester.feature_size

     # test padding for List[int] + numpy
     _a				:	int			=   feat_extract.pad(_a							,padding=_a       )
     _a				:	List[Any]			=   input_a[input_name]

     _a				:	Tuple			=   feat_extract.pad(_a							,padding='longest'       )
     _a				:	Any			=   input_a[input_name]

     _a				:	Optional[Any]			=   feat_extract.pad(_a							,padding='max_length'							,max_length=len(speech_inputs[-1]       )       )
     _a				:	List[str]			=   input_a[input_name]

     _a				:	List[str]			=   feat_extract.pad(_a							,padding='longest'							,return_tensors='np'       )
     _a				:	str			=   input_a[input_name]

     # max_length parameter has to be provided when setting `padding="max_length"`
     with self.assertRaises(_a       ):
        feat_extract.pad(_a							,padding='max_length'       )[input_name]

     _a				:	int			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=_a							,return_tensors='np'       )
     _a				:	Optional[int]			=   input_a[input_name]

     self.assertFalse(_inputs_have_equal_length(_a       )       )
     self.assertTrue(_inputs_have_equal_length(_a       )       )
     self.assertTrue(_inputs_have_equal_length(_a       )       )
     self.assertTrue(_inputs_are_equal(_a							,_a       )       )
     self.assertTrue(len(input_a[0]       ) == pad_min_length       )
     self.assertTrue(len(input_a[1]       ) == pad_min_length + pad_diff       )
     self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0]       ))       )
     self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length)       )

     if feature_size > 1:
        self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size       )

     # test padding for `pad_to_multiple_of` for List[int] + numpy
     _a				:	Tuple			=   feat_extract.pad(_a							,pad_to_multiple_of=10       )
     _a				:	List[str]			=   input_a[input_name]

     _a				:	str			=   feat_extract.pad(_a							,padding='longest'							,pad_to_multiple_of=10       )
     _a				:	Tuple			=   input_a[input_name]

     _a				:	Optional[int]			=   feat_extract.pad(
         _a							,padding='max_length'							,pad_to_multiple_of=10							,max_length=_a       )
     _a				:	Any			=   input_a[input_name]

     _a				:	Optional[int]			=   feat_extract.pad(
         _a							,padding='max_length'							,pad_to_multiple_of=10							,max_length=_a							,return_tensors='np'							,)
     _a				:	Dict			=   input_a[input_name]

     self.assertTrue(all(len(_a       ) % 10 == 0 for x in input_a       )       )
     self.assertTrue(_inputs_are_equal(_a							,_a       )       )

     _a				:	List[str]			=   pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
     self.assertTrue(all(len(_a       ) == expected_mult_pad_length for x in input_a       )       )
     self.assertEqual(input_a.shape[:2]							,(batch_size, expected_mult_pad_length)       )

     if feature_size > 1:
        self.assertTrue(input_a.shape[2] == feature_size       )

     # Check padding value is correct
     _a				:	Any			=   (np.ones(self.feat_extract_tester.feature_size       ) * feat_extract.padding_value).sum()
     self.assertTrue(
         abs(np.asarray(input_a[0]       )[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)       )
         < 1E-3       )
     self.assertTrue(
         abs(
             np.asarray(input_a[1]       )[pad_min_length + pad_diff :].sum()
             - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff)       )
         < 1E-3       )
     self.assertTrue(
         abs(
             np.asarray(input_a[2]       )[pad_min_length + 2 * pad_diff :].sum()
             - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff)       )
         < 1E-3       )
     self.assertTrue(
         abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)       ) < 1E-3       )
     self.assertTrue(
         abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length)       )
         < 1E-3       )


  def   __lowercase		(		self      :     List[Any]							,_a      :     Optional[int]=False       ):


     '''simple docstring'''






     def _inputs_have_equal_length(_a      :     List[str]       ):
        _a				:	Union[str, Any]			=   len(input[0]       )
        for input_slice in input[1:]:
           if len(_a       ) != length:
              return False
        return True

     def _inputs_are_equal(_a      :     List[str]							,_a      :     List[str]       ):
        if len(_a       ) != len(_a       ):
           return False

        for input_slice_a, input_slice_a in zip(_a							,_a       ):
           if not np.allclose(np.asarray(_a       )							,np.asarray(_a       )							,atol=1E-3       ):
              return False
        return True

     _a				:	Dict			=   self.feature_extraction_class(**self.feat_extract_dict       )
     _a				:	str			=   self.feat_extract_tester.prepare_inputs_for_common(numpify=_a       )
     _a				:	Any			=   feat_extract.model_input_names[0]

     _a				:	List[Any]			=   BatchFeature({input_name: speech_inputs}       )

     # truncate to smallest
     _a				:	Union[str, Any]			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=len(speech_inputs[0]       )							,truncation=_a       )
     _a				:	str			=   input_a[input_name]

     _a				:	List[str]			=   feat_extract.pad(_a							,padding='max_length'							,max_length=len(speech_inputs[0]       )       )
     _a				:	Tuple			=   input_a[input_name]

     self.assertTrue(_inputs_have_equal_length(_a       )       )
     self.assertFalse(_inputs_have_equal_length(_a       )       )

     # truncate to smallest with np
     _a				:	Dict			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=len(speech_inputs[0]       )							,return_tensors='np'							,truncation=_a							,)
     _a				:	Any			=   input_a[input_name]

     _a				:	List[Any]			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=len(speech_inputs[0]       )							,return_tensors='np'       )
     _a				:	int			=   input_a[input_name]

     self.assertTrue(_inputs_have_equal_length(_a       )       )
     self.assertTrue(input_a.shape[1] == len(speech_inputs[0]       )       )

     # since truncation forces padding to be smaller than longest input
     # function can't return `np.ndarray`, but has to return list
     self.assertFalse(_inputs_have_equal_length(_a       )       )

     # truncate to middle
     _a				:	Dict			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=len(speech_inputs[1]       )							,truncation=_a							,return_tensors='np'							,)
     _a				:	List[Any]			=   input_a[input_name]

     _a				:	Tuple			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=len(speech_inputs[1]       )							,truncation=_a       )
     _a				:	Tuple			=   input_a[input_name]

     _a				:	Tuple			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=len(speech_inputs[1]       )							,return_tensors='np'       )
     _a				:	Dict			=   input_a[input_name]

     self.assertTrue(input_a.shape[1] == len(speech_inputs[1]       )       )
     self.assertTrue(_inputs_have_equal_length(_a       )       )
     self.assertTrue(_inputs_have_equal_length(_a       )       )
     self.assertTrue(_inputs_are_equal(_a							,_a       )       )

     # since truncation forces padding to be smaller than longest input
     # function can't return `np.ndarray`, but has to return list
     self.assertFalse(_inputs_have_equal_length(_a       )       )
     self.assertTrue(len(input_a[-1]       ) == len(speech_inputs[-1]       )       )

     # padding has to be max_length when setting `truncation=True`
     with self.assertRaises(_a       ):
        feat_extract.pad(_a							,truncation=_a       )[input_name]

     # padding has to be max_length when setting `truncation=True`
     with self.assertRaises(_a       ):
        feat_extract.pad(_a							,padding='longest'							,truncation=_a       )[input_name]

     # padding has to be max_length when setting `truncation=True`
     with self.assertRaises(_a       ):
        feat_extract.pad(_a							,padding='longest'							,truncation=_a       )[input_name]

     # max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
     with self.assertRaises(_a       ):
        feat_extract.pad(_a							,padding='max_length'							,truncation=_a       )[input_name]

     # test truncation for `pad_to_multiple_of` for List[int] + numpy
     _a				:	Optional[Any]			=   12
     _a				:	List[Any]			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=len(speech_inputs[0]       )							,pad_to_multiple_of=_a							,truncation=_a							,)
     _a				:	Tuple			=   input_a[input_name]

     _a				:	str			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=len(speech_inputs[0]       )							,pad_to_multiple_of=_a							,)
     _a				:	List[Any]			=   input_a[input_name]

     # retrieve expected_length as multiple of pad_to_multiple_of
     _a				:	List[Any]			=   len(speech_inputs[0]       )
     if expected_length % pad_to_multiple_of != 0:
        _a				:	Union[str, Any]			=   ((len(speech_inputs[0]       ) // pad_to_multiple_of) + 1) * pad_to_multiple_of

     self.assertTrue(len(input_a[0]       ) == expected_length       )
     self.assertTrue(_inputs_have_equal_length(_a       )       )
     self.assertFalse(_inputs_have_equal_length(_a       )       )


  def   __lowercase		(		self      :     Union[str, Any]       ):


     '''simple docstring'''






     self._check_padding(numpify=_a       )


  def   __lowercase		(		self      :     Tuple       ):


     '''simple docstring'''






     self._check_padding(numpify=_a       )


  def   __lowercase		(		self      :     Dict       ):


     '''simple docstring'''






     self._check_truncation(numpify=_a       )


  def   __lowercase		(		self      :     str       ):


     '''simple docstring'''






     self._check_truncation(numpify=_a       )


  @require_torch
  def   __lowercase		(		self      :     Dict       ):


     '''simple docstring'''






     _a				:	Any			=   self.feature_extraction_class(**self.feat_extract_dict       )
     _a				:	List[Any]			=   self.feat_extract_tester.prepare_inputs_for_common()
     _a				:	Union[str, Any]			=   feat_extract.model_input_names[0]

     _a				:	Optional[int]			=   BatchFeature({input_name: speech_inputs}       )

     _a				:	List[Any]			=   feat_extract.pad(_a							,padding='longest'							,return_tensors='np'       )[input_name]
     _a				:	List[str]			=   feat_extract.pad(_a							,padding='longest'							,return_tensors='pt'       )[input_name]

     self.assertTrue(abs(input_np.astype(np.floataa       ).sum() - input_pt.numpy().astype(np.floataa       ).sum()       ) < 1E-2       )


  @require_tf
  def   __lowercase		(		self      :     int       ):


     '''simple docstring'''






     _a				:	List[str]			=   self.feature_extraction_class(**self.feat_extract_dict       )
     _a				:	Optional[Any]			=   self.feat_extract_tester.prepare_inputs_for_common()
     _a				:	Dict			=   feat_extract.model_input_names[0]

     _a				:	Optional[Any]			=   BatchFeature({input_name: speech_inputs}       )

     _a				:	Dict			=   feat_extract.pad(_a							,padding='longest'							,return_tensors='np'       )[input_name]
     _a				:	Any			=   feat_extract.pad(_a							,padding='longest'							,return_tensors='tf'       )[input_name]

     self.assertTrue(abs(input_np.astype(np.floataa       ).sum() - input_tf.numpy().astype(np.floataa       ).sum()       ) < 1E-2       )


  def   __lowercase		(		self      :     Union[str, Any]       ):


     '''simple docstring'''






     _a				:	str			=   self.feat_extract_dict
     _a				:	List[Any]			=   True
     _a				:	Optional[int]			=   self.feature_extraction_class(**_a       )
     _a				:	List[Any]			=   self.feat_extract_tester.prepare_inputs_for_common()
     _a				:	Tuple			=   [len(_a       ) for x in speech_inputs]
     _a				:	int			=   feat_extract.model_input_names[0]

     _a				:	Optional[Any]			=   BatchFeature({input_name: speech_inputs}       )

     _a				:	str			=   feat_extract.pad(_a							,padding='longest'							,return_tensors='np'       )
     self.assertIn('attention_mask'							,_a       )
     self.assertListEqual(list(processed.attention_mask.shape       )							,list(processed[input_name].shape[:2]       )       )
     self.assertListEqual(processed.attention_mask.sum(-1       ).tolist()							,_a       )


  def   __lowercase		(		self      :     int       ):


     '''simple docstring'''






     _a				:	Any			=   self.feat_extract_dict
     _a				:	Tuple			=   True
     _a				:	Optional[int]			=   self.feature_extraction_class(**_a       )
     _a				:	Dict			=   self.feat_extract_tester.prepare_inputs_for_common()
     _a				:	Dict			=   [len(_a       ) for x in speech_inputs]
     _a				:	Union[str, Any]			=   feat_extract.model_input_names[0]

     _a				:	Any			=   BatchFeature({input_name: speech_inputs}       )
     _a				:	List[Any]			=   min(_a       )

     _a				:	Dict			=   feat_extract.pad(
         _a							,padding='max_length'							,max_length=_a							,truncation=_a							,return_tensors='np'       )
     self.assertIn('attention_mask'							,_a       )
     self.assertListEqual(
         list(processed_pad.attention_mask.shape       )							,[processed_pad[input_name].shape[0], max_length]       )
     self.assertListEqual(
         processed_pad.attention_mask[:, :max_length].sum(-1       ).tolist()							,[max_length for x in speech_inputs]       )



