


'''simple docstring'''







from __future__ import annotations

import unittest

from transformers import AlbertConfig, is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers import TF_MODEL_FOR_PRETRAINING_MAPPING
  from transformers.models.albert.modeling_tf_albert import (
      TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFAlbertForMaskedLM,
      TFAlbertForMultipleChoice,
      TFAlbertForPreTraining,
      TFAlbertForQuestionAnswering,
      TFAlbertForSequenceClassification,
      TFAlbertForTokenClassification,
      TFAlbertModel,
  )
class  lowercase_					:


    def __init__(					self  , a  , a=13  , a=7  , a=True  , a=True  , a=True  , a=True  , a=99  , a=16  , a=32  , a=2  , a=4  , a=37  , a="gelu"  , a=0.1  , a=0.1  , a=5_12  , a=16  , a=2  , a=0.02  , a=3  , a=4  , a=None  , ):
          UpperCamelCase__  =    parent
          UpperCamelCase__  =    13
          UpperCamelCase__  =    7
          UpperCamelCase__  =    True
          UpperCamelCase__  =    True
          UpperCamelCase__  =    True
          UpperCamelCase__  =    True
          UpperCamelCase__  =    99
          UpperCamelCase__  =    16
          UpperCamelCase__  =    32
          UpperCamelCase__  =    2
          UpperCamelCase__  =    4
          UpperCamelCase__  =    37
          UpperCamelCase__  =    "gelu"
          UpperCamelCase__  =    0.1
          UpperCamelCase__  =    0.1
          UpperCamelCase__  =    5_12
          UpperCamelCase__  =    16
          UpperCamelCase__  =    2
          UpperCamelCase__  =    0.02
          UpperCamelCase__  =    3
          UpperCamelCase__  =    4
          UpperCamelCase__  =    None


    def        __a							(					self   ):
          UpperCamelCase__  =    ids_tensor([self.batch_size, self.seq_length]  , self.vocab_size   )

          UpperCamelCase__  =    None
          if self.use_input_mask:
                UpperCamelCase__  =    random_attention_mask([self.batch_size, self.seq_length]   )

          UpperCamelCase__  =    None
          if self.use_token_type_ids:
                UpperCamelCase__  =    ids_tensor([self.batch_size, self.seq_length]  , self.type_vocab_size   )

          UpperCamelCase__  =    None
          UpperCamelCase__  =    None
          UpperCamelCase__  =    None
          if self.use_labels:
                UpperCamelCase__  =    ids_tensor([self.batch_size]  , self.type_sequence_label_size   )
                UpperCamelCase__  =    ids_tensor([self.batch_size, self.seq_length]  , self.num_labels   )
                UpperCamelCase__  =    ids_tensor([self.batch_size]  , self.num_choices   )

          UpperCamelCase__  =    AlbertConfig(
              vocab_size=self.vocab_size  , hidden_size=self.hidden_size  , embedding_size=self.embedding_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  , initializer_range=self.initializer_range  , )

          return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


    def        __a							(					self  , a  , a  , a  , a  , a  , a  , a   ):
          UpperCamelCase__  =    TFAlbertModel(config=a   )
          # inputs = {'input_ids': input_ids,
          #           'attention_mask': input_mask,
          #           'token_type_ids': token_type_ids}
          # sequence_output, pooled_output = model(**inputs)
          UpperCamelCase__  =    {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
          UpperCamelCase__  =    model(a   )

          UpperCamelCase__  =    [input_ids, input_mask]
          UpperCamelCase__  =    model(a   )

          UpperCamelCase__  =    model(a   )

          self.parent.assertEqual(result.last_hidden_state.shape  , (self.batch_size, self.seq_length, self.hidden_size)   )
          self.parent.assertEqual(result.pooler_output.shape  , (self.batch_size, self.hidden_size)   )


    def        __a							(					self  , a  , a  , a  , a  , a  , a  , a   ):
          UpperCamelCase__  =    self.num_labels
          UpperCamelCase__  =    TFAlbertForPreTraining(config=a   )
          UpperCamelCase__  =    {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
          UpperCamelCase__  =    model(a   )
          self.parent.assertEqual(result.prediction_logits.shape  , (self.batch_size, self.seq_length, self.vocab_size)   )
          self.parent.assertEqual(result.sop_logits.shape  , (self.batch_size, self.num_labels)   )


    def        __a							(					self  , a  , a  , a  , a  , a  , a  , a   ):
          UpperCamelCase__  =    TFAlbertForMaskedLM(config=a   )
          UpperCamelCase__  =    {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
          UpperCamelCase__  =    model(a   )
          self.parent.assertEqual(result.logits.shape  , (self.batch_size, self.seq_length, self.vocab_size)   )


    def        __a							(					self  , a  , a  , a  , a  , a  , a  , a   ):
          UpperCamelCase__  =    self.num_labels
          UpperCamelCase__  =    TFAlbertForSequenceClassification(config=a   )
          UpperCamelCase__  =    {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
          UpperCamelCase__  =    model(a   )
          self.parent.assertEqual(result.logits.shape  , (self.batch_size, self.num_labels)   )


    def        __a							(					self  , a  , a  , a  , a  , a  , a  , a   ):
          UpperCamelCase__  =    TFAlbertForQuestionAnswering(config=a   )
          UpperCamelCase__  =    {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
          UpperCamelCase__  =    model(a   )
          self.parent.assertEqual(result.start_logits.shape  , (self.batch_size, self.seq_length)   )
          self.parent.assertEqual(result.end_logits.shape  , (self.batch_size, self.seq_length)   )


    def        __a							(					self  , a  , a  , a  , a  , a  , a  , a   ):
          UpperCamelCase__  =    self.num_choices
          UpperCamelCase__  =    TFAlbertForMultipleChoice(config=a   )
          UpperCamelCase__  =    tf.tile(tf.expand_dims(a  , 1   )  , (1, self.num_choices, 1)   )
          UpperCamelCase__  =    tf.tile(tf.expand_dims(a  , 1   )  , (1, self.num_choices, 1)   )
          UpperCamelCase__  =    tf.tile(tf.expand_dims(a  , 1   )  , (1, self.num_choices, 1)   )
          UpperCamelCase__  =    {
              "input_ids": multiple_choice_inputs_ids,
              "attention_mask": multiple_choice_input_mask,
              "token_type_ids": multiple_choice_token_type_ids,
          }
          UpperCamelCase__  =    model(a   )
          self.parent.assertListEqual(list(result["logits"].shape   )  , [self.batch_size, self.num_choices]   )


    def        __a							(					self  , a  , a  , a  , a  , a  , a  , a   ):
          UpperCamelCase__  =    self.num_labels
          UpperCamelCase__  =    TFAlbertForTokenClassification(config=a   )
          UpperCamelCase__  =    {
              "input_ids": input_ids,
              "attention_mask": input_mask,
              "token_type_ids": token_type_ids,
          }
          UpperCamelCase__  =    model(a   )
          self.parent.assertListEqual(list(result["logits"].shape   )  , [self.batch_size, self.seq_length, self.num_labels]   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.prepare_config_and_inputs()
          (
              (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     
          )  =    config_and_inputs
          UpperCamelCase__  =    {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
          return config, inputs_dict

@require_tf
class  lowercase_					(   a__  ,						a__  ,						unittest.TestCase       ):
    __UpperCAmelCase             =     (
        (
            TFAlbertModel,
            TFAlbertForPreTraining,
            TFAlbertForMaskedLM,
            TFAlbertForSequenceClassification,
            TFAlbertForQuestionAnswering,
            TFAlbertForTokenClassification,
            TFAlbertForMultipleChoice,
        )
        if is_tf_available()
        else ()
    )
    __UpperCAmelCase             =     (
        {
            'feature-extraction': TFAlbertModel,
            'fill-mask': TFAlbertForMaskedLM,
            'question-answering': TFAlbertForQuestionAnswering,
            'text-classification': TFAlbertForSequenceClassification,
            'token-classification': TFAlbertForTokenClassification,
            'zero-shot': TFAlbertForSequenceClassification,
        }
        if is_tf_available()
        else {}
    )
    __UpperCAmelCase             =     False
    __UpperCAmelCase             =     False


    def        __a							(					self  , a  , a  , a=False   ):
          UpperCamelCase__  =    super()._prepare_for_class(a  , a  , return_labels=a   )

          if return_labels:
                if model_class in get_values(a   ):
                      UpperCamelCase__  =    tf.zeros(self.model_tester.batch_size  , dtype=tf.intaa   )

          return inputs_dict


    def        __a							(					self   ):
          UpperCamelCase__  =    TFAlbertModelTester(self   )
          UpperCamelCase__  =    ConfigTester(self  , config_class=a  , hidden_size=37   )


    def        __a							(					self   ):
          self.config_tester.run_common_tests()


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_albert_model(*a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_albert_for_pretraining(*a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_albert_for_masked_lm(*a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_albert_for_multiple_choice(*a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_albert_for_sequence_classification(*a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_albert_for_question_answering(*a   )


    @slow
    def        __a							(					self   ):
          for model_name in TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                UpperCamelCase__  =    TFAlbertModel.from_pretrained(a   )
                self.assertIsNotNone(a   )

@require_tf
class  lowercase_					(   unittest.TestCase       ):


    @slow
    def        __a							(					self   ):
          UpperCamelCase__  =    TFAlbertForPreTraining.from_pretrained("albert-base-v2"   )
          UpperCamelCase__  =    tf.constant([[0, 1, 2, 3, 4, 5]]   )
          UpperCamelCase__  =    model(a   )[0]

          UpperCamelCase__  =    [1, 6, 3_00_00]
          self.assertEqual(output.shape  , a   )

          UpperCamelCase__  =    tf.constant(
              [
                  [
                      [4.59_5668, 0.7446_2754, -1.81_8147],
                      [4.595_4347, 0.745_4184, -1.818_8258],
                      [4.595_4905, 0.744_8235, -1.818_2316],
                  ]
              ]   )
          tf.debugging.assert_near(output[:, :3, :3]  , a  , atol=1e-4   )









'''simple docstring'''







def _UpperCamelCase	(					__A   )							->		int:


      '''simple docstring'''



      if number != int(__A   ):
            raise ValueError("factorial() only accepts integral values"   )
      if number < 0:
            raise ValueError("factorial() not defined for negative values"   )
      UpperCamelCase__  =    1
      for i in range(1				,      number + 1   ):
            value *= i
      return value







def _UpperCamelCase	(					__A   )							->		int:


      '''simple docstring'''



      if not isinstance(__A				,      __A   ):
            raise ValueError("factorial() only accepts integral values"   )
      if n < 0:
            raise ValueError("factorial() not defined for negative values"   )
      return 1 if n == 0 or n == 1 else n * factorial(n - 1   )


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  a__  : str				=	int(input('Enter a positive integer: ').strip() or 0)
  print(F"""factorial{n} is {factorial(n)}""")





