



"""simple docstring"""






import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch
   from torch import nn

   from transformers import MaskFormerSwinBackbone
   from transformers.models.maskformer import MaskFormerSwinModel






class 	__snake_case	:




  def __init__(			self					:						List[str]						, __lowerCAmelCase					:						str						, __lowerCAmelCase					:						Optional[int]=1_3						, __lowerCAmelCase					:						str=3_2						, __lowerCAmelCase					:						Optional[int]=2						, __lowerCAmelCase					:						Optional[int]=3						, __lowerCAmelCase					:						List[Any]=1_6						, __lowerCAmelCase					:						Dict=[1, 2, 1]						, __lowerCAmelCase					:						str=[2, 2, 4]						, __lowerCAmelCase					:						str=2						, __lowerCAmelCase					:						Optional[Any]=2.0						, __lowerCAmelCase					:						Union[str, Any]=True						, __lowerCAmelCase					:						Any=0.0						, __lowerCAmelCase					:						Union[str, Any]=0.0						, __lowerCAmelCase					:						str=0.1						, __lowerCAmelCase					:						List[Any]="gelu"						, __lowerCAmelCase					:						Any=False						, __lowerCAmelCase					:						str=True						, __lowerCAmelCase					:						List[Any]=0.02						, __lowerCAmelCase					:						Any=1E-5						, __lowerCAmelCase					:						List[str]=True						, __lowerCAmelCase					:						Union[str, Any]=None						, __lowerCAmelCase					:						Dict=True						, __lowerCAmelCase					:						Optional[int]=1_0						, __lowerCAmelCase					:						Union[str, Any]=8						, __lowerCAmelCase					:						List[Any]=["stage1", "stage2", "stage3"]						, __lowerCAmelCase					:						str=[1, 2, 3]						, ):






         """simple docstring"""






         _lowerCamelCase						:    List[str]         =			parent
         _lowerCamelCase						:    Optional[int]         =			batch_size
         _lowerCamelCase						:    Tuple         =			image_size
         _lowerCamelCase						:    int         =			patch_size
         _lowerCamelCase						:    str         =			num_channels
         _lowerCamelCase						:    Tuple         =			embed_dim
         _lowerCamelCase						:    Optional[int]         =			depths
         _lowerCamelCase						:    List[Any]         =			num_heads
         _lowerCamelCase						:    str         =			window_size
         _lowerCamelCase						:    int         =			mlp_ratio
         _lowerCamelCase						:    Union[str, Any]         =			qkv_bias
         _lowerCamelCase						:    Dict         =			hidden_dropout_prob
         _lowerCamelCase						:    str         =			attention_probs_dropout_prob
         _lowerCamelCase						:    Union[str, Any]         =			drop_path_rate
         _lowerCamelCase						:    Union[str, Any]         =			hidden_act
         _lowerCamelCase						:    int         =			use_absolute_embeddings
         _lowerCamelCase						:    Union[str, Any]         =			patch_norm
         _lowerCamelCase						:    List[Any]         =			layer_norm_eps
         _lowerCamelCase						:    Optional[int]         =			initializer_range
         _lowerCamelCase						:    Tuple         =			is_training
         _lowerCamelCase						:    str         =			scope
         _lowerCamelCase						:    Optional[int]         =			use_labels
         _lowerCamelCase						:    Optional[Any]         =			type_sequence_label_size
         _lowerCamelCase						:    List[Any]         =			encoder_stride
         _lowerCamelCase						:    Dict         =			out_features
         _lowerCamelCase						:    Tuple         =			out_indices




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[Any]		):






         """simple docstring"""






         _lowerCamelCase						:    int         =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

         _lowerCamelCase						:    Union[str, Any]         =			None
         if self.use_labels:
                _lowerCamelCase						:    List[Any]         =			ids_tensor([self.batch_size]						, self.type_sequence_label_size		)

         _lowerCamelCase						:    Dict         =			self.get_config()

         return config, pixel_values, labels




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[Any]		):






         """simple docstring"""






         return MaskFormerSwinConfig(
             image_size=self.image_size						, patch_size=self.patch_size						, num_channels=self.num_channels						, embed_dim=self.embed_dim						, depths=self.depths						, num_heads=self.num_heads						, window_size=self.window_size						, mlp_ratio=self.mlp_ratio						, qkv_bias=self.qkv_bias						, hidden_dropout_prob=self.hidden_dropout_prob						, attention_probs_dropout_prob=self.attention_probs_dropout_prob						, drop_path_rate=self.drop_path_rate						, hidden_act=self.hidden_act						, use_absolute_embeddings=self.use_absolute_embeddings						, path_norm=self.patch_norm						, layer_norm_eps=self.layer_norm_eps						, initializer_range=self.initializer_range						, encoder_stride=self.encoder_stride						, out_features=self.out_features						, out_indices=self.out_indices						, )




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[str]						, __lowerCAmelCase					:						List[Any]						, __lowerCAmelCase					:						Optional[Any]						, __lowerCAmelCase					:						int		):






         """simple docstring"""






         _lowerCamelCase						:    Optional[int]         =			MaskFormerSwinModel(config=__lowerCAmelCase		)
         model.to(__lowerCAmelCase		)
         model.eval()
         _lowerCamelCase						:    Optional[Any]         =			model(__lowerCAmelCase		)

         _lowerCamelCase						:    List[Any]         =			((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths		) - 1))
         _lowerCamelCase						:    Optional[Any]         =			int(config.embed_dim * 2 ** (len(config.depths		) - 1)		)

         self.parent.assertEqual(result.last_hidden_state.shape						, (self.batch_size, expected_seq_len, expected_dim)		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[str]						, __lowerCAmelCase					:						str						, __lowerCAmelCase					:						Optional[int]						, __lowerCAmelCase					:						Dict		):






         """simple docstring"""






         _lowerCamelCase						:    List[str]         =			MaskFormerSwinBackbone(config=__lowerCAmelCase		)
         model.to(__lowerCAmelCase		)
         model.eval()
         _lowerCamelCase						:    Optional[int]         =			model(__lowerCAmelCase		)

         # verify feature maps
         self.parent.assertEqual(len(result.feature_maps		)						, len(config.out_features		)		)
         self.parent.assertListEqual(list(result.feature_maps[0].shape		)						, [1_3, 1_6, 1_6, 1_6]		)

         # verify channels
         self.parent.assertEqual(len(model.channels		)						, len(config.out_features		)		)
         self.parent.assertListEqual(model.channels						, [1_6, 3_2, 6_4]		)

         # verify ValueError
         with self.parent.assertRaises(__lowerCAmelCase		):
                _lowerCamelCase						:    Union[str, Any]         =			['''stem''']
                _lowerCamelCase						:    List[Any]         =			MaskFormerSwinBackbone(config=__lowerCAmelCase		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[str]		):






         """simple docstring"""






         _lowerCamelCase						:    Union[str, Any]         =			self.prepare_config_and_inputs()
         _lowerCamelCase						:    Dict         =			config_and_inputs
         _lowerCamelCase						:    Union[str, Any]         =			{'''pixel_values''': pixel_values}
         return config, inputs_dict






@require_torch
class 	__snake_case	(     _lowercase  ,					_lowercase  ,					unittest.TestCase):
  snake_case__    :       Tuple        =						(
      (
          MaskFormerSwinModel,
          MaskFormerSwinBackbone,
      )
      if is_torch_available()
      else ()
  )
  snake_case__    :       Dict        =						{"feature-extraction": MaskFormerSwinModel} if is_torch_available() else {}
  snake_case__    :       str        =						False
  snake_case__    :       Union[str, Any]        =						False
  snake_case__    :       Optional[Any]        =						False
  snake_case__    :       int        =						False
  snake_case__    :       Union[str, Any]        =						False




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[str]		):






         """simple docstring"""






         _lowerCamelCase						:    int         =			MaskFormerSwinModelTester(self		)
         _lowerCamelCase						:    str         =			ConfigTester(self						, config_class=__lowerCAmelCase						, embed_dim=3_7		)




  @require_torch_multi_gpu
  @unittest.skip(
      reason=(
          '''`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn\'t work well with'''
          ''' `nn.DataParallel`'''
      )		)
  def 						SCREAMING_SNAKE_CASE    (			self					:						Tuple		):






         """simple docstring"""






         pass




  def 						SCREAMING_SNAKE_CASE    (			self					:						str		):






         """simple docstring"""






         self.create_and_test_config_common_properties()
         self.config_tester.create_and_test_config_to_json_string()
         self.config_tester.create_and_test_config_to_json_file()
         self.config_tester.create_and_test_config_from_and_save_pretrained()
         self.config_tester.create_and_test_config_with_num_labels()
         self.config_tester.check_config_can_be_init_without_params()
         self.config_tester.check_config_arguments_init()




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[int]		):






         """simple docstring"""






         return




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[int]		):






         """simple docstring"""






         _lowerCamelCase						:    Dict         =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__lowerCAmelCase		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Any		):






         """simple docstring"""






         _lowerCamelCase						:    int         =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_backbone(*__lowerCAmelCase		)




  @unittest.skip('''Swin does not use inputs_embeds'''		)
  def 						SCREAMING_SNAKE_CASE    (			self					:						str		):






         """simple docstring"""






         pass




  @unittest.skip('''Swin does not support feedforward chunking'''		)
  def 						SCREAMING_SNAKE_CASE    (			self					:						str		):






         """simple docstring"""






         pass




  def 						SCREAMING_SNAKE_CASE    (			self					:						Dict		):






         """simple docstring"""






         _lowerCamelCase						:    Optional[Any]         =			self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
                _lowerCamelCase						:    Tuple         =			model_class(__lowerCAmelCase		)
                self.assertIsInstance(model.get_input_embeddings()						, (nn.Module)		)
                _lowerCamelCase						:    str         =			model.get_output_embeddings()
                self.assertTrue(x is None or isinstance(__lowerCAmelCase						, nn.Linear		)		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[int]		):






         """simple docstring"""






         _lowerCamelCase						:    Any         =			self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
                _lowerCamelCase						:    Dict         =			model_class(__lowerCAmelCase		)
                _lowerCamelCase						:    Tuple         =			inspect.signature(model.forward		)
                # signature.parameters is an OrderedDict => so arg_names order is deterministic
                _lowerCamelCase						:    int         =			[*signature.parameters.keys()]

                _lowerCamelCase						:    Tuple         =			['''pixel_values''']
                self.assertListEqual(arg_names[:1]						, __lowerCAmelCase		)




  @unittest.skip(reason='''MaskFormerSwin is only used as backbone and doesn\'t support output_attentions'''		)
  def 						SCREAMING_SNAKE_CASE    (			self					:						int		):






         """simple docstring"""






         pass




  @unittest.skip(reason='''MaskFormerSwin is only used as an internal backbone'''		)
  def 						SCREAMING_SNAKE_CASE    (			self					:						Union[str, Any]		):






         """simple docstring"""






         pass




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[Any]						, __lowerCAmelCase					:						int						, __lowerCAmelCase					:						Dict						, __lowerCAmelCase					:						Optional[Any]						, __lowerCAmelCase					:						Any		):






         """simple docstring"""






         _lowerCamelCase						:    Optional[Any]         =			model_class(__lowerCAmelCase		)
         model.to(__lowerCAmelCase		)
         model.eval()

         with torch.no_grad():
                _lowerCamelCase						:    List[Any]         =			model(**self._prepare_for_class(__lowerCAmelCase						, __lowerCAmelCase		)		)

         _lowerCamelCase						:    Dict         =			outputs.hidden_states

         _lowerCamelCase						:    int         =			getattr(
             self.model_tester						, '''expected_num_hidden_layers'''						, len(self.model_tester.depths		) + 1		)
         self.assertEqual(len(__lowerCAmelCase		)						, __lowerCAmelCase		)

         # Swin has a different seq_length
         _lowerCamelCase						:    Dict         =			(
             config.patch_size
             if isinstance(config.patch_size						, collections.abc.Iterable		)
             else (config.patch_size, config.patch_size)
         )

         _lowerCamelCase						:    List[Any]         =			(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

         self.assertListEqual(
             list(hidden_states[0].shape[-2:]		)						, [num_patches, self.model_tester.embed_dim]						, )




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[str]		):






         """simple docstring"""






         _lowerCamelCase						:    List[Any]         =			self.model_tester.prepare_config_and_inputs_for_common()

         _lowerCamelCase						:    Tuple         =			(
             self.model_tester.image_size
             if isinstance(self.model_tester.image_size						, collections.abc.Iterable		)
             else (self.model_tester.image_size, self.model_tester.image_size)
         )

         for model_class in self.all_model_classes:
                _lowerCamelCase						:    Dict         =			True
                self.check_hidden_states_output(__lowerCAmelCase						, __lowerCAmelCase						, __lowerCAmelCase						, __lowerCAmelCase		)

                # check that output_hidden_states also work using config
                del inputs_dict["output_hidden_states"]
                _lowerCamelCase						:    Any         =			True

                self.check_hidden_states_output(__lowerCAmelCase						, __lowerCAmelCase						, __lowerCAmelCase						, __lowerCAmelCase		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						str		):






         """simple docstring"""






         _lowerCamelCase						:    str         =			self.model_tester.prepare_config_and_inputs_for_common()
         _lowerCamelCase						:    List[str]         =			3

         _lowerCamelCase						:    Optional[Any]         =			(
             self.model_tester.image_size
             if isinstance(self.model_tester.image_size						, collections.abc.Iterable		)
             else (self.model_tester.image_size, self.model_tester.image_size)
         )
         _lowerCamelCase						:    Any         =			(
             config.patch_size
             if isinstance(config.patch_size						, collections.abc.Iterable		)
             else (config.patch_size, config.patch_size)
         )

         _lowerCamelCase						:    List[Any]         =			image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
         _lowerCamelCase						:    int         =			image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

         for model_class in self.all_model_classes:
                _lowerCamelCase						:    List[Any]         =			True
                self.check_hidden_states_output(__lowerCAmelCase						, __lowerCAmelCase						, __lowerCAmelCase						, (padded_height, padded_width)		)

                # check that output_hidden_states also work using config
                del inputs_dict["output_hidden_states"]
                _lowerCamelCase						:    Union[str, Any]         =			True
                self.check_hidden_states_output(__lowerCAmelCase						, __lowerCAmelCase						, __lowerCAmelCase						, (padded_height, padded_width)		)




  @unittest.skip(reason='''MaskFormerSwin doesn\'t have pretrained checkpoints'''		)
  def 						SCREAMING_SNAKE_CASE    (			self					:						Union[str, Any]		):






         """simple docstring"""






         pass




  @unittest.skip(reason='''This will be fixed once MaskFormerSwin is replaced by native Swin'''		)
  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[Any]		):






         """simple docstring"""






         pass




  @unittest.skip(reason='''This will be fixed once MaskFormerSwin is replaced by native Swin'''		)
  def 						SCREAMING_SNAKE_CASE    (			self					:						int		):






         """simple docstring"""






         pass




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[int]		):






         """simple docstring"""






         _lowerCamelCase						:    Optional[Any]         =			self.model_tester.prepare_config_and_inputs_for_common()

         def set_nan_tensor_to_zero(__lowerCAmelCase					:						Optional[int]		):
                _lowerCamelCase						:    str         =			0
                return t

         def check_equivalence(__lowerCAmelCase					:						Union[str, Any]						, __lowerCAmelCase					:						Dict						, __lowerCAmelCase					:						Union[str, Any]						, __lowerCAmelCase					:						Optional[int]={}		):
                with torch.no_grad():
                       _lowerCamelCase						:    Any         =			model(**__lowerCAmelCase						, return_dict=__lowerCAmelCase						, **__lowerCAmelCase		)
                       _lowerCamelCase						:    Optional[Any]         =			model(**__lowerCAmelCase						, return_dict=__lowerCAmelCase						, **__lowerCAmelCase		).to_tuple()

                       def recursive_check(__lowerCAmelCase					:						Union[str, Any]						, __lowerCAmelCase					:						Any		):
                              if isinstance(__lowerCAmelCase						, (List, Tuple)		):
                                     for tuple_iterable_value, dict_iterable_value in zip(__lowerCAmelCase						, __lowerCAmelCase		):
                                            recursive_check(__lowerCAmelCase						, __lowerCAmelCase		)
                              elif isinstance(__lowerCAmelCase						, __lowerCAmelCase		):
                                     for tuple_iterable_value, dict_iterable_value in zip(
                                         tuple_object.values()						, dict_object.values()		):
                                            recursive_check(__lowerCAmelCase						, __lowerCAmelCase		)
                              elif tuple_object is None:
                                     return
                              else:
                                     self.assertTrue(
                                         torch.allclose(
                                             set_nan_tensor_to_zero(__lowerCAmelCase		)						, set_nan_tensor_to_zero(__lowerCAmelCase		)						, atol=1E-5		)						, msg=(
                                             '''Tuple and dict output are not equal. Difference:'''
                                             f''' {torch.max(torch.abs(tuple_object - dict_object		)		)}. Tuple has `nan`:'''
                                             f''' {torch.isnan(__lowerCAmelCase		).any()} and `inf`: {torch.isinf(__lowerCAmelCase		)}. Dict has'''
                                             f''' `nan`: {torch.isnan(__lowerCAmelCase		).any()} and `inf`: {torch.isinf(__lowerCAmelCase		)}.'''
                                         )						, )

                       recursive_check(__lowerCAmelCase						, __lowerCAmelCase		)

         for model_class in self.all_model_classes:
                _lowerCamelCase						:    Any         =			model_class(__lowerCAmelCase		)
                model.to(__lowerCAmelCase		)
                model.eval()

                _lowerCamelCase						:    int         =			self._prepare_for_class(__lowerCAmelCase						, __lowerCAmelCase		)
                _lowerCamelCase						:    List[str]         =			self._prepare_for_class(__lowerCAmelCase						, __lowerCAmelCase		)
                check_equivalence(__lowerCAmelCase						, __lowerCAmelCase						, __lowerCAmelCase		)

                _lowerCamelCase						:    int         =			self._prepare_for_class(__lowerCAmelCase						, __lowerCAmelCase						, return_labels=__lowerCAmelCase		)
                _lowerCamelCase						:    str         =			self._prepare_for_class(__lowerCAmelCase						, __lowerCAmelCase						, return_labels=__lowerCAmelCase		)
                check_equivalence(__lowerCAmelCase						, __lowerCAmelCase						, __lowerCAmelCase		)

                _lowerCamelCase						:    Optional[int]         =			self._prepare_for_class(__lowerCAmelCase						, __lowerCAmelCase		)
                _lowerCamelCase						:    int         =			self._prepare_for_class(__lowerCAmelCase						, __lowerCAmelCase		)
                check_equivalence(__lowerCAmelCase						, __lowerCAmelCase						, __lowerCAmelCase						, {'''output_hidden_states''': True}		)

                _lowerCamelCase						:    List[str]         =			self._prepare_for_class(__lowerCAmelCase						, __lowerCAmelCase						, return_labels=__lowerCAmelCase		)
                _lowerCamelCase						:    Optional[int]         =			self._prepare_for_class(__lowerCAmelCase						, __lowerCAmelCase						, return_labels=__lowerCAmelCase		)
                check_equivalence(__lowerCAmelCase						, __lowerCAmelCase						, __lowerCAmelCase						, {'''output_hidden_states''': True}		)






@require_torch
class 	__snake_case	(     unittest.TestCase  ,					_lowercase):
  snake_case__    :       int        =						(MaskFormerSwinBackbone,) if is_torch_available() else ()
  snake_case__    :       List[str]        =						MaskFormerSwinConfig




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






         """simple docstring"""






         _lowerCamelCase						:    Dict         =			MaskFormerSwinModelTester(self		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Dict		):






         """simple docstring"""






         _lowerCamelCase						:    Optional[Any]         =			self.model_tester.prepare_config_and_inputs_for_common()
         _lowerCamelCase						:    Union[str, Any]         =			inputs_dict['''pixel_values'''].shape[0]

         for backbone_class in self.all_model_classes:
                _lowerCamelCase						:    Optional[int]         =			backbone_class(__lowerCAmelCase		)
                backbone.to(__lowerCAmelCase		)
                backbone.eval()

                _lowerCamelCase						:    int         =			backbone(**__lowerCAmelCase		)

                # Test default outputs and verify feature maps
                self.assertIsInstance(outputs.feature_maps						, __lowerCAmelCase		)
                self.assertTrue(len(outputs.feature_maps		) == len(backbone.channels		)		)
                for feature_map, n_channels in zip(outputs.feature_maps						, backbone.channels		):
                       self.assertTrue(feature_map.shape[:2]						, (batch_size, n_channels)		)
                self.assertIsNone(outputs.hidden_states		)
                self.assertIsNone(outputs.attentions		)

                # Test output_hidden_states=True
                _lowerCamelCase						:    str         =			backbone(**__lowerCAmelCase						, output_hidden_states=__lowerCAmelCase		)
                self.assertIsNotNone(outputs.hidden_states		)
                self.assertTrue(len(outputs.hidden_states		)						, len(backbone.stage_names		)		)
                # We skip the stem layer
                for hidden_states, n_channels in zip(outputs.hidden_states[1:]						, backbone.channels		):
                       for hidden_state in hidden_states:
                              # Hidden states are in the format (batch_size, (height * width), n_channels)
                              _lowerCamelCase						:    List[str]         =			hidden_state.shape
                              self.assertTrue((h_batch_size, h_n_channels)						, (batch_size, n_channels)		)

            # Test output_attentions=True
                if self.has_attentions:
                       _lowerCamelCase						:    List[str]         =			backbone(**__lowerCAmelCase						, output_attentions=__lowerCAmelCase		)
                       self.assertIsNotNone(outputs.attentions		)







"""simple docstring"""






import os
import tempfile
import unittest

from transformers import FlaubertConfig, is_torch_available
from transformers.testing_utils import require_torch, require_torch_gpu, 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 (
       FlaubertForMultipleChoice,
       FlaubertForQuestionAnswering,
       FlaubertForQuestionAnsweringSimple,
       FlaubertForSequenceClassification,
       FlaubertForTokenClassification,
       FlaubertModel,
       FlaubertWithLMHeadModel,
   )
   from transformers.models.flaubert.modeling_flaubert import FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST






class 	__snake_case	(     _lowercase):




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






         """simple docstring"""






         _lowerCamelCase						:    Dict         =			parent
         _lowerCamelCase						:    List[str]         =			batch_size
         _lowerCamelCase						:    Dict         =			seq_length
         _lowerCamelCase						:    List[Any]         =			is_training
         _lowerCamelCase						:    Dict         =			use_input_lengths
         _lowerCamelCase						:    Tuple         =			use_token_type_ids
         _lowerCamelCase						:    Any         =			use_labels
         _lowerCamelCase						:    Optional[Any]         =			gelu_activation
         _lowerCamelCase						:    Optional[Any]         =			sinusoidal_embeddings
         _lowerCamelCase						:    Dict         =			causal
         _lowerCamelCase						:    Dict         =			asm
         _lowerCamelCase						:    str         =			n_langs
         _lowerCamelCase						:    str         =			vocab_size
         _lowerCamelCase						:    Optional[int]         =			n_special
         _lowerCamelCase						:    Dict         =			hidden_size
         _lowerCamelCase						:    int         =			num_hidden_layers
         _lowerCamelCase						:    str         =			num_attention_heads
         _lowerCamelCase						:    Dict         =			hidden_dropout_prob
         _lowerCamelCase						:    int         =			attention_probs_dropout_prob
         _lowerCamelCase						:    Any         =			max_position_embeddings
         _lowerCamelCase						:    Any         =			type_vocab_size
         _lowerCamelCase						:    Optional[int]         =			type_sequence_label_size
         _lowerCamelCase						:    List[str]         =			initializer_range
         _lowerCamelCase						:    List[Any]         =			num_labels
         _lowerCamelCase						:    Dict         =			num_choices
         _lowerCamelCase						:    str         =			summary_type
         _lowerCamelCase						:    List[str]         =			use_proj
         _lowerCamelCase						:    int         =			scope




  def 						SCREAMING_SNAKE_CASE    (			self					:						Tuple		):






         """simple docstring"""






         _lowerCamelCase						:    List[Any]         =			ids_tensor([self.batch_size, self.seq_length]						, self.vocab_size		)
         _lowerCamelCase						:    Optional[Any]         =			random_attention_mask([self.batch_size, self.seq_length]		)

         _lowerCamelCase						:    Optional[int]         =			None
         if self.use_input_lengths:
                _lowerCamelCase						:    int         =			(
                    ids_tensor([self.batch_size]						, vocab_size=2		) + self.seq_length - 2
                )  # small variation of seq_length

         _lowerCamelCase						:    Union[str, Any]         =			None
         if self.use_token_type_ids:
                _lowerCamelCase						:    str         =			ids_tensor([self.batch_size, self.seq_length]						, self.n_langs		)

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

         _lowerCamelCase						:    Tuple         =			self.get_config()

         return (
             config,
             input_ids,
             token_type_ids,
             input_lengths,
             sequence_labels,
             token_labels,
             is_impossible_labels,
             choice_labels,
             input_mask,
         )




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[int]		):






         """simple docstring"""






         return FlaubertConfig(
             vocab_size=self.vocab_size						, n_special=self.n_special						, emb_dim=self.hidden_size						, n_layers=self.num_hidden_layers						, n_heads=self.num_attention_heads						, dropout=self.hidden_dropout_prob						, attention_dropout=self.attention_probs_dropout_prob						, gelu_activation=self.gelu_activation						, sinusoidal_embeddings=self.sinusoidal_embeddings						, asm=self.asm						, causal=self.causal						, n_langs=self.n_langs						, max_position_embeddings=self.max_position_embeddings						, initializer_range=self.initializer_range						, summary_type=self.summary_type						, use_proj=self.use_proj						, )




  def 						SCREAMING_SNAKE_CASE    (			self					:						str						, __lowerCAmelCase					:						List[str]						, __lowerCAmelCase					:						Optional[Any]						, __lowerCAmelCase					:						str						, __lowerCAmelCase					:						Optional[Any]						, __lowerCAmelCase					:						Tuple						, __lowerCAmelCase					:						Any						, __lowerCAmelCase					:						Optional[Any]						, __lowerCAmelCase					:						List[str]						, __lowerCAmelCase					:						Tuple						, ):






         """simple docstring"""






         _lowerCamelCase						:    Optional[Any]         =			FlaubertModel(config=__lowerCAmelCase		)
         model.to(__lowerCAmelCase		)
         model.eval()
         _lowerCamelCase						:    Union[str, Any]         =			model(__lowerCAmelCase						, lengths=__lowerCAmelCase						, langs=__lowerCAmelCase		)
         _lowerCamelCase						:    str         =			model(__lowerCAmelCase						, langs=__lowerCAmelCase		)
         _lowerCamelCase						:    List[str]         =			model(__lowerCAmelCase		)
         self.parent.assertEqual(result.last_hidden_state.shape						, (self.batch_size, self.seq_length, self.hidden_size)		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Dict						, __lowerCAmelCase					:						str						, __lowerCAmelCase					:						Dict						, __lowerCAmelCase					:						Dict						, __lowerCAmelCase					:						List[str]						, __lowerCAmelCase					:						Optional[Any]						, __lowerCAmelCase					:						Tuple						, __lowerCAmelCase					:						int						, __lowerCAmelCase					:						Optional[int]						, __lowerCAmelCase					:						str						, ):






         """simple docstring"""






         _lowerCamelCase						:    Tuple         =			FlaubertWithLMHeadModel(__lowerCAmelCase		)
         model.to(__lowerCAmelCase		)
         model.eval()

         _lowerCamelCase						:    str         =			model(__lowerCAmelCase						, token_type_ids=__lowerCAmelCase						, labels=__lowerCAmelCase		)
         self.parent.assertEqual(result.loss.shape						, ()		)
         self.parent.assertEqual(result.logits.shape						, (self.batch_size, self.seq_length, self.vocab_size)		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						int						, __lowerCAmelCase					:						int						, __lowerCAmelCase					:						int						, __lowerCAmelCase					:						Tuple						, __lowerCAmelCase					:						Any						, __lowerCAmelCase					:						Any						, __lowerCAmelCase					:						str						, __lowerCAmelCase					:						Optional[int]						, __lowerCAmelCase					:						Dict						, __lowerCAmelCase					:						Union[str, Any]						, ):






         """simple docstring"""






         _lowerCamelCase						:    Union[str, Any]         =			FlaubertForQuestionAnsweringSimple(__lowerCAmelCase		)
         model.to(__lowerCAmelCase		)
         model.eval()

         _lowerCamelCase						:    List[str]         =			model(__lowerCAmelCase		)

         _lowerCamelCase						:    Union[str, Any]         =			model(__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 						SCREAMING_SNAKE_CASE    (			self					:						Union[str, Any]						, __lowerCAmelCase					:						List[Any]						, __lowerCAmelCase					:						Any						, __lowerCAmelCase					:						Optional[Any]						, __lowerCAmelCase					:						List[Any]						, __lowerCAmelCase					:						int						, __lowerCAmelCase					:						int						, __lowerCAmelCase					:						List[Any]						, __lowerCAmelCase					:						Union[str, Any]						, __lowerCAmelCase					:						int						, ):






         """simple docstring"""






         _lowerCamelCase						:    str         =			FlaubertForQuestionAnswering(__lowerCAmelCase		)
         model.to(__lowerCAmelCase		)
         model.eval()

         _lowerCamelCase						:    Optional[Any]         =			model(__lowerCAmelCase		)

         _lowerCamelCase						:    Optional[Any]         =			model(
             __lowerCAmelCase						, start_positions=__lowerCAmelCase						, end_positions=__lowerCAmelCase						, cls_index=__lowerCAmelCase						, is_impossible=__lowerCAmelCase						, p_mask=__lowerCAmelCase						, )

         _lowerCamelCase						:    List[str]         =			model(
             __lowerCAmelCase						, start_positions=__lowerCAmelCase						, end_positions=__lowerCAmelCase						, cls_index=__lowerCAmelCase						, is_impossible=__lowerCAmelCase						, )

         ((_lowerCamelCase)      ,   )						:    str         =			result_with_labels.to_tuple()

         _lowerCamelCase						:    Optional[Any]         =			model(__lowerCAmelCase						, start_positions=__lowerCAmelCase						, end_positions=__lowerCAmelCase		)

         ((_lowerCamelCase)      ,   )						:    Union[str, Any]         =			result_with_labels.to_tuple()

         self.parent.assertEqual(result_with_labels.loss.shape						, ()		)
         self.parent.assertEqual(result.start_top_log_probs.shape						, (self.batch_size, model.config.start_n_top)		)
         self.parent.assertEqual(result.start_top_index.shape						, (self.batch_size, model.config.start_n_top)		)
         self.parent.assertEqual(
             result.end_top_log_probs.shape						, (self.batch_size, model.config.start_n_top * model.config.end_n_top)		)
         self.parent.assertEqual(
             result.end_top_index.shape						, (self.batch_size, model.config.start_n_top * model.config.end_n_top)		)
         self.parent.assertEqual(result.cls_logits.shape						, (self.batch_size,)		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						int						, __lowerCAmelCase					:						str						, __lowerCAmelCase					:						List[Any]						, __lowerCAmelCase					:						Union[str, Any]						, __lowerCAmelCase					:						int						, __lowerCAmelCase					:						List[str]						, __lowerCAmelCase					:						List[Any]						, __lowerCAmelCase					:						Any						, __lowerCAmelCase					:						Dict						, __lowerCAmelCase					:						str						, ):






         """simple docstring"""






         _lowerCamelCase						:    Dict         =			FlaubertForSequenceClassification(__lowerCAmelCase		)
         model.to(__lowerCAmelCase		)
         model.eval()

         _lowerCamelCase						:    str         =			model(__lowerCAmelCase		)
         _lowerCamelCase						:    Tuple         =			model(__lowerCAmelCase						, labels=__lowerCAmelCase		)

         self.parent.assertEqual(result.loss.shape						, ()		)
         self.parent.assertEqual(result.logits.shape						, (self.batch_size, self.type_sequence_label_size)		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Union[str, Any]						, __lowerCAmelCase					:						Any						, __lowerCAmelCase					:						List[Any]						, __lowerCAmelCase					:						Optional[int]						, __lowerCAmelCase					:						List[str]						, __lowerCAmelCase					:						List[str]						, __lowerCAmelCase					:						Dict						, __lowerCAmelCase					:						List[str]						, __lowerCAmelCase					:						Tuple						, __lowerCAmelCase					:						Union[str, Any]						, ):






         """simple docstring"""






         _lowerCamelCase						:    Any         =			self.num_labels
         _lowerCamelCase						:    List[str]         =			FlaubertForTokenClassification(__lowerCAmelCase		)
         model.to(__lowerCAmelCase		)
         model.eval()

         _lowerCamelCase						:    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 						SCREAMING_SNAKE_CASE    (			self					:						Union[str, Any]						, __lowerCAmelCase					:						Any						, __lowerCAmelCase					:						List[str]						, __lowerCAmelCase					:						Dict						, __lowerCAmelCase					:						List[Any]						, __lowerCAmelCase					:						Union[str, Any]						, __lowerCAmelCase					:						List[Any]						, __lowerCAmelCase					:						Dict						, __lowerCAmelCase					:						Dict						, __lowerCAmelCase					:						Optional[Any]						, ):






         """simple docstring"""






         _lowerCamelCase						:    List[str]         =			self.num_choices
         _lowerCamelCase						:    Any         =			FlaubertForMultipleChoice(config=__lowerCAmelCase		)
         model.to(__lowerCAmelCase		)
         model.eval()
         _lowerCamelCase						:    List[str]         =			input_ids.unsqueeze(1		).expand(-1						, self.num_choices						, -1		).contiguous()
         _lowerCamelCase						:    List[str]         =			token_type_ids.unsqueeze(1		).expand(-1						, self.num_choices						, -1		).contiguous()
         _lowerCamelCase						:    List[Any]         =			input_mask.unsqueeze(1		).expand(-1						, self.num_choices						, -1		).contiguous()
         _lowerCamelCase						:    int         =			model(
             __lowerCAmelCase						, attention_mask=__lowerCAmelCase						, token_type_ids=__lowerCAmelCase						, labels=__lowerCAmelCase						, )
         self.parent.assertEqual(result.logits.shape						, (self.batch_size, self.num_choices)		)




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






         """simple docstring"""






         _lowerCamelCase						:    Any         =			self.prepare_config_and_inputs()
         (
             (
             _lowerCamelCase
         )      ,   (
             _lowerCamelCase
         )      ,   (
             _lowerCamelCase
         )      ,   (
             _lowerCamelCase
         )      ,   (
             _lowerCamelCase
         )      ,   (
             _lowerCamelCase
         )      ,   (
             _lowerCamelCase
         )      ,   (
             _lowerCamelCase
         )      ,   (
             _lowerCamelCase
         )      ,   
         )						:    Optional[Any]         =			config_and_inputs
         _lowerCamelCase						:    int         =			{
             '''input_ids''': input_ids,
             '''token_type_ids''': token_type_ids,
             '''lengths''': input_lengths,
             '''attention_mask''': input_mask,
         }
         return config, inputs_dict






@require_torch
class 	__snake_case	(     _lowercase  ,					_lowercase  ,					unittest.TestCase):
  snake_case__    :       List[str]        =						(
      (
          FlaubertModel,
          FlaubertWithLMHeadModel,
          FlaubertForQuestionAnswering,
          FlaubertForQuestionAnsweringSimple,
          FlaubertForSequenceClassification,
          FlaubertForTokenClassification,
          FlaubertForMultipleChoice,
      )
      if is_torch_available()
      else ()
  )
  snake_case__    :       List[Any]        =						(
      {
          "feature-extraction": FlaubertModel,
          "fill-mask": FlaubertWithLMHeadModel,
          "question-answering": FlaubertForQuestionAnsweringSimple,
          "text-classification": FlaubertForSequenceClassification,
          "token-classification": FlaubertForTokenClassification,
          "zero-shot": FlaubertForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )




  def 						SCREAMING_SNAKE_CASE    (			self					:						str						, __lowerCAmelCase					:						List[str]						, __lowerCAmelCase					:						int						, __lowerCAmelCase					:						Dict						, __lowerCAmelCase					:						Optional[int]						, __lowerCAmelCase					:						Tuple		):






         """simple docstring"""






         if (
             pipeline_test_casse_name == "QAPipelineTests"
             and tokenizer_name is not None
             and not tokenizer_name.endswith('''Fast'''		)
         ):
                # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
                # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
                # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
                return True

         return False




  def 						SCREAMING_SNAKE_CASE    (			self					:						Dict						, __lowerCAmelCase					:						int						, __lowerCAmelCase					:						int						, __lowerCAmelCase					:						Optional[int]=False		):






         """simple docstring"""






         _lowerCamelCase						:    Dict         =			super()._prepare_for_class(__lowerCAmelCase						, __lowerCAmelCase						, return_labels=__lowerCAmelCase		)

         if return_labels:
                if model_class.__name__ == "FlaubertForQuestionAnswering":
                       _lowerCamelCase						:    Dict         =			torch.zeros(
                           self.model_tester.batch_size						, dtype=torch.long						, device=__lowerCAmelCase		)
                       _lowerCamelCase						:    Any         =			torch.zeros(
                           self.model_tester.batch_size						, dtype=torch.long						, device=__lowerCAmelCase		)

         return inputs_dict




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[Any]		):






         """simple docstring"""






         _lowerCamelCase						:    int         =			FlaubertModelTester(self		)
         _lowerCamelCase						:    str         =			ConfigTester(self						, config_class=__lowerCAmelCase						, emb_dim=3_7		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[Any]		):






         """simple docstring"""






         self.config_tester.run_common_tests()




  def 						SCREAMING_SNAKE_CASE    (			self					:						int		):






         """simple docstring"""






         _lowerCamelCase						:    Dict         =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_model(*__lowerCAmelCase		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[str]		):






         """simple docstring"""






         _lowerCamelCase						:    Dict         =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_lm_head(*__lowerCAmelCase		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Tuple		):






         """simple docstring"""






         _lowerCamelCase						:    int         =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_simple_qa(*__lowerCAmelCase		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Tuple		):






         """simple docstring"""






         _lowerCamelCase						:    Tuple         =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_qa(*__lowerCAmelCase		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[int]		):






         """simple docstring"""






         _lowerCamelCase						:    Optional[int]         =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_sequence_classif(*__lowerCAmelCase		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Dict		):






         """simple docstring"""






         _lowerCamelCase						:    int         =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_token_classif(*__lowerCAmelCase		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[Any]		):






         """simple docstring"""






         _lowerCamelCase						:    List[Any]         =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_multiple_choice(*__lowerCAmelCase		)




  @slow
  def 						SCREAMING_SNAKE_CASE    (			self					:						Union[str, Any]		):






         """simple docstring"""






         for model_name in FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                _lowerCamelCase						:    Dict         =			FlaubertModel.from_pretrained(__lowerCAmelCase		)
                self.assertIsNotNone(__lowerCAmelCase		)




  @slow
  @require_torch_gpu
  def 						SCREAMING_SNAKE_CASE    (			self					:						Union[str, Any]		):






         """simple docstring"""






         _lowerCamelCase      ,   _lowerCamelCase						:    str         =			self.model_tester.prepare_config_and_inputs_for_common()
         for model_class in self.all_model_classes:
                # FlauBertForMultipleChoice behaves incorrectly in JIT environments.
                if model_class == FlaubertForMultipleChoice:
                       return

                _lowerCamelCase						:    Any         =			True
                _lowerCamelCase						:    int         =			model_class(config=__lowerCAmelCase		)

                _lowerCamelCase						:    List[str]         =			self._prepare_for_class(__lowerCAmelCase						, __lowerCAmelCase		)
                _lowerCamelCase						:    int         =			torch.jit.trace(
                    __lowerCAmelCase						, (inputs_dict['''input_ids'''].to('''cpu'''		), inputs_dict['''attention_mask'''].to('''cpu'''		))		)

                with tempfile.TemporaryDirectory() as tmp:
                       torch.jit.save(__lowerCAmelCase						, os.path.join(__lowerCAmelCase						, '''traced_model.pt'''		)		)
                       _lowerCamelCase						:    Union[str, Any]         =			torch.jit.load(os.path.join(__lowerCAmelCase						, '''traced_model.pt'''		)						, map_location=__lowerCAmelCase		)
                       loaded(inputs_dict['''input_ids'''].to(__lowerCAmelCase		)						, inputs_dict['''attention_mask'''].to(__lowerCAmelCase		)		)






@require_torch
class 	__snake_case	(     unittest.TestCase):




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






         """simple docstring"""






         _lowerCamelCase						:    Union[str, Any]         =			FlaubertModel.from_pretrained('''flaubert/flaubert_base_cased'''		)
         _lowerCamelCase						:    Any         =			torch.tensor([[0, 3_4_5, 2_3_2, 3_2_8, 7_4_0, 1_4_0, 1_6_9_5, 6_9, 6_0_7_8, 1_5_8_8, 2]]		)
         with torch.no_grad():
                _lowerCamelCase						:    Any         =			model(__lowerCAmelCase		)[0]
         _lowerCamelCase						:    Optional[Any]         =			torch.Size((1, 1_1, 7_6_8)		)
         self.assertEqual(output.shape						, __lowerCAmelCase		)
         _lowerCamelCase						:    Optional[int]         =			torch.tensor(
             [[[-2.62_51, -1.42_98, -0.02_27], [-2.85_10, -1.63_87, 0.22_58], [-2.81_14, -1.18_32, -0.30_66]]]		)

         self.assertTrue(torch.allclose(output[:, :3, :3]						, __lowerCAmelCase						, atol=1E-4		)		)


