



import os
import sys
import tempfile

import torch

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





def      __snake_case	(			_UpperCAmelCase   , _UpperCAmelCase=()   , _UpperCAmelCase=None   , _UpperCAmelCase="no"   , _UpperCAmelCase="29500"				):
    __a						       =				False
    __a						       =				False
    if any(key.startswith('''KAGGLE'''				) for key in os.environ.keys()				):
        __a						       =				True
    elif "IPython" in sys.modules:
        __a						       =				'''google.colab''' in str(sys.modules['''IPython'''].get_ipython()				)

    try:
        __a						       =				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'''   , _UpperCAmelCase				) 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:
            __a						       =				8

        __a						       =				PrepareForLaunch(_UpperCAmelCase   , distributed_type='''TPU'''				)
        print(f'Launching a training on {num_processes} TPU cores.'				)
        xmp.spawn(_UpperCAmelCase   , args=_UpperCAmelCase   , nprocs=_UpperCAmelCase   , 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(*_UpperCAmelCase				)
    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=_UpperCAmelCase   , master_addr='''127.0.01'''   , master_port=_UpperCAmelCase   , mixed_precision=_UpperCAmelCase				):
                __a						       =				PrepareForLaunch(_UpperCAmelCase   , distributed_type='''MULTI_GPU'''				)
                print(f'Launching training on {num_processes} GPUs.'				)
                try:
                    start_processes(_UpperCAmelCase   , args=_UpperCAmelCase   , nprocs=_UpperCAmelCase   , 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():
                __a						       =				'''1'''
                print('''Launching training on MPS.'''				)
            elif torch.cuda.is_available():
                print('''Launching training on one GPU.'''				)
            else:
                print('''Launching training on CPU.'''				)
            function(*_UpperCAmelCase				)





def      __snake_case	(			_UpperCAmelCase   , _UpperCAmelCase=()   , _UpperCAmelCase=2				):
    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=_UpperCAmelCase   , master_addr='''127.0.01'''   , master_port='''29500'''   , accelerate_mixed_precision='''no'''   , accelerate_debug_rdv_file=tmp_file.name   , accelerate_use_cpu='''yes'''   , ):
            __a						       =				PrepareForLaunch(_UpperCAmelCase   , debug=_UpperCAmelCase				)
            start_processes(_UpperCAmelCase   , args=_UpperCAmelCase   , nprocs=_UpperCAmelCase   , start_method='''fork'''				)










import argparse

import torch

from transformers import LxmertConfig, LxmertForPreTraining, load_tf_weights_in_lxmert
from transformers.utils import logging


logging.set_verbosity_info()





def      __snake_case	(			_UpperCAmelCase   , _UpperCAmelCase   , _UpperCAmelCase				):
    # Initialise PyTorch model
    __a						       =				LxmertConfig.from_json_file(_UpperCAmelCase				)
    print(f'Building PyTorch model from configuration: {config}'				)
    __a						       =				LxmertForPreTraining(_UpperCAmelCase				)

    # Load weights from tf checkpoint
    load_tf_weights_in_lxmert(_UpperCAmelCase   , _UpperCAmelCase   , _UpperCAmelCase				)

    # Save pytorch-model
    print(f'Save PyTorch model to {pytorch_dump_path}'				)
    torch.save(model.state_dict()   , _UpperCAmelCase				)


if __name__ == "__main__":
 __snake_case						:List[Any]      		=     argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.'''
 )
 parser.add_argument(
     '''--config_file''',
     default=None,
     type=str,
     required=True,
     help='''The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.''',
 )
 parser.add_argument(
     '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
 )
 __snake_case						:Optional[Any]      		=     parser.parse_args()
 convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)





