

'''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 							A__   (	A__					,       unittest.TestCase  ):
  A__					=    DiTPipeline
  A__					=    CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS
  A__					=    PipelineTesterMixin.required_optional_params - {
      'latents',
      'num_images_per_prompt',
      'callback',
      'callback_steps',
  }
  A__					=    CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS
  A__					=    False





  def 						A  (		self				:     int			)     ->   Union[str, Any]:





       '''simple docstring'''






       torch.manual_seed(0			)
       _SCREAMING_SNAKE_CASE							   =TransformeraDModel(
           sample_size=16							, num_layers=2							, patch_size=4							, attention_head_dim=8							, num_attention_heads=2							, in_channels=4							, out_channels=8							, attention_bias=_a							, activation_fn='gelu-approximate'							, num_embeds_ada_norm=1000							, norm_type='ada_norm_zero'							, norm_elementwise_affine=_a							, )
       _SCREAMING_SNAKE_CASE							   =AutoencoderKL()
       _SCREAMING_SNAKE_CASE							   =DDIMScheduler()
       _SCREAMING_SNAKE_CASE							   ={'transformer': transformer.eval(), 'vae': vae.eval(), 'scheduler': scheduler}
       return components





  def 						A  (		self				:     int							, _a				:     str							, _a				:     Union[str, Any]=0			)     ->   str:





       '''simple docstring'''






       if str(_a			).startswith('mps'			):
            _SCREAMING_SNAKE_CASE							   =torch.manual_seed(_a			)
       else:
            _SCREAMING_SNAKE_CASE							   =torch.Generator(device=_a			).manual_seed(_a			)
       _SCREAMING_SNAKE_CASE							   ={
           'class_labels': [1],
           'generator': generator,
           'num_inference_steps': 2,
           'output_type': 'numpy',
       }
       return inputs





  def 						A  (		self				:     List[Any]			)     ->   Union[str, Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   ='cpu'

       _SCREAMING_SNAKE_CASE							   =self.get_dummy_components()
       _SCREAMING_SNAKE_CASE							   =self.pipeline_class(**_a			)
       pipe.to(_a			)
       pipe.set_progress_bar_config(disable=_a			)

       _SCREAMING_SNAKE_CASE							   =self.get_dummy_inputs(_a			)
       _SCREAMING_SNAKE_CASE							   =pipe(**_a			).images
       _SCREAMING_SNAKE_CASE							   =image[0, -3:, -3:, -1]

       self.assertEqual(image.shape							, (1, 16, 16, 3)			)
       _SCREAMING_SNAKE_CASE							   =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]			)
       _SCREAMING_SNAKE_CASE							   =np.abs(image_slice.flatten() - expected_slice			).max()
       self.assertLessEqual(_a							, 1e-3			)





  def 						A  (		self				:     Dict			)     ->   Any:





       '''simple docstring'''






       self._test_inference_batch_single_identical(relax_max_difference=_a							, 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 						A  (		self				:     Optional[int]			)     ->   Dict:





       '''simple docstring'''






       self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3			)







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





  def 						A  (		self				:     int			)     ->   Union[str, Any]:





       '''simple docstring'''






       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()





  def 						A  (		self				:     str			)     ->   Any:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =torch.manual_seed(0			)

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

       _SCREAMING_SNAKE_CASE							   =['vase', 'umbrella', 'white shark', 'white wolf']
       _SCREAMING_SNAKE_CASE							   =pipe.get_label_ids(_a			)

       _SCREAMING_SNAKE_CASE							   =pipe(_a							, generator=_a							, num_inference_steps=40							, output_type='np'			).images

       for word, image in zip(_a							, _a			):
            _SCREAMING_SNAKE_CASE							   =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 						A  (		self				:     int			)     ->   Optional[int]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =DiTPipeline.from_pretrained('facebook/DiT-XL-2-512'			)
       _SCREAMING_SNAKE_CASE							   =DPMSolverMultistepScheduler.from_config(pipe.scheduler.config			)
       pipe.to('cuda'			)

       _SCREAMING_SNAKE_CASE							   =['vase', 'umbrella']
       _SCREAMING_SNAKE_CASE							   =pipe.get_label_ids(_a			)

       _SCREAMING_SNAKE_CASE							   =torch.manual_seed(0			)
       _SCREAMING_SNAKE_CASE							   =pipe(_a							, generator=_a							, num_inference_steps=25							, output_type='np'			).images

       for word, image in zip(_a							, _a			):
            _SCREAMING_SNAKE_CASE							   =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'''
def 	_lowerCAmelCase (						_UpperCamelCase						:					int = 50    )				->      int:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   =[[0] * 3 for _ in range(length + 1    )]

     for row_length in range(length + 1    ):
          for tile_length in range(2							,			5    ):
               for tile_start in range(row_length - tile_length + 1    ):
                    different_colour_ways_number[row_length][tile_length - 2] += (
                        different_colour_ways_number[row_length - tile_start - tile_length][
                            tile_length - 2
                        ]
                        + 1
                    )

     return sum(different_colour_ways_number[length]    )


if __name__ == "__main__":
     print(f'''{solution() = }''')
