


"""simple docstring"""





import os
import tempfile
import unittest

import numpy as np

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


if is_flax_available():
 import jax
 import jax.numpy as jnp
 from flax.jax_utils import replicate
 from flax.training.common_utils import shard

 from diffusers import FlaxDDIMScheduler, FlaxDiffusionPipeline, FlaxStableDiffusionPipeline



@require_flax
class 						snake_case_(				unittest.TestCase	):






     def    lowerCamelCase__   (		self     :    int ):
           with tempfile.TemporaryDirectory() as tmpdirname:
                 # pipeline has Flax weights
                 lowerCAmelCase    :		int				=      FlaxDiffusionPipeline.from_pretrained(
                     '''hf-internal-testing/tiny-stable-diffusion-pipe'''    , safety_checker=UpperCamelCase_    , cache_dir=UpperCamelCase_ )

                 lowerCAmelCase    :		List[Any]				=      [t[-1] for t in os.walk(os.path.join(UpperCamelCase_    , os.listdir(UpperCamelCase_ )[0]    , '''snapshots''' ) )]
                 lowerCAmelCase    :		Dict				=      [item for sublist in all_root_files for item in sublist]

                 # None of the downloaded files should be a PyTorch file even if we have some here:
                 # https://huggingface.co/hf-internal-testing/tiny-stable-diffusion-pipe/blob/main/unet/diffusion_pytorch_model.bin
                 assert not any(f.endswith('''.bin''' ) for f in files )



@slow
@require_flax
class 						snake_case_(				unittest.TestCase	):






     def    lowerCamelCase__   (		self     :    List[Any] ):
           lowerCAmelCase,					lowerCAmelCase    :		int				=      FlaxStableDiffusionPipeline.from_pretrained(
               '''hf-internal-testing/tiny-stable-diffusion-pipe'''    , safety_checker=UpperCamelCase_ )

           lowerCAmelCase    :		Tuple				=      (
               '''A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of'''
               ''' field, close up, split lighting, cinematic'''
           )

           lowerCAmelCase    :		List[Any]				=      jax.random.PRNGKey(0 )
           lowerCAmelCase    :		Any				=      4

           lowerCAmelCase    :		Union[str, Any]				=      jax.device_count()
           lowerCAmelCase    :		int				=      num_samples * [prompt]
           lowerCAmelCase    :		Any				=      pipeline.prepare_inputs(UpperCamelCase_ )

           # shard inputs and rng
           lowerCAmelCase    :		int				=      replicate(UpperCamelCase_ )
           lowerCAmelCase    :		Dict				=      jax.random.split(UpperCamelCase_    , UpperCamelCase_ )
           lowerCAmelCase    :		Any				=      shard(UpperCamelCase_ )

           lowerCAmelCase    :		Union[str, Any]				=      pipeline(UpperCamelCase_    , UpperCamelCase_    , UpperCamelCase_    , UpperCamelCase_    , jit=UpperCamelCase_ ).images

           assert images.shape == (num_samples, 1, 6_4, 6_4, 3)
           if jax.device_count() == 8:
                 assert np.abs(np.abs(images[0, 0, :2, :2, -2:]    , dtype=np.floataa ).sum() - 4.1_514_745 ) < 1E-3
                 assert np.abs(np.abs(UpperCamelCase_    , dtype=np.floataa ).sum() - 49_947.875 ) < 5E-1

           lowerCAmelCase    :		Union[str, Any]				=      pipeline.numpy_to_pil(np.asarray(images.reshape((num_samples,) + images.shape[-3:] ) ) )
           assert len(UpperCamelCase_ ) == num_samples






     def    lowerCamelCase__   (		self     :    Union[str, Any] ):
           lowerCAmelCase,					lowerCAmelCase    :		List[Any]				=      FlaxStableDiffusionPipeline.from_pretrained(
               '''CompVis/stable-diffusion-v1-4'''    , revision='''flax'''    , safety_checker=UpperCamelCase_ )

           lowerCAmelCase    :		str				=      (
               '''A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of'''
               ''' field, close up, split lighting, cinematic'''
           )

           lowerCAmelCase    :		Union[str, Any]				=      jax.random.PRNGKey(0 )
           lowerCAmelCase    :		List[str]				=      5_0

           lowerCAmelCase    :		Optional[int]				=      jax.device_count()
           lowerCAmelCase    :		Optional[Any]				=      num_samples * [prompt]
           lowerCAmelCase    :		List[str]				=      pipeline.prepare_inputs(UpperCamelCase_ )

           # shard inputs and rng
           lowerCAmelCase    :		Union[str, Any]				=      replicate(UpperCamelCase_ )
           lowerCAmelCase    :		Dict				=      jax.random.split(UpperCamelCase_    , UpperCamelCase_ )
           lowerCAmelCase    :		Tuple				=      shard(UpperCamelCase_ )

           lowerCAmelCase    :		Union[str, Any]				=      pipeline(UpperCamelCase_    , UpperCamelCase_    , UpperCamelCase_    , UpperCamelCase_    , jit=UpperCamelCase_ ).images

           assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
           if jax.device_count() == 8:
                 assert np.abs((np.abs(images[0, 0, :2, :2, -2:]    , dtype=np.floataa ).sum() - 0.05_652_401) ) < 1E-3
                 assert np.abs((np.abs(UpperCamelCase_    , dtype=np.floataa ).sum() - 2_383_808.2) ) < 5E-1






     def    lowerCamelCase__   (		self     :    Optional[int] ):
           lowerCAmelCase,					lowerCAmelCase    :		List[str]				=      FlaxStableDiffusionPipeline.from_pretrained(
               '''CompVis/stable-diffusion-v1-4'''    , revision='''bf16'''    , dtype=jnp.bfloataa    , safety_checker=UpperCamelCase_ )

           lowerCAmelCase    :		List[str]				=      (
               '''A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of'''
               ''' field, close up, split lighting, cinematic'''
           )

           lowerCAmelCase    :		int				=      jax.random.PRNGKey(0 )
           lowerCAmelCase    :		List[str]				=      5_0

           lowerCAmelCase    :		Optional[Any]				=      jax.device_count()
           lowerCAmelCase    :		List[str]				=      num_samples * [prompt]
           lowerCAmelCase    :		Union[str, Any]				=      pipeline.prepare_inputs(UpperCamelCase_ )

           # shard inputs and rng
           lowerCAmelCase    :		Tuple				=      replicate(UpperCamelCase_ )
           lowerCAmelCase    :		Optional[Any]				=      jax.random.split(UpperCamelCase_    , UpperCamelCase_ )
           lowerCAmelCase    :		List[str]				=      shard(UpperCamelCase_ )

           lowerCAmelCase    :		str				=      pipeline(UpperCamelCase_    , UpperCamelCase_    , UpperCamelCase_    , UpperCamelCase_    , jit=UpperCamelCase_ ).images

           assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
           if jax.device_count() == 8:
                 assert np.abs((np.abs(images[0, 0, :2, :2, -2:]    , dtype=np.floataa ).sum() - 0.04_003_906) ) < 1E-3
                 assert np.abs((np.abs(UpperCamelCase_    , dtype=np.floataa ).sum() - 2_373_516.75) ) < 5E-1






     def    lowerCamelCase__   (		self     :    Dict ):
           lowerCAmelCase,					lowerCAmelCase    :		Tuple				=      FlaxStableDiffusionPipeline.from_pretrained(
               '''CompVis/stable-diffusion-v1-4'''    , revision='''bf16'''    , dtype=jnp.bfloataa )

           lowerCAmelCase    :		int				=      (
               '''A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of'''
               ''' field, close up, split lighting, cinematic'''
           )

           lowerCAmelCase    :		Optional[int]				=      jax.random.PRNGKey(0 )
           lowerCAmelCase    :		List[Any]				=      5_0

           lowerCAmelCase    :		Dict				=      jax.device_count()
           lowerCAmelCase    :		Optional[int]				=      num_samples * [prompt]
           lowerCAmelCase    :		Any				=      pipeline.prepare_inputs(UpperCamelCase_ )

           # shard inputs and rng
           lowerCAmelCase    :		str				=      replicate(UpperCamelCase_ )
           lowerCAmelCase    :		Union[str, Any]				=      jax.random.split(UpperCamelCase_    , UpperCamelCase_ )
           lowerCAmelCase    :		List[Any]				=      shard(UpperCamelCase_ )

           lowerCAmelCase    :		Tuple				=      pipeline(UpperCamelCase_    , UpperCamelCase_    , UpperCamelCase_    , UpperCamelCase_    , jit=UpperCamelCase_ ).images

           assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
           if jax.device_count() == 8:
                 assert np.abs((np.abs(images[0, 0, :2, :2, -2:]    , dtype=np.floataa ).sum() - 0.04_003_906) ) < 1E-3
                 assert np.abs((np.abs(UpperCamelCase_    , dtype=np.floataa ).sum() - 2_373_516.75) ) < 5E-1






     def    lowerCamelCase__   (		self     :    int ):
           lowerCAmelCase    :		int				=      FlaxDDIMScheduler(
               beta_start=0.00_085    , beta_end=0.012    , beta_schedule='''scaled_linear'''    , set_alpha_to_one=UpperCamelCase_    , steps_offset=1    , )

           lowerCAmelCase,					lowerCAmelCase    :		Any				=      FlaxStableDiffusionPipeline.from_pretrained(
               '''CompVis/stable-diffusion-v1-4'''    , revision='''bf16'''    , dtype=jnp.bfloataa    , scheduler=UpperCamelCase_    , safety_checker=UpperCamelCase_    , )
           lowerCAmelCase    :		int				=      scheduler.create_state()

           lowerCAmelCase    :		Union[str, Any]				=      scheduler_state

           lowerCAmelCase    :		Optional[int]				=      (
               '''A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of'''
               ''' field, close up, split lighting, cinematic'''
           )

           lowerCAmelCase    :		List[Any]				=      jax.random.PRNGKey(0 )
           lowerCAmelCase    :		List[str]				=      5_0

           lowerCAmelCase    :		Union[str, Any]				=      jax.device_count()
           lowerCAmelCase    :		Optional[Any]				=      num_samples * [prompt]
           lowerCAmelCase    :		Any				=      pipeline.prepare_inputs(UpperCamelCase_ )

           # shard inputs and rng
           lowerCAmelCase    :		int				=      replicate(UpperCamelCase_ )
           lowerCAmelCase    :		List[Any]				=      jax.random.split(UpperCamelCase_    , UpperCamelCase_ )
           lowerCAmelCase    :		Optional[Any]				=      shard(UpperCamelCase_ )

           lowerCAmelCase    :		Tuple				=      pipeline(UpperCamelCase_    , UpperCamelCase_    , UpperCamelCase_    , UpperCamelCase_    , jit=UpperCamelCase_ ).images

           assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
           if jax.device_count() == 8:
                 assert np.abs((np.abs(images[0, 0, :2, :2, -2:]    , dtype=np.floataa ).sum() - 0.045_043_945) ) < 1E-3
                 assert np.abs((np.abs(UpperCamelCase_    , dtype=np.floataa ).sum() - 2_347_693.5) ) < 5E-1






     def    lowerCamelCase__   (		self     :    str ):
           lowerCAmelCase    :		Tuple				=      (
               '''A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of'''
               ''' field, close up, split lighting, cinematic'''
           )

           lowerCAmelCase    :		Union[str, Any]				=      jax.device_count()
           lowerCAmelCase    :		List[str]				=      num_samples * [prompt]
           lowerCAmelCase    :		str				=      jax.random.split(jax.random.PRNGKey(0 )    , UpperCamelCase_ )

           lowerCAmelCase,					lowerCAmelCase    :		Optional[Any]				=      FlaxStableDiffusionPipeline.from_pretrained(
               '''CompVis/stable-diffusion-v1-4'''    , revision='''bf16'''    , dtype=jnp.bfloataa    , safety_checker=UpperCamelCase_    , )

           lowerCAmelCase    :		int				=      replicate(UpperCamelCase_ )
           lowerCAmelCase    :		Any				=      pipeline.prepare_inputs(UpperCamelCase_ )
           lowerCAmelCase    :		List[str]				=      shard(UpperCamelCase_ )
           lowerCAmelCase    :		Optional[int]				=      pipeline(UpperCamelCase_    , UpperCamelCase_    , UpperCamelCase_    , jit=UpperCamelCase_ ).images
           assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
           lowerCAmelCase    :		List[Any]				=      images[2, 0, 2_5_6, 1_0:1_7, 1]

           # With memory efficient attention
           lowerCAmelCase,					lowerCAmelCase    :		str				=      FlaxStableDiffusionPipeline.from_pretrained(
               '''CompVis/stable-diffusion-v1-4'''    , revision='''bf16'''    , dtype=jnp.bfloataa    , safety_checker=UpperCamelCase_    , use_memory_efficient_attention=UpperCamelCase_    , )

           lowerCAmelCase    :		List[str]				=      replicate(UpperCamelCase_ )
           lowerCAmelCase    :		str				=      pipeline.prepare_inputs(UpperCamelCase_ )
           lowerCAmelCase    :		int				=      shard(UpperCamelCase_ )
           lowerCAmelCase    :		Optional[int]				=      pipeline(UpperCamelCase_    , UpperCamelCase_    , UpperCamelCase_    , jit=UpperCamelCase_ ).images
           assert images_eff.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
           lowerCAmelCase    :		Dict				=      images[2, 0, 2_5_6, 1_0:1_7, 1]

           # I checked the results visually and they are very similar. However, I saw that the max diff is `1` and the `sum`
           # over the 8 images is exactly `256`, which is very suspicious. Testing a random slice for now.
           assert abs(slice_eff - slice ).max() < 1E-2






"""simple docstring"""





import unittest

import numpy as np

from transformers import RobertaPreLayerNormConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
 import jax.numpy as jnp

 from transformers.models.roberta_prelayernorm.modeling_flax_roberta_prelayernorm import (
     FlaxRobertaPreLayerNormForCausalLM,
     FlaxRobertaPreLayerNormForMaskedLM,
     FlaxRobertaPreLayerNormForMultipleChoice,
     FlaxRobertaPreLayerNormForQuestionAnswering,
     FlaxRobertaPreLayerNormForSequenceClassification,
     FlaxRobertaPreLayerNormForTokenClassification,
     FlaxRobertaPreLayerNormModel,
 )



class 						snake_case_(				unittest.TestCase	):






     def __init__(		self     :    List[Any]    , UpperCamelCase_     :    Union[str, Any]    , UpperCamelCase_     :    List[Any]=1_3    , UpperCamelCase_     :    Tuple=7    , UpperCamelCase_     :    List[Any]=True    , UpperCamelCase_     :    int=True    , UpperCamelCase_     :    Union[str, Any]=True    , UpperCamelCase_     :    Optional[Any]=True    , UpperCamelCase_     :    List[str]=9_9    , UpperCamelCase_     :    str=3_2    , UpperCamelCase_     :    Union[str, Any]=5    , UpperCamelCase_     :    int=4    , UpperCamelCase_     :    Optional[Any]=3_7    , UpperCamelCase_     :    Optional[int]="gelu"    , UpperCamelCase_     :    Any=0.1    , UpperCamelCase_     :    List[str]=0.1    , UpperCamelCase_     :    str=5_1_2    , UpperCamelCase_     :    Optional[Any]=1_6    , UpperCamelCase_     :    Union[str, Any]=2    , UpperCamelCase_     :    Any=0.02    , UpperCamelCase_     :    Union[str, Any]=4    , ):
           lowerCAmelCase    :		str				=      parent
           lowerCAmelCase    :		List[str]				=      batch_size
           lowerCAmelCase    :		int				=      seq_length
           lowerCAmelCase    :		str				=      is_training
           lowerCAmelCase    :		Tuple				=      use_attention_mask
           lowerCAmelCase    :		Dict				=      use_token_type_ids
           lowerCAmelCase    :		Optional[int]				=      use_labels
           lowerCAmelCase    :		Optional[Any]				=      vocab_size
           lowerCAmelCase    :		Optional[int]				=      hidden_size
           lowerCAmelCase    :		Optional[Any]				=      num_hidden_layers
           lowerCAmelCase    :		str				=      num_attention_heads
           lowerCAmelCase    :		Optional[Any]				=      intermediate_size
           lowerCAmelCase    :		int				=      hidden_act
           lowerCAmelCase    :		int				=      hidden_dropout_prob
           lowerCAmelCase    :		Tuple				=      attention_probs_dropout_prob
           lowerCAmelCase    :		str				=      max_position_embeddings
           lowerCAmelCase    :		str				=      type_vocab_size
           lowerCAmelCase    :		str				=      type_sequence_label_size
           lowerCAmelCase    :		Any				=      initializer_range
           lowerCAmelCase    :		int				=      num_choices






     def    lowerCamelCase__   (		self     :    Optional[int] ):
           lowerCAmelCase    :		Tuple				=      ids_tensor([self.batch_size, self.seq_length]    , self.vocab_size )

           lowerCAmelCase    :		Optional[int]				=      None
           if self.use_attention_mask:
                 lowerCAmelCase    :		Union[str, Any]				=      random_attention_mask([self.batch_size, self.seq_length] )

           lowerCAmelCase    :		Union[str, Any]				=      None
           if self.use_token_type_ids:
                 lowerCAmelCase    :		Dict				=      ids_tensor([self.batch_size, self.seq_length]    , self.type_vocab_size )

           lowerCAmelCase    :		Union[str, Any]				=      RobertaPreLayerNormConfig(
               vocab_size=self.vocab_size    , hidden_size=self.hidden_size    , num_hidden_layers=self.num_hidden_layers    , num_attention_heads=self.num_attention_heads    , intermediate_size=self.intermediate_size    , hidden_act=self.hidden_act    , hidden_dropout_prob=self.hidden_dropout_prob    , attention_probs_dropout_prob=self.attention_probs_dropout_prob    , max_position_embeddings=self.max_position_embeddings    , type_vocab_size=self.type_vocab_size    , is_decoder=UpperCamelCase_    , initializer_range=self.initializer_range    , )

           return config, input_ids, token_type_ids, attention_mask






     def    lowerCamelCase__   (		self     :    int ):
           lowerCAmelCase    :		List[str]				=      self.prepare_config_and_inputs()
           lowerCAmelCase,					lowerCAmelCase,					lowerCAmelCase,					lowerCAmelCase    :		Optional[Any]				=      config_and_inputs
           lowerCAmelCase    :		Optional[Any]				=      {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': attention_mask}
           return config, inputs_dict






     def    lowerCamelCase__   (		self     :    List[str] ):
           lowerCAmelCase    :		int				=      self.prepare_config_and_inputs()
           lowerCAmelCase,					lowerCAmelCase,					lowerCAmelCase,					lowerCAmelCase    :		Tuple				=      config_and_inputs

           lowerCAmelCase    :		str				=      True
           lowerCAmelCase    :		Optional[Any]				=      floats_tensor([self.batch_size, self.seq_length, self.hidden_size] )
           lowerCAmelCase    :		str				=      ids_tensor([self.batch_size, self.seq_length]    , vocab_size=2 )

           return (
               config,
               input_ids,
               token_type_ids,
               encoder_hidden_states,
               encoder_attention_mask,
           )



@require_flax
# Copied from tests.models.roberta.test_modelling_flax_roberta.FlaxRobertaPreLayerNormModelTest with ROBERTA->ROBERTA_PRELAYERNORM,Roberta->RobertaPreLayerNorm,roberta-base->andreasmadsen/efficient_mlm_m0.40
class 						snake_case_(				a__							,    unittest.TestCase	):
     __UpperCamelCase     =    True

     __UpperCamelCase     =    (
         (
             FlaxRobertaPreLayerNormModel,
             FlaxRobertaPreLayerNormForCausalLM,
             FlaxRobertaPreLayerNormForMaskedLM,
             FlaxRobertaPreLayerNormForSequenceClassification,
             FlaxRobertaPreLayerNormForTokenClassification,
             FlaxRobertaPreLayerNormForMultipleChoice,
             FlaxRobertaPreLayerNormForQuestionAnswering,
         )
         if is_flax_available()
         else ()
     )






     def    lowerCamelCase__   (		self     :    List[Any] ):
           lowerCAmelCase    :		Any				=      FlaxRobertaPreLayerNormModelTester(self )






     @slow
     def    lowerCamelCase__   (		self     :    List[str] ):
           for model_class_name in self.all_model_classes:
                 lowerCAmelCase    :		Optional[int]				=      model_class_name.from_pretrained('''andreasmadsen/efficient_mlm_m0.40'''    , from_pt=UpperCamelCase_ )
                 lowerCAmelCase    :		int				=      model(np.ones((1, 1) ) )
                 self.assertIsNotNone(UpperCamelCase_ )



@require_flax
class 						snake_case_(				unittest.TestCase	):






     @slow
     def    lowerCamelCase__   (		self     :    List[str] ):
           lowerCAmelCase    :		str				=      FlaxRobertaPreLayerNormForMaskedLM.from_pretrained('''andreasmadsen/efficient_mlm_m0.40'''    , from_pt=UpperCamelCase_ )

           lowerCAmelCase    :		Any				=      np.array([[0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9, 4_6_0_7_8, 1_5_8_8, 2]]    , dtype=jnp.intaa )
           lowerCAmelCase    :		Union[str, Any]				=      model(UpperCamelCase_ )[0]
           lowerCAmelCase    :		str				=      [1, 1_1, 5_0_2_6_5]
           self.assertEqual(list(output.shape )    , UpperCamelCase_ )
           # compare the actual values for a slice.
           lowerCAmelCase    :		Optional[Any]				=      np.array(
               [[[40.4_880, 18.0_199, -5.2_367], [-1.8_877, -4.0_885, 10.7_085], [-2.2_613, -5.6_110, 7.2_665]]]    , dtype=np.floataa )
           self.assertTrue(np.allclose(output[:, :3, :3]    , UpperCamelCase_    , atol=1E-4 ) )






     @slow
     def    lowerCamelCase__   (		self     :    List[str] ):
           lowerCAmelCase    :		Dict				=      FlaxRobertaPreLayerNormModel.from_pretrained('''andreasmadsen/efficient_mlm_m0.40'''    , from_pt=UpperCamelCase_ )

           lowerCAmelCase    :		str				=      np.array([[0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9, 4_6_0_7_8, 1_5_8_8, 2]]    , dtype=jnp.intaa )
           lowerCAmelCase    :		str				=      model(UpperCamelCase_ )[0]
           # compare the actual values for a slice.
           lowerCAmelCase    :		str				=      np.array(
               [[[0.0_208, -0.0_356, 0.0_237], [-0.1_569, -0.0_411, -0.2_626], [0.1_879, 0.0_125, -0.0_089]]]    , dtype=np.floataa )
           self.assertTrue(np.allclose(output[:, :3, :3]    , UpperCamelCase_    , atol=1E-4 ) )


