






'''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    lowerCamelCase__ (		_A=None       ):






  if subparsers is not None:
    a		:      Optional[int]       =  subparsers.add_parser('env'       )
  else:
    a		:      List[Any]       =  argparse.ArgumentParser('Accelerate env command'       )

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

  if subparsers is not None:
    parser.set_defaults(func=_A       )
  return parser
def    lowerCamelCase__ (		_A       ):
  a		:      List[Any]       =  torch.__version__
  a		:      Union[str, Any]       =  torch.cuda.is_available()
  a		:      int       =  is_xpu_available()
  a		:      Any       =  is_npu_available()

  a		:      str       =  '''Not found'''
  # Get the default from the config file.
  if args.config_file is not None or os.path.isfile(_A       ):
    a		:      List[Any]       =  load_config_from_file(args.config_file       ).to_dict()

  a		:      Dict       =  {
      '''`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(_A       ),
      '''PyTorch NPU available''': str(_A       ),
      '''System RAM''': f"""{psutil.virtual_memory().total / 1024 ** 3:.2f} GB""",
  }
  if pt_cuda_available:
    a		:      Optional[int]       =  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:'       )
  a		:      Union[str, Any]       =  (
      '''\n'''.join([f"""\t- {prop}: {val}""" for prop, val in accelerate_config.items()]       )
      if isinstance(_A				,    _A       )
      else f"""\t{accelerate_config}"""
  )
  print(_A       )

  a		:      List[str]       =  accelerate_config

  return info
def    lowerCamelCase__ (		):
  a		:      Dict       =  env_command_parser()
  a		:      Union[str, Any]       =  parser.parse_args()
  env_command(_A       )
  return 0


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




'''simple docstring'''






import unittest

import numpy as np

from transformers import BertConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
     from transformers.models.bert.modeling_flax_bert import (
         FlaxBertForMaskedLM,
         FlaxBertForMultipleChoice,
         FlaxBertForNextSentencePrediction,
         FlaxBertForPreTraining,
         FlaxBertForQuestionAnswering,
         FlaxBertForSequenceClassification,
         FlaxBertForTokenClassification,
         FlaxBertModel,
     )

class 							a__(      unittest.TestCase			):







    def __init__(   self				:						Dict		,    __snake_case				:						Union[str, Any]		,    __snake_case				:						Any=13		,    __snake_case				:						Any=7		,    __snake_case				:						int=True		,    __snake_case				:						List[Any]=True		,    __snake_case				:						int=True		,    __snake_case				:						List[Any]=True		,    __snake_case				:						Optional[Any]=99		,    __snake_case				:						List[str]=32		,    __snake_case				:						List[Any]=5		,    __snake_case				:						int=4		,    __snake_case				:						List[str]=37		,    __snake_case				:						int="gelu"		,    __snake_case				:						Tuple=0.1		,    __snake_case				:						Union[str, Any]=0.1		,    __snake_case				:						Any=5_12		,    __snake_case				:						Tuple=16		,    __snake_case				:						Union[str, Any]=2		,    __snake_case				:						str=0.02		,    __snake_case				:						Union[str, Any]=4		,    ):
      a		:      List[Any]       =  parent
      a		:      List[str]       =  batch_size
      a		:      Dict       =  seq_length
      a		:      str       =  is_training
      a		:      Optional[int]       =  use_attention_mask
      a		:      Union[str, Any]       =  use_token_type_ids
      a		:      List[str]       =  use_labels
      a		:      Dict       =  vocab_size
      a		:      Tuple       =  hidden_size
      a		:      Optional[Any]       =  num_hidden_layers
      a		:      List[str]       =  num_attention_heads
      a		:      Tuple       =  intermediate_size
      a		:      Dict       =  hidden_act
      a		:      List[str]       =  hidden_dropout_prob
      a		:      str       =  attention_probs_dropout_prob
      a		:      str       =  max_position_embeddings
      a		:      Tuple       =  type_vocab_size
      a		:      Optional[Any]       =  type_sequence_label_size
      a		:      Union[str, Any]       =  initializer_range
      a		:      Union[str, Any]       =  num_choices







    def     lowercase_ (   self				:						Any			):
      a		:      List[Any]       =  ids_tensor([self.batch_size, self.seq_length]		,    self.vocab_size			)

      a		:      List[str]       =  None
      if self.use_attention_mask:
        a		:      List[Any]       =  random_attention_mask([self.batch_size, self.seq_length]			)

      a		:      Dict       =  None
      if self.use_token_type_ids:
        a		:      List[str]       =  ids_tensor([self.batch_size, self.seq_length]		,    self.type_vocab_size			)

      a		:      Dict       =  BertConfig(
          vocab_size=self.vocab_size		,    hidden_size=self.hidden_size		,    num_hidden_layers=self.num_hidden_layers		,    num_attention_heads=self.num_attention_heads		,    intermediate_size=self.intermediate_size		,    hidden_act=self.hidden_act		,    hidden_dropout_prob=self.hidden_dropout_prob		,    attention_probs_dropout_prob=self.attention_probs_dropout_prob		,    max_position_embeddings=self.max_position_embeddings		,    type_vocab_size=self.type_vocab_size		,    is_decoder=__snake_case		,    initializer_range=self.initializer_range		,    )

      return config, input_ids, token_type_ids, attention_mask







    def     lowercase_ (   self				:						Tuple			):
      a		:      Optional[int]       =  self.prepare_config_and_inputs()
      a     ,			a     ,			a     ,			a		:      Union[str, Any]       =  config_and_inputs
      a		:      str       =  {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': attention_mask}
      return config, inputs_dict







    def     lowercase_ (   self				:						List[str]			):
      a		:      int       =  self.prepare_config_and_inputs()
      a     ,			a     ,			a     ,			a		:      Tuple       =  config_and_inputs

      a		:      int       =  True
      a		:      int       =  floats_tensor([self.batch_size, self.seq_length, self.hidden_size]			)
      a		:      Optional[Any]       =  ids_tensor([self.batch_size, self.seq_length]		,    vocab_size=2			)

      return (
          config,
          input_ids,
          attention_mask,
          encoder_hidden_states,
          encoder_attention_mask,
      )

@require_flax
class 							a__(      lowerCamelCase__	,				unittest.TestCase			):
    lowercase__				=					True

    lowercase__				=					(
        (
            FlaxBertModel,
            FlaxBertForPreTraining,
            FlaxBertForMaskedLM,
            FlaxBertForMultipleChoice,
            FlaxBertForQuestionAnswering,
            FlaxBertForNextSentencePrediction,
            FlaxBertForSequenceClassification,
            FlaxBertForTokenClassification,
            FlaxBertForQuestionAnswering,
        )
        if is_flax_available()
        else ()
    )







    def     lowercase_ (   self				:						Union[str, Any]			):
      a		:      str       =  FlaxBertModelTester(self			)







    @slow
    def     lowercase_ (   self				:						Any			):
      # Only check this for base model, not necessary for all model classes.
      # This will also help speed-up tests.
      a		:      Optional[Any]       =  FlaxBertModel.from_pretrained('bert-base-cased'			)
      a		:      Union[str, Any]       =  model(np.ones((1, 1)			)			)
      self.assertIsNotNone(__snake_case			)