





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

      '''simple docstring'''



      def       A_					(							self       :      Dict ):


        '''simple docstring'''




        __UpperCAmelCase    :						Any       =						tf.convert_to_tensor(
            [
                [
                    8.2_2_2_0_9_9_1,  # 3rd highest value; idx. 0
                    -0.5_6_2_0_0_4_4,
                    5.2_3_2_2_9_7_5_2,
                    4.0_3_8_6_3_9_3,
                    -6.8_7_9_8_3_7_8,
                    -0.5_4_7_8_5_8_0_2,
                    -3.2_0_1_2_1_5_3,
                    2.9_2_7_7_7_1_7_6,
                    1.8_8_1_7_1_9_5_3,
                    7.3_5_3_4_1_2_7_6,  # 5th highest value; idx. 9
                    8.4_3_2_0_7_8_3_3,  # 2nd highest value; idx. 10
                    -9.8_5_7_1_1_8_3_6,
                    -5.9_6_2_0_9_2_3_6,
                    -1.1_3_0_3_9_1_6_1,
                    -7.1_1_1_5_2_9_4,
                    -0.8_3_6_9_6_3_3,
                    -5.3_1_8_6_4_0_8,
                    7.0_6_4_2_7_4_0_7,
                    0.8_1_3_6_9_3_4_4,
                    -0.8_2_0_2_3_8_1_7,
                    -5.9_1_7_9_7_9_6,
                    0.5_8_8_1_3_4_4_3,
                    -6.9_9_7_7_8_4_3_8,
                    4.7_1_5_5_1_1_8_9,
                    -0.1_8_7_7_1_6_3_7,
                    7.4_4_0_2_0_7_5_9,  # 4th highest value; idx. 25
                    9.3_8_4_5_0_9_8_7,  # 1st highest value; idx. 26
                    2.1_2_6_6_2_9_4_1,
                    -9.3_2_5_6_2_0_3_8,
                    2.3_5_6_5_2_5_2_2,
                ],  # cummulative prob of 5 highest values <= 0.6
                [
                    0.5_8_4_2_5_5_1_8,
                    4.5_3_1_3_9_2_3_8,
                    -5.5_7_5_1_0_4_6_4,
                    -6.2_8_0_3_0_6_9_9,
                    -7.1_9_5_2_9_5_0_3,
                    -4.0_2_1_2_2_5_5_1,
                    1.3_9_3_3_7_0_3_7,
                    -6.0_6_7_0_7_0_5_7,
                    1.5_9_4_8_0_5_1_7,
                    -9.6_4_3_1_1_9,
                    0.0_3_9_0_7_7_9_9,
                    0.6_7_2_3_1_7_6_2,
                    -8.8_8_2_0_6_7_2_6,
                    6.2_7_1_1_5_9_2_2,  # 4th highest value; idx. 13
                    2.2_8_5_2_0_7_2_3,
                    4.8_2_7_6_7_5_0_6,
                    4.3_0_4_2_1_3_6_8,
                    8.8_2_7_5_3_1_3,  # 2nd highest value; idx. 17
                    5.4_4_0_2_9_9_5_8,  # 5th highest value; idx. 18
                    -4.4_7_3_5_7_9_4,
                    7.3_8_5_7_9_5_3_6,  # 3rd highest value; idx. 20
                    -2.9_1_0_5_1_6_6_3,
                    2.6_1_9_4_6_0_7_7,
                    -2.5_6_7_4_7_6_2,
                    -9.4_8_9_5_9_3_0_2,
                    -4.0_2_9_2_2_6_4_5,
                    -1.3_5_4_1_6_9_1_8,
                    9.6_7_7_0_2_3_2_3,  # 1st highest value; idx. 27
                    -5.8_9_4_7_8_5_5_3,
                    1.8_5_3_7_0_4_6_7,
                ],  # cummulative prob of 5 highest values <= 0.6
            ]						,				dtype=tf.floataa						,				)

        __UpperCAmelCase    :						str       =						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

        __UpperCAmelCase    :						Any       =						tf.convert_to_tensor(
            [8.2_2_2_0_9_9, 7.3_5_3_4_1_2_6, 8.4_3_2_0_7_8, 7.4_4_0_2_0_7_5, 9.3_8_4_5_1, 6.2_7_1_1_5_9, 8.8_2_7_5_3_1, 5.4_4_0_2_9_9_5, 7.3_8_5_7_9_5_6, 9.6_7_7_0_2_3]						,				dtype=tf.floataa						,				)  # expected non filtered values as noted above

        __UpperCAmelCase    :						List[Any]       =						tf_top_k_top_p_filtering(UpperCAmelCase__						,				top_k=10						,				top_p=0.6						,				min_tokens_to_keep=4 )

        __UpperCAmelCase    :						int       =						output[output != -float('''inf''' )]
        __UpperCAmelCase    :						Union[str, Any]       =						tf.cast(
            tf.where(tf.not_equal(UpperCAmelCase__						,				tf.constant(-float('''inf''' )						,				dtype=tf.floataa ) ) )						,				dtype=tf.intaa						,				)

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




@require_tf
class 							snake_case							(			unittest.TestCase      ,  __UpperCAmelCase ):

      '''simple docstring'''



      if is_tf_available():
            _A     :       int         =       {
                '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       A_					(							self       :      Dict ):


        '''simple docstring'''




        __UpperCAmelCase    :						Optional[int]       =						TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2''' )
        __UpperCAmelCase    :						Dict       =						2
        __UpperCAmelCase    :						List[str]       =						2




        class 							snake_case							(			tf.Module ):

              '''simple docstring'''



              def __init__(							self       :      List[str]						,				__lowercase       :      List[str] ):


                '''simple docstring'''




                super(UpperCAmelCase__						,				self ).__init__()
                __UpperCAmelCase    :						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=UpperCAmelCase__						,				)
              def       A_					(							self       :      Union[str, Any]						,				__lowercase       :      Union[str, Any]						,				__lowercase       :      List[str] ):


                '''simple docstring'''




                __UpperCAmelCase    :						Dict       =						self.model.generate(
                    input_ids=UpperCAmelCase__						,				attention_mask=UpperCAmelCase__						,				max_new_tokens=UpperCAmelCase__						,				return_dict_in_generate=UpperCAmelCase__						,				)
                return {"sequences": outputs["sequences"]}


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

      @slow
      def       A_					(							self       :      Tuple ):


        '''simple docstring'''




        __UpperCAmelCase    :						Tuple       =						TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2''' )
        __UpperCAmelCase    :						Tuple       =						1
        __UpperCAmelCase    :						Optional[Any]       =						2




        class 							snake_case							(			tf.Module ):

              '''simple docstring'''



              def __init__(							self       :      int						,				__lowercase       :      int ):


                '''simple docstring'''




                super(UpperCAmelCase__						,				self ).__init__()
                __UpperCAmelCase    :						Dict       =						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=UpperCAmelCase__						,				)
              def       A_					(							self       :      Dict						,				__lowercase       :      List[str]						,				__lowercase       :      Optional[Any] ):


                '''simple docstring'''




                __UpperCAmelCase    :						List[str]       =						self.model.generate(
                    input_ids=UpperCAmelCase__						,				attention_mask=UpperCAmelCase__						,				max_new_tokens=UpperCAmelCase__						,				return_dict_in_generate=UpperCAmelCase__						,				)
                return {"sequences": outputs["sequences"]}


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

      @slow
      @require_tensorflow_text
      def       A_					(							self       :      Optional[Any] ):


        '''simple docstring'''




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




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

                '''simple docstring'''



                def __init__(							self       :      List[str] ):


                  '''simple docstring'''




                  super().__init__()
                  __UpperCAmelCase    :						Dict       =						text.SentencepieceTokenizer(
                      model=tf.io.gfile.GFile(os.path.join(UpperCAmelCase__						,				'''spiece.model''' )						,				'''rb''' ).read() )
                  __UpperCAmelCase    :						Optional[int]       =						TFAutoModelForSeqaSeqLM.from_pretrained('''hf-internal-testing/tiny-random-t5''' )







                def       A_					(							self       :      Any						,				__lowercase       :      Union[str, Any]						,				*__lowercase       :      Union[str, Any]						,				**__lowercase       :      str ):


                  '''simple docstring'''




                  __UpperCAmelCase    :						List[str]       =						self.tokenizer.tokenize(UpperCAmelCase__ )
                  __UpperCAmelCase       ,     __UpperCAmelCase    :						str       =						text.pad_model_inputs(
                      UpperCAmelCase__						,				max_seq_length=64						,				pad_value=self.model.config.pad_token_id )
                  __UpperCAmelCase    :						Optional[int]       =						self.model.generate(input_ids=UpperCAmelCase__						,				attention_mask=UpperCAmelCase__ )
                  return self.tokenizer.detokenize(UpperCAmelCase__ )


          __UpperCAmelCase    :						Union[str, Any]       =						CompleteSentenceTransformer()
          __UpperCAmelCase    :						Optional[int]       =						tf.keras.layers.Input(shape=(1,)						,				dtype=tf.string						,				name='''inputs''' )
          __UpperCAmelCase    :						str       =						complete_model(UpperCAmelCase__ )
          __UpperCAmelCase    :						Any       =						tf.keras.Model(UpperCAmelCase__						,				UpperCAmelCase__ )
          keras_model.save(UpperCAmelCase__ )

      def       A_					(							self       :      Optional[int] ):


        '''simple docstring'''




        __UpperCAmelCase    :						List[Any]       =						{
            '''do_sample''': True,
            '''num_beams''': 1,
            '''top_p''': 0.7,
            '''top_k''': 10,
            '''temperature''': 0.7,
        }
        __UpperCAmelCase    :						Optional[int]       =						14

        __UpperCAmelCase    :						Optional[Any]       =						AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-gpt2''' )
        __UpperCAmelCase    :						List[Any]       =						'''Hello, my dog is cute and'''
        __UpperCAmelCase    :						List[str]       =						tokenizer(UpperCAmelCase__						,				return_tensors='''tf''' )
        __UpperCAmelCase    :						Optional[Any]       =						TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2''' )

        __UpperCAmelCase    :						Union[str, Any]       =						638
        # forces the generation to happen on CPU, to avoid GPU-related quirks
        with tf.device(''':/CPU:0''' ):
          tf.random.set_seed(0 )
          __UpperCAmelCase    :						List[str]       =						model.generate(**UpperCAmelCase__						,				eos_token_id=UpperCAmelCase__						,				**UpperCAmelCase__ )
        self.assertTrue(expectation == len(generated_tokens[0] ) )

        __UpperCAmelCase    :						str       =						[638, 198]
        with tf.device(''':/CPU:0''' ):
          tf.random.set_seed(0 )
          __UpperCAmelCase    :						Optional[int]       =						model.generate(**UpperCAmelCase__						,				eos_token_id=UpperCAmelCase__						,				**UpperCAmelCase__ )
        self.assertTrue(expectation == len(generated_tokens[0] ) )







      def       A_					(							self       :      Optional[int] ):


        '''simple docstring'''




        __UpperCAmelCase    :						Tuple       =						AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bart''' )
        __UpperCAmelCase    :						Dict       =						'''Hugging Face is a technology company based in New York and Paris.'''
        __UpperCAmelCase    :						Optional[int]       =						bart_tokenizer(UpperCAmelCase__						,				return_tensors='''tf''' ).input_ids
        __UpperCAmelCase    :						str       =						TFBartForConditionalGeneration.from_pretrained('''hf-internal-testing/tiny-random-bart''' )
        __UpperCAmelCase    :						List[Any]       =						bart_model.generate(UpperCAmelCase__ ).numpy()




        class 							snake_case							(			__UpperCAmelCase ):

              '''simple docstring'''



              def       A_					(							self       :      int						,				__lowercase       :      Dict						,				__lowercase       :      List[Any]=None						,				**__lowercase       :      int ):


                '''simple docstring'''




                return super().call(UpperCAmelCase__						,				**UpperCAmelCase__ )


        __UpperCAmelCase    :						Union[str, Any]       =						FakeBart.from_pretrained('''hf-internal-testing/tiny-random-bart''' )
        __UpperCAmelCase    :						Optional[Any]       =						bart_model.generate(UpperCAmelCase__						,				foo='''bar''' ).numpy()
        self.assertTrue(np.array_equal(UpperCAmelCase__						,				UpperCAmelCase__ ) )




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

              '''simple docstring'''



              def       A_					(							self       :      str						,				__lowercase       :      List[str]						,				**__lowercase       :      Dict ):


                '''simple docstring'''




                return super().call(UpperCAmelCase__						,				**UpperCAmelCase__ )


        __UpperCAmelCase    :						Any       =						FakeEncoder(bart_model.config						,				bart_model.model.shared )
        __UpperCAmelCase    :						Tuple       =						fake_encoder

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






"""simple docstring"""





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

import torch
import torch.nn.functional as F
from torch import nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput
from .attention import BasicTransformerBlock
from .attention_processor import AttentionProcessor, AttnProcessor
from .embeddings import TimestepEmbedding, Timesteps
from .modeling_utils import ModelMixin




@dataclass
class 							snake_case							(			__UpperCAmelCase ):

      '''simple docstring'''



      _A     :       torch.FloatTensor




class 							snake_case							(			__UpperCAmelCase      ,  __UpperCAmelCase ):

      '''simple docstring'''



      @register_to_config
      def __init__(							self       :      Union[str, Any]						,				__lowercase       :      int = 32						,				__lowercase       :      int = 64						,				__lowercase       :      int = 20						,				__lowercase       :      int = 768						,				__lowercase       :      Optional[int]=77						,				__lowercase       :      Union[str, Any]=4						,				__lowercase       :      float = 0.0						,				__lowercase       :      str = "silu"						,				__lowercase       :      Optional[str] = None						,				__lowercase       :      Optional[str] = None						,				__lowercase       :      Optional[str] = "linear"						,				__lowercase       :      Optional[str] = "prd"						,				__lowercase       :      Optional[int] = None						,				__lowercase       :      Optional[int] = None						,				__lowercase       :      Optional[int] = None						,				):


        '''simple docstring'''




        super().__init__()
        __UpperCAmelCase    :						int       =						num_attention_heads
        __UpperCAmelCase    :						List[Any]       =						attention_head_dim
        __UpperCAmelCase    :						int       =						num_attention_heads * attention_head_dim
        __UpperCAmelCase    :						List[str]       =						additional_embeddings

        __UpperCAmelCase    :						Optional[int]       =						time_embed_dim or inner_dim
        __UpperCAmelCase    :						Tuple       =						embedding_proj_dim or embedding_dim
        __UpperCAmelCase    :						Dict       =						clip_embed_dim or embedding_dim

        __UpperCAmelCase    :						Dict       =						Timesteps(__lowercase						,				__lowercase						,				0 )
        __UpperCAmelCase    :						List[str]       =						TimestepEmbedding(__lowercase						,				__lowercase						,				out_dim=__lowercase						,				act_fn=__lowercase )

        __UpperCAmelCase    :						Any       =						nn.Linear(__lowercase						,				__lowercase )

        if embedding_proj_norm_type is None:
          __UpperCAmelCase    :						Dict       =						None
        elif embedding_proj_norm_type == "layer":
          __UpperCAmelCase    :						Any       =						nn.LayerNorm(__lowercase )
        else:
          raise ValueError(f'''unsupported embedding_proj_norm_type: {embedding_proj_norm_type}''' )

        __UpperCAmelCase    :						List[Any]       =						nn.Linear(__lowercase						,				__lowercase )

        if encoder_hid_proj_type is None:
          __UpperCAmelCase    :						int       =						None
        elif encoder_hid_proj_type == "linear":
          __UpperCAmelCase    :						int       =						nn.Linear(__lowercase						,				__lowercase )
        else:
          raise ValueError(f'''unsupported encoder_hid_proj_type: {encoder_hid_proj_type}''' )

        __UpperCAmelCase    :						str       =						nn.Parameter(torch.zeros(1						,				num_embeddings + additional_embeddings						,				__lowercase ) )

        if added_emb_type == "prd":
          __UpperCAmelCase    :						Optional[int]       =						nn.Parameter(torch.zeros(1						,				1						,				__lowercase ) )
        elif added_emb_type is None:
          __UpperCAmelCase    :						str       =						None
        else:
          raise ValueError(
              f'''`added_emb_type`: {added_emb_type} is not supported. Make sure to choose one of `\'prd\'` or `None`.''' )

        __UpperCAmelCase    :						Union[str, Any]       =						nn.ModuleList(
            [
                BasicTransformerBlock(
                    __lowercase						,				__lowercase						,				__lowercase						,				dropout=__lowercase						,				activation_fn='''gelu'''						,				attention_bias=__lowercase						,				)
                for d in range(__lowercase )
            ] )

        if norm_in_type == "layer":
          __UpperCAmelCase    :						Optional[Any]       =						nn.LayerNorm(__lowercase )
        elif norm_in_type is None:
          __UpperCAmelCase    :						List[Any]       =						None
        else:
          raise ValueError(f'''Unsupported norm_in_type: {norm_in_type}.''' )

        __UpperCAmelCase    :						str       =						nn.LayerNorm(__lowercase )

        __UpperCAmelCase    :						List[Any]       =						nn.Linear(__lowercase						,				__lowercase )

        __UpperCAmelCase    :						List[Any]       =						torch.full(
            [num_embeddings + additional_embeddings, num_embeddings + additional_embeddings]						,				-1_0_0_0_0.0 )
        causal_attention_mask.triu_(1 )
        __UpperCAmelCase    :						Optional[Any]       =						causal_attention_mask[None, ...]
        self.register_buffer('''causal_attention_mask'''						,				__lowercase						,				persistent=__lowercase )

        __UpperCAmelCase    :						Any       =						nn.Parameter(torch.zeros(1						,				__lowercase ) )
        __UpperCAmelCase    :						List[str]       =						nn.Parameter(torch.zeros(1						,				__lowercase ) )

      @property
      # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors
      def       A_					(							self       :      Optional[int] ):


        '''simple docstring'''




        __UpperCAmelCase    :						Optional[int]       =						{}

        def fn_recursive_add_processors(__lowercase       :      str						,				__lowercase       :      torch.nn.Module						,				__lowercase       :      Dict[str, AttentionProcessor] ):
          if hasattr(__lowercase						,				'''set_processor''' ):
            __UpperCAmelCase    :						Optional[Any]       =						module.processor

          for sub_name, child in module.named_children():
            fn_recursive_add_processors(f'''{name}.{sub_name}'''						,				__lowercase						,				__lowercase )

          return processors

        for name, module in self.named_children():
          fn_recursive_add_processors(__lowercase						,				__lowercase						,				__lowercase )

        return processors

      def       A_					(							self       :      Any						,				__lowercase       :      Union[AttentionProcessor, Dict[str, AttentionProcessor]] ):


        '''simple docstring'''




        __UpperCAmelCase    :						Tuple       =						len(self.attn_processors.keys() )

        if isinstance(__lowercase						,				__lowercase ) and len(__lowercase ) != count:
          raise ValueError(
              f'''A dict of processors was passed, but the number of processors {len(__lowercase )} does not match the'''
              f''' number of attention layers: {count}. Please make sure to pass {count} processor classes.''' )

        def fn_recursive_attn_processor(__lowercase       :      str						,				__lowercase       :      torch.nn.Module						,				__lowercase       :      int ):
          if hasattr(__lowercase						,				'''set_processor''' ):
            if not isinstance(__lowercase						,				__lowercase ):
              module.set_processor(__lowercase )
            else:
              module.set_processor(processor.pop(f'''{name}.processor''' ) )

          for sub_name, child in module.named_children():
            fn_recursive_attn_processor(f'''{name}.{sub_name}'''						,				__lowercase						,				__lowercase )

        for name, module in self.named_children():
          fn_recursive_attn_processor(__lowercase						,				__lowercase						,				__lowercase )

      def       A_					(							self       :      Optional[Any] ):


        '''simple docstring'''




        self.set_attn_processor(AttnProcessor() )

      def       A_					(							self       :      Optional[int]						,				__lowercase       :      Dict						,				__lowercase       :      Union[torch.Tensor, float, int]						,				__lowercase       :      torch.FloatTensor						,				__lowercase       :      Optional[torch.FloatTensor] = None						,				__lowercase       :      Optional[torch.BoolTensor] = None						,				__lowercase       :      bool = True						,				):


        '''simple docstring'''




        __UpperCAmelCase    :						List[Any]       =						hidden_states.shape[0]

        __UpperCAmelCase    :						Any       =						timestep
        if not torch.is_tensor(__lowercase ):
          __UpperCAmelCase    :						Union[str, Any]       =						torch.tensor([timesteps]						,				dtype=torch.long						,				device=hidden_states.device )
        elif torch.is_tensor(__lowercase ) and len(timesteps.shape ) == 0:
          __UpperCAmelCase    :						Union[str, Any]       =						timesteps[None].to(hidden_states.device )

        # broadcast to batch dimension in a way that's compatible with ONNX/Core ML
        __UpperCAmelCase    :						List[str]       =						timesteps * torch.ones(__lowercase						,				dtype=timesteps.dtype						,				device=timesteps.device )

        __UpperCAmelCase    :						List[str]       =						self.time_proj(__lowercase )

        # timesteps does not contain any weights and will always return f32 tensors
        # but time_embedding might be fp16, so we need to cast here.
        __UpperCAmelCase    :						Any       =						timesteps_projected.to(dtype=self.dtype )
        __UpperCAmelCase    :						List[str]       =						self.time_embedding(__lowercase )

        if self.embedding_proj_norm is not None:
          __UpperCAmelCase    :						Dict       =						self.embedding_proj_norm(__lowercase )

        __UpperCAmelCase    :						Optional[int]       =						self.embedding_proj(__lowercase )
        if self.encoder_hidden_states_proj is not None and encoder_hidden_states is not None:
          __UpperCAmelCase    :						Dict       =						self.encoder_hidden_states_proj(__lowercase )
        elif self.encoder_hidden_states_proj is not None and encoder_hidden_states is None:
          raise ValueError('''`encoder_hidden_states_proj` requires `encoder_hidden_states` to be set''' )

        __UpperCAmelCase    :						int       =						self.proj_in(__lowercase )

        __UpperCAmelCase    :						Tuple       =						self.positional_embedding.to(hidden_states.dtype )

        __UpperCAmelCase    :						Optional[Any]       =						[]
        __UpperCAmelCase    :						str       =						0

        if encoder_hidden_states is not None:
          additional_embeds.append(__lowercase )
          additional_embeddings_len += encoder_hidden_states.shape[1]

        if len(proj_embeddings.shape ) == 2:
          __UpperCAmelCase    :						str       =						proj_embeddings[:, None, :]

        if len(hidden_states.shape ) == 2:
          __UpperCAmelCase    :						Optional[int]       =						hidden_states[:, None, :]

        __UpperCAmelCase    :						str       =						additional_embeds + [
            proj_embeddings,
            time_embeddings[:, None, :],
            hidden_states,
        ]

        if self.prd_embedding is not None:
          __UpperCAmelCase    :						Dict       =						self.prd_embedding.to(hidden_states.dtype ).expand(__lowercase						,				-1						,				-1 )
          additional_embeds.append(__lowercase )

        __UpperCAmelCase    :						Optional[Any]       =						torch.cat(
            __lowercase						,				dim=1						,				)

        # Allow positional_embedding to not include the `addtional_embeddings` and instead pad it with zeros for these additional tokens
        __UpperCAmelCase    :						Optional[int]       =						additional_embeddings_len + proj_embeddings.shape[1] + 1
        if positional_embeddings.shape[1] < hidden_states.shape[1]:
          __UpperCAmelCase    :						List[str]       =						F.pad(
              __lowercase						,				(
                  0,
                  0,
                  additional_embeddings_len,
                  self.prd_embedding.shape[1] if self.prd_embedding is not None else 0,
              )						,				value=0.0						,				)

        __UpperCAmelCase    :						Dict       =						hidden_states + positional_embeddings

        if attention_mask is not None:
          __UpperCAmelCase    :						Optional[Any]       =						(1 - attention_mask.to(hidden_states.dtype )) * -1_0_0_0_0.0
          __UpperCAmelCase    :						Optional[Any]       =						F.pad(__lowercase						,				(0, self.additional_embeddings)						,				value=0.0 )
          __UpperCAmelCase    :						Dict       =						(attention_mask[:, None, :] + self.causal_attention_mask).to(hidden_states.dtype )
          __UpperCAmelCase    :						Tuple       =						attention_mask.repeat_interleave(self.config.num_attention_heads						,				dim=0 )

        if self.norm_in is not None:
          __UpperCAmelCase    :						str       =						self.norm_in(__lowercase )

        for block in self.transformer_blocks:
          __UpperCAmelCase    :						Dict       =						block(__lowercase						,				attention_mask=__lowercase )

        __UpperCAmelCase    :						Any       =						self.norm_out(__lowercase )

        if self.prd_embedding is not None:
          __UpperCAmelCase    :						List[Any]       =						hidden_states[:, -1]
        else:
          __UpperCAmelCase    :						List[str]       =						hidden_states[:, additional_embeddings_len:]

        __UpperCAmelCase    :						Optional[int]       =						self.proj_to_clip_embeddings(__lowercase )

        if not return_dict:
          return (predicted_image_embedding,)

        return PriorTransformerOutput(predicted_image_embedding=__lowercase )







      def       A_					(							self       :      List[Any]						,				__lowercase       :      Optional[int] ):


        '''simple docstring'''




        __UpperCAmelCase    :						List[str]       =						(prior_latents * self.clip_std) + self.clip_mean
        return prior_latents