





"""simple docstring"""




import warnings

from ...configuration_utils import PretrainedConfig
from ...utils import logging


a		:				List[str]  			=	logging.get_logger(__name__)

a		:				Union[str, Any]  			=	{
    '''xlnet-base-cased''': '''https://huggingface.co/xlnet-base-cased/resolve/main/config.json''',
    '''xlnet-large-cased''': '''https://huggingface.co/xlnet-large-cased/resolve/main/config.json''',
}


class  __UpperCamelCase       (		a__		):
							lowerCamelCase     :      str         ="""xlnet"""
							lowerCamelCase     :      Dict         =["""mems"""]
							lowerCamelCase     :      Optional[int]         ={
							    """n_token""": """vocab_size""",  # Backward compatibility
							    """hidden_size""": """d_model""",
							    """num_attention_heads""": """n_head""",
							    """num_hidden_layers""": """n_layer""",
							}






							def __init__(     self   ,      lowerCAmelCase__=3_2000   ,      lowerCAmelCase__=1024   ,      lowerCAmelCase__=24   ,      lowerCAmelCase__=16   ,      lowerCAmelCase__=4096   ,      lowerCAmelCase__="gelu"   ,      lowerCAmelCase__=True   ,      lowerCAmelCase__="bi"   ,      lowerCAmelCase__=0.02   ,      lowerCAmelCase__=1E-12   ,      lowerCAmelCase__=0.1   ,      lowerCAmelCase__=512   ,      lowerCAmelCase__=None   ,      lowerCAmelCase__=True   ,      lowerCAmelCase__=False   ,      lowerCAmelCase__=False   ,      lowerCAmelCase__=-1   ,      lowerCAmelCase__=False   ,      lowerCAmelCase__="last"   ,      lowerCAmelCase__=True   ,      lowerCAmelCase__="tanh"   ,      lowerCAmelCase__=0.1   ,      lowerCAmelCase__=5   ,      lowerCAmelCase__=5   ,      lowerCAmelCase__=5   ,      lowerCAmelCase__=1   ,      lowerCAmelCase__=2   ,      **lowerCAmelCase__   ,      )			->				Optional[int]:
								a   :	Any			=       vocab_size
								a   :	Tuple			=       d_model
								a   :	Tuple			=       n_layer
								a   :	Tuple			=       n_head
								if d_model % n_head != 0:
									raise ValueError(f"""'d_model % n_head' ({d_model % n_head}) should be equal to 0"""   )
								if "d_head" in kwargs:
									if kwargs["d_head"] != d_model // n_head:
										raise ValueError(
										    f"""`d_head` ({kwargs['d_head']}) should be equal to `d_model // n_head` ({d_model // n_head})"""   )
								a   :	Tuple			=       d_model // n_head
								a   :	Optional[Any]			=       ff_activation
								a   :	List[Any]			=       d_inner
								a   :	Any			=       untie_r
								a   :	str			=       attn_type

								a   :	List[Any]			=       initializer_range
								a   :	Any			=       layer_norm_eps

								a   :	List[Any]			=       dropout
								a   :	List[Any]			=       mem_len
								a   :	Optional[Any]			=       reuse_len
								a   :	List[str]			=       bi_data
								a   :	Dict			=       clamp_len
								a   :	Any			=       same_length

								a   :	int			=       summary_type
								a   :	str			=       summary_use_proj
								a   :	Tuple			=       summary_activation
								a   :	Tuple			=       summary_last_dropout
								a   :	List[Any]			=       start_n_top
								a   :	Tuple			=       end_n_top

								a   :	Dict			=       bos_token_id
								a   :	List[Any]			=       pad_token_id
								a   :	Dict			=       eos_token_id

								if "use_cache" in kwargs:
									warnings.warn(
									    "The `use_cache` argument is deprecated and will be removed in a future version, use `use_mems_eval`"
									    " instead."   ,      lowerCAmelCase__   ,      )
									a   :	Union[str, Any]			=       kwargs["use_cache"]

								a   :	Optional[Any]			=       use_mems_eval
								a   :	Dict			=       use_mems_train
								super().__init__(pad_token_id=lowerCAmelCase__   ,      bos_token_id=lowerCAmelCase__   ,      eos_token_id=lowerCAmelCase__   ,      **lowerCAmelCase__   )






							@property
							def 					__a     (     self   )			->				Union[str, Any]:
								logger.info(f"""The model {self.model_type} is one of the few models that has no sequence length limit."""   )
								return -1






							@max_position_embeddings.setter
							def 					__a     (     self   ,      lowerCAmelCase__   )			->				List[str]:
								# Message copied from Transformer-XL documentation
								raise NotImplementedError(
								    f"""The model {self.model_type} is one of the few models that has no sequence length limit."""   )









"""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


a		:				Optional[int]  			=    '''Run commands across TPU VMs for initial setup before running `accelerate launch`.'''






def    _SCREAMING_SNAKE_CASE	(			_lowercase		:					Any=None      )				->Optional[Any]:






	'''simple docstring'''






	if subparsers is not None:
		a   :	int			=       subparsers.add_parser("tpu-config"					, description=_description      )
	else:
		a   :	List[Any]			=       argparse.ArgumentParser("Accelerate tpu-config command"					, description=_description      )
	# Core arguments
	a   :	Dict			=       parser.add_argument_group(
	    "Config Arguments"					, "Arguments that can be configured through `accelerate config`."      )
	config_args.add_argument(
	    "--config_file"					, type=_lowercase					, default=_lowercase					, help="Path to the config file to use for accelerate."					, )
	config_args.add_argument(
	    "--tpu_name"					, default=_lowercase					, 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=_lowercase					, help="The zone of the TPU to use. If not specified, will use the zone specified in the config file."					, )
	a   :	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=_lowercase					, 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=_lowercase      )
	return parser






def    _SCREAMING_SNAKE_CASE	(			_lowercase		:					Any      )				->Tuple:






	'''simple docstring'''






	a   :	Union[str, Any]			=       None

	# Get the default from the config file if it exists.
	if args.config_file is not None or os.path.isfile(_lowercase      ):
		a   :	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:
			a   :	int			=       defaults.command_file
		if not args.command and defaults.commands is not None:
			a   :	Union[str, Any]			=       defaults.commands
		if not args.tpu_name:
			a   :	int			=       defaults.tpu_name
		if not args.tpu_zone:
			a   :	Union[str, Any]			=       defaults.tpu_zone
	if args.accelerate_version == "dev":
		a   :	int			=       "git+https://github.com/huggingface/accelerate.git"
	elif args.accelerate_version == "latest":
		a   :	Optional[Any]			=       "accelerate -U"
	elif isinstance(parse(args.accelerate_version      )					, _lowercase      ):
		a   :	Optional[Any]			=       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:
			a   :	int			=       [f.read().splitlines()]

    # To turn list of lists into list of strings
	if isinstance(args.command[0]					, _lowercase      ):
		a   :	Union[str, Any]			=       [line for cmd in args.command for line in cmd]
	# Default to the shared folder and install accelerate
	a   :	Tuple			=       ["cd /usr/share"]
	if args.install_accelerate:
		new_cmd += [F"""pip install {args.accelerate_version}"""]
	new_cmd += args.command
	a   :	List[Any]			=       "; ".join(_lowercase      )

	# Then send it to gcloud
	# Eventually try to use google-api-core to do this instead of subprocess
	a   :	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(_lowercase      )}"""      )
		return
	subprocess.run(_lowercase      )
	print("Successfully setup pod."      )







def    _SCREAMING_SNAKE_CASE	(			)				->Tuple:






	'''simple docstring'''






	a   :	List[Any]			=       tpu_command_parser()
	a   :	Optional[int]			=       parser.parse_args()

	tpu_command_launcher(_lowercase      )


