



# 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


__lowerCamelCase         =			'''Run commands across TPU VMs for initial setup before running `accelerate launch`.'''







def    _snake_case (       __snake_case=None    )     ->     List[str]:






      '''simple docstring'''







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







def    _snake_case (       __snake_case    )     ->     Dict:






      '''simple docstring'''







      UpperCAmelCase_  :	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(__snake_case    ):
            UpperCAmelCase_  :	Optional[int]				      =		load_config_from_file(args.config_file    )
            if not args.command_file and defaults.command_file is not None and not args.command:
                  UpperCAmelCase_  :	int				      =		defaults.command_file
            if not args.command and defaults.commands is not None:
                  UpperCAmelCase_  :	Tuple				      =		defaults.commands
            if not args.tpu_name:
                  UpperCAmelCase_  :	Dict				      =		defaults.tpu_name
            if not args.tpu_zone:
                  UpperCAmelCase_  :	Optional[Any]				      =		defaults.tpu_zone
      if args.accelerate_version == "dev":
            UpperCAmelCase_  :	Dict				      =		"git+https://github.com/huggingface/accelerate.git"
      elif args.accelerate_version == "latest":
            UpperCAmelCase_  :	Union[str, Any]				      =		"accelerate -U"
      elif isinstance(parse(args.accelerate_version    )					,  __snake_case    ):
            UpperCAmelCase_  :	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:
                  UpperCAmelCase_  :	Any				      =		[f.read().splitlines()]

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

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







def    _snake_case (       )     ->     int:






      '''simple docstring'''







      UpperCAmelCase_  :	Any				      =		tpu_command_parser()
      UpperCAmelCase_  :	str				      =		parser.parse_args()

      tpu_command_launcher(__snake_case    )





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


__lowerCamelCase         =			logging.get_logger(__name__)

__lowerCamelCase         =			{
    '''microsoft/trocr-base-handwritten''': (
        '''https://huggingface.co/microsoft/trocr-base-handwritten/resolve/main/config.json'''
    ),
    # See all TrOCR models at https://huggingface.co/models?filter=trocr
}


class   snake_case_ (lowercase__  ):




       """simple docstring"""






       _lowerCamelCase			    =				"""trocr"""
       _lowerCamelCase			    =				["""past_key_values"""]
       _lowerCamelCase			    =				{
           """num_attention_heads""": """decoder_attention_heads""",
           """hidden_size""": """d_model""",
           """num_hidden_layers""": """decoder_layers""",
       }



       def __init__(     self     ,lowercase=50265     ,lowercase=1024     ,lowercase=12     ,lowercase=16     ,lowercase=4096     ,lowercase="gelu"     ,lowercase=512     ,lowercase=0.1     ,lowercase=0.0     ,lowercase=0.0     ,lowercase=2     ,lowercase=0.02     ,lowercase=0.0     ,lowercase=True     ,lowercase=False     ,lowercase=True     ,lowercase=True     ,lowercase=1     ,lowercase=0     ,lowercase=2     ,**lowercase     ,):

             """simple docstring"""





             UpperCAmelCase_  :	int				      =		vocab_size
             UpperCAmelCase_  :	Tuple				      =		d_model
             UpperCAmelCase_  :	List[str]				      =		decoder_layers
             UpperCAmelCase_  :	Union[str, Any]				      =		decoder_attention_heads
             UpperCAmelCase_  :	Optional[Any]				      =		decoder_ffn_dim
             UpperCAmelCase_  :	Tuple				      =		activation_function
             UpperCAmelCase_  :	List[Any]				      =		max_position_embeddings
             UpperCAmelCase_  :	List[Any]				      =		dropout
             UpperCAmelCase_  :	List[str]				      =		attention_dropout
             UpperCAmelCase_  :	Union[str, Any]				      =		activation_dropout
             UpperCAmelCase_  :	Optional[int]				      =		init_std
             UpperCAmelCase_  :	Dict				      =		decoder_layerdrop
             UpperCAmelCase_  :	List[str]				      =		use_cache
             UpperCAmelCase_  :	Dict				      =		scale_embedding
             UpperCAmelCase_  :	Dict				      =		use_learned_position_embeddings
             UpperCAmelCase_  :	Optional[Any]				      =		layernorm_embedding

             super().__init__(
                 pad_token_id=lowercase     ,bos_token_id=lowercase     ,eos_token_id=lowercase     ,decoder_start_token_id=lowercase     ,**lowercase     ,)
