





'''simple docstring'''


import os
import sys
import tempfile

import torch

from .state import AcceleratorState
from .utils import PrecisionType, PrepareForLaunch, is_mps_available, patch_environment


def 						__a(SCREAMING_SNAKE_CASE_	:       List[Any]		,							SCREAMING_SNAKE_CASE_	:       Optional[int]=()		,							SCREAMING_SNAKE_CASE_	:       Optional[int]=None		,							SCREAMING_SNAKE_CASE_	:       Optional[Any]="no"		,							SCREAMING_SNAKE_CASE_	:       Any="29500"     ):



    '''simple docstring'''





    _lowerCAmelCase						      =   False
    _lowerCAmelCase						      =   False
    if any(key.startswith("KAGGLE"     ) for key in os.environ.keys()     ):
        _lowerCAmelCase						      =   True
    elif "IPython" in sys.modules:
        _lowerCAmelCase						      =   "google.colab" in str(sys.modules["IPython"].get_ipython()     )

    try:
        _lowerCAmelCase						      =   PrecisionType(mixed_precision.lower()     )
    except ValueError:
        raise ValueError(
            F'''Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}.'''     )

    if (in_colab or in_kaggle) and (os.environ.get("TPU_NAME"		,							SCREAMING_SNAKE_CASE_     ) is not None):
        # TPU launch
        import torch_xla.distributed.xla_multiprocessing as xmp

        if len(AcceleratorState._shared_state     ) > 0:
            raise ValueError(
                "To train on TPU in Colab or Kaggle Kernel, the `Accelerator` should only be initialized inside "
                "your training function. Restart your notebook and make sure no cells initializes an "
                "`Accelerator`."     )
        if num_processes is None:
            _lowerCAmelCase						      =   8

        _lowerCAmelCase						      =   PrepareForLaunch(SCREAMING_SNAKE_CASE_		,							distributed_type="TPU"     )
        print(F'''Launching a training on {num_processes} TPU cores.'''     )
        xmp.spawn(SCREAMING_SNAKE_CASE_		,							args=SCREAMING_SNAKE_CASE_		,							nprocs=SCREAMING_SNAKE_CASE_		,							start_method="fork"     )
    elif in_colab:
        # No need for a distributed launch otherwise as it's either CPU or one GPU.
        if torch.cuda.is_available():
            print("Launching training on one GPU."     )
        else:
            print("Launching training on one CPU."     )
        function(*SCREAMING_SNAKE_CASE_     )
    else:
        if num_processes is None:
            raise ValueError(
                "You have to specify the number of GPUs you would like to use, add `num_processes=...` to your call."     )

        if num_processes > 1:
            # Multi-GPU launch
            from torch.multiprocessing import start_processes
            from torch.multiprocessing.spawn import ProcessRaisedException

            if len(AcceleratorState._shared_state     ) > 0:
                raise ValueError(
                    "To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized "
                    "inside your training function. Restart your notebook and make sure no cells initializes an "
                    "`Accelerator`."     )

            if torch.cuda.is_initialized():
                raise ValueError(
                    "To launch a multi-GPU training from your notebook, you need to avoid running any instruction "
                    "using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA "
                    "function."     )

            # torch.distributed will expect a few environment variable to be here. We set the ones common to each
            # process here (the other ones will be set be the launcher).
            with patch_environment(
                world_size=SCREAMING_SNAKE_CASE_		,							master_addr="127.0.01"		,							master_port=SCREAMING_SNAKE_CASE_		,							mixed_precision=SCREAMING_SNAKE_CASE_     ):
                _lowerCAmelCase						      =   PrepareForLaunch(SCREAMING_SNAKE_CASE_		,							distributed_type="MULTI_GPU"     )
                print(F'''Launching training on {num_processes} GPUs.'''     )
                try:
                    start_processes(SCREAMING_SNAKE_CASE_		,							args=SCREAMING_SNAKE_CASE_		,							nprocs=SCREAMING_SNAKE_CASE_		,							start_method="fork"     )
                except ProcessRaisedException as e:
                    if "Cannot re-initialize CUDA in forked subprocess" in e.args[0]:
                        raise RuntimeError(
                            "CUDA has been initialized before the `notebook_launcher` could create a forked subprocess. "
                            "This likely stems from an outside import causing issues once the `notebook_launcher()` is called. "
                            "Please review your imports and test them when running the `notebook_launcher()` to identify "
                            "which one is problematic."     ) from e

        else:
            # No need for a distributed launch otherwise as it's either CPU, GPU or MPS.
            if is_mps_available():
                _lowerCAmelCase						      =   "1"
                print("Launching training on MPS."     )
            elif torch.cuda.is_available():
                print("Launching training on one GPU."     )
            else:
                print("Launching training on CPU."     )
            function(*SCREAMING_SNAKE_CASE_     )





def 						__a(SCREAMING_SNAKE_CASE_	:       List[str]		,							SCREAMING_SNAKE_CASE_	:       Optional[int]=()		,							SCREAMING_SNAKE_CASE_	:       List[str]=2     ):



    '''simple docstring'''





    from torch.multiprocessing import start_processes

    with tempfile.NamedTemporaryFile() as tmp_file:
        # torch.distributed will expect a few environment variable to be here. We set the ones common to each
        # process here (the other ones will be set be the launcher).
        with patch_environment(
            world_size=SCREAMING_SNAKE_CASE_		,							master_addr="127.0.01"		,							master_port="29500"		,							accelerate_mixed_precision="no"		,							accelerate_debug_rdv_file=tmp_file.name		,							accelerate_use_cpu="yes"		,							):
            _lowerCAmelCase						      =   PrepareForLaunch(SCREAMING_SNAKE_CASE_		,							debug=SCREAMING_SNAKE_CASE_     )
            start_processes(SCREAMING_SNAKE_CASE_		,							args=SCREAMING_SNAKE_CASE_		,							nprocs=SCREAMING_SNAKE_CASE_		,							start_method="fork"     )



'''simple docstring'''

import numpy as np







def __UpperCamelCase( _A       :					np.ndarray	,      _A       :					np.ndarray	,      _A       :					float = 1e-12	,      _A       :					int = 1_00	,      ):
   '''simple docstring'''
   assert np.shape(_A     )[0] == np.shape(_A     )[1]
   # Ensure proper dimensionality.
   assert np.shape(_A     )[0] == np.shape(_A     )[0]
   # Ensure inputs are either both complex or both real
   assert np.iscomplexobj(_A     ) == np.iscomplexobj(_A     )
   UpperCAmelCase__				:					int 					=	np.iscomplexobj(_A     )
   if is_complex:
      # Ensure complex input_matrix is Hermitian
      assert np.array_equal(_A	,      input_matrix.conj().T     )

   # Set convergence to False. Will define convergence when we exceed max_iterations
   # or when we have small changes from one iteration to next.

   UpperCAmelCase__				:					Any 					=	False
   UpperCAmelCase__				:					str 					=	0
   UpperCAmelCase__				:					Optional[int] 					=	0
   UpperCAmelCase__				:					Optional[int] 					=	1e12

   while not convergence:
      # Multiple matrix by the vector.
      UpperCAmelCase__				:					str 					=	np.dot(_A	,      _A     )
      # Normalize the resulting output vector.
      UpperCAmelCase__				:					int 					=	w / np.linalg.norm(_A     )
      # Find rayleigh quotient
      # (faster than usual b/c we know vector is normalized already)
      UpperCAmelCase__				:					int 					=	vector.conj().T if is_complex else vector.T
      UpperCAmelCase__				:					Any 					=	np.dot(_A	,      np.dot(_A	,      _A     )     )

      # Check convergence.
      UpperCAmelCase__				:					List[Any] 					=	np.abs(lambda_ - lambda_previous     ) / lambda_
      iterations += 1

      if error <= error_tol or iterations >= max_iterations:
         UpperCAmelCase__				:					Optional[Any] 					=	True

      UpperCAmelCase__				:					Optional[int] 					=	lambda_

   if is_complex:
      UpperCAmelCase__				:					Tuple 					=	np.real(lambda_     )

   return lambda_, vector







def __UpperCamelCase( ):
   '''simple docstring'''
   UpperCAmelCase__				:					Optional[int] 					=	np.array([[41, 4, 20], [4, 26, 30], [20, 30, 50]]     )
   UpperCAmelCase__				:					int 					=	np.array([41, 4, 20]     )
   UpperCAmelCase__				:					str 					=	real_input_matrix.astype(np.complexaaa     )
   UpperCAmelCase__				:					Union[str, Any] 					=	np.triu(1J * complex_input_matrix	,      1     )
   complex_input_matrix += imag_matrix
   complex_input_matrix += -1 * imag_matrix.T
   UpperCAmelCase__				:					Tuple 					=	np.array([41, 4, 20]     ).astype(np.complexaaa     )

   for problem_type in ["real", "complex"]:
      if problem_type == "real":
         UpperCAmelCase__				:					Optional[int] 					=	real_input_matrix
         UpperCAmelCase__				:					int 					=	real_vector
      elif problem_type == "complex":
         UpperCAmelCase__				:					int 					=	complex_input_matrix
         UpperCAmelCase__				:					Tuple 					=	complex_vector

      # Our implementation.
      UpperCAmelCase__					,   UpperCAmelCase__				:					str 					=	power_iteration(_A	,      _A     )

      # Numpy implementation.

      # Get eigenvalues and eigenvectors using built-in numpy
      # eigh (eigh used for symmetric or hermetian matrices).
      UpperCAmelCase__					,   UpperCAmelCase__				:					Tuple 					=	np.linalg.eigh(_A     )
      # Last eigenvalue is the maximum one.
      UpperCAmelCase__				:					Dict 					=	eigen_values[-1]
      # Last column in this matrix is eigenvector corresponding to largest eigenvalue.
      UpperCAmelCase__				:					Union[str, Any] 					=	eigen_vectors[:, -1]

      # Check our implementation and numpy gives close answers.
      assert np.abs(eigen_value - eigen_value_max     ) <= 1e-6
      # Take absolute values element wise of each eigenvector.
      # as they are only unique to a minus sign.
      assert np.linalg.norm(np.abs(_A     ) - np.abs(_A     )     ) <= 1e-6


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  test_power_iteration()




