'''simple docstring'''





import doctest
from collections import deque

import numpy as np


class 			UpperCAmelCase__    :



  """simple docstring"""






  def __init__(				self:			int   ) -> None:




    '''simple docstring'''




    __UpperCAmelCase						    =       [2, 1, 2, -1]
    __UpperCAmelCase						    =       [1, 2, 3, 4]






  def 	_UpperCAmelCase				(				self:			str   ) -> list[float]:




    '''simple docstring'''




    __UpperCAmelCase						    =       len(self.first_signal   )
    __UpperCAmelCase						    =       len(self.second_signal   )

    __UpperCAmelCase						    =       max(lowerCamelCase_				,				lowerCamelCase_   )

    # create a zero matrix of max_length x max_length
    __UpperCAmelCase						    =       [[0] * max_length for i in range(lowerCamelCase_   )]

    # fills the smaller signal with zeros to make both signals of same length
    if length_first_signal < length_second_signal:
      self.first_signal += [0] * (max_length - length_first_signal)
    elif length_first_signal > length_second_signal:
      self.second_signal += [0] * (max_length - length_second_signal)
    for i in range(lowerCamelCase_   ):
      __UpperCAmelCase						    =       deque(self.second_signal   )
      rotated_signal.rotate(lowerCamelCase_   )
      for j, item in enumerate(lowerCamelCase_   ):
        matrix[i][j] += item

        # multiply the matrix with the first signal
    __UpperCAmelCase						    =       np.matmul(np.transpose(lowerCamelCase_   )				,				np.transpose(self.first_signal   )   )

    # rounding-off to two decimal places
    return [round(lowerCamelCase_				,				2   ) for i in final_signal]


if __name__ == "__main__":
       doctest.testmod()




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__    (		snake_case		,	unittest.TestCase					):



  """simple docstring"""






  lowerCAmelCase__		:	int    		= DiTPipeline
  lowerCAmelCase__		:	Any    		= CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS
  lowerCAmelCase__		:	Optional[Any]    		= PipelineTesterMixin.required_optional_params - {
      'latents',
      'num_images_per_prompt',
      'callback',
      'callback_steps',
  }
  lowerCAmelCase__		:	List[Any]    		= CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS
  lowerCAmelCase__		:	Optional[int]    		= False






  def 	_UpperCAmelCase				(				self:			str   ) -> List[Any]:




    '''simple docstring'''




    torch.manual_seed(0   )
    __UpperCAmelCase						    =       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=__lowerCAmelCase				,				activation_fn="gelu-approximate"				,				num_embeds_ada_norm=1_000				,				norm_type="ada_norm_zero"				,				norm_elementwise_affine=__lowerCAmelCase				,				)
    __UpperCAmelCase						    =       AutoencoderKL()
    __UpperCAmelCase						    =       DDIMScheduler()
    __UpperCAmelCase						    =       {"transformer": transformer.eval(), "vae": vae.eval(), "scheduler": scheduler}
    return components






  def 	_UpperCAmelCase				(				self:			str				,				__lowerCAmelCase:			str				,				__lowerCAmelCase:			Optional[int]=0   ) -> int:




    '''simple docstring'''




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






  def 	_UpperCAmelCase				(				self:			Tuple   ) -> Dict:




    '''simple docstring'''




    __UpperCAmelCase						    =       "cpu"

    __UpperCAmelCase						    =       self.get_dummy_components()
    __UpperCAmelCase						    =       self.pipeline_class(**__lowerCAmelCase   )
    pipe.to(__lowerCAmelCase   )
    pipe.set_progress_bar_config(disable=__lowerCAmelCase   )

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

    self.assertEqual(image.shape				,				(1, 16, 16, 3)   )
    __UpperCAmelCase						    =       np.array([0.2946, 0.6601, 0.4329, 0.3296, 0.4144, 0.5319, 0.7273, 0.5013, 0.4457]   )
    __UpperCAmelCase						    =       np.abs(image_slice.flatten() - expected_slice   ).max()
    self.assertLessEqual(__lowerCAmelCase				,				1E-3   )






  def 	_UpperCAmelCase				(				self:			int   ) -> str:




    '''simple docstring'''




    self._test_inference_batch_single_identical(relax_max_difference=__lowerCAmelCase				,				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 	_UpperCAmelCase				(				self:			Optional[int]   ) -> str:




    '''simple docstring'''




    self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3   )






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



  """simple docstring"""






  def 	_UpperCAmelCase				(				self:			Any   ) -> Optional[Any]:




    '''simple docstring'''




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






  def 	_UpperCAmelCase				(				self:			Dict   ) -> List[Any]:




    '''simple docstring'''




    __UpperCAmelCase						    =       torch.manual_seed(0   )

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

    __UpperCAmelCase						    =       ["vase", "umbrella", "white shark", "white wolf"]
    __UpperCAmelCase						    =       pipe.get_label_ids(__lowerCAmelCase   )

    __UpperCAmelCase						    =       pipe(__lowerCAmelCase				,				generator=__lowerCAmelCase				,				num_inference_steps=40				,				output_type="np"   ).images

    for word, image in zip(__lowerCAmelCase				,				__lowerCAmelCase   ):
      __UpperCAmelCase						    =       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 	_UpperCAmelCase				(				self:			Any   ) -> List[str]:




    '''simple docstring'''




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

    __UpperCAmelCase						    =       ["vase", "umbrella"]
    __UpperCAmelCase						    =       pipe.get_label_ids(__lowerCAmelCase   )

    __UpperCAmelCase						    =       torch.manual_seed(0   )
    __UpperCAmelCase						    =       pipe(__lowerCAmelCase				,				generator=__lowerCAmelCase				,				num_inference_steps=25				,				output_type="np"   ).images

    for word, image in zip(__lowerCAmelCase				,				__lowerCAmelCase   ):
      __UpperCAmelCase						    =       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



