
'''simple docstring'''
import unittest

from transformers import SqueezeBertConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers import (
				    SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    SqueezeBertForMaskedLM,
				    SqueezeBertForMultipleChoice,
				    SqueezeBertForQuestionAnswering,
				    SqueezeBertForSequenceClassification,
				    SqueezeBertForTokenClassification,
				    SqueezeBertModel,
				)


class       _lowerCAmelCase   (   __snake_case				):







							'''simple docstring'''

							def __init__(self  ,  UpperCAmelCase  ,  UpperCAmelCase=13  ,  UpperCAmelCase=7  ,  UpperCAmelCase=True  ,  UpperCAmelCase=True  ,  UpperCAmelCase=False  ,  UpperCAmelCase=True  ,  UpperCAmelCase=99  ,  UpperCAmelCase=32  ,  UpperCAmelCase=5  ,  UpperCAmelCase=4  ,  UpperCAmelCase=64  ,  UpperCAmelCase="gelu"  ,  UpperCAmelCase=0.1  ,  UpperCAmelCase=0.1  ,  UpperCAmelCase=512  ,  UpperCAmelCase=16  ,  UpperCAmelCase=2  ,  UpperCAmelCase=0.02  ,  UpperCAmelCase=3  ,  UpperCAmelCase=4  ,  UpperCAmelCase=None  ,  UpperCAmelCase=2  ,  UpperCAmelCase=2  ,  UpperCAmelCase=2  ,  UpperCAmelCase=2  ,  UpperCAmelCase=4  ,  UpperCAmelCase=1  ,  )					->       Any:
														_snake_case       =  parent
														_snake_case       =  batch_size
														_snake_case       =  seq_length
														_snake_case       =  is_training
														_snake_case       =  use_input_mask
														_snake_case       =  use_token_type_ids
														_snake_case       =  use_labels
														_snake_case       =  vocab_size
														_snake_case       =  hidden_size
														_snake_case       =  num_hidden_layers
														_snake_case       =  num_attention_heads
														_snake_case       =  intermediate_size
														_snake_case       =  hidden_act
														_snake_case       =  hidden_dropout_prob
														_snake_case       =  attention_probs_dropout_prob
														_snake_case       =  max_position_embeddings
														_snake_case       =  type_vocab_size
														_snake_case       =  type_sequence_label_size
														_snake_case       =  initializer_range
														_snake_case       =  num_labels
														_snake_case       =  num_choices
														_snake_case       =  scope
														_snake_case       =  q_groups
														_snake_case       =  k_groups
														_snake_case       =  v_groups
														_snake_case       =  post_attention_groups
														_snake_case       =  intermediate_groups
														_snake_case       =  output_groups

							def 	lowercase							(self  )					->       Any:
														_snake_case       =  ids_tensor([self.batch_size, self.seq_length]  ,  self.vocab_size  )

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

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

														_snake_case       =  self.get_config()

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

							def 	lowercase							(self  )					->       Union[str, Any]:
														return SqueezeBertConfig(
														    embedding_size=self.hidden_size  ,  vocab_size=self.vocab_size  ,  hidden_size=self.hidden_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  ,  attention_probs_dropout_prob=self.hidden_dropout_prob  ,  attention_dropout=self.attention_probs_dropout_prob  ,  max_position_embeddings=self.max_position_embeddings  ,  initializer_range=self.initializer_range  ,  q_groups=self.q_groups  ,  k_groups=self.k_groups  ,  v_groups=self.v_groups  ,  post_attention_groups=self.post_attention_groups  ,  intermediate_groups=self.intermediate_groups  ,  output_groups=self.output_groups  ,  )

							def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Optional[int]:
														_snake_case       =  SqueezeBertModel(config=UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()
														_snake_case       =  model(UpperCAmelCase  ,  UpperCAmelCase  )
														_snake_case       =  model(UpperCAmelCase  )
														self.parent.assertEqual(result.last_hidden_state.shape  ,  (self.batch_size, self.seq_length, self.hidden_size)  )

							def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Optional[Any]:
														_snake_case       =  SqueezeBertForMaskedLM(config=UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()
														_snake_case       =  model(UpperCAmelCase  ,  attention_mask=UpperCAmelCase  ,  labels=UpperCAmelCase  )
														self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.seq_length, self.vocab_size)  )

							def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       List[Any]:
														_snake_case       =  SqueezeBertForQuestionAnswering(config=UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()
														_snake_case       =  model(
														    UpperCAmelCase  ,  attention_mask=UpperCAmelCase  ,  start_positions=UpperCAmelCase  ,  end_positions=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  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Any:
														_snake_case       =  self.num_labels
														_snake_case       =  SqueezeBertForSequenceClassification(UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()
														_snake_case       =  model(UpperCAmelCase  ,  attention_mask=UpperCAmelCase  ,  labels=UpperCAmelCase  )
														self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.num_labels)  )

							def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Optional[Any]:
														_snake_case       =  self.num_labels
														_snake_case       =  SqueezeBertForTokenClassification(config=UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()

														_snake_case       =  model(UpperCAmelCase  ,  attention_mask=UpperCAmelCase  ,  labels=UpperCAmelCase  )
														self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.seq_length, self.num_labels)  )

							def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Union[str, Any]:
														_snake_case       =  self.num_choices
														_snake_case       =  SqueezeBertForMultipleChoice(config=UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()
														_snake_case       =  input_ids.unsqueeze(1  ).expand(-1  ,  self.num_choices  ,  -1  ).contiguous()
														_snake_case       =  input_mask.unsqueeze(1  ).expand(-1  ,  self.num_choices  ,  -1  ).contiguous()
														_snake_case       =  model(
														    UpperCAmelCase  ,  attention_mask=UpperCAmelCase  ,  labels=UpperCAmelCase  ,  )
														self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.num_choices)  )





							def 	lowercase							(self  )					->       int:
														_snake_case       =  self.prepare_config_and_inputs()
														((_snake_case),							(_snake_case),							(_snake_case),							(_snake_case),							(_snake_case),							(_snake_case))       =  config_and_inputs
														_snake_case       =  {"""input_ids""": input_ids, """attention_mask""": input_mask}
														return config, inputs_dict


@require_torch
class       _lowerCAmelCase   (   __snake_case					,							__snake_case					,							unittest.TestCase				):







							'''simple docstring'''

							lowerCAmelCase_ 						=						(
							    (
							        SqueezeBertModel,
							        SqueezeBertForMaskedLM,
							        SqueezeBertForMultipleChoice,
							        SqueezeBertForQuestionAnswering,
							        SqueezeBertForSequenceClassification,
							        SqueezeBertForTokenClassification,
							    )
							    if is_torch_available()
							    else None
							)
							lowerCAmelCase_ 						=						(
							    {
							        "feature-extraction": SqueezeBertModel,
							        "fill-mask": SqueezeBertForMaskedLM,
							        "question-answering": SqueezeBertForQuestionAnswering,
							        "text-classification": SqueezeBertForSequenceClassification,
							        "token-classification": SqueezeBertForTokenClassification,
							        "zero-shot": SqueezeBertForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							lowerCAmelCase_ 						=						False
							lowerCAmelCase_ 						=						True
							lowerCAmelCase_ 						=						False

							def 	lowercase							(self  )					->       int:
														_snake_case       =  SqueezeBertModelTester(self  )
														_snake_case       =  ConfigTester(self  ,  config_class=UpperCAmelCase  ,  dim=37  )

							def 	lowercase							(self  )					->       Tuple:
														self.config_tester.run_common_tests()

							def 	lowercase							(self  )					->       Union[str, Any]:
														_snake_case       =  self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_squeezebert_model(*UpperCAmelCase  )

							def 	lowercase							(self  )					->       Optional[Any]:
														_snake_case       =  self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_squeezebert_for_masked_lm(*UpperCAmelCase  )

							def 	lowercase							(self  )					->       Dict:
														_snake_case       =  self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_squeezebert_for_question_answering(*UpperCAmelCase  )

							def 	lowercase							(self  )					->       Tuple:
														_snake_case       =  self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_squeezebert_for_sequence_classification(*UpperCAmelCase  )

							def 	lowercase							(self  )					->       Union[str, Any]:
														_snake_case       =  self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_squeezebert_for_token_classification(*UpperCAmelCase  )

							def 	lowercase							(self  )					->       List[str]:
														_snake_case       =  self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_squeezebert_for_multiple_choice(*UpperCAmelCase  )





							@slow
							def 	lowercase							(self  )					->       Any:
														for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					_snake_case       =  SqueezeBertModel.from_pretrained(UpperCAmelCase  )
																					self.assertIsNotNone(UpperCAmelCase  )


@require_sentencepiece
@require_tokenizers
@require_torch
class       _lowerCAmelCase   (   unittest.TestCase				):







							'''simple docstring'''

							@slow
							def 	lowercase							(self  )					->       Optional[Any]:
														_snake_case       =  SqueezeBertForSequenceClassification.from_pretrained("""squeezebert/squeezebert-mnli"""  )

														_snake_case       =  torch.tensor([[1, 29414, 232, 328, 740, 1140, 12695, 69, 13, 1588, 2]]  )
														_snake_case       =  model(UpperCAmelCase  )[0]
														_snake_case       =  torch.Size((1, 3)  )
														self.assertEqual(output.shape  ,  UpperCAmelCase  )
														_snake_case       =  torch.tensor([[0.6401, -0.0349, -0.6041]]  )
														self.assertTrue(torch.allclose(UpperCAmelCase  ,  UpperCAmelCase  ,  atol=1e-4  )  )

'''simple docstring'''
from typing import TYPE_CHECKING

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


__lowerCAmelCase												=	{
    'configuration_resnet': ['RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ResNetConfig', 'ResNetOnnxConfig']
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowerCAmelCase												=	[
				    'RESNET_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'ResNetForImageClassification',
				    'ResNetModel',
				    'ResNetPreTrainedModel',
				    'ResNetBackbone',
				]

try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowerCAmelCase												=	[
				    'TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'TFResNetForImageClassification',
				    'TFResNetModel',
				    'TFResNetPreTrainedModel',
				]

try:
				if not is_flax_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowerCAmelCase												=	[
				    'FlaxResNetForImageClassification',
				    'FlaxResNetModel',
				    'FlaxResNetPreTrainedModel',
				]

if TYPE_CHECKING:
				from .configuration_resnet import RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ResNetConfig, ResNetOnnxConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_resnet import (
								    RESNET_PRETRAINED_MODEL_ARCHIVE_LIST,
								    ResNetBackbone,
								    ResNetForImageClassification,
								    ResNetModel,
								    ResNetPreTrainedModel,
								)

				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_resnet import (
								    TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFResNetForImageClassification,
								    TFResNetModel,
								    TFResNetPreTrainedModel,
								)

				try:
								if not is_flax_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_flax_resnet import FlaxResNetForImageClassification, FlaxResNetModel, FlaxResNetPreTrainedModel


else:
				import sys

				__lowerCAmelCase												=	_LazyModule(__name__, globals()['__file__'], _import_structure)