




'''simple docstring'''



# Copyright 2022 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse
import os
import subprocess

from packaging.version import Version, parse

from accelerate.commands.config.config_args import default_config_file, load_config_from_file


UpperCamelCase_       =							"Run commands across TPU VMs for initial setup before running `accelerate launch`."




def    lowercase__(       __UpperCamelCase: Optional[Any]=None  ):

      """simple docstring"""






      if subparsers is not None:
            SCREAMING_SNAKE_CASE					:	List[str]   =		subparsers.add_parser('tpu-config'	,description=_description  )
      else:
            SCREAMING_SNAKE_CASE					:	Union[str, Any]   =		argparse.ArgumentParser('Accelerate tpu-config command'	,description=_description  )
      # Core arguments
      SCREAMING_SNAKE_CASE					:	List[Any]   =		parser.add_argument_group(
          'Config Arguments'	,'Arguments that can be configured through `accelerate config`.'  )
      config_args.add_argument(
          '--config_file'	,type=__UpperCamelCase	,default=__UpperCamelCase	,help='Path to the config file to use for accelerate.'	,)
      config_args.add_argument(
          '--tpu_name'	,default=__UpperCamelCase	,help='The name of the TPU to use. If not specified, will use the TPU specified in the config file.'	,)
      config_args.add_argument(
          '--tpu_zone'	,default=__UpperCamelCase	,help='The zone of the TPU to use. If not specified, will use the zone specified in the config file.'	,)
      SCREAMING_SNAKE_CASE					:	Optional[Any]   =		parser.add_argument_group('TPU Arguments'	,'Arguments for options ran inside the TPU.'  )
      pod_args.add_argument(
          '--use_alpha'	,action='store_true'	,help='Whether to use `gcloud alpha` when running the TPU training script instead of `gcloud`.'	,)
      pod_args.add_argument(
          '--command_file'	,default=__UpperCamelCase	,help='The path to the file containing the commands to run on the pod on startup.'	,)
      pod_args.add_argument(
          '--command'	,action='append'	,nargs='+'	,help='A command to run on the pod. Can be passed multiple times.'	,)
      pod_args.add_argument(
          '--install_accelerate'	,action='store_true'	,help='Whether to install accelerate on the pod. Defaults to False.'	,)
      pod_args.add_argument(
          '--accelerate_version'	,default='latest'	,help='The version of accelerate to install on the pod. If not specified, will use the latest pypi version. Specify \'dev\' to install from GitHub.'	,)
      pod_args.add_argument(
          '--debug'	,action='store_true'	,help='If set, will print the command that would be run instead of running it.'  )

      if subparsers is not None:
            parser.set_defaults(func=__UpperCamelCase  )
      return parser




def    lowercase__(       __UpperCamelCase: Union[str, Any]  ):

      """simple docstring"""






      SCREAMING_SNAKE_CASE					:	List[str]   =		None

      # Get the default from the config file if it exists.
      if args.config_file is not None or os.path.isfile(__UpperCamelCase  ):
            SCREAMING_SNAKE_CASE					:	Optional[Any]   =		load_config_from_file(args.config_file  )
            if not args.command_file and defaults.command_file is not None and not args.command:
                  SCREAMING_SNAKE_CASE					:	Dict   =		defaults.command_file
            if not args.command and defaults.commands is not None:
                  SCREAMING_SNAKE_CASE					:	str   =		defaults.commands
            if not args.tpu_name:
                  SCREAMING_SNAKE_CASE					:	List[str]   =		defaults.tpu_name
            if not args.tpu_zone:
                  SCREAMING_SNAKE_CASE					:	Any   =		defaults.tpu_zone
      if args.accelerate_version == "dev":
            SCREAMING_SNAKE_CASE					:	Any   =		'''git+https://github.com/huggingface/accelerate.git'''
      elif args.accelerate_version == "latest":
            SCREAMING_SNAKE_CASE					:	Optional[int]   =		'''accelerate -U'''
      elif isinstance(parse(args.accelerate_version  )	,__UpperCamelCase  ):
            SCREAMING_SNAKE_CASE					:	List[str]   =		f"accelerate=={args.accelerate_version}"

      if not args.command_file and not args.command:
            raise ValueError('You must specify either a command file or a command to run on the pod.'  )

      if args.command_file:
            with open(args.command_file	,'r'  ) as f:
                  SCREAMING_SNAKE_CASE					:	Tuple   =		[f.read().splitlines()]

    # To turn list of lists into list of strings
      if isinstance(args.command[0]	,__UpperCamelCase  ):
            SCREAMING_SNAKE_CASE					:	Any   =		[line for cmd in args.command for line in cmd]
      # Default to the shared folder and install accelerate
      SCREAMING_SNAKE_CASE					:	int   =		['''cd /usr/share''']
      if args.install_accelerate:
            new_cmd += [f"pip install {args.accelerate_version}"]
      new_cmd += args.command
      SCREAMING_SNAKE_CASE					:	Optional[Any]   =		'''; '''.join(__UpperCamelCase  )

      # Then send it to gcloud
      # Eventually try to use google-api-core to do this instead of subprocess
      SCREAMING_SNAKE_CASE					:	str   =		['''gcloud''']
      if args.use_alpha:
            cmd += ["alpha"]
      cmd += [
          "compute",
          "tpus",
          "tpu-vm",
          "ssh",
          args.tpu_name,
          "--zone",
          args.tpu_zone,
          "--command",
          args.command,
          "--worker",
          "all",
      ]
      if args.debug:
            print(f"Running {' '.join(__UpperCamelCase  )}"  )
            return
      subprocess.run(__UpperCamelCase  )
      print('Successfully setup pod.'  )





def    lowercase__(       ):

      """simple docstring"""






      SCREAMING_SNAKE_CASE					:	Tuple   =		tpu_command_parser()
      SCREAMING_SNAKE_CASE					:	Dict   =		parser.parse_args()

      tpu_command_launcher(__UpperCamelCase  )



import re

import jax.numpy as jnp
from flax.traverse_util import flatten_dict, unflatten_dict
from jax.random import PRNGKey

from ..utils import logging


__lowercase							 =					logging.get_logger(__name__)



def lowerCamelCase  (   SCREAMING_SNAKE_CASE	):
    '''simple docstring'''







    __UpperCamelCase     :Tuple			  =		R'''\w+[.]\d+'''
    __UpperCamelCase     :List[str]			  =		re.findall(SCREAMING_SNAKE_CASE  ,			SCREAMING_SNAKE_CASE	)
    for pat in pats:
        __UpperCamelCase     :int			  =		key.replace(SCREAMING_SNAKE_CASE  ,			'''_'''.join(pat.split('''.'''	)	)	)
    return key



def lowerCamelCase  (   SCREAMING_SNAKE_CASE  ,			SCREAMING_SNAKE_CASE  ,			SCREAMING_SNAKE_CASE	):
    '''simple docstring'''







    __UpperCamelCase     :Tuple			  =		pt_tuple_key[:-1] + ('''scale''',)
    if (
        any('''norm''' in str_ for str_ in pt_tuple_key	)
        and (pt_tuple_key[-1] == "bias")
        and (pt_tuple_key[:-1] + ("bias",) not in random_flax_state_dict)
        and (pt_tuple_key[:-1] + ("scale",) in random_flax_state_dict)
    ):
        __UpperCamelCase     :str			  =		pt_tuple_key[:-1] + ('''scale''',)
        return renamed_pt_tuple_key, pt_tensor
    elif pt_tuple_key[-1] in ["weight", "gamma"] and pt_tuple_key[:-1] + ("scale",) in random_flax_state_dict:
        __UpperCamelCase     :Any			  =		pt_tuple_key[:-1] + ('''scale''',)
        return renamed_pt_tuple_key, pt_tensor

    # embedding
    if pt_tuple_key[-1] == "weight" and pt_tuple_key[:-1] + ("embedding",) in random_flax_state_dict:
        __UpperCamelCase     :str			  =		pt_tuple_key[:-1] + ('''embedding''',)
        return renamed_pt_tuple_key, pt_tensor

    # conv layer
    __UpperCamelCase     :List[str]			  =		pt_tuple_key[:-1] + ('''kernel''',)
    if pt_tuple_key[-1] == "weight" and pt_tensor.ndim == 4:
        __UpperCamelCase     :List[Any]			  =		pt_tensor.transpose(2  ,			3  ,			1  ,			0	)
        return renamed_pt_tuple_key, pt_tensor

    # linear layer
    __UpperCamelCase     :List[str]			  =		pt_tuple_key[:-1] + ('''kernel''',)
    if pt_tuple_key[-1] == "weight":
        __UpperCamelCase     :Any			  =		pt_tensor.T
        return renamed_pt_tuple_key, pt_tensor

    # old PyTorch layer norm weight
    __UpperCamelCase     :int			  =		pt_tuple_key[:-1] + ('''weight''',)
    if pt_tuple_key[-1] == "gamma":
        return renamed_pt_tuple_key, pt_tensor

    # old PyTorch layer norm bias
    __UpperCamelCase     :int			  =		pt_tuple_key[:-1] + ('''bias''',)
    if pt_tuple_key[-1] == "beta":
        return renamed_pt_tuple_key, pt_tensor

    return pt_tuple_key, pt_tensor



def lowerCamelCase  (   SCREAMING_SNAKE_CASE  ,			SCREAMING_SNAKE_CASE  ,			SCREAMING_SNAKE_CASE=42	):
    '''simple docstring'''







    __UpperCamelCase     :Union[str, Any]			  =		{k: v.numpy() for k, v in pt_state_dict.items()}

    # Step 2: Since the model is stateless, get random Flax params
    __UpperCamelCase     :str			  =		flax_model.init_weights(PRNGKey(SCREAMING_SNAKE_CASE	)	)

    __UpperCamelCase     :int			  =		flatten_dict(SCREAMING_SNAKE_CASE	)
    __UpperCamelCase     :List[Any]			  =		{}

    # Need to change some parameters name to match Flax names
    for pt_key, pt_tensor in pt_state_dict.items():
        __UpperCamelCase     :List[Any]			  =		rename_key(SCREAMING_SNAKE_CASE	)
        __UpperCamelCase     :List[Any]			  =		tuple(renamed_pt_key.split('''.'''	)	)

        # Correctly rename weight parameters
        __UpperCamelCase  ,       __UpperCamelCase     :Any			  =		rename_key_and_reshape_tensor(SCREAMING_SNAKE_CASE  ,			SCREAMING_SNAKE_CASE  ,			SCREAMING_SNAKE_CASE	)

        if flax_key in random_flax_state_dict:
            if flax_tensor.shape != random_flax_state_dict[flax_key].shape:
                raise ValueError(
                    f"""PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape """
                    f"""{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}."""	)

        # also add unexpected weight so that warning is thrown
        __UpperCamelCase     :str			  =		jnp.asarray(SCREAMING_SNAKE_CASE	)

    return unflatten_dict(SCREAMING_SNAKE_CASE	)





