





"""simple docstring"""




from typing import Optional, Tuple, Union

import flax
import flax.linen as nn
import jax
import jax.numpy as jnp
from flax.core.frozen_dict import FrozenDict

from ..configuration_utils import ConfigMixin, flax_register_to_config
from ..utils import BaseOutput
from .embeddings_flax import FlaxTimestepEmbedding, FlaxTimesteps
from .modeling_flax_utils import FlaxModelMixin
from .unet_ad_blocks_flax import (
    FlaxCrossAttnDownBlockaD,
    FlaxCrossAttnUpBlockaD,
    FlaxDownBlockaD,
    FlaxUNetMidBlockaDCrossAttn,
    FlaxUpBlockaD,
)


@flax.struct.dataclass
class        __UpperCamelCase				(						a__						):
							lowerCamelCase   :					jnp.ndarray


@flax_register_to_config
class        __UpperCamelCase				(						nn.Module		,       a__		,       a__						):
							lowerCamelCase   :					int      					=32
							lowerCamelCase   :					int      					=4
							lowerCamelCase   :					int      					=4
							lowerCamelCase   :					Tuple[str]      					=(
							    "CrossAttnDownBlock2D",
							    "CrossAttnDownBlock2D",
							    "CrossAttnDownBlock2D",
							    "DownBlock2D",
							)
							lowerCamelCase   :					Tuple[str]      					=("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")
							lowerCamelCase   :					Union[bool, Tuple[bool]]      					=False
							lowerCamelCase   :					Tuple[int]      					=(320, 640, 1280, 1280)
							lowerCamelCase   :					int      					=2
							lowerCamelCase   :					Union[int, Tuple[int]]      					=8
							lowerCamelCase   :					Optional[Union[int, Tuple[int]]]      					=None
							lowerCamelCase   :					int      					=1280
							lowerCamelCase   :					float      					=0.0
							lowerCamelCase   :					bool      					=False
							lowerCamelCase   :					jnp.dtype      					=jnp.floataa
							lowerCamelCase   :					bool      					=True
							lowerCamelCase   :					int      					=0
							lowerCamelCase   :					bool      					=False






							def     __a   (   self      ,					lowerCAmelCase__      )	-> FrozenDict:
								# init input tensors
								a      :		int	=				(1, self.in_channels, self.sample_size, self.sample_size)
								a      :		Dict	=				jnp.zeros(lowerCAmelCase__      ,					dtype=jnp.floataa      )
								a      :		Tuple	=				jnp.ones((1,)      ,					dtype=jnp.intaa      )
								a      :		Dict	=				jnp.zeros((1, 1, self.cross_attention_dim)      ,					dtype=jnp.floataa      )

								a,       a      :		str	=				jax.random.split(lowerCAmelCase__      )
								a      :		Dict	=				{"params": params_rng, "dropout": dropout_rng}

								return self.init(lowerCAmelCase__      ,					lowerCAmelCase__      ,					lowerCAmelCase__      ,					lowerCAmelCase__      )["params"]






							def     __a   (   self      )	-> Optional[int]:
								a      :		List[str]	=				self.block_out_channels
								a      :		Dict	=				block_out_channels[0] * 4

								if self.num_attention_heads is not None:
									raise ValueError(
									    "At the moment it is not possible to define the number of attention heads via `num_attention_heads` because of a naming issue as described in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131. Passing `num_attention_heads` will only be supported in diffusers v0.19."      )

								# If `num_attention_heads` is not defined (which is the case for most models)
								# it will default to `attention_head_dim`. This looks weird upon first reading it and it is.
								# The reason for this behavior is to correct for incorrectly named variables that were introduced
								# when this library was created. The incorrect naming was only discovered much later in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131
								# Changing `attention_head_dim` to `num_attention_heads` for 40,000+ configurations is too backwards breaking
								# which is why we correct for the naming here.
								a      :		Tuple	=				self.num_attention_heads or self.attention_head_dim

								# input
								a      :		int	=				nn.Conv(
								    block_out_channels[0]      ,					kernel_size=(3, 3)      ,					strides=(1, 1)      ,					padding=((1, 1), (1, 1))      ,					dtype=self.dtype      ,					)

								# time
								a      :		Union[str, Any]	=				FlaxTimesteps(
								    block_out_channels[0]      ,					flip_sin_to_cos=self.flip_sin_to_cos      ,					freq_shift=self.config.freq_shift      )
								a      :		Union[str, Any]	=				FlaxTimestepEmbedding(lowerCAmelCase__      ,					dtype=self.dtype      )

								a      :		Any	=				self.only_cross_attention
								if isinstance(lowerCAmelCase__      ,					lowerCAmelCase__      ):
									a      :		List[str]	=				(only_cross_attention,) * len(self.down_block_types      )

								if isinstance(lowerCAmelCase__      ,					lowerCAmelCase__      ):
									a      :		List[str]	=				(num_attention_heads,) * len(self.down_block_types      )

								# down
								a      :		Optional[Any]	=				[]
								a      :		str	=				block_out_channels[0]
								for i, down_block_type in enumerate(self.down_block_types      ):
									a      :		Optional[Any]	=				output_channel
									a      :		str	=				block_out_channels[i]
									a      :		int	=				i == len(lowerCAmelCase__      ) - 1

									if down_block_type == "CrossAttnDownBlock2D":
										a      :		Dict	=				FlaxCrossAttnDownBlockaD(
										    in_channels=lowerCAmelCase__      ,					out_channels=lowerCAmelCase__      ,					dropout=self.dropout      ,					num_layers=self.layers_per_block      ,					num_attention_heads=num_attention_heads[i]      ,					add_downsample=not is_final_block      ,					use_linear_projection=self.use_linear_projection      ,					only_cross_attention=only_cross_attention[i]      ,					use_memory_efficient_attention=self.use_memory_efficient_attention      ,					dtype=self.dtype      ,					)
									else:
										a      :		Dict	=				FlaxDownBlockaD(
										    in_channels=lowerCAmelCase__      ,					out_channels=lowerCAmelCase__      ,					dropout=self.dropout      ,					num_layers=self.layers_per_block      ,					add_downsample=not is_final_block      ,					dtype=self.dtype      ,					)

									down_blocks.append(lowerCAmelCase__      )
								a      :		int	=				down_blocks

								# mid
								a      :		Tuple	=				FlaxUNetMidBlockaDCrossAttn(
								    in_channels=block_out_channels[-1]      ,					dropout=self.dropout      ,					num_attention_heads=num_attention_heads[-1]      ,					use_linear_projection=self.use_linear_projection      ,					use_memory_efficient_attention=self.use_memory_efficient_attention      ,					dtype=self.dtype      ,					)

								# up
								a      :		Any	=				[]
								a      :		Optional[int]	=				list(reversed(lowerCAmelCase__      )      )
								a      :		Tuple	=				list(reversed(lowerCAmelCase__      )      )
								a      :		Dict	=				list(reversed(lowerCAmelCase__      )      )
								a      :		List[str]	=				reversed_block_out_channels[0]
								for i, up_block_type in enumerate(self.up_block_types      ):
									a      :		Optional[int]	=				output_channel
									a      :		str	=				reversed_block_out_channels[i]
									a      :		List[Any]	=				reversed_block_out_channels[min(i + 1      ,					len(lowerCAmelCase__      ) - 1      )]

									a      :		Optional[Any]	=				i == len(lowerCAmelCase__      ) - 1

									if up_block_type == "CrossAttnUpBlock2D":
										a      :		str	=				FlaxCrossAttnUpBlockaD(
										    in_channels=lowerCAmelCase__      ,					out_channels=lowerCAmelCase__      ,					prev_output_channel=lowerCAmelCase__      ,					num_layers=self.layers_per_block + 1      ,					num_attention_heads=reversed_num_attention_heads[i]      ,					add_upsample=not is_final_block      ,					dropout=self.dropout      ,					use_linear_projection=self.use_linear_projection      ,					only_cross_attention=only_cross_attention[i]      ,					use_memory_efficient_attention=self.use_memory_efficient_attention      ,					dtype=self.dtype      ,					)
									else:
										a      :		Dict	=				FlaxUpBlockaD(
										    in_channels=lowerCAmelCase__      ,					out_channels=lowerCAmelCase__      ,					prev_output_channel=lowerCAmelCase__      ,					num_layers=self.layers_per_block + 1      ,					add_upsample=not is_final_block      ,					dropout=self.dropout      ,					dtype=self.dtype      ,					)

									up_blocks.append(lowerCAmelCase__      )
									a      :		Union[str, Any]	=				output_channel
								a      :		List[Any]	=				up_blocks

								# out
								a      :		int	=				nn.GroupNorm(num_groups=32      ,					epsilon=1E-5      )
								a      :		Union[str, Any]	=				nn.Conv(
								    self.out_channels      ,					kernel_size=(3, 3)      ,					strides=(1, 1)      ,					padding=((1, 1), (1, 1))      ,					dtype=self.dtype      ,					)






							def __call__(   self      ,					lowerCAmelCase__      ,					lowerCAmelCase__      ,					lowerCAmelCase__      ,					lowerCAmelCase__=None      ,					lowerCAmelCase__=None      ,					lowerCAmelCase__ = True      ,					lowerCAmelCase__ = False      ,					)	-> Union[FlaxUNetaDConditionOutput, Tuple]:
								# 1. time
								if not isinstance(lowerCAmelCase__      ,					jnp.ndarray      ):
									a      :		int	=				jnp.array([timesteps]      ,					dtype=jnp.intaa      )
								elif isinstance(lowerCAmelCase__      ,					jnp.ndarray      ) and len(timesteps.shape      ) == 0:
									a      :		Any	=				timesteps.astype(dtype=jnp.floataa      )
									a      :		int	=				jnp.expand_dims(lowerCAmelCase__      ,					0      )

								a      :		Any	=				self.time_proj(lowerCAmelCase__      )
								a      :		Union[str, Any]	=				self.time_embedding(lowerCAmelCase__      )

								# 2. pre-process
								a      :		Tuple	=				jnp.transpose(lowerCAmelCase__      ,					(0, 2, 3, 1)      )
								a      :		Optional[int]	=				self.conv_in(lowerCAmelCase__      )

								# 3. down
								a      :		Dict	=				(sample,)
								for down_block in self.down_blocks:
									if isinstance(lowerCAmelCase__      ,					lowerCAmelCase__      ):
										a,       a      :		Optional[Any]	=				down_block(lowerCAmelCase__      ,					lowerCAmelCase__      ,					lowerCAmelCase__      ,					deterministic=not train      )
									else:
										a,       a      :		Optional[int]	=				down_block(lowerCAmelCase__      ,					lowerCAmelCase__      ,					deterministic=not train      )
									down_block_res_samples += res_samples

								if down_block_additional_residuals is not None:
									a      :		Optional[Any]	=				()

									for down_block_res_sample, down_block_additional_residual in zip(
									    lowerCAmelCase__      ,					lowerCAmelCase__      ):
										down_block_res_sample += down_block_additional_residual
										new_down_block_res_samples += (down_block_res_sample,)

									a      :		List[str]	=				new_down_block_res_samples

								# 4. mid
								a      :		Optional[Any]	=				self.mid_block(lowerCAmelCase__      ,					lowerCAmelCase__      ,					lowerCAmelCase__      ,					deterministic=not train      )

								if mid_block_additional_residual is not None:
									sample += mid_block_additional_residual

								# 5. up
								for up_block in self.up_blocks:
									a      :		Union[str, Any]	=				down_block_res_samples[-(self.layers_per_block + 1) :]
									a      :		Any	=				down_block_res_samples[: -(self.layers_per_block + 1)]
									if isinstance(lowerCAmelCase__      ,					lowerCAmelCase__      ):
										a      :		Optional[int]	=				up_block(
										    lowerCAmelCase__      ,					temb=lowerCAmelCase__      ,					encoder_hidden_states=lowerCAmelCase__      ,					res_hidden_states_tuple=lowerCAmelCase__      ,					deterministic=not train      ,					)
									else:
										a      :		Optional[Any]	=				up_block(lowerCAmelCase__      ,					temb=lowerCAmelCase__      ,					res_hidden_states_tuple=lowerCAmelCase__      ,					deterministic=not train      )

        # 6. post-process
								a      :		List[Any]	=				self.conv_norm_out(lowerCAmelCase__      )
								a      :		str	=				nn.silu(lowerCAmelCase__      )
								a      :		List[Any]	=				self.conv_out(lowerCAmelCase__      )
								a      :		List[Any]	=				jnp.transpose(lowerCAmelCase__      ,					(0, 3, 1, 2)      )

								if not return_dict:
									return (sample,)

								return FlaxUNetaDConditionOutput(sample=lowerCAmelCase__      )








import numpy
class 		UpperCAmelCase   :







						'''simple docstring'''





						def __init__(						self							:     Union[str, Any]       ,	__lowercase							:     numpy.ndarray       ,	__lowercase							:     numpy.ndarray						):






							"""simple docstring"""






							snake_case_		    =     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.
							snake_case_		    =     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.
							snake_case_		    =     numpy.random.rand(
							    4       ,	3						)

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

							# Real output values provided.
							snake_case_		    =     output_array

							# Predicted output values by the neural network.
							# Predicted_output array initially consists of zeroes.
							snake_case_		    =     numpy.zeros(output_array.shape						)






						def        snake_case__						(						self							:     Optional[Any]						):






							"""simple docstring"""






							snake_case_		    =     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.
							snake_case_		    =     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.
							snake_case_		    =     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							:     Any						):






							"""simple docstring"""






							snake_case_		    =     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						)       ,	)
							snake_case_		    =     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						)       ,	)
							snake_case_		    =     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							:     Optional[Any]       ,	__lowercase							:     numpy.ndarray       ,	__lowercase							:     int       ,	__lowercase							:     bool						):






							"""simple docstring"""






							for iteration in range(1       ,	iterations + 1						):
								snake_case_		    =     self.feedforward()
								self.back_propagation()
								if give_loss:
									snake_case_		    =     numpy.mean(numpy.square(output - self.feedforward()						)						)
									print(f"Iteration {iteration} Loss: {loss}"						)






						def        snake_case__						(						self							:     Union[str, Any]       ,	__lowercase							:     numpy.ndarray						):






							"""simple docstring"""






							snake_case_		    =     input_arr

							snake_case_		    =     sigmoid(
							    numpy.dot(self.array       ,	self.input_layer_and_first_hidden_layer_weights						)						)

							snake_case_		    =     sigmoid(
							    numpy.dot(
							        self.layer_between_input_and_first_hidden_layer       ,	self.first_hidden_layer_and_second_hidden_layer_weights       ,	)						)

							snake_case_		    =     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 						lowerCamelCase__    (		_A							):







	'''simple docstring'''





	return 1 / (1 + numpy.exp(-value							))


def 						lowerCamelCase__    (		_A							):







	'''simple docstring'''





	return (value) * (1 - (value))


def 						lowerCamelCase__    (		):







	'''simple docstring'''





	snake_case_		    =     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.
	snake_case_		    =     numpy.array(([0], [1], [1], [0], [1], [0], [0], [1])     ,	dtype=numpy.floataa							)

	# Calling neural network class.
	snake_case_		    =     TwoHiddenLayerNeuralNetwork(
	    input_array=_A     ,	output_array=_A							)

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

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


if __name__ == "__main__":
		example()
