


'''simple docstring'''






from __future__ import annotations

import os
import tempfile
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import is_tensorflow_text_available, is_tf_available
from transformers.testing_utils import require_tensorflow_text, require_tf, slow

from ..test_modeling_tf_common import floats_tensor
from .test_framework_agnostic import GenerationIntegrationTestsMixin


if is_tf_available():
		import tensorflow as tf

		from transformers import (
		    AutoTokenizer,
		    TFAutoModelForCausalLM,
		    TFAutoModelForSeqaSeqLM,
		    TFAutoModelForSpeechSeqaSeq,
		    TFAutoModelForVisionaSeq,
		    TFBartForConditionalGeneration,
		    TFLogitsProcessorList,
		    TFMinLengthLogitsProcessor,
		    tf_top_k_top_p_filtering,
		)

if is_tensorflow_text_available():
		import tensorflow_text as text




@require_tf
class 						a__							(				unittest.TestCase    ):





							'''simple docstring'''






							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Tuple:
														lowerCAmelCase__			  =      tf.convert_to_tensor(
														    [
														        [
														            8.2_220_991,  # 3rd highest value; idx. 0
														            -0.5_620_044,
														            5.23_229_752,
														            4.0_386_393,
														            -6.8_798_378,
														            -0.54_785_802,
														            -3.2_012_153,
														            2.92_777_176,
														            1.88_171_953,
														            7.35_341_276,  # 5th highest value; idx. 9
														            8.43_207_833,  # 2nd highest value; idx. 10
														            -9.85_711_836,
														            -5.96_209_236,
														            -1.13_039_161,
														            -7.1_115_294,
														            -0.8_369_633,
														            -5.3_186_408,
														            7.06_427_407,
														            0.81_369_344,
														            -0.82_023_817,
														            -5.9_179_796,
														            0.58_813_443,
														            -6.99_778_438,
														            4.71_551_189,
														            -0.18_771_637,
														            7.44_020_759,  # 4th highest value; idx. 25
														            9.38_450_987,  # 1st highest value; idx. 26
														            2.12_662_941,
														            -9.32_562_038,
														            2.35_652_522,
														        ],  # cummulative prob of 5 highest values <= 0.6
														        [
														            0.58_425_518,
														            4.53_139_238,
														            -5.57_510_464,
														            -6.28_030_699,
														            -7.19_529_503,
														            -4.02_122_551,
														            1.39_337_037,
														            -6.06_707_057,
														            1.59_480_517,
														            -9.643_119,
														            0.03_907_799,
														            0.67_231_762,
														            -8.88_206_726,
														            6.27_115_922,  # 4th highest value; idx. 13
														            2.28_520_723,
														            4.82_767_506,
														            4.30_421_368,
														            8.8_275_313,  # 2nd highest value; idx. 17
														            5.44_029_958,  # 5th highest value; idx. 18
														            -4.4_735_794,
														            7.38_579_536,  # 3rd highest value; idx. 20
														            -2.91_051_663,
														            2.61_946_077,
														            -2.5_674_762,
														            -9.48_959_302,
														            -4.02_922_645,
														            -1.35_416_918,
														            9.67_702_323,  # 1st highest value; idx. 27
														            -5.89_478_553,
														            1.85_370_467,
														        ],  # cummulative prob of 5 highest values <= 0.6
														    ]   ,       dtype=tf.floataa   ,       )

														lowerCAmelCase__			  =      tf.convert_to_tensor(
														    [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]]   ,       dtype=tf.intaa   ,       )  # expected non filtered idx as noted above

														lowerCAmelCase__			  =      tf.convert_to_tensor(
														    [8.222_099, 7.3_534_126, 8.432_078, 7.4_402_075, 9.38_451, 6.271_159, 8.827_531, 5.4_402_995, 7.3_857_956, 9.677_023]   ,       dtype=tf.floataa   ,       )  # expected non filtered values as noted above

														lowerCAmelCase__			  =      tf_top_k_top_p_filtering(lowercase_   ,       top_k=10   ,       top_p=0.6   ,       min_tokens_to_keep=4  )

														lowerCAmelCase__			  =      output[output != -float('''inf'''  )]
														lowerCAmelCase__			  =      tf.cast(
														    tf.where(tf.not_equal(lowercase_   ,       tf.constant(-float('''inf'''  )   ,       dtype=tf.floataa  )  )  )   ,       dtype=tf.intaa   ,       )

														tf.debugging.assert_near(lowercase_   ,       lowercase_   ,       rtol=1e-12  )
														tf.debugging.assert_equal(lowercase_   ,       lowercase_  )




@require_tf
class 						a__							(				unittest.TestCase							,							UpperCamelCase__    ):





							'''simple docstring'''






							if is_tf_available():
														lowercase__     :  Dict      		= {
														    "AutoModelForCausalLM": TFAutoModelForCausalLM,
														    "AutoModelForSpeechSeq2Seq": TFAutoModelForSpeechSeqaSeq,
														    "AutoModelForSeq2SeqLM": TFAutoModelForSeqaSeqLM,
														    "AutoModelForVision2Seq": TFAutoModelForVisionaSeq,
														    "LogitsProcessorList": TFLogitsProcessorList,
														    "MinLengthLogitsProcessor": TFMinLengthLogitsProcessor,
														    "create_tensor_fn": tf.convert_to_tensor,
														    "floats_tensor": floats_tensor,
														    "return_tensors": "tf",
														}







							@slow
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[int]:
														# TF-only test: tf.saved_model export
														lowerCAmelCase__			  =      TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''  )
														lowerCAmelCase__			  =      2
														lowerCAmelCase__			  =      2




														class 						a__							(				tf.Module    ):





																					'''simple docstring'''






																					def __init__(						self   ,       lowerCamelCase_  )			->				Tuple:
																												super(lowercase_   ,       self  ).__init__()
																												lowerCAmelCase__			  =      model







																					@tf.function(
																					    input_signature=(
																					        tf.TensorSpec((None, input_length)   ,       tf.intaa   ,       name='''input_ids'''  ),
																					        tf.TensorSpec((None, input_length)   ,       tf.intaa   ,       name='''attention_mask'''  ),
																					    )   ,       jit_compile=lowercase_   ,       )
																					def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_  )			->				int:
																												lowerCAmelCase__			  =      self.model.generate(
																												    input_ids=lowercase_   ,       attention_mask=lowercase_   ,       max_new_tokens=lowercase_   ,       return_dict_in_generate=lowercase_   ,       )
																												return {"sequences": outputs["sequences"]}

														lowerCAmelCase__			  =      [[2, 0], [1_02, 1_03]]
														lowerCAmelCase__			  =      [[1, 0], [1, 1]]
														lowerCAmelCase__			  =      DummyModel(model=lowercase_  )
														with tempfile.TemporaryDirectory() as tmp_dir:
																					tf.saved_model.save(lowercase_   ,       lowercase_   ,       signatures={'''serving_default''': dummy_model.serving}  )
																					lowerCAmelCase__			  =      tf.saved_model.load(lowercase_  ).signatures['''serving_default''']
																					for batch_size in range(1   ,       len(lowercase_  ) + 1  ):
																												lowerCAmelCase__			  =      {
																												    '''input_ids''': tf.constant(dummy_input_ids[:batch_size]  ),
																												    '''attention_mask''': tf.constant(dummy_attention_masks[:batch_size]  ),
																												}
																												lowerCAmelCase__			  =      serving_func(**lowercase_  )['''sequences''']
																												lowerCAmelCase__			  =      test_model.generate(**lowercase_   ,       max_new_tokens=lowercase_  )
																												tf.debugging.assert_equal(lowercase_   ,       lowercase_  )







							@slow
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Dict:
														# TF-only test: tf.saved_model export
														lowerCAmelCase__			  =      TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''  )
														lowerCAmelCase__			  =      1
														lowerCAmelCase__			  =      2




														class 						a__							(				tf.Module    ):





																					'''simple docstring'''






																					def __init__(						self   ,       lowerCamelCase_  )			->				Union[str, Any]:
																												super(lowercase_   ,       self  ).__init__()
																												lowerCAmelCase__			  =      model







																					@tf.function(
																					    input_signature=(
																					        tf.TensorSpec((batch_size, None)   ,       tf.intaa   ,       name='''input_ids'''  ),
																					        tf.TensorSpec((batch_size, None)   ,       tf.intaa   ,       name='''attention_mask'''  ),
																					    )   ,       jit_compile=lowercase_   ,       )
																					def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_  )			->				Optional[Any]:
																												lowerCAmelCase__			  =      self.model.generate(
																												    input_ids=lowercase_   ,       attention_mask=lowercase_   ,       max_new_tokens=lowercase_   ,       return_dict_in_generate=lowercase_   ,       )
																												return {"sequences": outputs["sequences"]}

														lowerCAmelCase__			  =      [[2], [1_02, 1_03]]
														lowerCAmelCase__			  =      [[1], [1, 1]]
														lowerCAmelCase__			  =      DummyModel(model=lowercase_  )
														with tempfile.TemporaryDirectory() as tmp_dir:
																					tf.saved_model.save(lowercase_   ,       lowercase_   ,       signatures={'''serving_default''': dummy_model.serving}  )
																					lowerCAmelCase__			  =      tf.saved_model.load(lowercase_  ).signatures['''serving_default''']
																					for input_row in range(len(lowercase_  )  ):
																												lowerCAmelCase__			  =      {
																												    '''input_ids''': tf.constant([dummy_input_ids[input_row]]  ),
																												    '''attention_mask''': tf.constant([dummy_attention_masks[input_row]]  ),
																												}
																												lowerCAmelCase__			  =      serving_func(**lowercase_  )['''sequences''']
																												lowerCAmelCase__			  =      test_model.generate(**lowercase_   ,       max_new_tokens=lowercase_  )
																												tf.debugging.assert_equal(lowercase_   ,       lowercase_  )







							@slow
							@require_tensorflow_text
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Dict:
														# TF-only test: tf.saved_model export
														with tempfile.TemporaryDirectory() as tmp_dir:
																					# file needed to load the TF tokenizer
																					hf_hub_download(repo_id='''google/flan-t5-small'''   ,       filename='''spiece.model'''   ,       local_dir=lowercase_  )




																					class 						a__							(				tf.keras.layers.Layer    ):





																												'''simple docstring'''






																												def __init__(						self  )			->				int:
																																			super().__init__()
																																			lowerCAmelCase__			  =      text.SentencepieceTokenizer(
																																			    model=tf.io.gfile.GFile(os.path.join(lowercase_   ,       '''spiece.model'''  )   ,       '''rb'''  ).read()  )
																																			lowerCAmelCase__			  =      TFAutoModelForSeqaSeqLM.from_pretrained('''hf-internal-testing/tiny-random-t5'''  )







																												def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       *lowerCamelCase_   ,       **lowerCamelCase_  )			->				List[Any]:
																																			lowerCAmelCase__			  =      self.tokenizer.tokenize(lowercase_  )
																																			lowerCAmelCase__  ,   lowerCAmelCase__			  =      text.pad_model_inputs(
																																			    lowercase_   ,       max_seq_length=64   ,       pad_value=self.model.config.pad_token_id  )
																																			lowerCAmelCase__			  =      self.model.generate(input_ids=lowercase_   ,       attention_mask=lowercase_  )
																																			return self.tokenizer.detokenize(lowercase_  )

																					lowerCAmelCase__			  =      CompleteSentenceTransformer()
																					lowerCAmelCase__			  =      tf.keras.layers.Input(shape=(1,)   ,       dtype=tf.string   ,       name='''inputs'''  )
																					lowerCAmelCase__			  =      complete_model(lowercase_  )
																					lowerCAmelCase__			  =      tf.keras.Model(lowercase_   ,       lowercase_  )
																					keras_model.save(lowercase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														# Has PT equivalent: this test relies on random sampling
														lowerCAmelCase__			  =      {
														    '''do_sample''': True,
														    '''num_beams''': 1,
														    '''top_p''': 0.7,
														    '''top_k''': 10,
														    '''temperature''': 0.7,
														}
														lowerCAmelCase__			  =      14

														lowerCAmelCase__			  =      AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''  )
														lowerCAmelCase__			  =      '''Hello, my dog is cute and'''
														lowerCAmelCase__			  =      tokenizer(lowercase_   ,       return_tensors='''tf'''  )
														lowerCAmelCase__			  =      TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''  )

														lowerCAmelCase__			  =      6_38
														# forces the generation to happen on CPU, to avoid GPU-related quirks
														with tf.device(''':/CPU:0'''  ):
																					tf.random.set_seed(0  )
																					lowerCAmelCase__			  =      model.generate(**lowercase_   ,       eos_token_id=lowercase_   ,       **lowercase_  )
														self.assertTrue(expectation == len(generated_tokens[0]  )  )

														lowerCAmelCase__			  =      [6_38, 1_98]
														with tf.device(''':/CPU:0'''  ):
																					tf.random.set_seed(0  )
																					lowerCAmelCase__			  =      model.generate(**lowercase_   ,       eos_token_id=lowercase_   ,       **lowercase_  )
														self.assertTrue(expectation == len(generated_tokens[0]  )  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[str]:
														# Has PT equivalent: ample use of framework-specific code
														lowerCAmelCase__			  =      AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bart'''  )
														lowerCAmelCase__			  =      '''Hugging Face is a technology company based in New York and Paris.'''
														lowerCAmelCase__			  =      bart_tokenizer(lowercase_   ,       return_tensors='''tf'''  ).input_ids
														lowerCAmelCase__			  =      TFBartForConditionalGeneration.from_pretrained('''hf-internal-testing/tiny-random-bart'''  )
														lowerCAmelCase__			  =      bart_model.generate(lowercase_  ).numpy()




														class 						a__							(				UpperCamelCase__    ):





																					'''simple docstring'''






																					def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_=None   ,       **lowerCamelCase_  )			->				List[str]:
																												return super().call(lowercase_   ,       **lowercase_  )

														lowerCAmelCase__			  =      FakeBart.from_pretrained('''hf-internal-testing/tiny-random-bart'''  )
														lowerCAmelCase__			  =      bart_model.generate(lowercase_   ,       foo='''bar'''  ).numpy()
														self.assertTrue(np.array_equal(lowercase_   ,       lowercase_  )  )




														class 						a__							(				bart_model.model.encoder.__class__    ):





																					'''simple docstring'''






																					def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       **lowerCamelCase_  )			->				List[Any]:
																												return super().call(lowercase_   ,       **lowercase_  )

														lowerCAmelCase__			  =      FakeEncoder(bart_model.config   ,       bart_model.model.shared  )
														lowerCAmelCase__			  =      fake_encoder

														# Normal generation still works (the output will be different because the encoder weights are different)
														lowerCAmelCase__			  =      bart_model.generate(lowercase_  ).numpy()
														with self.assertRaises(lowercase_  ):
																					# FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
																					bart_model.generate(lowercase_   ,       foo='''bar'''  )






'''simple docstring'''

from dataclasses import dataclass
from typing import Optional, Tuple, Union

import torch
import torch.nn as nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput, apply_forward_hook
from .modeling_utils import ModelMixin
from .vae import Decoder, DecoderOutput, Encoder, VectorQuantizer






@dataclass
class   UpperCAmelCase      (			UpperCamelCase__							):
 __lowercase  						=							42






class   UpperCAmelCase      (			UpperCamelCase__     ,			UpperCamelCase__							):
 @register_to_config
 def __init__(							self :Tuple		,			lowercase_ :int = 3		,			lowercase_ :int = 3		,			lowercase_ :Tuple[str] = ("DownEncoderBlock2D",)		,			lowercase_ :Tuple[str] = ("UpDecoderBlock2D",)		,			lowercase_ :Tuple[int] = (64,)		,			lowercase_ :int = 1		,			lowercase_ :str = "silu"		,			lowercase_ :int = 3		,			lowercase_ :int = 32		,			lowercase_ :int = 2_56		,			lowercase_ :int = 32		,			lowercase_ :Optional[int] = None		,			lowercase_ :float = 0.1_8_2_1_5		,			lowercase_ :str = "group"		,			)->				Optional[int]:
     super().__init__()

     # pass init params to Encoder
     A__							=     Encoder(
         in_channels=lowercase_		,			out_channels=lowercase_		,			down_block_types=lowercase_		,			block_out_channels=lowercase_		,			layers_per_block=lowercase_		,			act_fn=lowercase_		,			norm_num_groups=lowercase_		,			double_z=lowercase_		,			)

     A__							=     vq_embed_dim if vq_embed_dim is not None else latent_channels

     A__							=     nn.Convad(lowercase_		,			lowercase_		,			1				)
     A__							=     VectorQuantizer(lowercase_		,			lowercase_		,			beta=0.2_5		,			remap=lowercase_		,			sane_index_shape=lowercase_				)
     A__							=     nn.Convad(lowercase_		,			lowercase_		,			1				)

     # pass init params to Decoder
     A__							=     Decoder(
         in_channels=lowercase_		,			out_channels=lowercase_		,			up_block_types=lowercase_		,			block_out_channels=lowercase_		,			layers_per_block=lowercase_		,			act_fn=lowercase_		,			norm_num_groups=lowercase_		,			norm_type=lowercase_		,			)
 @apply_forward_hook
 def 	UpperCAmelCase_				(							self :str		,			lowercase_ :torch.FloatTensor		,			lowercase_ :bool = True				)->				VQEncoderOutput:
     A__							=     self.encoder(lowercase_				)
     A__							=     self.quant_conv(lowercase_				)

     if not return_dict:
         return (h,)

     return VQEncoderOutput(latents=lowercase_				)
 @apply_forward_hook
 def 	UpperCAmelCase_				(							self :Dict		,			lowercase_ :torch.FloatTensor		,			lowercase_ :bool = False		,			lowercase_ :bool = True				)->				Union[DecoderOutput, torch.FloatTensor]:
     # also go through quantization layer
     if not force_not_quantize:
         A__,      A__,      A__							=     self.quantize(lowercase_				)
     else:
         A__							=     h
     A__							=     self.post_quant_conv(lowercase_				)
     A__							=     self.decoder(lowercase_		,			quant if self.config.norm_type == "spatial" else None				)

     if not return_dict:
         return (dec,)

     return DecoderOutput(sample=lowercase_				)



 def 	UpperCAmelCase_				(							self :str		,			lowercase_ :torch.FloatTensor		,			lowercase_ :bool = True				)->				Union[DecoderOutput, torch.FloatTensor]:
     A__							=     sample
     A__							=     self.encode(lowercase_				).latents
     A__							=     self.decode(lowercase_				).sample

     if not return_dict:
         return (dec,)

     return DecoderOutput(sample=lowercase_				)



