



"""simple docstring"""







import gc
import unittest

import numpy as np
import torch

from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, DPMSolverMultistepScheduler, TransformeraDModel
from diffusers.utils import is_xformers_available, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS,
    CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()







class 				UpperCamelCase__       (     lowercase_, unittest.TestCase  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE      =					DiTPipeline
      _SCREAMING_SNAKE_CASE      =					CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS
      _SCREAMING_SNAKE_CASE      =					PipelineTesterMixin.required_optional_params - {
          """latents""",
          """num_images_per_prompt""",
          """callback""",
          """callback_steps""",
      }
      _SCREAMING_SNAKE_CASE      =					CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS
      _SCREAMING_SNAKE_CASE      =					False



      def 					SCREAMING_SNAKE_CASE__			(				self    :				Any	):
        torch.manual_seed(0	)
        lowerCAmelCase_       :    Union[str, Any]								=			TransformeraDModel(
            sample_size=1_6   ,      num_layers=2   ,      patch_size=4   ,      attention_head_dim=8   ,      num_attention_heads=2   ,      in_channels=4   ,      out_channels=8   ,      attention_bias=SCREAMING_SNAKE_CASE_   ,      activation_fn='gelu-approximate'   ,      num_embeds_ada_norm=1_0_0_0   ,      norm_type='ada_norm_zero'   ,      norm_elementwise_affine=SCREAMING_SNAKE_CASE_   ,      )
        lowerCAmelCase_       :    List[Any]								=			AutoencoderKL()
        lowerCAmelCase_       :    List[Any]								=			DDIMScheduler()
        lowerCAmelCase_       :    List[str]								=			{'transformer': transformer.eval(), 'vae': vae.eval(), 'scheduler': scheduler}
        return components



      def 					SCREAMING_SNAKE_CASE__			(				self    :				Tuple   ,      SCREAMING_SNAKE_CASE_    :				str   ,      SCREAMING_SNAKE_CASE_    :				Optional[int]=0	):
        if str(SCREAMING_SNAKE_CASE_	).startswith('mps'	):
          lowerCAmelCase_       :    List[str]								=			torch.manual_seed(SCREAMING_SNAKE_CASE_	)
        else:
          lowerCAmelCase_       :    List[str]								=			torch.Generator(device=SCREAMING_SNAKE_CASE_	).manual_seed(SCREAMING_SNAKE_CASE_	)
        lowerCAmelCase_       :    Tuple								=			{
            'class_labels': [1],
            'generator': generator,
            'num_inference_steps': 2,
            'output_type': 'numpy',
        }
        return inputs



      def 					SCREAMING_SNAKE_CASE__			(				self    :				Any	):
        lowerCAmelCase_       :    Any								=			'cpu'

        lowerCAmelCase_       :    List[str]								=			self.get_dummy_components()
        lowerCAmelCase_       :    Optional[Any]								=			self.pipeline_class(**SCREAMING_SNAKE_CASE_	)
        pipe.to(SCREAMING_SNAKE_CASE_	)
        pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_	)

        lowerCAmelCase_       :    int								=			self.get_dummy_inputs(SCREAMING_SNAKE_CASE_	)
        lowerCAmelCase_       :    str								=			pipe(**SCREAMING_SNAKE_CASE_	).images
        lowerCAmelCase_       :    List[str]								=			image[0, -3:, -3:, -1]

        self.assertEqual(image.shape   ,      (1, 1_6, 1_6, 3)	)
        lowerCAmelCase_       :    int								=			np.array([0.29_46, 0.66_01, 0.43_29, 0.32_96, 0.41_44, 0.53_19, 0.72_73, 0.50_13, 0.44_57]	)
        lowerCAmelCase_       :    int								=			np.abs(image_slice.flatten() - expected_slice	).max()
        self.assertLessEqual(SCREAMING_SNAKE_CASE_   ,      1E-3	)



      def 					SCREAMING_SNAKE_CASE__			(				self    :				Dict	):
        self._test_inference_batch_single_identical(relax_max_difference=SCREAMING_SNAKE_CASE_   ,      expected_max_diff=1E-3	)





      @unittest.skipIf(
          torch_device != 'cuda' or not is_xformers_available()   ,      reason='XFormers attention is only available with CUDA and `xformers` installed'   ,      )
      def 					SCREAMING_SNAKE_CASE__			(				self    :				Any	):
        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3	)







@require_torch_gpu
@slow
class 				UpperCamelCase__       (     unittest.TestCase  ):




      """simple docstring"""




      def 					SCREAMING_SNAKE_CASE__			(				self    :				Tuple	):
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()



      def 					SCREAMING_SNAKE_CASE__			(				self    :				Union[str, Any]	):
        lowerCAmelCase_       :    List[Any]								=			torch.manual_seed(0	)

        lowerCAmelCase_       :    Any								=			DiTPipeline.from_pretrained('facebook/DiT-XL-2-256'	)
        pipe.to('cuda'	)

        lowerCAmelCase_       :    Union[str, Any]								=			['vase', 'umbrella', 'white shark', 'white wolf']
        lowerCAmelCase_       :    Tuple								=			pipe.get_label_ids(SCREAMING_SNAKE_CASE_	)

        lowerCAmelCase_       :    Optional[Any]								=			pipe(SCREAMING_SNAKE_CASE_   ,      generator=SCREAMING_SNAKE_CASE_   ,      num_inference_steps=4_0   ,      output_type='np'	).images

        for word, image in zip(SCREAMING_SNAKE_CASE_   ,      SCREAMING_SNAKE_CASE_	):
          lowerCAmelCase_       :    Optional[Any]								=			load_numpy(
              F"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/dit/{word}.npy"	)
          assert np.abs((expected_image - image).max()	) < 1E-2





      def 					SCREAMING_SNAKE_CASE__			(				self    :				Tuple	):
        lowerCAmelCase_       :    List[Any]								=			DiTPipeline.from_pretrained('facebook/DiT-XL-2-512'	)
        lowerCAmelCase_       :    Any								=			DPMSolverMultistepScheduler.from_config(pipe.scheduler.config	)
        pipe.to('cuda'	)

        lowerCAmelCase_       :    Optional[Any]								=			['vase', 'umbrella']
        lowerCAmelCase_       :    Dict								=			pipe.get_label_ids(SCREAMING_SNAKE_CASE_	)

        lowerCAmelCase_       :    int								=			torch.manual_seed(0	)
        lowerCAmelCase_       :    int								=			pipe(SCREAMING_SNAKE_CASE_   ,      generator=SCREAMING_SNAKE_CASE_   ,      num_inference_steps=2_5   ,      output_type='np'	).images

        for word, image in zip(SCREAMING_SNAKE_CASE_   ,      SCREAMING_SNAKE_CASE_	):
          lowerCAmelCase_       :    Optional[Any]								=			load_numpy(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
              F"/dit/{word}_512.npy"	)

          assert np.abs((expected_image - image).max()	) < 1E-1










"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


lowercase__		:    Dict				   =     {
    """configuration_falcon""": ["""FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP""", """FalconConfig"""],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowercase__		:    str				   =     [
         """FALCON_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """FalconForCausalLM""",
         """FalconModel""",
         """FalconPreTrainedModel""",
         """FalconForSequenceClassification""",
         """FalconForTokenClassification""",
         """FalconForQuestionAnswering""",
     ]


if TYPE_CHECKING:
     from .configuration_falcon import FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP, FalconConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_falcon import (
              FALCON_PRETRAINED_MODEL_ARCHIVE_LIST,
              FalconForCausalLM,
              FalconForQuestionAnswering,
              FalconForSequenceClassification,
              FalconForTokenClassification,
              FalconModel,
              FalconPreTrainedModel,
          )


else:
     import sys

     lowercase__		:    Dict				   =     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





