


"""simple docstring"""




import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch


if is_torch_available():
				import torch

				from transformers.activations import gelu_new, gelu_python, get_activation
@require_torch
class 					__lowerCAmelCase					(   unittest.TestCase       ):


		'''simple docstring'''



		def 			__UpperCAmelCase       (  self      ):
				__a           =			torch.tensor([-100, -1, -0.1, 0, 0.1, 1.0, 100]      )
				__a           =			get_activation('''gelu'''      )
				self.assertTrue(torch.allclose(gelu_python(_a      )							, torch_builtin(_a      )      )      )
				self.assertFalse(torch.allclose(gelu_python(_a      )							, gelu_new(_a      )      )      )

		def 			__UpperCAmelCase       (  self      ):
				__a           =			torch.tensor([-100, -1, -0.1, 0, 0.1, 1.0, 100]      )
				__a           =			get_activation('''gelu'''      )
				__a           =			get_activation('''gelu_10'''      )

				__a           =			torch_builtin(_a      )
				__a           =			geluaa(_a      )

				__a           =			torch.where(y_gelu_aa < 10.0							, 1							, 0      )

				self.assertTrue(torch.max(_a      ).item() == 10.0      )
				self.assertTrue(torch.allclose(y_gelu * clipped_mask							, y_gelu_aa * clipped_mask      )      )

		def 			__UpperCAmelCase       (  self      ):
				get_activation('''gelu'''      )
				get_activation('''gelu_10'''      )
				get_activation('''gelu_fast'''      )
				get_activation('''gelu_new'''      )
				get_activation('''gelu_python'''      )
				get_activation('''gelu_pytorch_tanh'''      )
				get_activation('''linear'''      )
				get_activation('''mish'''      )
				get_activation('''quick_gelu'''      )
				get_activation('''relu'''      )
				get_activation('''sigmoid'''      )
				get_activation('''silu'''      )
				get_activation('''swish'''      )
				get_activation('''tanh'''      )
				with self.assertRaises(_a      ):
						get_activation('''bogus'''      )
				with self.assertRaises(_a      ):
						get_activation(_a      )





		def 			__UpperCAmelCase       (  self      ):
				__a           =			get_activation('''gelu'''      )
				__a           =			1
				__a           =			get_activation('''gelu'''      )
				self.assertEqual(acta.a							, 1      )
				with self.assertRaises(_a      ):
						__a           =			acta.a










"""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 					__lowerCAmelCase					(   unittest.TestCase       ):


		'''simple docstring'''



		def 			__UpperCAmelCase       (  self      ):
				__a           =			inspect.getfile(accelerate.test_utils      )
				__a           =			os.path.sep.join(mod_file.split(os.path.sep      )[:-1] + ['''scripts''', '''test_script.py''']      )
				__a           =			os.path.sep.join(
				    mod_file.split(os.path.sep      )[:-1] + ['''scripts''', '''test_distributed_data_loop.py''']      )
				__a           =			os.path.sep.join(mod_file.split(os.path.sep      )[:-1] + ['''scripts''', '''test_ops.py''']      )

		@require_multi_gpu
		def 			__UpperCAmelCase       (  self      ):
				print(f'''Found {torch.cuda.device_count()} devices.'''      )
				__a           =			['''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 			__UpperCAmelCase       (  self      ):
				print(f'''Found {torch.cuda.device_count()} devices.'''      )
				__a           =			['''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 			__UpperCAmelCase       (  self      ):
				__a           =			['''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 			__UpperCAmelCase       (  self      ):
				print(f'''Found {torch.cuda.device_count()} devices, using 2 devices only'''      )
				__a           =			['''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__":
				lowercase_			     =  Accelerator()
				lowercase_			     =  (accelerator.state.process_index + 2, 1_0)
				lowercase_			     =  torch.randint(0, 1_0, shape).to(accelerator.device)

				lowercase_			     =  ""

				lowercase_			     =  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)."

				lowercase_			     =  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."
				lowercase_			     =  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)






