


'''simple docstring'''




from typing import Optional

import torch
import torch.utils.checkpoint
from torch import Tensor, nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_outputs import (
    BaseModelOutputWithNoAttention,
    BaseModelOutputWithPoolingAndNoAttention,
    ImageClassifierOutputWithNoAttention,
)
from ...modeling_utils import PreTrainedModel
from ...utils import logging
from .configuration_regnet import RegNetConfig


__snake_case    						=logging.get_logger(__name__)

# General docstring
__snake_case    						="""RegNetConfig"""

# Base docstring
__snake_case    						="""facebook/regnet-y-040"""
__snake_case    						=[1, 1_088, 7, 7]

# Image classification docstring
__snake_case    						="""facebook/regnet-y-040"""
__snake_case    						="""tabby, tabby cat"""

__snake_case    						=[
    """facebook/regnet-y-040""",
    # See all regnet models at https://huggingface.co/models?filter=regnet
]

class 		UpperCAmelCase_      (  nn.Module		):





     def __init__( self       :      List[Any]    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int = 3    ,      UpperCAmelCase__       :      int = 1    ,      UpperCAmelCase__       :      int = 1    ,      UpperCAmelCase__       :      Optional[str] = "relu"    ,      )				->  Any:
        super().__init__()
        lowerCAmelCase     =			nn.Convad(
            UpperCAmelCase__    ,      UpperCAmelCase__    ,      kernel_size=UpperCAmelCase__    ,      stride=UpperCAmelCase__    ,      padding=kernel_size // 2    ,      groups=UpperCAmelCase__    ,      bias=UpperCAmelCase__    ,      )
        lowerCAmelCase     =			nn.BatchNormad(UpperCAmelCase__    )
        lowerCAmelCase     =			ACTaFN[activation] if activation is not None else nn.Identity()





     def 							__UpperCAmelCase      ( self       :      Dict    ,      UpperCAmelCase__       :      Tuple    )				->  Tuple:
        lowerCAmelCase     =			self.convolution(UpperCAmelCase__    )
        lowerCAmelCase     =			self.normalization(UpperCAmelCase__    )
        lowerCAmelCase     =			self.activation(UpperCAmelCase__    )
        return hidden_state




class 		UpperCAmelCase_      (  nn.Module		):





     def __init__( self       :      Optional[int]    ,      UpperCAmelCase__       :      RegNetConfig    )				->  Tuple:
        super().__init__()
        lowerCAmelCase     =			RegNetConvLayer(
            config.num_channels    ,      config.embedding_size    ,      kernel_size=3    ,      stride=2    ,      activation=config.hidden_act    )
        lowerCAmelCase     =			config.num_channels





     def 							__UpperCAmelCase      ( self       :      Union[str, Any]    ,      UpperCAmelCase__       :      Optional[Any]    )				->  Any:
        lowerCAmelCase     =			pixel_values.shape[1]
        if num_channels != self.num_channels:
           raise ValueError(
               'Make sure that the channel dimension of the pixel values match with the one set in the configuration.'    )
        lowerCAmelCase     =			self.embedder(UpperCAmelCase__    )
        return hidden_state




class 		UpperCAmelCase_      (  nn.Module		):





     def __init__( self       :      Tuple    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int = 2    )				->  Optional[int]:
        super().__init__()
        lowerCAmelCase     =			nn.Convad(UpperCAmelCase__    ,      UpperCAmelCase__    ,      kernel_size=1    ,      stride=UpperCAmelCase__    ,      bias=UpperCAmelCase__    )
        lowerCAmelCase     =			nn.BatchNormad(UpperCAmelCase__    )





     def 							__UpperCAmelCase      ( self       :      Union[str, Any]    ,      UpperCAmelCase__       :      Tensor    )				->  Tensor:
        lowerCAmelCase     =			self.convolution(UpperCAmelCase__    )
        lowerCAmelCase     =			self.normalization(UpperCAmelCase__    )
        return hidden_state




class 		UpperCAmelCase_      (  nn.Module		):





     def __init__( self       :      Any    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    )				->  Union[str, Any]:
        super().__init__()

        lowerCAmelCase     =			nn.AdaptiveAvgPoolad((1, 1)    )
        lowerCAmelCase     =			nn.Sequential(
            nn.Convad(UpperCAmelCase__    ,      UpperCAmelCase__    ,      kernel_size=1    )    ,      nn.ReLU()    ,      nn.Convad(UpperCAmelCase__    ,      UpperCAmelCase__    ,      kernel_size=1    )    ,      nn.Sigmoid()    ,      )





     def 							__UpperCAmelCase      ( self       :      Tuple    ,      UpperCAmelCase__       :      str    )				->  Optional[Any]:
        # b c h w -> b c 1 1
        lowerCAmelCase     =			self.pooler(UpperCAmelCase__    )
        lowerCAmelCase     =			self.attention(UpperCAmelCase__    )
        lowerCAmelCase     =			hidden_state * attention
        return hidden_state




class 		UpperCAmelCase_      (  nn.Module		):





     def __init__( self       :      Optional[int]    ,      UpperCAmelCase__       :      RegNetConfig    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int = 1    )				->  Optional[int]:
        super().__init__()
        lowerCAmelCase     =			in_channels != out_channels or stride != 1
        lowerCAmelCase     =			max(1    ,      out_channels // config.groups_width    )
        lowerCAmelCase     =			(
            RegNetShortCut(UpperCAmelCase__    ,      UpperCAmelCase__    ,      stride=UpperCAmelCase__    ) if should_apply_shortcut else nn.Identity()
        )
        lowerCAmelCase     =			nn.Sequential(
            RegNetConvLayer(UpperCAmelCase__    ,      UpperCAmelCase__    ,      kernel_size=1    ,      activation=config.hidden_act    )    ,      RegNetConvLayer(UpperCAmelCase__    ,      UpperCAmelCase__    ,      stride=UpperCAmelCase__    ,      groups=UpperCAmelCase__    ,      activation=config.hidden_act    )    ,      RegNetConvLayer(UpperCAmelCase__    ,      UpperCAmelCase__    ,      kernel_size=1    ,      activation=UpperCAmelCase__    )    ,      )
        lowerCAmelCase     =			ACTaFN[config.hidden_act]





     def 							__UpperCAmelCase      ( self       :      Dict    ,      UpperCAmelCase__       :      Any    )				->  Union[str, Any]:
        lowerCAmelCase     =			hidden_state
        lowerCAmelCase     =			self.layer(UpperCAmelCase__    )
        lowerCAmelCase     =			self.shortcut(UpperCAmelCase__    )
        hidden_state += residual
        lowerCAmelCase     =			self.activation(UpperCAmelCase__    )
        return hidden_state




class 		UpperCAmelCase_      (  nn.Module		):





     def __init__( self       :      str    ,      UpperCAmelCase__       :      RegNetConfig    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int = 1    )				->  Optional[Any]:
        super().__init__()
        lowerCAmelCase     =			in_channels != out_channels or stride != 1
        lowerCAmelCase     =			max(1    ,      out_channels // config.groups_width    )
        lowerCAmelCase     =			(
            RegNetShortCut(UpperCAmelCase__    ,      UpperCAmelCase__    ,      stride=UpperCAmelCase__    ) if should_apply_shortcut else nn.Identity()
        )
        lowerCAmelCase     =			nn.Sequential(
            RegNetConvLayer(UpperCAmelCase__    ,      UpperCAmelCase__    ,      kernel_size=1    ,      activation=config.hidden_act    )    ,      RegNetConvLayer(UpperCAmelCase__    ,      UpperCAmelCase__    ,      stride=UpperCAmelCase__    ,      groups=UpperCAmelCase__    ,      activation=config.hidden_act    )    ,      RegNetSELayer(UpperCAmelCase__    ,      reduced_channels=int(round(in_channels / 4    )    )    )    ,      RegNetConvLayer(UpperCAmelCase__    ,      UpperCAmelCase__    ,      kernel_size=1    ,      activation=UpperCAmelCase__    )    ,      )
        lowerCAmelCase     =			ACTaFN[config.hidden_act]





     def 							__UpperCAmelCase      ( self       :      Any    ,      UpperCAmelCase__       :      Union[str, Any]    )				->  Tuple:
        lowerCAmelCase     =			hidden_state
        lowerCAmelCase     =			self.layer(UpperCAmelCase__    )
        lowerCAmelCase     =			self.shortcut(UpperCAmelCase__    )
        hidden_state += residual
        lowerCAmelCase     =			self.activation(UpperCAmelCase__    )
        return hidden_state




class 		UpperCAmelCase_      (  nn.Module		):





     def __init__( self       :      Union[str, Any]    ,      UpperCAmelCase__       :      RegNetConfig    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int    ,      UpperCAmelCase__       :      int = 2    ,      UpperCAmelCase__       :      int = 2    ,      )				->  Optional[Any]:
        super().__init__()

        lowerCAmelCase     =			RegNetXLayer if config.layer_type == 'x' else RegNetYLayer

        lowerCAmelCase     =			nn.Sequential(
            # downsampling is done in the first layer with stride of 2
            layer(
                UpperCAmelCase__    ,      UpperCAmelCase__    ,      UpperCAmelCase__    ,      stride=UpperCAmelCase__    ,      )    ,      *[layer(UpperCAmelCase__    ,      UpperCAmelCase__    ,      UpperCAmelCase__    ) for _ in range(depth - 1    )]    ,      )





     def 							__UpperCAmelCase      ( self       :      Optional[Any]    ,      UpperCAmelCase__       :      List[str]    )				->  Tuple:
        lowerCAmelCase     =			self.layers(UpperCAmelCase__    )
        return hidden_state




class 		UpperCAmelCase_      (  nn.Module		):





     def __init__( self       :      Any    ,      UpperCAmelCase__       :      RegNetConfig    )				->  Dict:
        super().__init__()
        lowerCAmelCase     =			nn.ModuleList([]    )
        # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input
        self.stages.append(
            RegNetStage(
                UpperCAmelCase__    ,      config.embedding_size    ,      config.hidden_sizes[0]    ,      stride=2 if config.downsample_in_first_stage else 1    ,      depth=config.depths[0]    ,      )    )
        lowerCAmelCase     =			zip(config.hidden_sizes    ,      config.hidden_sizes[1:]    )
        for (in_channels, out_channels), depth in zip(UpperCAmelCase__    ,      config.depths[1:]    ):
           self.stages.append(RegNetStage(UpperCAmelCase__    ,      UpperCAmelCase__    ,      UpperCAmelCase__    ,      depth=UpperCAmelCase__    )    )





     def 							__UpperCAmelCase      ( self       :      Union[str, Any]    ,      UpperCAmelCase__       :      Tensor    ,      UpperCAmelCase__       :      bool = False    ,      UpperCAmelCase__       :      bool = True    )				->  BaseModelOutputWithNoAttention:
        lowerCAmelCase     =			() if output_hidden_states else None

        for stage_module in self.stages:
           if output_hidden_states:
              lowerCAmelCase     =			hidden_states + (hidden_state,)

           lowerCAmelCase     =			stage_module(UpperCAmelCase__    )

        if output_hidden_states:
           lowerCAmelCase     =			hidden_states + (hidden_state,)

        if not return_dict:
           return tuple(v for v in [hidden_state, hidden_states] if v is not None    )

        return BaseModelOutputWithNoAttention(last_hidden_state=UpperCAmelCase__    ,      hidden_states=UpperCAmelCase__    )




class 		UpperCAmelCase_      (  __lowercase		):
     lowerCamelCase				:	List[Any]		=     RegNetConfig
     lowerCamelCase				:	Any		=     '''regnet'''
     lowerCamelCase				:	Any		=     '''pixel_values'''
     lowerCamelCase				:	Union[str, Any]		=     True





     def 							__UpperCAmelCase      ( self       :      List[str]    ,      UpperCAmelCase__       :      int    )				->  Optional[int]:
        if isinstance(UpperCAmelCase__    ,      nn.Convad    ):
           nn.init.kaiming_normal_(module.weight    ,      mode='fan_out'    ,      nonlinearity='relu'    )
        elif isinstance(UpperCAmelCase__    ,      (nn.BatchNormad, nn.GroupNorm)    ):
           nn.init.constant_(module.weight    ,      1    )
           nn.init.constant_(module.bias    ,      0    )





     def 							__UpperCAmelCase      ( self       :      str    ,      UpperCAmelCase__       :      Optional[int]    ,      UpperCAmelCase__       :      Tuple=False    )				->  Any:
        if isinstance(UpperCAmelCase__    ,      UpperCAmelCase__    ):
           lowerCAmelCase     =			value




__snake_case    						=R"""
    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it
    as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and
    behavior.

    Parameters:
        config ([`RegNetConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
"""

__snake_case    						=R"""
    Args:
        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`ConvNextImageProcessor.__call__`] for details.

        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
            more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple.
"""

@add_start_docstrings(
    '''The bare RegNet model outputting raw features without any specific head on top.'''       ,	__lowercase       ,	)
# Copied from transformers.models.resnet.modeling_resnet.ResNetModel with RESNET->REGNET,ResNet->RegNet
class 		UpperCAmelCase_      (  __lowercase		):





     def __init__( self       :      List[str]    ,      UpperCAmelCase__       :      Optional[int]    )				->  List[Any]:
        super().__init__(UpperCAmelCase__    )
        lowerCAmelCase     =			config
        lowerCAmelCase     =			RegNetEmbeddings(UpperCAmelCase__    )
        lowerCAmelCase     =			RegNetEncoder(UpperCAmelCase__    )
        lowerCAmelCase     =			nn.AdaptiveAvgPoolad((1, 1)    )
        # Initialize weights and apply final processing
        self.post_init()





     @add_start_docstrings_to_model_forward(UpperCAmelCase__    )
     @add_code_sample_docstrings(
         checkpoint=_CHECKPOINT_FOR_DOC    ,      output_type=UpperCAmelCase__    ,      config_class=_CONFIG_FOR_DOC    ,      modality='vision'    ,      expected_output=_EXPECTED_OUTPUT_SHAPE    ,      )
     def 							__UpperCAmelCase      ( self       :      Dict    ,      UpperCAmelCase__       :      Tensor    ,      UpperCAmelCase__       :      Optional[bool] = None    ,      UpperCAmelCase__       :      Optional[bool] = None    )				->  BaseModelOutputWithPoolingAndNoAttention:
        lowerCAmelCase     =			(
            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
        )
        lowerCAmelCase     =			return_dict if return_dict is not None else self.config.use_return_dict

        lowerCAmelCase     =			self.embedder(UpperCAmelCase__    )

        lowerCAmelCase     =			self.encoder(
            UpperCAmelCase__    ,      output_hidden_states=UpperCAmelCase__    ,      return_dict=UpperCAmelCase__    )

        lowerCAmelCase     =			encoder_outputs[0]

        lowerCAmelCase     =			self.pooler(UpperCAmelCase__    )

        if not return_dict:
           return (last_hidden_state, pooled_output) + encoder_outputs[1:]

        return BaseModelOutputWithPoolingAndNoAttention(
            last_hidden_state=UpperCAmelCase__    ,      pooler_output=UpperCAmelCase__    ,      hidden_states=encoder_outputs.hidden_states    ,      )




@add_start_docstrings(
    '''
    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    '''       ,	__lowercase       ,	)
# Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet
class 		UpperCAmelCase_      (  __lowercase		):





     def __init__( self       :      Optional[int]    ,      UpperCAmelCase__       :      Union[str, Any]    )				->  str:
        super().__init__(UpperCAmelCase__    )
        lowerCAmelCase     =			config.num_labels
        lowerCAmelCase     =			RegNetModel(UpperCAmelCase__    )
        # classification head
        lowerCAmelCase     =			nn.Sequential(
            nn.Flatten()    ,      nn.Linear(config.hidden_sizes[-1]    ,      config.num_labels    ) if config.num_labels > 0 else nn.Identity()    ,      )
        # initialize weights and apply final processing
        self.post_init()





     @add_start_docstrings_to_model_forward(UpperCAmelCase__    )
     @add_code_sample_docstrings(
         checkpoint=_IMAGE_CLASS_CHECKPOINT    ,      output_type=UpperCAmelCase__    ,      config_class=_CONFIG_FOR_DOC    ,      expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT    ,      )
     def 							__UpperCAmelCase      ( self       :      int    ,      UpperCAmelCase__       :      Optional[torch.FloatTensor] = None    ,      UpperCAmelCase__       :      Optional[torch.LongTensor] = None    ,      UpperCAmelCase__       :      Optional[bool] = None    ,      UpperCAmelCase__       :      Optional[bool] = None    ,      )				->  ImageClassifierOutputWithNoAttention:
        lowerCAmelCase     =			return_dict if return_dict is not None else self.config.use_return_dict

        lowerCAmelCase     =			self.regnet(UpperCAmelCase__    ,      output_hidden_states=UpperCAmelCase__    ,      return_dict=UpperCAmelCase__    )

        lowerCAmelCase     =			outputs.pooler_output if return_dict else outputs[1]

        lowerCAmelCase     =			self.classifier(UpperCAmelCase__    )

        lowerCAmelCase     =			None

        if labels is not None:
           if self.config.problem_type is None:
              if self.num_labels == 1:
                 lowerCAmelCase     =			'regression'
              elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
                 lowerCAmelCase     =			'single_label_classification'
              else:
                 lowerCAmelCase     =			'multi_label_classification'
           if self.config.problem_type == "regression":
              lowerCAmelCase     =			MSELoss()
              if self.num_labels == 1:
                 lowerCAmelCase     =			loss_fct(logits.squeeze()    ,      labels.squeeze()    )
              else:
                 lowerCAmelCase     =			loss_fct(UpperCAmelCase__    ,      UpperCAmelCase__    )
           elif self.config.problem_type == "single_label_classification":
              lowerCAmelCase     =			CrossEntropyLoss()
              lowerCAmelCase     =			loss_fct(logits.view(-1    ,      self.num_labels    )    ,      labels.view(-1    )    )
           elif self.config.problem_type == "multi_label_classification":
              lowerCAmelCase     =			BCEWithLogitsLoss()
              lowerCAmelCase     =			loss_fct(UpperCAmelCase__    ,      UpperCAmelCase__    )

        if not return_dict:
           lowerCAmelCase     =			(logits,) + outputs[2:]
           return (loss,) + output if loss is not None else output

        return ImageClassifierOutputWithNoAttention(loss=UpperCAmelCase__    ,      logits=UpperCAmelCase__    ,      hidden_states=outputs.hidden_states    )









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(						_a   ):
       def __init__(					self,      lowerCamelCase,      lowerCamelCase=13,      lowerCamelCase=7,      lowerCamelCase=True,      lowerCamelCase=True,      lowerCamelCase=False,      lowerCamelCase=True,      lowerCamelCase=99,      lowerCamelCase=32,      lowerCamelCase=5,      lowerCamelCase=4,      lowerCamelCase=64,      lowerCamelCase="gelu",      lowerCamelCase=0.1,      lowerCamelCase=0.1,      lowerCamelCase=5_12,      lowerCamelCase=16,      lowerCamelCase=2,      lowerCamelCase=0.0_2,      lowerCamelCase=3,      lowerCamelCase=4,      lowerCamelCase=None,      lowerCamelCase=2,      lowerCamelCase=2,      lowerCamelCase=2,      lowerCamelCase=2,      lowerCamelCase=4,      lowerCamelCase=1,      )       ->   Union[str, Any]:




           """simple docstring"""

           _lowercase       :							Dict      		=		parent
           _lowercase       :							Optional[Any]      		=		batch_size
           _lowercase       :							Any      		=		seq_length
           _lowercase       :							Optional[Any]      		=		is_training
           _lowercase       :							Optional[Any]      		=		use_input_mask
           _lowercase       :							List[Any]      		=		use_token_type_ids
           _lowercase       :							List[str]      		=		use_labels
           _lowercase       :							str      		=		vocab_size
           _lowercase       :							List[str]      		=		hidden_size
           _lowercase       :							Dict      		=		num_hidden_layers
           _lowercase       :							List[str]      		=		num_attention_heads
           _lowercase       :							int      		=		intermediate_size
           _lowercase       :							Union[str, Any]      		=		hidden_act
           _lowercase       :							int      		=		hidden_dropout_prob
           _lowercase       :							List[Any]      		=		attention_probs_dropout_prob
           _lowercase       :							Dict      		=		max_position_embeddings
           _lowercase       :							Union[str, Any]      		=		type_vocab_size
           _lowercase       :							List[Any]      		=		type_sequence_label_size
           _lowercase       :							Any      		=		initializer_range
           _lowercase       :							List[str]      		=		num_labels
           _lowercase       :							Any      		=		num_choices
           _lowercase       :							Tuple      		=		scope
           _lowercase       :							Optional[Any]      		=		q_groups
           _lowercase       :							List[str]      		=		k_groups
           _lowercase       :							Optional[int]      		=		v_groups
           _lowercase       :							List[str]      		=		post_attention_groups
           _lowercase       :							Union[str, Any]      		=		intermediate_groups
           _lowercase       :							int      		=		output_groups
       def 			UpperCamelCase     (					self)       ->   Optional[int]:




           """simple docstring"""

           _lowercase       :							int      		=		ids_tensor([self.batch_size, self.seq_length],      self.vocab_size)

           _lowercase       :							Any      		=		None
           if self.use_input_mask:
               _lowercase       :							Tuple      		=		random_attention_mask([self.batch_size, self.seq_length])

           _lowercase       :							Dict      		=		None
           _lowercase       :							int      		=		None
           _lowercase       :							List[Any]      		=		None
           if self.use_labels:
               _lowercase       :							List[Any]      		=		ids_tensor([self.batch_size],      self.type_sequence_label_size)
               _lowercase       :							int      		=		ids_tensor([self.batch_size, self.seq_length],      self.num_labels)
               _lowercase       :							Dict      		=		ids_tensor([self.batch_size],      self.num_choices)

           _lowercase       :							Optional[Any]      		=		self.get_config()

           return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels
       def 			UpperCamelCase     (					self)       ->   Optional[int]:




           """simple docstring"""

           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 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   Union[str, Any]:




           """simple docstring"""

           _lowercase       :							List[str]      		=		SqueezeBertModel(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase       :							Dict      		=		model(lowerCamelCase,      lowerCamelCase)
           _lowercase       :							Any      		=		model(lowerCamelCase)
           self.parent.assertEqual(result.last_hidden_state.shape,      (self.batch_size, self.seq_length, self.hidden_size))
       def 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   int:




           """simple docstring"""

           _lowercase       :							Dict      		=		SqueezeBertForMaskedLM(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase       :							Optional[Any]      		=		model(lowerCamelCase,      attention_mask=lowerCamelCase,      labels=lowerCamelCase)
           self.parent.assertEqual(result.logits.shape,      (self.batch_size, self.seq_length, self.vocab_size))
       def 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   Union[str, Any]:




           """simple docstring"""

           _lowercase       :							Union[str, Any]      		=		SqueezeBertForQuestionAnswering(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase       :							List[Any]      		=		model(
               lowerCamelCase,      attention_mask=lowerCamelCase,      start_positions=lowerCamelCase,      end_positions=lowerCamelCase)
           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,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   str:




           """simple docstring"""

           _lowercase       :							Optional[Any]      		=		self.num_labels
           _lowercase       :							int      		=		SqueezeBertForSequenceClassification(lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase       :							Any      		=		model(lowerCamelCase,      attention_mask=lowerCamelCase,      labels=lowerCamelCase)
           self.parent.assertEqual(result.logits.shape,      (self.batch_size, self.num_labels))
       def 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   List[Any]:




           """simple docstring"""

           _lowercase       :							Union[str, Any]      		=		self.num_labels
           _lowercase       :							List[str]      		=		SqueezeBertForTokenClassification(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()

           _lowercase       :							Union[str, Any]      		=		model(lowerCamelCase,      attention_mask=lowerCamelCase,      labels=lowerCamelCase)
           self.parent.assertEqual(result.logits.shape,      (self.batch_size, self.seq_length, self.num_labels))
       def 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   Dict:




           """simple docstring"""

           _lowercase       :							str      		=		self.num_choices
           _lowercase       :							str      		=		SqueezeBertForMultipleChoice(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase       :							Dict      		=		input_ids.unsqueeze(1).expand(-1,      self.num_choices,      -1).contiguous()
           _lowercase       :							int      		=		input_mask.unsqueeze(1).expand(-1,      self.num_choices,      -1).contiguous()
           _lowercase       :							Optional[Any]      		=		model(
               lowerCamelCase,      attention_mask=lowerCamelCase,      labels=lowerCamelCase,      )
           self.parent.assertEqual(result.logits.shape,      (self.batch_size, self.num_choices))




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




           """simple docstring"""

           _lowercase       :							Optional[int]      		=		self.prepare_config_and_inputs()
           ((_lowercase)		,				(_lowercase)		,				(_lowercase)		,				(_lowercase)		,				(_lowercase)		,				(_lowercase))       :							Dict      		=		config_and_inputs
           _lowercase       :							Tuple      		=		{'input_ids': input_ids, 'attention_mask': input_mask}
           return config, inputs_dict






@require_torch
class _lowerCamelCase(						_a, _a, unittest.TestCase   ):
       lowercase_ :	Union[str, Any]     =			(
           (
               SqueezeBertModel,
               SqueezeBertForMaskedLM,
               SqueezeBertForMultipleChoice,
               SqueezeBertForQuestionAnswering,
               SqueezeBertForSequenceClassification,
               SqueezeBertForTokenClassification,
           )
           if is_torch_available()
           else None
       )
       lowercase_ :	Optional[int]     =			(
           {
               """feature-extraction""": SqueezeBertModel,
               """fill-mask""": SqueezeBertForMaskedLM,
               """question-answering""": SqueezeBertForQuestionAnswering,
               """text-classification""": SqueezeBertForSequenceClassification,
               """token-classification""": SqueezeBertForTokenClassification,
               """zero-shot""": SqueezeBertForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       lowercase_ :	Tuple     =			False
       lowercase_ :	List[str]     =			True
       lowercase_ :	int     =			False
       def 			UpperCamelCase     (					self)       ->   int:




           """simple docstring"""

           _lowercase       :							str      		=		SqueezeBertModelTester(self)
           _lowercase       :							Dict      		=		ConfigTester(self,      config_class=lowerCamelCase,      dim=37)
       def 			UpperCamelCase     (					self)       ->   List[str]:




           """simple docstring"""

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




           """simple docstring"""

           _lowercase       :							Optional[Any]      		=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_squeezebert_model(*lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   List[str]:




           """simple docstring"""

           _lowercase       :							Any      		=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_squeezebert_for_masked_lm(*lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   Any:




           """simple docstring"""

           _lowercase       :							List[Any]      		=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_squeezebert_for_question_answering(*lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   Union[str, Any]:




           """simple docstring"""

           _lowercase       :							Union[str, Any]      		=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_squeezebert_for_sequence_classification(*lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   Any:




           """simple docstring"""

           _lowercase       :							List[Any]      		=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_squeezebert_for_token_classification(*lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   Optional[int]:




           """simple docstring"""

           _lowercase       :							Optional[Any]      		=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_squeezebert_for_multiple_choice(*lowerCamelCase)




       @slow
       def 			UpperCamelCase     (					self)       ->   Dict:




           """simple docstring"""

           for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _lowercase       :							List[Any]      		=		SqueezeBertModel.from_pretrained(lowerCamelCase)
               self.assertIsNotNone(lowerCamelCase)






@require_sentencepiece
@require_tokenizers
@require_torch
class _lowerCamelCase(						unittest.TestCase   ):
       @slow
       def 			UpperCamelCase     (					self)       ->   Optional[Any]:




           """simple docstring"""

           _lowercase       :							Union[str, Any]      		=		SqueezeBertForSequenceClassification.from_pretrained('squeezebert/squeezebert-mnli')

           _lowercase       :							Optional[int]      		=		torch.tensor([[1, 2_94_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 13, 15_88, 2]])
           _lowercase       :							List[str]      		=		model(lowerCamelCase)[0]
           _lowercase       :							Union[str, Any]      		=		torch.Size((1, 3))
           self.assertEqual(output.shape,      lowerCamelCase)
           _lowercase       :							Tuple      		=		torch.tensor([[0.6_4_0_1, -0.0_3_4_9, -0.6_0_4_1]])
           self.assertTrue(torch.allclose(lowerCamelCase,      lowerCamelCase,      atol=1E-4))


