






import gc
import random
import unittest

import numpy as np
import torch
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()


class 			__SCREAMING_SNAKE_CASE    (      __lowercase						,    unittest.TestCase):
						_SCREAMING_SNAKE_CASE		:				Any            =    KandinskyPipeline
						_SCREAMING_SNAKE_CASE		:				List[Any]            =    [
						    '''prompt''',
						    '''image_embeds''',
						    '''negative_image_embeds''',
						]
						_SCREAMING_SNAKE_CASE		:				Dict            =    ['''prompt''', '''negative_prompt''', '''image_embeds''', '''negative_image_embeds''']
						_SCREAMING_SNAKE_CASE		:				str            =    [
						    '''generator''',
						    '''height''',
						    '''width''',
						    '''latents''',
						    '''guidance_scale''',
						    '''negative_prompt''',
						    '''num_inference_steps''',
						    '''return_dict''',
						    '''guidance_scale''',
						    '''num_images_per_prompt''',
						    '''output_type''',
						    '''return_dict''',
						]
						_SCREAMING_SNAKE_CASE		:				Optional[int]            =    False






						@property
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												return 32






						@property
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												return 32






						@property
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												return self.time_input_dim






						@property
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												return self.time_input_dim * 4






						@property
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												return 1_00






						@property
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  XLMRobertaTokenizerFast.from_pretrained('YiYiXu/tiny-random-mclip-base'      )
												return tokenizer






						@property
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												torch.manual_seed(0      )
												lowerCAmelCase__			  =  MCLIPConfig(
												    numDims=self.cross_attention_dim   ,  transformerDimensions=self.text_embedder_hidden_size   ,  hidden_size=self.text_embedder_hidden_size   ,  intermediate_size=37   ,  num_attention_heads=4   ,  num_hidden_layers=5   ,  vocab_size=10_05   ,  )

												lowerCAmelCase__			  =  MultilingualCLIP(_UpperCamelCase      )
												lowerCAmelCase__			  =  text_encoder.eval()

												return text_encoder






						@property
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												torch.manual_seed(0      )

												lowerCAmelCase__			  =  {
												    'in_channels': 4,
												    # Out channels is double in channels because predicts mean and variance
												    'out_channels': 8,
												    'addition_embed_type': 'text_image',
												    'down_block_types': ('ResnetDownsampleBlock2D', 'SimpleCrossAttnDownBlock2D'),
												    'up_block_types': ('SimpleCrossAttnUpBlock2D', 'ResnetUpsampleBlock2D'),
												    'mid_block_type': 'UNetMidBlock2DSimpleCrossAttn',
												    'block_out_channels': (self.block_out_channels_a, self.block_out_channels_a * 2),
												    'layers_per_block': 1,
												    'encoder_hid_dim': self.text_embedder_hidden_size,
												    'encoder_hid_dim_type': 'text_image_proj',
												    'cross_attention_dim': self.cross_attention_dim,
												    'attention_head_dim': 4,
												    'resnet_time_scale_shift': 'scale_shift',
												    'class_embed_type': None,
												}

												lowerCAmelCase__			  =  UNetaDConditionModel(**_UpperCamelCase      )
												return model






						@property
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												return {
												    "block_out_channels": [32, 64],
												    "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
												    "in_channels": 3,
												    "latent_channels": 4,
												    "layers_per_block": 1,
												    "norm_num_groups": 8,
												    "norm_type": "spatial",
												    "num_vq_embeddings": 12,
												    "out_channels": 3,
												    "up_block_types": [
												        "AttnUpDecoderBlock2D",
												        "UpDecoderBlock2D",
												    ],
												    "vq_embed_dim": 4,
												}






						@property
						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												torch.manual_seed(0      )
												lowerCAmelCase__			  =  VQModel(**self.dummy_movq_kwargs      )
												return model






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  self.dummy_text_encoder
												lowerCAmelCase__			  =  self.dummy_tokenizer
												lowerCAmelCase__			  =  self.dummy_unet
												lowerCAmelCase__			  =  self.dummy_movq

												lowerCAmelCase__			  =  DDIMScheduler(
												    num_train_timesteps=10_00   ,  beta_schedule='linear'   ,  beta_start=0.0_00_85   ,  beta_end=0.0_12   ,  clip_sample=_UpperCamelCase   ,  set_alpha_to_one=_UpperCamelCase   ,  steps_offset=1   ,  prediction_type='epsilon'   ,  thresholding=_UpperCamelCase   ,  )

												lowerCAmelCase__			  =  {
												    'text_encoder': text_encoder,
												    'tokenizer': tokenizer,
												    'unet': unet,
												    'scheduler': scheduler,
												    'movq': movq,
												}
												return components






						def 					UpperCamelCase__					(		self   ,  _UpperCamelCase   ,  _UpperCamelCase=0      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  floats_tensor((1, self.cross_attention_dim)   ,  rng=random.Random(_UpperCamelCase      )      ).to(_UpperCamelCase      )
												lowerCAmelCase__			  =  floats_tensor((1, self.cross_attention_dim)   ,  rng=random.Random(seed + 1      )      ).to(_UpperCamelCase      )
												if str(_UpperCamelCase      ).startswith('mps'      ):
																		lowerCAmelCase__			  =  torch.manual_seed(_UpperCamelCase      )
												else:
																		lowerCAmelCase__			  =  torch.Generator(device=_UpperCamelCase      ).manual_seed(_UpperCamelCase      )
												lowerCAmelCase__			  =  {
												    'prompt': 'horse',
												    'image_embeds': image_embeds,
												    'negative_image_embeds': negative_image_embeds,
												    'generator': generator,
												    'height': 64,
												    'width': 64,
												    'guidance_scale': 4.0,
												    'num_inference_steps': 2,
												    'output_type': 'np',
												}
												return inputs







						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  'cpu'

												lowerCAmelCase__			  =  self.get_dummy_components()

												lowerCAmelCase__			  =  self.pipeline_class(**_UpperCamelCase      )
												lowerCAmelCase__			  =  pipe.to(_UpperCamelCase      )

												pipe.set_progress_bar_config(disable=_UpperCamelCase      )

												lowerCAmelCase__			  =  pipe(**self.get_dummy_inputs(_UpperCamelCase      )      )
												lowerCAmelCase__			  =  output.images

												lowerCAmelCase__			  =  pipe(
												    **self.get_dummy_inputs(_UpperCamelCase      )   ,  return_dict=_UpperCamelCase   ,  )[0]

												lowerCAmelCase__			  =  image[0, -3:, -3:, -1]
												lowerCAmelCase__			  =  image_from_tuple[0, -3:, -3:, -1]

												assert image.shape == (1, 64, 64, 3)

												lowerCAmelCase__			  =  np.array(
												    [0.32_86_63, 1.0, 0.23_21_68_73, 1.0, 0.92_71_75_64, 0.4_63_90_46, 0.96_89_47_77, 0.31_71_33_78, 0.6_29_39_53]      )

												assert (
												    np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-2
												), F" expected_slice {expected_slice}, but got {image_slice.flatten()}"
												assert (
												    np.abs(image_from_tuple_slice.flatten() - expected_slice      ).max() < 1E-2
												), F" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"




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






						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												# clean up the VRAM after each test
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()







						def 					UpperCamelCase__					(		self      ):






												"""simple docstring"""
												lowerCAmelCase__			  =  load_numpy(
												    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
												    '/kandinsky/kandinsky_text2img_cat_fp16.npy'      )

												lowerCAmelCase__			  =  KandinskyPriorPipeline.from_pretrained(
												    'kandinsky-community/kandinsky-2-1-prior'   ,  torch_dtype=torch.floataa      )
												pipe_prior.to(_UpperCamelCase      )

												lowerCAmelCase__			  =  KandinskyPipeline.from_pretrained('kandinsky-community/kandinsky-2-1'   ,  torch_dtype=torch.floataa      )
												lowerCAmelCase__			  =  pipeline.to(_UpperCamelCase      )
												pipeline.set_progress_bar_config(disable=_UpperCamelCase      )

												lowerCAmelCase__			  =  'red cat, 4k photo'

												lowerCAmelCase__			  =  torch.Generator(device='cuda'      ).manual_seed(0      )
												lowerCAmelCase__  ,				lowerCAmelCase__			  =  pipe_prior(
												    _UpperCamelCase   ,  generator=_UpperCamelCase   ,  num_inference_steps=5   ,  negative_prompt=''   ,  ).to_tuple()

												lowerCAmelCase__			  =  torch.Generator(device='cuda'      ).manual_seed(0      )
												lowerCAmelCase__			  =  pipeline(
												    _UpperCamelCase   ,  image_embeds=_UpperCamelCase   ,  negative_image_embeds=_UpperCamelCase   ,  generator=_UpperCamelCase   ,  num_inference_steps=1_00   ,  output_type='np'   ,  )

												lowerCAmelCase__			  =  output.images[0]

												assert image.shape == (5_12, 5_12, 3)

												assert_mean_pixel_difference(_UpperCamelCase   ,  _UpperCamelCase      )













import numpy as np
import requests







def 		_UpperCamelCase      (			)     ->      Dict:

						"""simple docstring"""



						lowerCAmelCase__			  =  requests.get(
						    'https://raw.githubusercontent.com/yashLadha/The_Math_of_Intelligence/'
						    'master/Week1/ADRvsRating.csv'						)
						lowerCAmelCase__			  =  response.text.splitlines()
						lowerCAmelCase__			  =  []
						for item in lines:
												lowerCAmelCase__			  =  item.split(','						)
												data.append(UpperCamelCase_						)
						data.pop(0						)  # This is for removing the labels from the list
						lowerCAmelCase__			  =  np.matrix(UpperCamelCase_						)
						return dataset







def 		_UpperCamelCase      (			UpperCamelCase_				:    Union[str, Any]			,				UpperCamelCase_				:    Optional[Any]			,				UpperCamelCase_				:    Dict			,				UpperCamelCase_				:    List[Any]			,				UpperCamelCase_				:    int						)     ->      int:

						"""simple docstring"""



						lowerCAmelCase__			  =  len_data

						lowerCAmelCase__			  =  np.dot(UpperCamelCase_			,				data_x.transpose()						)
						prod -= data_y.transpose()
						lowerCAmelCase__			  =  np.dot(UpperCamelCase_			,				UpperCamelCase_						)
						lowerCAmelCase__			  =  theta - (alpha / n) * sum_grad
						return theta







def 		_UpperCamelCase      (			UpperCamelCase_				:    str			,				UpperCamelCase_				:    Any			,				UpperCamelCase_				:    str			,				UpperCamelCase_				:    List[Any]						)     ->      Dict:

						"""simple docstring"""



						lowerCAmelCase__			  =  np.dot(UpperCamelCase_			,				data_x.transpose()						)
						prod -= data_y.transpose()
						lowerCAmelCase__			  =  np.sum(np.square(UpperCamelCase_						)						)
						lowerCAmelCase__			  =  sum_elem / (2 * len_data)
						return error







def 		_UpperCamelCase      (			UpperCamelCase_				:    Any			,				UpperCamelCase_				:    List[Any]						)     ->      str:

						"""simple docstring"""



						lowerCAmelCase__			  =  10_0000
						lowerCAmelCase__			  =  0.000_1550

						lowerCAmelCase__			  =  data_x.shape[1]
						lowerCAmelCase__			  =  data_x.shape[0] - 1

						lowerCAmelCase__			  =  np.zeros((1, no_features)						)

						for i in range(0			,				UpperCamelCase_						):
												lowerCAmelCase__			  =  run_steep_gradient_descent(UpperCamelCase_			,				UpperCamelCase_			,				UpperCamelCase_			,				UpperCamelCase_			,				UpperCamelCase_						)
												lowerCAmelCase__			  =  sum_of_square_error(UpperCamelCase_			,				UpperCamelCase_			,				UpperCamelCase_			,				UpperCamelCase_						)
												print(F"At Iteration {i + 1} - Error is {error:.5f}"						)

						return theta







def 		_UpperCamelCase      (			UpperCamelCase_				:    Dict			,				UpperCamelCase_				:    Any						)     ->      Union[str, Any]:

						"""simple docstring"""



						lowerCAmelCase__			  =  sum(abs(y - predicted_y[i]						) for i, y in enumerate(UpperCamelCase_						)						)
						return total / len(UpperCamelCase_						)







def 		_UpperCamelCase      (			)     ->      List[Any]:

						"""simple docstring"""



						lowerCAmelCase__			  =  collect_dataset()

						lowerCAmelCase__			  =  data.shape[0]
						lowerCAmelCase__			  =  np.c_[np.ones(UpperCamelCase_						), data[:, :-1]].astype(UpperCamelCase_						)
						lowerCAmelCase__			  =  data[:, -1].astype(UpperCamelCase_						)

						lowerCAmelCase__			  =  run_linear_regression(UpperCamelCase_			,				UpperCamelCase_						)
						lowerCAmelCase__			  =  theta.shape[1]
						print('Resultant Feature vector : '						)
						for i in range(0			,				UpperCamelCase_						):
												print(F"{theta[0, i]:.5f}"						)


if __name__ == "__main__":
					main()





