



import inspect
import unittest

from transformers import BitConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_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 BitBackbone, BitForImageClassification, BitImageProcessor, BitModel
   from transformers.models.bit.modeling_bit import BIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
   from PIL import Image



class     _UpperCAmelCase			:




     def __init__(				self ,						a__ ,						a__=3 ,						a__=3_2 ,						a__=3 ,						a__=1_0 ,						a__=[8, 1_6, 3_2, 6_4] ,						a__=[1, 1, 2, 1] ,						a__=True ,						a__=True ,						a__="relu" ,						a__=3 ,						a__=None ,						a__=["stage2", "stage3", "stage4"] ,						a__=[2, 3, 4] ,						a__=1 ,						):
         A__		 =					parent
         A__		 =					batch_size
         A__		 =					image_size
         A__		 =					num_channels
         A__		 =					embeddings_size
         A__		 =					hidden_sizes
         A__		 =					depths
         A__		 =					is_training
         A__		 =					use_labels
         A__		 =					hidden_act
         A__		 =					num_labels
         A__		 =					scope
         A__		 =					len(__UpperCamelCase)
         A__		 =					out_features
         A__		 =					out_indices
         A__		 =					num_groups




     def 		snake_case_		(				self):
         A__		 =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

         A__		 =					None
         if self.use_labels:
             A__		 =					ids_tensor([self.batch_size] ,						self.num_labels)

         A__		 =					self.get_config()

         return config, pixel_values, labels




     def 		snake_case_		(				self):
         return BitConfig(
             num_channels=self.num_channels ,						embeddings_size=self.embeddings_size ,						hidden_sizes=self.hidden_sizes ,						depths=self.depths ,						hidden_act=self.hidden_act ,						num_labels=self.num_labels ,						out_features=self.out_features ,						out_indices=self.out_indices ,						num_groups=self.num_groups ,						)




     def 		snake_case_		(				self ,						a__ ,						a__ ,						a__):
         A__		 =					BitModel(config=__UpperCamelCase)
         model.to(__UpperCamelCase)
         model.eval()
         A__		 =					model(__UpperCamelCase)
         self.parent.assertEqual(
             result.last_hidden_state.shape ,						(self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2) ,						)




     def 		snake_case_		(				self ,						a__ ,						a__ ,						a__):
         A__		 =					self.num_labels
         A__		 =					BitForImageClassification(__UpperCamelCase)
         model.to(__UpperCamelCase)
         model.eval()
         A__		 =					model(__UpperCamelCase ,						labels=__UpperCamelCase)
         self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.num_labels))




     def 		snake_case_		(				self ,						a__ ,						a__ ,						a__):
         A__		 =					BitBackbone(config=__UpperCamelCase)
         model.to(__UpperCamelCase)
         model.eval()
         A__		 =					model(__UpperCamelCase)

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

         # verify channels
         self.parent.assertEqual(len(model.channels) ,						len(config.out_features))
         self.parent.assertListEqual(model.channels ,						config.hidden_sizes[1:])

         # verify backbone works with out_features=None
         A__		 =					None
         A__		 =					BitBackbone(config=__UpperCamelCase)
         model.to(__UpperCamelCase)
         model.eval()
         A__		 =					model(__UpperCamelCase)

         # verify feature maps
         self.parent.assertEqual(len(result.feature_maps) ,						1)
         self.parent.assertListEqual(list(result.feature_maps[0].shape) ,						[self.batch_size, self.hidden_sizes[-1], 1, 1])

         # verify channels
         self.parent.assertEqual(len(model.channels) ,						1)
         self.parent.assertListEqual(model.channels ,						[config.hidden_sizes[-1]])




     def 		snake_case_		(				self):
         A__		 =					self.prepare_config_and_inputs()
         A__ ,	A__ ,	A__		 =					config_and_inputs
         A__		 =					{'''pixel_values''': pixel_values}
         return config, inputs_dict







@require_torch
class     _UpperCAmelCase			(       __snake_case			,      __snake_case			,      unittest.TestCase     ):
     UpperCamelCase__					    =				(BitModel, BitForImageClassification, BitBackbone) if is_torch_available() else ()
     UpperCamelCase__					    =				(
         {'''feature-extraction''': BitModel, '''image-classification''': BitForImageClassification}
         if is_torch_available()
         else {}
     )

     UpperCamelCase__					    =				False
     UpperCamelCase__					    =				False
     UpperCamelCase__					    =				False
     UpperCamelCase__					    =				False
     UpperCamelCase__					    =				False




     def 		snake_case_		(				self):
         A__		 =					BitModelTester(self)
         A__		 =					ConfigTester(self ,						config_class=__UpperCamelCase ,						has_text_modality=__UpperCamelCase)




     def 		snake_case_		(				self):
         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 		snake_case_		(				self):
         return




     @unittest.skip(reason='''Bit does not output attentions''')
     def 		snake_case_		(				self):
         pass




     @unittest.skip(reason='''Bit does not use inputs_embeds''')
     def 		snake_case_		(				self):
         pass




     @unittest.skip(reason='''Bit does not support input and output embeddings''')
     def 		snake_case_		(				self):
         pass




     def 		snake_case_		(				self):
         A__ ,	A__		 =					self.model_tester.prepare_config_and_inputs_for_common()

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

             A__		 =					['''pixel_values''']
             self.assertListEqual(arg_names[:1] ,						__UpperCamelCase)




     def 		snake_case_		(				self):
         A__		 =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__UpperCamelCase)




     def 		snake_case_		(				self):
         A__		 =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_backbone(*__UpperCamelCase)




     def 		snake_case_		(				self):
         A__ ,	A__		 =					self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             A__		 =					model_class(config=__UpperCamelCase)
             for name, module in model.named_modules():
                 if isinstance(__UpperCamelCase ,						(nn.BatchNormad, nn.GroupNorm)):
                     self.assertTrue(
                         torch.all(module.weight == 1) ,						msg=F"Parameter {name} of model {model_class} seems not properly initialized" ,						)
                     self.assertTrue(
                         torch.all(module.bias == 0) ,						msg=F"Parameter {name} of model {model_class} seems not properly initialized" ,						)




     def 		snake_case_		(				self):


         def check_hidden_states_output(a__ ,						a__ ,						a__):
             A__		 =					model_class(__UpperCamelCase)
             model.to(__UpperCamelCase)
             model.eval()

             with torch.no_grad():
                 A__		 =					model(**self._prepare_for_class(__UpperCamelCase ,						__UpperCamelCase))

             A__		 =					outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

             A__		 =					self.model_tester.num_stages
             self.assertEqual(len(__UpperCamelCase) ,						expected_num_stages + 1)

             # Bit's feature maps are of shape (batch_size, num_channels, height, width)
             self.assertListEqual(
                 list(hidden_states[0].shape[-2:]) ,						[self.model_tester.image_size // 4, self.model_tester.image_size // 4] ,						)

         A__ ,	A__		 =					self.model_tester.prepare_config_and_inputs_for_common()
         A__		 =					['''preactivation''', '''bottleneck''']
         for model_class in self.all_model_classes:
             for layer_type in layers_type:
                 A__		 =					layer_type
                 A__		 =					True
                 check_hidden_states_output(__UpperCamelCase ,						__UpperCamelCase ,						__UpperCamelCase)

                 # check that output_hidden_states also work using config
                 del inputs_dict["output_hidden_states"]
                 A__		 =					True

                 check_hidden_states_output(__UpperCamelCase ,						__UpperCamelCase ,						__UpperCamelCase)




     @unittest.skip(reason='''Bit does not use feedforward chunking''')
     def 		snake_case_		(				self):
         pass




     def 		snake_case_		(				self):
         A__		 =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase)




     @slow
     def 		snake_case_		(				self):


         for model_name in BIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             A__		 =					BitModel.from_pretrained(__UpperCamelCase)
             self.assertIsNotNone(__UpperCamelCase)







def 		lowerCAmelCase__    (					)->  List[str]:
    A__		 =					Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
    return image



@require_torch
@require_vision
class     _UpperCAmelCase			(       unittest.TestCase     ):




     @cached_property
     def 		snake_case_		(				self):
         return (
             BitImageProcessor.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]) if is_vision_available() else None
         )




     @slow
     def 		snake_case_		(				self):
         A__		 =					BitForImageClassification.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]).to(__UpperCamelCase)

         A__		 =					self.default_image_processor
         A__		 =					prepare_img()
         A__		 =					image_processor(images=__UpperCamelCase ,						return_tensors='''pt''').to(__UpperCamelCase)

         # forward pass
         with torch.no_grad():
             A__		 =					model(**__UpperCamelCase)

         # verify the logits
         A__		 =					torch.Size((1, 1_0_0_0))
         self.assertEqual(outputs.logits.shape ,						__UpperCamelCase)

         A__		 =					torch.tensor([[-0.6_5_2_6, -0.5_2_6_3, -1.4_3_9_8]]).to(__UpperCamelCase)

         self.assertTrue(torch.allclose(outputs.logits[0, :3] ,						__UpperCamelCase ,						atol=1e-4))







@require_torch
class     _UpperCAmelCase			(       __snake_case			,      unittest.TestCase     ):
     UpperCamelCase__					    =				(BitBackbone,) if is_torch_available() else ()
     UpperCamelCase__					    =				BitConfig

     UpperCamelCase__					    =				False




     def 		snake_case_		(				self):
         A__		 =					BitModelTester(self)





from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
   import numpy as np
   import tensorflow as tf

   from transformers import (
       TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
       FlaubertConfig,
       TFFlaubertForMultipleChoice,
       TFFlaubertForQuestionAnsweringSimple,
       TFFlaubertForSequenceClassification,
       TFFlaubertForTokenClassification,
       TFFlaubertModel,
       TFFlaubertWithLMHeadModel,
   )



class     _UpperCAmelCase			:




     def __init__(				self ,						a__ ,						):
         A__		 =					parent
         A__		 =					1_3
         A__		 =					7
         A__		 =					True
         A__		 =					True
         A__		 =					True
         A__		 =					True
         A__		 =					True
         A__		 =					False
         A__		 =					False
         A__		 =					False
         A__		 =					2
         A__		 =					9_9
         A__		 =					0
         A__		 =					3_2
         A__		 =					2
         A__		 =					4
         A__		 =					0.1
         A__		 =					0.1
         A__		 =					5_1_2
         A__		 =					1_6
         A__		 =					2
         A__		 =					0.0_2
         A__		 =					3
         A__		 =					4
         A__		 =					'''last'''
         A__		 =					True
         A__		 =					None
         A__		 =					0




     def 		snake_case_		(				self):
         A__		 =					ids_tensor([self.batch_size, self.seq_length] ,						self.vocab_size)
         A__		 =					random_attention_mask([self.batch_size, self.seq_length] ,						dtype=tf.floataa)

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

         A__		 =					None
         if self.use_token_type_ids:
             A__		 =					ids_tensor([self.batch_size, self.seq_length] ,						self.n_langs)

         A__		 =					None
         A__		 =					None
         A__		 =					None
         if self.use_labels:
             A__		 =					ids_tensor([self.batch_size] ,						self.type_sequence_label_size)
             A__		 =					ids_tensor([self.batch_size, self.seq_length] ,						self.num_labels)
             A__		 =					ids_tensor([self.batch_size] ,						2 ,						dtype=tf.floataa)
             A__		 =					ids_tensor([self.batch_size] ,						self.num_choices)

         A__		 =					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 ,						bos_token_id=self.bos_token_id ,						)

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




     def 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						):
         A__		 =					TFFlaubertModel(config=a__)
         A__		 =					{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
         A__		 =					model(a__)

         A__		 =					[input_ids, input_mask]
         A__		 =					model(a__)
         self.parent.assertEqual(result.last_hidden_state.shape ,						(self.batch_size, self.seq_length, self.hidden_size))




     def 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						):
         A__		 =					TFFlaubertWithLMHeadModel(a__)

         A__		 =					{'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
         A__		 =					model(a__)

         self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.seq_length, self.vocab_size))




     def 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						):
         A__		 =					TFFlaubertForQuestionAnsweringSimple(a__)

         A__		 =					{'''input_ids''': input_ids, '''lengths''': input_lengths}

         A__		 =					model(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 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						):
         A__		 =					TFFlaubertForSequenceClassification(a__)

         A__		 =					{'''input_ids''': input_ids, '''lengths''': input_lengths}

         A__		 =					model(a__)

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




     def 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						):
         A__		 =					self.num_labels
         A__		 =					TFFlaubertForTokenClassification(config=a__)
         A__		 =					{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
         A__		 =					model(a__)
         self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.seq_length, self.num_labels))




     def 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						a__ ,						):
         A__		 =					self.num_choices
         A__		 =					TFFlaubertForMultipleChoice(config=a__)
         A__		 =					tf.tile(tf.expand_dims(a__ ,						1) ,						(1, self.num_choices, 1))
         A__		 =					tf.tile(tf.expand_dims(a__ ,						1) ,						(1, self.num_choices, 1))
         A__		 =					tf.tile(tf.expand_dims(a__ ,						1) ,						(1, self.num_choices, 1))
         A__		 =					{
             '''input_ids''': multiple_choice_inputs_ids,
             '''attention_mask''': multiple_choice_input_mask,
             '''token_type_ids''': multiple_choice_token_type_ids,
         }
         A__		 =					model(a__)
         self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.num_choices))




     def 		snake_case_		(				self):
         A__		 =					self.prepare_config_and_inputs()
         (
             (
             A__
         ) ,	(
             A__
         ) ,	(
             A__
         ) ,	(
             A__
         ) ,	(
             A__
         ) ,	(
             A__
         ) ,	(
             A__
         ) ,	(
             A__
         ) ,	(
             A__
         ) ,	
         )		 =					config_and_inputs
         A__		 =					{
             '''input_ids''': input_ids,
             '''token_type_ids''': token_type_ids,
             '''langs''': token_type_ids,
             '''lengths''': input_lengths,
         }
         return config, inputs_dict







@require_tf
class     _UpperCAmelCase			(       A__			,      A__			,      unittest.TestCase     ):
     UpperCamelCase__		    =				(
         (
             TFFlaubertModel,
             TFFlaubertWithLMHeadModel,
             TFFlaubertForSequenceClassification,
             TFFlaubertForQuestionAnsweringSimple,
             TFFlaubertForTokenClassification,
             TFFlaubertForMultipleChoice,
         )
         if is_tf_available()
         else ()
     )
     UpperCamelCase__		    =				(
         (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
     )  # TODO (PVP): Check other models whether language generation is also applicable
     UpperCamelCase__		    =				(
         {
             '''feature-extraction''': TFFlaubertModel,
             '''fill-mask''': TFFlaubertWithLMHeadModel,
             '''question-answering''': TFFlaubertForQuestionAnsweringSimple,
             '''text-classification''': TFFlaubertForSequenceClassification,
             '''token-classification''': TFFlaubertForTokenClassification,
             '''zero-shot''': TFFlaubertForSequenceClassification,
         }
         if is_tf_available()
         else {}
     )
     UpperCamelCase__		    =				False
     UpperCamelCase__		    =				False




     def 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__ ,						a__):
         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 		snake_case_		(				self):
         A__		 =					TFFlaubertModelTester(self)
         A__		 =					ConfigTester(self ,						config_class=a__ ,						emb_dim=3_7)




     def 		snake_case_		(				self):
         self.config_tester.run_common_tests()




     def 		snake_case_		(				self):
         A__		 =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_model(*a__)




     def 		snake_case_		(				self):
         A__		 =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_lm_head(*a__)




     def 		snake_case_		(				self):
         A__		 =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_qa(*a__)




     def 		snake_case_		(				self):
         A__		 =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_sequence_classif(*a__)




     def 		snake_case_		(				self):
         A__		 =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_for_token_classification(*a__)




     def 		snake_case_		(				self):
         A__		 =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_for_multiple_choice(*a__)




     @slow
     def 		snake_case_		(				self):
         for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             A__		 =					TFFlaubertModel.from_pretrained(a__)
             self.assertIsNotNone(a__)







@require_tf
@require_sentencepiece
@require_tokenizers
class     _UpperCAmelCase			(       unittest.TestCase     ):




     @slow
     def 		snake_case_		(				self):
         A__		 =					TFFlaubertModel.from_pretrained('''jplu/tf-flaubert-small-cased''')

         A__		 =					tf.convert_to_tensor(
             [[0, 1_5_8, 7_3_5, 2_5_9_2, 1_4_2_4, 6_7_2_7, 8_2, 1]] ,						dtype=tf.intaa ,						)  # "J'aime flaubert !"

         A__		 =					model(a__)[0]
         A__		 =					tf.TensorShape((1, 8, 5_1_2))
         self.assertEqual(output.shape ,						a__)
         # compare the actual values for a slice.
         A__		 =					tf.convert_to_tensor(
             [
                 [
                     [-1.8_7_6_8_7_7_3, -1.5_6_6_5_5_5, 0.2_7_0_7_2_4_1_8],
                     [-1.6_9_2_0_0_3_8, -0.5_8_7_3_5_0_5, 1.9_3_2_9_5_9_9],
                     [-2.9_5_6_3_9_8_5, -1.6_9_9_3_8_3_5, 1.7_9_7_2_0_5_2],
                 ]
             ] ,						dtype=tf.floataa ,						)

         self.assertTrue(np.allclose(output[:, :3, :3].numpy() ,						expected_slice.numpy() ,						atol=1e-4))
