


"""simple docstring"""




from ctypes import c_float, sizeof
from enum import Enum
from typing import TYPE_CHECKING, Optional, Union


if TYPE_CHECKING:
					from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore




class  __snake_case      (lowerCamelCase     ):
							__a				   =					c_float




							@property
							def      __a      (    self:						int      ):
														return sizeof(self.value      )





def 			a_   (  lowercase__   :int, lowercase__   :int, lowercase__   :int = 0    ):
							# < 0 is possible if using a dynamic axis
							if dimension <= 0:
														__lowerCamelCase        =			fixed_dimension

							dimension -= num_token_to_add
							return dimension





def 			a_   (  lowercase__   :int, lowercase__   :ParameterFormat    ):
							return num_parameters * dtype.size





def 			a_   (  lowercase__   :str    ):
							from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore

							try:
														return AutoProcessor.from_pretrained(lowercase__    )
							except (ValueError, OSError, KeyError):
														__lowerCamelCase    ,__lowerCamelCase        =			None, None
														try:
																					__lowerCamelCase        =			AutoTokenizer.from_pretrained(lowercase__    )
														except (OSError, KeyError):
																					pass
														try:
																					__lowerCamelCase        =			AutoFeatureExtractor.from_pretrained(lowercase__    )
														except (OSError, KeyError):
																					pass

														if tokenizer is not None and feature_extractor is not None:
																					raise ValueError(
																					    f'Couldn\'t auto-detect preprocessor for {model_name}. Found both a tokenizer and a feature extractor.'    )
														elif tokenizer is None and feature_extractor is None:
																					return None
														elif tokenizer is not None:
																					return tokenizer
														else:
																					return feature_extractor








"""simple docstring"""




import numpy as np





def 			a_   (  lowercase__   :List[str]    ):
			__lowerCamelCase        =			np.exp(lowercase__    )

			# Add up the all the exponentials
			__lowerCamelCase        =			np.sum(lowercase__    )

			# Divide every exponent by the sum of all exponents
			__lowerCamelCase        =			exponent_vector / sum_of_exponents

			return softmax_vector


if __name__ == "__main__":
					print(softmax((0,)))




