






"""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      SCREAMING_SNAKE_CASE  (				unittest.TestCase						):





 """simple docstring"""




 def    lowerCamelCase(self							):
  A_		:						Any	    =   tf.convert_to_tensor(
      [
          [
              8.2220991,  # 3rd highest value; idx. 0
              -0.5620044,
              5.23229752,
              4.0386393,
              -6.8798378,
              -0.54785802,
              -3.2012153,
              2.92777176,
              1.88171953,
              7.35341276,  # 5th highest value; idx. 9
              8.43207833,  # 2nd highest value; idx. 10
              -9.85711836,
              -5.96209236,
              -1.13039161,
              -7.1115294,
              -0.8369633,
              -5.3186408,
              7.06427407,
              0.81369344,
              -0.82023817,
              -5.9179796,
              0.58813443,
              -6.99778438,
              4.71551189,
              -0.18771637,
              7.44020759,  # 4th highest value; idx. 25
              9.38450987,  # 1st highest value; idx. 26
              2.12662941,
              -9.32562038,
              2.35652522,
          ],  # cummulative prob of 5 highest values <= 0.6
          [
              0.58425518,
              4.53139238,
              -5.57510464,
              -6.28030699,
              -7.19529503,
              -4.02122551,
              1.39337037,
              -6.06707057,
              1.59480517,
              -9.643119,
              0.03907799,
              0.67231762,
              -8.88206726,
              6.27115922,  # 4th highest value; idx. 13
              2.28520723,
              4.82767506,
              4.30421368,
              8.8275313,  # 2nd highest value; idx. 17
              5.44029958,  # 5th highest value; idx. 18
              -4.4735794,
              7.38579536,  # 3rd highest value; idx. 20
              -2.91051663,
              2.61946077,
              -2.5674762,
              -9.48959302,
              -4.02922645,
              -1.35416918,
              9.67702323,  # 1st highest value; idx. 27
              -5.89478553,
              1.85370467,
          ],  # cummulative prob of 5 highest values <= 0.6
      ]     ,     dtype=tf.floataa     ,     )

  A_		:						Dict	    =   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

  A_		:						Any	    =   tf.convert_to_tensor(
      [8.222099, 7.3534126, 8.432078, 7.4402075, 9.38451, 6.271159, 8.827531, 5.4402995, 7.3857956, 9.677023]     ,     dtype=tf.floataa     ,     )  # expected non filtered values as noted above

  A_		:						Dict	    =   tf_top_k_top_p_filtering(_snake_case     ,     top_k=10     ,     top_p=0.6     ,     min_tokens_to_keep=4							)

  A_		:						List[Any]	    =   output[output != -float("""inf"""							)]
  A_		:						int	    =   tf.cast(
      tf.where(tf.not_equal(_snake_case     ,     tf.constant(-float("""inf"""							)     ,     dtype=tf.floataa							)							)							)     ,     dtype=tf.intaa     ,     )

  tf.debugging.assert_near(_snake_case     ,     _snake_case     ,     rtol=1e-1_2							)
  tf.debugging.assert_equal(_snake_case     ,     _snake_case							)






@require_tf
class      SCREAMING_SNAKE_CASE  (				unittest.TestCase       ,       UpperCAmelCase_						):





 """simple docstring"""




 if is_tf_available():
  _A       :				List[Any]    =				{
      "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    lowerCamelCase(self							):
  A_		:						List[Any]	    =   TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""							)
  A_		:						Tuple	    =   2
  A_		:						Union[str, Any]	    =   2



  class      SCREAMING_SNAKE_CASE  (				tf.Module						):





   """simple docstring"""




   def __init__(self     ,     lowerCAmelCase_							):
    super(_snake_case     ,     self							).__init__()
    A_		:						int	    =   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=_snake_case     ,     )
   def    lowerCamelCase(self     ,     lowerCAmelCase_     ,     lowerCAmelCase_							):
    A_		:						Optional[Any]	    =   self.model.generate(
        input_ids=_snake_case     ,     attention_mask=_snake_case     ,     max_new_tokens=_snake_case     ,     return_dict_in_generate=_snake_case     ,     )
    return {"sequences": outputs["sequences"]}






  A_		:						Dict	    =   [[2, 0], [102, 103]]
  A_		:						Any	    =   [[1, 0], [1, 1]]
  A_		:						Dict	    =   DummyModel(model=_snake_case							)
  with tempfile.TemporaryDirectory() as tmp_dir:
   tf.saved_model.save(_snake_case     ,     _snake_case     ,     signatures={"""serving_default""": dummy_model.serving}							)
   A_		:						Optional[Any]	    =   tf.saved_model.load(_snake_case							).signatures["""serving_default"""]
   for batch_size in range(1     ,     len(_snake_case							) + 1							):
    A_		:						str	    =   {
        """input_ids""": tf.constant(dummy_input_ids[:batch_size]							),
        """attention_mask""": tf.constant(dummy_attention_masks[:batch_size]							),
    }
    A_		:						Dict	    =   serving_func(**_snake_case							)["""sequences"""]
    A_		:						Tuple	    =   test_model.generate(**_snake_case     ,     max_new_tokens=_snake_case							)
    tf.debugging.assert_equal(_snake_case     ,     _snake_case							)





 @slow
 def    lowerCamelCase(self							):
  A_		:						Union[str, Any]	    =   TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""							)
  A_		:						int	    =   1
  A_		:						Dict	    =   2



  class      SCREAMING_SNAKE_CASE  (				tf.Module						):





   """simple docstring"""




   def __init__(self     ,     lowerCAmelCase_							):
    super(_snake_case     ,     self							).__init__()
    A_		:						List[Any]	    =   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=_snake_case     ,     )
   def    lowerCamelCase(self     ,     lowerCAmelCase_     ,     lowerCAmelCase_							):
    A_		:						Any	    =   self.model.generate(
        input_ids=_snake_case     ,     attention_mask=_snake_case     ,     max_new_tokens=_snake_case     ,     return_dict_in_generate=_snake_case     ,     )
    return {"sequences": outputs["sequences"]}






  A_		:						Tuple	    =   [[2], [102, 103]]
  A_		:						List[Any]	    =   [[1], [1, 1]]
  A_		:						List[Any]	    =   DummyModel(model=_snake_case							)
  with tempfile.TemporaryDirectory() as tmp_dir:
   tf.saved_model.save(_snake_case     ,     _snake_case     ,     signatures={"""serving_default""": dummy_model.serving}							)
   A_		:						Optional[Any]	    =   tf.saved_model.load(_snake_case							).signatures["""serving_default"""]
   for input_row in range(len(_snake_case							)							):
    A_		:						Any	    =   {
        """input_ids""": tf.constant([dummy_input_ids[input_row]]							),
        """attention_mask""": tf.constant([dummy_attention_masks[input_row]]							),
    }
    A_		:						Union[str, Any]	    =   serving_func(**_snake_case							)["""sequences"""]
    A_		:						List[Any]	    =   test_model.generate(**_snake_case     ,     max_new_tokens=_snake_case							)
    tf.debugging.assert_equal(_snake_case     ,     _snake_case							)





 @slow
 @require_tensorflow_text
 def    lowerCamelCase(self							):


  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=_snake_case							)



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





    """simple docstring"""




    def __init__(self							):
     super().__init__()
     A_		:						Union[str, Any]	    =   text.SentencepieceTokenizer(
         model=tf.io.gfile.GFile(os.path.join(_snake_case     ,     """spiece.model"""							)     ,     """rb"""							).read()							)
     A_		:						Optional[int]	    =   TFAutoModelForSeqaSeqLM.from_pretrained("""hf-internal-testing/tiny-random-t5"""							)





    def    lowerCamelCase(self     ,     lowerCAmelCase_     ,     *lowerCAmelCase_     ,     **lowerCAmelCase_							):
     A_		:						Union[str, Any]	    =   self.tokenizer.tokenize(_snake_case							)
     A_    ,     A_		:						str	    =   text.pad_model_inputs(
         _snake_case     ,     max_seq_length=64     ,     pad_value=self.model.config.pad_token_id							)
     A_		:						Any	    =   self.model.generate(input_ids=_snake_case     ,     attention_mask=_snake_case							)
     return self.tokenizer.detokenize(_snake_case							)






   A_		:						Union[str, Any]	    =   CompleteSentenceTransformer()
   A_		:						Tuple	    =   tf.keras.layers.Input(shape=(1,)     ,     dtype=tf.string     ,     name="""inputs"""							)
   A_		:						Optional[Any]	    =   complete_model(_snake_case							)
   A_		:						Dict	    =   tf.keras.Model(_snake_case     ,     _snake_case							)
   keras_model.save(_snake_case							)





 def    lowerCamelCase(self							):
  A_		:						Union[str, Any]	    =   {
      """do_sample""": True,
      """num_beams""": 1,
      """top_p""": 0.7,
      """top_k""": 10,
      """temperature""": 0.7,
  }
  A_		:						str	    =   14

  A_		:						Dict	    =   AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""							)
  A_		:						List[Any]	    =   """Hello, my dog is cute and"""
  A_		:						List[str]	    =   tokenizer(_snake_case     ,     return_tensors="""tf"""							)
  A_		:						Tuple	    =   TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""							)

  A_		:						int	    =   638
  # forces the generation to happen on CPU, to avoid GPU-related quirks
  with tf.device(""":/CPU:0"""							):
   tf.random.set_seed(0							)
   A_		:						Any	    =   model.generate(**_snake_case     ,     eos_token_id=_snake_case     ,     **_snake_case							)
  self.assertTrue(expectation == len(generated_tokens[0]							)							)

  A_		:						Tuple	    =   [638, 198]
  with tf.device(""":/CPU:0"""							):
   tf.random.set_seed(0							)
   A_		:						Any	    =   model.generate(**_snake_case     ,     eos_token_id=_snake_case     ,     **_snake_case							)
  self.assertTrue(expectation == len(generated_tokens[0]							)							)





 def    lowerCamelCase(self							):
  A_		:						Dict	    =   AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bart"""							)
  A_		:						Tuple	    =   """Hugging Face is a technology company based in New York and Paris."""
  A_		:						str	    =   bart_tokenizer(_snake_case     ,     return_tensors="""tf"""							).input_ids
  A_		:						Any	    =   TFBartForConditionalGeneration.from_pretrained("""hf-internal-testing/tiny-random-bart"""							)
  A_		:						Dict	    =   bart_model.generate(_snake_case							).numpy()



  class      SCREAMING_SNAKE_CASE  (				UpperCAmelCase_						):





   """simple docstring"""




   def    lowerCamelCase(self     ,     lowerCAmelCase_     ,     lowerCAmelCase_=None     ,     **lowerCAmelCase_							):
    return super().call(_snake_case     ,     **_snake_case							)






  A_		:						Tuple	    =   FakeBart.from_pretrained("""hf-internal-testing/tiny-random-bart"""							)
  A_		:						Union[str, Any]	    =   bart_model.generate(_snake_case     ,     foo="""bar"""							).numpy()
  self.assertTrue(np.array_equal(_snake_case     ,     _snake_case							)							)



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





   """simple docstring"""




   def    lowerCamelCase(self     ,     lowerCAmelCase_     ,     **lowerCAmelCase_							):
    return super().call(_snake_case     ,     **_snake_case							)






  A_		:						Union[str, Any]	    =   FakeEncoder(bart_model.config     ,     bart_model.model.shared							)
  A_		:						Optional[Any]	    =   fake_encoder

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









"""simple docstring"""
import argparse

import OmegaConf
import torch

from diffusers import DDIMScheduler, LDMPipeline, UNetLDMModel, VQModel






def 			__UpperCamelCase	(		snake_case__   ,   snake_case__   ,   snake_case__					):
	A_		:						str	    =   OmegaConf.load(snake_case__					)
	A_		:						List[str]	    =   torch.load(snake_case__   ,   map_location="""cpu"""					)["""model"""]
	A_		:						Any	    =   list(state_dict.keys()					)

	# extract state_dict for VQVAE
	A_		:						Any	    =   {}
	A_		:						Union[str, Any]	    =   """first_stage_model."""
	for key in keys:
		if key.startswith(snake_case__					):
			A_		:						List[Any]	    =   state_dict[key]

    # extract state_dict for UNetLDM
	A_		:						Tuple	    =   {}
	A_		:						Dict	    =   """model.diffusion_model."""
	for key in keys:
		if key.startswith(snake_case__					):
			A_		:						Optional[Any]	    =   state_dict[key]

	A_		:						List[Any]	    =   config.model.params.first_stage_config.params
	A_		:						Tuple	    =   config.model.params.unet_config.params

	A_		:						Any	    =   VQModel(**snake_case__					).eval()
	vqvae.load_state_dict(snake_case__					)

	A_		:						Optional[int]	    =   UNetLDMModel(**snake_case__					).eval()
	unet.load_state_dict(snake_case__					)

	A_		:						List[str]	    =   DDIMScheduler(
	    timesteps=config.model.params.timesteps   ,   beta_schedule="""scaled_linear"""   ,   beta_start=config.model.params.linear_start   ,   beta_end=config.model.params.linear_end   ,   clip_sample=snake_case__   ,   )

	A_		:						str	    =   LDMPipeline(snake_case__   ,   snake_case__   ,   snake_case__					)
	pipeline.save_pretrained(snake_case__					)


if __name__ == "__main__":
							_lowerCAmelCase         =							argparse.ArgumentParser()
							parser.add_argument("--checkpoint_path", type=str, required=True)
							parser.add_argument("--config_path", type=str, required=True)
							parser.add_argument("--output_path", type=str, required=True)
							_lowerCAmelCase         =							parser.parse_args()

							convert_ldm_original(args.checkpoint_path, args.config_path, args.output_path)

