





import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


_UpperCAmelCase							:			str        =							logging.get_logger(__name__)

_UpperCAmelCase							:			Union[str, Any]        =							{
    """microsoft/wavlm-base""": """https://huggingface.co/microsoft/wavlm-base/resolve/main/config.json""",
    # See all WavLM models at https://huggingface.co/models?filter=wavlm
}

class   lowerCAmelCase				(   __UpperCamelCase     ):
 UpperCAmelCase__						=						"""wavlm"""
 def __init__( self    : Optional[int]     ,	UpperCAmelCase    : int=32     ,	UpperCAmelCase    : List[str]=768     ,	UpperCAmelCase    : List[str]=12     ,	UpperCAmelCase    : Optional[Any]=12     ,	UpperCAmelCase    : Dict=3072     ,	UpperCAmelCase    : int="gelu"     ,	UpperCAmelCase    : Optional[int]=0.1     ,	UpperCAmelCase    : Union[str, Any]=0.1     ,	UpperCAmelCase    : Union[str, Any]=0.1     ,	UpperCAmelCase    : str=0.0     ,	UpperCAmelCase    : Any=0.1     ,	UpperCAmelCase    : Optional[int]=0.1     ,	UpperCAmelCase    : Union[str, Any]=0.0_2     ,	UpperCAmelCase    : Optional[Any]=1e-5     ,	UpperCAmelCase    : List[str]="group"     ,	UpperCAmelCase    : List[str]="gelu"     ,	UpperCAmelCase    : str=(512, 512, 512, 512, 512, 512, 512)     ,	UpperCAmelCase    : Optional[int]=(5, 2, 2, 2, 2, 2, 2)     ,	UpperCAmelCase    : Optional[Any]=(10, 3, 3, 3, 3, 2, 2)     ,	UpperCAmelCase    : Tuple=False     ,	UpperCAmelCase    : Optional[int]=128     ,	UpperCAmelCase    : Dict=16     ,	UpperCAmelCase    : Optional[int]=320     ,	UpperCAmelCase    : Tuple=800     ,	UpperCAmelCase    : Optional[Any]=False     ,	UpperCAmelCase    : int=True     ,	UpperCAmelCase    : Dict=0.0_5     ,	UpperCAmelCase    : Union[str, Any]=10     ,	UpperCAmelCase    : Any=2     ,	UpperCAmelCase    : Dict=0.0     ,	UpperCAmelCase    : Any=10     ,	UpperCAmelCase    : Dict=320     ,	UpperCAmelCase    : Dict=2     ,	UpperCAmelCase    : List[Any]=0.1     ,	UpperCAmelCase    : List[Any]=100     ,	UpperCAmelCase    : Tuple=256     ,	UpperCAmelCase    : Tuple=256     ,	UpperCAmelCase    : Union[str, Any]=0.1     ,	UpperCAmelCase    : Any="mean"     ,	UpperCAmelCase    : int=False     ,	UpperCAmelCase    : Union[str, Any]=False     ,	UpperCAmelCase    : Optional[int]=256     ,	UpperCAmelCase    : Dict=(512, 512, 512, 512, 1500)     ,	UpperCAmelCase    : List[str]=(5, 3, 3, 1, 1)     ,	UpperCAmelCase    : str=(1, 2, 3, 1, 1)     ,	UpperCAmelCase    : Union[str, Any]=512     ,	UpperCAmelCase    : Union[str, Any]=80     ,	UpperCAmelCase    : Dict=0     ,	UpperCAmelCase    : List[Any]=1     ,	UpperCAmelCase    : Tuple=2     ,	UpperCAmelCase    : Union[str, Any]=False     ,	UpperCAmelCase    : Optional[Any]=3     ,	UpperCAmelCase    : Any=2     ,	UpperCAmelCase    : List[Any]=3     ,	UpperCAmelCase    : List[Any]=None     ,	**UpperCAmelCase    : Optional[int]     ,	)     ->      str:
     super().__init__(**UpperCAmelCase     ,	pad_token_id=UpperCAmelCase     ,	bos_token_id=UpperCAmelCase     ,	eos_token_id=UpperCAmelCase      )
     lowerCamelCase__       : str   					=						hidden_size
     lowerCamelCase__       : Dict   					=						feat_extract_norm
     lowerCamelCase__       : List[Any]   					=						feat_extract_activation
     lowerCamelCase__       : Dict   					=						list(UpperCAmelCase      )
     lowerCamelCase__       : List[str]   					=						list(UpperCAmelCase      )
     lowerCamelCase__       : Union[str, Any]   					=						list(UpperCAmelCase      )
     lowerCamelCase__       : List[str]   					=						conv_bias
     lowerCamelCase__       : Union[str, Any]   					=						num_buckets
     lowerCamelCase__       : List[Any]   					=						max_bucket_distance
     lowerCamelCase__       : Tuple   					=						num_conv_pos_embeddings
     lowerCamelCase__       : Optional[int]   					=						num_conv_pos_embedding_groups
     lowerCamelCase__       : Optional[int]   					=						len(self.conv_dim      )
     lowerCamelCase__       : List[str]   					=						num_hidden_layers
     lowerCamelCase__       : Optional[int]   					=						intermediate_size
     lowerCamelCase__       : Tuple   					=						hidden_act
     lowerCamelCase__       : Optional[Any]   					=						num_attention_heads
     lowerCamelCase__       : Dict   					=						hidden_dropout
     lowerCamelCase__       : List[Any]   					=						attention_dropout
     lowerCamelCase__       : Dict   					=						activation_dropout
     lowerCamelCase__       : Optional[Any]   					=						feat_proj_dropout
     lowerCamelCase__       : List[Any]   					=						final_dropout
     lowerCamelCase__       : List[str]   					=						layerdrop
     lowerCamelCase__       : str   					=						layer_norm_eps
     lowerCamelCase__       : Dict   					=						initializer_range
     lowerCamelCase__       : List[str]   					=						num_ctc_classes
     lowerCamelCase__       : Dict   					=						vocab_size
     lowerCamelCase__       : List[str]   					=						do_stable_layer_norm
     lowerCamelCase__       : Optional[Any]   					=						use_weighted_layer_sum
     lowerCamelCase__       : Tuple   					=						classifier_proj_size

     if (
         (len(self.conv_stride      ) != self.num_feat_extract_layers)
         or (len(self.conv_kernel      ) != self.num_feat_extract_layers)
         or (len(self.conv_dim      ) != self.num_feat_extract_layers)
     ):
         raise ValueError(
             'Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =='
             ' `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ='
             F""" {len(self.conv_dim      )}`, `len(config.conv_stride) = {len(self.conv_stride      )}`,"""
             F""" `len(config.conv_kernel) = {len(self.conv_kernel      )}`."""      )

     # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
     lowerCamelCase__       : Dict   					=						apply_spec_augment
     lowerCamelCase__       : Dict   					=						mask_time_prob
     lowerCamelCase__       : Dict   					=						mask_time_length
     lowerCamelCase__       : Optional[int]   					=						mask_time_min_masks
     lowerCamelCase__       : int   					=						mask_feature_prob
     lowerCamelCase__       : List[Any]   					=						mask_feature_length

     # parameters for pretraining with codevector quantized representations
     lowerCamelCase__       : Optional[int]   					=						num_codevectors_per_group
     lowerCamelCase__       : List[Any]   					=						num_codevector_groups
     lowerCamelCase__       : Optional[Any]   					=						contrastive_logits_temperature
     lowerCamelCase__       : Optional[Any]   					=						num_negatives
     lowerCamelCase__       : Union[str, Any]   					=						codevector_dim
     lowerCamelCase__       : Optional[int]   					=						proj_codevector_dim
     lowerCamelCase__       : Tuple   					=						diversity_loss_weight

     # ctc loss
     lowerCamelCase__       : Union[str, Any]   					=						ctc_loss_reduction
     lowerCamelCase__       : Optional[Any]   					=						ctc_zero_infinity

     # adapter
     lowerCamelCase__       : List[str]   					=						add_adapter
     lowerCamelCase__       : List[Any]   					=						adapter_kernel_size
     lowerCamelCase__       : Tuple   					=						adapter_stride
     lowerCamelCase__       : str   					=						num_adapter_layers
     lowerCamelCase__       : Any   					=						output_hidden_size or hidden_size

     # SequenceClassification-specific parameter. Feel free to ignore for other classes.
     lowerCamelCase__       : Optional[int]   					=						classifier_proj_size

     # XVector-specific parameters. Feel free to ignore for other classes.
     lowerCamelCase__       : List[Any]   					=						list(UpperCAmelCase      )
     lowerCamelCase__       : List[Any]   					=						list(UpperCAmelCase      )
     lowerCamelCase__       : Union[str, Any]   					=						list(UpperCAmelCase      )
     lowerCamelCase__       : List[str]   					=						xvector_output_dim







 @property
 def 	A_      ( self    : Union[str, Any]      )     ->      Any:
     return functools.reduce(operator.mul     ,	self.conv_stride     ,	1      )












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				(   __UpperCamelCase     ):
 def __init__( self    : str     ,	UpperCAmelCase    : Dict     ,	UpperCAmelCase    : Dict=13     ,	UpperCAmelCase    : List[Any]=7     ,	UpperCAmelCase    : Tuple=True     ,	UpperCAmelCase    : str=True     ,	UpperCAmelCase    : int=False     ,	UpperCAmelCase    : Optional[Any]=True     ,	UpperCAmelCase    : int=99     ,	UpperCAmelCase    : Dict=32     ,	UpperCAmelCase    : Dict=5     ,	UpperCAmelCase    : List[str]=4     ,	UpperCAmelCase    : Optional[Any]=64     ,	UpperCAmelCase    : Any="gelu"     ,	UpperCAmelCase    : List[str]=0.1     ,	UpperCAmelCase    : Optional[Any]=0.1     ,	UpperCAmelCase    : Any=512     ,	UpperCAmelCase    : List[str]=16     ,	UpperCAmelCase    : Union[str, Any]=2     ,	UpperCAmelCase    : Union[str, Any]=0.0_2     ,	UpperCAmelCase    : Dict=3     ,	UpperCAmelCase    : List[Any]=4     ,	UpperCAmelCase    : int=None     ,	UpperCAmelCase    : Optional[int]=2     ,	UpperCAmelCase    : Tuple=2     ,	UpperCAmelCase    : Optional[Any]=2     ,	UpperCAmelCase    : Tuple=2     ,	UpperCAmelCase    : List[str]=4     ,	UpperCAmelCase    : Dict=1     ,	)     ->      List[Any]:
     lowerCamelCase__       : Any   					=						parent
     lowerCamelCase__       : Tuple   					=						batch_size
     lowerCamelCase__       : Union[str, Any]   					=						seq_length
     lowerCamelCase__       : Optional[Any]   					=						is_training
     lowerCamelCase__       : Optional[Any]   					=						use_input_mask
     lowerCamelCase__       : List[Any]   					=						use_token_type_ids
     lowerCamelCase__       : str   					=						use_labels
     lowerCamelCase__       : Any   					=						vocab_size
     lowerCamelCase__       : Any   					=						hidden_size
     lowerCamelCase__       : int   					=						num_hidden_layers
     lowerCamelCase__       : Optional[Any]   					=						num_attention_heads
     lowerCamelCase__       : Optional[int]   					=						intermediate_size
     lowerCamelCase__       : int   					=						hidden_act
     lowerCamelCase__       : List[Any]   					=						hidden_dropout_prob
     lowerCamelCase__       : List[str]   					=						attention_probs_dropout_prob
     lowerCamelCase__       : Any   					=						max_position_embeddings
     lowerCamelCase__       : Dict   					=						type_vocab_size
     lowerCamelCase__       : Optional[int]   					=						type_sequence_label_size
     lowerCamelCase__       : Any   					=						initializer_range
     lowerCamelCase__       : int   					=						num_labels
     lowerCamelCase__       : Tuple   					=						num_choices
     lowerCamelCase__       : Optional[Any]   					=						scope
     lowerCamelCase__       : Dict   					=						q_groups
     lowerCamelCase__       : Optional[Any]   					=						k_groups
     lowerCamelCase__       : Any   					=						v_groups
     lowerCamelCase__       : List[str]   					=						post_attention_groups
     lowerCamelCase__       : Dict   					=						intermediate_groups
     lowerCamelCase__       : Optional[int]   					=						output_groups
 def 	A_      ( self    : str      )     ->      str:
     lowerCamelCase__       : List[Any]   					=						ids_tensor([self.batch_size, self.seq_length]     ,	self.vocab_size      )

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

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

     lowerCamelCase__       : int   					=						self.get_config()

     return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels
 def 	A_      ( self    : Union[str, Any]      )     ->      List[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 	A_      ( self    : List[Any]     ,	UpperCAmelCase    : Optional[Any]     ,	UpperCAmelCase    : str     ,	UpperCAmelCase    : Dict     ,	UpperCAmelCase    : Any     ,	UpperCAmelCase    : Optional[Any]     ,	UpperCAmelCase    : List[str]      )     ->      List[str]:
     lowerCamelCase__       : List[Any]   					=						SqueezeBertModel(config=UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()
     lowerCamelCase__       : Optional[Any]   					=						model(UpperCAmelCase     ,	UpperCAmelCase      )
     lowerCamelCase__       : Union[str, Any]   					=						model(UpperCAmelCase      )
     self.parent.assertEqual(result.last_hidden_state.shape     ,	(self.batch_size, self.seq_length, self.hidden_size)      )
 def 	A_      ( self    : List[str]     ,	UpperCAmelCase    : Optional[Any]     ,	UpperCAmelCase    : Tuple     ,	UpperCAmelCase    : List[str]     ,	UpperCAmelCase    : List[str]     ,	UpperCAmelCase    : Union[str, Any]     ,	UpperCAmelCase    : List[Any]      )     ->      Optional[Any]:
     lowerCamelCase__       : List[Any]   					=						SqueezeBertForMaskedLM(config=UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()
     lowerCamelCase__       : Union[str, Any]   					=						model(UpperCAmelCase     ,	attention_mask=UpperCAmelCase     ,	labels=UpperCAmelCase      )
     self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.seq_length, self.vocab_size)      )
 def 	A_      ( self    : int     ,	UpperCAmelCase    : Optional[int]     ,	UpperCAmelCase    : List[str]     ,	UpperCAmelCase    : int     ,	UpperCAmelCase    : List[Any]     ,	UpperCAmelCase    : Union[str, Any]     ,	UpperCAmelCase    : List[str]      )     ->      Optional[Any]:
     lowerCamelCase__       : Union[str, Any]   					=						SqueezeBertForQuestionAnswering(config=UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()
     lowerCamelCase__       : List[Any]   					=						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 	A_      ( self    : Tuple     ,	UpperCAmelCase    : str     ,	UpperCAmelCase    : Optional[int]     ,	UpperCAmelCase    : Dict     ,	UpperCAmelCase    : Optional[Any]     ,	UpperCAmelCase    : Any     ,	UpperCAmelCase    : Any      )     ->      Any:
     lowerCamelCase__       : int   					=						self.num_labels
     lowerCamelCase__       : Optional[int]   					=						SqueezeBertForSequenceClassification(UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()
     lowerCamelCase__       : Union[str, Any]   					=						model(UpperCAmelCase     ,	attention_mask=UpperCAmelCase     ,	labels=UpperCAmelCase      )
     self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.num_labels)      )
 def 	A_      ( self    : int     ,	UpperCAmelCase    : Any     ,	UpperCAmelCase    : Tuple     ,	UpperCAmelCase    : Any     ,	UpperCAmelCase    : List[str]     ,	UpperCAmelCase    : List[Any]     ,	UpperCAmelCase    : Optional[Any]      )     ->      List[str]:
     lowerCamelCase__       : str   					=						self.num_labels
     lowerCamelCase__       : int   					=						SqueezeBertForTokenClassification(config=UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()

     lowerCamelCase__       : List[Any]   					=						model(UpperCAmelCase     ,	attention_mask=UpperCAmelCase     ,	labels=UpperCAmelCase      )
     self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.seq_length, self.num_labels)      )
 def 	A_      ( self    : Optional[int]     ,	UpperCAmelCase    : int     ,	UpperCAmelCase    : Dict     ,	UpperCAmelCase    : Dict     ,	UpperCAmelCase    : List[Any]     ,	UpperCAmelCase    : str     ,	UpperCAmelCase    : int      )     ->      Tuple:
     lowerCamelCase__       : Optional[int]   					=						self.num_choices
     lowerCamelCase__       : List[str]   					=						SqueezeBertForMultipleChoice(config=UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()
     lowerCamelCase__       : Dict   					=						input_ids.unsqueeze(1      ).expand(-1     ,	self.num_choices     ,	-1      ).contiguous()
     lowerCamelCase__       : List[str]   					=						input_mask.unsqueeze(1      ).expand(-1     ,	self.num_choices     ,	-1      ).contiguous()
     lowerCamelCase__       : str   					=						model(
         UpperCAmelCase     ,	attention_mask=UpperCAmelCase     ,	labels=UpperCAmelCase     ,	)
     self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.num_choices)      )







 def 	A_      ( self    : Optional[Any]      )     ->      Optional[int]:
     lowerCamelCase__       : Optional[Any]   					=						self.prepare_config_and_inputs()
     ((lowerCamelCase__)					,				(lowerCamelCase__)					,				(lowerCamelCase__)					,				(lowerCamelCase__)					,				(lowerCamelCase__)					,				(lowerCamelCase__))       : Tuple   					=						config_and_inputs
     lowerCamelCase__       : Optional[Any]   					=						{'input_ids': input_ids, 'attention_mask': input_mask}
     return config, inputs_dict


@require_torch
class   lowerCAmelCase				(   __UpperCamelCase,    __UpperCamelCase,    unittest.TestCase     ):
 UpperCAmelCase__						=						(
     (
         SqueezeBertModel,
         SqueezeBertForMaskedLM,
         SqueezeBertForMultipleChoice,
         SqueezeBertForQuestionAnswering,
         SqueezeBertForSequenceClassification,
         SqueezeBertForTokenClassification,
     )
     if is_torch_available()
     else None
 )
 UpperCAmelCase__						=						(
     {
         """feature-extraction""": SqueezeBertModel,
         """fill-mask""": SqueezeBertForMaskedLM,
         """question-answering""": SqueezeBertForQuestionAnswering,
         """text-classification""": SqueezeBertForSequenceClassification,
         """token-classification""": SqueezeBertForTokenClassification,
         """zero-shot""": SqueezeBertForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 UpperCAmelCase__						=						False
 UpperCAmelCase__						=						True
 UpperCAmelCase__						=						False
 def 	A_      ( self    : Union[str, Any]      )     ->      Dict:
     lowerCamelCase__       : Optional[Any]   					=						SqueezeBertModelTester(self      )
     lowerCamelCase__       : Optional[Any]   					=						ConfigTester(self     ,	config_class=UpperCAmelCase     ,	dim=37      )
 def 	A_      ( self    : str      )     ->      str:
     self.config_tester.run_common_tests()
 def 	A_      ( self    : str      )     ->      int:
     lowerCamelCase__       : List[str]   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_model(*UpperCAmelCase      )
 def 	A_      ( self    : Union[str, Any]      )     ->      Tuple:
     lowerCamelCase__       : int   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_masked_lm(*UpperCAmelCase      )
 def 	A_      ( self    : Union[str, Any]      )     ->      Any:
     lowerCamelCase__       : List[str]   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_question_answering(*UpperCAmelCase      )
 def 	A_      ( self    : Union[str, Any]      )     ->      List[str]:
     lowerCamelCase__       : Optional[Any]   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_sequence_classification(*UpperCAmelCase      )
 def 	A_      ( self    : Optional[int]      )     ->      Optional[Any]:
     lowerCamelCase__       : Tuple   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_token_classification(*UpperCAmelCase      )
 def 	A_      ( self    : Any      )     ->      Optional[Any]:
     lowerCamelCase__       : List[str]   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_multiple_choice(*UpperCAmelCase      )







 @slow
 def 	A_      ( self    : Optional[int]      )     ->      Dict:
     for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         lowerCamelCase__       : Any   					=						SqueezeBertModel.from_pretrained(UpperCAmelCase      )
         self.assertIsNotNone(UpperCAmelCase      )


@require_sentencepiece
@require_tokenizers
@require_torch
class   lowerCAmelCase				(   unittest.TestCase     ):
 @slow
 def 	A_      ( self    : Optional[Any]      )     ->      List[str]:
     lowerCamelCase__       : Dict   					=						SqueezeBertForSequenceClassification.from_pretrained('squeezebert/squeezebert-mnli'      )

     lowerCamelCase__       : Optional[int]   					=						torch.tensor([[1, 29414, 232, 328, 740, 1140, 12695, 69, 13, 1588, 2]]      )
     lowerCamelCase__       : Optional[int]   					=						model(UpperCAmelCase      )[0]
     lowerCamelCase__       : Dict   					=						torch.Size((1, 3)      )
     self.assertEqual(output.shape     ,	UpperCAmelCase      )
     lowerCamelCase__       : List[str]   					=						torch.tensor([[0.6_4_0_1, -0.0_3_4_9, -0.6_0_4_1]]      )
     self.assertTrue(torch.allclose(UpperCAmelCase     ,	UpperCAmelCase     ,	atol=1e-4      )      )





