
'''simple docstring'''







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 					lowerCamelCase							(			self       ,  lowerCAmelCase_       ,  lowerCAmelCase_    ):





								"""simple docstring"""






								return F'gaussian_noise_s={seed}_shape={"_".join([str(lowerCAmelCase_    ) for s in shape]    )}.npy'


							def 					lowerCamelCase							(			self    ):





								"""simple docstring"""






								super().tearDown()
								gc.collect()


							def 					lowerCamelCase							(			self       ,  lowerCAmelCase_=0       ,  lowerCAmelCase_=(4, 4, 64, 64)       ,  lowerCAmelCase_=False    ):





								"""simple docstring"""






								_snake_case  		=						jnp.bfloataa if fpaa else jnp.floataa
								_snake_case  		=						jnp.array(load_hf_numpy(self.get_file_format(lowerCAmelCase_       ,  lowerCAmelCase_    )    )       ,  dtype=lowerCAmelCase_    )
								return image


							def 					lowerCamelCase							(			self       ,  lowerCAmelCase_=False       ,  lowerCAmelCase_="CompVis/stable-diffusion-v1-4"    ):





								"""simple docstring"""






								_snake_case  		=						jnp.bfloataa if fpaa else jnp.floataa
								_snake_case  		=						'bf16' if fpaa else None

								_snake_case		,					_snake_case  		=						FlaxUNetaDConditionModel.from_pretrained(
								    lowerCAmelCase_       ,  subfolder='unet'       ,  dtype=lowerCAmelCase_       ,  revision=lowerCAmelCase_    )
								return model, params


							def 					lowerCamelCase							(			self       ,  lowerCAmelCase_=0       ,  lowerCAmelCase_=(4, 77, 7_68)       ,  lowerCAmelCase_=False    ):





								"""simple docstring"""






								_snake_case  		=						jnp.bfloataa if fpaa else jnp.floataa
								_snake_case  		=						jnp.array(load_hf_numpy(self.get_file_format(lowerCAmelCase_       ,  lowerCAmelCase_    )    )       ,  dtype=lowerCAmelCase_    )
								return hidden_states


							@parameterized.expand(
							    [
							        # fmt: off
							        [83, 4, [-0.2323, -0.1304, 0.0813, -0.3093, -0.0919, -0.1571, -0.1125, -0.5806]],
							        [17, 0.55, [-0.0831, -0.2443, 0.0901, -0.0919, 0.3396, 0.0103, -0.3743, 0.0701]],
							        [8, 0.89, [-0.4863, 0.0859, 0.0875, -0.1658, 0.9199, -0.0114, 0.4839, 0.4639]],
							        [3, 10_00, [-0.5649, 0.2402, -0.5518, 0.1248, 1.1328, -0.2443, -0.0325, -1.0078]],
							        # fmt: on
							    ]    )
							def 					lowerCamelCase							(			self       ,  lowerCAmelCase_       ,  lowerCAmelCase_       ,  lowerCAmelCase_    ):





								"""simple docstring"""






								_snake_case		,					_snake_case  		=						self.get_unet_model(model_id='CompVis/stable-diffusion-v1-4'       ,  fpaa=lowerCAmelCase_    )
								_snake_case  		=						self.get_latents(lowerCAmelCase_       ,  fpaa=lowerCAmelCase_    )
								_snake_case  		=						self.get_encoder_hidden_states(lowerCAmelCase_       ,  fpaa=lowerCAmelCase_    )

								_snake_case  		=						model.apply(
								    {'params': params}       ,  lowerCAmelCase_       ,  jnp.array(lowerCAmelCase_       ,  dtype=jnp.intaa    )       ,  encoder_hidden_states=lowerCAmelCase_       ,  ).sample

								assert sample.shape == latents.shape

								_snake_case  		=						jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten())    )       ,  dtype=jnp.floataa    )
								_snake_case  		=						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.1514, 0.0807, 0.1624, 0.1016, -0.1896, 0.0263, 0.0677, 0.2310]],
							        [17, 0.55, [0.1164, -0.0216, 0.0170, 0.1589, -0.3120, 0.1005, -0.0581, -0.1458]],
							        [8, 0.89, [-0.1758, -0.0169, 0.1004, -0.1411, 0.1312, 0.1103, -0.1996, 0.2139]],
							        [3, 10_00, [0.1214, 0.0352, -0.0731, -0.1562, -0.0994, -0.0906, -0.2340, -0.0539]],
							        # fmt: on
							    ]    )
							def 					lowerCamelCase							(			self       ,  lowerCAmelCase_       ,  lowerCAmelCase_       ,  lowerCAmelCase_    ):





								"""simple docstring"""






								_snake_case		,					_snake_case  		=						self.get_unet_model(model_id='stabilityai/stable-diffusion-2'       ,  fpaa=lowerCAmelCase_    )
								_snake_case  		=						self.get_latents(lowerCAmelCase_       ,  shape=(4, 4, 96, 96)       ,  fpaa=lowerCAmelCase_    )
								_snake_case  		=						self.get_encoder_hidden_states(lowerCAmelCase_       ,  shape=(4, 77, 10_24)       ,  fpaa=lowerCAmelCase_    )

								_snake_case  		=						model.apply(
								    {'params': params}       ,  lowerCAmelCase_       ,  jnp.array(lowerCAmelCase_       ,  dtype=jnp.intaa    )       ,  encoder_hidden_states=lowerCAmelCase_       ,  ).sample

								assert sample.shape == latents.shape

								_snake_case  		=						jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten())    )       ,  dtype=jnp.floataa    )
								_snake_case  		=						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    )








"""simple docstring"""





import logging
import os

from .state import PartialState

class 						lowercase   (   logging.LoggerAdapter   ):





      @staticmethod
      def        _snake_case     (			lowercase					)						->	Optional[Any]:
            lowerCAmelCase    		=			PartialState()
            return not main_process_only or (main_process_only and state.is_main_process)





      def        _snake_case     (			self ,		lowercase ,		lowercase ,		*lowercase ,		**lowercase					)						->	Dict:
            if PartialState._shared_state == {}:
                  raise RuntimeError(
                      """You must initialize the accelerate state by calling either `PartialState()` or `Accelerator()` before using the logging utility."""					)
            lowerCAmelCase    		=			kwargs.pop("""main_process_only""" ,		lowercase					)
            lowerCAmelCase    		=			kwargs.pop("""in_order""" ,		lowercase					)

            if self.isEnabledFor(lowercase					):
                  if self._should_log(lowercase					):
                        lowerCAmelCase		,						lowerCAmelCase    		=			self.process(lowercase ,		lowercase					)
                        self.logger.log(lowercase ,		lowercase ,		*lowercase ,		**lowercase					)

                  elif in_order:
                        lowerCAmelCase    		=			PartialState()
                        for i in range(state.num_processes					):
                              if i == state.process_index:
                                    lowerCAmelCase		,						lowerCAmelCase    		=			self.process(lowercase ,		lowercase					)
                                    self.logger.log(lowercase ,		lowercase ,		*lowercase ,		**lowercase					)
                              state.wait_for_everyone()







def      UpperCAmelCase__				(    SCREAMING_SNAKE_CASE	:		str				,		SCREAMING_SNAKE_CASE	:		str = None     ):







      '''simple docstring'''




      if log_level is None:
            lowerCAmelCase    		=			os.environ.get("""ACCELERATE_LOG_LEVEL"""				,		SCREAMING_SNAKE_CASE     )
      lowerCAmelCase    		=			logging.getLogger(SCREAMING_SNAKE_CASE     )
      if log_level is not None:
            logger.setLevel(log_level.upper()     )
            logger.root.setLevel(log_level.upper()     )
      return MultiProcessAdapter(SCREAMING_SNAKE_CASE				,		{}     )






