





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_       :


							def __init__(							self    :Tuple							,				__A    :Any							,				)   ->   Union[str, Any]:



									"""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__			=      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.0_2
									SCREAMING_SNAKE_CASE__			=      3
									SCREAMING_SNAKE_CASE__			=      4
									SCREAMING_SNAKE_CASE__			=      None


							def      _snake_case  (							self    :Optional[Any]		)   ->   str:



									"""simple docstring"""



									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      _snake_case  (							self    :List[str]							,				__A    :List[Any]							,				__A    :Dict							,				__A    :int							,				__A    :Optional[Any]							,				__A    :Any							,				__A    :List[str]		)   ->   List[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      TFDistilBertModel(config=__A		)
									SCREAMING_SNAKE_CASE__			=      {"""input_ids""": input_ids, """attention_mask""": input_mask}

									SCREAMING_SNAKE_CASE__			=      model(__A		)

									SCREAMING_SNAKE_CASE__			=      [input_ids, input_mask]

									SCREAMING_SNAKE_CASE__			=      model(__A		)

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


							def      _snake_case  (							self    :Tuple							,				__A    :Optional[int]							,				__A    :List[str]							,				__A    :Union[str, Any]							,				__A    :Any							,				__A    :List[Any]							,				__A    :Tuple		)   ->   str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      TFDistilBertForMaskedLM(config=__A		)
									SCREAMING_SNAKE_CASE__			=      {"""input_ids""": input_ids, """attention_mask""": input_mask}
									SCREAMING_SNAKE_CASE__			=      model(__A		)
									self.parent.assertEqual(result.logits.shape							,				(self.batch_size, self.seq_length, self.vocab_size)		)


							def      _snake_case  (							self    :Tuple							,				__A    :int							,				__A    :str							,				__A    :Union[str, Any]							,				__A    :Optional[Any]							,				__A    :Any							,				__A    :List[str]		)   ->   Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      TFDistilBertForQuestionAnswering(config=__A		)
									SCREAMING_SNAKE_CASE__			=      {
									    """input_ids""": input_ids,
									    """attention_mask""": input_mask,
									}
									SCREAMING_SNAKE_CASE__			=      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      _snake_case  (							self    :Dict							,				__A    :Optional[Any]							,				__A    :Optional[Any]							,				__A    :Dict							,				__A    :Optional[int]							,				__A    :List[Any]							,				__A    :Tuple		)   ->   Tuple:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.num_labels
									SCREAMING_SNAKE_CASE__			=      TFDistilBertForSequenceClassification(__A		)
									SCREAMING_SNAKE_CASE__			=      {"""input_ids""": input_ids, """attention_mask""": input_mask}
									SCREAMING_SNAKE_CASE__			=      model(__A		)
									self.parent.assertEqual(result.logits.shape							,				(self.batch_size, self.num_labels)		)


							def      _snake_case  (							self    :Union[str, Any]							,				__A    :List[str]							,				__A    :Any							,				__A    :Optional[int]							,				__A    :int							,				__A    :str							,				__A    :Union[str, Any]		)   ->   List[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.num_choices
									SCREAMING_SNAKE_CASE__			=      TFDistilBertForMultipleChoice(__A		)
									SCREAMING_SNAKE_CASE__			=      tf.tile(tf.expand_dims(__A							,				1		)							,				(1, self.num_choices, 1)		)
									SCREAMING_SNAKE_CASE__			=      tf.tile(tf.expand_dims(__A							,				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(__A		)
									self.parent.assertEqual(result.logits.shape							,				(self.batch_size, self.num_choices)		)


							def      _snake_case  (							self    :List[Any]							,				__A    :Any							,				__A    :Any							,				__A    :int							,				__A    :List[Any]							,				__A    :str							,				__A    :Dict		)   ->   str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.num_labels
									SCREAMING_SNAKE_CASE__			=      TFDistilBertForTokenClassification(__A		)
									SCREAMING_SNAKE_CASE__			=      {"""input_ids""": input_ids, """attention_mask""": input_mask}
									SCREAMING_SNAKE_CASE__			=      model(__A		)
									self.parent.assertEqual(result.logits.shape							,				(self.batch_size, self.seq_length, self.num_labels)		)


							def      _snake_case  (							self    :Optional[int]		)   ->   List[str]:



									"""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__))			=      config_and_inputs
									SCREAMING_SNAKE_CASE__			=      {"""input_ids""": input_ids, """attention_mask""": input_mask}
									return config, inputs_dict




@require_tf
class   UpperCamelCase_       (     UpperCamelCase__				,  UpperCamelCase__				,  unittest.TestCase    ):
							lowerCamelCase_           =					(
							    (
							        TFDistilBertModel,
							        TFDistilBertForMaskedLM,
							        TFDistilBertForQuestionAnswering,
							        TFDistilBertForSequenceClassification,
							        TFDistilBertForTokenClassification,
							        TFDistilBertForMultipleChoice,
							    )
							    if is_tf_available()
							    else None
							)
							lowerCamelCase_           =					(
							    {
							        "feature-extraction": TFDistilBertModel,
							        "fill-mask": TFDistilBertForMaskedLM,
							        "question-answering": TFDistilBertForQuestionAnswering,
							        "text-classification": TFDistilBertForSequenceClassification,
							        "token-classification": TFDistilBertForTokenClassification,
							        "zero-shot": TFDistilBertForSequenceClassification,
							    }
							    if is_tf_available()
							    else {}
							)
							lowerCamelCase_           =					False
							lowerCamelCase_           =					False


							def      _snake_case  (							self    :Tuple		)   ->   Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      TFDistilBertModelTester(self		)
									SCREAMING_SNAKE_CASE__			=      ConfigTester(self							,				config_class=__A							,				dim=37		)


							def      _snake_case  (							self    :List[str]		)   ->   Optional[int]:



									"""simple docstring"""



									self.config_tester.run_common_tests()


							def      _snake_case  (							self    :Optional[Any]		)   ->   Any:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_model(*__A		)


							def      _snake_case  (							self    :List[str]		)   ->   str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_masked_lm(*__A		)


							def      _snake_case  (							self    :List[Any]		)   ->   Dict:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_question_answering(*__A		)


							def      _snake_case  (							self    :List[str]		)   ->   Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_sequence_classification(*__A		)


							def      _snake_case  (							self    :Dict		)   ->   str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_multiple_choice(*__A		)


							def      _snake_case  (							self    :str		)   ->   int:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_token_classification(*__A		)


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



									"""simple docstring"""



									for model_name in list(TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]		):
											SCREAMING_SNAKE_CASE__			=      TFDistilBertModel.from_pretrained(__A		)
											self.assertIsNotNone(__A		)




@require_tf
class   UpperCamelCase_       (     unittest.TestCase    ):


							@slow
							def      _snake_case  (							self    :List[str]		)   ->   Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      TFDistilBertModel.from_pretrained("""distilbert-base-uncased"""		)
									SCREAMING_SNAKE_CASE__			=      tf.constant([[0, 1, 2, 3, 4, 5]]		)
									SCREAMING_SNAKE_CASE__			=      model(__A		)[0]

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

									SCREAMING_SNAKE_CASE__			=      tf.constant(
									    [
									        [
									            [0.1_9_2_6_1_8_8_5, -0.1_3_7_3_2_9_5_5, 0.4_1_1_9_7_9_9],
									            [0.2_2_1_5_0_1_5_6, -0.0_7_4_2_2_6_6_1, 0.3_9_0_3_7_2_0_4],
									            [0.2_2_7_5_6_0_1_8, -0.0_8_9_6_4_1_4, 0.3_7_0_1_4_6_7],
									        ]
									    ]		)
									tf.debugging.assert_near(output[:, :3, :3]							,				__A							,				atol=1E-4		)






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

from ..features import ClassLabel, Features, Image
from .base import TaskTemplate




@dataclass(frozen=UpperCamelCase__    )
class   UpperCamelCase_       (     UpperCamelCase__    ):
							lowerCamelCase_           =					field(default="image-classification"				,  metadata={"include_in_asdict_even_if_is_default": True}    )
							lowerCamelCase_           =					Features({"image": Image()}    )
							lowerCamelCase_           =					Features({"labels": ClassLabel}    )
							lowerCamelCase_           =					"image"
							lowerCamelCase_           =					"labels"


							def      _snake_case  (							self    :List[str]							,				__A    :Tuple		)   ->   Tuple:



									"""simple docstring"""



									if self.label_column not in features:
											raise ValueError(f'''Column {self.label_column} is not present in features.'''		)
									if not isinstance(features[self.label_column]							,				__A		):
											raise ValueError(f'''Column {self.label_column} is not a ClassLabel.'''		)
									SCREAMING_SNAKE_CASE__			=      copy.deepcopy(self		)
									SCREAMING_SNAKE_CASE__			=      self.label_schema.copy()
									SCREAMING_SNAKE_CASE__			=      features[self.label_column]
									SCREAMING_SNAKE_CASE__			=      label_schema
									return task_template


							@property
							def      _snake_case  (							self    :Dict		)   ->   Dict[str, str]:



									"""simple docstring"""



									return {
									    self.image_column: "image",
									    self.label_column: "labels",
									}