


'''simple docstring'''



import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()


class 						_snake_case   (       a__    ,				a__    ,				a__    ,				unittest.TestCase		):
     lowerCAmelCase :Union[str, Any]						=   StableUnCLIPPipeline
     lowerCAmelCase :int						=   TEXT_TO_IMAGE_PARAMS
     lowerCAmelCase :List[Any]						=   TEXT_TO_IMAGE_BATCH_PARAMS
     lowerCAmelCase :Optional[int]						=   TEXT_TO_IMAGE_IMAGE_PARAMS
     lowerCAmelCase :str						=   TEXT_TO_IMAGE_IMAGE_PARAMS

     # TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
     lowerCAmelCase :str						=   False




     def 			snake_case__  ( self):
        UpperCAmelCase__					:   List[str]       				=       32
        UpperCAmelCase__					:   Any       				=       embedder_hidden_size

        # prior components

        torch.manual_seed(0)
        UpperCAmelCase__					:   str       				=       CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""")

        torch.manual_seed(0)
        UpperCAmelCase__					:   Any       				=       CLIPTextModelWithProjection(
            CLIPTextConfig(
                bos_token_id=0							,							eos_token_id=2							,							hidden_size=_lowerCamelCase							,							projection_dim=_lowerCamelCase							,							intermediate_size=37							,							layer_norm_eps=1e-0_5							,							num_attention_heads=4							,							num_hidden_layers=5							,							pad_token_id=1							,							vocab_size=1000							,							))

        torch.manual_seed(0)
        UpperCAmelCase__					:   Optional[Any]       				=       PriorTransformer(
            num_attention_heads=2							,							attention_head_dim=12							,							embedding_dim=_lowerCamelCase							,							num_layers=1							,							)

        torch.manual_seed(0)
        UpperCAmelCase__					:   Tuple       				=       DDPMScheduler(
            variance_type="""fixed_small_log"""							,							prediction_type="""sample"""							,							num_train_timesteps=1000							,							clip_sample=_lowerCamelCase							,							clip_sample_range=5.0							,							beta_schedule="""squaredcos_cap_v2"""							,							)

        # regular denoising components

        torch.manual_seed(0)
        UpperCAmelCase__					:   Optional[Any]       				=       StableUnCLIPImageNormalizer(embedding_dim=_lowerCamelCase)
        UpperCAmelCase__					:   Any       				=       DDPMScheduler(beta_schedule="""squaredcos_cap_v2""")

        torch.manual_seed(0)
        UpperCAmelCase__					:   Tuple       				=       CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""")

        torch.manual_seed(0)
        UpperCAmelCase__					:   Dict       				=       CLIPTextModel(
            CLIPTextConfig(
                bos_token_id=0							,							eos_token_id=2							,							hidden_size=_lowerCamelCase							,							projection_dim=32							,							intermediate_size=37							,							layer_norm_eps=1e-0_5							,							num_attention_heads=4							,							num_hidden_layers=5							,							pad_token_id=1							,							vocab_size=1000							,							))

        torch.manual_seed(0)
        UpperCAmelCase__					:   Optional[Any]       				=       UNetaDConditionModel(
            sample_size=32							,							in_channels=4							,							out_channels=4							,							down_block_types=("""CrossAttnDownBlock2D""", """DownBlock2D""")							,							up_block_types=("""UpBlock2D""", """CrossAttnUpBlock2D""")							,							block_out_channels=(32, 64)							,							attention_head_dim=(2, 4)							,							class_embed_type="""projection"""							,							projection_class_embeddings_input_dim=embedder_projection_dim * 2							,							cross_attention_dim=_lowerCamelCase							,							layers_per_block=1							,							upcast_attention=_lowerCamelCase							,							use_linear_projection=_lowerCamelCase							,							)

        torch.manual_seed(0)
        UpperCAmelCase__					:   List[Any]       				=       DDIMScheduler(
            beta_schedule="""scaled_linear"""							,							beta_start=0.00085							,							beta_end=0.012							,							prediction_type="""v_prediction"""							,							set_alpha_to_one=_lowerCamelCase							,							steps_offset=1							,							)

        torch.manual_seed(0)
        UpperCAmelCase__					:   str       				=       AutoencoderKL()

        UpperCAmelCase__					:   List[str]       				=       {
            # prior components
            """prior_tokenizer""": prior_tokenizer,
            """prior_text_encoder""": prior_text_encoder,
            """prior""": prior,
            """prior_scheduler""": prior_scheduler,
            # image noising components
            """image_normalizer""": image_normalizer,
            """image_noising_scheduler""": image_noising_scheduler,
            # regular denoising components
            """tokenizer""": tokenizer,
            """text_encoder""": text_encoder,
            """unet""": unet,
            """scheduler""": scheduler,
            """vae""": vae,
        }

        return components




     def 			snake_case__  ( self							,							_lowerCamelCase							,							_lowerCamelCase=0):
        if str(_lowerCamelCase).startswith("""mps"""):
           UpperCAmelCase__					:   Tuple       				=       torch.manual_seed(_lowerCamelCase)
        else:
           UpperCAmelCase__					:   str       				=       torch.Generator(device=_lowerCamelCase).manual_seed(_lowerCamelCase)
        UpperCAmelCase__					:   Optional[int]       				=       {
            """prompt""": """A painting of a squirrel eating a burger""",
            """generator""": generator,
            """num_inference_steps""": 2,
            """prior_num_inference_steps""": 2,
            """output_type""": """numpy""",
        }
        return inputs




     def 			snake_case__  ( self):
        UpperCAmelCase__					:   Dict       				=       torch_device == """cpu"""

        self._test_attention_slicing_forward_pass(test_max_difference=_lowerCamelCase)




     def 			snake_case__  ( self):
        UpperCAmelCase__					:   List[Any]       				=       torch_device in ["""cpu""", """mps"""]

        self._test_inference_batch_single_identical(test_max_difference=_lowerCamelCase)


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




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




     def 			snake_case__  ( self):
        UpperCAmelCase__					:   List[Any]       				=       load_numpy(
            """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy""")

        UpperCAmelCase__					:   Union[str, Any]       				=       StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""							,							torch_dtype=torch.floataa)
        pipe.to(_lowerCamelCase)
        pipe.set_progress_bar_config(disable=_lowerCamelCase)
        # stable unclip will oom when integration tests are run on a V100,
        # so turn on memory savings
        pipe.enable_attention_slicing()
        pipe.enable_sequential_cpu_offload()

        UpperCAmelCase__					:   Optional[int]       				=       torch.Generator(device="""cpu""").manual_seed(0)
        UpperCAmelCase__					:   Union[str, Any]       				=       pipe("""anime turle"""							,							generator=_lowerCamelCase							,							output_type="""np""")

        UpperCAmelCase__					:   List[str]       				=       output.images[0]

        assert image.shape == (768, 768, 3)

        assert_mean_pixel_difference(_lowerCamelCase							,							_lowerCamelCase)




     def 			snake_case__  ( self):
        torch.cuda.empty_cache()
        torch.cuda.reset_max_memory_allocated()
        torch.cuda.reset_peak_memory_stats()

        UpperCAmelCase__					:   List[str]       				=       StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""							,							torch_dtype=torch.floataa)
        UpperCAmelCase__					:   Optional[int]       				=       pipe.to(_lowerCamelCase)
        pipe.set_progress_bar_config(disable=_lowerCamelCase)
        pipe.enable_attention_slicing()
        pipe.enable_sequential_cpu_offload()

        UpperCAmelCase__					:   List[str]       				=       pipe(
            """anime turtle"""							,							prior_num_inference_steps=2							,							num_inference_steps=2							,							output_type="""np"""							,							)

        UpperCAmelCase__					:   Optional[Any]       				=       torch.cuda.max_memory_allocated()
        # make sure that less than 7 GB is allocated
        assert mem_bytes < 7 * 10**9



'''simple docstring'''



import numpy


class 						_snake_case   :




					def __init__( self							,							_lowerCamelCase							,							_lowerCamelCase):
								UpperCAmelCase__					:   Dict       				=       input_array

								# Random initial weights are assigned where first argument is the
								# number of nodes in previous layer and second argument is the
								# number of nodes in the next layer.

								# Random initial weights are assigned.
								# self.input_array.shape[1] is used to represent number of nodes in input layer.
								# First hidden layer consists of 4 nodes.
								UpperCAmelCase__					:   Optional[Any]       				=       numpy.random.rand(
								    self.input_array.shape[1]							,							4)

								# Random initial values for the first hidden layer.
								# First hidden layer has 4 nodes.
								# Second hidden layer has 3 nodes.
								UpperCAmelCase__					:   Optional[int]       				=       numpy.random.rand(
								    4							,							3)

								# Random initial values for the second hidden layer.
								# Second hidden layer has 3 nodes.
								# Output layer has 1 node.
								UpperCAmelCase__					:   Any       				=       numpy.random.rand(3							,							1)

								# Real output values provided.
								UpperCAmelCase__					:   Tuple       				=       output_array

								# Predicted output values by the neural network.
								# Predicted_output array initially consists of zeroes.
								UpperCAmelCase__					:   Union[str, Any]       				=       numpy.zeros(output_array.shape)




					def 			snake_case__  ( self):
								UpperCAmelCase__					:   List[str]       				=       sigmoid(
								    numpy.dot(self.input_array							,							self.input_layer_and_first_hidden_layer_weights))

								# layer_between_first_hidden_layer_and_second_hidden_layer is the layer
								# connecting the first hidden set of nodes with the second hidden set of nodes.
								UpperCAmelCase__					:   Any       				=       sigmoid(
								    numpy.dot(
								        self.layer_between_input_and_first_hidden_layer							,							self.first_hidden_layer_and_second_hidden_layer_weights							,							))

								# layer_between_second_hidden_layer_and_output is the layer connecting
								# second hidden layer with the output node.
								UpperCAmelCase__					:   Tuple       				=       sigmoid(
								    numpy.dot(
								        self.layer_between_first_hidden_layer_and_second_hidden_layer							,							self.second_hidden_layer_and_output_layer_weights							,							))

								return self.layer_between_second_hidden_layer_and_output




					def 			snake_case__  ( self):
								UpperCAmelCase__					:   Optional[int]       				=       numpy.dot(
								    self.layer_between_first_hidden_layer_and_second_hidden_layer.T							,							2
								    * (self.output_array - self.predicted_output)
								    * sigmoid_derivative(self.predicted_output)							,							)
								UpperCAmelCase__					:   str       				=       numpy.dot(
								    self.layer_between_input_and_first_hidden_layer.T							,							numpy.dot(
								        2
								        * (self.output_array - self.predicted_output)
								        * sigmoid_derivative(self.predicted_output)							,							self.second_hidden_layer_and_output_layer_weights.T							,							)
								    * sigmoid_derivative(
								        self.layer_between_first_hidden_layer_and_second_hidden_layer)							,							)
								UpperCAmelCase__					:   Any       				=       numpy.dot(
								    self.input_array.T							,							numpy.dot(
								        numpy.dot(
								            2
								            * (self.output_array - self.predicted_output)
								            * sigmoid_derivative(self.predicted_output)							,							self.second_hidden_layer_and_output_layer_weights.T							,							)
								        * sigmoid_derivative(
								            self.layer_between_first_hidden_layer_and_second_hidden_layer)							,							self.first_hidden_layer_and_second_hidden_layer_weights.T							,							)
								    * sigmoid_derivative(self.layer_between_input_and_first_hidden_layer)							,							)

								self.input_layer_and_first_hidden_layer_weights += (
								    updated_input_layer_and_first_hidden_layer_weights
								)
								self.first_hidden_layer_and_second_hidden_layer_weights += (
								    updated_first_hidden_layer_and_second_hidden_layer_weights
								)
								self.second_hidden_layer_and_output_layer_weights += (
								    updated_second_hidden_layer_and_output_layer_weights
								)




					def 			snake_case__  ( self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
								for iteration in range(1							,							iterations + 1):
											UpperCAmelCase__					:   Optional[Any]       				=       self.feedforward()
											self.back_propagation()
											if give_loss:
														UpperCAmelCase__					:   str       				=       numpy.mean(numpy.square(output - self.feedforward()))
														print(f'''Iteration {iteration} Loss: {loss}''')




					def 			snake_case__  ( self							,							_lowerCamelCase):
								UpperCAmelCase__					:   List[Any]       				=       input_arr

								UpperCAmelCase__					:   Tuple       				=       sigmoid(
								    numpy.dot(self.array							,							self.input_layer_and_first_hidden_layer_weights))

								UpperCAmelCase__					:   List[Any]       				=       sigmoid(
								    numpy.dot(
								        self.layer_between_input_and_first_hidden_layer							,							self.first_hidden_layer_and_second_hidden_layer_weights							,							))

								UpperCAmelCase__					:   Optional[Any]       				=       sigmoid(
								    numpy.dot(
								        self.layer_between_first_hidden_layer_and_second_hidden_layer							,							self.second_hidden_layer_and_output_layer_weights							,							))

								return int(self.layer_between_second_hidden_layer_and_output > 0.6)







def       _UpperCamelCase (						UpperCamelCase__   ):
			return 1 / (1 + numpy.exp(-value   ))







def       _UpperCamelCase (						UpperCamelCase__   ):
			return (value) * (1 - (value))







def       _UpperCamelCase (						):
			UpperCAmelCase__					:   Union[str, Any]       				=       numpy.array(
			    (
			        [0, 0, 0],
			        [0, 0, 1],
			        [0, 1, 0],
			        [0, 1, 1],
			        [1, 0, 0],
			        [1, 0, 1],
			        [1, 1, 0],
			        [1, 1, 1],
			    )	, dtype=numpy.floataa	, )

			# True output values for the given input values.
			UpperCAmelCase__					:   str       				=       numpy.array(([0], [1], [1], [0], [1], [0], [0], [1])	, dtype=numpy.floataa   )

			# Calling neural network class.
			UpperCAmelCase__					:   List[Any]       				=       TwoHiddenLayerNeuralNetwork(
			    input_array=UpperCamelCase__	, output_array=UpperCamelCase__   )

			# Calling training function.
			# Set give_loss to True if you want to see loss in every iteration.
			neural_network.train(output=UpperCamelCase__	, iterations=1_0	, give_loss=UpperCamelCase__   )

			return neural_network.predict(numpy.array(([1, 1, 1])	, dtype=numpy.floataa   )   )


if __name__ == "__main__":
		example()