'''simple docstring'''





from collections import OrderedDict
from typing import Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...feature_extraction_utils import FeatureExtractionMixin
from ...onnx import OnnxConfig
from ...onnx.utils import compute_effective_axis_dimension
from ...tokenization_utils_base import PreTrainedTokenizerBase
from ...utils import TensorType, logging


SCREAMING_SNAKE_CASE_:	Optional[Any]    =logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_:	List[Any]    ={
    'deepmind/language-perceiver': 'https://huggingface.co/deepmind/language-perceiver/resolve/main/config.json',
    # See all Perceiver models at https://huggingface.co/models?filter=perceiver
}




class 			__A (					UpperCamelCase__      ):
    a__			:		List[Any]			  =    """perceiver"""



    def __init__(self       :       Optional[int]  ,     __a       :       Tuple=256  ,     __a       :       Optional[Any]=1280  ,     __a       :       Optional[int]=768  ,     __a       :       Any=1  ,     __a       :       List[str]=26  ,     __a       :       Dict=8  ,     __a       :       List[Any]=8  ,     __a       :       Tuple=None  ,     __a       :       List[str]=None  ,     __a       :       Optional[int]="kv"  ,     __a       :       Union[str, Any]=1  ,     __a       :       List[str]=1  ,     __a       :       List[Any]="gelu"  ,     __a       :       List[str]=0.1  ,     __a       :       str=0.02  ,     __a       :       List[str]=1E-12  ,     __a       :       Optional[int]=True  ,     __a       :       Tuple=262  ,     __a       :       Dict=2048  ,     __a       :       int=56  ,     __a       :       Optional[int]=[368, 496]  ,     __a       :       Any=16  ,     __a       :       Optional[Any]=1920  ,     __a       :       Any=16  ,     __a       :       str=[1, 16, 224, 224]  ,     **__a       :       Any  ,     ):
         super().__init__(**__a					)

         UpperCAmelCase_			       =  num_latents
         UpperCAmelCase_			       =  d_latents
         UpperCAmelCase_			       =  d_model
         UpperCAmelCase_			       =  num_blocks
         UpperCAmelCase_			       =  num_self_attends_per_block
         UpperCAmelCase_			       =  num_self_attention_heads
         UpperCAmelCase_			       =  num_cross_attention_heads
         UpperCAmelCase_			       =  qk_channels
         UpperCAmelCase_			       =  v_channels
         UpperCAmelCase_			       =  cross_attention_shape_for_attention
         UpperCAmelCase_			       =  self_attention_widening_factor
         UpperCAmelCase_			       =  cross_attention_widening_factor
         UpperCAmelCase_			       =  hidden_act
         UpperCAmelCase_			       =  attention_probs_dropout_prob
         UpperCAmelCase_			       =  initializer_range
         UpperCAmelCase_			       =  layer_norm_eps
         UpperCAmelCase_			       =  use_query_residual
         # masked language modeling attributes
         UpperCAmelCase_			       =  vocab_size
         UpperCAmelCase_			       =  max_position_embeddings
         # image classification attributes
         UpperCAmelCase_			       =  image_size
         # flow attributes
         UpperCAmelCase_			       =  train_size
         # multimodal autoencoding attributes
         UpperCAmelCase_			       =  num_frames
         UpperCAmelCase_			       =  audio_samples_per_frame
         UpperCAmelCase_			       =  samples_per_patch
         UpperCAmelCase_			       =  output_shape




class 			__A (					UpperCamelCase__      ):



    @property
    def    _lowercase		(self       :       Dict					):
         if self.task == "multiple-choice":
              UpperCAmelCase_			       =  {0: "batch", 1: "choice", 2: "sequence"}
         else:
              UpperCAmelCase_			       =  {0: "batch", 1: "sequence"}
         return OrderedDict(
             [
                 ("inputs", dynamic_axis),
                 ("attention_mask", dynamic_axis),
             ]					)



    @property
    def    _lowercase		(self       :       Optional[Any]					):
         return 1E-4






    def    _lowercase		(self       :       Union[str, Any]  ,     __a       :       Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]  ,     __a       :       int = -1  ,     __a       :       int = -1  ,     __a       :       int = -1  ,     __a       :       bool = False  ,     __a       :       Optional[TensorType] = None  ,     __a       :       int = 3  ,     __a       :       int = 40  ,     __a       :       int = 40  ,     ):
         # copied from `transformers.onnx.config.OnnxConfig` and slightly altered/simplified

         if isinstance(__a  ,     __a					):
              # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
              UpperCAmelCase_			       =  compute_effective_axis_dimension(
                  __a  ,     fixed_dimension=OnnxConfig.default_fixed_batch  ,     num_token_to_add=0					)
              # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
              UpperCAmelCase_			       =  preprocessor.num_special_tokens_to_add(__a					)
              UpperCAmelCase_			       =  compute_effective_axis_dimension(
                  __a  ,     fixed_dimension=OnnxConfig.default_fixed_sequence  ,     num_token_to_add=__a					)
              # Generate dummy inputs according to compute batch and sequence
              UpperCAmelCase_			       =  [" ".join(["a"]					) * seq_length] * batch_size
              UpperCAmelCase_			       =  dict(preprocessor(__a  ,     return_tensors=__a					)					)
              UpperCAmelCase_			       =  inputs.pop("input_ids"					)
              return inputs
         elif isinstance(__a  ,     __a					) and preprocessor.model_input_names[0] == "pixel_values":
              # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
              UpperCAmelCase_			       =  compute_effective_axis_dimension(__a  ,     fixed_dimension=OnnxConfig.default_fixed_batch					)
              UpperCAmelCase_			       =  self._generate_dummy_images(__a  ,     __a  ,     __a  ,     __a					)
              UpperCAmelCase_			       =  dict(preprocessor(images=__a  ,     return_tensors=__a					)					)
              UpperCAmelCase_			       =  inputs.pop("pixel_values"					)
              return inputs
         else:
              raise ValueError(
                  "Unable to generate dummy inputs for the model. Please provide a tokenizer or a preprocessor."					)











import gc
import unittest

import numpy as np
import torch

from diffusers import DanceDiffusionPipeline, IPNDMScheduler, UNetaDModel
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import UNCONDITIONAL_AUDIO_GENERATION_BATCH_PARAMS, UNCONDITIONAL_AUDIO_GENERATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()




class 			__UpperCamelCase    (							A__	, unittest.TestCase    ):
     __A	:  Any							  =   DanceDiffusionPipeline
     __A	:  Any							  =   UNCONDITIONAL_AUDIO_GENERATION_PARAMS
     __A	:  Tuple							  =   PipelineTesterMixin.required_optional_params - {
         """callback""",
         """latents""",
         """callback_steps""",
         """output_type""",
         """num_images_per_prompt""",
     }
     __A	:  Tuple							  =   UNCONDITIONAL_AUDIO_GENERATION_BATCH_PARAMS
     __A	:  List[str]							  =   False
     __A	:  str							  =   False





     def 		UpperCamelCase(     self					):
        torch.manual_seed(0					)
        _UpperCAmelCase           =   UNetaDModel(
            block_out_channels=(32, 32, 64)				,							extra_in_channels=16				,							sample_size=512				,							sample_rate=16000				,							in_channels=2				,							out_channels=2				,							flip_sin_to_cos=_UpperCamelCase				,							use_timestep_embedding=_UpperCamelCase				,							time_embedding_type='''fourier'''				,							mid_block_type='''UNetMidBlock1D'''				,							down_block_types=('''DownBlock1DNoSkip''', '''DownBlock1D''', '''AttnDownBlock1D''')				,							up_block_types=('''AttnUpBlock1D''', '''UpBlock1D''', '''UpBlock1DNoSkip''')				,							)
        _UpperCAmelCase           =   IPNDMScheduler()

        _UpperCAmelCase           =   {
            '''unet''': unet,
            '''scheduler''': scheduler,
        }
        return components





     def 		UpperCamelCase(     self				,							_UpperCamelCase				,							_UpperCamelCase=0					):
        if str(_UpperCamelCase					).startswith('''mps'''					):
           _UpperCAmelCase           =   torch.manual_seed(_UpperCamelCase					)
        else:
           _UpperCAmelCase           =   torch.Generator(device=_UpperCamelCase					).manual_seed(_UpperCamelCase					)
        _UpperCAmelCase           =   {
            '''batch_size''': 1,
            '''generator''': generator,
            '''num_inference_steps''': 4,
        }
        return inputs





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   '''cpu'''  # ensure determinism for the device-dependent torch.Generator
        _UpperCAmelCase           =   self.get_dummy_components()
        _UpperCAmelCase           =   DanceDiffusionPipeline(**_UpperCamelCase					)
        _UpperCAmelCase           =   pipe.to(_UpperCamelCase					)
        pipe.set_progress_bar_config(disable=_UpperCamelCase					)

        _UpperCAmelCase           =   self.get_dummy_inputs(_UpperCamelCase					)
        _UpperCAmelCase           =   pipe(**_UpperCamelCase					)
        _UpperCAmelCase           =   output.audios

        _UpperCAmelCase           =   audio[0, -3:, -3:]

        assert audio.shape == (1, 2, components["unet"].sample_size)
        _UpperCAmelCase           =   np.array([-0.7265, 1.0000, -0.8388, 0.1175, 0.9498, -1.0000]					)
        assert np.abs(audio_slice.flatten() - expected_slice					).max() < 1e-2





     @skip_mps
     def 		UpperCamelCase(     self					):
        return super().test_save_load_local()





     @skip_mps
     def 		UpperCamelCase(     self					):
        return super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3					)





     @skip_mps
     def 		UpperCamelCase(     self					):
        return super().test_save_load_optional_components()





     @skip_mps
     def 		UpperCamelCase(     self					):
        return super().test_attention_slicing_forward_pass()





     def 		UpperCamelCase(     self					):
        super().test_inference_batch_single_identical(expected_max_diff=3e-3					)




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





     def 		UpperCamelCase(     self					):
        # clean up the VRAM after each test
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   torch_device

        _UpperCAmelCase           =   DanceDiffusionPipeline.from_pretrained('''harmonai/maestro-150k'''					)
        _UpperCAmelCase           =   pipe.to(_UpperCamelCase					)
        pipe.set_progress_bar_config(disable=_UpperCamelCase					)

        _UpperCAmelCase           =   torch.manual_seed(0					)
        _UpperCAmelCase           =   pipe(generator=_UpperCamelCase				,							num_inference_steps=100				,							audio_length_in_s=4.096					)
        _UpperCAmelCase           =   output.audios

        _UpperCAmelCase           =   audio[0, -3:, -3:]

        assert audio.shape == (1, 2, pipe.unet.sample_size)
        _UpperCAmelCase           =   np.array([-0.0192, -0.0231, -0.0318, -0.0059, 0.0002, -0.0020]					)

        assert np.abs(audio_slice.flatten() - expected_slice					).max() < 1e-2





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   torch_device

        _UpperCAmelCase           =   DanceDiffusionPipeline.from_pretrained('''harmonai/maestro-150k'''				,							torch_dtype=torch.floataa					)
        _UpperCAmelCase           =   pipe.to(_UpperCamelCase					)
        pipe.set_progress_bar_config(disable=_UpperCamelCase					)

        _UpperCAmelCase           =   torch.manual_seed(0					)
        _UpperCAmelCase           =   pipe(generator=_UpperCamelCase				,							num_inference_steps=100				,							audio_length_in_s=4.096					)
        _UpperCAmelCase           =   output.audios

        _UpperCAmelCase           =   audio[0, -3:, -3:]

        assert audio.shape == (1, 2, pipe.unet.sample_size)
        _UpperCAmelCase           =   np.array([-0.0367, -0.0488, -0.0771, -0.0525, -0.0444, -0.0341]					)

        assert np.abs(audio_slice.flatten() - expected_slice					).max() < 1e-2