




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 			_UpperCamelCase      (				unittest.TestCase		):
      def 	UpperCAmelCase_						(			self   :Optional[int] ,      lowerCamelCase   :Union[str, Any] ,      lowerCamelCase   :Optional[Any]      )     ->			Tuple:
       return f'''gaussian_noise_s={seed}_shape={"_".join([str(lowerCamelCase      ) for s in shape]      )}.npy'''
      def 	UpperCAmelCase_						(			self   :Any      )     ->			Union[str, Any]:
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
      def 	UpperCAmelCase_						(			self   :Optional[Any] ,      lowerCamelCase   :str=0 ,      lowerCamelCase   :Optional[int]=(4, 4, 64, 64) ,      lowerCamelCase   :List[str]=False      )     ->			Dict:
       UpperCAmelCase__							 =						jnp.bfloataa if fpaa else jnp.floataa
       UpperCAmelCase__							 =						jnp.array(load_hf_numpy(self.get_file_format(lowerCamelCase ,      lowerCamelCase      )      ) ,      dtype=lowerCamelCase      )
       return image
      def 	UpperCAmelCase_						(			self   :Tuple ,      lowerCamelCase   :Dict=False ,      lowerCamelCase   :List[Any]="CompVis/stable-diffusion-v1-4"      )     ->			Optional[Any]:
       UpperCAmelCase__							 =						jnp.bfloataa if fpaa else jnp.floataa
       UpperCAmelCase__							 =						"bf16" if fpaa else None

       UpperCAmelCase__ , UpperCAmelCase__							 =						FlaxUNetaDConditionModel.from_pretrained(
           lowerCamelCase ,      subfolder="unet" ,      dtype=lowerCamelCase ,      revision=lowerCamelCase      )
       return model, params
      def 	UpperCAmelCase_						(			self   :Dict ,      lowerCamelCase   :Tuple=0 ,      lowerCamelCase   :Dict=(4, 77, 768) ,      lowerCamelCase   :Optional[int]=False      )     ->			str:
       UpperCAmelCase__							 =						jnp.bfloataa if fpaa else jnp.floataa
       UpperCAmelCase__							 =						jnp.array(load_hf_numpy(self.get_file_format(lowerCamelCase ,      lowerCamelCase      )      ) ,      dtype=lowerCamelCase      )
       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 	UpperCAmelCase_						(			self   :Tuple ,      lowerCamelCase   :List[str] ,      lowerCamelCase   :Optional[int] ,      lowerCamelCase   :List[Any]      )     ->			str:
       UpperCAmelCase__ , UpperCAmelCase__							 =						self.get_unet_model(model_id="CompVis/stable-diffusion-v1-4" ,      fpaa=lowerCamelCase      )
       UpperCAmelCase__							 =						self.get_latents(lowerCamelCase ,      fpaa=lowerCamelCase      )
       UpperCAmelCase__							 =						self.get_encoder_hidden_states(lowerCamelCase ,      fpaa=lowerCamelCase      )

       UpperCAmelCase__							 =						model.apply(
           {"params": params} ,      lowerCamelCase ,      jnp.array(lowerCamelCase ,      dtype=jnp.intaa      ) ,      encoder_hidden_states=lowerCamelCase ,      ).sample

       assert sample.shape == latents.shape

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

       # Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, in the same hardware
       assert jnp.allclose(lowerCamelCase ,      lowerCamelCase ,      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 	UpperCAmelCase_						(			self   :Optional[int] ,      lowerCamelCase   :Union[str, Any] ,      lowerCamelCase   :Dict ,      lowerCamelCase   :Any      )     ->			str:
       UpperCAmelCase__ , UpperCAmelCase__							 =						self.get_unet_model(model_id="stabilityai/stable-diffusion-2" ,      fpaa=lowerCamelCase      )
       UpperCAmelCase__							 =						self.get_latents(lowerCamelCase ,      shape=(4, 4, 96, 96) ,      fpaa=lowerCamelCase      )
       UpperCAmelCase__							 =						self.get_encoder_hidden_states(lowerCamelCase ,      shape=(4, 77, 1024) ,      fpaa=lowerCamelCase      )

       UpperCAmelCase__							 =						model.apply(
           {"params": params} ,      lowerCamelCase ,      jnp.array(lowerCamelCase ,      dtype=jnp.intaa      ) ,      encoder_hidden_states=lowerCamelCase ,      ).sample

       assert sample.shape == latents.shape

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

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











from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tensorflow_text_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_lowerCAmelCase						:   Union[str, Any]		=   {
    "configuration_bert": ["BERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "BertConfig", "BertOnnxConfig"],
    "tokenization_bert": ["BasicTokenizer", "BertTokenizer", "WordpieceTokenizer"],
}

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCAmelCase						:   str		=   ["BertTokenizerFast"]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCAmelCase						:   int		=   [
      "BERT_PRETRAINED_MODEL_ARCHIVE_LIST",
      "BertForMaskedLM",
      "BertForMultipleChoice",
      "BertForNextSentencePrediction",
      "BertForPreTraining",
      "BertForQuestionAnswering",
      "BertForSequenceClassification",
      "BertForTokenClassification",
      "BertLayer",
      "BertLMHeadModel",
      "BertModel",
      "BertPreTrainedModel",
      "load_tf_weights_in_bert",
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCAmelCase						:   Dict		=   [
      "TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST",
      "TFBertEmbeddings",
      "TFBertForMaskedLM",
      "TFBertForMultipleChoice",
      "TFBertForNextSentencePrediction",
      "TFBertForPreTraining",
      "TFBertForQuestionAnswering",
      "TFBertForSequenceClassification",
      "TFBertForTokenClassification",
      "TFBertLMHeadModel",
      "TFBertMainLayer",
      "TFBertModel",
      "TFBertPreTrainedModel",
  ]
try:
  if not is_tensorflow_text_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCAmelCase						:   str		=   ["TFBertTokenizer"]

try:
  if not is_flax_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCAmelCase						:   Optional[Any]		=   [
      "FlaxBertForCausalLM",
      "FlaxBertForMaskedLM",
      "FlaxBertForMultipleChoice",
      "FlaxBertForNextSentencePrediction",
      "FlaxBertForPreTraining",
      "FlaxBertForQuestionAnswering",
      "FlaxBertForSequenceClassification",
      "FlaxBertForTokenClassification",
      "FlaxBertModel",
      "FlaxBertPreTrainedModel",
  ]

if TYPE_CHECKING:
  from .configuration_bert import BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BertConfig, BertOnnxConfig
  from .tokenization_bert import BasicTokenizer, BertTokenizer, WordpieceTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_bert_fast import BertTokenizerFast

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_bert import (
        BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        BertForMaskedLM,
        BertForMultipleChoice,
        BertForNextSentencePrediction,
        BertForPreTraining,
        BertForQuestionAnswering,
        BertForSequenceClassification,
        BertForTokenClassification,
        BertLayer,
        BertLMHeadModel,
        BertModel,
        BertPreTrainedModel,
        load_tf_weights_in_bert,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_bert import (
        TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFBertEmbeddings,
        TFBertForMaskedLM,
        TFBertForMultipleChoice,
        TFBertForNextSentencePrediction,
        TFBertForPreTraining,
        TFBertForQuestionAnswering,
        TFBertForSequenceClassification,
        TFBertForTokenClassification,
        TFBertLMHeadModel,
        TFBertMainLayer,
        TFBertModel,
        TFBertPreTrainedModel,
    )

  try:
    if not is_tensorflow_text_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_bert_tf import TFBertTokenizer

  try:
    if not is_flax_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_flax_bert import (
        FlaxBertForCausalLM,
        FlaxBertForMaskedLM,
        FlaxBertForMultipleChoice,
        FlaxBertForNextSentencePrediction,
        FlaxBertForPreTraining,
        FlaxBertForQuestionAnswering,
        FlaxBertForSequenceClassification,
        FlaxBertForTokenClassification,
        FlaxBertModel,
        FlaxBertPreTrainedModel,
    )

else:
  import sys

  _lowerCAmelCase						:   Union[str, Any]		=   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





