

'''simple docstring'''





from __future__ import annotations

import unittest

from transformers import DistilBertConfig, is_tf_available
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.models.distilbert.modeling_tf_distilbert import (
           TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
           TFDistilBertForMaskedLM,
           TFDistilBertForMultipleChoice,
           TFDistilBertForQuestionAnswering,
           TFDistilBertForSequenceClassification,
           TFDistilBertForTokenClassification,
           TFDistilBertModel,
       )






class  UpperCAmelCase__	:






  """simple docstring"""


  def __init__(							self		:	List[Any]			,     __lowerCamelCase		:	List[Any]			,     )	->							List[Any]:
       SCREAMING_SNAKE_CASE__					=					parent
       SCREAMING_SNAKE_CASE__					=					13
       SCREAMING_SNAKE_CASE__					=					7
       SCREAMING_SNAKE_CASE__					=					True
       SCREAMING_SNAKE_CASE__					=					True
       SCREAMING_SNAKE_CASE__					=					False
       SCREAMING_SNAKE_CASE__					=					True
       SCREAMING_SNAKE_CASE__					=					99
       SCREAMING_SNAKE_CASE__					=					32
       SCREAMING_SNAKE_CASE__					=					2
       SCREAMING_SNAKE_CASE__					=					4
       SCREAMING_SNAKE_CASE__					=					37
       SCREAMING_SNAKE_CASE__					=					'''gelu'''
       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__					=					None






  def    lowercase_	(							self		:	Optional[Any]      )	->							List[Any]:
       SCREAMING_SNAKE_CASE__					=					ids_tensor([self.batch_size, self.seq_length]			,     self.vocab_size      )

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

       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]			,     self.num_choices      )

       SCREAMING_SNAKE_CASE__					=					DistilBertConfig(
           vocab_size=self.vocab_size			,     dim=self.hidden_size			,     n_layers=self.num_hidden_layers			,     n_heads=self.num_attention_heads			,     hidden_dim=self.intermediate_size			,     hidden_act=self.hidden_act			,     dropout=self.hidden_dropout_prob			,     attention_dropout=self.attention_probs_dropout_prob			,     max_position_embeddings=self.max_position_embeddings			,     initializer_range=self.initializer_range			,     )

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






  def    lowercase_	(							self		:	Any			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	Union[str, Any]			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	Any			,     __lowerCamelCase		:	Optional[int]      )	->							List[Any]:
       SCREAMING_SNAKE_CASE__					=					TFDistilBertModel(config=UpperCAmelCase__      )
       SCREAMING_SNAKE_CASE__					=					{'''input_ids''': input_ids, '''attention_mask''': input_mask}

       SCREAMING_SNAKE_CASE__					=					model(UpperCAmelCase__      )

       SCREAMING_SNAKE_CASE__					=					[input_ids, input_mask]

       SCREAMING_SNAKE_CASE__					=					model(UpperCAmelCase__      )

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






  def    lowercase_	(							self		:	Union[str, Any]			,     __lowerCamelCase		:	List[Any]			,     __lowerCamelCase		:	List[Any]			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	Union[str, Any]			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	int      )	->							str:
       SCREAMING_SNAKE_CASE__					=					TFDistilBertForMaskedLM(config=UpperCAmelCase__      )
       SCREAMING_SNAKE_CASE__					=					{'''input_ids''': input_ids, '''attention_mask''': input_mask}
       SCREAMING_SNAKE_CASE__					=					model(UpperCAmelCase__      )
       self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.vocab_size)      )






  def    lowercase_	(							self		:	List[Any]			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Union[str, Any]			,     __lowerCamelCase		:	Union[str, Any]			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Optional[int]      )	->							str:
       SCREAMING_SNAKE_CASE__					=					TFDistilBertForQuestionAnswering(config=UpperCAmelCase__      )
       SCREAMING_SNAKE_CASE__					=					{
           '''input_ids''': input_ids,
           '''attention_mask''': input_mask,
       }
       SCREAMING_SNAKE_CASE__					=					model(UpperCAmelCase__      )
       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    lowercase_	(							self		:	str			,     __lowerCamelCase		:	Union[str, Any]			,     __lowerCamelCase		:	Union[str, Any]			,     __lowerCamelCase		:	Union[str, Any]			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	List[str]      )	->							List[str]:
       SCREAMING_SNAKE_CASE__					=					self.num_labels
       SCREAMING_SNAKE_CASE__					=					TFDistilBertForSequenceClassification(UpperCAmelCase__      )
       SCREAMING_SNAKE_CASE__					=					{'''input_ids''': input_ids, '''attention_mask''': input_mask}
       SCREAMING_SNAKE_CASE__					=					model(UpperCAmelCase__      )
       self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_labels)      )






  def    lowercase_	(							self		:	List[Any]			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	Tuple			,     __lowerCamelCase		:	Union[str, Any]			,     __lowerCamelCase		:	str			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	Union[str, Any]      )	->							Any:
       SCREAMING_SNAKE_CASE__					=					self.num_choices
       SCREAMING_SNAKE_CASE__					=					TFDistilBertForMultipleChoice(UpperCAmelCase__      )
       SCREAMING_SNAKE_CASE__					=					tf.tile(tf.expand_dims(UpperCAmelCase__			,     1      )			,     (1, self.num_choices, 1)      )
       SCREAMING_SNAKE_CASE__					=					tf.tile(tf.expand_dims(UpperCAmelCase__			,     1      )			,     (1, self.num_choices, 1)      )
       SCREAMING_SNAKE_CASE__					=					{
           '''input_ids''': multiple_choice_inputs_ids,
           '''attention_mask''': multiple_choice_input_mask,
       }
       SCREAMING_SNAKE_CASE__					=					model(UpperCAmelCase__      )
       self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_choices)      )






  def    lowercase_	(							self		:	Union[str, Any]			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	str			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	Optional[int]      )	->							List[Any]:
       SCREAMING_SNAKE_CASE__					=					self.num_labels
       SCREAMING_SNAKE_CASE__					=					TFDistilBertForTokenClassification(UpperCAmelCase__      )
       SCREAMING_SNAKE_CASE__					=					{'''input_ids''': input_ids, '''attention_mask''': input_mask}
       SCREAMING_SNAKE_CASE__					=					model(UpperCAmelCase__      )
       self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.num_labels)      )







  def    lowercase_	(							self		:	Any      )	->							Any:
       SCREAMING_SNAKE_CASE__					=					self.prepare_config_and_inputs()
       (SCREAMING_SNAKE_CASE__)					=					config_and_inputs
       SCREAMING_SNAKE_CASE__					=					{'''input_ids''': input_ids, '''attention_mask''': input_mask}
       return config, inputs_dict






@require_tf
class  UpperCAmelCase__	( lowercase__		,  lowercase__		,  unittest.TestCase ):






  """simple docstring"""


  a     =      (
      (
          TFDistilBertModel,
          TFDistilBertForMaskedLM,
          TFDistilBertForQuestionAnswering,
          TFDistilBertForSequenceClassification,
          TFDistilBertForTokenClassification,
          TFDistilBertForMultipleChoice,
      )
      if is_tf_available()
      else None
  )
  a     =      (
      {
          "feature-extraction": TFDistilBertModel,
          "fill-mask": TFDistilBertForMaskedLM,
          "question-answering": TFDistilBertForQuestionAnswering,
          "text-classification": TFDistilBertForSequenceClassification,
          "token-classification": TFDistilBertForTokenClassification,
          "zero-shot": TFDistilBertForSequenceClassification,
      }
      if is_tf_available()
      else {}
  )
  a     =      False
  a     =      False






  def    lowercase_	(							self		:	Optional[Any]      )	->							str:
       SCREAMING_SNAKE_CASE__					=					TFDistilBertModelTester(self      )
       SCREAMING_SNAKE_CASE__					=					ConfigTester(self			,     config_class=UpperCAmelCase__			,     dim=37      )






  def    lowercase_	(							self		:	List[Any]      )	->							List[Any]:
       self.config_tester.run_common_tests()






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






  def    lowercase_	(							self		:	Dict      )	->							str:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_distilbert_for_masked_lm(*UpperCAmelCase__      )






  def    lowercase_	(							self		:	str      )	->							int:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_distilbert_for_question_answering(*UpperCAmelCase__      )






  def    lowercase_	(							self		:	int      )	->							Any:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_distilbert_for_sequence_classification(*UpperCAmelCase__      )






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






  def    lowercase_	(							self		:	Optional[int]      )	->							List[Any]:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_distilbert_for_token_classification(*UpperCAmelCase__      )







  @slow
  def    lowercase_	(							self		:	Dict      )	->							Optional[Any]:
       for model_name in list(TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]      ):
            SCREAMING_SNAKE_CASE__					=					TFDistilBertModel.from_pretrained(UpperCAmelCase__      )
            self.assertIsNotNone(UpperCAmelCase__      )






@require_tf
class  UpperCAmelCase__	( unittest.TestCase ):






  """simple docstring"""


  @slow
  def    lowercase_	(							self		:	Dict      )	->							str:
       SCREAMING_SNAKE_CASE__					=					TFDistilBertModel.from_pretrained('''distilbert-base-uncased'''      )
       SCREAMING_SNAKE_CASE__					=					tf.constant([[0, 1, 2, 3, 4, 5]]      )
       SCREAMING_SNAKE_CASE__					=					model(UpperCAmelCase__      )[0]

       SCREAMING_SNAKE_CASE__					=					[1, 6, 768]
       self.assertEqual(output.shape			,     UpperCAmelCase__      )

       SCREAMING_SNAKE_CASE__					=					tf.constant(
           [
               [
                   [0.19261885, -0.13732955, 0.4119799],
                   [0.22150156, -0.07422661, 0.39037204],
                   [0.22756018, -0.0896414, 0.3701467],
               ]
           ]      )
       tf.debugging.assert_near(output[:, :3, :3]			,     UpperCAmelCase__			,     atol=1e-4      )





from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Features, Sequence, Value
from .base import TaskTemplate






@dataclass(frozen=A__ )
class  UpperCAmelCase__	( A__ ):






  """simple docstring"""


  a     =      field(default="question-answering-extractive"		,  metadata={"include_in_asdict_even_if_is_default": True} )
  a     =      Features({"question": Value("string" ), "context": Value("string" )} )
  a     =      Features(
      {
          "answers": Sequence(
              {
                  "text": Value("string" ),
                  "answer_start": Value("int32" ),
              } )
      } )
  a     =      "question"
  a     =      "context"
  a     =      "answers"






  @property
  def    lowercase_	(							self		:	Dict      )	->							Dict[str, str]:
       return {self.question_column: "question", self.context_column: "context", self.answers_column: "answers"}


