





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

import torch_xla.distributed.xla_multiprocessing as xmp


def 							__snake_case							(    )				->						Union[str, Any]:
    SCREAMING_SNAKE_CASE__											=			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=lowerCAmelCase_ ,							default=1 ,							help='''Number of TPU cores to use (1 or 8).'''	)

    # positional
    parser.add_argument(
        '''training_script''' ,							type=lowerCAmelCase_ ,							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=lowerCAmelCase_	)

    return parser.parse_args()


def 							__snake_case							(    )				->						int:
    SCREAMING_SNAKE_CASE__											=			parse_args()

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

    # Patch sys.argv
    SCREAMING_SNAKE_CASE__											=			[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 unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation







class        UpperCAmelCase_			(			unittest.TestCase      ):
    """simple docstring"""







    def lowerCamelCase			(       self   :	Union[str, Any]		):
          snake_case__    :       int       		= get_activation("""swish"""		)

          self.assertIsInstance(snake_case_					,	nn.SiLU		)

          self.assertEqual(act(torch.tensor(-100					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertNotEqual(act(torch.tensor(-1					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(0					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(20					,	dtype=torch.floataa		)		).item()					,	20		)




    def lowerCamelCase			(       self   :	Optional[Any]		):
          snake_case__    :       int       		= get_activation("""silu"""		)

          self.assertIsInstance(snake_case_					,	nn.SiLU		)

          self.assertEqual(act(torch.tensor(-100					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertNotEqual(act(torch.tensor(-1					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(0					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(20					,	dtype=torch.floataa		)		).item()					,	20		)




    def lowerCamelCase			(       self   :	Dict		):
          snake_case__    :       Union[str, Any]       		= get_activation("""mish"""		)

          self.assertIsInstance(snake_case_					,	nn.Mish		)

          self.assertEqual(act(torch.tensor(-200					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertNotEqual(act(torch.tensor(-1					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(0					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(20					,	dtype=torch.floataa		)		).item()					,	20		)




    def lowerCamelCase			(       self   :	Union[str, Any]		):
          snake_case__    :       int       		= get_activation("""gelu"""		)

          self.assertIsInstance(snake_case_					,	nn.GELU		)

          self.assertEqual(act(torch.tensor(-100					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertNotEqual(act(torch.tensor(-1					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(0					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(20					,	dtype=torch.floataa		)		).item()					,	20		)
