



import gc
import unittest

from parameterized import parameterized

from diffusers import FlaxUNetaDConditionModel
from diffusers.utils import is_flax_available
from diffusers.utils.testing_utils import load_hf_numpy, require_flax, slow


if is_flax_available():
    import jax
    import jax.numpy as jnp



@slow
@require_flax
class 				lowerCAmelCase_		(  unittest.TestCase							):
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )     ->		List[str]:
          return F"""gaussian_noise_s={seed}_shape={"_".join([str(SCREAMING_SNAKE_CASE_       ) for s in shape]       )}.npy"""
       def 					snake_case_       (			self       )     ->		Optional[Any]:
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_=0,			SCREAMING_SNAKE_CASE_=(4, 4, 64, 64),			SCREAMING_SNAKE_CASE_=False       )     ->		Union[str, Any]:
          UpperCamelCase    :  Dict							=	jnp.bfloataa if fpaa else jnp.floataa
          UpperCamelCase    :  List[str]							=	jnp.array(load_hf_numpy(self.get_file_format(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )       ),			dtype=SCREAMING_SNAKE_CASE_       )
          return image
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_=False,			SCREAMING_SNAKE_CASE_="CompVis/stable-diffusion-v1-4"       )     ->		Tuple:
          UpperCamelCase    :  Dict							=	jnp.bfloataa if fpaa else jnp.floataa
          UpperCamelCase    :  Union[str, Any]							=	'bf16' if fpaa else None

          UpperCamelCase	,     UpperCamelCase    :  Dict							=	FlaxUNetaDConditionModel.from_pretrained(
              SCREAMING_SNAKE_CASE_,			subfolder='unet',			dtype=SCREAMING_SNAKE_CASE_,			revision=SCREAMING_SNAKE_CASE_       )
          return model, params
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_=0,			SCREAMING_SNAKE_CASE_=(4, 77, 768),			SCREAMING_SNAKE_CASE_=False       )     ->		int:
          UpperCamelCase    :  Any							=	jnp.bfloataa if fpaa else jnp.floataa
          UpperCamelCase    :  List[str]							=	jnp.array(load_hf_numpy(self.get_file_format(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )       ),			dtype=SCREAMING_SNAKE_CASE_       )
          return hidden_states
       @parameterized.expand(
           [
               # fmt: off
               [83, 4, [-0.23_23, -0.13_04, 0.08_13, -0.30_93, -0.09_19, -0.15_71, -0.11_25, -0.58_06]],
               [17, 0.55, [-0.08_31, -0.24_43, 0.09_01, -0.09_19, 0.33_96, 0.01_03, -0.37_43, 0.07_01]],
               [8, 0.89, [-0.48_63, 0.08_59, 0.08_75, -0.16_58, 0.91_99, -0.01_14, 0.48_39, 0.46_39]],
               [3, 1000, [-0.56_49, 0.24_02, -0.55_18, 0.12_48, 1.13_28, -0.24_43, -0.03_25, -1.00_78]],
               # fmt: on
           ]       )
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )     ->		List[Any]:
          UpperCamelCase	,     UpperCamelCase    :  Union[str, Any]							=	self.get_unet_model(model_id='CompVis/stable-diffusion-v1-4',			fpaa=SCREAMING_SNAKE_CASE_       )
          UpperCamelCase    :  Union[str, Any]							=	self.get_latents(SCREAMING_SNAKE_CASE_,			fpaa=SCREAMING_SNAKE_CASE_       )
          UpperCamelCase    :  Dict							=	self.get_encoder_hidden_states(SCREAMING_SNAKE_CASE_,			fpaa=SCREAMING_SNAKE_CASE_       )

          UpperCamelCase    :  Tuple							=	model.apply(
              {'params': params},			SCREAMING_SNAKE_CASE_,			jnp.array(SCREAMING_SNAKE_CASE_,			dtype=jnp.intaa       ),			encoder_hidden_states=SCREAMING_SNAKE_CASE_,			).sample

          assert sample.shape == latents.shape

          UpperCamelCase    :  Any							=	jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten())       ),			dtype=jnp.floataa       )
          UpperCamelCase    :  Any							=	jnp.array(SCREAMING_SNAKE_CASE_,			dtype=jnp.floataa       )

          # Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, in the same hardware
          assert jnp.allclose(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			atol=1e-2       )






       @parameterized.expand(
           [
               # fmt: off
               [83, 4, [0.15_14, 0.08_07, 0.16_24, 0.10_16, -0.18_96, 0.02_63, 0.06_77, 0.23_10]],
               [17, 0.55, [0.11_64, -0.02_16, 0.01_70, 0.15_89, -0.31_20, 0.10_05, -0.05_81, -0.14_58]],
               [8, 0.89, [-0.17_58, -0.01_69, 0.10_04, -0.14_11, 0.13_12, 0.11_03, -0.19_96, 0.21_39]],
               [3, 1000, [0.12_14, 0.03_52, -0.07_31, -0.15_62, -0.09_94, -0.09_06, -0.23_40, -0.05_39]],
               # fmt: on
           ]       )
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )     ->		List[str]:
          UpperCamelCase	,     UpperCamelCase    :  List[str]							=	self.get_unet_model(model_id='stabilityai/stable-diffusion-2',			fpaa=SCREAMING_SNAKE_CASE_       )
          UpperCamelCase    :  Union[str, Any]							=	self.get_latents(SCREAMING_SNAKE_CASE_,			shape=(4, 4, 96, 96),			fpaa=SCREAMING_SNAKE_CASE_       )
          UpperCamelCase    :  Any							=	self.get_encoder_hidden_states(SCREAMING_SNAKE_CASE_,			shape=(4, 77, 1024),			fpaa=SCREAMING_SNAKE_CASE_       )

          UpperCamelCase    :  List[str]							=	model.apply(
              {'params': params},			SCREAMING_SNAKE_CASE_,			jnp.array(SCREAMING_SNAKE_CASE_,			dtype=jnp.intaa       ),			encoder_hidden_states=SCREAMING_SNAKE_CASE_,			).sample

          assert sample.shape == latents.shape

          UpperCamelCase    :  Tuple							=	jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten())       ),			dtype=jnp.floataa       )
          UpperCamelCase    :  Optional[int]							=	jnp.array(SCREAMING_SNAKE_CASE_,			dtype=jnp.floataa       )

          # Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, on the same hardware
          assert jnp.allclose(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			atol=1e-2       )








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


__UpperCAmelCase          =       {
    '''configuration_transfo_xl''': ['''TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''TransfoXLConfig'''],
    '''tokenization_transfo_xl''': ['''TransfoXLCorpus''', '''TransfoXLTokenizer'''],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCAmelCase          =       [
        '''TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''AdaptiveEmbedding''',
        '''TransfoXLForSequenceClassification''',
        '''TransfoXLLMHeadModel''',
        '''TransfoXLModel''',
        '''TransfoXLPreTrainedModel''',
        '''load_tf_weights_in_transfo_xl''',
    ]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCAmelCase          =       [
        '''TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''TFAdaptiveEmbedding''',
        '''TFTransfoXLForSequenceClassification''',
        '''TFTransfoXLLMHeadModel''',
        '''TFTransfoXLMainLayer''',
        '''TFTransfoXLModel''',
        '''TFTransfoXLPreTrainedModel''',
    ]


if TYPE_CHECKING:
    from .configuration_transfo_xl import TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, TransfoXLConfig
    from .tokenization_transfo_xl import TransfoXLCorpus, TransfoXLTokenizer

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_transfo_xl import (
            TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
            AdaptiveEmbedding,
            TransfoXLForSequenceClassification,
            TransfoXLLMHeadModel,
            TransfoXLModel,
            TransfoXLPreTrainedModel,
            load_tf_weights_in_transfo_xl,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_transfo_xl import (
            TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFAdaptiveEmbedding,
            TFTransfoXLForSequenceClassification,
            TFTransfoXLLMHeadModel,
            TFTransfoXLMainLayer,
            TFTransfoXLModel,
            TFTransfoXLPreTrainedModel,
        )

else:
    import sys

    __UpperCAmelCase          =       _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



