
"""simple docstring"""





from __future__ import annotations

import unittest

import numpy as np

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

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


if is_tf_available():
				import tensorflow as tf

				from transformers import GPTaTokenizer, TFOPTForCausalLM, TFOPTModel



def 				lowerCamelCase__		(      __snake_case,					__snake_case,					__snake_case=None,					__snake_case=None     )							->		Union[str, Any]:


					"""simple docstring"""





					if attention_mask is None:
										_UpperCamelCase										=  tf.cast(tf.math.not_equal(__snake_case,					config.pad_token_id     ),					tf.inta     )
					return {"input_ids": input_ids, "attention_mask": attention_mask}






@require_tf
class    _UpperCAmelCase:
		lowercase__      =				OPTConfig
		lowercase__      =				{}
		lowercase__      =				'gelu'



		def __init__( self    ,		__a    ,		__a=13    ,		__a=7    ,		__a=True    ,		__a=False    ,		__a=99    ,		__a=16    ,		__a=2    ,		__a=4    ,		__a=4    ,		__a="gelu"    ,		__a=0.1    ,		__a=0.1    ,		__a=20    ,		__a=2    ,		__a=1    ,		__a=0    ,		__a=16    ,		__a=16    ,		)	->	List[Any]:






							'''simple docstring'''
							_UpperCamelCase										=  parent
							_UpperCamelCase										=  batch_size
							_UpperCamelCase										=  seq_length
							_UpperCamelCase										=  is_training
							_UpperCamelCase										=  use_labels
							_UpperCamelCase										=  vocab_size
							_UpperCamelCase										=  hidden_size
							_UpperCamelCase										=  num_hidden_layers
							_UpperCamelCase										=  num_attention_heads
							_UpperCamelCase										=  intermediate_size
							_UpperCamelCase										=  hidden_act
							_UpperCamelCase										=  hidden_dropout_prob
							_UpperCamelCase										=  attention_probs_dropout_prob
							_UpperCamelCase										=  max_position_embeddings
							_UpperCamelCase										=  eos_token_id
							_UpperCamelCase										=  pad_token_id
							_UpperCamelCase										=  bos_token_id
							_UpperCamelCase										=  embed_dim
							_UpperCamelCase										=  word_embed_proj_dim
							_UpperCamelCase										=  False



		def 						UpperCAmelCase							( self)	->	Tuple:






							'''simple docstring'''
							_UpperCamelCase										=  ids_tensor([self.batch_size, self.seq_length - 1]    ,		self.vocab_size)
							_UpperCamelCase										=  tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size)    ,		1)
							_UpperCamelCase										=  tf.concat([input_ids, eos_tensor]    ,		axis=1)

							_UpperCamelCase										=  self.config_cls(
							    vocab_size=self.vocab_size    ,		hidden_size=self.hidden_size    ,		num_hidden_layers=self.num_hidden_layers    ,		num_attention_heads=self.num_attention_heads    ,		ffn_dim=self.intermediate_size    ,		dropout=self.hidden_dropout_prob    ,		attention_dropout=self.attention_probs_dropout_prob    ,		max_position_embeddings=self.max_position_embeddings    ,		eos_token_id=self.eos_token_id    ,		bos_token_id=self.bos_token_id    ,		pad_token_id=self.pad_token_id    ,		embed_dim=self.embed_dim    ,		word_embed_proj_dim=self.word_embed_proj_dim    ,		is_encoder_decoder=__a    ,		**self.config_updates    ,		)
							_UpperCamelCase										=  prepare_opt_inputs_dict(__a    ,		__a)
							return config, inputs_dict




		def 						UpperCAmelCase							( self    ,		__a    ,		__a)	->	Any:






							'''simple docstring'''
							_UpperCamelCase										=  TFOPTModel(config=__a)
							_UpperCamelCase										=  inputs_dict['''input_ids''']

							_UpperCamelCase										=  input_ids[:1, :]
							_UpperCamelCase										=  inputs_dict['''attention_mask'''][:1, :]
							_UpperCamelCase										=  1

							# first forward pass
							_UpperCamelCase										=  model(__a    ,		attention_mask=__a    ,		use_cache=__a)

							_UpperCamelCase			,  _UpperCamelCase										=  outputs.to_tuple()

							# create hypothetical next token and extent to next_input_ids
							_UpperCamelCase										=  ids_tensor((self.batch_size, 3)    ,		config.vocab_size)
							_UpperCamelCase										=  tf.cast(ids_tensor((self.batch_size, 3)    ,		2)    ,		tf.inta)

							# append to next input_ids and
							_UpperCamelCase										=  tf.concat([input_ids, next_tokens]    ,		axis=-1)
							_UpperCamelCase										=  tf.concat([attention_mask, next_attn_mask]    ,		axis=-1)

							_UpperCamelCase										=  model(__a    ,		attention_mask=__a)[0]
							_UpperCamelCase										=  model(__a    ,		attention_mask=__a    ,		past_key_values=__a)[0]

							self.parent.assertEqual(next_tokens.shape[1]    ,		output_from_past.shape[1])

							# select random slice
							_UpperCamelCase										=  int(ids_tensor((1,)    ,		output_from_past.shape[-1]))
							_UpperCamelCase										=  output_from_no_past[:, -3:, random_slice_idx]
							_UpperCamelCase										=  output_from_past[:, :, random_slice_idx]

							# test that outputs are equal for slice
							tf.debugging.assert_near(__a    ,		__a    ,		rtol=1e-3)






@require_tf
class    _UpperCAmelCase(   lowerCamelCase				,					lowerCamelCase				,					unittest.TestCase     ):
		lowercase__      =				(TFOPTModel, TFOPTForCausalLM) if is_tf_available() else ()
		lowercase__      =				(TFOPTForCausalLM,) if is_tf_available() else ()
		lowercase__      =				(
		    {'feature-extraction': TFOPTModel, 'text-generation': TFOPTForCausalLM} if is_tf_available() else {}
		)
		lowercase__      =				False
		lowercase__      =				False
		lowercase__      =				False
		lowercase__      =				10



		def 						UpperCAmelCase							( self)	->	Any:






							'''simple docstring'''
							_UpperCamelCase										=  TFOPTModelTester(self)
							_UpperCamelCase										=  ConfigTester(self    ,		config_class=__a)



		def 						UpperCAmelCase							( self)	->	str:






							'''simple docstring'''
							self.config_tester.run_common_tests()



		def 						UpperCAmelCase							( self)	->	int:






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.check_decoder_model_past_large_inputs(*__a)




		def 						UpperCAmelCase							( self)	->	Tuple:






							'''simple docstring'''
							_UpperCamelCase			,  _UpperCamelCase										=  self.model_tester.prepare_config_and_inputs_for_common()

							def _get_word_embedding_weight(__a    ,		__a):
												if hasattr(__a    ,		'''weight'''):
																	return embedding_layer.weight
												else:
																	# Here we build the word embeddings weights if not exists.
																	# And then we retry to get the attribute once built.
																	model.build()
																	if hasattr(__a    ,		'''weight'''):
																						return embedding_layer.weight
																	else:
																						return None

							for model_class in self.all_model_classes:
												for size in [config.vocab_size - 10, config.vocab_size + 10]:
																	# build the embeddings
																	_UpperCamelCase										=  model_class(config=__a)
																	_UpperCamelCase										=  _get_word_embedding_weight(__a    ,		model.get_input_embeddings())
																	_UpperCamelCase										=  _get_word_embedding_weight(__a    ,		model.get_output_embeddings())

																	# reshape the embeddings
																	model.resize_token_embeddings(__a)
																	_UpperCamelCase										=  _get_word_embedding_weight(__a    ,		model.get_input_embeddings())
																	_UpperCamelCase										=  _get_word_embedding_weight(__a    ,		model.get_output_embeddings())

																	# check that the resized embeddings size matches the desired size.
																	_UpperCamelCase										=  size if size is not None else config.vocab_size

																	self.assertEqual(new_input_embeddings.shape[0]    ,		__a)

																	# check that weights remain the same after resizing
																	_UpperCamelCase										=  True
																	for pa, pa in zip(old_input_embeddings.value()    ,		new_input_embeddings.value()):
																						if tf.math.reduce_sum(tf.math.abs(pa - pa)) > 0:
																											_UpperCamelCase										=  False
																	self.assertTrue(__a)

																	if old_output_embeddings is not None and new_output_embeddings is not None:
																						self.assertEqual(new_output_embeddings.shape[0]    ,		__a)

																						_UpperCamelCase										=  True
																						for pa, pa in zip(old_output_embeddings.value()    ,		new_output_embeddings.value()):
																											if tf.math.reduce_sum(tf.math.abs(pa - pa)) > 0:
																																_UpperCamelCase										=  False
																						self.assertTrue(__a)





def 				lowerCamelCase__		(      __snake_case     )							->		Optional[int]:


					"""simple docstring"""





					return tf.constant(__snake_case,					dtype=tf.intaa     )






@require_tf
class    _UpperCAmelCase(   unittest.TestCase     ):
		lowercase__      =				99



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






							'''simple docstring'''
							_UpperCamelCase										=  tf.ones((4, 1)    ,		dtype=tf.intaa) * 2
							_UpperCamelCase										=  tf.concat([ids_tensor((4, 6)    ,		self.vocab_size - 3) + 3, eos_column_vector]    ,		axis=1)
							_UpperCamelCase										=  input_ids.shape[0]
							_UpperCamelCase										=  OPTConfig(
							    vocab_size=self.vocab_size    ,		hidden_size=24    ,		num_hidden_layers=2    ,		num_attention_heads=2    ,		ffn_dim=32    ,		max_position_embeddings=48    ,		eos_token_id=2    ,		pad_token_id=1    ,		bos_token_id=0    ,		)
							return config, input_ids, batch_size






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



		@slow
		def 						UpperCAmelCase							( self)	->	Optional[int]:






							'''simple docstring'''
							_UpperCamelCase										=  TFOPTModel.from_pretrained('''facebook/opt-350m''')
							_UpperCamelCase										=  _long_tensor([[0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 4_60_78, 15_88, 2]])
							_UpperCamelCase										=  tf.not_equal(__a    ,		model.config.pad_token_id)
							with tf.GradientTape():
												_UpperCamelCase										=  model(input_ids=__a    ,		attention_mask=__a).last_hidden_state
							_UpperCamelCase										=  (1, 11, 5_12)
							self.assertEqual(output.shape    ,		__a)
							_UpperCamelCase										=  tf.constant(
							    [[-0.2873, -1.9218, -0.3033], [-1.2710, -0.1338, -0.1902], [0.4095, 0.1214, -1.3121]])
							self.assertTrue(np.allclose(output[:, :3, :3]    ,		__a    ,		atol=4e-3))

							_UpperCamelCase										=  tf.function(__a    ,		jit_compile=__a)
							_UpperCamelCase										=  xla_generate(__a    ,		__a)[0]
							self.assertTrue(np.allclose(output[:, :3, :3]    ,		__a    ,		atol=4e-2))






@require_tf
@slow
class    _UpperCAmelCase(   unittest.TestCase     ):



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






							'''simple docstring'''
							super().setUp()
							_UpperCamelCase										=  '''facebook/opt-350m'''




		def 						UpperCAmelCase							( self)	->	Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase										=  TFOPTForCausalLM.from_pretrained(self.path_model)
							_UpperCamelCase										=  GPTaTokenizer.from_pretrained(self.path_model)

							_UpperCamelCase										=  [
							    '''Today is a beautiful day and I want to''',
							    '''In the city of''',
							    '''Paris is the capital of France and''',
							    '''Computers and mobile phones have taken''',
							]
							# verify that prompt without BOS token is identical to Metaseq -> add_special_tokens=False
							_UpperCamelCase										=  tokenizer(__a    ,		return_tensors='''tf'''    ,		padding=__a    ,		add_special_tokens=__a)
							_UpperCamelCase										=  tf.math.reduce_mean(model(inputs.input_ids    ,		attention_mask=inputs.attention_mask)[0]    ,		axis=-1)
							_UpperCamelCase										=  tf.constant(
							    [
							        [1.3851, -13.8923, -10.5229, -10.7533, -0.2309, -10.2384, -0.5365, -9.0947, -5.1670],
							        [-4.7073, -10.6276, -3.9415, -21.5242, -0.2822, -0.2822, -0.2822, -0.2822, -0.2822],
							        [0.6247, -3.4229, -8.9179, -1.4297, -14.1650, 1.4146, -9.0218, -0.2703, -0.2703],
							        [6.4783, -1.9913, -10.7926, -2.3336, 1.5092, -0.9974, -6.8213, 1.3477, 1.3477],
							    ])
							self.assertTrue(np.allclose(__a    ,		__a    ,		atol=1e-4))

							_UpperCamelCase										=  tf.function(__a    ,		jit_compile=__a)
							_UpperCamelCase										=  tf.math.reduce_mean(xla_generate(inputs.input_ids    ,		attention_mask=inputs.attention_mask)[0]    ,		axis=-1)
							self.assertTrue(np.allclose(__a    ,		__a    ,		atol=1e-4))






@require_tf
@slow
class    _UpperCAmelCase(   unittest.TestCase     ):



		@property
		def 						UpperCAmelCase							( self)	->	List[Any]:






							'''simple docstring'''
							return [
							    "Today is a beautiful day and I want",
							    "In the city of",
							    "Paris is the capital of France and",
							    "Computers and mobile phones have taken",
							]



		def 						UpperCAmelCase							( self)	->	Optional[Any]:






							'''simple docstring'''
							_UpperCamelCase										=  '''facebook/opt-125m'''

							_UpperCamelCase										=  [
							    '''Today is a beautiful day and I want to''',
							    '''In the city of New York, the city''',
							    '''Paris is the capital of France and the capital''',
							    '''Computers and mobile phones have taken over the''',
							]

							_UpperCamelCase										=  []
							_UpperCamelCase										=  GPTaTokenizer.from_pretrained(__a)
							_UpperCamelCase										=  TFOPTForCausalLM.from_pretrained(__a)

							for prompt in self.prompts:
												_UpperCamelCase										=  tokenizer(__a    ,		return_tensors='''tf''').input_ids

												_UpperCamelCase										=  model.generate(__a    ,		max_length=10)

												_UpperCamelCase										=  tokenizer.batch_decode(__a    ,		skip_special_tokens=__a)
												predicted_outputs += generated_string

							self.assertListEqual(__a    ,		__a)



		def 						UpperCAmelCase							( self)	->	int:






							'''simple docstring'''
							_UpperCamelCase										=  '''facebook/opt-350m'''

							_UpperCamelCase										=  GPTaTokenizer.from_pretrained(__a)
							_UpperCamelCase										=  TFOPTForCausalLM.from_pretrained(__a)

							_UpperCamelCase										=  '''left'''

							# use different length sentences to test batching
							_UpperCamelCase										=  [
							    '''Hello, my dog is a little''',
							    '''Today, I''',
							]

							_UpperCamelCase										=  tokenizer(__a    ,		return_tensors='''tf'''    ,		padding=__a)
							_UpperCamelCase										=  inputs['''input_ids''']

							_UpperCamelCase										=  model.generate(input_ids=__a    ,		attention_mask=inputs['''attention_mask'''])

							_UpperCamelCase										=  tokenizer(sentences[0]    ,		return_tensors='''tf''').input_ids
							_UpperCamelCase										=  model.generate(input_ids=__a)

							_UpperCamelCase										=  inputs_non_padded.shape[-1] - tf.math.reduce_sum(
							    tf.cast(inputs['''attention_mask'''][-1]    ,		tf.intaa))
							_UpperCamelCase										=  tokenizer(sentences[1]    ,		return_tensors='''tf''').input_ids
							_UpperCamelCase										=  model.generate(input_ids=__a    ,		max_length=model.config.max_length - num_paddings)

							_UpperCamelCase										=  tokenizer.batch_decode(__a    ,		skip_special_tokens=__a)
							_UpperCamelCase										=  tokenizer.decode(output_non_padded[0]    ,		skip_special_tokens=__a)
							_UpperCamelCase										=  tokenizer.decode(output_padded[0]    ,		skip_special_tokens=__a)

							_UpperCamelCase										=  [
							    '''Hello, my dog is a little bit of a dork.\nI\'m a little bit''',
							    '''Today, I was in the middle of a conversation with a friend about the''',
							]
							self.assertListEqual(__a    ,		__a)
							self.assertListEqual(__a    ,		[non_padded_sentence, padded_sentence])




		def 						UpperCAmelCase							( self)	->	str:






							'''simple docstring'''
							_UpperCamelCase										=  '''facebook/opt-350m'''

							_UpperCamelCase										=  [
							    '''Today is a beautiful day and I want to''',
							    '''In the city of San Francisco, the city''',
							    '''Paris is the capital of France and the capital''',
							    '''Computers and mobile phones have taken over the''',
							]

							_UpperCamelCase										=  []
							_UpperCamelCase										=  GPTaTokenizer.from_pretrained(__a)
							_UpperCamelCase										=  TFOPTForCausalLM.from_pretrained(__a)

							for prompt in self.prompts:
												_UpperCamelCase										=  tokenizer(__a    ,		return_tensors='''tf''').input_ids

												_UpperCamelCase										=  model.generate(__a    ,		max_length=10)

												_UpperCamelCase										=  tokenizer.batch_decode(__a    ,		skip_special_tokens=__a)
												predicted_outputs += generated_string

							self.assertListEqual(__a    ,		__a)








"""simple docstring"""





import copy
from collections import OrderedDict
from typing import Dict, Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


_a														=		logging.get_logger(__name__)

_a														=		{
    """facebook/detr-resnet-50""": """https://huggingface.co/facebook/detr-resnet-50/resolve/main/config.json""",
    # See all DETR models at https://huggingface.co/models?filter=detr
}






class    _UpperCAmelCase(   lowerCamelCase     ):
		lowercase__      =				'detr'
		lowercase__      =				['past_key_values']
		lowercase__      =				{
		    'hidden_size': 'd_model',
		    'num_attention_heads': 'encoder_attention_heads',
		}



		def __init__( self    ,		__a=True    ,		__a=None    ,		__a=3    ,		__a=1_00    ,		__a=6    ,		__a=20_48    ,		__a=8    ,		__a=6    ,		__a=20_48    ,		__a=8    ,		__a=0.0    ,		__a=0.0    ,		__a=True    ,		__a="relu"    ,		__a=2_56    ,		__a=0.1    ,		__a=0.0    ,		__a=0.0    ,		__a=0.02    ,		__a=1.0    ,		__a=False    ,		__a="sine"    ,		__a="resnet50"    ,		__a=True    ,		__a=False    ,		__a=1    ,		__a=5    ,		__a=2    ,		__a=1    ,		__a=1    ,		__a=5    ,		__a=2    ,		__a=0.1    ,		**__a    ,		)	->	Tuple:






							'''simple docstring'''
							if backbone_config is not None and use_timm_backbone:
												raise ValueError('''You can\'t specify both `backbone_config` and `use_timm_backbone`.''')

							if not use_timm_backbone:
												if backbone_config is None:
																	logger.info('''`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.''')
																	_UpperCamelCase										=  CONFIG_MAPPING['''resnet'''](out_features=['''stage4'''])
												elif isinstance(__a    ,		__a):
																	_UpperCamelCase										=  backbone_config.get('''model_type''')
																	_UpperCamelCase										=  CONFIG_MAPPING[backbone_model_type]
																	_UpperCamelCase										=  config_class.from_dict(__a)
												# set timm attributes to None
												_UpperCamelCase			,  _UpperCamelCase			,  _UpperCamelCase										=  None, None, None

							_UpperCamelCase										=  use_timm_backbone
							_UpperCamelCase										=  backbone_config
							_UpperCamelCase										=  num_channels
							_UpperCamelCase										=  num_queries
							_UpperCamelCase										=  d_model
							_UpperCamelCase										=  encoder_ffn_dim
							_UpperCamelCase										=  encoder_layers
							_UpperCamelCase										=  encoder_attention_heads
							_UpperCamelCase										=  decoder_ffn_dim
							_UpperCamelCase										=  decoder_layers
							_UpperCamelCase										=  decoder_attention_heads
							_UpperCamelCase										=  dropout
							_UpperCamelCase										=  attention_dropout
							_UpperCamelCase										=  activation_dropout
							_UpperCamelCase										=  activation_function
							_UpperCamelCase										=  init_std
							_UpperCamelCase										=  init_xavier_std
							_UpperCamelCase										=  encoder_layerdrop
							_UpperCamelCase										=  decoder_layerdrop
							_UpperCamelCase										=  encoder_layers
							_UpperCamelCase										=  auxiliary_loss
							_UpperCamelCase										=  position_embedding_type
							_UpperCamelCase										=  backbone
							_UpperCamelCase										=  use_pretrained_backbone
							_UpperCamelCase										=  dilation
							# Hungarian matcher
							_UpperCamelCase										=  class_cost
							_UpperCamelCase										=  bbox_cost
							_UpperCamelCase										=  giou_cost
							# Loss coefficients
							_UpperCamelCase										=  mask_loss_coefficient
							_UpperCamelCase										=  dice_loss_coefficient
							_UpperCamelCase										=  bbox_loss_coefficient
							_UpperCamelCase										=  giou_loss_coefficient
							_UpperCamelCase										=  eos_coefficient
							super().__init__(is_encoder_decoder=__a    ,		**__a)



		@property
		def 						UpperCAmelCase							( self)	->	int:






							'''simple docstring'''
							return self.encoder_attention_heads



		@property
		def 						UpperCAmelCase							( self)	->	int:






							'''simple docstring'''
							return self.d_model



		@classmethod
		def 						UpperCAmelCase							( cls    ,		__a    ,		**__a)	->	Any:






							'''simple docstring'''
							return cls(backbone_config=__a    ,		**__a)




		def 						UpperCAmelCase							( self)	->	Dict[str, any]:






							'''simple docstring'''
							_UpperCamelCase										=  copy.deepcopy(self.__dict__)
							if output["backbone_config"] is not None:
												_UpperCamelCase										=  self.backbone_config.to_dict()
							_UpperCamelCase										=  self.__class__.model_type
							return output






class    _UpperCAmelCase(   lowerCamelCase     ):
		lowercase__      =				version.parse('1.11'     )



		@property
		def 						UpperCAmelCase							( self)	->	Mapping[str, Mapping[int, str]]:






							'''simple docstring'''
							return OrderedDict(
							    [
							        ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
							        ('''pixel_mask''', {0: '''batch'''}),
							    ])



		@property
		def 						UpperCAmelCase							( self)	->	float:






							'''simple docstring'''
							return 1e-5




		@property
		def 						UpperCAmelCase							( self)	->	int:






							'''simple docstring'''
							return 12






