


from typing import List, Optional, Union

import numpy as np
import tensorflow as tf

from .utils import logging


snake_case__			 =						logging.get_logger(__name__)


def 				lowerCamelCase__	(      a	:   Union[tf.Tensor, np.ndarray]				)    ->	List[int]:





			"""simple docstring"""
			if isinstance(a	,  np.ndarray				):
						return list(tensor.shape				)

			a__ :Union[str, Any]						  =    tf.shape(a				)

			if tensor.shape == tf.TensorShape(a				):
						return dynamic

			a__ :Tuple						  =    tensor.shape.as_list()

			return [dynamic[i] if s is None else s for i, s in enumerate(a				)]


def 				lowerCamelCase__	(      a	:   tf.Tensor	,  a	:   Optional[int] = None	,  a	:   Optional[str] = None				)    ->	tf.Tensor:





			"""simple docstring"""
			return tf.nn.softmax(logits=logits + 1e-9	,  axis=a	,  name=a				)


def 				lowerCamelCase__	(      a	:   Optional[int]	,  a	:   Any	,  a	:   int	,  a	:   Optional[Any]=1e-5	,  a	:   str=-1				)    ->	Optional[Any]:





			"""simple docstring"""
			# This is a very simplified functional layernorm, designed to duplicate
			# the functionality of PyTorch nn.functional.layer_norm when this is needed to port
			# models in Transformers.

			if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(a	,  a				):
						raise NotImplementedError("Only 1D weight and bias tensors are supported for now, with only a single axis."				)

			# Get mean and variance on the axis to be normalized
			a__  ,  a__ :Optional[int]						  =    tf.nn.moments(a	,  axes=[axis]	,  keepdims=a				)

			if axis != -1:
						# Reshape scale and weight to have the same rank as inputs, but with 1 dimensions
						# on every dimension except axis
						a__ :Optional[int]						  =    [1] * inputs.shape.rank
						a__ :Optional[int]						  =    shape_list(a				)[axis]
						a__ :Optional[Any]						  =    tf.reshape(a	,  a				)
						a__ :List[str]						  =    tf.reshape(a	,  a				)

			# Compute layer normalization using the batch_normalization
			# function.
			a__ :List[Any]						  =    tf.nn.batch_normalization(
			    a	,  a	,  a	,  offset=a	,  scale=a	,  variance_epsilon=a	,  )
			return outputs


def 				lowerCamelCase__	(      a	:   Dict	,  a	:   Dict=0	,  a	:   Any=-1				)    ->	List[Any]:





			"""simple docstring"""
			# Replicates the behavior of torch.flatten in TF

			# If end_dim or start_dim is negative, count them from the end
			if end_dim < 0:
						end_dim += input.shape.rank
			if start_dim < 0:
						start_dim += input.shape.rank

			if start_dim == end_dim:
						return input

			a__ :Optional[Any]						  =    tf.shape(a				)
			a__ :int						  =    tf.math.reduce_prod(in_shape[start_dim : end_dim + 1]				)
			a__ :Union[str, Any]						  =    tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]]	,  axis=0				)
			return tf.reshape(a	,  a				)


def 				lowerCamelCase__	(      a	:   tf.Tensor				)    ->	tf.Tensor:





			"""simple docstring"""
			if not isinstance(a	,  tf.Tensor				):
						a__ :Optional[Any]						  =    tf.convert_to_tensor(a				)  # Catches stray NumPy inputs
			if encoder_attention_mask.shape.rank == 3:
						a__ :Dict						  =    encoder_attention_mask[:, None, :, :]
			if encoder_attention_mask.shape.rank == 2:
						a__ :Any						  =    encoder_attention_mask[:, None, None, :]
			# T5 has a mask that can compare sequence ids, we can simulate this here with this transposition
			# Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow
			# /transformer/transformer_layers.py#L270
			# encoder_extended_attention_mask = (encoder_extended_attention_mask ==
			# encoder_extended_attention_mask.transpose(-1, -2))
			a__ :Tuple						  =    (
			    tf.cast(1	,  encoder_attention_mask.dtype				) - encoder_extended_attention_mask
			) * encoder_extended_attention_mask.dtype.min

			return encoder_extended_attention_mask


def 				lowerCamelCase__	(      a	:   tf.Tensor	,  a	:   int	,  a	:   str = "input_ids"				)    ->	None:





			"""simple docstring"""
			tf.debugging.assert_less(
			    a	,  tf.cast(a	,  dtype=tensor.dtype				)	,  message=(
			        F'''The maximum value of {tensor_name} ({tf.math.reduce_max(a				)}) must be smaller than the embedding '''
			        F'''layer\'s input dimension ({embed_dim}). The likely cause is some problem at tokenization time.'''
			    )	,  )


def 				lowerCamelCase__	(      a	:   Dict	,  a	:   Dict	,  a	:   Any				)    ->	Optional[Any]:





			"""simple docstring"""
			a__ :Tuple						  =    64_512
			# Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT`
			# because in that case even chunking the array would not make the saving
			# possible.
			a__ :str						  =    [x for x in data if len(a				) > HDF5_OBJECT_HEADER_LIMIT]

			# Expecting this to never be true.
			if bad_attributes:
						raise RuntimeError(
						    "The following attributes cannot be saved to HDF5 file because "
						    F'''they are larger than {HDF5_OBJECT_HEADER_LIMIT} '''
						    F'''bytes: {bad_attributes}'''				)

			a__ :List[Any]						  =    np.asarray(a				)

			a__ :Tuple						  =    1
			a__ :str						  =    np.array_split(a	,  a				)

			# This will never loop forever thanks to the test above.
			while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data				):
						num_chunks += 1
						a__ :str						  =    np.array_split(a	,  a				)

			if num_chunks > 1:
						for chunk_id, chunk_data in enumerate(a				):
									a__ :Tuple						  =    chunk_data
			else:
						a__ :Tuple						  =    data


def 				lowerCamelCase__	(      a	:   Any	,  a	:   int				)    ->	List[Any]:





			"""simple docstring"""
			if name in group.attrs:
						a__ :Optional[int]						  =    [n.decode("utf8"				) if hasattr(a	,  "decode"				) else n for n in group.attrs[name]]
			else:
						a__ :str						  =    []
						a__ :List[str]						  =    0
						while "%s%d" % (name, chunk_id) in group.attrs:
									data.extend(
									    [n.decode("utf8"				) if hasattr(a	,  "decode"				) else n for n in group.attrs["%s%d" % (name, chunk_id)]]				)
									chunk_id += 1
			return data







def 				lowerCamelCase__	(      a	:   Optional[int]				)    ->	Any:





			"""simple docstring"""

			def _expand_single_ad_tensor(a	:   Optional[int]				):
						if isinstance(a	,  tf.Tensor				) and t.shape.rank == 1:
									return tf.expand_dims(a	,  axis=-1				)
						return t

			return tf.nest.map_structure(_expand_single_ad_tensor	,  a				)






# Copyright 2021 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

from ...utils.dataclasses import (
    ComputeEnvironment,
    DistributedType,
    DynamoBackend,
    PrecisionType,
    SageMakerDistributedType,
)
from ..menu import BulletMenu


snake_case__			 =						[
    '''EAGER''',
    '''AOT_EAGER''',
    '''INDUCTOR''',
    '''NVFUSER''',
    '''AOT_NVFUSER''',
    '''AOT_CUDAGRAPHS''',
    '''OFI''',
    '''FX2TRT''',
    '''ONNXRT''',
    '''IPEX''',
]


def 				lowerCamelCase__	(      a	:   Optional[Any]	,  a	:   Tuple=None	,  a	:   int=None	,  a	:   List[str]=None				)    ->	int:





			"""simple docstring"""
			a__ :Tuple						  =    True
			while ask_again:
						a__ :str						  =    input(a				)
						try:
									if default is not None and len(a				) == 0:
												return default
									return convert_value(a				) if convert_value is not None else result
						except Exception:
									if error_message is not None:
												print(a				)


def 				lowerCamelCase__	(      a	:   int	,  a	:   Union[str, Any]=[]	,  a	:   str=None	,  a	:   str=0				)    ->	List[str]:





			"""simple docstring"""
			a__ :str						  =    BulletMenu(a	,  a				)
			a__ :int						  =    menu.run(default_choice=a				)
			return convert_value(a				) if convert_value is not None else result


def 				lowerCamelCase__	(      a	:   Optional[Any]				)    ->	Dict:





			"""simple docstring"""
			a__ :str						  =    int(a				)
			return ComputeEnvironment(["LOCAL_MACHINE", "AMAZON_SAGEMAKER"][value]				)


def 				lowerCamelCase__	(      a	:   Tuple				)    ->	List[str]:





			"""simple docstring"""
			a__ :Union[str, Any]						  =    int(a				)
			return DistributedType(["NO", "MULTI_CPU", "MULTI_XPU", "MULTI_GPU", "MULTI_NPU", "TPU"][value]				)


def 				lowerCamelCase__	(      a	:   List[Any]				)    ->	str:





			"""simple docstring"""
			a__ :int						  =    int(a				)
			return DynamoBackend(DYNAMO_BACKENDS[value]				).value


def 				lowerCamelCase__	(      a	:   Any				)    ->	Union[str, Any]:





			"""simple docstring"""
			a__ :Optional[Any]						  =    int(a				)
			return PrecisionType(["no", "fp16", "bf16", "fp8"][value]				)


def 				lowerCamelCase__	(      a	:   List[Any]				)    ->	Union[str, Any]:





			"""simple docstring"""
			a__ :Optional[Any]						  =    int(a				)
			return SageMakerDistributedType(["NO", "DATA_PARALLEL", "MODEL_PARALLEL"][value]				)


def 				lowerCamelCase__	(      a	:   Union[str, Any]				)    ->	List[str]:





			"""simple docstring"""
			return {"yes": True, "no": False}[value.lower()]







class 					lowerCAmelCase_ (       argparse.RawDescriptionHelpFormatter):




						def  _snake_case					(	self						:   Tuple   ,     __A						:   Tuple   ,     __A						:   int   ,     __A						:   Tuple   ,     __A						:   Any						)      ->Union[str, Any]:






									"""simple docstring"""






									a__ :Optional[int]						  =    super()._format_usage(__A   ,     __A   ,     __A   ,     __A						)
									a__ :Any						  =    usage.replace("<command> [<args>] "   ,     ""						)
									return usage


