

'''simple docstring'''



from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, 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 numpy as np
  import tensorflow as tf

  from transformers import (
      TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
      FlaubertConfig,
      TFFlaubertForMultipleChoice,
      TFFlaubertForQuestionAnsweringSimple,
      TFFlaubertForSequenceClassification,
      TFFlaubertForTokenClassification,
      TFFlaubertModel,
      TFFlaubertWithLMHeadModel,
  )







class 		lowerCAmelCase__  :



 """simple docstring"""



 def __init__(						self   :			int   ,				__SCREAMING_SNAKE_CASE   :			Tuple   ,				)    ->					Optional[int]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = parent
      __SCREAMING_SNAKE_CASE      = 13
      __SCREAMING_SNAKE_CASE      = 7
      __SCREAMING_SNAKE_CASE      = True
      __SCREAMING_SNAKE_CASE      = True
      __SCREAMING_SNAKE_CASE      = True
      __SCREAMING_SNAKE_CASE      = True
      __SCREAMING_SNAKE_CASE      = True
      __SCREAMING_SNAKE_CASE      = False
      __SCREAMING_SNAKE_CASE      = False
      __SCREAMING_SNAKE_CASE      = False
      __SCREAMING_SNAKE_CASE      = 2
      __SCREAMING_SNAKE_CASE      = 99
      __SCREAMING_SNAKE_CASE      = 0
      __SCREAMING_SNAKE_CASE      = 32
      __SCREAMING_SNAKE_CASE      = 2
      __SCREAMING_SNAKE_CASE      = 4
      __SCREAMING_SNAKE_CASE      = 0.1
      __SCREAMING_SNAKE_CASE      = 0.1
      __SCREAMING_SNAKE_CASE      = 512
      __SCREAMING_SNAKE_CASE      = 16
      __SCREAMING_SNAKE_CASE      = 2
      __SCREAMING_SNAKE_CASE      = 0.02
      __SCREAMING_SNAKE_CASE      = 3
      __SCREAMING_SNAKE_CASE      = 4
      __SCREAMING_SNAKE_CASE      = """last"""
      __SCREAMING_SNAKE_CASE      = True
      __SCREAMING_SNAKE_CASE      = None
      __SCREAMING_SNAKE_CASE      = 0
 def  UpperCAmelCase__						(						self   :			int     )    ->					Optional[int]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size, self.seq_length]   ,				self.vocab_size     )
      __SCREAMING_SNAKE_CASE      = random_attention_mask([self.batch_size, self.seq_length]   ,				dtype=tf.floataa     )

      __SCREAMING_SNAKE_CASE      = None
      if self.use_input_lengths:
           __SCREAMING_SNAKE_CASE      = (
               ids_tensor([self.batch_size]   ,				vocab_size=2     ) + self.seq_length - 2
           )  # small variation of seq_length

      __SCREAMING_SNAKE_CASE      = None
      if self.use_token_type_ids:
           __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size, self.seq_length]   ,				self.n_langs     )

      __SCREAMING_SNAKE_CASE      = None
      __SCREAMING_SNAKE_CASE      = None
      __SCREAMING_SNAKE_CASE      = None
      if self.use_labels:
           __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size]   ,				self.type_sequence_label_size     )
           __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size, self.seq_length]   ,				self.num_labels     )
           __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size]   ,				2   ,				dtype=tf.floataa     )
           __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size]   ,				self.num_choices     )

      __SCREAMING_SNAKE_CASE      = FlaubertConfig(
          vocab_size=self.vocab_size   ,				n_special=self.n_special   ,				emb_dim=self.hidden_size   ,				n_layers=self.num_hidden_layers   ,				n_heads=self.num_attention_heads   ,				dropout=self.hidden_dropout_prob   ,				attention_dropout=self.attention_probs_dropout_prob   ,				gelu_activation=self.gelu_activation   ,				sinusoidal_embeddings=self.sinusoidal_embeddings   ,				asm=self.asm   ,				causal=self.causal   ,				n_langs=self.n_langs   ,				max_position_embeddings=self.max_position_embeddings   ,				initializer_range=self.initializer_range   ,				summary_type=self.summary_type   ,				use_proj=self.use_proj   ,				bos_token_id=self.bos_token_id   ,				)

      return (
          config,
          input_ids,
          token_type_ids,
          input_lengths,
          sequence_labels,
          token_labels,
          is_impossible_labels,
          choice_labels,
          input_mask,
      )
 def  UpperCAmelCase__						(						self   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			List[Any]   ,				__SCREAMING_SNAKE_CASE   :			int   ,				__SCREAMING_SNAKE_CASE   :			Optional[Any]   ,				__SCREAMING_SNAKE_CASE   :			Tuple   ,				__SCREAMING_SNAKE_CASE   :			Any   ,				__SCREAMING_SNAKE_CASE   :			Tuple   ,				__SCREAMING_SNAKE_CASE   :			int   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			Any   ,				)    ->					Optional[int]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = TFFlaubertModel(config=lowercase_     )
      __SCREAMING_SNAKE_CASE      = {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
      __SCREAMING_SNAKE_CASE      = model(lowercase_     )

      __SCREAMING_SNAKE_CASE      = [input_ids, input_mask]
      __SCREAMING_SNAKE_CASE      = model(lowercase_     )
      self.parent.assertEqual(result.last_hidden_state.shape   ,				(self.batch_size, self.seq_length, self.hidden_size)     )
 def  UpperCAmelCase__						(						self   :			Any   ,				__SCREAMING_SNAKE_CASE   :			List[Any]   ,				__SCREAMING_SNAKE_CASE   :			Union[str, Any]   ,				__SCREAMING_SNAKE_CASE   :			List[Any]   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			Union[str, Any]   ,				__SCREAMING_SNAKE_CASE   :			str   ,				__SCREAMING_SNAKE_CASE   :			Union[str, Any]   ,				__SCREAMING_SNAKE_CASE   :			int   ,				)    ->					Tuple:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = TFFlaubertWithLMHeadModel(lowercase_     )

      __SCREAMING_SNAKE_CASE      = {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
      __SCREAMING_SNAKE_CASE      = model(lowercase_     )

      self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.seq_length, self.vocab_size)     )
 def  UpperCAmelCase__						(						self   :			List[Any]   ,				__SCREAMING_SNAKE_CASE   :			Any   ,				__SCREAMING_SNAKE_CASE   :			Union[str, Any]   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			str   ,				__SCREAMING_SNAKE_CASE   :			Tuple   ,				__SCREAMING_SNAKE_CASE   :			int   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			Union[str, Any]   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				)    ->					List[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = TFFlaubertForQuestionAnsweringSimple(lowercase_     )

      __SCREAMING_SNAKE_CASE      = {"""input_ids""": input_ids, """lengths""": input_lengths}

      __SCREAMING_SNAKE_CASE      = model(lowercase_     )

      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  UpperCAmelCase__						(						self   :			Tuple   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			Optional[Any]   ,				__SCREAMING_SNAKE_CASE   :			Union[str, Any]   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			Optional[Any]   ,				__SCREAMING_SNAKE_CASE   :			Tuple   ,				__SCREAMING_SNAKE_CASE   :			int   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				)    ->					Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = TFFlaubertForSequenceClassification(lowercase_     )

      __SCREAMING_SNAKE_CASE      = {"""input_ids""": input_ids, """lengths""": input_lengths}

      __SCREAMING_SNAKE_CASE      = model(lowercase_     )

      self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.type_sequence_label_size)     )
 def  UpperCAmelCase__						(						self   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			Tuple   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			str   ,				__SCREAMING_SNAKE_CASE   :			str   ,				__SCREAMING_SNAKE_CASE   :			str   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			Optional[Any]   ,				)    ->					Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.num_labels
      __SCREAMING_SNAKE_CASE      = TFFlaubertForTokenClassification(config=lowercase_     )
      __SCREAMING_SNAKE_CASE      = {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
      __SCREAMING_SNAKE_CASE      = model(lowercase_     )
      self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.seq_length, self.num_labels)     )
 def  UpperCAmelCase__						(						self   :			Optional[Any]   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			List[Any]   ,				__SCREAMING_SNAKE_CASE   :			List[Any]   ,				__SCREAMING_SNAKE_CASE   :			Tuple   ,				__SCREAMING_SNAKE_CASE   :			str   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]   ,				)    ->					int:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.num_choices
      __SCREAMING_SNAKE_CASE      = TFFlaubertForMultipleChoice(config=lowercase_     )
      __SCREAMING_SNAKE_CASE      = tf.tile(tf.expand_dims(lowercase_   ,				1     )   ,				(1, self.num_choices, 1)     )
      __SCREAMING_SNAKE_CASE      = tf.tile(tf.expand_dims(lowercase_   ,				1     )   ,				(1, self.num_choices, 1)     )
      __SCREAMING_SNAKE_CASE      = tf.tile(tf.expand_dims(lowercase_   ,				1     )   ,				(1, self.num_choices, 1)     )
      __SCREAMING_SNAKE_CASE      = {
          """input_ids""": multiple_choice_inputs_ids,
          """attention_mask""": multiple_choice_input_mask,
          """token_type_ids""": multiple_choice_token_type_ids,
      }
      __SCREAMING_SNAKE_CASE      = model(lowercase_     )
      self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.num_choices)     )


 def  UpperCAmelCase__						(						self   :			Optional[Any]     )    ->					Union[str, Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.prepare_config_and_inputs()
      (
          (
          __SCREAMING_SNAKE_CASE				
      )  ,     (
          __SCREAMING_SNAKE_CASE				
      )  ,     (
          __SCREAMING_SNAKE_CASE				
      )  ,     (
          __SCREAMING_SNAKE_CASE				
      )  ,     (
          __SCREAMING_SNAKE_CASE				
      )  ,     (
          __SCREAMING_SNAKE_CASE				
      )  ,     (
          __SCREAMING_SNAKE_CASE				
      )  ,     (
          __SCREAMING_SNAKE_CASE				
      )  ,     (
          __SCREAMING_SNAKE_CASE				
      )  ,     				
      )      = config_and_inputs
      __SCREAMING_SNAKE_CASE      = {
          """input_ids""": input_ids,
          """token_type_ids""": token_type_ids,
          """langs""": token_type_ids,
          """lengths""": input_lengths,
      }
      return config, inputs_dict







@require_tf
class 		lowerCAmelCase__  ( SCREAMING_SNAKE_CASE_					,   SCREAMING_SNAKE_CASE_					,   unittest.TestCase   ):



 """simple docstring"""



 lowerCAmelCase__       = (
     (
         TFFlaubertModel,
         TFFlaubertWithLMHeadModel,
         TFFlaubertForSequenceClassification,
         TFFlaubertForQuestionAnsweringSimple,
         TFFlaubertForTokenClassification,
         TFFlaubertForMultipleChoice,
     )
     if is_tf_available()
     else ()
 )
 lowerCAmelCase__       = (
     (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
 )  # TODO (PVP): Check other models whether language generation is also applicable
 lowerCAmelCase__       = (
     {
         "feature-extraction": TFFlaubertModel,
         "fill-mask": TFFlaubertWithLMHeadModel,
         "question-answering": TFFlaubertForQuestionAnsweringSimple,
         "text-classification": TFFlaubertForSequenceClassification,
         "token-classification": TFFlaubertForTokenClassification,
         "zero-shot": TFFlaubertForSequenceClassification,
     }
     if is_tf_available()
     else {}
 )
 lowerCAmelCase__       = False
 lowerCAmelCase__       = False
 def  UpperCAmelCase__						(						self   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			List[Any]   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			Union[str, Any]   ,				__SCREAMING_SNAKE_CASE   :			Tuple   ,				__SCREAMING_SNAKE_CASE   :			Optional[Any]     )    ->					Optional[int]:


      """simple docstring"""




      if (
          pipeline_test_casse_name == "QAPipelineTests"
          and tokenizer_name is not None
          and not tokenizer_name.endswith("""Fast"""     )
      ):
           # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
           # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
           # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
           return True

      return False
 def  UpperCAmelCase__						(						self   :			Optional[int]     )    ->					Tuple:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = TFFlaubertModelTester(self     )
      __SCREAMING_SNAKE_CASE      = ConfigTester(self   ,				config_class=lowercase_   ,				emb_dim=37     )
 def  UpperCAmelCase__						(						self   :			List[Any]     )    ->					List[Any]:


      """simple docstring"""




      self.config_tester.run_common_tests()
 def  UpperCAmelCase__						(						self   :			Any     )    ->					Any:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_flaubert_model(*lowercase_     )
 def  UpperCAmelCase__						(						self   :			List[str]     )    ->					Optional[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_flaubert_lm_head(*lowercase_     )
 def  UpperCAmelCase__						(						self   :			Union[str, Any]     )    ->					Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_flaubert_qa(*lowercase_     )
 def  UpperCAmelCase__						(						self   :			Optional[int]     )    ->					List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_flaubert_sequence_classif(*lowercase_     )
 def  UpperCAmelCase__						(						self   :			Any     )    ->					str:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_flaubert_for_token_classification(*lowercase_     )
 def  UpperCAmelCase__						(						self   :			List[str]     )    ->					Union[str, Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_flaubert_for_multiple_choice(*lowercase_     )


 @slow
 def  UpperCAmelCase__						(						self   :			Any     )    ->					List[Any]:


      """simple docstring"""




      for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           __SCREAMING_SNAKE_CASE      = TFFlaubertModel.from_pretrained(lowercase_     )
           self.assertIsNotNone(lowercase_     )







@require_tf
@require_sentencepiece
@require_tokenizers
class 		lowerCAmelCase__  ( unittest.TestCase   ):



 """simple docstring"""



 @slow
 def  UpperCAmelCase__						(						self   :			int     )    ->					int:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = TFFlaubertModel.from_pretrained("""jplu/tf-flaubert-small-cased"""     )

      __SCREAMING_SNAKE_CASE      = tf.convert_to_tensor(
          [[0, 158, 735, 2_592, 1_424, 6_727, 82, 1]]   ,				dtype=tf.intaa   ,				)  # "J'aime flaubert !"

      __SCREAMING_SNAKE_CASE      = model(lowercase_     )[0]
      __SCREAMING_SNAKE_CASE      = tf.TensorShape((1, 8, 512)     )
      self.assertEqual(output.shape   ,				lowercase_     )
      # compare the actual values for a slice.
      __SCREAMING_SNAKE_CASE      = tf.convert_to_tensor(
          [
              [
                  [-1.8768773, -1.566555, 0.27072418],
                  [-1.6920038, -0.5873505, 1.9329599],
                  [-2.9563985, -1.6993835, 1.7972052],
              ]
          ]   ,				dtype=tf.floataa   ,				)

      self.assertTrue(np.allclose(output[:, :3, :3].numpy()   ,				expected_slice.numpy()   ,				atol=1E-4     )     )








"""simple docstring"""

from math import ceil, sqrt




def      lowercase__    (       lowerCAmelCase					:       int = 1_000_000			)			->   int:






    """simple docstring"""




    UpperCAmelCase          =       0

    for outer_width in range(3			,					(limit // 4) + 2			):
        if outer_width**2 > limit:
            UpperCAmelCase          =       max(ceil(sqrt(outer_width**2 - limit			)			)			,					1			)
        else:
            UpperCAmelCase          =       1
        if (outer_width - hole_width_lower_bound) % 2:
            hole_width_lower_bound += 1

        answer += (outer_width - hole_width_lower_bound - 2) // 2 + 1

    return answer


if __name__ == "__main__":
   print(F'{solution() = }')



