



"""simple docstring"""





import unittest
from pathlib import Path
from tempfile import NamedTemporaryFile, TemporaryDirectory

from transformers import BertConfig, BertTokenizerFast, FeatureExtractionPipeline
from transformers.convert_graph_to_onnx import (
    convert,
    ensure_valid_input,
    generate_identified_filename,
    infer_shapes,
    quantize,
)
from transformers.testing_utils import require_tf, require_tokenizers, require_torch, slow
class  lowercase__  :







       '''simple docstring'''


       def 	lowercase__							(				self     :    Optional[Any]						,							_UpperCAmelCase     :    Any						,							_UpperCAmelCase     :    str						,							_UpperCAmelCase     :    str       )					->		Dict:


             '''simple docstring'''




             return None



class  lowercase__  :







       '''simple docstring'''


       def 	lowercase__							(				self     :    Tuple						,							_UpperCAmelCase     :    Dict						,							_UpperCAmelCase     :    List[Any]						,							_UpperCAmelCase     :    List[Any]						,							_UpperCAmelCase     :    Union[str, Any]       )					->		Dict:


             '''simple docstring'''




             return None



class  lowercase__  (       unittest.TestCase ):







       '''simple docstring'''


       UpperCamelCase		=	[
           # (model_name, model_kwargs)
           ('''bert-base-cased''', {}),
           ('''gpt2''', {'''use_cache''': False}),  # We don't support exporting GPT2 past keys anymore
       ]



       @require_tf
       @slow
       def 	lowercase__							(				self     :    Union[str, Any]       )					->		List[Any]:


             '''simple docstring'''




             for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
                   self._test_export(_UpperCAmelCase						,							"tf"						,							12						,							**_UpperCAmelCase       )



       @require_torch
       @slow
       def 	lowercase__							(				self     :    List[str]       )					->		Union[str, Any]:


             '''simple docstring'''




             for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
                   self._test_export(_UpperCAmelCase						,							"pt"						,							12						,							**_UpperCAmelCase       )



       @require_torch
       @slow
       def 	lowercase__							(				self     :    Optional[int]       )					->		Optional[Any]:


             '''simple docstring'''




             from transformers import BertModel

             UpperCAmelCase_     					=				["[UNK]", "[SEP]", "[CLS]", "[PAD]", "[MASK]", "some", "other", "words"]
             with NamedTemporaryFile(mode="w+t"       ) as vocab_file:
                   vocab_file.write("\n".join(_UpperCAmelCase       )       )
                   vocab_file.flush()
                   UpperCAmelCase_     					=				BertTokenizerFast(vocab_file.name       )

             with TemporaryDirectory() as bert_save_dir:
                   UpperCAmelCase_     					=				BertModel(BertConfig(vocab_size=len(_UpperCAmelCase       )       )       )
                   model.save_pretrained(_UpperCAmelCase       )
                   self._test_export(_UpperCAmelCase						,							"pt"						,							12						,							_UpperCAmelCase       )



       @require_tf
       @slow
       def 	lowercase__							(				self     :    str       )					->		Any:


             '''simple docstring'''




             for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
                   UpperCAmelCase_     					=				self._test_export(_UpperCAmelCase						,							"tf"						,							12						,							**_UpperCAmelCase       )
                   UpperCAmelCase_     					=				quantize(Path(_UpperCAmelCase       )       )

                   # Ensure the actual quantized model is not bigger than the original one
                   if quantized_path.stat().st_size >= Path(_UpperCAmelCase       ).stat().st_size:
                         self.fail("Quantized model is bigger than initial ONNX model"       )



       @require_torch
       @slow
       def 	lowercase__							(				self     :    Union[str, Any]       )					->		List[str]:


             '''simple docstring'''




             for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
                   UpperCAmelCase_     					=				self._test_export(_UpperCAmelCase						,							"pt"						,							12						,							**_UpperCAmelCase       )
                   UpperCAmelCase_     					=				quantize(_UpperCAmelCase       )

                   # Ensure the actual quantized model is not bigger than the original one
                   if quantized_path.stat().st_size >= Path(_UpperCAmelCase       ).stat().st_size:
                         self.fail("Quantized model is bigger than initial ONNX model"       )



       def 	lowercase__							(				self     :    Optional[Any]						,							_UpperCAmelCase     :    List[Any]						,							_UpperCAmelCase     :    str						,							_UpperCAmelCase     :    List[str]						,							_UpperCAmelCase     :    List[Any]=None						,							**_UpperCAmelCase     :    Dict       )					->		Optional[Any]:


             '''simple docstring'''




             try:
                   # Compute path
                   with TemporaryDirectory() as tempdir:
                         UpperCAmelCase_     					=				Path(_UpperCAmelCase       ).joinpath("model.onnx"       )

                   # Remove folder if exists
                   if path.parent.exists():
                         path.parent.rmdir()

                   # Export
                   convert(_UpperCAmelCase						,							_UpperCAmelCase						,							_UpperCAmelCase						,							_UpperCAmelCase						,							_UpperCAmelCase						,							**_UpperCAmelCase       )

                   return path
             except Exception as e:
                   self.fail(_UpperCAmelCase       )



       @require_torch
       @require_tokenizers
       @slow
       def 	lowercase__							(				self     :    Optional[int]       )					->		List[Any]:


             '''simple docstring'''




             from transformers import BertModel

             UpperCAmelCase_     					=				BertModel(BertConfig.from_pretrained("lysandre/tiny-bert-random"       )       )
             UpperCAmelCase_     					=				BertTokenizerFast.from_pretrained("lysandre/tiny-bert-random"       )
             self._test_infer_dynamic_axis(_UpperCAmelCase						,							_UpperCAmelCase						,							"pt"       )



       @require_tf
       @require_tokenizers
       @slow
       def 	lowercase__							(				self     :    Optional[Any]       )					->		List[Any]:


             '''simple docstring'''




             from transformers import TFBertModel

             UpperCAmelCase_     					=				TFBertModel(BertConfig.from_pretrained("lysandre/tiny-bert-random"       )       )
             UpperCAmelCase_     					=				BertTokenizerFast.from_pretrained("lysandre/tiny-bert-random"       )
             self._test_infer_dynamic_axis(_UpperCAmelCase						,							_UpperCAmelCase						,							"tf"       )



       def 	lowercase__							(				self     :    Tuple						,							_UpperCAmelCase     :    Union[str, Any]						,							_UpperCAmelCase     :    Union[str, Any]						,							_UpperCAmelCase     :    List[Any]       )					->		int:


             '''simple docstring'''




             UpperCAmelCase_     					=				FeatureExtractionPipeline(_UpperCAmelCase						,							_UpperCAmelCase       )

             UpperCAmelCase_     					=				["input_ids", "token_type_ids", "attention_mask", "output_0", "output_1"]
             UpperCAmelCase_					,       UpperCAmelCase_					,       UpperCAmelCase_					,       UpperCAmelCase_     					=				infer_shapes(_UpperCAmelCase						,							_UpperCAmelCase       )

             # Assert all variables are present
             self.assertEqual(len(_UpperCAmelCase       )						,							len(_UpperCAmelCase       )       )
             self.assertTrue(all(var_name in shapes for var_name in variable_names       )       )
             self.assertSequenceEqual(variable_names[:3]						,							_UpperCAmelCase       )
             self.assertSequenceEqual(variable_names[3:]						,							_UpperCAmelCase       )

             # Assert inputs are {0: batch, 1: sequence}
             for var_name in ["input_ids", "token_type_ids", "attention_mask"]:
                   self.assertDictEqual(shapes[var_name]						,							{0: "batch", 1: "sequence"}       )

             # Assert outputs are {0: batch, 1: sequence} and {0: batch}
             self.assertDictEqual(shapes["output_0"]						,							{0: "batch", 1: "sequence"}       )
             self.assertDictEqual(shapes["output_1"]						,							{0: "batch"}       )



       def 	lowercase__							(				self     :    Any       )					->		List[Any]:


             '''simple docstring'''




             UpperCAmelCase_     					=				["input_ids", "attention_mask", "token_type_ids"]
             UpperCAmelCase_     					=				{"input_ids": [1, 2, 3, 4], "attention_mask": [0, 0, 0, 0], "token_type_ids": [1, 1, 1, 1]}
             UpperCAmelCase_					,       UpperCAmelCase_     					=				ensure_valid_input(FuncContiguousArgs()						,							_UpperCAmelCase						,							_UpperCAmelCase       )

             # Should have exactly the same number of args (all are valid)
             self.assertEqual(len(_UpperCAmelCase       )						,							3       )

             # Should have exactly the same input names
             self.assertEqual(set(_UpperCAmelCase       )						,							set(_UpperCAmelCase       )       )

             # Parameter should be reordered according to their respective place in the function:
             # (input_ids, token_type_ids, attention_mask)
             self.assertEqual(_UpperCAmelCase						,							(tokens["input_ids"], tokens["token_type_ids"], tokens["attention_mask"])       )

             # Generated args are interleaved with another args (for instance parameter "past" in GPT2)
             UpperCAmelCase_					,       UpperCAmelCase_     					=				ensure_valid_input(FuncNonContiguousArgs()						,							_UpperCAmelCase						,							_UpperCAmelCase       )

             # Should have exactly the one arg (all before the one not provided "some_other_args")
             self.assertEqual(len(_UpperCAmelCase       )						,							1       )
             self.assertEqual(len(_UpperCAmelCase       )						,							1       )

             # Should have only "input_ids"
             self.assertEqual(inputs_args[0]						,							tokens["input_ids"]       )
             self.assertEqual(ordered_input_names[0]						,							"input_ids"       )







       def 	lowercase__							(				self     :    int       )					->		List[Any]:


             '''simple docstring'''




             UpperCAmelCase_     					=				generate_identified_filename(Path("/home/something/my_fake_model.onnx"       )						,							"-test"       )
             self.assertEqual("/home/something/my_fake_model-test.onnx"						,							generated.as_posix()       )





from __future__ import annotations

import unittest

import numpy as np

from transformers import BlipTextConfig
from transformers.testing_utils import require_tf, slow
from transformers.utils import is_tf_available

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


if is_tf_available():
					import tensorflow as tf

					from transformers import TFBlipTextModel
					from transformers.models.blip.modeling_tf_blip import TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST
class     lowerCAmelCase_     :







							def __init__(   self      :     Any ,			_A      :     int ,			_A      :     int=12 ,			_A      :     int=7 ,			_A      :     Tuple=True ,			_A      :     Optional[int]=True ,			_A      :     Union[str, Any]=True ,			_A      :     str=99 ,			_A      :     str=32 ,			_A      :     int=32 ,			_A      :     Optional[Any]=2 ,			_A      :     Dict=4 ,			_A      :     int=37 ,			_A      :     List[Any]=0.1 ,			_A      :     str=0.1 ,			_A      :     Any=512 ,			_A      :     int=0.02 ,			_A      :     Optional[Any]=0 ,			_A      :     Dict=None ,			):
												_UpperCamelCase			     =     parent
												_UpperCamelCase			     =     batch_size
												_UpperCamelCase			     =     seq_length
												_UpperCamelCase			     =     is_training
												_UpperCamelCase			     =     use_input_mask
												_UpperCamelCase			     =     use_labels
												_UpperCamelCase			     =     vocab_size
												_UpperCamelCase			     =     hidden_size
												_UpperCamelCase			     =     projection_dim
												_UpperCamelCase			     =     num_hidden_layers
												_UpperCamelCase			     =     num_attention_heads
												_UpperCamelCase			     =     intermediate_size
												_UpperCamelCase			     =     dropout
												_UpperCamelCase			     =     attention_dropout
												_UpperCamelCase			     =     max_position_embeddings
												_UpperCamelCase			     =     initializer_range
												_UpperCamelCase			     =     scope
												_UpperCamelCase			     =     bos_token_id







							def  UpperCamelCase_						(   self      :     List[str]		):
												_UpperCamelCase			     =     ids_tensor([self.batch_size, self.seq_length] ,			self.vocab_size		)

												_UpperCamelCase			     =     None
												if self.use_input_mask:
																	_UpperCamelCase			     =     random_attention_mask([self.batch_size, self.seq_length]		)

												if input_mask is not None:
																	_UpperCamelCase			     =     input_mask.numpy()
																	_UpperCamelCase     ,    _UpperCamelCase			     =     input_mask.shape
																	_UpperCamelCase			     =     np.random.randint(1 ,			seq_length - 1 ,			size=(batch_size,)		)
																	for batch_idx, start_index in enumerate(_A		):
																						_UpperCamelCase			     =     1
																						_UpperCamelCase			     =     0

												_UpperCamelCase			     =     self.get_config()

												return config, input_ids, tf.convert_to_tensor(_A		)







							def  UpperCamelCase_						(   self      :     str		):
												return BlipTextConfig(
												    vocab_size=self.vocab_size ,			hidden_size=self.hidden_size ,			projection_dim=self.projection_dim ,			num_hidden_layers=self.num_hidden_layers ,			num_attention_heads=self.num_attention_heads ,			intermediate_size=self.intermediate_size ,			dropout=self.dropout ,			attention_dropout=self.attention_dropout ,			max_position_embeddings=self.max_position_embeddings ,			initializer_range=self.initializer_range ,			bos_token_id=self.bos_token_id ,			)







							def  UpperCamelCase_						(   self      :     List[str] ,			_A      :     Tuple ,			_A      :     str ,			_A      :     Optional[Any]		):
												_UpperCamelCase			     =     TFBlipTextModel(config=_A		)
												_UpperCamelCase			     =     model(_A ,			attention_mask=_A ,			training=_A		)
												_UpperCamelCase			     =     model(_A ,			training=_A		)
												self.parent.assertEqual(result.last_hidden_state.shape ,			(self.batch_size, self.seq_length, self.hidden_size)		)
												self.parent.assertEqual(result.pooler_output.shape ,			(self.batch_size, self.hidden_size)		)







							def  UpperCamelCase_						(   self      :     Tuple		):
												_UpperCamelCase			     =     self.prepare_config_and_inputs()
												_UpperCamelCase     ,    _UpperCamelCase     ,    _UpperCamelCase			     =     config_and_inputs
												_UpperCamelCase			     =     {'''input_ids''': input_ids, '''attention_mask''': input_mask}
												return config, inputs_dict




@require_tf
class     lowerCAmelCase_     (       __lowercase,  unittest.TestCase ):
							UpperCAmelCase				   =     (TFBlipTextModel,) if is_tf_available() else ()
							UpperCAmelCase				   =     False
							UpperCAmelCase				   =     False
							UpperCAmelCase				   =     False







							def  UpperCamelCase_						(   self      :     Dict		):
												_UpperCamelCase			     =     BlipTextModelTester(self		)
												_UpperCamelCase			     =     ConfigTester(self ,			config_class=_A ,			hidden_size=37		)







							def  UpperCamelCase_						(   self      :     Dict		):
												self.config_tester.run_common_tests()







							def  UpperCamelCase_						(   self      :     int		):
												_UpperCamelCase			     =     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*_A		)







							def  UpperCamelCase_						(   self      :     List[Any]		):
												pass







							def  UpperCamelCase_						(   self      :     Tuple		):
												pass







							@unittest.skip(reason='''Blip does not use inputs_embeds'''		)
							def  UpperCamelCase_						(   self      :     Dict		):
												pass







							@unittest.skip(reason='''BlipTextModel has no base class and is not available in MODEL_MAPPING'''		)
							def  UpperCamelCase_						(   self      :     Dict		):
												pass







							@unittest.skip(reason='''BlipTextModel has no base class and is not available in MODEL_MAPPING'''		)
							def  UpperCamelCase_						(   self      :     List[str]		):
												pass







							@slow
							def  UpperCamelCase_						(   self      :     Optional[int]		):
												for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	_UpperCamelCase			     =     TFBlipTextModel.from_pretrained(_A		)
																	self.assertIsNotNone(_A		)







							def  UpperCamelCase_						(   self      :     int ,			_A      :     Optional[int]=True		):
												super().test_pt_tf_model_equivalence(allow_missing_keys=_A		)
