





'''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 platform

import numpy as np
import psutil
import torch

from accelerate import __version__ as version
from accelerate.commands.config import default_config_file, load_config_from_file

from ..utils import is_npu_available, is_xpu_available







def  a__    (    lowercase :					Optional[int]=None				)		->		List[str]:





     """simple docstring"""

     if subparsers is not None:
          _UpperCamelCase       =	subparsers.add_parser('''env'''				)
     else:
          _UpperCamelCase       =	argparse.ArgumentParser('''Accelerate env command'''				)

     parser.add_argument(
         '''--config_file''', default=lowercase, help='''The config file to use for the default values in the launching script.'''				)

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







def  a__    (    lowercase :					Dict				)		->		int:





     """simple docstring"""

     _UpperCamelCase       =	torch.__version__
     _UpperCamelCase       =	torch.cuda.is_available()
     _UpperCamelCase       =	is_xpu_available()
     _UpperCamelCase       =	is_npu_available()

     _UpperCamelCase       =	'''Not found'''
     # Get the default from the config file.
     if args.config_file is not None or os.path.isfile(lowercase				):
          _UpperCamelCase       =	load_config_from_file(args.config_file				).to_dict()

     _UpperCamelCase       =	{
         '''`Accelerate` version''': version,
         '''Platform''': platform.platform(),
         '''Python version''': platform.python_version(),
         '''Numpy version''': np.__version__,
         '''PyTorch version (GPU?)''': F"""{pt_version} ({pt_cuda_available})""",
         '''PyTorch XPU available''': str(lowercase				),
         '''PyTorch NPU available''': str(lowercase				),
         '''System RAM''': F"""{psutil.virtual_memory().total / 1024 ** 3:.2f} GB""",
     }
     if pt_cuda_available:
          _UpperCamelCase       =	torch.cuda.get_device_name()

     print('''\nCopy-and-paste the text below in your GitHub issue\n'''				)
     print('''\n'''.join([F"""- {prop}: {val}""" for prop, val in info.items()]				)				)

     print('''- `Accelerate` default config:''' if args.config_file is None else '''- `Accelerate` config passed:'''				)
     _UpperCamelCase       =	(
         '''\n'''.join([F"""\t- {prop}: {val}""" for prop, val in accelerate_config.items()]				)
         if isinstance(lowercase, lowercase				)
         else F"""\t{accelerate_config}"""
     )
     print(lowercase				)

     _UpperCamelCase       =	accelerate_config

     return info







def  a__    (    )		->		int:





     """simple docstring"""

     _UpperCamelCase       =	env_command_parser()
     _UpperCamelCase       =	parser.parse_args()
     env_command(lowercase				)
     return 0


if __name__ == "__main__":
   raise SystemExit(main())










'''simple docstring'''

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


lowercase__						:      List[Any]	=    logging.get_logger(__name__)

lowercase__						:      Tuple	=    {
    '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     __lowerCAmelCase					(   __magic_name__			):






       """simple docstring"""
       _snake_case     :					int						    =   'trocr'
       _snake_case     :					List[str]						    =   ['past_key_values']
       _snake_case     :					Tuple						    =   {
           'num_attention_heads': 'decoder_attention_heads',
           'hidden_size': 'd_model',
           'num_hidden_layers': 'decoder_layers',
       }





       def __init__(							self       :		Tuple	,			lowerCAmelCase__       :		Union[str, Any]=50265	,			lowerCAmelCase__       :		List[Any]=1024	,			lowerCAmelCase__       :		List[str]=12	,			lowerCAmelCase__       :		int=16	,			lowerCAmelCase__       :		List[Any]=4096	,			lowerCAmelCase__       :		Optional[int]="gelu"	,			lowerCAmelCase__       :		int=512	,			lowerCAmelCase__       :		Optional[Any]=0.1	,			lowerCAmelCase__       :		Optional[int]=0.0	,			lowerCAmelCase__       :		Dict=0.0	,			lowerCAmelCase__       :		Tuple=2	,			lowerCAmelCase__       :		Dict=0.02	,			lowerCAmelCase__       :		Tuple=0.0	,			lowerCAmelCase__       :		int=True	,			lowerCAmelCase__       :		Optional[Any]=False	,			lowerCAmelCase__       :		Any=True	,			lowerCAmelCase__       :		Dict=True	,			lowerCAmelCase__       :		Optional[int]=1	,			lowerCAmelCase__       :		List[Any]=0	,			lowerCAmelCase__       :		Any=2	,			**lowerCAmelCase__       :		Optional[int]	,			)   ->					Any:

            '''simple docstring'''




            _UpperCamelCase       =	vocab_size
            _UpperCamelCase       =	d_model
            _UpperCamelCase       =	decoder_layers
            _UpperCamelCase       =	decoder_attention_heads
            _UpperCamelCase       =	decoder_ffn_dim
            _UpperCamelCase       =	activation_function
            _UpperCamelCase       =	max_position_embeddings
            _UpperCamelCase       =	dropout
            _UpperCamelCase       =	attention_dropout
            _UpperCamelCase       =	activation_dropout
            _UpperCamelCase       =	init_std
            _UpperCamelCase       =	decoder_layerdrop
            _UpperCamelCase       =	use_cache
            _UpperCamelCase       =	scale_embedding
            _UpperCamelCase       =	use_learned_position_embeddings
            _UpperCamelCase       =	layernorm_embedding

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



