





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      _snake_case  (							self    :Any		)   ->   int:



         """simple docstring"""



         SCREAMING_SNAKE_CASE__			=      inspect.getfile(accelerate.test_utils		)
         SCREAMING_SNAKE_CASE__			=      os.path.sep.join(mod_file.split(os.path.sep		)[:-1] + ["""scripts""", """test_script.py"""]		)
         SCREAMING_SNAKE_CASE__			=      os.path.sep.join(
             mod_file.split(os.path.sep		)[:-1] + ["""scripts""", """test_distributed_data_loop.py"""]		)
         SCREAMING_SNAKE_CASE__			=      os.path.sep.join(mod_file.split(os.path.sep		)[:-1] + ["""scripts""", """test_ops.py"""]		)


       @require_multi_gpu
       def      _snake_case  (							self    :Optional[Any]		)   ->   Tuple:



         """simple docstring"""



         print(f'''Found {torch.cuda.device_count()} devices.'''		)
         SCREAMING_SNAKE_CASE__			=      ["""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      _snake_case  (							self    :Tuple		)   ->   Optional[Any]:



         """simple docstring"""



         print(f'''Found {torch.cuda.device_count()} devices.'''		)
         SCREAMING_SNAKE_CASE__			=      ["""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      _snake_case  (							self    :Optional[Any]		)   ->   Union[str, Any]:



         """simple docstring"""



         SCREAMING_SNAKE_CASE__			=      ["""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      _snake_case  (							self    :Optional[int]		)   ->   str:



         """simple docstring"""



         print(f'''Found {torch.cuda.device_count()} devices, using 2 devices only'''		)
         SCREAMING_SNAKE_CASE__			=      ["""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, 10)
 _lowerCamelCase   				=			torch.randint(0, 10, 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)






import unittest

from datasets import load_dataset

from transformers.pipelines import pipeline
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_torch, slow




@is_pipeline_test
@require_torch
class   UpperCamelCase_       (     unittest.TestCase    ):


							@require_torch
							def      _snake_case  (							self    :Dict		)   ->   Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      pipeline(
									    task="""zero-shot-audio-classification"""							,				model="""hf-internal-testing/tiny-clap-htsat-unfused"""		)
									SCREAMING_SNAKE_CASE__			=      load_dataset("""ashraq/esc50"""		)
									SCREAMING_SNAKE_CASE__			=      dataset["""train"""]["""audio"""][-1]["""array"""]
									SCREAMING_SNAKE_CASE__			=      audio_classifier(__A							,				candidate_labels=["""Sound of a dog""", """Sound of vaccum cleaner"""]		)
									self.assertEqual(
									    nested_simplify(__A		)							,				[{"""score""": 0.5_0_1, """label""": """Sound of a dog"""}, {"""score""": 0.4_9_9, """label""": """Sound of vaccum cleaner"""}]							,				)


							@unittest.skip("""No models are available in TF"""		)
							def      _snake_case  (							self    :Dict		)   ->   List[str]:



									"""simple docstring"""



									pass


							@slow
							@require_torch
							def      _snake_case  (							self    :Any		)   ->   int:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      pipeline(
									    task="""zero-shot-audio-classification"""							,				model="""laion/clap-htsat-unfused"""							,				)
									# This is an audio of a dog
									SCREAMING_SNAKE_CASE__			=      load_dataset("""ashraq/esc50"""		)
									SCREAMING_SNAKE_CASE__			=      dataset["""train"""]["""audio"""][-1]["""array"""]
									SCREAMING_SNAKE_CASE__			=      audio_classifier(__A							,				candidate_labels=["""Sound of a dog""", """Sound of vaccum cleaner"""]		)

									self.assertEqual(
									    nested_simplify(__A		)							,				[
									        {"""score""": 0.9_9_9, """label""": """Sound of a dog"""},
									        {"""score""": 0.0_0_1, """label""": """Sound of vaccum cleaner"""},
									    ]							,				)

									SCREAMING_SNAKE_CASE__			=      audio_classifier([audio] * 5							,				candidate_labels=["""Sound of a dog""", """Sound of vaccum cleaner"""]		)
									self.assertEqual(
									    nested_simplify(__A		)							,				[
									        [
									            {"""score""": 0.9_9_9, """label""": """Sound of a dog"""},
									            {"""score""": 0.0_0_1, """label""": """Sound of vaccum cleaner"""},
									        ],
									    ]
									    * 5							,				)
									SCREAMING_SNAKE_CASE__			=      audio_classifier(
									    [audio] * 5							,				candidate_labels=["""Sound of a dog""", """Sound of vaccum cleaner"""]							,				batch_size=5		)
									self.assertEqual(
									    nested_simplify(__A		)							,				[
									        [
									            {"""score""": 0.9_9_9, """label""": """Sound of a dog"""},
									            {"""score""": 0.0_0_1, """label""": """Sound of vaccum cleaner"""},
									        ],
									    ]
									    * 5							,				)


							@unittest.skip("""No models are available in TF"""		)
							def      _snake_case  (							self    :str		)   ->   Optional[int]:



									"""simple docstring"""



									pass