


'''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  __magic_name__							(		unittest.TestCase    ):






       def       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case)						->  List[str]:




          '''simple docstring'''
          return f"gaussian_noise_s={seed}_shape={'_'.join([str(snake_case) for s in shape])}.npy"






       def       lowerCAmelCase		(      self)						->  Any:




          '''simple docstring'''
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()






       def       lowerCAmelCase		(      self  ,							snake_case=0  ,							snake_case=(4, 4, 6_4, 6_4)  ,							snake_case=False)						->  Any:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[int]							   =jnp.bfloataa if fpaa else jnp.floataa
          _UpperCAmelCase       :       Optional[Any]							   =jnp.array(load_hf_numpy(self.get_file_format(snake_case  ,							snake_case))  ,							dtype=snake_case)
          return image






       def       lowerCAmelCase		(      self  ,							snake_case=False  ,							snake_case="CompVis/stable-diffusion-v1-4")						->  List[str]:




          '''simple docstring'''
          _UpperCAmelCase       :       List[str]							   =jnp.bfloataa if fpaa else jnp.floataa
          _UpperCAmelCase       :       List[str]							   ='bf16' if fpaa else None

          _UpperCAmelCase   ,	_UpperCAmelCase       :       Optional[Any]							   =FlaxUNetaDConditionModel.from_pretrained(
              snake_case  ,							subfolder='unet'  ,							dtype=snake_case  ,							revision=snake_case)
          return model, params






       def       lowerCAmelCase		(      self  ,							snake_case=0  ,							snake_case=(4, 7_7, 7_6_8)  ,							snake_case=False)						->  Tuple:




          '''simple docstring'''
          _UpperCAmelCase       :       str							   =jnp.bfloataa if fpaa else jnp.floataa
          _UpperCAmelCase       :       int							   =jnp.array(load_hf_numpy(self.get_file_format(snake_case  ,							snake_case))  ,							dtype=snake_case)
          return hidden_states






       @parameterized.expand(
           [
               # fmt: off
               [8_3, 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]],
               [1_7, 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, 1_0_0_0, [-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       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case  ,							snake_case)						->  Optional[int]:




          '''simple docstring'''
          _UpperCAmelCase   ,	_UpperCAmelCase       :       Union[str, Any]							   =self.get_unet_model(model_id='CompVis/stable-diffusion-v1-4'  ,							fpaa=snake_case)
          _UpperCAmelCase       :       str							   =self.get_latents(snake_case  ,							fpaa=snake_case)
          _UpperCAmelCase       :       Optional[int]							   =self.get_encoder_hidden_states(snake_case  ,							fpaa=snake_case)

          _UpperCAmelCase       :       Optional[Any]							   =model.apply(
              {'params': params}  ,							snake_case  ,							jnp.array(snake_case  ,							dtype=jnp.intaa)  ,							encoder_hidden_states=snake_case  ,							).sample

          assert sample.shape == latents.shape

          _UpperCAmelCase       :       Dict							   =jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten()))  ,							dtype=jnp.floataa)
          _UpperCAmelCase       :       Union[str, Any]							   =jnp.array(snake_case  ,							dtype=jnp.floataa)

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






       @parameterized.expand(
           [
               # fmt: off
               [8_3, 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]],
               [1_7, 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, 1_0_0_0, [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       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case  ,							snake_case)						->  Tuple:




          '''simple docstring'''
          _UpperCAmelCase   ,	_UpperCAmelCase       :       int							   =self.get_unet_model(model_id='stabilityai/stable-diffusion-2'  ,							fpaa=snake_case)
          _UpperCAmelCase       :       List[str]							   =self.get_latents(snake_case  ,							shape=(4, 4, 9_6, 9_6)  ,							fpaa=snake_case)
          _UpperCAmelCase       :       Optional[int]							   =self.get_encoder_hidden_states(snake_case  ,							shape=(4, 7_7, 1_0_2_4)  ,							fpaa=snake_case)

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

          assert sample.shape == latents.shape

          _UpperCAmelCase       :       List[Any]							   =jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten()))  ,							dtype=jnp.floataa)
          _UpperCAmelCase       :       int							   =jnp.array(snake_case  ,							dtype=jnp.floataa)

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





'''simple docstring'''






from __future__ import annotations





def lowerCamelCase__      (						__lowerCamelCase	:							list[int]							):







   '''simple docstring'''




   if not nums:
      return 0
   _UpperCAmelCase       :       Tuple							   =nums[0]
   _UpperCAmelCase       :       int							   =0
   for num in nums[1:]:
      _UpperCAmelCase   ,	_UpperCAmelCase       :       Optional[int]							   =(
          max_excluding + num,
          max(__lowerCamelCase	,   __lowerCamelCase							),
      )
   return max(__lowerCamelCase	,   __lowerCamelCase							)


if __name__ == "__main__":
 import doctest

 doctest.testmod()

