

import argparse
from pathlib import Path

import fairseq
import torch
from fairseq.models.xmod import XMODModel as FairseqXmodModel
from packaging import version

from transformers import XmodConfig, XmodForMaskedLM, XmodForSequenceClassification
from transformers.utils import logging


if version.parse(fairseq.__version__) < version.parse('0.12.2'):
  raise Exception('requires fairseq >= 0.12.2')
if version.parse(fairseq.__version__) > version.parse('2'):
  raise Exception('requires fairseq < v2')

logging.set_verbosity_info()
__UpperCAmelCase    				=     logging.get_logger(__name__)

__UpperCAmelCase    				=     'Hello, World!'
__UpperCAmelCase    				=     'en_XX'







def 	_snake_case		(    SCREAMING_SNAKE_CASE		,							SCREAMING_SNAKE_CASE		,							SCREAMING_SNAKE_CASE				)       ->      int:

     """simple docstring"""







     _lowerCAmelCase   :					List[str]        =    Path("data_bin"				)
     _lowerCAmelCase   :					Tuple        =    FairseqXmodModel.from_pretrained(
         model_name_or_path=str(Path(SCREAMING_SNAKE_CASE				).parent				)		,							checkpoint_file=Path(SCREAMING_SNAKE_CASE				).name		,							_name="xmod_base"		,							arch="xmod_base"		,							task="multilingual_masked_lm"		,							data_name_or_path=str(SCREAMING_SNAKE_CASE				)		,							bpe="sentencepiece"		,							sentencepiece_model=str(Path(SCREAMING_SNAKE_CASE				).parent / "sentencepiece.bpe.model"				)		,							src_dict=str(data_dir / "dict.txt"				)		,							)
     xmod.eval()  # disable dropout
     print(SCREAMING_SNAKE_CASE				)

     _lowerCAmelCase   :					int        =    xmod.model.encoder.sentence_encoder
     _lowerCAmelCase   :					List[Any]        =    XmodConfig(
         vocab_size=xmod_sent_encoder.embed_tokens.num_embeddings		,							hidden_size=xmod.cfg.model.encoder_embed_dim		,							num_hidden_layers=xmod.cfg.model.encoder_layers		,							num_attention_heads=xmod.cfg.model.encoder_attention_heads		,							intermediate_size=xmod.cfg.model.encoder_ffn_embed_dim		,							max_position_embeddings=514		,							type_vocab_size=1		,							layer_norm_eps=1e-5		,							pre_norm=xmod.cfg.model.encoder_normalize_before		,							adapter_reduction_factor=getattr(xmod.cfg.model		,							"bottleneck"		,							2				)		,							adapter_layer_norm=xmod.cfg.model.adapter_layer_norm		,							adapter_reuse_layer_norm=xmod.cfg.model.adapter_reuse_layer_norm		,							ln_before_adapter=xmod.cfg.model.ln_before_adapter		,							languages=xmod.cfg.model.languages		,							)
     if classification_head:
          _lowerCAmelCase   :					Dict        =    xmod.model.classification_heads["mnli"].out_proj.weight.shape[0]

     print("Our X-MOD config:"		,							SCREAMING_SNAKE_CASE				)

     _lowerCAmelCase   :					Any        =    XmodForSequenceClassification(SCREAMING_SNAKE_CASE				) if classification_head else XmodForMaskedLM(SCREAMING_SNAKE_CASE				)
     model.eval()

     # Now let's copy all the weights.
     # Embeddings
     _lowerCAmelCase   :					Optional[int]        =    xmod_sent_encoder.embed_tokens.weight
     _lowerCAmelCase   :					Optional[int]        =    xmod_sent_encoder.embed_positions.weight
     _lowerCAmelCase   :					Union[str, Any]        =    torch.zeros_like(
         model.roberta.embeddings.token_type_embeddings.weight				)  # just zero them out b/c xmod doesn't use them.

     _lowerCAmelCase   :					int        =    xmod_sent_encoder.layernorm_embedding.weight
     _lowerCAmelCase   :					List[Any]        =    xmod_sent_encoder.layernorm_embedding.bias

     for i in range(config.num_hidden_layers				):
          # Encoder: start of layer
          _lowerCAmelCase   :					Optional[int]        =    model.roberta.encoder.layer[i]
          _lowerCAmelCase   :					List[str]        =    xmod_sent_encoder.layers[i]

          # self attention
          _lowerCAmelCase   :					Optional[Any]        =    layer.attention.self
          if not (
              xmod_layer.self_attn.k_proj.weight.data.shape
              == xmod_layer.self_attn.q_proj.weight.data.shape
              == xmod_layer.self_attn.v_proj.weight.data.shape
              == torch.Size((config.hidden_size, config.hidden_size)				)
          ):
               raise AssertionError("Dimensions of self-attention weights do not match."				)

          _lowerCAmelCase   :					List[Any]        =    xmod_layer.self_attn.q_proj.weight
          _lowerCAmelCase   :					str        =    xmod_layer.self_attn.q_proj.bias
          _lowerCAmelCase   :					Tuple        =    xmod_layer.self_attn.k_proj.weight
          _lowerCAmelCase   :					List[Any]        =    xmod_layer.self_attn.k_proj.bias
          _lowerCAmelCase   :					Any        =    xmod_layer.self_attn.v_proj.weight
          _lowerCAmelCase   :					List[str]        =    xmod_layer.self_attn.v_proj.bias

          # self-attention output
          _lowerCAmelCase   :					int        =    layer.attention.output
          if self_output.dense.weight.shape != xmod_layer.self_attn.out_proj.weight.shape:
               raise AssertionError("Dimensions of self-attention output weights do not match."				)
          _lowerCAmelCase   :					Tuple        =    xmod_layer.self_attn.out_proj.weight
          _lowerCAmelCase   :					Dict        =    xmod_layer.self_attn.out_proj.bias
          _lowerCAmelCase   :					List[str]        =    xmod_layer.self_attn_layer_norm.weight
          _lowerCAmelCase   :					List[str]        =    xmod_layer.self_attn_layer_norm.bias

          # intermediate
          _lowerCAmelCase   :					Tuple        =    layer.intermediate
          if intermediate.dense.weight.shape != xmod_layer.fca.weight.shape:
               raise AssertionError("Dimensions of intermediate weights do not match."				)
          _lowerCAmelCase   :					List[Any]        =    xmod_layer.fca.weight
          _lowerCAmelCase   :					str        =    xmod_layer.fca.bias

          # output
          _lowerCAmelCase   :					List[str]        =    layer.output
          if bert_output.dense.weight.shape != xmod_layer.fca.weight.shape:
               raise AssertionError("Dimensions of feed-forward weights do not match."				)
          _lowerCAmelCase   :					Optional[Any]        =    xmod_layer.fca.weight
          _lowerCAmelCase   :					str        =    xmod_layer.fca.bias
          _lowerCAmelCase   :					Optional[Any]        =    xmod_layer.final_layer_norm.weight
          _lowerCAmelCase   :					int        =    xmod_layer.final_layer_norm.bias
          if bert_output.adapter_layer_norm is not None:
               _lowerCAmelCase   :					str        =    xmod_layer.adapter_layer_norm.weight
               _lowerCAmelCase   :					Any        =    xmod_layer.adapter_layer_norm.bias

          if sorted(bert_output.adapter_modules.keys()				) != sorted(xmod_layer.adapter_modules.keys()				):
               raise AssertionError("Lists of language adapters do not match."				)
          for lang_code, adapter in xmod_layer.adapter_modules.items():
               _lowerCAmelCase   :					Optional[int]        =    bert_output.adapter_modules[lang_code]
               _lowerCAmelCase   :					List[str]        =    xmod_layer.adapter_modules[lang_code]
               _lowerCAmelCase   :					Optional[Any]        =    from_adapter.fca.weight
               _lowerCAmelCase   :					Optional[int]        =    from_adapter.fca.bias
               _lowerCAmelCase   :					Union[str, Any]        =    from_adapter.fca.weight
               _lowerCAmelCase   :					Union[str, Any]        =    from_adapter.fca.bias

          # end of layer

     if xmod_sent_encoder.layer_norm is not None:
          _lowerCAmelCase   :					Dict        =    xmod_sent_encoder.layer_norm.weight
          _lowerCAmelCase   :					Optional[int]        =    xmod_sent_encoder.layer_norm.bias

     if classification_head:
          _lowerCAmelCase   :					List[Any]        =    xmod.model.classification_heads["mnli"].dense.weight
          _lowerCAmelCase   :					Optional[int]        =    xmod.model.classification_heads["mnli"].dense.bias
          _lowerCAmelCase   :					str        =    xmod.model.classification_heads["mnli"].out_proj.weight
          _lowerCAmelCase   :					Dict        =    xmod.model.classification_heads["mnli"].out_proj.bias
     else:
          # LM Head
          _lowerCAmelCase   :					int        =    xmod.model.encoder.lm_head.dense.weight
          _lowerCAmelCase   :					Optional[Any]        =    xmod.model.encoder.lm_head.dense.bias
          _lowerCAmelCase   :					Union[str, Any]        =    xmod.model.encoder.lm_head.layer_norm.weight
          _lowerCAmelCase   :					List[Any]        =    xmod.model.encoder.lm_head.layer_norm.bias
          _lowerCAmelCase   :					List[str]        =    xmod.model.encoder.lm_head.weight
          _lowerCAmelCase   :					Dict        =    xmod.model.encoder.lm_head.bias

     # Let's check that we get the same results.
     _lowerCAmelCase   :					List[str]        =    xmod.encode(SCREAMING_SNAKE_CASE				).unsqueeze(0				)  # batch of size 1
     model.roberta.set_default_language(SCREAMING_SNAKE_CASE				)

     _lowerCAmelCase   :					List[Any]        =    model(SCREAMING_SNAKE_CASE				)[0]
     if classification_head:
          _lowerCAmelCase   :					Any        =    xmod.model.classification_heads["mnli"](xmod.extract_features(SCREAMING_SNAKE_CASE				)				)
     else:
          _lowerCAmelCase   :					Any        =    xmod.model(SCREAMING_SNAKE_CASE		,							lang_id=[SAMPLE_LANGUAGE]				)[0]
     print(our_output.shape		,							their_output.shape				)
     _lowerCAmelCase   :					int        =    torch.max(torch.abs(our_output - their_output				)				).item()
     print(f'''max_absolute_diff = {max_absolute_diff}'''				)  # ~ 1e-7
     _lowerCAmelCase   :					Dict        =    torch.allclose(SCREAMING_SNAKE_CASE		,							SCREAMING_SNAKE_CASE		,							atol=1e-3				)
     print("Do both models output the same tensors?"		,							"🔥" if success else "💩"				)
     if not success:
          raise Exception("Something went wRoNg"				)

     Path(SCREAMING_SNAKE_CASE				).mkdir(parents=SCREAMING_SNAKE_CASE		,							exist_ok=SCREAMING_SNAKE_CASE				)
     print(f'''Saving model to {pytorch_dump_folder_path}'''				)
     model.save_pretrained(SCREAMING_SNAKE_CASE				)


if __name__ == "__main__":
  __UpperCAmelCase    				=     argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      '--xmod_checkpoint_path', default=None, type=str, required=True, help='Path the official PyTorch dump.'
  )
  parser.add_argument(
      '--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
  )
  parser.add_argument(
      '--classification_head', action='store_true', help='Whether to convert a final classification head.'
  )
  __UpperCAmelCase    				=     parser.parse_args()
  convert_xmod_checkpoint_to_pytorch(
      args.xmod_checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
  )









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 A__    ( A ):



 """simple docstring"""







 def __init__(		self :	Tuple     ,						A_ :	Optional[Any]     ,						A_ :	Dict=1_3     ,						A_ :	str=7     ,						A_ :	Union[str, Any]=True     ,						A_ :	int=True     ,						A_ :	Any=False     ,						A_ :	str=True     ,						A_ :	int=9_9     ,						A_ :	int=3_2     ,						A_ :	Optional[int]=5     ,						A_ :	List[str]=4     ,						A_ :	int=6_4     ,						A_ :	Optional[int]="gelu"     ,						A_ :	List[Any]=0.1     ,						A_ :	int=0.1     ,						A_ :	List[str]=5_1_2     ,						A_ :	Optional[Any]=1_6     ,						A_ :	int=2     ,						A_ :	Optional[int]=0.02     ,						A_ :	Any=3     ,						A_ :	Optional[Any]=4     ,						A_ :	Union[str, Any]=None     ,						A_ :	Union[str, Any]=2     ,						A_ :	Tuple=2     ,						A_ :	Optional[int]=2     ,						A_ :	List[Any]=2     ,						A_ :	List[str]=4     ,						A_ :	Union[str, Any]=1     ,						):






      '''simple docstring'''




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

 def    __magic_name__       (		self :	Union[str, Any]       ):






      '''simple docstring'''




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

      _lowerCAmelCase   :					int        =    None
      if self.use_input_mask:
           _lowerCAmelCase   :					Union[str, Any]        =    random_attention_mask([self.batch_size, self.seq_length]       )

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

      _lowerCAmelCase   :					Any        =    self.get_config()

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

 def    __magic_name__       (		self :	Any       ):






      '''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    __magic_name__       (		self :	List[str]     ,						A_ :	Dict     ,						A_ :	Union[str, Any]     ,						A_ :	List[str]     ,						A_ :	Optional[int]     ,						A_ :	str     ,						A_ :	Optional[int]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[Any]        =    SqueezeBertModel(config=A_       )
      model.to(A_       )
      model.eval()
      _lowerCAmelCase   :					List[Any]        =    model(A_     ,						A_       )
      _lowerCAmelCase   :					Tuple        =    model(A_       )
      self.parent.assertEqual(result.last_hidden_state.shape     ,						(self.batch_size, self.seq_length, self.hidden_size)       )

 def    __magic_name__       (		self :	Optional[int]     ,						A_ :	int     ,						A_ :	Dict     ,						A_ :	Any     ,						A_ :	List[Any]     ,						A_ :	List[Any]     ,						A_ :	Optional[int]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[Any]        =    SqueezeBertForMaskedLM(config=A_       )
      model.to(A_       )
      model.eval()
      _lowerCAmelCase   :					int        =    model(A_     ,						attention_mask=A_     ,						labels=A_       )
      self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.seq_length, self.vocab_size)       )

 def    __magic_name__       (		self :	Optional[int]     ,						A_ :	Union[str, Any]     ,						A_ :	List[Any]     ,						A_ :	List[Any]     ,						A_ :	List[Any]     ,						A_ :	List[str]     ,						A_ :	int       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[Any]        =    SqueezeBertForQuestionAnswering(config=A_       )
      model.to(A_       )
      model.eval()
      _lowerCAmelCase   :					List[Any]        =    model(
          A_     ,						attention_mask=A_     ,						start_positions=A_     ,						end_positions=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    __magic_name__       (		self :	Tuple     ,						A_ :	Optional[int]     ,						A_ :	Dict     ,						A_ :	str     ,						A_ :	Tuple     ,						A_ :	List[Any]     ,						A_ :	List[Any]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					int        =    self.num_labels
      _lowerCAmelCase   :					int        =    SqueezeBertForSequenceClassification(A_       )
      model.to(A_       )
      model.eval()
      _lowerCAmelCase   :					List[Any]        =    model(A_     ,						attention_mask=A_     ,						labels=A_       )
      self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.num_labels)       )

 def    __magic_name__       (		self :	Optional[Any]     ,						A_ :	List[Any]     ,						A_ :	List[Any]     ,						A_ :	Tuple     ,						A_ :	List[Any]     ,						A_ :	List[Any]     ,						A_ :	List[Any]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					List[Any]        =    self.num_labels
      _lowerCAmelCase   :					Any        =    SqueezeBertForTokenClassification(config=A_       )
      model.to(A_       )
      model.eval()

      _lowerCAmelCase   :					Any        =    model(A_     ,						attention_mask=A_     ,						labels=A_       )
      self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.seq_length, self.num_labels)       )

 def    __magic_name__       (		self :	Tuple     ,						A_ :	Tuple     ,						A_ :	Tuple     ,						A_ :	Union[str, Any]     ,						A_ :	int     ,						A_ :	List[Any]     ,						A_ :	int       ):






      '''simple docstring'''




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


 def    __magic_name__       (		self :	Optional[int]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[int]        =    self.prepare_config_and_inputs()
      ((_lowerCAmelCase)      ,			(_lowerCAmelCase)      ,			(_lowerCAmelCase)      ,			(_lowerCAmelCase)      ,			(_lowerCAmelCase)      ,			(_lowerCAmelCase))   :					Optional[int]        =    config_and_inputs
      _lowerCAmelCase   :					Optional[Any]        =    {"input_ids": input_ids, "attention_mask": input_mask}
      return config, inputs_dict





@require_torch
class A__    ( A  ,		A  ,		unittest.TestCase ):



 """simple docstring"""







 _lowercase     :					Tuple      =						(
     (
         SqueezeBertModel,
         SqueezeBertForMaskedLM,
         SqueezeBertForMultipleChoice,
         SqueezeBertForQuestionAnswering,
         SqueezeBertForSequenceClassification,
         SqueezeBertForTokenClassification,
     )
     if is_torch_available()
     else None
 )
 _lowercase     :					Optional[Any]      =						(
     {
         '''feature-extraction''': SqueezeBertModel,
         '''fill-mask''': SqueezeBertForMaskedLM,
         '''question-answering''': SqueezeBertForQuestionAnswering,
         '''text-classification''': SqueezeBertForSequenceClassification,
         '''token-classification''': SqueezeBertForTokenClassification,
         '''zero-shot''': SqueezeBertForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 _lowercase     :					Union[str, Any]      =						False
 _lowercase     :					int      =						True
 _lowercase     :					List[str]      =						False

 def    __magic_name__       (		self :	Optional[Any]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					int        =    SqueezeBertModelTester(self       )
      _lowerCAmelCase   :					Tuple        =    ConfigTester(self     ,						config_class=A_     ,						dim=3_7       )

 def    __magic_name__       (		self :	int       ):






      '''simple docstring'''




      self.config_tester.run_common_tests()

 def    __magic_name__       (		self :	List[str]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					str        =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_squeezebert_model(*A_       )

 def    __magic_name__       (		self :	Optional[Any]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Tuple        =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_squeezebert_for_masked_lm(*A_       )

 def    __magic_name__       (		self :	List[Any]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					str        =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_squeezebert_for_question_answering(*A_       )

 def    __magic_name__       (		self :	List[str]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					int        =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_squeezebert_for_sequence_classification(*A_       )

 def    __magic_name__       (		self :	Dict       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Dict        =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_squeezebert_for_token_classification(*A_       )

 def    __magic_name__       (		self :	List[str]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					List[Any]        =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_squeezebert_for_multiple_choice(*A_       )


 @slow
 def    __magic_name__       (		self :	Optional[int]       ):






      '''simple docstring'''




      for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _lowerCAmelCase   :					int        =    SqueezeBertModel.from_pretrained(A_       )
           self.assertIsNotNone(A_       )





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



 """simple docstring"""







 @slow
 def    __magic_name__       (		self :	List[str]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[Any]        =    SqueezeBertForSequenceClassification.from_pretrained("squeezebert/squeezebert-mnli"       )

      _lowerCAmelCase   :					Optional[int]        =    torch.tensor([[1, 2_9_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9, 1_3, 1_5_8_8, 2]]       )
      _lowerCAmelCase   :					List[str]        =    model(A_       )[0]
      _lowerCAmelCase   :					Any        =    torch.Size((1, 3)       )
      self.assertEqual(output.shape     ,						A_       )
      _lowerCAmelCase   :					Any        =    torch.tensor([[0.6401, -0.0349, -0.6041]]       )
      self.assertTrue(torch.allclose(A_     ,						A_     ,						atol=1E-4       )       )






