


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__a   				=      {
    '''configuration_openai''': ['''OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''OpenAIGPTConfig'''],
    '''tokenization_openai''': ['''OpenAIGPTTokenizer'''],
}

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __a   				=      ['''OpenAIGPTTokenizerFast''']

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __a   				=      [
      '''OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST''',
      '''OpenAIGPTDoubleHeadsModel''',
      '''OpenAIGPTForSequenceClassification''',
      '''OpenAIGPTLMHeadModel''',
      '''OpenAIGPTModel''',
      '''OpenAIGPTPreTrainedModel''',
      '''load_tf_weights_in_openai_gpt''',
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __a   				=      [
      '''TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST''',
      '''TFOpenAIGPTDoubleHeadsModel''',
      '''TFOpenAIGPTForSequenceClassification''',
      '''TFOpenAIGPTLMHeadModel''',
      '''TFOpenAIGPTMainLayer''',
      '''TFOpenAIGPTModel''',
      '''TFOpenAIGPTPreTrainedModel''',
  ]


if TYPE_CHECKING:
  from .configuration_openai import OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, OpenAIGPTConfig
  from .tokenization_openai import OpenAIGPTTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_openai_fast import OpenAIGPTTokenizerFast

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_openai import (
        OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
        OpenAIGPTDoubleHeadsModel,
        OpenAIGPTForSequenceClassification,
        OpenAIGPTLMHeadModel,
        OpenAIGPTModel,
        OpenAIGPTPreTrainedModel,
        load_tf_weights_in_openai_gpt,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_openai import (
        TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFOpenAIGPTDoubleHeadsModel,
        TFOpenAIGPTForSequenceClassification,
        TFOpenAIGPTLMHeadModel,
        TFOpenAIGPTMainLayer,
        TFOpenAIGPTModel,
        TFOpenAIGPTPreTrainedModel,
    )

else:
  import sys

  __a   				=      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





import numpy as np




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->Dict:







      """simple docstring"""

      lowercase			:   Optional[Any]					   =		np.array(_UpperCamelCase     )
      lowercase			:   Dict					   =		np.array(_UpperCamelCase     )

      lowercase			:   List[Any]					   =		abs(predict - actual     )
      lowercase			:   int					   =		difference.mean()

      return score




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->List[Any]:







      """simple docstring"""

      lowercase			:   Tuple					   =		np.array(_UpperCamelCase     )
      lowercase			:   str					   =		np.array(_UpperCamelCase     )

      lowercase			:   List[str]					   =		predict - actual
      lowercase			:   Tuple					   =		np.square(_UpperCamelCase     )

      lowercase			:   Union[str, Any]					   =		square_diff.mean()
      return score




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->str:







      """simple docstring"""

      lowercase			:   Union[str, Any]					   =		np.array(_UpperCamelCase     )
      lowercase			:   Optional[Any]					   =		np.array(_UpperCamelCase     )

      lowercase			:   Tuple					   =		predict - actual
      lowercase			:   Dict					   =		np.square(_UpperCamelCase     )
      lowercase			:   Union[str, Any]					   =		square_diff.mean()
      lowercase			:   Union[str, Any]					   =		np.sqrt(_UpperCamelCase     )
      return score




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->List[Any]:







      """simple docstring"""

      lowercase			:   List[str]					   =		np.array(_UpperCamelCase     )
      lowercase			:   List[Any]					   =		np.array(_UpperCamelCase     )

      lowercase			:   Dict					   =		np.log(predict + 1     )
      lowercase			:   List[str]					   =		np.log(actual + 1     )

      lowercase			:   int					   =		log_predict - log_actual
      lowercase			:   Tuple					   =		np.square(_UpperCamelCase     )
      lowercase			:   List[Any]					   =		square_diff.mean()

      lowercase			:   int					   =		np.sqrt(_UpperCamelCase     )

      return score




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->List[str]:







      """simple docstring"""

      lowercase			:   List[Any]					   =		np.array(_UpperCamelCase     )
      lowercase			:   Optional[int]					   =		np.array(_UpperCamelCase     )

      lowercase			:   Optional[int]					   =		predict - actual
      lowercase			:   Optional[int]					   =		np.sum(_UpperCamelCase     ) / len(_UpperCamelCase     )
      lowercase			:   Dict					   =		np.sum(_UpperCamelCase     ) / len(_UpperCamelCase     )
      # print(numerator, denumerator)
      lowercase			:   int					   =		float(_UpperCamelCase     ) / denumerator * 100

      return score




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->List[Any]:







      """simple docstring"""

      return np.mean(np.array(_UpperCamelCase     ) == np.array(_UpperCamelCase     )     )

