

import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    TextToVideoSDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, load_numpy, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()
@skip_mps
class     A_      (					lowerCAmelCase__       ,   unittest.TestCase  ):


    '''simple docstring'''






    a__   							=				TextToVideoSDPipeline
    a__   							=				TEXT_TO_IMAGE_PARAMS
    a__   							=				TEXT_TO_IMAGE_BATCH_PARAMS
    # No `output_type`.
    a__   							=				frozenset(
        [
            "num_inference_steps",
            "generator",
            "latents",
            "return_dict",
            "callback",
            "callback_steps",
        ]  )


    def    lowerCAmelCase_  (self     )   ->					Optional[int]:
        torch.manual_seed(0     )
        __UpperCAmelCase     =	UNetaDConditionModel(
            block_out_channels=(32, 64, 64, 64)   ,					layers_per_block=2   ,					sample_size=32   ,					in_channels=4   ,					out_channels=4   ,					down_block_types=('''CrossAttnDownBlock3D''', '''CrossAttnDownBlock3D''', '''CrossAttnDownBlock3D''', '''DownBlock3D''')   ,					up_block_types=('''UpBlock3D''', '''CrossAttnUpBlock3D''', '''CrossAttnUpBlock3D''', '''CrossAttnUpBlock3D''')   ,					cross_attention_dim=32   ,					attention_head_dim=4   ,					)
        __UpperCAmelCase     =	DDIMScheduler(
            beta_start=0.00085   ,					beta_end=0.012   ,					beta_schedule='''scaled_linear'''   ,					clip_sample=UpperCamelCase__   ,					set_alpha_to_one=UpperCamelCase__   ,					)
        torch.manual_seed(0     )
        __UpperCAmelCase     =	AutoencoderKL(
            block_out_channels=[32, 64]   ,					in_channels=3   ,					out_channels=3   ,					down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']   ,					up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']   ,					latent_channels=4   ,					sample_size=128   ,					)
        torch.manual_seed(0     )
        __UpperCAmelCase     =	CLIPTextConfig(
            bos_token_id=0   ,					eos_token_id=2   ,					hidden_size=32   ,					intermediate_size=37   ,					layer_norm_eps=1E-05   ,					num_attention_heads=4   ,					num_hidden_layers=5   ,					pad_token_id=1   ,					vocab_size=1_000   ,					hidden_act='''gelu'''   ,					projection_dim=512   ,					)
        __UpperCAmelCase     =	CLIPTextModel(UpperCamelCase__     )
        __UpperCAmelCase     =	CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''     )

        __UpperCAmelCase     =	{
            "unet": unet,
            "scheduler": scheduler,
            "vae": vae,
            "text_encoder": text_encoder,
            "tokenizer": tokenizer,
        }
        return components


    def    lowerCAmelCase_  (self   ,					lowercase__   ,					lowercase__=0     )   ->					Union[str, Any]:
        if str(UpperCamelCase__     ).startswith('''mps'''     ):
            __UpperCAmelCase     =	torch.manual_seed(UpperCamelCase__     )
        else:
            __UpperCAmelCase     =	torch.Generator(device=UpperCamelCase__     ).manual_seed(UpperCamelCase__     )
        __UpperCAmelCase     =	{
            "prompt": "A painting of a squirrel eating a burger",
            "generator": generator,
            "num_inference_steps": 2,
            "guidance_scale": 6.0,
            "output_type": "pt",
        }
        return inputs


    def    lowerCAmelCase_  (self     )   ->					Any:
        __UpperCAmelCase     =	"cpu"  # ensure determinism for the device-dependent torch.Generator
        __UpperCAmelCase     =	self.get_dummy_components()
        __UpperCAmelCase     =	TextToVideoSDPipeline(**UpperCamelCase__     )
        __UpperCAmelCase     =	sd_pipe.to(UpperCamelCase__     )
        sd_pipe.set_progress_bar_config(disable=UpperCamelCase__     )

        __UpperCAmelCase     =	self.get_dummy_inputs(UpperCamelCase__     )
        __UpperCAmelCase     =	"np"
        __UpperCAmelCase     =	sd_pipe(**UpperCamelCase__     ).frames
        __UpperCAmelCase     =	frames[0][-3:, -3:, -1]

        assert frames[0].shape == (64, 64, 3)
        __UpperCAmelCase     =	np.array([158.0, 160.0, 153.0, 125.0, 100.0, 121.0, 111.0, 93.0, 113.0]     )

        assert np.abs(image_slice.flatten() - expected_slice     ).max() < 1E-2


    def    lowerCAmelCase_  (self     )   ->					Any:
        self._test_attention_slicing_forward_pass(test_mean_pixel_difference=UpperCamelCase__   ,					expected_max_diff=3E-3     )


    @unittest.skipIf(
        torch_device != '''cuda''' or not is_xformers_available()   ,					reason='''XFormers attention is only available with CUDA and `xformers` installed'''   ,					)
    def    lowerCAmelCase_  (self     )   ->					Optional[Any]:
        self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=UpperCamelCase__   ,					expected_max_diff=1E-2     )


    @unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.'''     )
    def    lowerCAmelCase_  (self     )   ->					Dict:
        pass


    @unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.'''     )
    def    lowerCAmelCase_  (self     )   ->					Union[str, Any]:
        pass


    @unittest.skip(reason='''`num_images_per_prompt` argument is not supported for this pipeline.'''     )
    def    lowerCAmelCase_  (self     )   ->					List[str]:
        pass






    def    lowerCAmelCase_  (self     )   ->					int:
        return super().test_progress_bar()






@slow
@skip_mps
class     A_      (					unittest.TestCase  ):


    '''simple docstring'''






    def    lowerCAmelCase_  (self     )   ->					str:
        __UpperCAmelCase     =	load_numpy(
            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy'''     )

        __UpperCAmelCase     =	TextToVideoSDPipeline.from_pretrained('''damo-vilab/text-to-video-ms-1.7b'''     )
        __UpperCAmelCase     =	DPMSolverMultistepScheduler.from_config(pipe.scheduler.config     )
        __UpperCAmelCase     =	pipe.to('''cuda'''     )

        __UpperCAmelCase     =	"Spiderman is surfing"
        __UpperCAmelCase     =	torch.Generator(device='''cpu'''     ).manual_seed(0     )

        __UpperCAmelCase     =	pipe(UpperCamelCase__   ,					generator=UpperCamelCase__   ,					num_inference_steps=25   ,					output_type='''pt'''     ).frames
        __UpperCAmelCase     =	video_frames.cpu().numpy()

        assert np.abs(expected_video - video     ).mean() < 5E-2






    def    lowerCAmelCase_  (self     )   ->					str:
        __UpperCAmelCase     =	load_numpy(
            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy'''     )

        __UpperCAmelCase     =	TextToVideoSDPipeline.from_pretrained('''damo-vilab/text-to-video-ms-1.7b'''     )
        __UpperCAmelCase     =	pipe.to('''cuda'''     )

        __UpperCAmelCase     =	"Spiderman is surfing"
        __UpperCAmelCase     =	torch.Generator(device='''cpu'''     ).manual_seed(0     )

        __UpperCAmelCase     =	pipe(UpperCamelCase__   ,					generator=UpperCamelCase__   ,					num_inference_steps=2   ,					output_type='''pt'''     ).frames
        __UpperCAmelCase     =	video_frames.cpu().numpy()

        assert np.abs(expected_video - video     ).mean() < 5E-2










import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.metrics import mean_absolute_error, mean_squared_error
from sklearn.model_selection import train_test_split
from xgboost import XGBRegressor

def      A      (      _SCREAMING_SNAKE_CASE    )	-> tuple:
       return (data["data"], data["target"])

def      A      (      _SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE    )	-> np.ndarray:
       lowerCamelCase   :      List[str]			 =					XGBRegressor(verbosity=0 ,random_state=42    )
       xgb.fit(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE    )
       # Predict target for test data
       lowerCamelCase   :      List[Any]			 =					xgb.predict(_SCREAMING_SNAKE_CASE    )
       lowerCamelCase   :      Tuple			 =					predictions.reshape(len(_SCREAMING_SNAKE_CASE    ) ,1    )
       return predictions

def      A      (      )	-> None:
       lowerCamelCase   :      Dict			 =					fetch_california_housing()
       lowerCamelCase ,      lowerCamelCase   :      Tuple			 =					data_handling(_SCREAMING_SNAKE_CASE    )
       lowerCamelCase ,      lowerCamelCase ,      lowerCamelCase ,      lowerCamelCase   :      Optional[Any]			 =					train_test_split(
           _SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,test_size=0.25 ,random_state=1    )
       lowerCamelCase   :      Any			 =					xgboost(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE    )
       # Error printing
       print(f'''Mean Absolute Error : {mean_absolute_error(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE    )}'''    )
       print(f'''Mean Square Error  : {mean_squared_error(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE    )}'''    )


if __name__ == "__main__":
       import doctest

       doctest.testmod(verbose=True)
       main()






